AmrObject.h

Go to the documentation of this file.

//
// Class AmrObject
//   The AMR interface to OPAL. A new AMR library needs
//   to inherit from this class in order to work properly
//   with OPAL. Among other things it specifies the refinement
//   strategies.
//
// Copyright (c) 2016 - 2020, Matthias Frey, Paul Scherrer Institut, Villigen PSI, Switzerland
// All rights reserved
//
// Implemented as part of the PhD thesis
// "Precise Simulations of Multibunches in High Intensity Cyclotrons"
//
// This file is part of OPAL.
//
// OPAL is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// You should have received a copy of the GNU General Public License
// along with OPAL. If not, see <https://www.gnu.org/licenses/>.
//
#ifndef AMR_OBECT_H
#define AMR_OBECT_H
 
#include "Index/NDIndex.h"
 
#include "Algorithms/PBunchDefs.h"
 
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(const 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