SDInjection Class Reference

Super-droplets initialization structure. More...

#include <ERF_SDInitialization.H>

Inheritance diagram for SDInjection:

Collaboration diagram for SDInjection:

Public Member Functions
virtual	~SDInjection ()=default
void	updateDt (const double a_dt, const bool a_active)
	Update time-dependent quantities for particle injection. More...
void	readInputs (SDInputs &, const std::string &, const amrex::Geometry &, const MatVec &, const MatVec &) override
void	readInputs (SDInputs &a_in, const amrex::Geometry &a_geom, const MatVec &a_species_mat, const MatVec &a_aerosol_mat, const double a_dt)
	Read super-droplet injection parameters from input file. More...
void	printParameters (const MatVec &, const MatVec &) const override
int	numSDPerCell (const amrex::Real) const override
	Number of super-droplets to inject per cell this step. Decided in updateDt() from the accumulated count (0 = inject nothing). More...
amrex::Real	numParticlesPerCell (const amrex::Real) const override
	Number of physical particles to inject per cell this step. Equals num_sd * integer-multiplicity, decided in updateDt(). More...
bool	perBoxInjection () const override
	Per-box high-multiplicity injection (false for initialization and legacy per-cell injection). More...
int	injectBoxCount () const override
	Number of super-droplets to inject in the whole box this step. More...
amrex::Real	injectMultiplicity () const override
	Multiplicity of each super-droplet injected this step. More...
unsigned int	injectSeed () const override
	Reproducible seed for scattering this step's super-droplets. More...
Public Member Functions inherited from SDInitProperties
virtual	~SDInitProperties ()=default
virtual void	setDefaults (const amrex::Geometry &a_geom, const MatVec &a_species_mat, const MatVec &a_aerosol_mat)
	Set default values for initialization parameters. More...
void	getDistribution (amrex::Vector< amrex::Real > &a_mass, int a_np, amrex::Real a_density, SDDistributionType a_init_type, amrex::Real a_mass_min, amrex::Real a_mass_max, amrex::Real a_mass_mean, amrex::Real a_radius_min, amrex::Real a_radius_max, amrex::Real a_radius_mean, amrex::Real a_radius_gstd, std::mt19937 &a_rng) const
	Get a distribution with constant multiplicity. More...
void	getDistribution (amrex::Vector< amrex::Real > &a_mass, amrex::Vector< amrex::Real > &a_mult, amrex::Real a_dV, int a_np, amrex::Real a_density, SDDistributionType a_init_type, amrex::Real a_mass_min, amrex::Real a_mass_max, amrex::Real a_mass_mean, amrex::Real a_radius_min, amrex::Real a_radius_max, amrex::Real a_radius_mean, amrex::Real a_radius_gstd, std::mt19937 &a_rng) const
	Get a distribution with sampled multiplicity. More...
void	getAerosolDistribution (amrex::Vector< amrex::Real > &a_mass, const int a_idx, const int a_np, const amrex::Real a_density, std::mt19937 &a_rng) const
	Compute the aerosol mass distribution. More...
void	getAerosolDistribution (amrex::Vector< amrex::Real > &a_mass, amrex::Vector< amrex::Real > &a_mult, amrex::Real a_dV, int a_idx, int a_np, amrex::Real a_density, std::mt19937 &a_rng) const
	Compute the aerosol mass distribution with sampled multiplicity. More...
void	getSpeciesDistribution (amrex::Vector< amrex::Real > &a_mass, const int a_idx, const int a_np, const amrex::Real a_density, std::mt19937 &a_rng) const
	Compute the species mass distribution with constant multiplicity. More...
void	getSpeciesDistribution (amrex::Vector< amrex::Real > &a_mass, amrex::Vector< amrex::Real > &a_mult, amrex::Real a_dV, int a_idx, int a_np, amrex::Real a_density, std::mt19937 &a_rng) const
	Compute the species mass distribution with sampled multiplicity. More...
SDDistributionParams	getSpeciesDistParams (int a_idx, amrex::Real a_density, amrex::Real a_cell_volume, bool a_sampled_mult) const
	Get GPU-compatible distribution parameters for a species. More...
SDDistributionParams	getAerosolDistParams (int a_idx, amrex::Real a_density, amrex::Real a_cell_volume, bool a_sampled_mult) const
	Get GPU-compatible distribution parameters for an aerosol. More...
SDDistributionParams	makeDistributionParams (SDDistributionType a_init_type, amrex::Real a_mass_min, amrex::Real a_mass_max, amrex::Real a_mass_mean, amrex::Real a_radius_min, amrex::Real a_radius_max, amrex::Real a_radius_mean, amrex::Real a_radius_gstd, amrex::Real a_density, amrex::Real a_cell_volume, bool a_sampled_mult) const
	Create GPU-compatible distribution parameters structure. More...
bool	sampledMultiplicity () const
	Determine whether multiplicity is sampled or constant. More...
amrex::Real	volume () const
	Calculate the volume of the particle domain. More...

Public Attributes
amrex::Real	m_inj_rate = 0
amrex::Real	m_sd_inj_rate = 0
amrex::Real	m_numdens_sd = -1
amrex::Vector< amrex::Real >	m_domain_vel = {zero,zero,zero}
amrex::Real	m_tstart = zero
amrex::Real	m_tstop = amrex::Real(1.0e17)
amrex::Real	m_numdens_accum = zero
amrex::Real	m_cell_volume = -1
int	m_inject_num_sd = 0
amrex::Real	m_inject_mult = zero
amrex::Real	m_frac_tol = amrex::Real(1.0e-3)
amrex::Real	m_min_multiplicity = 100
bool	m_perbox = false
bool	m_both_specified = false
bool	m_ppc_specified = false
bool	m_sd_specified = false
bool	m_mm_specified = false
amrex::Real	m_eff_sd_rate = -1
amrex::Real	m_box_volume = -1
amrex::Real	m_sd_accum = zero
unsigned int	m_inject_count = 0
unsigned int	m_inject_seed = 0
std::string	m_prefix
Public Attributes inherited from SDInitProperties
int	m_ppc = 1
bool	m_ppc_from_inputs = false
SDInitShape	m_type = SDInitShape::uniform
amrex::Real	m_numdens = -1
amrex::Real	m_max_multiplicity = 1000000
amrex::Real	m_ice_app_density = -1
std::vector< amrex::Real >	m_mass_species_min
std::vector< amrex::Real >	m_mass_species_max
std::vector< amrex::Real >	m_mass_species_mean
std::vector< amrex::Real >	m_radius_species_min
std::vector< amrex::Real >	m_radius_species_max
std::vector< amrex::Real >	m_radius_species_mean
std::vector< amrex::Real >	m_radius_species_geom_std
std::vector< SDDistributionType >	m_species_init_type
std::vector< amrex::Real >	m_mass_aerosol_min
std::vector< amrex::Real >	m_mass_aerosol_max
std::vector< amrex::Real >	m_mass_aerosol_mean
std::vector< amrex::Real >	m_radius_aerosol_min
std::vector< amrex::Real >	m_radius_aerosol_max
std::vector< amrex::Real >	m_radius_aerosol_mean
std::vector< amrex::Real >	m_radius_aerosol_geom_std
std::vector< SDDistributionType >	m_aerosol_init_type
int	m_num_species = 0
int	m_num_aerosols = 0
amrex::RealBox	m_particle_domain
amrex::Vector< amrex::Real >	m_init_particle_p1
amrex::Vector< amrex::Real >	m_init_particle_p2
SDMultiplicityType	m_mult_type

Additional Inherited Members
Public Types inherited from SDInitProperties
using	MatVec = std::vector< std::unique_ptr< MaterialProperties > >

Detailed Description

Super-droplets initialization structure.

Constructor & Destructor Documentation

~SDInjection()

virtual SDInjection::~SDInjection ( )

virtualdefault

Injection rate (number of physical particles per meter^3 second)

Member Function Documentation

injectBoxCount()

int SDInjection::injectBoxCount ( ) const

inlineoverridevirtual

Number of super-droplets to inject in the whole box this step.

Reimplemented from SDInitProperties.

{ return m_inject_num_sd; }

injectMultiplicity()

amrex::Real SDInjection::injectMultiplicity ( ) const

inlineoverridevirtual

Multiplicity of each super-droplet injected this step.

Reimplemented from SDInitProperties.

{ return m_inject_mult; }

injectSeed()

unsigned int SDInjection::injectSeed ( ) const

inlineoverridevirtual

Reproducible seed for scattering this step's super-droplets.

Reimplemented from SDInitProperties.

{ return m_inject_seed; }

numParticlesPerCell()

amrex::Real SDInjection::numParticlesPerCell ( const amrex::Real  ) const

inlineoverridevirtual

Number of physical particles to inject per cell this step. Equals num_sd * integer-multiplicity, decided in updateDt().

Implements SDInitProperties.

        {
            return amrex::Real(m_inject_num_sd) * m_inject_mult;
        }

numSDPerCell()

int SDInjection::numSDPerCell ( const amrex::Real  ) const

inlineoverridevirtual

Number of super-droplets to inject per cell this step. Decided in updateDt() from the accumulated count (0 = inject nothing).

Implements SDInitProperties.

        {
            return m_inject_num_sd;
        }

perBoxInjection()

bool SDInjection::perBoxInjection ( ) const

inlineoverridevirtual

Per-box high-multiplicity injection (false for initialization and legacy per-cell injection).

Reimplemented from SDInitProperties.

{ return m_perbox; }

printParameters()

void SDInjection::printParameters ( const MatVec &  a_species_mat, const MatVec &  a_aerosol_mat  ) const

overridevirtual

print super-droplets injection parameters to screen

Reimplemented from SDInitProperties.

{
    using namespace amrex;
    Print() << "    Injection rate (# m^{-3} s^{-1}): " << m_inj_rate << "\n"
            << "    Injection domain velocity [m/s]: "
            << m_domain_vel[0] << ","
            << m_domain_vel[1] << ","
            << m_domain_vel[2] << "\n"
            << "    Time (start, stop) [s]: " << m_tstart << ", " << m_tstop << "\n";
    if (m_perbox) {
        if (m_both_specified) {
            Print() << "    Warning: sd_rate and min_multiplicity both specified for "
                    << m_prefix << "\n";
        }
        Print() << "    Injection mode: per-box high-multiplicity\n"
                << "    SD injection rate (specified): " << m_sd_inj_rate << "\n"
                << "    Minimum multiplicity: " << m_min_multiplicity << "\n"
                << "    Effective SD injection rate (# m^{-3} s^{-1}): " << m_eff_sd_rate << "\n"
                << "    Implied multiplicity: "
                << (m_eff_sd_rate > zero ? m_inj_rate / m_eff_sd_rate : zero) << "\n";
    } else {
        Print() << "    Injection mode: per-cell (particles_per_cell)\n"
                << "    SD injection rate: " << m_sd_inj_rate << "\n";
    }
    Print() << "    Fractional-accumulation tolerance: " << m_frac_tol << "\n";
    SDInitProperties::printParameters(a_species_mat, a_aerosol_mat);
}

Here is the call graph for this function:

readInputs() [1/2]

void SDInjection::readInputs ( SDInputs &  , const std::string &  , const amrex::Geometry &  , const MatVec &  , const MatVec &    )

inlineoverridevirtual

read super-droplets injection parameters

Reimplemented from SDInitProperties.

        {
            amrex::Abort("SDInjection::readInputs(): Do not use this interface");
        }

readInputs() [2/2]

void SDInjection::readInputs	(	SDInputs &	a_in,
		const amrex::Geometry &	a_geom,
		const MatVec &	a_species_mat,
		const MatVec &	a_aerosol_mat,
		const double	a_dt
	)

Read super-droplet injection parameters from input file.

This function reads injection-specific parameters like injection rate, timing parameters, and domain velocity.

Parameters

[in]	a_in	Two-tier input resolver
[in]	a_geom	Simulation geometry information
[in]	a_species_mat	Vector of species material properties
[in]	a_aerosol_mat	Vector of aerosol material properties
[in]	a_dt	Current timestep size

{
    BL_PROFILE("SDInjection::readInputs");
 
    SDInitProperties::readInputs( a_in, "", a_geom, a_species_mat, a_aerosol_mat);
 
    amrex::ignore_unused(a_dt);
    using namespace amrex;
 
    m_prefix = a_in.m_block_name;
    a_in.query("rate", m_inj_rate);
    m_sd_specified = a_in.query("sd_rate", m_sd_inj_rate);
    m_mm_specified = a_in.query("min_multiplicity", m_min_multiplicity);
    a_in.query("t_start", m_tstart);
    a_in.query("t_stop", m_tstop);
    a_in.queryarr("domain_velocity", m_domain_vel);
    a_in.query("fractional_tol", m_frac_tol);
 
    // Cell volume of the injection level, used to accumulate the per-cell count.
    const auto dx = a_geom.CellSize();
    m_cell_volume = dx[0]*dx[1]*dx[2];
    m_box_volume  = this->volume();
 
    // Injection mode: an explicit particles_per_cell selects the legacy per-cell
    // path; otherwise inject in per-box high-multiplicity mode. The effective SD
    // injection rate is taken from sd_rate or rate/min_multiplicity; if both are
    // specified, the one giving fewer super-droplets (lower SD rate) is used.
    // SDInitProperties::readInputs already read this key and published whether it
    // came from the input file; reading it again here would find the default that
    // read recorded and report it as user-specified.
    m_ppc_specified = m_ppc_from_inputs;
    m_perbox = !m_ppc_specified;
    if (m_perbox) {
        if (m_sd_specified && m_mm_specified) {
            m_eff_sd_rate    = std::min(m_sd_inj_rate, m_inj_rate / m_min_multiplicity);
            m_both_specified = true;
        } else if (m_sd_specified) {
            m_eff_sd_rate    = m_sd_inj_rate;
            m_both_specified = false;
        } else {
            m_eff_sd_rate    = m_inj_rate / m_min_multiplicity;
            m_both_specified = false;
        }
    }
}

Here is the call graph for this function:

updateDt()

void SDInjection::updateDt ( const double  a_dt, const bool  a_active  )

inline

Update time-dependent quantities for particle injection.

This function updates:

1. The accumulated physical-particle count, and the integer number of super-droplets and their integer multiplicity to inject this step
2. Position of the injection domain based on domain velocity

The number of super-droplets per cell is the specified count (m_ppc, or derived from the SD rate). The physical-particle count accumulates from the injection rate; a step injects only once each of those super-droplets would carry at least unit multiplicity, with integer multiplicity max(round(num_par/num_sd), 1). This lets sub-unity per-step injection rates be honored automatically, with no separate opt-in.

Parameters

[in]	a_dt	Timestep size in seconds
[in]	a_active	True while the injection time window is open

        {
            using amrex::Real;
 
            if (m_perbox) {
                // Per-box high-multiplicity injection: accumulate the box-level
                // super-droplet and physical-particle counts. Inject floor(SD
                // count) super-droplets at the implied multiplicity (= rate /
                // eff_sd_rate) once at least one super-droplet is owed. This
                // decouples the super-droplet count from the grid and bounds the
                // population at physical/multiplicity.
                if (a_active) {
                    m_sd_accum      += m_eff_sd_rate * a_dt * m_box_volume;
                    m_numdens_accum += m_inj_rate    * a_dt * m_box_volume;  // physical count in box
                }
                if (a_active && m_sd_accum >= one - m_frac_tol) {
                    const int N = std::max(static_cast<int>(std::floor(m_sd_accum + m_frac_tol)), 1);
                    m_inject_mult   = std::max(std::round(m_numdens_accum / N), one);
                    m_inject_num_sd = N;
                    m_sd_accum      -= N;
                    m_numdens_accum -= N * m_inject_mult;
                    m_inject_seed   = m_inject_count++;
                } else {
                    m_inject_num_sd = 0;
                    m_inject_mult   = zero;
                }
            } else {
 
            // Specified number of super-droplets per cell (m_ppc) or from the SD rate.
            Real num_sd;
            if (m_sd_inj_rate > 0) {
                num_sd = std::max(Real(std::round(m_sd_inj_rate * a_dt * m_cell_volume)), one);
            } else {
                num_sd = std::max(Real(m_ppc), one);
            }
 
            // Physical particles this step (per cell) and the resulting multiplicity.
            const Real par_step  = m_inj_rate * a_dt * m_cell_volume;
            const Real mult_step = par_step / num_sd;
 
            if (!a_active) {
                m_inject_num_sd = 0;
                m_inject_mult   = zero;
            } else if (mult_step >= one) {
                // Each super-droplet already carries at least unit multiplicity:
                // inject the specified count every step (no accumulation).
                m_inject_num_sd = static_cast<int>(num_sd);
                m_inject_mult   = std::max(std::round(mult_step), one);
                m_numdens_accum = zero;
            } else {
                // Sub-unity per-step multiplicity: accumulate the physical-particle
                // count and inject only once it amounts to >= 1 multiplicity.
                m_numdens_accum += m_inj_rate * a_dt;
                const Real num_par = m_numdens_accum * m_cell_volume;
                const Real mult    = num_par / num_sd;
                if (mult >= one - m_frac_tol) {
                    m_inject_mult   = std::max(std::round(mult), one);   // integer multiplicity
                    m_inject_num_sd = static_cast<int>(num_sd);
                    m_numdens_accum -= (num_sd * m_inject_mult) / m_cell_volume;  // carry remainder
                } else {
                    m_inject_num_sd = 0;
                    m_inject_mult   = zero;
                }
            }
 
            }
 
            if (this->m_type == SDInitShape::uniform) {
                amrex::Vector<amrex::Real> lo = {zero, zero, zero};
                amrex::Vector<amrex::Real> hi = {zero, zero, zero};
                for (int dir = 0; dir < AMREX_SPACEDIM; dir++) {
                    lo[dir] = this->m_particle_domain.lo(dir) + m_domain_vel[dir] * a_dt;
                    hi[dir] = this->m_particle_domain.hi(dir) + m_domain_vel[dir] * a_dt;
                }
                this->m_particle_domain.setLo(lo);
                this->m_particle_domain.setHi(hi);
            } else if (m_type == SDInitShape::bubble) {
                amrex::Vector<amrex::Real> center = {zero, zero, zero};
                for (int dir = 0; dir < AMREX_SPACEDIM; dir++) {
                    center[dir] = this->m_particle_domain.lo(dir) + m_domain_vel[dir] * a_dt;
                }
                this->m_particle_domain.setLo(center);
            }
        }

Member Data Documentation

m_both_specified

bool SDInjection::m_both_specified = false

Whether each knob was specified in any readInputs call (the resolver reports this exactly, in a single pass).

m_box_volume

amrex::Real SDInjection::m_box_volume = -1

Accumulated super-droplet count owed to the box (per-box mode)

Referenced by updateDt().

m_cell_volume

amrex::Real SDInjection::m_cell_volume = -1

Number of super-droplets to inject this step (0 = none). Per cell in legacy mode; per box in per-box high-multiplicity mode.

Referenced by updateDt().

m_domain_vel

amrex::Vector<amrex::Real> SDInjection::m_domain_vel = {zero,zero,zero}

Start time for injection

Referenced by updateDt().

m_eff_sd_rate

amrex::Real SDInjection::m_eff_sd_rate = -1

Injection-box volume [m^3], set from the box at read time

Referenced by updateDt().

m_frac_tol

amrex::Real SDInjection::m_frac_tol = amrex::Real(1.0e-3)

Minimum multiplicity for per-box injection (default 100)

Referenced by updateDt().

m_inj_rate

amrex::Real SDInjection::m_inj_rate = 0

Injection rate (number of SDs per meter^3 second)

Referenced by updateDt().

m_inject_count

unsigned int SDInjection::m_inject_count = 0

Reproducible seed for scattering this step's super-droplets

Referenced by updateDt().

m_inject_mult

amrex::Real SDInjection::m_inject_mult = zero

Tolerance below 1 at which an accumulated injection fires

Referenced by injectMultiplicity(), numParticlesPerCell(), and updateDt().

m_inject_num_sd

int SDInjection::m_inject_num_sd = 0

Integer multiplicity of each super-droplet injected this step

Referenced by injectBoxCount(), numParticlesPerCell(), numSDPerCell(), and updateDt().

m_inject_seed

unsigned int SDInjection::m_inject_seed = 0

Input prefix (e.g. injection.0) for diagnostic messages

Referenced by injectSeed(), and updateDt().

m_min_multiplicity

amrex::Real SDInjection::m_min_multiplicity = 100

Per-box high-multiplicity injection mode (set when particles_per_cell is not specified)

m_mm_specified

bool SDInjection::m_mm_specified = false

Effective SD injection rate [# m^-3 s^-1] used in per-box mode

m_numdens_accum

amrex::Real SDInjection::m_numdens_accum = zero

Injection-level cell volume [m^3], set from geometry at read time

Referenced by updateDt().

m_numdens_sd

amrex::Real SDInjection::m_numdens_sd = -1

Injection domain velocity

m_perbox

bool SDInjection::m_perbox = false

True when both sd_rate and min_multiplicity are explicitly specified

Referenced by perBoxInjection(), and updateDt().

m_ppc_specified

bool SDInjection::m_ppc_specified = false

m_prefix

std::string SDInjection::m_prefix

m_sd_accum

amrex::Real SDInjection::m_sd_accum = zero

Count of injection events so far, used as a reproducible scatter seed

Referenced by updateDt().

m_sd_inj_rate

amrex::Real SDInjection::m_sd_inj_rate = 0

Initial number density of super-droplets

Referenced by updateDt().

m_sd_specified

bool SDInjection::m_sd_specified = false

m_tstart

amrex::Real SDInjection::m_tstart = zero

Stop time for injection

m_tstop

amrex::Real SDInjection::m_tstop = amrex::Real(1.0e17)

Accumulated physical-particle number density [m^-3]. When the per-cell injection rate is sub-unity, the fractional part is carried here until it amounts to at least one super-droplet of unit multiplicity.

---

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

• Source/Particles/ERF_SDInitialization.H
• Source/Particles/ERF_SDInitialization.cpp