AmrObject.h

Go to the documentation of this file.

#ifndef AMR_OBECT_H
#define AMR_OBECT_H

#include "Index/NDIndex.h"

#include "Algorithms/PBunchDefs.h"
#include "Utilities/Util.h"

// #include "Algorithms/AmrPartBunch.h"

// class AmrPartBunch;

class AmrObject {
    
public:
    // FIXME Why not using typedef of PartBunchBase
    typedef std::pair<Vector_t, Vector_t> VectorPair_t;
//     using VectorPair_t = typename AmrPartBunch::VectorPair_t;
    
    enum TaggingCriteria {
        CHARGE_DENSITY = 0, // default
        POTENTIAL,
        EFIELD,
        MOMENTA,
        MIN_NUM_PARTICLES,       
        MAX_NUM_PARTICLES        
    };
    
    
    struct AmrInfo {
        int grid[3];        
        int maxgrid[3];     
        int bf[3];          
        int maxlevel;       
        int refratio[3];    
    };
    
public:
    
    AmrObject();
    
    AmrObject(TaggingCriteria tagging,
              double scaling,
              double chargedensity);
    
    virtual ~AmrObject();
    
    virtual void getGridStatistics(std::map<int, long>& gridPtsPerCore,
                                   std::vector<int>& gridsPerLevel) const = 0;
    
    virtual void initFineLevels() = 0; 
    
    virtual void regrid(double time) = 0;
    
    void setTagging(TaggingCriteria tagging);
    
    void setTagging(std::string tagging);
    
    void setScalingFactor(double scaling);
    
    void setChargeDensity(double chargedensity);
    
    void setMaxNumParticles(size_t maxNumPart);
    
    void setMinNumParticles(size_t minNumPart);
    
    /* Methods that are needed by the
     * bunch
     */
    virtual VectorPair_t getEExtrema() = 0;
    
    virtual double getRho(int x, int y, int z) = 0;
    
    virtual void computeSelfFields() = 0;
    
    virtual void computeSelfFields(int b) = 0;
    
    virtual void computeSelfFields_cycl(double gamma) = 0;
    
    virtual void computeSelfFields_cycl(int b) = 0;
    
    virtual void updateMesh() = 0;
    
    virtual Vektor<int, 3> getBaseLevelGridPoints() const = 0;
    
    virtual const int& maxLevel() const = 0;
    virtual const int& finestLevel() const = 0;
    
    virtual double getT() const = 0;
    
    virtual void redistributeGrids(int how) { }
    
    const bool& isRefined() const;
    
    static std::string enum2string(int number);

protected:

    TaggingCriteria tagging_m;  
    
    double scaling_m;           
                                // (POTENTIAL, EFIELD)
    double chargedensity_m;     
    
    size_t maxNumPart_m;        
    
    size_t minNumPart_m;        
    
    bool refined_m;             
    
    IpplTimings::TimerRef amrSolveTimer_m;
    IpplTimings::TimerRef amrRegridTimer_m;
};

#endif