spades::particles::EntityParticleContainer Class Reference

Main SPADES entity container. More...

#include <EntityParticleContainer.H>

Inheritance diagram for spades::particles::EntityParticleContainer:

Collaboration diagram for spades::particles::EntityParticleContainer:

Public Member Functions
	EntityParticleContainer (amrex::AmrParGDB *par_gdb, int ngrow=0)
	Constructor.
	EntityParticleContainer (const amrex::Vector< amrex::Geometry > &geom, const amrex::Vector< amrex::DistributionMapping > &dmap, const amrex::Vector< amrex::BoxArray > &ba, int ngrow=0)
	Constructor.
void	initialize_entities ()
	Initialize the entities.
void	sort () override
	Sort the entities.
void	write_plot_file (const std::string &plt_filename) override
	Write the particles to file.
void	read_parameters () override
	Read user parameters.
void	initialize_variable_names () override
	Initialize variable names.
Public Member Functions inherited from spades::particles::SpadesParticleContainer< EntityTypes::NTYPES, 0, 0, EntityRealData::ncomps, EntityIntData::ncomps >
	SpadesParticleContainer (amrex::AmrParGDB *par_gdb, int ngrow=0)
	Constructor.
	SpadesParticleContainer (const amrex::Vector< amrex::Geometry > &geom, const amrex::Vector< amrex::DistributionMapping > &dmap, const amrex::Vector< amrex::BoxArray > &ba, int ngrow=0)
	Constructor.
void	initialize_state ()
	Initialize particle states (counts and offsets)
void	clear_state ()
	Delete particle states (counts and offsets)
void	update_counts ()
	Update the particle counts and offsets.
void	count_particles ()
	Update the particle counts.
void	count_offsets ()
	Update the particle offsets.
const amrex::iMultiFab &	counts () const
	Get the particle counts.
const amrex::iMultiFab &	offsets () const
	Get the particle offsets.
amrex::Long	total_count (const int typ) const
	Get the total number of particles of typ.
amrex::Long	min_count (const int typ) const
	Get the minimum number of particles of typ.
amrex::Long	max_count (const int typ) const
	Get the maximum number of particles of typ.
void	check_sort (const amrex::MFIter &mfi)
	Check the result of the sort operation.
void	sort_impl (const CompareFunctor &compare)
	Sort the particles implementation.
void	sort_impl (const CompareFunc &compare)
void	sort_impl (const CompareFunc &compare)
void	nonencoded_sort_impl (const CompareFunctor &compare)
	Non-encoded sort the particles implementation.
void	nonencoded_sort_impl (const CompareFunc &compare)
void	nonencoded_sort_impl (const CompareFunc &compare)
void	encoded_sort_impl ()
	Encoded sort the particles implementation.
void	print_messages (const std::string &header)
	Print all the particles to screen.
void	reposition_particles ()
	Reposition the particles inside a cell for visualization.
int	ngrow () const
	Number of grow cells.
void	write_plot_file_impl (const std::string &plt_filename, const std::string &name)
	Write the particles to file (implementation)
void	check_sort_type (const std::string &sort_type)
	Check valid sort type.
ParticleArrays< NArrayReal, NArrayInt, ParticleType, RealVector, IntVector >	particle_arrays (ParticleTileType &pti) const

Static Public Member Functions
static std::string	identifier ()
	Class identifier name.
Static Public Member Functions inherited from spades::particles::SpadesParticleContainer< EntityTypes::NTYPES, 0, 0, EntityRealData::ncomps, EntityIntData::ncomps >
static std::string	identifier ()
	Class identifier name.

Private Attributes
int	m_entities_per_lp {1}
	Initial entities per LP.

Additional Inherited Members
Public Types inherited from spades::particles::SpadesParticleContainer< EntityTypes::NTYPES, 0, 0, EntityRealData::ncomps, EntityIntData::ncomps >
using	ParticleType
using	ParticleTileType
using	IntVector
using	RealVector
Static Public Attributes inherited from spades::particles::SpadesParticleContainer< EntityTypes::NTYPES, 0, 0, EntityRealData::ncomps, EntityIntData::ncomps >
static constexpr int	LEV
	Level index.
Protected Attributes inherited from spades::particles::SpadesParticleContainer< EntityTypes::NTYPES, 0, 0, EntityRealData::ncomps, EntityIntData::ncomps >
int	m_ngrow
	Number of grow cells.
amrex::Vector< int >	m_writeflags_real
	Flags for real data to write to file.
amrex::Vector< int >	m_writeflags_int
	Flags for int data to write to file.
amrex::Vector< std::string >	m_real_data_names
	Names for real data to write to file.
amrex::Vector< std::string >	m_int_data_names
	Names for int data to write to file.
std::string	m_sort_type
	Sort type.
amrex::iMultiFab	m_counts
	Count of particles in each cell.
amrex::iMultiFab	m_offsets
	Offsets of particles in each cell.
amrex::MultiFab	m_min_timestamp
	Minimum timestamp in each cell for each type.
amrex::MultiFab	m_max_timestamp
	Maximum timestamp in each cell for each type.

Detailed Description

Main SPADES entity container.

Constructor & Destructor Documentation

EntityParticleContainer() [1/2]

spades::particles::EntityParticleContainer::EntityParticleContainer ( amrex::AmrParGDB * par_gdb, int ngrow = 0 )

explicit

Constructor.

Parameters

par_gdb	[in] particle database
ngrow	[in] number of grow cells

    : SpadesParticleContainer<
          EntityTypes::NTYPES,
          0,
          0,
          EntityRealData::ncomps,
          EntityIntData::ncomps>(par_gdb, ngrow)
{}

EntityParticleContainer() [2/2]

spades::particles::EntityParticleContainer::EntityParticleContainer ( const amrex::Vector< amrex::Geometry > & geom, const amrex::Vector< amrex::DistributionMapping > & dmap, const amrex::Vector< amrex::BoxArray > & ba, int ngrow = 0 )

explicit

Constructor.

Parameters

geom	[in] geometry
dmap	[in] distribution map
ba	[in] box array
ngrow	[in] number of grow cells

    : SpadesParticleContainer<
          EntityTypes::NTYPES,
          0,
          0,
          EntityRealData::ncomps,
          EntityIntData::ncomps>(geom, dmap, ba, ngrow)
{}

Member Function Documentation

identifier()

static std::string spades::particles::EntityParticleContainer::identifier ( )

inlinestatic

Class identifier name.

Returns

class identifier

{ return "entities"; }

Here is the caller graph for this function:

initialize_entities()

void spades::particles::EntityParticleContainer::initialize_entities

(

)

Initialize the entities.

{
    BL_PROFILE("spades::EntityParticleContainer::initialize_entities()");
 
    const auto& plo = Geom(LEV).ProbLoArray();
    const auto& dx = Geom(LEV).CellSizeArray();
    const auto& dom = Geom(LEV).Domain();
    const auto entities_per_lp = m_entities_per_lp;
 
    for (amrex::MFIter mfi = MakeMFIter(LEV); mfi.isValid(); ++mfi) {
        DefineAndReturnParticleTile(LEV, mfi);
    }
 
    amrex::iMultiFab num_particles(
        ParticleBoxArray(LEV), ParticleDistributionMap(LEV), 1, 0,
        amrex::MFInfo());
    amrex::iMultiFab init_offsets(
        ParticleBoxArray(LEV), ParticleDistributionMap(LEV), 1, 0,
        amrex::MFInfo());
    num_particles.setVal(entities_per_lp);
    init_offsets.setVal(0);
 
    for (amrex::MFIter mfi = MakeMFIter(LEV); mfi.isValid(); ++mfi) {
        const amrex::Box& box = mfi.tilebox();
 
        const auto ncells = static_cast<int>(box.numPts());
        const int* in = num_particles[mfi].dataPtr();
        int* out = init_offsets[mfi].dataPtr();
        const auto np = amrex::Scan::PrefixSum<int>(
            ncells, [=] AMREX_GPU_DEVICE(int i) -> int { return in[i]; },
            [=] AMREX_GPU_DEVICE(int i, int const& xi) { out[i] = xi; },
            amrex::Scan::Type::exclusive, amrex::Scan::retSum);
 
        const amrex::Long pid = ParticleType::NextID();
        ParticleType::NextID(pid + np);
        AMREX_ALWAYS_ASSERT_WITH_MESSAGE(
            static_cast<amrex::Long>(pid + np) < amrex::LastParticleID,
            "Error: overflow on particle id numbers!");
 
        const auto my_proc = amrex::ParallelDescriptor::MyProc();
        const auto& offset_arr = init_offsets[mfi].const_array();
        const auto& num_particles_arr = num_particles[mfi].const_array();
        const auto index = std::make_pair(mfi.index(), mfi.LocalTileIndex());
        auto& pti = GetParticles(LEV)[index];
        pti.resize(np);
        const auto parrs = particle_arrays(pti);
 
        amrex::ParallelFor(
            box, [=] AMREX_GPU_DEVICE(
                     int i, int j, int AMREX_D_PICK(, , k)) noexcept {
                const amrex::IntVect iv(AMREX_D_DECL(i, j, k));
                const int start = offset_arr(iv);
                for (int n = start; n < start + num_particles_arr(iv); n++) {
                    auto& p = parrs.m_aos[n];
                    p.id() = pid + n;
                    p.cpu() = my_proc;
 
                    MarkEntityUndefined()(n, parrs);
                    parrs.m_idata[EntityIntData::owner][n] =
                        static_cast<int>(dom.index(iv));
 
                    AMREX_D_TERM(
                        p.pos(0) = plo[0] + (iv[0] + constants::HALF) * dx[0];
                        , p.pos(1) = plo[1] + (iv[1] + constants::HALF) * dx[1];
                        ,
                        p.pos(2) = plo[2] + (iv[2] + constants::HALF) * dx[2];)
 
                    AMREX_D_TERM(parrs.m_idata[CommonIntData::i][n] = iv[0];
                                 , parrs.m_idata[CommonIntData::j][n] = iv[1];
                                 , parrs.m_idata[CommonIntData::k][n] = iv[2];)
                }
 
                for (int n = start; n < start + entities_per_lp; n++) {
                    const amrex::Real ts = 0.0;
 
                    parrs.m_rdata[CommonRealData::timestamp][n] = ts;
                    parrs.m_idata[CommonIntData::type_id][n] =
                        EntityTypes::ENTITY;
                }
            });
 
        // This is necessary
        amrex::Gpu::streamSynchronize();
    }
    Redistribute();
 
    // Sanity check all initial particles
#ifdef AMREX_USE_OMP
#pragma omp parallel if (amrex::Gpu::notInLaunchRegion())
#endif
    for (MyParIter pti(*this, LEV); pti.isValid(); ++pti) {
        const size_t np = pti.numParticles();
        const auto parrs = particle_arrays(pti.GetParticleTile());
 
        amrex::ParallelFor(np, [=] AMREX_GPU_DEVICE(long pidx) noexcept {
            bool valid_type = false;
            for (int typ = 0; typ < EntityTypes::NTYPES; typ++) {
                valid_type = parrs.m_idata[CommonIntData::type_id][pidx] == typ;
                if (valid_type) {
                    break;
                }
            }
            AMREX_ASSERT(valid_type);
            AMREX_ASSERT(parrs.m_aos[pidx].id() >= 0);
        });
    }
}

Here is the call graph for this function:

initialize_variable_names()

void spades::particles::EntityParticleContainer::initialize_variable_names ( )

overridevirtual

Initialize variable names.

Implements spades::particles::SpadesParticleContainer< EntityTypes::NTYPES, 0, 0, EntityRealData::ncomps, EntityIntData::ncomps >.

{
    BL_PROFILE("spades::EntityParticleContainer::initialize_variable_names()");
 
    m_real_data_names.resize(EntityRealData::ncomps, "");
    m_writeflags_real.resize(EntityRealData::ncomps, 0);
    m_int_data_names.resize(EntityIntData::ncomps, "");
    m_writeflags_int.resize(EntityIntData::ncomps, 0);
 
    m_real_data_names[CommonRealData::timestamp] = "timestamp";
    m_writeflags_real[CommonRealData::timestamp] = 1;
 
    AMREX_D_TERM(
        m_int_data_names[CommonIntData::i] = "i";
        m_writeflags_int[CommonIntData::i] = 1;
        , m_int_data_names[CommonIntData::j] = "j";
        m_writeflags_int[CommonIntData::j] = 1;
        , m_int_data_names[CommonIntData::k] = "k";
        m_writeflags_int[CommonIntData::k] = 1;)
    m_int_data_names[CommonIntData::type_id] = "type_id";
    m_writeflags_int[CommonIntData::type_id] = 1;
    m_int_data_names[EntityIntData::owner] = "owner";
    m_writeflags_int[EntityIntData::owner] = 1;
}

read_parameters()

void spades::particles::EntityParticleContainer::read_parameters ( )

overridevirtual

Read user parameters.

Reimplemented from spades::particles::SpadesParticleContainer< EntityTypes::NTYPES, 0, 0, EntityRealData::ncomps, EntityIntData::ncomps >.

{
    SpadesParticleContainer::read_parameters();
    {
        amrex::ParmParse pp("spades");
        pp.query("entities_per_lp", m_entities_per_lp);
    }
}

Here is the call graph for this function:

sort()

void spades::particles::EntityParticleContainer::sort ( )

overridevirtual

Sort the entities.

Implements spades::particles::SpadesParticleContainer< EntityTypes::NTYPES, 0, 0, EntityRealData::ncomps, EntityIntData::ncomps >.

{
    BL_PROFILE("spades::EntityParticleContainer::sort()");
 
    sort_impl(CompareParticle());
}

Here is the call graph for this function:

write_plot_file()

void spades::particles::EntityParticleContainer::write_plot_file ( const std::string & plt_filename )

inlineoverridevirtual

Write the particles to file.

Parameters

plt_filename

[in] file name for the plot file

Implements spades::particles::SpadesParticleContainer< EntityTypes::NTYPES, 0, 0, EntityRealData::ncomps, EntityIntData::ncomps >.

    {
        write_plot_file_impl(plt_filename, identifier());
    };

Here is the call graph for this function:

Member Data Documentation

m_entities_per_lp

int spades::particles::EntityParticleContainer::m_entities_per_lp {1}

private

Initial entities per LP.

{1};

---

The documentation for this class was generated from the following files:

• /home/runner/work/spades/spades/Source/EntityParticleContainer.H
• /home/runner/work/spades/spades/Source/EntityParticleContainer.cpp