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 class TaggingCriteria: unsigned int {
        CHARGE_DENSITY = 0,
        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 getTaggingString(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