SDInitProperties Class Reference

Super-droplets initial properties. More...

#include <ERF_SDInitialization.H>

Inheritance diagram for SDInitProperties:

Collaboration diagram for SDInitProperties:

Public Types
using	MatVec = std::vector< std::unique_ptr< MaterialProperties > >

Public Member Functions
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...
virtual void	readInputs (SDInputs &a_in, const std::string &a_key, const amrex::Geometry &a_geom, const MatVec &a_species_mat, const MatVec &a_aerosol_mat)
	Read super-droplets initialization parameters from input file. More...
virtual void	printParameters (const MatVec &a_species_mat, const MatVec &a_aerosol_mat) const
	Print super-droplets initialization parameters to screen. 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...
virtual int	numSDPerCell (const amrex::Real) const =0
virtual amrex::Real	numParticlesPerCell (const amrex::Real) const =0
virtual bool	perBoxInjection () const
	Per-box high-multiplicity injection (false for initialization and legacy per-cell injection). More...
virtual int	injectBoxCount () const
	Number of super-droplets to inject in the whole box this step. More...
virtual amrex::Real	injectMultiplicity () const
	Multiplicity of each super-droplet injected this step. More...
virtual unsigned int	injectSeed () const
	Reproducible seed for scattering this step's super-droplets. More...

Public Attributes
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

Detailed Description

Super-droplets initial properties.

Member Typedef Documentation

MatVec

using SDInitProperties::MatVec = std::vector<std::unique_ptr<MaterialProperties> >

Initial number of super-droplets per cell

Constructor & Destructor Documentation

~SDInitProperties()

virtual SDInitProperties::~SDInitProperties ( )

virtualdefault

Member Function Documentation

getAerosolDistParams()

SDDistributionParams SDInitProperties::getAerosolDistParams ( int  a_idx, amrex::Real  a_density, amrex::Real  a_cell_volume, bool  a_sampled_mult  ) const

inline

Get GPU-compatible distribution parameters for an aerosol.

Parameters

[in]	a_idx	Aerosol species index
[in]	a_density	Density of the aerosol material
[in]	a_cell_volume	Cell volume for multiplicity scaling
[in]	a_sampled_mult	Whether using sampled multiplicity mode

Returns

SDDistributionParams structure for GPU use

        {
            return makeDistributionParams(
                m_aerosol_init_type[a_idx],
                m_mass_aerosol_min[a_idx],
                m_mass_aerosol_max[a_idx],
                m_mass_aerosol_mean[a_idx],
                m_radius_aerosol_min[a_idx],
                m_radius_aerosol_max[a_idx],
                m_radius_aerosol_mean[a_idx],
                m_radius_aerosol_geom_std[a_idx],
                a_density,
                a_cell_volume,
                a_sampled_mult);
        }

Here is the call graph for this function:

getAerosolDistribution() [1/2]

void SDInitProperties::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

inline

Compute the aerosol mass distribution with sampled multiplicity.

Parameters

[out]	a_mass	Output vector of aerosol masses
[out]	a_mult	Output vector of particle multiplicities
[in]	a_dV	Cell volume for scaling multiplicity
[in]	a_idx	Aerosol species index
[in]	a_np	Number of particles to generate
[in]	a_density	Density of the aerosol material
[in,out]	a_rng	Random number generator

        {
            getDistribution( a_mass,
                             a_mult,
                             a_dV,
                             a_np,
                             a_density,
                             m_aerosol_init_type[a_idx],
                             m_mass_aerosol_min[a_idx],
                             m_mass_aerosol_max[a_idx],
                             m_mass_aerosol_mean[a_idx],
                             m_radius_aerosol_min[a_idx],
                             m_radius_aerosol_max[a_idx],
                             m_radius_aerosol_mean[a_idx],
                             m_radius_aerosol_geom_std[a_idx],
                             a_rng);
        }

Here is the call graph for this function:

getAerosolDistribution() [2/2]

void SDInitProperties::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

inline

Compute the aerosol mass distribution.

Parameters

[out]	a_mass	Output vector of aerosol masses
[in]	a_idx	Aerosol species index
[in]	a_np	Number of particles
[in]	a_density	Density of the aerosol material
[in,out]	a_rng	Random number generator

        {
            getDistribution( a_mass,
                             a_np,
                             a_density,
                             m_aerosol_init_type[a_idx],
                             m_mass_aerosol_min[a_idx],
                             m_mass_aerosol_max[a_idx],
                             m_mass_aerosol_mean[a_idx],
                             m_radius_aerosol_min[a_idx],
                             m_radius_aerosol_max[a_idx],
                             m_radius_aerosol_mean[a_idx],
                             m_radius_aerosol_geom_std[a_idx],
                             a_rng);
        }

Here is the call graph for this function:

getDistribution() [1/2]

void SDInitProperties::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.

Parameters

[out]	a_mass	Output vector of particle masses
[out]	a_mult	Output vector of particle multiplicities
[in]	a_dV	Cell volume
[in]	a_np	Number of particles
[in]	a_density	Density of the particle material
[in]	a_init_type	Type of initialization distribution
[in]	a_mass_min	Minimum mass value
[in]	a_mass_max	Maximum mass value
[in]	a_mass_mean	Mean mass value
[in]	a_radius_min	Minimum radius value
[in]	a_radius_max	Maximum radius value
[in]	a_radius_mean	Mean radius value
[in]	a_radius_gstd	Geometric standard deviation for radius
[in,out]	a_rng	Random number generator

{
    a_mass.resize(a_np);
    AMREX_ALWAYS_ASSERT(static_cast<amrex::Long>(a_mult.size()) == a_np);
    if (a_init_type == SDDistributionType::mass_constant) {
        std::uniform_real_distribution<amrex::Real> urd(zero, one);
        for (int n = 0; n < a_np; n++) {
            a_mass[n] = a_mass_mean;
            a_mult[n] += urd(a_rng); // initially this will be a non-integer; later we will rescale to an integer.
        }
    } else if (a_init_type == SDDistributionType::mass_exponential) {
        std::uniform_real_distribution<amrex::Real> urd(zero, one);
        auto delta = a_mass_mean - a_mass_min;
        auto lnrng = std::log(a_mass_max) - std::log(a_mass_min);
        auto lnmin = std::log(a_mass_min);
        for (int n = 0; n < a_np; n++) {
            auto tmp = lnmin + urd(a_rng) * lnrng;
            a_mass[n] = std::exp(tmp);
            a_mult[n] += (m_numdens * a_dV) * (a_mass[n] / delta)
                       * std::exp(-(a_mass[n] - a_mass_min) / delta);
        }
    } else if (a_init_type == SDDistributionType::radius_log_normal) {
        std::uniform_real_distribution<amrex::Real> urd(zero, one);
        auto sigma = std::log(a_radius_gstd);
        auto mu = a_radius_mean;
        auto lnrng = std::log(a_radius_max) - std::log(a_radius_min);
        auto lnmin = std::log(a_radius_min);
        for (int n = 0; n < a_np; n++) {
            auto tmp = lnmin + urd(a_rng) * lnrng;
            auto dry_r = std::exp(tmp);
            a_mass[n] = four_thirds_pi * dry_r * dry_r * dry_r * a_density;
            auto term = std::exp(-std::log(dry_r/mu)*std::log(dry_r/mu)/(two*sigma*sigma));
            a_mult[n] += ( m_numdens * a_dV ) / (sigma*std::sqrt(amrex::Real(2)*PI)) * term;
        }
    } else if (a_init_type == SDDistributionType::radius_lognormal_autorange) {
        std::uniform_real_distribution<amrex::Real> urd(zero, one);
        auto sigma = std::log(a_radius_gstd);
        auto mu = a_radius_mean;
        // automatically find the min and max radius of superdroplets, using Dziekan & Pawlowska 2017
        auto rmin = amrex::Real(1e-9);
        auto rmax = one;
        auto dlnr = (std::log(rmax) - std::log(rmin)) / a_np;
        auto P_min = zero;
        auto P_max = one;
        auto tol = one / (m_numdens * a_dV);
        int a_np_tail = static_cast<int>(std::ceil(amrex::Real(0.01)*a_np)); // this is an approximation for now; saves 1% of SDs for the tail
        amrex::Vector<amrex::Real> tmp_mass(a_np);
        amrex::Vector<amrex::Real> tmp_mult(a_np);
        amrex::Print() << "Finding aerosol radius sampling range\n";
        while ((P_max >= one - tol) || (P_min <= tol)) {
            if (P_max >= one - tol) {
                rmax = rmax * amrex::Real(0.99);
            }
            if (P_min <= tol) {
                rmin = rmin * amrex::Real(1.01);
            }
            P_min = (one + std::erf((std::log(rmin / mu)) / sigma / std::sqrt(amrex::Real(2)))) / amrex::Real(2);
            P_max = (one + std::erf((std::log(rmax / mu)) / sigma / std::sqrt(amrex::Real(2)))) / amrex::Real(2);
        }
        dlnr = (std::log(rmax) - std::log(rmin));
        amrex::Print() << "Range: rmin =" << rmin << ", rmax = " << rmax << ", dlnr = " << dlnr << "\n";
 
        // initialize the main distribution
        amrex::Print() << "Initializing radii\n";
        auto lnrmin = std::log(rmin);
        for (int n = 0; n < a_np; n++) {
            auto tmp = lnrmin + urd(a_rng)*dlnr;
            auto dry_r = std::exp(tmp);
            tmp_mass[n] = four_thirds_pi * dry_r * dry_r * dry_r * a_density;
            auto term = std::exp(-std::log(dry_r/mu)*std::log(dry_r/mu)/(two*sigma*sigma));
            tmp_mult[n] =  (m_numdens * a_dV)/ (sigma*std::sqrt(amrex::Real(2)*PI)) * term;
        }
 
        // initialize the tail using approximate erfinv
        amrex::Print() << "Initializing tail: " << a_np_tail << " particles\n";
        auto tail_mult = std::exp(-std::log(rmax/mu)*std::log(rmax/mu)/(two*sigma*sigma)) / (sigma*std::sqrt(amrex::Real(2)*PI));
        for (int n = 0; n < a_np_tail; n++) {
            int sd_id = amrex::min(static_cast<int>(std::round(urd(a_rng) * a_np)), a_np-1);
            AMREX_ASSERT(sd_id >= 0 && sd_id < a_np);
            auto tmp = P_max + (one - P_max) * urd(a_rng);
            auto tmp2 = SD_erfinv(amrex::Real(2) * tmp - amrex::Real(1));
            auto dry_r = mu * std::exp(sigma * std::sqrt(amrex::Real(2)) * tmp2);
            tmp_mass[sd_id] = four_thirds_pi * dry_r * dry_r * dry_r * a_density;
            // set the multiplicity to the same as for the 99th percentile aerosol
            tmp_mult[sd_id] = (m_numdens * a_dV) * tail_mult;
        }
        // Update SD multiplicity and mass with the initialized main + tail distribution
        for (int n = 0; n < a_np; n++) {
            a_mult[n] += tmp_mult[n];
            a_mass[n] = tmp_mass[n];
        }
        amrex::Print() << "Done sampling\n";
    } else {
        amrex::Abort("Unknown m_init_type!");
    }
}

Here is the call graph for this function:

getDistribution() [2/2]

void SDInitProperties::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.

Parameters

[out]	a_mass	Output vector of particle masses
[in]	a_np	Number of particles
[in]	a_density	Density of the particle material
[in]	a_init_type	Type of initialization distribution
[in]	a_mass_min	Minimum mass value
[in]	a_mass_max	Maximum mass value
[in]	a_mass_mean	Mean mass value
[in]	a_radius_min	Minimum radius value
[in]	a_radius_max	Maximum radius value
[in]	a_radius_mean	Mean radius value
[in]	a_radius_gstd	Geometric standard deviation for radius
[in,out]	a_rng	Random number generator

{
    a_mass.resize(a_np);
    if (a_init_type == SDDistributionType::mass_constant) {
        for (int n = 0; n < a_np; n++) {
            a_mass[n] = a_mass_mean;
        }
    } else if (a_init_type == SDDistributionType::mass_exponential) {
        auto delta = a_mass_mean - a_mass_min;
        std::exponential_distribution<amrex::Real> ed(one/delta);
        for (int n = 0; n < a_np; n++) {
            a_mass[n] = ed(a_rng) + a_mass_min;
        }
    } else if (a_init_type == SDDistributionType::radius_log_normal) {
        std::normal_distribution<amrex::Real> nrd(std::log(a_radius_mean),
                                                  std::log(a_radius_gstd));
        for (int n = 0; n < a_np; n++) {
            auto dry_r = std::exp(nrd(a_rng));
            int count = 0;
            while ((dry_r < a_radius_min) || (dry_r > a_radius_max)) {
                dry_r = std::exp(nrd(a_rng));
                count++;
                if (count > 100) { break; }
            }
            a_mass[n] = four_thirds_pi
                                * dry_r * dry_r * dry_r
                                * a_density;
        }
    } else {
        amrex::Abort("Unknown a_init_type!");
    }
}

Referenced by getAerosolDistribution(), and getSpeciesDistribution().

Here is the caller graph for this function:

getSpeciesDistParams()

SDDistributionParams SDInitProperties::getSpeciesDistParams ( int  a_idx, amrex::Real  a_density, amrex::Real  a_cell_volume, bool  a_sampled_mult  ) const

inline

Get GPU-compatible distribution parameters for a species.

Parameters

[in]	a_idx	Species index
[in]	a_density	Density of the species material
[in]	a_cell_volume	Cell volume for multiplicity scaling
[in]	a_sampled_mult	Whether using sampled multiplicity mode

Returns

SDDistributionParams structure for GPU use

        {
            return makeDistributionParams(
                m_species_init_type[a_idx],
                m_mass_species_min[a_idx],
                m_mass_species_max[a_idx],
                m_mass_species_mean[a_idx],
                m_radius_species_min[a_idx],
                m_radius_species_max[a_idx],
                m_radius_species_mean[a_idx],
                m_radius_species_geom_std[a_idx],
                a_density,
                a_cell_volume,
                a_sampled_mult);
        }

Here is the call graph for this function:

getSpeciesDistribution() [1/2]

void SDInitProperties::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

inline

Compute the species mass distribution with sampled multiplicity.

Parameters

[out]	a_mass	Output vector of species masses
[out]	a_mult	Output vector of particle multiplicities
[in]	a_dV	Cell volume for scaling multiplicity
[in]	a_idx	Species index
[in]	a_np	Number of particles to generate
[in]	a_density	Density of the species material
[in,out]	a_rng	Random number generator

        {
            getDistribution( a_mass,
                             a_mult,
                             a_dV,
                             a_np,
                             a_density,
                             m_species_init_type[a_idx],
                             m_mass_species_min[a_idx],
                             m_mass_species_max[a_idx],
                             m_mass_species_mean[a_idx],
                             m_radius_species_min[a_idx],
                             m_radius_species_max[a_idx],
                             m_radius_species_mean[a_idx],
                             m_radius_species_geom_std[a_idx],
                             a_rng);
        }

Here is the call graph for this function:

getSpeciesDistribution() [2/2]

void SDInitProperties::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

inline

Compute the species mass distribution with constant multiplicity.

Parameters

[out]	a_mass	Output vector of species masses
[in]	a_idx	Species index
[in]	a_np	Number of particles to generate
[in]	a_density	Density of the species material
[in,out]	a_rng	Random number generator

        {
            getDistribution( a_mass,
                             a_np,
                             a_density,
                             m_species_init_type[a_idx],
                             m_mass_species_min[a_idx],
                             m_mass_species_max[a_idx],
                             m_mass_species_mean[a_idx],
                             m_radius_species_min[a_idx],
                             m_radius_species_max[a_idx],
                             m_radius_species_mean[a_idx],
                             m_radius_species_geom_std[a_idx],
                             a_rng);
        }

Here is the call graph for this function:

injectBoxCount()

virtual int SDInitProperties::injectBoxCount ( ) const

inlinevirtual

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

Reimplemented in SDInjection.

{ return 0; }

injectMultiplicity()

virtual amrex::Real SDInitProperties::injectMultiplicity ( ) const

inlinevirtual

Multiplicity of each super-droplet injected this step.

Reimplemented in SDInjection.

{ return zero; }

injectSeed()

virtual unsigned int SDInitProperties::injectSeed ( ) const

inlinevirtual

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

Reimplemented in SDInjection.

{ return 0; }

makeDistributionParams()

SDDistributionParams SDInitProperties::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.

Parameters

[in]	a_init_type	Distribution type
[in]	a_mass_min	Minimum mass
[in]	a_mass_max	Maximum mass
[in]	a_mass_mean	Mean mass
[in]	a_radius_min	Minimum radius
[in]	a_radius_max	Maximum radius
[in]	a_radius_mean	Mean radius
[in]	a_radius_gstd	Geometric standard deviation
[in]	a_density	Material density
[in]	a_cell_volume	Cell volume
[in]	a_sampled_mult	Whether using sampled multiplicity mode

Returns

SDDistributionParams structure

{
    SDDistributionParams params;
    params.dist_type = a_init_type;
    params.mass_min = a_mass_min;
    params.mass_max = a_mass_max;
    params.mass_mean = a_mass_mean;
    params.radius_min = a_radius_min;
    params.radius_max = a_radius_max;
    params.radius_mean = a_radius_mean;
    params.radius_gstd = a_radius_gstd;
    params.density = a_density;
    params.numdens = m_numdens;
    params.cell_volume = a_cell_volume;
    params.delta = a_mass_mean - a_mass_min;
    params.sampled_mult = a_sampled_mult ? 1 : 0;
 
    // Pre-compute values for log-normal distribution
    params.sigma = std::log(a_radius_gstd);
 
    if (params.dist_type == SDDistributionType::mass_exponential) {
        // For exponential with sampled multiplicity, we sample in log-space
        // For constant multiplicity, we use inverse transform sampling
        params.lnmin = std::log(a_mass_min);
        params.lnrng = std::log(a_mass_max) - params.lnmin;
        params.cdf_min = zero;
        params.cdf_max = one;
    } else if (params.dist_type == SDDistributionType::radius_log_normal ||
               params.dist_type == SDDistributionType::radius_lognormal_autorange) {
        // For log-normal, compute CDF bounds for truncated sampling
        // CDF of log-normal: Phi((ln(x) - ln(mu)) / sigma)
        // where Phi is the standard normal CDF: Phi(z) = 0.5 * (1 + erf(z/sqrt(2)))
        amrex::Real rmin = a_radius_min;
        amrex::Real rmax = a_radius_max;
        amrex::Real mu = a_radius_mean;
        amrex::Real sigma = params.sigma;
 
        // For LogNormalAuto, find appropriate bounds iteratively
        if (params.dist_type == SDDistributionType::radius_lognormal_autorange) {
            rmin = amrex::Real(1e-9);
            rmax = one;
            amrex::Real tol = (m_numdens > 0 && a_cell_volume > 0) ?
                              one / (m_numdens * a_cell_volume) : amrex::Real(1e-6);
            amrex::Real P_min = zero;
            amrex::Real P_max = one;
            while ((P_max >= one - tol) || (P_min <= tol)) {
                if (P_max >= one - tol) rmax *= amrex::Real(0.99);
                if (P_min <= tol) rmin *= amrex::Real(1.01);
                P_min = myhalf * (one + std::erf(std::log(rmin / mu) / (sigma * std::sqrt(two))));
                P_max = myhalf * (one + std::erf(std::log(rmax / mu) / (sigma * std::sqrt(two))));
            }
            // Update the params with computed bounds
            params.radius_min = rmin;
            params.radius_max = rmax;
        }
 
        params.cdf_min = myhalf * (one + std::erf(std::log(rmin / mu) / (sigma * std::sqrt(two))));
        params.cdf_max = myhalf * (one + std::erf(std::log(rmax / mu) / (sigma * std::sqrt(two))));
        params.lnmin = std::log(rmin);
        params.lnrng = std::log(rmax) - params.lnmin;
    } else {
        // Constant distribution - no special pre-computation needed
        params.cdf_min = zero;
        params.cdf_max = one;
        params.lnmin = zero;
        params.lnrng = zero;
    }
 
    return params;
}

Referenced by getAerosolDistParams(), and getSpeciesDistParams().

Here is the caller graph for this function:

numParticlesPerCell()

virtual amrex::Real SDInitProperties::numParticlesPerCell ( const amrex::Real  ) const

pure virtual

Implemented in SDInjection, and SDInitialization.

numSDPerCell()

virtual int SDInitProperties::numSDPerCell ( const amrex::Real  ) const

pure virtual

Implemented in SDInjection, and SDInitialization.

perBoxInjection()

virtual bool SDInitProperties::perBoxInjection ( ) const

inlinevirtual

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

Reimplemented in SDInjection.

{ return false; }

printParameters()

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

virtual

Print super-droplets initialization parameters to screen.

Parameters

[in]	a_species_mat	Vector of species material properties
[in]	a_aerosol_mat	Vector of aerosol material properties

Reimplemented in SDInitialization, and SDInjection.

{
    using namespace amrex;
    if (m_type == SDInitShape::uniform) {
        Print() << "    Particle box: " << m_particle_domain << "\n";
    } else if (m_type == SDInitShape::bubble) {
        Print() << "    Particle bubble (radius, center): " << m_particle_domain << "\n";
    }
    Print() << "    Multiplicity type: " << amrex::getEnumNameString(m_mult_type) << "\n";
    Print() << "    Particles per cell: " << m_ppc << "\n";
 
    Print() << "    Vapour/Condensate Species material:\n";
    for (unsigned long i=0; i < a_species_mat.size(); i++) {
        Print() << "        "
                << getEnumNameString(a_species_mat[i]->m_name)
                << " (distribution: " << getEnumNameString(m_species_init_type[i]);
        if (m_species_init_type[i] == SDDistributionType::mass_constant) {
            Print() << ", value=" << m_mass_species_mean[i];
        } else if (m_species_init_type[i] == SDDistributionType::mass_exponential) {
            Print() << ", min=" << m_mass_species_min[i]
                    << ", mean=" << m_mass_species_mean[i]
                    << ", max=" << m_mass_species_max[i];
            AMREX_ALWAYS_ASSERT(m_mass_species_min[i] >= zero);
            AMREX_ALWAYS_ASSERT(m_mass_species_max[i] >= m_mass_species_min[i]);
            AMREX_ALWAYS_ASSERT(    (m_mass_species_mean[i] >= m_mass_species_min[i])
                                 && (m_mass_species_mean[i] <= m_mass_species_max[i]) );
        } else if (m_species_init_type[i] == SDDistributionType::radius_log_normal) {
            Print() << ", min=" << m_radius_species_min[i]
                    << ", max=" << m_radius_species_max[i]
                    << ", mean=" << m_radius_species_mean[i]
                    << ", std=" << m_radius_species_geom_std[i];
            AMREX_ALWAYS_ASSERT(m_radius_species_min[i] > zero);
            AMREX_ALWAYS_ASSERT(m_radius_species_max[i] >= m_radius_species_min[i]);
            AMREX_ALWAYS_ASSERT(    (m_radius_species_mean[i] >= m_radius_species_min[i])
                                 && (m_radius_species_mean[i] <= m_radius_species_max[i]) );
        } else if (m_species_init_type[i] == SDDistributionType::radius_lognormal_autorange) {
            Print() << ", mean=" << m_radius_species_mean[i]
                    << ", std=" << m_radius_species_geom_std[i];
            AMREX_ALWAYS_ASSERT(m_radius_species_mean[i] > zero);
        }
        Print() << ")" << "\n";
    }
 
    if (a_aerosol_mat.size() > 0) {
        Print() << "    Aerosols material:\n";
        for (unsigned long i=0; i < a_aerosol_mat.size(); i++) {
            Print() << "        "
                    << getEnumNameString(a_aerosol_mat[i]->m_name)
                    << " (distribution: " << getEnumNameString(m_aerosol_init_type[i]);
            if (m_aerosol_init_type[i] == SDDistributionType::mass_constant) {
                Print() << ", value=" << m_mass_aerosol_mean[i];
                AMREX_ALWAYS_ASSERT(m_mass_aerosol_mean[i] >= zero);
            } else if (m_aerosol_init_type[i] == SDDistributionType::mass_exponential) {
                Print() << ", min=" << m_mass_aerosol_min[i]
                        << ", mean=" << m_mass_aerosol_mean[i]
                        << ", max=" << m_mass_aerosol_max[i];
                AMREX_ALWAYS_ASSERT(m_mass_aerosol_min[i] > zero);
                AMREX_ALWAYS_ASSERT(m_mass_aerosol_max[i] >= m_mass_aerosol_min[i]);
                AMREX_ALWAYS_ASSERT(    (m_mass_aerosol_mean[i] >= m_mass_aerosol_min[i])
                                     && (m_mass_aerosol_mean[i] <= m_mass_aerosol_max[i]) );
            } else if (m_aerosol_init_type[i] == SDDistributionType::radius_log_normal) {
                Print() << ", min=" << m_radius_aerosol_min[i]
                        << ", max=" << m_radius_aerosol_max[i]
                        << ", mean=" << m_radius_aerosol_mean[i]
                        << ", std=" << m_radius_aerosol_geom_std[i];
                AMREX_ALWAYS_ASSERT(m_radius_aerosol_min[i] > zero);
                AMREX_ALWAYS_ASSERT(m_radius_aerosol_max[i] >= m_radius_aerosol_min[i]);
                AMREX_ALWAYS_ASSERT(    (m_radius_aerosol_mean[i] >= m_radius_aerosol_min[i])
                                     && (m_radius_aerosol_mean[i] <= m_radius_aerosol_max[i]) );
            } else if (m_aerosol_init_type[i] == SDDistributionType::radius_lognormal_autorange) {
                Print() << ", mean=" << m_radius_aerosol_mean[i]
                        << ", std=" << m_radius_aerosol_geom_std[i];
                AMREX_ALWAYS_ASSERT(m_radius_aerosol_mean[i] > zero);
            }
            Print() << ")" << "\n";
        }
 
        // At least one aerosol must carry non-zero dry mass; individual aerosols
        // may be empty (e.g. a pure-CCN mode with no dust core).
        bool any_aerosol_nonzero = false;
        for (unsigned long i=0; i < a_aerosol_mat.size(); i++) {
            if (m_aerosol_init_type[i] == SDDistributionType::mass_constant) {
                if (m_mass_aerosol_mean[i] > zero) { any_aerosol_nonzero = true; }
            } else {
                any_aerosol_nonzero = true;
            }
        }
        AMREX_ALWAYS_ASSERT(any_aerosol_nonzero);
    }
}

Referenced by SDInjection::printParameters(), and SDInitialization::printParameters().

Here is the call graph for this function:

Here is the caller graph for this function:

readInputs()

void SDInitProperties::readInputs ( SDInputs &  a_in, const std::string &  a_key, const amrex::Geometry &  a_geom, const MatVec &  a_species_mat, const MatVec &  a_aerosol_mat  )

virtual

Read super-droplets initialization parameters from input file.

Parameters

[in]	a_in	Two-tier input resolver
[in]	a_key	Key identifier for initialization parameters
[in]	a_geom	Simulation geometry information
[in]	a_species_mat	Vector of species material properties
[in]	a_aerosol_mat	Vector of aerosol material properties

Reimplemented in SDInitialization, and SDInjection.

{
    BL_PROFILE("SDInitProperties::readInputs");
    amrex::ignore_unused(a_geom);
    using namespace amrex;
 
    a_in.query(std::string(a_key+"distribution_type").c_str(), m_type);
    a_in.query("maximum_multiplicity", m_max_multiplicity);
    a_in.query("multiplicity_type", m_mult_type);
    a_in.query("ice_apparent_density", m_ice_app_density);
 
    m_ppc_from_inputs = a_in.query(std::string(a_key+"particles_per_cell").c_str(), m_ppc);
 
    if (m_type == SDInitShape::uniform) {
 
        a_in.queryarr("particle_box_lo", m_init_particle_p1, AMREX_SPACEDIM);
        AMREX_ASSERT(m_init_particle_p1.size() == AMREX_SPACEDIM);
 
        a_in.queryarr("particle_box_hi", m_init_particle_p2, AMREX_SPACEDIM);
        AMREX_ASSERT(m_init_particle_p2.size() == AMREX_SPACEDIM);
 
        m_particle_domain.setLo(m_init_particle_p1);
        m_particle_domain.setHi(m_init_particle_p2);
    } else if (m_type == SDInitShape::bubble){
 
        a_in.queryarr("particle_bubble_center", m_init_particle_p1, AMREX_SPACEDIM);
        AMREX_ASSERT(m_init_particle_p1.size() == AMREX_SPACEDIM);
 
        a_in.queryarr("particle_bubble_radius", m_init_particle_p2, AMREX_SPACEDIM);
        AMREX_ASSERT(m_init_particle_p2.size() == AMREX_SPACEDIM);
 
        m_particle_domain.setLo(m_init_particle_p1);
        m_particle_domain.setHi(m_init_particle_p2);
    }
 
    for (int i = 0; i < m_num_species; i++) {
        {
            std::string key = a_key+"species_distribution_type_"+getEnumNameString(a_species_mat[i]->m_name);
            a_in.query(key.c_str(), m_species_init_type[i]);
        }
        {
            std::string key = a_key+"species_min_mass_" + getEnumNameString(a_species_mat[i]->m_name);
            a_in.query(key.c_str(), m_mass_species_min[i]);
        }
        {
            std::string key = a_key+"species_mean_mass_" + getEnumNameString(a_species_mat[i]->m_name);
            a_in.query(key.c_str(), m_mass_species_mean[i]);
        }
        {
            m_mass_species_max[i] = 5 * m_mass_species_mean[i]; // default
            std::string key = a_key+"species_max_mass_" + getEnumNameString(a_species_mat[i]->m_name);
            a_in.query(key.c_str(), m_mass_species_max[i]);
        }
        {
            std::string key = a_key+"species_min_radius_" + getEnumNameString(a_species_mat[i]->m_name);
            a_in.query(key.c_str(), m_radius_species_min[i]);
        }
        {
            std::string key = a_key+"species_max_radius_" + getEnumNameString(a_species_mat[i]->m_name);
            a_in.query(key.c_str(), m_radius_species_max[i]);
        }
        {
            std::string key = a_key+"species_mean_radius_" + getEnumNameString(a_species_mat[i]->m_name);
            a_in.query(key.c_str(), m_radius_species_mean[i]);
        }
        {
            std::string key_std  = a_key+"species_std_radius_" + getEnumNameString(a_species_mat[i]->m_name);
            std::string key_gstd = a_key+"species_geomstd_radius_" + getEnumNameString(a_species_mat[i]->m_name);
 
            // The two spellings are alternatives: std_radius is the log of the
            // geometric std, geomstd_radius is the geometric std itself. Ask the
            // resolver whether each came from the input file rather than whether the
            // name is present in the table, so a recorded default cannot masquerade
            // as a user setting.
            amrex::Real std_val  = amrex::Real(0.0);
            amrex::Real gstd_val = m_radius_species_geom_std[i];
            const bool has_std  = a_in.query(key_std,  std_val,  false);
            const bool has_gstd = a_in.query(key_gstd, gstd_val, false);
            if (has_std && has_gstd) {
                amrex::Abort("Cannot specify BOTH "+key_std+" and "+key_gstd);
            }
            m_radius_species_geom_std[i] = has_std ? std::exp(std_val) : gstd_val;
            if (!has_std && !has_gstd) { a_in.record(key_gstd, m_radius_species_geom_std[i]); }
        }
    }
 
    for (int i = 0; i < m_num_aerosols; i++) {
        {
            std::string key = a_key+"aerosol_distribution_type_"+getEnumNameString(a_aerosol_mat[i]->m_name);
            a_in.query(key.c_str(), m_aerosol_init_type[i]);
        }
        {
            std::string key = a_key+"aerosol_min_mass_" + getEnumNameString(a_aerosol_mat[i]->m_name);
            a_in.query(key.c_str(), m_mass_aerosol_min[i]);
        }
        {
            std::string key = a_key+"aerosol_mean_mass_" + getEnumNameString(a_aerosol_mat[i]->m_name);
            a_in.query(key.c_str(), m_mass_aerosol_mean[i]);
        }
        {
            m_mass_aerosol_max[i] = 5 * m_mass_aerosol_mean[i]; // default
            std::string key = a_key+"aerosol_max_mass_" + getEnumNameString(a_aerosol_mat[i]->m_name);
            a_in.query(key.c_str(), m_mass_aerosol_max[i]);
        }
        {
            std::string key = a_key+"aerosol_min_radius_" + getEnumNameString(a_aerosol_mat[i]->m_name);
            a_in.query(key.c_str(), m_radius_aerosol_min[i]);
        }
        {
            std::string key = a_key+"aerosol_max_radius_" + getEnumNameString(a_aerosol_mat[i]->m_name);
            a_in.query(key.c_str(), m_radius_aerosol_max[i]);
        }
        {
            std::string key = a_key+"aerosol_mean_radius_" + getEnumNameString(a_aerosol_mat[i]->m_name);
            a_in.query(key.c_str(), m_radius_aerosol_mean[i]);
        }
        {
            std::string key_std  = a_key+"aerosol_std_radius_" + getEnumNameString(a_aerosol_mat[i]->m_name);
            std::string key_gstd = a_key+"aerosol_geomstd_radius_" + getEnumNameString(a_aerosol_mat[i]->m_name);
 
            // The two spellings are alternatives: std_radius is the log of the
            // geometric std, geomstd_radius is the geometric std itself. Ask the
            // resolver whether each came from the input file rather than whether the
            // name is present in the table, so a recorded default cannot masquerade
            // as a user setting.
            amrex::Real std_val  = amrex::Real(0.0);
            amrex::Real gstd_val = m_radius_aerosol_geom_std[i];
            const bool has_std  = a_in.query(key_std,  std_val,  false);
            const bool has_gstd = a_in.query(key_gstd, gstd_val, false);
            if (has_std && has_gstd) {
                amrex::Abort("Cannot specify BOTH "+key_std+" and "+key_gstd);
            }
            m_radius_aerosol_geom_std[i] = has_std ? std::exp(std_val) : gstd_val;
            if (!has_std && !has_gstd) { a_in.record(key_gstd, m_radius_aerosol_geom_std[i]); }
        }
    }
 
}

Referenced by SDInitialization::readInputs(), and SDInjection::readInputs().

Here is the call graph for this function:

Here is the caller graph for this function:

sampledMultiplicity()

bool SDInitProperties::sampledMultiplicity ( ) const

inline

Determine whether multiplicity is sampled or constant.

Returns

True if multiplicity is sampled, false if constant

        {
            return (m_mult_type == SDMultiplicityType::sampled);
        }

setDefaults()

void SDInitProperties::setDefaults ( const amrex::Geometry &  a_geom, const MatVec &  a_species_mat, const MatVec &  a_aerosol_mat  )

virtual

Set default values for initialization parameters.

Parameters

[in]	a_geom	Simulation geometry information
[in]	a_species_mat	Vector of species material properties
[in]	a_aerosol_mat	Vector of aerosol material properties

{
    BL_PROFILE("SDInitProperties::setDefaults");
 
    // Default
    m_init_particle_p1.resize(AMREX_SPACEDIM);
    m_init_particle_p2.resize(AMREX_SPACEDIM);
    for (int i = 0; i < AMREX_SPACEDIM; i++) {
        m_init_particle_p1[i] = a_geom.ProbLo(i);
        m_init_particle_p2[i] = a_geom.ProbHi(i);
    }
 
    m_num_species = static_cast<int>(a_species_mat.size());
    m_mass_species_min.resize(m_num_species);
    m_mass_species_max.resize(m_num_species);
    m_mass_species_mean.resize(m_num_species);
    m_radius_species_min.resize(m_num_species);
    m_radius_species_max.resize(m_num_species);
    m_radius_species_mean.resize(m_num_species);
    m_radius_species_geom_std.resize(m_num_species);
    m_species_init_type.resize(m_num_species);
 
    for (int i = 0; i < m_num_species; i++) {
        // default values
        m_species_init_type[i] = SDDistributionType::mass_constant;
        if (a_species_mat[i]->m_is_water) {
            m_mass_species_min[i]   = amrex::Real(4.1887902e-42);
            m_mass_species_max[i]   = amrex::Real(4.1887902e-42);
            m_mass_species_mean[i]  = amrex::Real(4.1887902e-42);
            m_radius_species_min[i] = amrex::Real(1.0e-15);
            m_radius_species_max[i] = amrex::Real(1.0e-15);
            m_radius_species_mean[i] = amrex::Real(1.0e-15);
        } else {
            m_mass_species_min[i]   = zero;
            m_mass_species_max[i]   = zero;
            m_mass_species_mean[i]  = zero;
            m_radius_species_min[i] = zero;
            m_radius_species_max[i] = zero;
            m_radius_species_mean[i] = zero;
        }
        m_radius_species_geom_std[i] = two;
    }
 
    m_num_aerosols = static_cast<int>(a_aerosol_mat.size());
    m_mass_aerosol_min.resize(m_num_aerosols);
    m_mass_aerosol_max.resize(m_num_aerosols);
    m_mass_aerosol_mean.resize(m_num_aerosols);
    m_radius_aerosol_min.resize(m_num_aerosols);
    m_radius_aerosol_max.resize(m_num_aerosols);
    m_radius_aerosol_mean.resize(m_num_aerosols);
    m_radius_aerosol_geom_std.resize(m_num_aerosols);
    m_aerosol_init_type.resize(m_num_aerosols);
 
    for (int i = 0; i < m_num_aerosols; i++) {
        // default values
        m_aerosol_init_type[i] = SDDistributionType::mass_constant;
        m_mass_aerosol_min[i]   = zero;
        m_mass_aerosol_max[i]   = zero;
        m_mass_aerosol_mean[i]  = zero;
        m_radius_aerosol_min[i] = amrex::Real(1.0e-9);
        m_radius_aerosol_max[i] = amrex::Real(1.0e-6);
        m_radius_aerosol_mean[i] = amrex::Real(1.0e-40);
        m_radius_aerosol_geom_std[i] = two;
    }
 
    m_mult_type = SDMultiplicityType::sampled;
}

volume()

amrex::Real SDInitProperties::volume ( ) const

inline

Calculate the volume of the particle domain.

For uniform distribution type, returns the box volume. For bubble distribution type, returns the volume of the bubble.

Returns

Volume of the particle domain in cubic meters

        {
            amrex::Real vol = zero;
            if (m_type == SDInitShape::uniform) {
                vol = m_particle_domain.volume();
            } else if (m_type == SDInitShape::bubble) {
                const auto& radius = m_particle_domain.hi();
                vol = four_thirds_pi*radius[0]*radius[1]*radius[2];
            }
            return vol;
        }

Referenced by SDInjection::readInputs().

Here is the caller graph for this function:

Member Data Documentation

m_aerosol_init_type

std::vector<SDDistributionType> SDInitProperties::m_aerosol_init_type

Initial distribution type for aerosol

Referenced by getAerosolDistParams(), getAerosolDistribution(), printParameters(), readInputs(), and setDefaults().

m_ice_app_density

amrex::Real SDInitProperties::m_ice_app_density = -1

Referenced by readInputs().

m_init_particle_p1

amrex::Vector<amrex::Real> SDInitProperties::m_init_particle_p1

Particle distribution shape parameters Box shape, p1 -> lo end, p2 -> hi end Bubble shape, p1 -> center, p2 -> radius

Referenced by readInputs(), and setDefaults().

m_init_particle_p2

amrex::Vector<amrex::Real> SDInitProperties::m_init_particle_p2

Referenced by readInputs(), and setDefaults().

m_mass_aerosol_max

std::vector<amrex::Real> SDInitProperties::m_mass_aerosol_max

Maximum aerosol mass

Referenced by getAerosolDistParams(), getAerosolDistribution(), printParameters(), readInputs(), and setDefaults().

m_mass_aerosol_mean

std::vector<amrex::Real> SDInitProperties::m_mass_aerosol_mean

Mean aerosol mass

Referenced by getAerosolDistParams(), getAerosolDistribution(), printParameters(), readInputs(), and setDefaults().

m_mass_aerosol_min

std::vector<amrex::Real> SDInitProperties::m_mass_aerosol_min

Minimum aerosol mass

Referenced by getAerosolDistParams(), getAerosolDistribution(), printParameters(), readInputs(), and setDefaults().

m_mass_species_max

std::vector<amrex::Real> SDInitProperties::m_mass_species_max

Maximum species mass

Referenced by getSpeciesDistParams(), getSpeciesDistribution(), printParameters(), readInputs(), and setDefaults().

m_mass_species_mean

std::vector<amrex::Real> SDInitProperties::m_mass_species_mean

Mean species mass

Referenced by getSpeciesDistParams(), getSpeciesDistribution(), printParameters(), readInputs(), and setDefaults().

m_mass_species_min

std::vector<amrex::Real> SDInitProperties::m_mass_species_min

Minimum species mass

Referenced by getSpeciesDistParams(), getSpeciesDistribution(), printParameters(), readInputs(), and setDefaults().

m_max_multiplicity

amrex::Real SDInitProperties::m_max_multiplicity = 1000000

Apparent (bulk) density of initialized ice particles [kg m^-3]; <= 0 means use the solid-ice material density (a solid sphere)

Referenced by readInputs().

m_mult_type

SDMultiplicityType SDInitProperties::m_mult_type

multiplicity type

Referenced by printParameters(), readInputs(), sampledMultiplicity(), and setDefaults().

m_num_aerosols

int SDInitProperties::m_num_aerosols = 0

Number of aerosols

Referenced by readInputs(), and setDefaults().

m_num_species

int SDInitProperties::m_num_species = 0

Number of species

Referenced by readInputs(), and setDefaults().

m_numdens

amrex::Real SDInitProperties::m_numdens = -1

Maximum multiplicity

Referenced by getDistribution(), makeDistributionParams(), SDInitialization::numParticlesPerCell(), SDInitialization::printParameters(), and SDInitialization::readInputs().

m_particle_domain

amrex::RealBox SDInitProperties::m_particle_domain

box within which to place particles

Referenced by printParameters(), readInputs(), SDInjection::updateDt(), and volume().

m_ppc

int SDInitProperties::m_ppc = 1

Whether particles_per_cell came from the input file. Published by readInputs so callers do not have to read the key a second time – a second read would find the default this one recorded.

Referenced by SDInitialization::numSDPerCell(), printParameters(), readInputs(), and SDInjection::updateDt().

m_ppc_from_inputs

bool SDInitProperties::m_ppc_from_inputs = false

Referenced by SDInjection::readInputs(), and readInputs().

m_radius_aerosol_geom_std

std::vector<amrex::Real> SDInitProperties::m_radius_aerosol_geom_std

Standard deviation of aerosol dry radius

Referenced by getAerosolDistParams(), getAerosolDistribution(), printParameters(), readInputs(), and setDefaults().

m_radius_aerosol_max

std::vector<amrex::Real> SDInitProperties::m_radius_aerosol_max

Maximum aerosol dry radius

Referenced by getAerosolDistParams(), getAerosolDistribution(), printParameters(), readInputs(), and setDefaults().

m_radius_aerosol_mean

std::vector<amrex::Real> SDInitProperties::m_radius_aerosol_mean

Mean aerosol dry radius

Referenced by getAerosolDistParams(), getAerosolDistribution(), printParameters(), readInputs(), and setDefaults().

m_radius_aerosol_min

std::vector<amrex::Real> SDInitProperties::m_radius_aerosol_min

Minimum aerosol dry radius

Referenced by getAerosolDistParams(), getAerosolDistribution(), printParameters(), readInputs(), and setDefaults().

m_radius_species_geom_std

std::vector<amrex::Real> SDInitProperties::m_radius_species_geom_std

Standard deviation of species dry radius

Referenced by getSpeciesDistParams(), getSpeciesDistribution(), printParameters(), readInputs(), and setDefaults().

m_radius_species_max

std::vector<amrex::Real> SDInitProperties::m_radius_species_max

Maximum species dry radius

Referenced by getSpeciesDistParams(), getSpeciesDistribution(), printParameters(), readInputs(), and setDefaults().

m_radius_species_mean

std::vector<amrex::Real> SDInitProperties::m_radius_species_mean

Mean species dry radius

Referenced by getSpeciesDistParams(), getSpeciesDistribution(), printParameters(), readInputs(), and setDefaults().

m_radius_species_min

std::vector<amrex::Real> SDInitProperties::m_radius_species_min

Minimum species dry radius

Referenced by getSpeciesDistParams(), getSpeciesDistribution(), printParameters(), readInputs(), and setDefaults().

m_species_init_type

std::vector<SDDistributionType> SDInitProperties::m_species_init_type

Initial distribution type for species

Referenced by getSpeciesDistParams(), getSpeciesDistribution(), printParameters(), readInputs(), and setDefaults().

m_type

SDInitShape SDInitProperties::m_type = SDInitShape::uniform

Initial distribution type Initial number density (m^{-3}) of physical particles

Referenced by printParameters(), readInputs(), SDInjection::updateDt(), and volume().

---

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

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