NamedComponentParticleContainer.H

Go to the documentation of this file.

/* Copyright 2022 Remi Lehe
 *
 * This file is part of WarpX.
 *
 * License: BSD-3-Clause-LBNL
 */
#ifndef NamedComponentParticleContainer_H_
#define NamedComponentParticleContainer_H_
 
#include "Utils/TextMsg.H"
 
#include <AMReX.H>
#include <AMReX_AmrParGDB.H>
#include <AMReX_Particles.H>
 
#include <map>
#include <string>
 
struct PIdx
{
    enum {
        w = 0,      
        ux, uy, uz,
#ifdef WARPX_DIM_RZ
        theta,      
#endif
        nattribs    
    };
};
 
template <template<class> class T_Allocator=amrex::DefaultAllocator>
class NamedComponentParticleContainer :
public amrex::ParticleContainer<0,0,PIdx::nattribs,0,T_Allocator>
{
public:
    NamedComponentParticleContainer () : amrex::ParticleContainer<0,0,PIdx::nattribs,0,T_Allocator>() {}
 
    NamedComponentParticleContainer (amrex::AmrParGDB* amr_pgdb)
    : amrex::ParticleContainer<0,0,PIdx::nattribs,0,T_Allocator>(amr_pgdb) {
        // build up the map of string names to particle component numbers
        particle_comps["w"]  = PIdx::w;
        particle_comps["ux"] = PIdx::ux;
        particle_comps["uy"] = PIdx::uy;
        particle_comps["uz"] = PIdx::uz;
#ifdef WARPX_DIM_RZ
        particle_comps["theta"] = PIdx::theta;
#endif
    }
 
    virtual ~NamedComponentParticleContainer() = default;
 
    NamedComponentParticleContainer(
        amrex::ParticleContainer<0,0,PIdx::nattribs,0,T_Allocator> && pc,
        std::map<std::string, int> p_comps,
        std::map<std::string, int> p_icomps,
        std::map<std::string, int> p_rcomps,
        std::map<std::string, int> p_ricomps)
    : amrex::ParticleContainer<0,0,PIdx::nattribs,0,T_Allocator>(std::move(pc)),
    particle_comps(p_comps),
    particle_icomps(p_icomps),
    particle_runtime_comps(p_rcomps),
    particle_runtime_icomps(p_ricomps) {}
 
    NamedComponentParticleContainer ( NamedComponentParticleContainer && ) = default;
    NamedComponentParticleContainer& operator= ( NamedComponentParticleContainer && ) = default;
 
    template <template<class> class NewAllocator=amrex::DefaultAllocator>
    NamedComponentParticleContainer<NewAllocator>
    make_alike () const {
        auto tmp = NamedComponentParticleContainer<NewAllocator>(
            amrex::ParticleContainer<0,0,PIdx::nattribs,0,T_Allocator>::template make_alike<NewAllocator>(),
            particle_comps,
            particle_icomps,
            particle_runtime_comps,
            particle_runtime_icomps);
 
        return tmp;
    }
 
    using BaseContainer = amrex::ParticleContainer<0,0,PIdx::nattribs,0,T_Allocator>;
 
    using BaseContainer::NumRealComps;
    using BaseContainer::NumIntComps;
    using BaseContainer::AddRealComp;
    using BaseContainer::AddIntComp;
 
    void AddRealComp (const std::string& name, [[maybe_unused]] int communicate=1)
    {
        auto search = particle_comps.find(name);
        if (search == particle_comps.end()) {
            particle_comps[name] = NumRealComps();
            particle_runtime_comps[name] = NumRealComps() - PIdx::nattribs;
            BaseContainer::AddRealComp(communicate);
        } else {
            amrex::Print() << Utils::TextMsg::Info(
                name + " already exists in particle_comps, not adding.");
        }
    }
 
    void AddIntComp (const std::string& name, [[maybe_unused]] int communicate=1)
    {
        auto search = particle_icomps.find(name);
        if (search == particle_icomps.end()) {
            particle_icomps[name] = NumIntComps();
            particle_runtime_icomps[name] = NumIntComps() - 0;
            BaseContainer::AddIntComp(communicate);
        } else {
            amrex::Print() << Utils::TextMsg::Info(
                name + " already exists in particle_icomps, not adding.");
        }
    }
 
    std::map<std::string, int> getParticleComps () const noexcept { return particle_comps;}
    std::map<std::string, int> getParticleiComps () const noexcept { return particle_icomps;}
    std::map<std::string, int> getParticleRuntimeComps () const noexcept { return particle_runtime_comps;}
    std::map<std::string, int> getParticleRuntimeiComps () const noexcept { return particle_runtime_icomps;}
 
protected:
    std::map<std::string, int> particle_comps;
    std::map<std::string, int> particle_icomps;
    std::map<std::string, int> particle_runtime_comps;
    std::map<std::string, int> particle_runtime_icomps;
};
 
#endif