AMReX_ParticleContainerBase.H

Go to the documentation of this file.

#ifndef AMREX_PARTICLECONTAINERBASE_H_
#define AMREX_PARTICLECONTAINERBASE_H_
#include <AMReX_Config.H>
 
#include <AMReX_Extension.H>
#include <AMReX_INT.H>
#include <AMReX_IntVect.H>
#include <AMReX_ParGDB.H>
#include <AMReX_Geometry.H>
#include <AMReX_DistributionMapping.H>
#include <AMReX_BoxArray.H>
#include <AMReX_Vector.H>
#include <AMReX_ParticleUtil.H>
#include <AMReX_MultiFab.H>
#include <AMReX_iMultiFab.H>
#include <AMReX_ParticleLocator.H>
#include <AMReX_DenseBins.H>
 
#include <string>
 
namespace amrex {
 
#if defined(AMREX_USE_MPI)
struct ParticleHandshakeWindow
{
    ParticleHandshakeWindow () = default;
 
    ParticleHandshakeWindow (const ParticleHandshakeWindow&) = delete;
    ParticleHandshakeWindow& operator= (const ParticleHandshakeWindow&) = delete;
    ParticleHandshakeWindow (ParticleHandshakeWindow&&) = delete;
    ParticleHandshakeWindow& operator= (ParticleHandshakeWindow&&) = delete;
 
    ~ParticleHandshakeWindow ();
 
    MPI_Win win = MPI_WIN_NULL;
    Long* ptr = nullptr;
    int nprocs = 0;
    MPI_Comm comm = MPI_COMM_NULL;
};
#endif
 
class ParticleContainerBase
{
public:
 
    ParticleContainerBase () = default;
 
    ParticleContainerBase (ParGDBBase* gdb)
        :
        m_gdb(gdb)
    {}
 
    ParticleContainerBase (const Geometry            & geom,
                           const DistributionMapping & dmap,
                           const BoxArray            & ba)
        :
        m_gdb_object(std::make_unique<ParGDB>(geom,dmap,ba)),
        m_gdb(static_cast<ParGDBBase*>(m_gdb_object.get()))
    {
    }
 
    ParticleContainerBase (const Vector<Geometry>            & geom,
                           const Vector<DistributionMapping> & dmap,
                           const Vector<BoxArray>            & ba,
                           const Vector<int>                 & rr)
        :
        m_gdb_object(std::make_unique<ParGDB>(geom,dmap,ba,rr)),
        m_gdb(static_cast<ParGDBBase*>(m_gdb_object.get()))
    {
    }
 
    ParticleContainerBase (const Vector<Geometry>            & geom,
                           const Vector<DistributionMapping> & dmap,
                           const Vector<BoxArray>            & ba,
                           const Vector<IntVect>             & rr)
        :
        m_gdb_object(std::make_unique<ParGDB>(geom,dmap,ba,rr)),
        m_gdb(static_cast<ParGDBBase*>(m_gdb_object.get()))
    {
    }
 
    virtual ~ParticleContainerBase () = default;
 
    ParticleContainerBase ( const ParticleContainerBase &) = delete;
    ParticleContainerBase& operator= ( const ParticleContainerBase & ) = delete;
 
    ParticleContainerBase ( ParticleContainerBase && ) noexcept = default;
    ParticleContainerBase& operator= ( ParticleContainerBase && ) noexcept = default;
 
    void Define (ParGDBBase* gdb) { m_gdb = gdb;}
 
    void Define (const Geometry            & geom,
                 const DistributionMapping & dmap,
                 const BoxArray            & ba);
 
    void Define (const Vector<Geometry>            & geom,
                 const Vector<DistributionMapping> & dmap,
                 const Vector<BoxArray>            & ba,
                 const Vector<int>                 & rr);
 
    void Define (const Vector<Geometry>            & geom,
                 const Vector<DistributionMapping> & dmap,
                 const Vector<BoxArray>            & ba,
                 const Vector<IntVect>             & rr);
 
    bool isDefined () const { return m_gdb != nullptr; }
 
    virtual void reserveData ();
    virtual void resizeData ();
    void RedefineDummyMF (int lev);
 
    MFIter MakeMFIter (int lev, const MFItInfo& info) const {
        AMREX_ASSERT(m_dummy_mf[lev] != nullptr);
        return MFIter(*m_dummy_mf[lev], info);
    }
 
    MFIter MakeMFIter (int lev) const {
        AMREX_ASSERT(m_dummy_mf[lev] != nullptr);
        return MFIter(*m_dummy_mf[lev], do_tiling ? tile_size : IntVect::TheZeroVector());
    }
 
    MFIter MakeMFIter (int lev, bool tile) const {
        AMREX_ASSERT(m_dummy_mf[lev] != nullptr);
        return MFIter(*m_dummy_mf[lev], tile ? tile_size : IntVect::TheZeroVector());
    }
 
    void SetParGDB (const Geometry            & geom,
                    const DistributionMapping & dmap,
                    const BoxArray            & ba);
 
    void SetParGDB (const Vector<Geometry>            & geom,
                    const Vector<DistributionMapping> & dmap,
                    const Vector<BoxArray>            & ba,
                    const Vector<IntVect>             & rr);
 
    void SetParGDB (const Vector<Geometry>            & geom,
                    const Vector<DistributionMapping> & dmap,
                    const Vector<BoxArray>            & ba,
                    const Vector<int>                 & rr);
 
    void SetParticleBoxArray (int lev, BoxArray new_ba);
 
    void SetParticleDistributionMap (int lev, DistributionMapping new_dmap);
 
    void SetParticleGeometry (int lev, Geometry new_geom);
 
    const BoxArray& ParticleBoxArray (int lev) const
        { return m_gdb->ParticleBoxArray(lev); }
 
    const DistributionMapping& ParticleDistributionMap (int lev) const
        { return m_gdb->ParticleDistributionMap(lev); }
 
    const Geometry& Geom (int lev) const { return m_gdb->ParticleGeom(lev); }
 
    const Geometry& ParticleGeom (int lev) const { return m_gdb->ParticleGeom(lev); }
 
    int finestLevel () const { return m_gdb->finestLevel(); }
 
    int maxLevel ()    const { return m_gdb->maxLevel(); }
 
    int numLevels()    const { return finestLevel() + 1; }
 
    const ParGDBBase* GetParGDB () const { return m_gdb; }
 
    ParGDBBase* GetParGDB ()       { return m_gdb; }
 
    int Verbose () const { return m_verbose; }
 
    void SetVerbose (int verbose) { m_verbose = verbose; }
 
    [[nodiscard]] int stableRedistribute () const {return m_stable_redistribute; }
 
    void setStableRedistribute (int stable) { m_stable_redistribute = stable; }
 
    const ParticleBufferMap& BufferMap () const {return m_buffer_map;}
 
#if defined(AMREX_USE_MPI)
    void ensureParticleHandshakeWindow () const;
    [[nodiscard]] Long* particleHandshakeBuffer () const
        { return m_particle_handshake_window ? m_particle_handshake_window->ptr : nullptr; }
    [[nodiscard]] MPI_Win particleHandshakeWindow () const
        { return m_particle_handshake_window ? m_particle_handshake_window->win : MPI_WIN_NULL; }
#endif
 
    Vector<int> NeighborProcs(IntVect ngrow) const
    {
        return computeNeighborProcs(this->GetParGDB(), ngrow);
    }
 
    Vector<int> NeighborProcs(int ngrow) const
    {
        return NeighborProcs(IntVect(ngrow));
    }
 
    template <class MF>
    bool OnSameGrids (int level, const MF& mf) const { return m_gdb->OnSameGrids(level, mf); }
 
    [[nodiscard]] Arena* arena () const {
        return m_arena;
    }
 
    void SetArena (Arena* a) {
        m_arena = a;
    }
 
    static const std::string& CheckpointVersion ();
    static const std::string& PlotfileVersion ();
    static const std::string& DataPrefix ();
    static int MaxReaders ();
    static Long MaxParticlesPerRead ();
    static const std::string& AggregationType ();
    static int AggregationBuffer ();
 
    static AMREX_EXPORT bool do_tiling;
    static AMREX_EXPORT IntVect tile_size;
    static AMREX_EXPORT bool memEfficientSort;
    static AMREX_EXPORT bool use_comms_arena;
    mutable AmrParticleLocator<DenseBins<Box> > m_particle_locator;
 
protected:
 
    bool RedistributeMaskLooksCheap (int lev, IntVect nghost) const;
 
    void BuildRedistributeMask (int lev, IntVect nghost) const;
 
    void BuildRedistributeMask (int lev, int nghost=1) const
    {
        BuildRedistributeMask(lev, IntVect(nghost));
    }
    void defineBufferMap () const;
 
    int         m_verbose{0};
    int m_stable_redistribute = 0;
    std::unique_ptr<ParGDB> m_gdb_object = std::make_unique<ParGDB>();
    ParGDBBase* m_gdb{nullptr};
    Vector<std::unique_ptr<MultiFab> > m_dummy_mf;
    Arena* m_arena = nullptr;
 
    mutable std::unique_ptr<iMultiFab> redistribute_mask_ptr;
    mutable IntVect redistribute_mask_nghost = IntVect(std::numeric_limits<int>::min());
    mutable bool redistribute_mask_cost_cached = false;
    mutable bool redistribute_mask_cost = false;
    mutable IntVect redistribute_mask_cost_nghost = IntVect(std::numeric_limits<int>::min());
    mutable BoxArray redistribute_mask_cost_ba;
    mutable DistributionMapping redistribute_mask_cost_dmap;
    mutable amrex::Vector<int> neighbor_procs;
    mutable ParticleBufferMap m_buffer_map;
 
#if defined(AMREX_USE_MPI)
    mutable std::unique_ptr<ParticleHandshakeWindow> m_particle_handshake_window;
#endif
 
};
 
} // namespace amrex
 
#endif // AMREX_PARTICLECONTAINERBASE_H_