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, const int a_np, const amrex::Real a_density, const std::string &a_init_type, const amrex::Real a_mass_min, const amrex::Real a_mass_max, const amrex::Real a_mass_mean, const amrex::Real a_radius_min, const amrex::Real a_radius_max, const amrex::Real a_radius_mean, const 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, const amrex::Real a_dV, const int a_np, const amrex::Real a_density, const std::string &a_init_type, const amrex::Real a_mass_min, const amrex::Real a_mass_max, const amrex::Real a_mass_mean, const amrex::Real a_radius_min, const amrex::Real a_radius_max, const amrex::Real a_radius_mean, const 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...
 
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< std::string > 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< std::string > 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

◆ 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
240  {
241  getDistribution( a_mass,
242  a_mult,
243  a_dV,
244  a_np,
245  a_density,
246  m_aerosol_init_type[a_idx],
247  m_mass_aerosol_min[a_idx],
248  m_mass_aerosol_max[a_idx],
249  m_mass_aerosol_mean[a_idx],
250  m_radius_aerosol_min[a_idx],
251  m_radius_aerosol_max[a_idx],
252  m_radius_aerosol_mean[a_idx],
253  m_radius_aerosol_geom_std[a_idx],
254  a_rng);
255  }
SDInitProperties::m_radius_aerosol_geom_std
std::vector< amrex::Real > m_radius_aerosol_geom_std
Definition: ERF_SDInitialization.H:90
SDInitProperties::getDistribution
void getDistribution(amrex::Vector< amrex::Real > &a_mass, const int a_np, const amrex::Real a_density, const std::string &a_init_type, const amrex::Real a_mass_min, const amrex::Real a_mass_max, const amrex::Real a_mass_mean, const amrex::Real a_radius_min, const amrex::Real a_radius_max, const amrex::Real a_radius_mean, const amrex::Real a_radius_gstd, std::mt19937 &a_rng) const
Get a distribution with constant multiplicity.
Definition: ERF_SDInitialization.cpp:350
SDInitProperties::m_aerosol_init_type
std::vector< std::string > m_aerosol_init_type
Definition: ERF_SDInitialization.H:92
SDInitProperties::m_radius_aerosol_min
std::vector< amrex::Real > m_radius_aerosol_min
Definition: ERF_SDInitialization.H:84
SDInitProperties::m_radius_aerosol_max
std::vector< amrex::Real > m_radius_aerosol_max
Definition: ERF_SDInitialization.H:86
SDInitProperties::m_radius_aerosol_mean
std::vector< amrex::Real > m_radius_aerosol_mean
Definition: ERF_SDInitialization.H:88
SDInitProperties::m_mass_aerosol_min
std::vector< amrex::Real > m_mass_aerosol_min
Definition: ERF_SDInitialization.H:78
SDInitProperties::m_mass_aerosol_mean
std::vector< amrex::Real > m_mass_aerosol_mean
Definition: ERF_SDInitialization.H:82
SDInitProperties::m_mass_aerosol_max
std::vector< amrex::Real > m_mass_aerosol_max
Definition: ERF_SDInitialization.H:80
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
209  {
210  getDistribution( a_mass,
211  a_np,
212  a_density,
213  m_aerosol_init_type[a_idx],
214  m_mass_aerosol_min[a_idx],
215  m_mass_aerosol_max[a_idx],
216  m_mass_aerosol_mean[a_idx],
217  m_radius_aerosol_min[a_idx],
218  m_radius_aerosol_max[a_idx],
219  m_radius_aerosol_mean[a_idx],
220  m_radius_aerosol_geom_std[a_idx],
221  a_rng);
222  }
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,
const amrex::Real  a_dV,
const int  a_np,
const amrex::Real  a_density,
const std::string &  a_init_type,
const amrex::Real  a_mass_min,
const amrex::Real  a_mass_max,
const amrex::Real  a_mass_mean,
const amrex::Real  a_radius_min,
const amrex::Real  a_radius_max,
const amrex::Real  a_radius_mean,
const 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
418 {
419  a_mass.resize(a_np);
420  AMREX_ALWAYS_ASSERT(a_mult.size() == a_np);
421  if (a_init_type == SupDropInit::attrib_init_const) {
422  std::uniform_real_distribution<> urd(0.0, 1.0);
423  for (int n = 0; n < a_np; n++) {
424  a_mass[n] = a_mass_mean;
425  a_mult[n] += urd(a_rng); // initially this will be a non-integer; later we will rescale to an integer.
426  }
427  } else if (a_init_type == SupDropInit::attrib_init_exp) {
428  std::uniform_real_distribution<> urd(0.0, 1.0);
429  auto delta = a_mass_mean - a_mass_min;
430  auto lnrng = std::log(a_mass_max) - std::log(a_mass_min);
431  auto lnmin = std::log(a_mass_min);
432  for (int n = 0; n < a_np; n++) {
433  auto tmp = lnmin + urd(a_rng) * lnrng;
434  a_mass[n] = std::exp(tmp);
435  a_mult[n] += (m_numdens * a_dV) * std::exp(-a_mass[n] / delta);
436  }
437  } else if (a_init_type == SupDropInit::attrib_init_lnr) {
438  std::uniform_real_distribution<> urd(0.0, 1.0);
439  auto sigma = std::log(a_radius_gstd);
440  auto mu = a_radius_mean;
441  auto lnrng = std::log(a_radius_max) - std::log(a_radius_min);
442  auto lnmin = std::log(a_radius_min);
443  for (int n = 0; n < a_np; n++) {
444  auto tmp = lnmin + urd(a_rng) * lnrng;
445  auto dry_r = std::exp(tmp);
446  a_mass[n] = (4.0/3.0) * PI * dry_r * dry_r * dry_r * a_density;
447  auto term = std::exp(-std::log(dry_r/mu)*std::log(dry_r/mu)/(2.0*sigma*sigma));
448  a_mult[n] += ( m_numdens * a_dV ) / (sigma*std::sqrt(2*PI)) * term;
449  }
450  } else if (a_init_type == SupDropInit::attrib_init_lnr_auto) {
451  std::uniform_real_distribution<> urd(0.0, 1.0);
452  auto sigma = std::log(a_radius_gstd);
453  auto mu = a_radius_mean;
454  // automatically find the min and max radius of superdroplets, using Dziekan & Pawlowska 2017
455  auto rmin = 1e-9;
456  auto rmax = 1.0;
457  auto dlnr = (std::log(rmax) - std::log(rmin)) / a_np;
458  auto P_min = 0.0;
459  auto P_max = 1.0;
460  auto tol = 1.0 / (m_numdens * a_dV);
461  int a_np_tail = static_cast<int>(std::ceil(0.01*a_np)); // this is an approximation for now; saves 1% of SDs for the tail
462  amrex::Vector<amrex::Real> tmp_mass(a_np);
463  amrex::Vector<amrex::Real> tmp_mult(a_np);
464  amrex::Print() << "Finding aerosol radius sampling range\n";
465  while ((P_max >= 1.0 - tol) || (P_min <= tol)) {
466  if (P_max >= 1.0 - tol) {
467  rmax = rmax * 0.99;
468  }
469  if (P_min <= tol) {
470  rmin = rmin * 1.01;
471  }
472  P_min = (1 + std::erf((std::log(rmin / mu)) / sigma / std::sqrt(2))) / 2;
473  P_max = (1 + std::erf((std::log(rmax / mu)) / sigma / std::sqrt(2))) / 2;
474  }
475  dlnr = (std::log(rmax) - std::log(rmin));
476  amrex::Print() << "Range: rmin =" << rmin << ", rmax = " << rmax << ", dlnr = " << dlnr << "\n";
477 
478  // initialize the main distribution
479  amrex::Print() << "Initializing radii\n";
480  auto lnrmin = std::log(rmin);
481  for (int n = 0; n < a_np; n++) {
482  auto tmp = lnrmin + urd(a_rng)*dlnr;
483  auto dry_r = std::exp(tmp);
484  tmp_mass[n] = (4.0/3.0) * PI * dry_r * dry_r * dry_r * a_density;
485  auto term = std::exp(-std::log(dry_r/mu)*std::log(dry_r/mu)/(2.0*sigma*sigma));
486  tmp_mult[n] = (m_numdens * a_dV)/ (sigma*std::sqrt(2*PI)) * term;
487  }
488 
489  // initialize the tail using approximate erfinv
490  amrex::Print() << "Initializing tail: " << a_np_tail << " particles\n";
491  auto tail_mult = std::exp(-std::log(rmax/mu)*std::log(rmax/mu)/(2.0*sigma*sigma)) / (sigma*std::sqrt(2*PI));
492  for (int n = 0; n < a_np_tail; n++) {
493  int sd_id = static_cast<int>(std::round(urd(a_rng) * a_np));
494  auto tmp = P_max + (1.0 - P_max) * urd(a_rng);
495  auto tmp2 = SD_erfinv(2 * tmp - 1);
496  auto dry_r = mu * std::exp(sigma * std::sqrt(2) * tmp2);
497  tmp_mass[sd_id] = (4.0/3.0) * PI * dry_r * dry_r * dry_r * a_density;
498  // set the multiplicity to the same as for the 99th percentile aerosol
499  tmp_mult[sd_id] = (m_numdens * a_dV) * tail_mult;
500  }
501  // Update SD multiplicity and mass with the initialized main + tail distribution
502  for (int n = 0; n < a_np; n++) {
503  a_mult[n] += tmp_mult[n];
504  a_mass[n] += tmp_mass[n];
505  }
506  amrex::Print() << "Done sampling\n";
507  } else {
508  amrex::Abort("Unknown m_init_type!");
509  }
510 }
PI
constexpr amrex::Real PI
Definition: ERF_Constants.H:6
SD_erfinv
AMREX_GPU_HOST_DEVICE static AMREX_FORCE_INLINE amrex::Real SD_erfinv(const amrex::Real x)
Definition: ERF_SDInitialization.cpp:395
SDInitProperties::m_numdens
amrex::Real m_numdens
Definition: ERF_SDInitialization.H:56
MORRInd::mu
@ mu
Definition: ERF_AdvanceMorrison.cpp:87
SupDropInit::attrib_init_lnr_auto
const std::string attrib_init_lnr_auto
Definition: ERF_SDInitialization.H:35
SupDropInit::attrib_init_const
const std::string attrib_init_const
Definition: ERF_SDInitialization.H:32
SupDropInit::attrib_init_exp
const std::string attrib_init_exp
Definition: ERF_SDInitialization.H:33
SupDropInit::attrib_init_lnr
const std::string attrib_init_lnr
Definition: ERF_SDInitialization.H:34
Here is the call graph for this function:

◆ getDistribution() [2/2]

void SDInitProperties::getDistribution ( amrex::Vector< amrex::Real > &  a_mass,
const int  a_np,
const amrex::Real  a_density,
const std::string &  a_init_type,
const amrex::Real  a_mass_min,
const amrex::Real  a_mass_max,
const amrex::Real  a_mass_mean,
const amrex::Real  a_radius_min,
const amrex::Real  a_radius_max,
const amrex::Real  a_radius_mean,
const 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
362 {
363  a_mass.resize(a_np);
364  if (a_init_type == SupDropInit::attrib_init_const) {
365  for (int n = 0; n < a_np; n++) {
366  a_mass[n] = a_mass_mean;
367  }
368  } else if (a_init_type == SupDropInit::attrib_init_exp) {
369  auto delta = a_mass_mean - a_mass_min;
370  std::exponential_distribution<amrex::Real> ed(1.0/delta);
371  for (int n = 0; n < a_np; n++) {
372  a_mass[n] = ed(a_rng) + a_mass_min;
373  }
374  } else if (a_init_type == SupDropInit::attrib_init_lnr) {
375  std::normal_distribution<amrex::Real> nrd(std::log(a_radius_mean),
376  std::log(a_radius_gstd));
377  for (int n = 0; n < a_np; n++) {
378  auto dry_r = std::exp(nrd(a_rng));
379  int count = 0;
380  while ((dry_r < a_radius_min) || (dry_r > a_radius_max)) {
381  dry_r = std::exp(nrd(a_rng));
382  count++;
383  if (count > 100) { break; }
384  }
385  a_mass[n] = (4.0/3.0) * PI
386  * dry_r * dry_r * dry_r
387  * a_density;
388  }
389  } else {
390  amrex::Abort("Unknown a_init_type!");
391  }
392 }

Referenced by getAerosolDistribution(), and getSpeciesDistribution().

Here is the caller 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
300  {
301  getDistribution( a_mass,
302  a_mult,
303  a_dV,
304  a_np,
305  a_density,
306  m_species_init_type[a_idx],
307  m_mass_species_min[a_idx],
308  m_mass_species_max[a_idx],
309  m_mass_species_mean[a_idx],
310  m_radius_species_min[a_idx],
311  m_radius_species_max[a_idx],
312  m_radius_species_mean[a_idx],
313  m_radius_species_geom_std[a_idx],
314  a_rng);
315  }
SDInitProperties::m_radius_species_max
std::vector< amrex::Real > m_radius_species_max
Definition: ERF_SDInitialization.H:69
SDInitProperties::m_mass_species_max
std::vector< amrex::Real > m_mass_species_max
Definition: ERF_SDInitialization.H:63
SDInitProperties::m_species_init_type
std::vector< std::string > m_species_init_type
Definition: ERF_SDInitialization.H:75
SDInitProperties::m_radius_species_mean
std::vector< amrex::Real > m_radius_species_mean
Definition: ERF_SDInitialization.H:71
SDInitProperties::m_radius_species_geom_std
std::vector< amrex::Real > m_radius_species_geom_std
Definition: ERF_SDInitialization.H:73
SDInitProperties::m_mass_species_min
std::vector< amrex::Real > m_mass_species_min
Definition: ERF_SDInitialization.H:61
SDInitProperties::m_mass_species_mean
std::vector< amrex::Real > m_mass_species_mean
Definition: ERF_SDInitialization.H:65
SDInitProperties::m_radius_species_min
std::vector< amrex::Real > m_radius_species_min
Definition: ERF_SDInitialization.H:67
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
269  {
270  getDistribution( a_mass,
271  a_np,
272  a_density,
273  m_species_init_type[a_idx],
274  m_mass_species_min[a_idx],
275  m_mass_species_max[a_idx],
276  m_mass_species_mean[a_idx],
277  m_radius_species_min[a_idx],
278  m_radius_species_max[a_idx],
279  m_radius_species_mean[a_idx],
280  m_radius_species_geom_std[a_idx],
281  a_rng);
282  }
Here is the call 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.

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

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

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.

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

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
321  {
322  return (m_mult_type == SDMultiplicityType::sampled);
323  }

◆ 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] = SupDropInit::attrib_init_const;
33  m_mass_species_min[i] = 4.1887902e-42;
34  m_mass_species_max[i] = 4.1887902e-42;
35  m_mass_species_mean[i] = 4.1887902e-42;
36  m_radius_species_min[i] = 1.0e-15;
37  m_radius_species_max[i] = 1.0e-15;
38  m_radius_species_mean[i] = 1.0e-15;
39  m_radius_species_geom_std[i] = 2.0;
40  }
41 
42  m_num_aerosols = a_aerosol_mat.size();
43  m_mass_aerosol_min.resize(m_num_aerosols);
44  m_mass_aerosol_max.resize(m_num_aerosols);
45  m_mass_aerosol_mean.resize(m_num_aerosols);
46  m_radius_aerosol_min.resize(m_num_aerosols);
47  m_radius_aerosol_max.resize(m_num_aerosols);
48  m_radius_aerosol_mean.resize(m_num_aerosols);
49  m_radius_aerosol_geom_std.resize(m_num_aerosols);
50  m_aerosol_init_type.resize(m_num_aerosols);
51 
52  for (int i = 0; i < m_num_aerosols; i++) {
53  // default values
54  m_aerosol_init_type[i] = SupDropInit::attrib_init_const;
55  m_mass_aerosol_min[i] = 0.0;
56  m_mass_aerosol_max[i] = 0.0;
57  m_mass_aerosol_mean[i] = 0.0;
58  m_radius_aerosol_min[i] = 1.0e-9;
59  m_radius_aerosol_max[i] = 1.0e-6;
60  m_radius_aerosol_mean[i] = 1.0e-40;
61  m_radius_aerosol_geom_std[i] = 2.0;
62  }
63 
64  m_mult_type = SDMultiplicityType::sampled;
65 }

◆ 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
333  {
334  amrex::Real vol = 0.0;
335  if (m_type == SDInitShape::uniform) {
336  vol = m_particle_domain.volume();
337  } else if (m_type == SDInitShape::bubble) {
338  const auto& radius = m_particle_domain.hi();
339  vol = (4.0/3.0)*PI*radius[0]*radius[1]*radius[2];
340  }
341  return vol;
342  }
Real
amrex::Real Real
Definition: ERF_ShocInterface.H:19

Member Data Documentation

◆ m_aerosol_init_type

std::vector<std::string> SDInitProperties::m_aerosol_init_type

Initial distribution type for aerosol

Referenced by 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 getAerosolDistribution(), printParameters(), readInputs(), and setDefaults().

◆ m_mass_aerosol_mean

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

Mean aerosol mass

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

◆ m_mass_aerosol_min

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

Minimum aerosol mass

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

◆ m_mass_species_max

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

Maximum species mass

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

◆ m_mass_species_mean

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

Mean species mass

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

◆ m_mass_species_min

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

Minimum species mass

Referenced by 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(), 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 getAerosolDistribution(), printParameters(), readInputs(), and setDefaults().

◆ m_radius_aerosol_max

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

Maximum aerosol dry radius

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

◆ m_radius_aerosol_mean

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

Mean aerosol dry radius

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

◆ m_radius_aerosol_min

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

Minimum aerosol dry radius

Referenced by 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 getSpeciesDistribution(), printParameters(), readInputs(), and setDefaults().

◆ m_radius_species_max

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

Maximum species dry radius

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

◆ m_radius_species_mean

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

Mean species dry radius

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

◆ m_radius_species_min

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

Minimum species dry radius

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

◆ m_species_init_type

std::vector<std::string> SDInitProperties::m_species_init_type

Initial distribution type for species

Referenced by 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: