ERF_SDInitialization.H File Reference

#include <string>
#include <vector>
#include <random>
#include <AMReX_ParmParse.H>
#include <AMReX_Enum.H>
#include <AMReX_REAL.H>
#include <AMReX_RealBox.H>
#include <AMReX_Geometry.H>
#include <AMReX_Random.H>
#include <AMReX_GpuContainers.H>
#include "ERF_Constants.H"
#include "ERF_MaterialProperties.H"

Include dependency graph for ERF_SDInitialization.H:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	SDDistributionParams
	GPU-compatible structure holding distribution parameters. More...
class	SDInitProperties
	Super-droplets initial properties. More...
class	SDInjection
	Super-droplets initialization structure. More...
class	SDInitialization
	Super-droplets initialization structure. More...

Namespaces
	SupDropInit
	List of super-droplet initializations.

Functions
	AMREX_ENUM (SDInitShape, uniform, bubble, null)
	AMREX_ENUM (SDDistributionType, mass_constant, mass_exponential, radius_log_normal, radius_lognormal_autorange)
	Distribution type enum for GPU compatibility. More...
	AMREX_ENUM (SDMultiplicityType, constant, sampled)
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	SD_erfinv_gpu (const amrex::Real x)
	Inverse error function approximation for GPU. More...
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	SD_sample_mass_gpu (const SDDistributionParams &params, const amrex::RandomEngine &engine, amrex::Real &mult_contribution)
	Generate mass from distribution parameters on GPU. More...

Variables
const int	SupDropInit::num_species_max = 10
const int	SupDropInit::num_aerosols_max = 8

Function Documentation

AMREX_ENUM() [1/3]

AMREX_ENUM	(	SDDistributionType	,
		mass_constant	,
		mass_exponential	,
		radius_log_normal	,
		radius_lognormal_autorange
	)

Distribution type enum for GPU compatibility.

AMREX_ENUM() [2/3]

AMREX_ENUM	(	SDInitShape	,
		uniform	,
		bubble	,
		null
	)

AMREX_ENUM() [3/3]

AMREX_ENUM	(	SDMultiplicityType	,
		constant	,
		sampled
	)

SD_erfinv_gpu()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real SD_erfinv_gpu

(

const amrex::Real

x

)

Inverse error function approximation for GPU.

Parameters

[in]

x

Input value in (-1, 1)

Returns

Approximate inverse error function value

                                           {
    amrex::Real a = 0.147;
    amrex::Real eps = std::numeric_limits<amrex::Real>::epsilon();
    amrex::Real term = std::log(1 - x * x + eps);
    amrex::Real p1 = 2 / (PI * a) + term / 2.0;
    amrex::Real p2 = term / a;
    amrex::Real sign = (x >= 0) ? 1.0 : -1.0;
    return sign * std::sqrt(std::sqrt(p1 * p1 - p2) - p1);
}

Referenced by SD_sample_mass_gpu().

Here is the caller graph for this function:

SD_sample_mass_gpu()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real SD_sample_mass_gpu	(	const SDDistributionParams &	params,
		const amrex::RandomEngine &	engine,
		amrex::Real &	mult_contribution
	)

Generate mass from distribution parameters on GPU.

Parameters

[in]	params	Distribution parameters
[in]	engine	Random engine
[out]	mult_contribution	Contribution to multiplicity (added, not set)

Returns

Generated mass value

{
    using amrex::Random;
    amrex::Real mass = 0.0;
    amrex::Real u = Random(engine);
 
    switch (params.dist_type) {
        case SDDistributionType::mass_constant:
            mass = params.mass_mean;
            mult_contribution = u;  // Random [0,1] for later rescaling
            break;
 
        case SDDistributionType::mass_exponential: {
            if (params.sampled_mult) {
                // Sampled multiplicity: sample uniformly in log-space, weight by exponential PDF
                amrex::Real lnval = params.lnmin + u * params.lnrng;
                mass = std::exp(lnval);
                mult_contribution = (params.numdens * params.cell_volume) * std::exp(-mass / params.delta);
            } else {
                // Constant multiplicity: true exponential distribution via inverse transform
                // If U ~ Uniform(0,1), then -delta*ln(U) ~ Exponential(1/delta)
                mass = -params.delta * std::log(u) + params.mass_min;
                mult_contribution = 0.0;  // Not used for constant multiplicity
            }
            break;
        }
 
        case SDDistributionType::radius_log_normal:
        case SDDistributionType::radius_lognormal_autorange: {
            amrex::Real dry_r;
            if (params.sampled_mult) {
                // Sampled multiplicity: sample uniformly in log-space, weight by log-normal PDF
                amrex::Real lnval = params.lnmin + u * params.lnrng;
                dry_r = std::exp(lnval);
                // Log-normal PDF contribution for multiplicity weighting
                amrex::Real term = std::exp(-std::log(dry_r/params.radius_mean)*std::log(dry_r/params.radius_mean)
                                            /(2.0*params.sigma*params.sigma));
                mult_contribution = (params.numdens * params.cell_volume) / (params.sigma * std::sqrt(2.0*PI)) * term;
            } else {
                // Constant multiplicity: true log-normal via inverse CDF
                // Map u from [0,1] to [cdf_min, cdf_max] for truncated distribution
                amrex::Real u_trunc = params.cdf_min + u * (params.cdf_max - params.cdf_min);
                // Inverse CDF: r = mu * exp(sigma * sqrt(2) * erfinv(2*u - 1))
                amrex::Real z = SD_erfinv_gpu(2.0 * u_trunc - 1.0) * std::sqrt(2.0);
                dry_r = params.radius_mean * std::exp(params.sigma * z);
                mult_contribution = 0.0;  // Not used for constant multiplicity
            }
            mass = four_thirds_pi * dry_r * dry_r * dry_r * params.density;
            break;
        }
    }
    return mass;
}

Here is the call graph for this function: