BoxLibLayout.h

Go to the documentation of this file.

//
// Class BoxLibLayout
//   In contrast to AMReX, OPAL is optimized for the
//   distribution of particles to cores. In AMReX the ParGDB object
//   is responsible for the particle to core distribution. This
//   layout is derived from this object and does all important
//   bunch updates. It is the interface for AMReX and Ippl.
//
//   In AMReX, the geometry, i.e. physical domain, is fixed
//   during the whole computation. Particles leaving the domain
//   would be deleted. In order to prevent this we map the particles
//   onto the domain [-1, 1]^3. Furthermore, it makes sure
//   that we have enougth grid points to represent the bunch
//   when its charges are scattered on the grid for the self-field
//   computation.
//
//   The self-field computation and the particle-to-core update
//   are performed in the particle mapped domain.
//
// Copyright (c) 2016 - 2020, Matthias Frey, Uldis Locans, 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 BOXLIB_LAYOUT_H
#define BOXLIB_LAYOUT_H
 
#include "AmrParticle/ParticleAmrLayout.h"
#include "AmrParticle/AmrParticleBase.h"
 
#include "Amr/AmrDefs.h"
 
#include <AMReX_ParGDB.H>
 
template<class T, unsigned Dim>
class BoxLibLayout : public ParticleAmrLayout<T, Dim>,
                     public amrex::ParGDB
{
    
public:
    typedef typename ParticleAmrLayout<T, Dim>::pair_t pair_t;
    typedef typename ParticleAmrLayout<T, Dim>::pair_iterator pair_iterator;
    typedef typename ParticleAmrLayout<T, Dim>::SingleParticlePos_t SingleParticlePos_t;
    typedef typename ParticleAmrLayout<T, Dim>::Index_t Index_t;
    
    typedef amr::AmrField_t                AmrField_t;
    typedef amr::AmrVectorField_t          AmrVectorField_t;
    typedef amr::AmrScalarFieldContainer_t AmrScalarFieldContainer_t;
    typedef amr::AmrVectorFieldContainer_t AmrVectorFieldContainer_t;
    typedef typename ParticleAmrLayout<T, Dim>::ParticlePos_t ParticlePos_t;
    typedef ParticleAttrib<Index_t> ParticleIndex_t;
    
    typedef amr::AmrProcMap_t           AmrProcMap_t;
    typedef amr::AmrGrid_t              AmrGrid_t;
    typedef amr::AmrGeometry_t          AmrGeometry_t;
    typedef amr::AmrGeomContainer_t     AmrGeomContainer_t;
    typedef amr::AmrGridContainer_t     AmrGridContainer_t;
    typedef amr::AmrProcMapContainer_t  AmrProcMapContainer_t;
    typedef amr::AmrIntVect_t           AmrIntVect_t;
    typedef amr::AmrIntVectContainer_t  AmrIntVectContainer_t;
    typedef amr::AmrIntArray_t          AmrIntArray_t;
    typedef amr::AmrDomain_t            AmrDomain_t;
    typedef amr::AmrBox_t               AmrBox_t;
    typedef amr::AmrReal_t              AmrReal_t;
    
    typedef amrex::BaseFab<int>         basefab_t;
    typedef amrex::FabArray<basefab_t>  mask_t;
    
    static Vector_t lowerBound;
    
    static Vector_t upperBound;
 
public:
    
    BoxLibLayout();
    
    BoxLibLayout(const BoxLibLayout* layout_p);
 
    BoxLibLayout(int nGridPoints, int maxGridSize);
    
    BoxLibLayout(const AmrGeometry_t &geom,
                 const AmrProcMap_t &dmap,
                 const AmrGrid_t &ba);
    
    BoxLibLayout(const AmrGeomContainer_t &geom,
                 const AmrProcMapContainer_t &dmap,
                 const AmrGridContainer_t &ba,
                 const AmrIntArray_t &rr);
    
    
    /*
     * Overloaded functions of ParticleAmrLayout
     */
    
    void setBoundingBox(double dh);
    
    void setDomainRatio(const std::vector<double>& ratio);
 
 
    /*
     * Functions of IpplParticleBase
     */
    
    void update(IpplParticleBase< BoxLibLayout<T,Dim> >& PData,
                const ParticleAttrib<char>* canSwap = 0);
    
    void update(AmrParticleBase< BoxLibLayout<T,Dim> >& PData,
                int lev_min = 0, int lev_max = -1, bool isRegrid = false);
    
    
    /*
     * Functions from AMReX that are adjusted to work with Ippl AmrParticleBase class
     */
    
    AmrIntVect_t Index (AmrParticleBase< BoxLibLayout<T,Dim> >& p,
                        const unsigned int ip, int level) const;
    
    AmrIntVect_t Index (SingleParticlePos_t &R, int lev) const;
    
    
    /*
     * Additional methods
     */
    
    
    void buildLevelMask(int lev, const int ncells = 1);
 
    void clearLevelMask(int lev);
 
    const std::unique_ptr<mask_t>& getLevelMask(int lev) const;
    
    
    void resize(int maxLevel) {
        int length = maxLevel + 1;
        this->m_geom.resize(length);
        this->m_dmap.resize(length);
        this->m_ba.resize(length);
        this->m_nlevels = length;
        this->refRatio_m.resize(maxLevel);
//         this->m_rr.resize(maxLevel);
        this->maxLevel_m = maxLevel;
    }
    
 
    void define(const AmrGeomContainer_t& geom) {
        for (unsigned int i = 0; i < geom.size(); ++i)
            this->m_geom[i] = geom[i];
    }
    
    
    void define(const AmrIntVectContainer_t& refRatio) {
        for (unsigned int i = 0; i < refRatio.size(); ++i) {
            refRatio_m[i] = refRatio[i];
        }
    }
    
    /*
     * ParGDB overwritten functions
     */
    
    inline bool LevelDefined (int level) const;
    
    inline int finestLevel () const;
    
    inline int maxLevel () const;
    
    inline AmrIntVect_t refRatio (int level) const;
    
    inline int MaxRefRatio (int level) const;
    
private:
    
    void initBaseBox_m(int nGridPoints, int maxGridSize, double dh = 0.04);
    
    
    /*
     * Functions from AMReX that are adjusted to work with Ippl AmrParticleBase class
     */
    
    bool Where (AmrParticleBase< BoxLibLayout<T,Dim> >& p,
                const unsigned int ip, 
                int lev_min = 0, int lev_max = -1, int nGrow = 0) const;
 
    bool EnforcePeriodicWhere (AmrParticleBase< BoxLibLayout<T,Dim> >& prt,
                               const unsigned int ip,
                               int lev_min = 0, int lev_max = -1) const;
 
    bool PeriodicShift (SingleParticlePos_t R) const;
    
    void locateParticle(AmrParticleBase< BoxLibLayout<T,Dim> >& p, 
                        const unsigned int ip,
                        int lev_min, int lev_max, int nGrow) const;
    
private:
    
    // don't use m_rr from ParGDB since it is the same refinement in all directions
    AmrIntVectContainer_t refRatio_m;   
    
    /* mask to reduce spurious self-field forces at
     * coarse-fine interfaces
     */
    std::vector<std::unique_ptr<mask_t> > masks_m;
};
 
#include "BoxLibLayout.hpp"
 
#endif