ERF
Energy Research and Forecasting: An Atmospheric Modeling Code
Public Types | Public Member Functions | Public Attributes | List of all members
SDInitProperties Class Referenceabstract

Super-droplets initial properties. More...

#include <ERF_SDInitialization.H>

Inheritance diagram for SDInitProperties:
Inheritance graph
[legend]
Collaboration diagram for SDInitProperties:
Collaboration graph
[legend]

Public Types

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

Public Member Functions

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 (const std::string &a_prefix, 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
 

Public Attributes

int m_ppc = 1
 
SDInitShape m_type = SDInitShape::uniform
 
amrex::Real m_numdens = -1
 
amrex::Real m_max_multiplicity = 1000000
 
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

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_idxAerosol species index
[in]a_densityDensity of the aerosol material
[in]a_cell_volumeCell volume for multiplicity scaling
[in]a_sampled_multWhether using sampled multiplicity mode
Returns
SDDistributionParams structure for GPU use
462  {
463  return makeDistributionParams(
464  m_aerosol_init_type[a_idx],
465  m_mass_aerosol_min[a_idx],
466  m_mass_aerosol_max[a_idx],
467  m_mass_aerosol_mean[a_idx],
468  m_radius_aerosol_min[a_idx],
469  m_radius_aerosol_max[a_idx],
470  m_radius_aerosol_mean[a_idx],
471  m_radius_aerosol_geom_std[a_idx],
472  a_density,
473  a_cell_volume,
474  a_sampled_mult);
475  }
SDInitProperties::m_radius_aerosol_geom_std
std::vector< amrex::Real > m_radius_aerosol_geom_std
Definition: ERF_SDInitialization.H:196
SDInitProperties::makeDistributionParams
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.
Definition: ERF_SDInitialization.cpp:513
SDInitProperties::m_radius_aerosol_min
std::vector< amrex::Real > m_radius_aerosol_min
Definition: ERF_SDInitialization.H:190
SDInitProperties::m_radius_aerosol_max
std::vector< amrex::Real > m_radius_aerosol_max
Definition: ERF_SDInitialization.H:192
SDInitProperties::m_aerosol_init_type
std::vector< SDDistributionType > m_aerosol_init_type
Definition: ERF_SDInitialization.H:198
SDInitProperties::m_radius_aerosol_mean
std::vector< amrex::Real > m_radius_aerosol_mean
Definition: ERF_SDInitialization.H:194
SDInitProperties::m_mass_aerosol_min
std::vector< amrex::Real > m_mass_aerosol_min
Definition: ERF_SDInitialization.H:184
SDInitProperties::m_mass_aerosol_mean
std::vector< amrex::Real > m_mass_aerosol_mean
Definition: ERF_SDInitialization.H:188
SDInitProperties::m_mass_aerosol_max
std::vector< amrex::Real > m_mass_aerosol_max
Definition: ERF_SDInitialization.H:186
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_massOutput vector of aerosol masses
[out]a_multOutput vector of particle multiplicities
[in]a_dVCell volume for scaling multiplicity
[in]a_idxAerosol species index
[in]a_npNumber of particles to generate
[in]a_densityDensity of the aerosol material
[in,out]a_rngRandom number generator
346  {
347  getDistribution( a_mass,
348  a_mult,
349  a_dV,
350  a_np,
351  a_density,
352  m_aerosol_init_type[a_idx],
353  m_mass_aerosol_min[a_idx],
354  m_mass_aerosol_max[a_idx],
355  m_mass_aerosol_mean[a_idx],
356  m_radius_aerosol_min[a_idx],
357  m_radius_aerosol_max[a_idx],
358  m_radius_aerosol_mean[a_idx],
359  m_radius_aerosol_geom_std[a_idx],
360  a_rng);
361  }
SDInitProperties::getDistribution
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.
Definition: ERF_SDInitialization.cpp:351
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_massOutput vector of aerosol masses
[in]a_idxAerosol species index
[in]a_npNumber of particles
[in]a_densityDensity of the aerosol material
[in,out]a_rngRandom number generator
315  {
316  getDistribution( a_mass,
317  a_np,
318  a_density,
319  m_aerosol_init_type[a_idx],
320  m_mass_aerosol_min[a_idx],
321  m_mass_aerosol_max[a_idx],
322  m_mass_aerosol_mean[a_idx],
323  m_radius_aerosol_min[a_idx],
324  m_radius_aerosol_max[a_idx],
325  m_radius_aerosol_mean[a_idx],
326  m_radius_aerosol_geom_std[a_idx],
327  a_rng);
328  }
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_massOutput vector of particle masses
[out]a_multOutput vector of particle multiplicities
[in]a_dVCell volume
[in]a_npNumber of particles
[in]a_densityDensity of the particle material
[in]a_init_typeType of initialization distribution
[in]a_mass_minMinimum mass value
[in]a_mass_maxMaximum mass value
[in]a_mass_meanMean mass value
[in]a_radius_minMinimum radius value
[in]a_radius_maxMaximum radius value
[in]a_radius_meanMean radius value
[in]a_radius_gstdGeometric standard deviation for radius
[in,out]a_rngRandom number generator
419 {
420  a_mass.resize(a_np);
421  AMREX_ALWAYS_ASSERT(static_cast<amrex::Long>(a_mult.size()) == a_np);
422  if (a_init_type == SDDistributionType::mass_constant) {
423  std::uniform_real_distribution<> urd(zero, one);
424  for (int n = 0; n < a_np; n++) {
425  a_mass[n] = a_mass_mean;
426  a_mult[n] += urd(a_rng); // initially this will be a non-integer; later we will rescale to an integer.
427  }
428  } else if (a_init_type == SDDistributionType::mass_exponential) {
429  std::uniform_real_distribution<> urd(zero, one);
430  auto delta = a_mass_mean - a_mass_min;
431  auto lnrng = std::log(a_mass_max) - std::log(a_mass_min);
432  auto lnmin = std::log(a_mass_min);
433  for (int n = 0; n < a_np; n++) {
434  auto tmp = lnmin + urd(a_rng) * lnrng;
435  a_mass[n] = std::exp(tmp);
436  a_mult[n] += (m_numdens * a_dV) * std::exp(-a_mass[n] / delta);
437  }
438  } else if (a_init_type == SDDistributionType::radius_log_normal) {
439  std::uniform_real_distribution<> urd(zero, one);
440  auto sigma = std::log(a_radius_gstd);
441  auto mu = a_radius_mean;
442  auto lnrng = std::log(a_radius_max) - std::log(a_radius_min);
443  auto lnmin = std::log(a_radius_min);
444  for (int n = 0; n < a_np; n++) {
445  auto tmp = lnmin + urd(a_rng) * lnrng;
446  auto dry_r = std::exp(tmp);
447  a_mass[n] = four_thirds_pi * dry_r * dry_r * dry_r * a_density;
448  auto term = std::exp(-std::log(dry_r/mu)*std::log(dry_r/mu)/(two*sigma*sigma));
449  a_mult[n] += ( m_numdens * a_dV ) / (sigma*std::sqrt(2*PI)) * term;
450  }
451  } else if (a_init_type == SDDistributionType::radius_lognormal_autorange) {
452  std::uniform_real_distribution<> urd(zero, one);
453  auto sigma = std::log(a_radius_gstd);
454  auto mu = a_radius_mean;
455  // automatically find the min and max radius of superdroplets, using Dziekan & Pawlowska 2017
456  auto rmin = 1e-9;
457  auto rmax = one;
458  auto dlnr = (std::log(rmax) - std::log(rmin)) / a_np;
459  auto P_min = zero;
460  auto P_max = one;
461  auto tol = one / (m_numdens * a_dV);
462  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
463  amrex::Vector<amrex::Real> tmp_mass(a_np);
464  amrex::Vector<amrex::Real> tmp_mult(a_np);
465  amrex::Print() << "Finding aerosol radius sampling range\n";
466  while ((P_max >= one - tol) || (P_min <= tol)) {
467  if (P_max >= one - tol) {
468  rmax = rmax * amrex::Real(0.99);
469  }
470  if (P_min <= tol) {
471  rmin = rmin * amrex::Real(1.01);
472  }
473  P_min = (1 + std::erf((std::log(rmin / mu)) / sigma / std::sqrt(2))) / 2;
474  P_max = (1 + std::erf((std::log(rmax / mu)) / sigma / std::sqrt(2))) / 2;
475  }
476  dlnr = (std::log(rmax) - std::log(rmin));
477  amrex::Print() << "Range: rmin =" << rmin << ", rmax = " << rmax << ", dlnr = " << dlnr << "\n";
478 
479  // initialize the main distribution
480  amrex::Print() << "Initializing radii\n";
481  auto lnrmin = std::log(rmin);
482  for (int n = 0; n < a_np; n++) {
483  auto tmp = lnrmin + urd(a_rng)*dlnr;
484  auto dry_r = std::exp(tmp);
485  tmp_mass[n] = four_thirds_pi * dry_r * dry_r * dry_r * a_density;
486  auto term = std::exp(-std::log(dry_r/mu)*std::log(dry_r/mu)/(two*sigma*sigma));
487  tmp_mult[n] = (m_numdens * a_dV)/ (sigma*std::sqrt(2*PI)) * term;
488  }
489 
490  // initialize the tail using approximate erfinv
491  amrex::Print() << "Initializing tail: " << a_np_tail << " particles\n";
492  auto tail_mult = std::exp(-std::log(rmax/mu)*std::log(rmax/mu)/(two*sigma*sigma)) / (sigma*std::sqrt(2*PI));
493  for (int n = 0; n < a_np_tail; n++) {
494  int sd_id = static_cast<int>(std::round(urd(a_rng) * a_np));
495  auto tmp = P_max + (one - P_max) * urd(a_rng);
496  auto tmp2 = SD_erfinv(2 * tmp - 1);
497  auto dry_r = mu * std::exp(sigma * std::sqrt(2) * tmp2);
498  tmp_mass[sd_id] = four_thirds_pi * dry_r * dry_r * dry_r * a_density;
499  // set the multiplicity to the same as for the 99th percentile aerosol
500  tmp_mult[sd_id] = (m_numdens * a_dV) * tail_mult;
501  }
502  // Update SD multiplicity and mass with the initialized main + tail distribution
503  for (int n = 0; n < a_np; n++) {
504  a_mult[n] += tmp_mult[n];
505  a_mass[n] += tmp_mass[n];
506  }
507  amrex::Print() << "Done sampling\n";
508  } else {
509  amrex::Abort("Unknown m_init_type!");
510  }
511 }
two
constexpr amrex::Real two
Definition: ERF_Constants.H:8
one
constexpr amrex::Real one
Definition: ERF_Constants.H:7
zero
constexpr amrex::Real zero
Definition: ERF_Constants.H:6
PI
constexpr amrex::Real PI
Definition: ERF_Constants.H:16
four_thirds_pi
constexpr amrex::Real four_thirds_pi
Definition: ERF_Constants.H:18
AMREX_ALWAYS_ASSERT
AMREX_ALWAYS_ASSERT(bx.length()[2]==khi+1)
sigma
amrex::Real sigma
Definition: ERF_InitCustomPert_DataAssimilation_ISV.H:11
SD_erfinv
AMREX_GPU_HOST_DEVICE static AMREX_FORCE_INLINE amrex::Real SD_erfinv(const amrex::Real x)
Definition: ERF_SDInitialization.cpp:396
Real
amrex::Real Real
Definition: ERF_ShocInterface.H:19
SDInitProperties::m_numdens
amrex::Real m_numdens
Definition: ERF_SDInitialization.H:162
MORRInd::mu
@ mu
Definition: ERF_AdvanceMorrison.cpp:89
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_massOutput vector of particle masses
[in]a_npNumber of particles
[in]a_densityDensity of the particle material
[in]a_init_typeType of initialization distribution
[in]a_mass_minMinimum mass value
[in]a_mass_maxMaximum mass value
[in]a_mass_meanMean mass value
[in]a_radius_minMinimum radius value
[in]a_radius_maxMaximum radius value
[in]a_radius_meanMean radius value
[in]a_radius_gstdGeometric standard deviation for radius
[in,out]a_rngRandom number generator
363 {
364  a_mass.resize(a_np);
365  if (a_init_type == SDDistributionType::mass_constant) {
366  for (int n = 0; n < a_np; n++) {
367  a_mass[n] = a_mass_mean;
368  }
369  } else if (a_init_type == SDDistributionType::mass_exponential) {
370  auto delta = a_mass_mean - a_mass_min;
371  std::exponential_distribution<amrex::Real> ed(one/delta);
372  for (int n = 0; n < a_np; n++) {
373  a_mass[n] = ed(a_rng) + a_mass_min;
374  }
375  } else if (a_init_type == SDDistributionType::radius_log_normal) {
376  std::normal_distribution<amrex::Real> nrd(std::log(a_radius_mean),
377  std::log(a_radius_gstd));
378  for (int n = 0; n < a_np; n++) {
379  auto dry_r = std::exp(nrd(a_rng));
380  int count = 0;
381  while ((dry_r < a_radius_min) || (dry_r > a_radius_max)) {
382  dry_r = std::exp(nrd(a_rng));
383  count++;
384  if (count > 100) { break; }
385  }
386  a_mass[n] = four_thirds_pi
387  * dry_r * dry_r * dry_r
388  * a_density;
389  }
390  } else {
391  amrex::Abort("Unknown a_init_type!");
392  }
393 }

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_idxSpecies index
[in]a_densityDensity of the species material
[in]a_cell_volumeCell volume for multiplicity scaling
[in]a_sampled_multWhether using sampled multiplicity mode
Returns
SDDistributionParams structure for GPU use
435  {
436  return makeDistributionParams(
437  m_species_init_type[a_idx],
438  m_mass_species_min[a_idx],
439  m_mass_species_max[a_idx],
440  m_mass_species_mean[a_idx],
441  m_radius_species_min[a_idx],
442  m_radius_species_max[a_idx],
443  m_radius_species_mean[a_idx],
444  m_radius_species_geom_std[a_idx],
445  a_density,
446  a_cell_volume,
447  a_sampled_mult);
448  }
SDInitProperties::m_radius_species_max
std::vector< amrex::Real > m_radius_species_max
Definition: ERF_SDInitialization.H:175
SDInitProperties::m_species_init_type
std::vector< SDDistributionType > m_species_init_type
Definition: ERF_SDInitialization.H:181
SDInitProperties::m_mass_species_max
std::vector< amrex::Real > m_mass_species_max
Definition: ERF_SDInitialization.H:169
SDInitProperties::m_radius_species_mean
std::vector< amrex::Real > m_radius_species_mean
Definition: ERF_SDInitialization.H:177
SDInitProperties::m_radius_species_geom_std
std::vector< amrex::Real > m_radius_species_geom_std
Definition: ERF_SDInitialization.H:179
SDInitProperties::m_mass_species_min
std::vector< amrex::Real > m_mass_species_min
Definition: ERF_SDInitialization.H:167
SDInitProperties::m_mass_species_mean
std::vector< amrex::Real > m_mass_species_mean
Definition: ERF_SDInitialization.H:171
SDInitProperties::m_radius_species_min
std::vector< amrex::Real > m_radius_species_min
Definition: ERF_SDInitialization.H:173
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_massOutput vector of species masses
[out]a_multOutput vector of particle multiplicities
[in]a_dVCell volume for scaling multiplicity
[in]a_idxSpecies index
[in]a_npNumber of particles to generate
[in]a_densityDensity of the species material
[in,out]a_rngRandom number generator
406  {
407  getDistribution( a_mass,
408  a_mult,
409  a_dV,
410  a_np,
411  a_density,
412  m_species_init_type[a_idx],
413  m_mass_species_min[a_idx],
414  m_mass_species_max[a_idx],
415  m_mass_species_mean[a_idx],
416  m_radius_species_min[a_idx],
417  m_radius_species_max[a_idx],
418  m_radius_species_mean[a_idx],
419  m_radius_species_geom_std[a_idx],
420  a_rng);
421  }
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_massOutput vector of species masses
[in]a_idxSpecies index
[in]a_npNumber of particles to generate
[in]a_densityDensity of the species material
[in,out]a_rngRandom number generator
375  {
376  getDistribution( a_mass,
377  a_np,
378  a_density,
379  m_species_init_type[a_idx],
380  m_mass_species_min[a_idx],
381  m_mass_species_max[a_idx],
382  m_mass_species_mean[a_idx],
383  m_radius_species_min[a_idx],
384  m_radius_species_max[a_idx],
385  m_radius_species_mean[a_idx],
386  m_radius_species_geom_std[a_idx],
387  a_rng);
388  }
Here is the call graph for this function:

◆ 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_typeDistribution type
[in]a_mass_minMinimum mass
[in]a_mass_maxMaximum mass
[in]a_mass_meanMean mass
[in]a_radius_minMinimum radius
[in]a_radius_maxMaximum radius
[in]a_radius_meanMean radius
[in]a_radius_gstdGeometric standard deviation
[in]a_densityMaterial density
[in]a_cell_volumeCell volume
[in]a_sampled_multWhether using sampled multiplicity mode
Returns
SDDistributionParams structure
525 {
526  SDDistributionParams params;
527  params.dist_type = a_init_type;
528  params.mass_min = a_mass_min;
529  params.mass_max = a_mass_max;
530  params.mass_mean = a_mass_mean;
531  params.radius_min = a_radius_min;
532  params.radius_max = a_radius_max;
533  params.radius_mean = a_radius_mean;
534  params.radius_gstd = a_radius_gstd;
535  params.density = a_density;
536  params.numdens = m_numdens;
537  params.cell_volume = a_cell_volume;
538  params.delta = a_mass_mean - a_mass_min;
539  params.sampled_mult = a_sampled_mult ? 1 : 0;
540 
541  // Pre-compute values for log-normal distribution
542  params.sigma = std::log(a_radius_gstd);
543 
544  if (params.dist_type == SDDistributionType::mass_exponential) {
545  // For exponential with sampled multiplicity, we sample in log-space
546  // For constant multiplicity, we use inverse transform sampling
547  params.lnmin = std::log(a_mass_min);
548  params.lnrng = std::log(a_mass_max) - params.lnmin;
549  params.cdf_min = zero;
550  params.cdf_max = one;
551  } else if (params.dist_type == SDDistributionType::radius_log_normal ||
552  params.dist_type == SDDistributionType::radius_lognormal_autorange) {
553  // For log-normal, compute CDF bounds for truncated sampling
554  // CDF of log-normal: Phi((ln(x) - ln(mu)) / sigma)
555  // where Phi is the standard normal CDF: Phi(z) = 0.5 * (1 + erf(z/sqrt(2)))
556  amrex::Real rmin = a_radius_min;
557  amrex::Real rmax = a_radius_max;
558  amrex::Real mu = a_radius_mean;
559  amrex::Real sigma = params.sigma;
560 
561  // For LogNormalAuto, find appropriate bounds iteratively
562  if (params.dist_type == SDDistributionType::radius_lognormal_autorange) {
563  rmin = amrex::Real(1e-9);
564  rmax = one;
565  amrex::Real tol = (m_numdens > 0 && a_cell_volume > 0) ?
566  one / (m_numdens * a_cell_volume) : amrex::Real(1e-6);
567  amrex::Real P_min = zero;
568  amrex::Real P_max = one;
569  while ((P_max >= one - tol) || (P_min <= tol)) {
570  if (P_max >= one - tol) rmax *= amrex::Real(0.99);
571  if (P_min <= tol) rmin *= amrex::Real(1.01);
572  P_min = myhalf * (one + std::erf(std::log(rmin / mu) / (sigma * std::sqrt(two))));
573  P_max = myhalf * (one + std::erf(std::log(rmax / mu) / (sigma * std::sqrt(two))));
574  }
575  // Update the params with computed bounds
576  params.radius_min = rmin;
577  params.radius_max = rmax;
578  }
579 
580  params.cdf_min = myhalf * (one + std::erf(std::log(rmin / mu) / (sigma * std::sqrt(two))));
581  params.cdf_max = myhalf * (one + std::erf(std::log(rmax / mu) / (sigma * std::sqrt(two))));
582  params.lnmin = std::log(rmin);
583  params.lnrng = std::log(rmax) - params.lnmin;
584  } else {
585  // Constant distribution - no special pre-computation needed
586  params.cdf_min = zero;
587  params.cdf_max = one;
588  params.lnmin = zero;
589  params.lnrng = zero;
590  }
591 
592  return params;
593 }
myhalf
constexpr amrex::Real myhalf
Definition: ERF_Constants.H:11
SDDistributionParams
GPU-compatible structure holding distribution parameters.
Definition: ERF_SDInitialization.H:48
SDDistributionParams::numdens
amrex::Real numdens
Definition: ERF_SDInitialization.H:58
SDDistributionParams::mass_mean
amrex::Real mass_mean
Definition: ERF_SDInitialization.H:52
SDDistributionParams::sigma
amrex::Real sigma
Definition: ERF_SDInitialization.H:63
SDDistributionParams::delta
amrex::Real delta
Definition: ERF_SDInitialization.H:66
SDDistributionParams::cdf_max
amrex::Real cdf_max
Definition: ERF_SDInitialization.H:62
SDDistributionParams::radius_mean
amrex::Real radius_mean
Definition: ERF_SDInitialization.H:55
SDDistributionParams::mass_max
amrex::Real mass_max
Definition: ERF_SDInitialization.H:51
SDDistributionParams::lnmin
amrex::Real lnmin
Definition: ERF_SDInitialization.H:65
SDDistributionParams::cell_volume
amrex::Real cell_volume
Definition: ERF_SDInitialization.H:59
SDDistributionParams::lnrng
amrex::Real lnrng
Definition: ERF_SDInitialization.H:64
SDDistributionParams::radius_gstd
amrex::Real radius_gstd
Definition: ERF_SDInitialization.H:56
SDDistributionParams::density
amrex::Real density
Definition: ERF_SDInitialization.H:57
SDDistributionParams::radius_min
amrex::Real radius_min
Definition: ERF_SDInitialization.H:53
SDDistributionParams::radius_max
amrex::Real radius_max
Definition: ERF_SDInitialization.H:54
SDDistributionParams::sampled_mult
int sampled_mult
Definition: ERF_SDInitialization.H:67
SDDistributionParams::dist_type
SDDistributionType dist_type
Definition: ERF_SDInitialization.H:49
SDDistributionParams::cdf_min
amrex::Real cdf_min
Definition: ERF_SDInitialization.H:61
SDDistributionParams::mass_min
amrex::Real mass_min
Definition: ERF_SDInitialization.H:50

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 SDInitialization, and SDInjection.

◆ numSDPerCell()

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

Implemented in SDInitialization, and SDInjection.

◆ 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_matVector of species material properties
[in]a_aerosol_matVector of aerosol material properties

Reimplemented in SDInitialization, and SDInjection.

250 {
251  using namespace amrex;
252  if (m_type == SDInitShape::uniform) {
253  Print() << " Particle box: " << m_particle_domain << "\n";
254  } else if (m_type == SDInitShape::bubble) {
255  Print() << " Particle bubble (radius, center): " << m_particle_domain << "\n";
256  }
257  Print() << " Multiplicity type: " << amrex::getEnumNameString(m_mult_type) << "\n";
258  Print() << " Particles per cell: " << m_ppc << "\n";
259 
260  Print() << " Vapour/Condensate Species material:\n";
261  for (unsigned long i=0; i < a_species_mat.size(); i++) {
262  Print() << " "
263  << getEnumNameString(a_species_mat[i]->m_name)
264  << " (distribution: " << getEnumNameString(m_species_init_type[i]);
265  if (m_species_init_type[i] == SDDistributionType::mass_constant) {
266  Print() << ", value=" << m_mass_species_mean[i];
267  } else if (m_species_init_type[i] == SDDistributionType::mass_exponential) {
268  Print() << ", min=" << m_mass_species_min[i]
269  << ", mean=" << m_mass_species_mean[i]
270  << ", max=" << m_mass_species_max[i];
271  AMREX_ALWAYS_ASSERT(m_mass_species_min[i] >= zero);
272  AMREX_ALWAYS_ASSERT(m_mass_species_max[i] >= m_mass_species_min[i]);
273  AMREX_ALWAYS_ASSERT( (m_mass_species_mean[i] >= m_mass_species_min[i])
274  && (m_mass_species_mean[i] <= m_mass_species_max[i]) );
275  } else if (m_species_init_type[i] == SDDistributionType::radius_log_normal) {
276  Print() << ", min=" << m_radius_species_min[i]
277  << ", max=" << m_radius_species_max[i]
278  << ", mean=" << m_radius_species_mean[i]
279  << ", std=" << m_radius_species_geom_std[i];
280  AMREX_ALWAYS_ASSERT(m_radius_species_min[i] > zero);
281  AMREX_ALWAYS_ASSERT(m_radius_species_max[i] >= m_radius_species_min[i]);
282  AMREX_ALWAYS_ASSERT( (m_radius_species_mean[i] >= m_radius_species_min[i])
283  && (m_radius_species_mean[i] <= m_radius_species_max[i]) );
284  } else if (m_species_init_type[i] == SDDistributionType::radius_lognormal_autorange) {
285  Print() << ", mean=" << m_radius_species_mean[i]
286  << ", std=" << m_radius_species_geom_std[i];
287  AMREX_ALWAYS_ASSERT(m_radius_species_mean[i] > zero);
288  }
289  Print() << ")" << "\n";
290  }
291 
292  if (a_aerosol_mat.size() > 0) {
293  Print() << " Aerosols material:\n";
294  for (unsigned long i=0; i < a_aerosol_mat.size(); i++) {
295  Print() << " "
296  << getEnumNameString(a_aerosol_mat[i]->m_name)
297  << " (distribution: " << getEnumNameString(m_aerosol_init_type[i]);
298  if (m_aerosol_init_type[i] == SDDistributionType::mass_constant) {
299  Print() << ", value=" << m_mass_aerosol_mean[i];
300  AMREX_ALWAYS_ASSERT(m_mass_aerosol_mean[i] > zero);
301  } else if (m_aerosol_init_type[i] == SDDistributionType::mass_exponential) {
302  Print() << ", min=" << m_mass_aerosol_min[i]
303  << ", mean=" << m_mass_aerosol_mean[i]
304  << ", max=" << m_mass_aerosol_max[i];
305  AMREX_ALWAYS_ASSERT(m_mass_aerosol_min[i] > zero);
306  AMREX_ALWAYS_ASSERT(m_mass_aerosol_max[i] >= m_mass_aerosol_min[i]);
307  AMREX_ALWAYS_ASSERT( (m_mass_aerosol_mean[i] >= m_mass_aerosol_min[i])
308  && (m_mass_aerosol_mean[i] <= m_mass_aerosol_max[i]) );
309  } else if (m_aerosol_init_type[i] == SDDistributionType::radius_log_normal) {
310  Print() << ", min=" << m_radius_aerosol_min[i]
311  << ", max=" << m_radius_aerosol_max[i]
312  << ", mean=" << m_radius_aerosol_mean[i]
313  << ", std=" << m_radius_aerosol_geom_std[i];
314  AMREX_ALWAYS_ASSERT(m_radius_aerosol_min[i] > zero);
315  AMREX_ALWAYS_ASSERT(m_radius_aerosol_max[i] >= m_radius_aerosol_min[i]);
316  AMREX_ALWAYS_ASSERT( (m_radius_aerosol_mean[i] >= m_radius_aerosol_min[i])
317  && (m_radius_aerosol_mean[i] <= m_radius_aerosol_max[i]) );
318  } else if (m_aerosol_init_type[i] == SDDistributionType::radius_lognormal_autorange) {
319  Print() << ", mean=" << m_radius_aerosol_mean[i]
320  << ", std=" << m_radius_aerosol_geom_std[i];
321  AMREX_ALWAYS_ASSERT(m_radius_aerosol_mean[i] > zero);
322  }
323  Print() << ")" << "\n";
324  }
325  }
326 }
SDInitProperties::m_mult_type
SDMultiplicityType m_mult_type
Definition: ERF_SDInitialization.H:214
SDInitProperties::m_type
SDInitShape m_type
Definition: ERF_SDInitialization.H:159
SDInitProperties::m_ppc
int m_ppc
Definition: ERF_SDInitialization.H:156
SDInitProperties::m_particle_domain
amrex::RealBox m_particle_domain
Definition: ERF_SDInitialization.H:206
amrex
Definition: ERF_ConsoleIO.cpp:12

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 ( const std::string &  a_prefix,
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_prefixPrefix for parameter parser
[in]a_keyKey identifier for initialization parameters
[in]a_geomSimulation geometry information
[in]a_species_matVector of species material properties
[in]a_aerosol_matVector of aerosol material properties

Reimplemented in SDInitialization, and SDInjection.

81 {
82  BL_PROFILE("SDInitProperties::readInputs");
83  amrex::ignore_unused(a_geom);
84  using namespace amrex;
85 
86  amrex::ParmParse pp(a_prefix);
87  pp.query(std::string(a_key+"distribution_type").c_str(), m_type);
88  pp.query("maximum_multiplicity", m_max_multiplicity);
89  pp.query("multiplicity_type", m_mult_type);
90 
91  pp.query(std::string(a_key+"particles_per_cell").c_str(), m_ppc);
92 
93  if (m_type == SDInitShape::uniform) {
94 
95  pp.queryAdd("particle_box_lo", m_init_particle_p1, AMREX_SPACEDIM);
96  AMREX_ASSERT(m_init_particle_p1.size() == AMREX_SPACEDIM);
97 
98  pp.queryAdd("particle_box_hi", m_init_particle_p2, AMREX_SPACEDIM);
99  AMREX_ASSERT(m_init_particle_p2.size() == AMREX_SPACEDIM);
100 
101  m_particle_domain.setLo(m_init_particle_p1);
102  m_particle_domain.setHi(m_init_particle_p2);
103  } else if (m_type == SDInitShape::bubble){
104 
105  pp.queryAdd("particle_bubble_center", m_init_particle_p1, AMREX_SPACEDIM);
106  AMREX_ASSERT(m_init_particle_p1.size() == AMREX_SPACEDIM);
107 
108  pp.queryAdd("particle_bubble_radius", m_init_particle_p2, AMREX_SPACEDIM);
109  AMREX_ASSERT(m_init_particle_p2.size() == AMREX_SPACEDIM);
110 
111  m_particle_domain.setLo(m_init_particle_p1);
112  m_particle_domain.setHi(m_init_particle_p2);
113  }
114 
115  for (int i = 0; i < m_num_species; i++) {
116  {
117  std::string key = a_key+"species_distribution_type_"+getEnumNameString(a_species_mat[i]->m_name);
118  pp.query(key.c_str(), m_species_init_type[i]);
119  }
120  {
121  std::string key = a_key+"species_min_mass_" + getEnumNameString(a_species_mat[i]->m_name);
122  pp.query(key.c_str(), m_mass_species_min[i]);
123  }
124  {
125  std::string key = a_key+"species_mean_mass_" + getEnumNameString(a_species_mat[i]->m_name);
126  pp.query(key.c_str(), m_mass_species_mean[i]);
127  }
128  {
129  m_mass_species_max[i] = 5 * m_mass_species_mean[i]; // default
130  std::string key = a_key+"species_max_mass_" + getEnumNameString(a_species_mat[i]->m_name);
131  pp.query(key.c_str(), m_mass_species_max[i]);
132  }
133  {
134  std::string key = a_key+"species_min_radius_" + getEnumNameString(a_species_mat[i]->m_name);
135  pp.query(key.c_str(), m_radius_species_min[i]);
136  }
137  {
138  std::string key = a_key+"species_max_radius_" + getEnumNameString(a_species_mat[i]->m_name);
139  pp.query(key.c_str(), m_radius_species_max[i]);
140  }
141  {
142  std::string key = a_key+"species_mean_radius_" + getEnumNameString(a_species_mat[i]->m_name);
143  pp.query(key.c_str(), m_radius_species_mean[i]);
144  }
145  {
146  std::string key_std = a_key+"species_std_radius_" + getEnumNameString(a_species_mat[i]->m_name);
147  std::string key_gstd = a_key+"species_geomstd_radius_" + getEnumNameString(a_species_mat[i]->m_name);
148  if (pp.contains(key_std.c_str()) && pp.contains(key_gstd.c_str())) {
149  amrex::Abort("Cannot specify BOTH initial_species_std_radius and initial_species_geomstd_radius");
150  }
151  if (pp.contains(key_std.c_str())) {
152  pp.get(key_std.c_str(), m_radius_species_geom_std[i]);
153  m_radius_species_geom_std[i] = std::exp(m_radius_species_geom_std[i]);
154  } else {
155  pp.query(key_gstd.c_str(), m_radius_species_geom_std[i]);
156  }
157  }
158  }
159 
160  for (int i = 0; i < m_num_aerosols; i++) {
161  {
162  std::string key = a_key+"aerosol_distribution_type_"+getEnumNameString(a_aerosol_mat[i]->m_name);
163  pp.query(key.c_str(), m_aerosol_init_type[i]);
164  }
165  {
166  std::string key = a_key+"aerosol_min_mass_" + getEnumNameString(a_aerosol_mat[i]->m_name);
167  pp.query(key.c_str(), m_mass_aerosol_min[i]);
168  }
169  {
170  std::string key = a_key+"aerosol_mean_mass_" + getEnumNameString(a_aerosol_mat[i]->m_name);
171  pp.query(key.c_str(), m_mass_aerosol_mean[i]);
172  }
173  {
174  m_mass_aerosol_max[i] = 5 * m_mass_aerosol_mean[i]; // default
175  std::string key = a_key+"aerosol_max_mass_" + getEnumNameString(a_aerosol_mat[i]->m_name);
176  pp.query(key.c_str(), m_mass_aerosol_max[i]);
177  }
178  {
179  std::string key = a_key+"aerosol_min_radius_" + getEnumNameString(a_aerosol_mat[i]->m_name);
180  pp.query(key.c_str(), m_radius_aerosol_min[i]);
181  }
182  {
183  std::string key = a_key+"aerosol_max_radius_" + getEnumNameString(a_aerosol_mat[i]->m_name);
184  pp.query(key.c_str(), m_radius_aerosol_max[i]);
185  }
186  {
187  std::string key = a_key+"aerosol_mean_radius_" + getEnumNameString(a_aerosol_mat[i]->m_name);
188  pp.query(key.c_str(), m_radius_aerosol_mean[i]);
189  }
190  {
191  std::string key_std = a_key+"aerosol_std_radius_" + getEnumNameString(a_aerosol_mat[i]->m_name);
192  std::string key_gstd = a_key+"aerosol_geomstd_radius_" + getEnumNameString(a_aerosol_mat[i]->m_name);
193  if (pp.contains(key_std.c_str()) && pp.contains(key_gstd.c_str())) {
194  amrex::Abort("Cannot specify BOTH initial_species_std_radius and initial_species_geomstd_radius");
195  }
196  if (pp.contains(key_std.c_str())) {
197  pp.get(key_std.c_str(), m_radius_aerosol_geom_std[i]);
198  m_radius_aerosol_geom_std[i] = std::exp(m_radius_aerosol_geom_std[i]);
199  } else {
200  pp.query(key_gstd.c_str(), m_radius_aerosol_geom_std[i]);
201  }
202  }
203  }
204 
205 }
pp
ParmParse pp("prob")
SDInitProperties::m_init_particle_p1
amrex::Vector< amrex::Real > m_init_particle_p1
Definition: ERF_SDInitialization.H:210
SDInitProperties::m_num_species
int m_num_species
Definition: ERF_SDInitialization.H:201
SDInitProperties::m_init_particle_p2
amrex::Vector< amrex::Real > m_init_particle_p2
Definition: ERF_SDInitialization.H:211
SDInitProperties::m_num_aerosols
int m_num_aerosols
Definition: ERF_SDInitialization.H:203
SDInitProperties::m_max_multiplicity
amrex::Real m_max_multiplicity
Definition: ERF_SDInitialization.H:164

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
508  {
509  return (m_mult_type == SDMultiplicityType::sampled);
510  }

◆ 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_geomSimulation geometry information
[in]a_species_matVector of species material properties
[in]a_aerosol_matVector of aerosol material properties
9 {
10  BL_PROFILE("SDInitProperties::setDefaults");
11 
12  // Default
13  m_init_particle_p1.resize(AMREX_SPACEDIM);
14  m_init_particle_p2.resize(AMREX_SPACEDIM);
15  for (int i = 0; i < AMREX_SPACEDIM; i++) {
16  m_init_particle_p1[i] = a_geom.ProbLo(i);
17  m_init_particle_p2[i] = a_geom.ProbHi(i);
18  }
19 
20  m_num_species = a_species_mat.size();
21  m_mass_species_min.resize(m_num_species);
22  m_mass_species_max.resize(m_num_species);
23  m_mass_species_mean.resize(m_num_species);
24  m_radius_species_min.resize(m_num_species);
25  m_radius_species_max.resize(m_num_species);
26  m_radius_species_mean.resize(m_num_species);
27  m_radius_species_geom_std.resize(m_num_species);
28  m_species_init_type.resize(m_num_species);
29 
30  for (int i = 0; i < m_num_species; i++) {
31  // default values
32  m_species_init_type[i] = SDDistributionType::mass_constant;
33  if (a_species_mat[i]->m_is_water) {
34  m_mass_species_min[i] = amrex::Real(4.1887902e-42);
35  m_mass_species_max[i] = amrex::Real(4.1887902e-42);
36  m_mass_species_mean[i] = amrex::Real(4.1887902e-42);
37  m_radius_species_min[i] = amrex::Real(1.0e-15);
38  m_radius_species_max[i] = amrex::Real(1.0e-15);
39  m_radius_species_mean[i] = amrex::Real(1.0e-15);
40  } else {
41  m_mass_species_min[i] = zero;
42  m_mass_species_max[i] = zero;
43  m_mass_species_mean[i] = zero;
44  m_radius_species_min[i] = zero;
45  m_radius_species_max[i] = zero;
46  m_radius_species_mean[i] = zero;
47  }
48  m_radius_species_geom_std[i] = two;
49  }
50 
51  m_num_aerosols = a_aerosol_mat.size();
52  m_mass_aerosol_min.resize(m_num_aerosols);
53  m_mass_aerosol_max.resize(m_num_aerosols);
54  m_mass_aerosol_mean.resize(m_num_aerosols);
55  m_radius_aerosol_min.resize(m_num_aerosols);
56  m_radius_aerosol_max.resize(m_num_aerosols);
57  m_radius_aerosol_mean.resize(m_num_aerosols);
58  m_radius_aerosol_geom_std.resize(m_num_aerosols);
59  m_aerosol_init_type.resize(m_num_aerosols);
60 
61  for (int i = 0; i < m_num_aerosols; i++) {
62  // default values
63  m_aerosol_init_type[i] = SDDistributionType::mass_constant;
64  m_mass_aerosol_min[i] = zero;
65  m_mass_aerosol_max[i] = zero;
66  m_mass_aerosol_mean[i] = zero;
67  m_radius_aerosol_min[i] = amrex::Real(1.0e-9);
68  m_radius_aerosol_max[i] = amrex::Real(1.0e-6);
69  m_radius_aerosol_mean[i] = amrex::Real(1.0e-40);
70  m_radius_aerosol_geom_std[i] = two;
71  }
72 
73  m_mult_type = SDMultiplicityType::sampled;
74 }

◆ 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
520  {
521  amrex::Real vol = zero;
522  if (m_type == SDInitShape::uniform) {
523  vol = m_particle_domain.volume();
524  } else if (m_type == SDInitShape::bubble) {
525  const auto& radius = m_particle_domain.hi();
526  vol = four_thirds_pi*radius[0]*radius[1]*radius[2];
527  }
528  return vol;
529  }

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_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

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(), SDInjection::numParticlesPerCell(), SDInitialization::numParticlesPerCell(), SDInitialization::printParameters(), SDInitialization::readInputs(), SDInjection::readInputs(), and SDInjection::updateDt().

◆ 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

Referenced by SDInjection::numSDPerCell(), SDInitialization::numSDPerCell(), printParameters(), 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: