walker namespace

Walker declarations and definitions.

Reference
- Namespaces
- Classes
- Typedefs
- Functions
- Variables

Everything that contributes to the walker executable.

Namespaces

namespace cmd: Walker command line grammar definition.
namespace ctr: Walker control facilitating user input to internal data transfer.
namespace deck: Walker input deck facilitating user input for integrating SDEs.

Classes

class CmdLineParser: CmdLineParser : StringParser.
class InputDeckParser: InputDeckParser : FileParser.
template<class Init, class Coefficients> class Beta: Beta SDE used polymorphically with DiffEq.
class BetaCoeffConst: Beta constant coefficients policity: constants in time.
template<class Init, class Coefficients> class MassFractionBeta: MassFractionBeta SDE used polymorphically with DiffEq.
class MassFractionBetaCoeffConst: Mass-fraction beta SDE constant coefficients policity: constants in time.
template<class Init, class Coefficients> class MixMassFractionBeta: MixMassFractionBeta SDE used polymorphically with DiffEq.
class MixMassFracBetaCoeffDecay: Mix mass-fraction beta SDE decay coefficients policy.
class MixMassFracBetaCoeffHomDecay: Mix mass-fraction beta SDE homogneous decay coefficients policy.
class MixMassFracBetaCoeffMonteCarloHomDecay: Mix mass-fraction beta SDE Monte Carlo homogenous decay coefficients policy.
class MixMassFracBetaCoeffHydroTimeScale: Mix mass-fraction beta SDE coefficients policy with DNS hydrodynamics time scale.
class MixMassFracBetaCoeffInstVel: Mix mass-fraction beta SDE coefficients policy coupled to velocity.
template<class Init, class Coefficients> class MixNumberFractionBeta: MixNumberFractionBeta SDE used polymorphically with DiffEq.
class MixNumFracBetaCoeffDecay: Mix number-fraction beta SDE decay coefficients policity.
template<class Init, class Coefficients> class NumberFractionBeta: NumberFractionBeta SDE used polymorphically with DiffEq.
class NumFracBetaCoeffConst: Number-fraction beta SDE constant coefficients policity: constants in time.
class DiffEq: Differential equation.
template<template<class, class> class Eq> struct registerDiffEq: Function object for registering a differential equation into the differential equation factory.
class DiffEqStack: Differential equations stack.
template<class Init, class Coefficients> class Dirichlet: Dirichlet SDE used polymorphically with DiffEq.
class DirichletCoeffConst: Dirichlet constant coefficients policity: constants in time.
template<class Init, class Coefficients> class GeneralizedDirichlet: Lochner's generalized Dirichlet SDE used polymorphically with DiffEq.
class GeneralizedDirichletCoeffConst: Generalized Dirichlet constant coefficients policity: constants in time.
template<class Init, class Coefficients> class MixDirichlet: MixDirichlet SDE used polymorphically with DiffEq.
class MixDirichletCoeffConst: MixDirichlet constant coefficients policity: constants in time.
class MixDirichletHomogeneous
class MixDirichletHydroTimeScale
template<class Init, class Coefficients> class Dissipation: Dissipation equation used polymorphically with DiffEq.
class DissipationCoeffConst: Dissipation equation coefficients policy keeping the coefficients constant.
class DissipationCoeffStationary: Dissipation equation coefficients policy keeping the dissipation rate in a constant statistically stationary state.
template<class Init, class Coefficients> class Gamma: Gamma SDE used polymorphically with DiffEq.
class GammaCoeffConst: Gamma constant coefficients policity: constants in time.
struct InitRaw: Raw initialization policy: leave memory uninitialized.
struct InitZero: Zero initialization policy: zero particle properties.
struct InitDelta: Delta initialization policy: put in delta-spikes as the joint PDF.
struct InitBeta: Beta initialization policy: generate samples from a joint beta PDF.
struct InitGaussian
struct InitCorrGaussian: Gaussian initialization policy: generate samples from a joint correlated Gaussian PDF.
struct InitGamma: Gamma initialization policy: generate samples from a joint gamma PDF.
struct InitDirichlet: Dirichlet initialization policy: generate samples from a Dirichlet PDF.
template<class Init, class Coefficients> class DiagOrnsteinUhlenbeck: Diagonal Ornstein-Uhlenbeck SDE used polymorphically with DiffEq.
class DiagOrnsteinUhlenbeckCoeffConst: Diagonal Ornstein-Uhlenbeck constant coefficients policity: constants in time.
template<class Init, class Coefficients> class OrnsteinUhlenbeck: Ornstein-Uhlenbeck SDE used polymorphically with DiffEq.
class OrnsteinUhlenbeckCoeffConst: Ornstein-Uhlenbeck constant coefficients policity: constants in time.
template<class Init, class Coefficients> class Position: Position equation used polymorphically with DiffEq.
class PositionInstVel: Position equation coefficients policy given by the instantaneous velocity.
class PositionConstShear: Position equation coefficients policy using a prescribed constant mean velocity gradient for homogeneous shear flow.
template<class Init, class Coefficients> class SkewNormal: Skew-normal SDE used polymorphically with DiffEq.
class SkewNormalCoeffConst: Skew-normal SDE constant coefficients policity: constants in time.
template<class Init, class Coefficients> class Velocity: Velocity SDE used polymorphically with DiffEq.
class VelocityCoeffConstShear
class VelocityCoeffStationary: Velocity equation coefficients policy yielding a statistically stationary state.
class VelocityCoeffHydroTimeScale
template<class Init, class Coefficients> class WrightFisher: Wright-Fisher SDE used polymorphically with DiffEq.
class WrightFisherCoeffConst: Wright-Fisher constant coefficients policity: constants in time.
class WalkerDriver: Walker driver used polymorphically with Driver.
class WalkerPrint: WalkerPrint : tk::RNGPrint.
class Collector
class Distributor: Distributor drives the time integration of differential equations.
class Integrator: Integrator Charm++ chare used to advance differential equations in time.

Typedefs

using BetaCoeffPolicies = brigand::list<BetaCoeffConst>: List of all beta's coefficients policies.
using MassFractionBetaCoeffPolicies = brigand::list<MassFractionBetaCoeffConst>: List of all mass-fraction beta's coefficients policies.
using MixMassFracBetaCoeffPolicies = brigand::list<MixMassFracBetaCoeffDecay, MixMassFracBetaCoeffHomDecay, MixMassFracBetaCoeffMonteCarloHomDecay, MixMassFracBetaCoeffHydroTimeScale, MixMassFracBetaCoeffInstVel>: List of all mix mass-fraction beta's coefficients policies.
using MixNumFracBetaCoeffPolicies = brigand::list<MixNumFracBetaCoeffDecay>: List of all mix numberf-fraction beta's coefficients policies.
using NumberFractionBetaCoeffPolicies = brigand::list<NumFracBetaCoeffConst>: List of all number-fraction beta's coefficients policies.
using DiffEqFactory = std::map<ctr::DiffEqKey, std::function<DiffEq(const tk::ctr::ncomp_t&)>>: Differential equation factory: keys associated to their constructors.
using DirichletCoeffPolicies = brigand::list<DirichletCoeffConst>: List of all Dirichlet's coefficients policies.
using GeneralizedDirichletCoeffPolicies = brigand::list<GeneralizedDirichletCoeffConst>: List of all generalized Dirichlet's coefficients policies.
using MixDirichletCoeffPolicies = brigand::list<MixDirichletCoeffConst, MixDirichletHomogeneous, MixDirichletHydroTimeScale>: List of all MixDirichlet's coefficients policies.
using DissipationCoeffPolicies = brigand::list<DissipationCoeffConst, DissipationCoeffStationary>: List of all dissipation eq coefficients policies.
using GammaCoeffPolicies = brigand::list<GammaCoeffConst>: List of all gamma's coefficients policies.
using InitPolicies = brigand::list<InitRaw, InitZero, InitDelta, InitBeta, InitGaussian, InitCorrGaussian, InitGamma, InitDirichlet>: List of all initialization policies.
using DiagOrnsteinUhlenbeckCoeffPolicies = brigand::list<DiagOrnsteinUhlenbeckCoeffConst>: List of all Ornstein-Uhlenbeck's coefficients policies.
using OrnsteinUhlenbeckCoeffPolicies = brigand::list<OrnsteinUhlenbeckCoeffConst>: List of all Ornstein-Uhlenbeck's coefficients policies.
using PositionCoeffPolicies = brigand::list<PositionInstVel, PositionConstShear>: List of all position eq coefficients policies.
using SkewNormalCoeffPolicies = brigand::list<SkewNormalCoeffConst>: List of all Skew-normal SDE's coefficients policies.
using VelocityCoeffPolicies = brigand::list<VelocityCoeffConstShear, VelocityCoeffStationary, VelocityCoeffHydroTimeScale>: List of all Velocity's coefficients policies.
using WrightFisherCoeffPolicies = brigand::list<WrightFisherCoeffConst>: List of all Wright-Fisher's coefficients policies.

Functions

void registerBeta(DiffEqFactory& f, std::set<ctr::DiffEqType>& t): Register beta SDE into DiffEq factory.
auto infoBeta(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt) -> std::vector<std::pair<std::string, std::string>>: Return information on the beta SDE.
void registerMassFractionBeta(DiffEqFactory& f, std::set<ctr::DiffEqType>& t): Register beta SDE into DiffEq factory.
auto infoMassFractionBeta(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt) -> std::vector<std::pair<std::string, std::string>>: Return information on the beta SDE.
void registerMixMassFractionBeta(DiffEqFactory& f, std::set<ctr::DiffEqType>& t): Register beta SDE into DiffEq factory.
auto infoMixMassFractionBeta(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt) -> std::vector<std::pair<std::string, std::string>>: Return information on the beta SDE.
void registerMixNumberFractionBeta(DiffEqFactory& f, std::set<ctr::DiffEqType>& t): Register beta SDE into DiffEq factory.
auto infoMixNumberFractionBeta(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt) -> std::vector<std::pair<std::string, std::string>>: Return information on the beta SDE.
void registerNumberFractionBeta(DiffEqFactory& f, std::set<ctr::DiffEqType>& t): Register beta SDE into DiffEq factory.
auto infoNumberFractionBeta(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt) -> std::vector<std::pair<std::string, std::string>>: Return information on the beta SDE.
template<typename eq, typename coupledeq, typename id> void coupledInfo(std::size_t system, std::string&& coupled_eq_name, std::vector<std::pair<std::string, std::string>> nfo)
template<typename eq, typename coupledeq> auto coupled(std::size_t system) -> bool
template<typename eq, typename coupledeq> auto depvar(std::size_t system) -> char
template<typename eq, typename coupledeq, typename id> auto system_id(std::size_t system) -> std::size_t
template<typename eq, typename coupledeq, typename id> auto offset(std::size_t system) -> std::size_t
template<typename eq, typename coupledeq, typename id> auto ncomp(std::size_t system) -> std::size_t
template<typename V> auto parameters(const V& v) -> std::string: Convert and return values from vector as string.
template<class Option, class OptTypeVec> auto options(const Option& opt, const OptTypeVec& v) -> std::string: Return names of options (tk::Toggle) from vector as a string.
template<typename Info, typename VV> void spikes(Info& nfo, const VV& spike): Insert spike information (used to specify delta PDFs) into info vector.
template<typename Info, typename VV> void betapdfs(Info& nfo, const VV& betapdf): Insert betapdf information (used to specify beta PDFs) into info vector.
void registerDirichlet(DiffEqFactory& f, std::set<ctr::DiffEqType>& t): Register Dirichlet SDE into DiffEq factory.
auto infoDirichlet(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt) -> std::vector<std::pair<std::string, std::string>>: Return information on the Dirichlet SDE.
void registerGenDir(DiffEqFactory& f, std::set<ctr::DiffEqType>& t): Register generalized Dirichlet SDE into DiffEq factory.
auto infoGenDir(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt) -> std::vector<std::pair<std::string, std::string>>: Return information on the generlized Dirichlet SDE.
void registerMixDirichlet(DiffEqFactory& f, std::set<ctr::DiffEqType>& t): Register MixDirichlet SDE into DiffEq factory.
auto infoMixDirichlet(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt) -> std::vector<std::pair<std::string, std::string>>: Return information on the MixDirichlet SDE.
auto MixDir_r(const std::vector<kw::sde_rho::info::expect::type>& rho, ctr::NormalizationType norm) -> std::vector<kw::sde_r::info::expect::type>: Compute parameter vector r based on r_i = rho_N/rho_i - 1.
void registerDissipation(DiffEqFactory& f, std::set<ctr::DiffEqType>& t): Register dissipation SDE into DiffEq factory.
auto infoDissipation(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt) -> std::vector<std::pair<std::string, std::string>>: Return information on the dissipation SDE.
void registerGamma(DiffEqFactory& f, std::set<ctr::DiffEqType>& t): Register gamma SDE into DiffEq factory.
auto infoGamma(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt) -> std::vector<std::pair<std::string, std::string>>: Return information on the gamma SDE.
void registerDiagOrnsteinUhlenbeck(DiffEqFactory& f, std::set<ctr::DiffEqType>& t): Register diagonal Ornstein-Uhlenbeck SDE into DiffEq factory.
auto infoDiagOrnsteinUhlenbeck(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt) -> std::vector<std::pair<std::string, std::string>>: Return information on the diagonal Ornstein-Uhlenbeck SDE.
void registerOrnsteinUhlenbeck(DiffEqFactory& f, std::set<ctr::DiffEqType>& t): Register Ornstein-Uhlenbeck SDE into DiffEq factory.
auto infoOrnsteinUhlenbeck(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt) -> std::vector<std::pair<std::string, std::string>>: Return information on the Ornstein-Uhlenbeck SDE.
void registerPosition(DiffEqFactory& f, std::set<ctr::DiffEqType>& t): Register position SDE into DiffEq factory.
auto infoPosition(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt) -> std::vector<std::pair<std::string, std::string>>: Return information on the position SDE.
void registerSkewNormal(DiffEqFactory& f, std::set<ctr::DiffEqType>& t): Register skew-normal SDE into DiffEq factory.
auto infoSkewNormal(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt) -> std::vector<std::pair<std::string, std::string>>: Return information on the skew-normal SDE.
void registerVelocity(DiffEqFactory& f, std::set<ctr::DiffEqType>& t): Register velocity SDE into DiffEq factory.
auto infoVelocity(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt) -> std::vector<std::pair<std::string, std::string>>: Return information on the velocity SDE.
auto slm(tk::real hts, tk::real C0) -> std::array<tk::real, 9>: Calculate the 2nd order tensor Gij based on the simplified Langevin model.
auto glm(tk::real hts, tk::real C0, const std::array<tk::real, 6>& rs, const std::array<tk::real, 9>& dU) -> std::array<tk::real, 9>: Calculate the 2nd order tensor Gij based on the generalized Langevin model.
auto reynoldsStress(char depvar, ctr::DepvarType solve, const std::map<tk::ctr::Product, tk::real>& moments) -> std::array<tk::real, 6>: Compute the Reynolds stress tensor.
auto tke(char depvar, ctr::DepvarType solve, const std::map<tk::ctr::Product, tk::real>& moments) -> tk::real: Compute the turbulent kinetic energy.
void registerWrightFisher(DiffEqFactory& f, std::set<ctr::DiffEqType>& t): Register Wright-Fisher SDE into DiffEq factory.
auto infoWrightFisher(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt) -> std::vector<std::pair<std::string, std::string>>: Return information on the Wright-Fisher SDE.
void operator|(PUP::er& p, std::map<tk::ctr::RawRNGType, tk::RNG>& rng)
void operator|(PUP::er& p, std::vector<DiffEq>& eqs)

Variables

ctr::InputDeck g_inputdeck
ctr::InputDeck g_inputdeck_defaults
std::map<tk::ctr::RawRNGType, tk::RNG> g_rng
const tk::Table<1> prod_A005H: Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous Rayleigh-Taylor instability. A = 0.05, IC: light << heavy.
const tk::Table<1> prod_A005S: Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous Rayleigh-Taylor instability. A = 0.05, IC: light = heavy.
const tk::Table<1> prod_A005L: Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous Rayleigh-Taylor instability. A = 0.05, IC: light >> heavy.
const tk::Table<1> prod_A05H: Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous Rayleigh-Taylor instability. A = 0.5, IC: light << heavy.
const tk::Table<1> prod_A05S: Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous Rayleigh-Taylor instability. A = 0.5, IC: light = heavy.
const tk::Table<1> prod_A05L: Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous Rayleigh-Taylor instability. A = 0.5, IC: light >> heavy.
const tk::Table<1> prod_A075H: Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous Rayleigh-Taylor instability. A = 0.75, IC: light << heavy.
const tk::Table<1> prod_A075S: Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous Rayleigh-Taylor instability. A = 0.75, IC: light = heavy.
const tk::Table<1> prod_A075L: Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous Rayleigh-Taylor instability. A = 0.75, IC: light >> heavy.
const tk::Table<1> invhts_eq_A005H: Inverse equilibrium hydrodynamics time scale from DNS of homogeneous Rayleigh-Taylor instability, tau_eq, A = 0.05, IC: light << heavy.
const tk::Table<1> invhts_eq_A005S: Inverse equilibrium hydrodynamics time scale from DNS of homogeneous Rayleigh-Taylor instability, tau_eq, A = 0.05, IC: light = heavy.
const tk::Table<1> invhts_eq_A005L: Inverse equilibrium hydrodynamics time scale from DNS of homogeneous Rayleigh-Taylor instability, tau_eq, A = 0.05, IC: light >> heavy.
const tk::Table<1> invhts_eq_A05H: Inverse equilibrium hydrodynamics time scale from DNS of homogeneous Rayleigh-Taylor instability, tau_eq, A = 0.5, IC: light << heavy.
const tk::Table<1> invhts_eq_A05S: Inverse equilibrium hydrodynamics time scale from DNS of homogeneous Rayleigh-Taylor instability, tau_eq, A = 0.5, IC: light = heavy.
const tk::Table<1> invhts_eq_A05L: Inverse equilibrium hydrodynamics time scale from DNS of homogeneous Rayleigh-Taylor instability, tau_eq, A = 0.5, IC: light >> heavy.
const tk::Table<1> invhts_eq_A075H: Inverse equilibrium hydrodynamics time scale from DNS of homogeneous Rayleigh-Taylor instability, tau_eq, A = 0.75, IC: light << heavy.
const tk::Table<1> invhts_eq_A075S: Inverse equilibrium hydrodynamics time scale from DNS of homogeneous Rayleigh-Taylor instability, tau_eq, A = 0.75, IC: light = heavy.
const tk::Table<1> invhts_eq_A075L: Inverse equilibrium hydrodynamics time scale from DNS of homogeneous Rayleigh-Taylor instability, tau_eq, A = 0.75, IC: light >> heavy.
std::vector<DiffEq> g_diffeqs
CProxy_Distributor g_DistributorProxy
CkReduction::reducerType PDFMerger: Charm++ PDF merger reducer.

Function documentation

void walker::registerBeta(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

Parameters
f in/out	Differential equation factory to register to
t in/out	Counters for equation types registered

std::vector<std::pair<std::string, std::string>> walker::infoBeta(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

Return information on the beta SDE.

Parameters
cnt in/out	std::map of counters for all differential equation types
Returns	vector of string pairs describing the SDE configuration

void walker::registerMassFractionBeta(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

Parameters
f in/out	Differential equation factory to register to
t in/out	Counters for equation types registered

std::vector<std::pair<std::string, std::string>> walker::infoMassFractionBeta(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

Return information on the beta SDE.

Parameters
cnt in/out	std::map of counters for all differential equation types
Returns	vector of string pairs describing the SDE configuration

void walker::registerMixMassFractionBeta(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

Parameters
f in/out	Differential equation factory to register to
t in/out	Counters for equation types registered

std::vector<std::pair<std::string, std::string>> walker::infoMixMassFractionBeta(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

Return information on the beta SDE.

Parameters
cnt in/out	std::map of counters for all differential equation types
Returns	vector of string pairs describing the SDE configuration

void walker::registerMixNumberFractionBeta(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

Parameters
f in/out	Differential equation factory to register to
t in/out	Counters for equation types registered

std::vector<std::pair<std::string, std::string>> walker::infoMixNumberFractionBeta(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

Return information on the beta SDE.

Parameters
cnt in/out	std::map of counters for all differential equation types
Returns	vector of string pairs describing the SDE configuration

void walker::registerNumberFractionBeta(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

Parameters
f in/out	Differential equation factory to register to
t in/out	Counters for equation types registered

std::vector<std::pair<std::string, std::string>> walker::infoNumberFractionBeta(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

Return information on the beta SDE.

Parameters
cnt in/out	std::map of counters for all differential equation types
Returns	vector of string pairs describing the SDE configuration

template<typename eq, typename coupledeq, typename id>
void walker::coupledInfo(std::size_t system, std::string&& coupled_eq_name, std::vector<std::pair<std::string, std::string>> nfo)

Template parameters
eq	Tag of the equation that is coupled
coupledeq	Tag of the equation that is coupled to equation 'eq'
id	Tag to access the coupled equation 'eq' (relative) ids, see tk::grm::couple in Control/Walker/InputDeck/Grammar.h
Parameters
system in	Relative equation system id of equation 'eq'
coupled_eq_name in	Coupled equation name
nfo in/out	Info vector to augment

template<typename eq, typename coupledeq>
bool walker::coupled(std::size_t system)

Template parameters
eq	Tag of the equation that is coupled
coupledeq	Tag of the equation that is coupled to equation 'eq'
Parameters
system in	Relative equation system id of equation 'eq'
Returns	True if equation 'eq' is coupled to equation 'coupledeq'

template<typename eq, typename coupledeq>
char walker::depvar(std::size_t system)

Template parameters
eq	Tag of the equation that is coupled
coupledeq	Tag of the equation that is coupled to equation 'eq'
Parameters
system in	Relative equation system id of equation 'eq'
Returns	Character (dependent variable) of equation coupled to equation 'eq'

template<typename eq, typename coupledeq, typename id>
std::size_t walker::system_id(std::size_t system)

Template parameters
eq	Tag of the equation that is coupled
coupledeq	Tag of the equation that is coupled to equation 'eq'
id	Tag to access the coupled equation 'eq' (relative) ids, see tk::grm::couple in Control/Walker/InputDeck/Grammar.h
Parameters
system in	Relative equation system id of equation 'eq'
Returns	Relative id of coupled equation of potentially multiple eqs

template<typename eq, typename coupledeq, typename id>
std::size_t walker::offset(std::size_t system)

Template parameters
eq	Tag of the equation that is coupled
coupledeq	Tag of the equation that is coupled to equation 'eq'
id	Tag to access the coupled equation 'eq' (relative) ids, see tk::grm::couple in Control/Walker/InputDeck/Grammar.h
Parameters
system in	Relative equation system id of equation 'eq'
Returns	System offset of coupled equation in tk::Data array of all systems

template<typename eq, typename coupledeq, typename id>
std::size_t walker::ncomp(std::size_t system)

Template parameters
eq	Tag of the equation that is coupled
coupledeq	Tag of the equation that is coupled to equation 'eq'
id	Tag to access the coupled equation 'eq' (relative) ids, see tk::grm::couple in Control/Walker/InputDeck/Grammar.h
Parameters
system in	Relative equation system id of equation 'eq'
Returns	Number of scalar components of coupled equation

template<typename V>
std::string walker::parameters(const V& v)

Convert and return values from vector as string.

Parameters
v in	Vector whose components to return as a string
Returns	Concatenated string of values read from a vector

template<class Option, class OptTypeVec>
std::string walker::options(const Option& opt, const OptTypeVec& v)

Return names of options (tk::Toggle) from vector as a string.

Parameters
opt in	Option instance (inheriting from tk::Toggle)
v in	Option vector whose names of components to return
Returns	Concatenated string of option names read from option vector

template<typename Info, typename VV>
void walker::spikes(Info& nfo, const VV& spike)

Insert spike information (used to specify delta PDFs) into info vector.

Parameters
nfo in/out	Info vector of string-pairs to insert to
spike in	Vector of vectors specifying spike info

template<typename Info, typename VV>
void walker::betapdfs(Info& nfo, const VV& betapdf)

Insert betapdf information (used to specify beta PDFs) into info vector.

Parameters
nfo in/out	Info vector of string-pairs to insert to
betapdf in	Vector of vectors specifying betapdf info

void walker::registerDirichlet(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

Parameters
f in/out	Differential equation factory to register to
t in/out	Counters for equation types registered

std::vector<std::pair<std::string, std::string>> walker::infoDirichlet(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

Return information on the Dirichlet SDE.

Parameters
cnt in/out	std::map of counters for all differential equation types
Returns	vector of string pairs describing the SDE configuration

void walker::registerGenDir(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

Parameters
f in/out	Differential equation factory to register to
t in/out	Counters for equation types registered

std::vector<std::pair<std::string, std::string>> walker::infoGenDir(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

Return information on the generlized Dirichlet SDE.

Parameters
cnt in/out	std::map of counters for all differential equation types
Returns	vector of string pairs describing the SDE configuration

void walker::registerMixDirichlet(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

Parameters
f in/out	Differential equation factory to register to
t in/out	Counters for equation types registered

std::vector<std::pair<std::string, std::string>> walker::infoMixDirichlet(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

Return information on the MixDirichlet SDE.

Parameters
cnt in/out	std::map of counters for all differential equation types
Returns	vector of string pairs describing the SDE configuration

std::vector<kw::sde_r::info::expect::type> walker::MixDir_r(const std::vector<kw::sde_rho::info::expect::type>& rho, ctr::NormalizationType norm)

Compute parameter vector r based on r_i = rho_N/rho_i - 1.

Parameters
rho in	Parameter vector rho to MixDirichlet
norm in	Normalization type (N=heavy or N=light)
Returns	Parameter vector r, determined by parameter vector rho

void walker::registerDissipation(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

Parameters
f in/out	Differential equation factory to register to
t in/out	Counters for equation types registered

std::vector<std::pair<std::string, std::string>> walker::infoDissipation(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

Return information on the dissipation SDE.

Parameters
cnt in/out	std::map of counters for all differential equation types
Returns	vector of string pairs describing the SDE configuration

void walker::registerGamma(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

Parameters
f in/out	Differential equation factory to register to
t in/out	Counters for equation types registered

std::vector<std::pair<std::string, std::string>> walker::infoGamma(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

Return information on the gamma SDE.

Parameters
cnt in/out	std::map of counters for all differential equation types
Returns	vector of string pairs describing the SDE configuration

void walker::registerDiagOrnsteinUhlenbeck(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

Parameters
f in/out	Differential equation factory to register to
t in/out	Counters for equation types registered

std::vector<std::pair<std::string, std::string>> walker::infoDiagOrnsteinUhlenbeck(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

Return information on the diagonal Ornstein-Uhlenbeck SDE.

Parameters
cnt in/out	std::map of counters for all differential equation types
Returns	vector of string pairs describing the SDE configuration

void walker::registerOrnsteinUhlenbeck(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

Parameters
f in/out	Differential equation factory to register to
t in/out	Counters for equation types registered

std::vector<std::pair<std::string, std::string>> walker::infoOrnsteinUhlenbeck(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

Return information on the Ornstein-Uhlenbeck SDE.

Parameters
cnt in/out	std::map of counters for all differential equation types
Returns	vector of string pairs describing the SDE configuration

void walker::registerPosition(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

Parameters
f in/out	Differential equation factory to register to
t in/out	Counters for equation types registered

std::vector<std::pair<std::string, std::string>> walker::infoPosition(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

Return information on the position SDE.

Parameters
cnt in/out	std::map of counters for all differential equation types
Returns	vector of string pairs describing the SDE configuration

void walker::registerSkewNormal(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

Parameters
f in/out	Differential equation factory to register to
t in/out	Counters for equation types registered

std::vector<std::pair<std::string, std::string>> walker::infoSkewNormal(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

Return information on the skew-normal SDE.

Parameters
cnt in/out	std::map of counters for all differential equation types
Returns	vector of string pairs describing the SDE configuration

void walker::registerVelocity(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

Parameters
f in/out	Differential equation factory to register to
t in/out	Counters for equation types registered

std::vector<std::pair<std::string, std::string>> walker::infoVelocity(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

Return information on the velocity SDE.

Parameters
cnt in/out	std::map of counters for all differential equation types
Returns	vector of string pairs describing the SDE configuration

std::array<tk::real, 9> walker::slm(tk::real hts, tk::real C0)

Calculate the 2nd order tensor Gij based on the simplified Langevin model.

Parameters
hts in	Inverse hydrodynamics time scale, e.g., eps/k
C0 in	Coefficient C0 in SLM
Returns	Tensor Gij computed based on the simplified Langevin model

std::array<tk::real, 9> walker::glm(tk::real hts, tk::real C0, const std::array<tk::real, 6>& rs, const std::array<tk::real, 9>& dU)

Calculate the 2nd order tensor Gij based on the generalized Langevin model.

Parameters
hts in	Inverse hydrodynamics time scale, e.g., eps/k
C0 in	Coefficient C0 in SLM
rs in	Reynolds stress
dU in	Mean velocity gradient
Returns	Tensor Gij computed based on the simplified Langevin model

std::array<tk::real, 6> walker::reynoldsStress(char depvar, ctr::DepvarType solve, const std::map<tk::ctr::Product, tk::real>& moments)

Compute the Reynolds stress tensor.

Parameters
depvar in	Dependent variable labeling a velocity eq
solve in	Enum selecting what the velocity eq solved for (fluctuating velocity of full/instantaneous veelocity)
moments in	Map of statistical moments
Returns	Symmetric part of the Reynolds stress tensor

tk::real walker::tke(char depvar, ctr::DepvarType solve, const std::map<tk::ctr::Product, tk::real>& moments)

Compute the turbulent kinetic energy.

Parameters
depvar in	Dependent variable labeling a velocity eq
solve in	Enum selecting what the velocity eq solved for (fluctuating velocity of full/instantaneous veelocity)
moments in	Map of statistical moments
Returns	Turbulent kinetic energy

void walker::registerWrightFisher(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

Parameters
f in/out	Differential equation factory to register to
t in/out	Counters for equation types registered

std::vector<std::pair<std::string, std::string>> walker::infoWrightFisher(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

Return information on the Wright-Fisher SDE.

Parameters
cnt in/out	std::map of counters for all differential equation types
Returns	vector of string pairs describing the SDE configuration

void walker::operator|(PUP::er& p, std::map<tk::ctr::RawRNGType, tk::RNG>& rng)

Pack/Unpack selected RNGs. This Pack/Unpack method (re-)creates the full RNG stack since it needs to (re-)bind function pointers on different processing elements. Therefore we circumvent Charm's usual pack/unpack for this type, and thus sizing does not make sense: sizing is a no-op. We could initialize the stack in RNGTestDriver's constructor and let this function re-create the stack only when unpacking, but that leads to repeating the same code twice: once in RNGTestDriver's constructor, once here. Another option is to use this pack/unpack routine to both initially create (when packing) and to re-create (when unpacking) the stack, which eliminates the need for pre-creating the object in RNGTestDriver's constructor and therefore eliminates the repeated code. This explains the guard for sizing: the code below is called for packing only (in serial) and packing and unpacking (in parallel).

void walker::operator|(PUP::er& p, std::vector<DiffEq>& eqs)

Pack/Unpack selected differential equations. This Pack/Unpack method (re-)creates the DiffEq factory since it needs to (re-)bind function pointers on different processing elements. Therefore we circumvent Charm's usual pack/unpack for this type, and thus sizing does not make sense: sizing is a no-op. We could initialize the factory in WalkerDriver's constructor and let this function re-create the stack only when unpacking, but that leads to repeating the same code twice: once in WalkerDriver's constructor, once here. Another option is to use this pack/unpack routine to both initially create (when packing) and to re-create (when unpacking) the factory, which eliminates the need for pre-creating the object in WalkerDriver's constructor and therefore eliminates the repeated code. This explains the guard for sizing: the code below is called for packing only (in serial) and packing and unpacking (in parallel).

Variable documentation

ctr::InputDeck walker::g_inputdeck

Input deck filled by parser, containing all input data

This object is in global scope, it contains all of user input, and thus it is made available to all PEs for convenience reasons. The runtime system distributes it to all PEs during initialization. Once distributed, the object does not change.

ctr::InputDeck walker::g_inputdeck_defaults

Global-scope data. Initialized by the main chare and distibuted to all PEs by the Charm++ runtime system. Though semantically not const, all these global data should be considered read-only. See also http://charm.cs.illinois.edu/manuals/html/charm++/manual.html. The data below is global-scope because they must be available to all PEs which could be on different machines. Defaults of input deck, facilitates detection what is set by user

This object is in global scope, it contains the default of all possible user input, and thus it is made available to all PEs for convenience reasons. The runtime system distributes it to all PEs during initialization. Once distributed, the object does not change.

std::map<tk::ctr::RawRNGType, tk::RNG> walker::g_rng

Random number generators selected by user

This map is in global scope, because it holds polymorphic objects, and thus must be distributed to all PEs during initialization. Once distributed by the runtime system, the objects do not change.

const tk::Table<1> walker::prod_A005H

Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous Rayleigh-Taylor instability. A = 0.05, IC: light << heavy.

Definition of turbulent kinetic energy production:

where is the turbulent kinetic energy and is the the dissipation rate of turbulent kinetic energy. The data contains P/eps, a measure of the non-equilibrium nature of the turbulent flow.

Configuration:

Atwood number = 0.05
Initial condition: light << heavy, Ytilde = 0.25

Produced from DNS data in two steps:

In gnuplot:

gnuplot> set table "prod_A0.05_H"
gnuplot> d2(x,y) = ($0 == 0) ? (x1 = x, y1 = y, 1/0) : (x2 = x1, x1 = x, y2 = y1, y1 = y, (y1-y2)/(x1-x2)); dx = 0.005; plot [0.01:100] "< paste asymmetric_runs/0.05_H/M_stats/Mktaib.dat asymmetric_runs/0.05_H/M_stats/Mrhokeq.dat asymmetric_runs/0.05_H/stats/var.dat asymmetric_runs/0.05_H/stats/avg.dat asymmetric_runs/0.05_H/M_stats/Mskew.dat" u 1:((d2($1,$2)-$12/$23)/(-$12/$23)) w lp pt 7 ps 0.5 t "P/e, H, Yt=0.25"
gnuplot> unset table

In unix shell: cat prod_A0.05_H | awk '{print "{ " $1 ", " $2 " }," }'

The resulting data is simply a y = f(x) function, where the x is the first, and the y is the second column. The x column is assumed to be in increasing order.

const tk::Table<1> walker::prod_A005S

Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous Rayleigh-Taylor instability. A = 0.05, IC: light = heavy.

Definition of turbulent kinetic energy production:

where is the turbulent kinetic energy and is the the dissipation rate of turbulent kinetic energy. The data contains P/eps, a measure of the non-equilibrium nature of the turbulent flow.

Configuration:

Atwood number = 0.05
Initial condition: light = heavy, Ytilde = 0.48

Produced from DNS data in two steps:

In gnuplot:

gnuplot> set table "prod_A0.05_S"
gnuplot> d2(x,y) = ($0 == 0) ? (x1 = x, y1 = y, 1/0) : (x2 = x1, x1 = x, y2 = y1, y1 = y, (y1-y2)/(x1-x2)); dx = 0.005; plot [0.01:100] "< paste sym_runs/0.05/M_stats/Mktaib.dat sym_runs/0.05/M_stats/Mrhokeq.dat sym_runs/0.05/stats/var.dat sym_runs/0.05/stats/avg.dat sym_runs/0.05/M_stats/Mskew.dat" u 1:((d2($1,$2)-$12/$23)/(-$12/$23)) w lp pt 7 ps 0.5 t "P/e, S, Yt=0.48"
gnuplot> unset table

In unix shell: cat prod_A0.05_S | awk '{print "{ " $1 ", " $2 " }," }'

The resulting data is simply a y = f(x) function, where the x is the first, and the y is the second column. The x column is assumed to be in increasing order.

const tk::Table<1> walker::prod_A005L

Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous Rayleigh-Taylor instability. A = 0.05, IC: light >> heavy.

Definition of turbulent kinetic energy production:

where is the turbulent kinetic energy and is the the dissipation rate of turbulent kinetic energy. The data contains P/eps, a measure of the non-equilibrium nature of the turbulent flow.

Configuration:

Atwood number = 0.05
Initial condition: light >> heavy, Ytilde = 0.723

Produced from DNS data in two steps:

In gnuplot:

gnuplot> set table "prod_A0.05_L"
gnuplot> d2(x,y) = ($0 == 0) ? (x1 = x, y1 = y, 1/0) : (x2 = x1, x1 = x, y2 = y1, y1 = y, (y1-y2)/(x1-x2)); dx = 0.005; plot [0.01:] "< paste asymmetric_runs/0.05_L/M_stats/Mktaib.dat asymmetric_runs/0.05_L/M_stats/Mrhokeq.dat asymmetric_runs/0.05_L/stats/var.dat asymmetric_runs/0.05_L/stats/avg.dat asymmetric_runs/0.05_L/M_stats/Mskew.dat" u 1:((d2($1,$2)-$12/$23)/(-$12/$23)) w lp pt 7 ps 0.5 t "P/e, L, Yt=0.723"
gnuplot> unset table

In unix shell: cat prod_A0.05_L | awk '{print "{ " $1 ", " $2 " }," }'

The resulting data is simply a y = f(x) function, where the x is the first, and the y is the second column. The x column is assumed to be in increasing order.

const tk::Table<1> walker::prod_A05H

Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous Rayleigh-Taylor instability. A = 0.5, IC: light << heavy.

Definition of turbulent kinetic energy production:

where is the turbulent kinetic energy and is the the dissipation rate of turbulent kinetic energy. The data contains P/eps, a measure of the non-equilibrium nature of the turbulent flow.

Configuration:

Atwood number = 0.5
Initial condition: light << heavy, Ytilde = 0.1

Produced from DNS data in two steps:

In gnuplot:

gnuplot> set table "prod_A0.5_H"
gnuplot> d2(x,y) = ($0 == 0) ? (x1 = x, y1 = y, 1/0) : (x2 = x1, x1 = x, y2 = y1, y1 = y, (y1-y2)/(x1-x2)); dx = 0.005; plot [0.01:30] "< paste asymmetric_runs/0.5_H/M_stats/Mktaib.dat asymmetric_runs/0.5_H/M_stats/Mrhokeq.dat asymmetric_runs/0.5_H/stats/var.dat asymmetric_runs/0.5_H/stats/avg.dat asymmetric_runs/0.5_H/M_stats/Mskew.dat" u 1:((d2($1,$2)-$12/$23)/(-$12/$23)) w lp pt 7 ps 0.5 t "P/e, H, Yt=0.1"
gnuplot> unset table

In unix shell: cat prod_A0.5_H | awk '{print "{ " $1 ", " $2 " }," }'

The resulting data is simply a y = f(x) function, where the x is the first, and the y is the second column. The x column is assumed to be in increasing order.

const tk::Table<1> walker::prod_A05S

Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous Rayleigh-Taylor instability. A = 0.5, IC: light = heavy.

Definition of turbulent kinetic energy production:

where is the turbulent kinetic energy and is the the dissipation rate of turbulent kinetic energy. The data contains P/eps, a measure of the non-equilibrium nature of the turbulent flow.

Configuration:

Atwood number = 0.5
Initial condition: light = heavy, Ytilde = 0.25

Produced from DNS data in two steps:

In gnuplot:

gnuplot> set table "prod_A0.5_S"
gnuplot> d2(x,y) = ($0 == 0) ? (x1 = x, y1 = y, 1/0) : (x2 = x1, x1 = x, y2 = y1, y1 = y, (y1-y2)/(x1-x2)); dx = 0.005; plot [0.01:40] "< paste sym_runs/0.5/M_stats/Mktaib.dat sym_runs/0.5/M_stats/Mrhokeq.dat sym_runs/0.5/stats/var.dat sym_runs/0.5/stats/avg.dat sym_runs/0.5/M_stats/Mskew.dat" u 1:((d2($1,$2)-$12/$23)/(-$12/$23)) w lp pt 7 ps 0.5 t "P/e, S, Yt=0.25"
gnuplot> unset table

In unix shell: cat prod_A0.5_S | awk '{print "{ " $1 ", " $2 " }," }'

The resulting data is simply a y = f(x) function, where the x is the first, and the y is the second column. The x column is assumed to be in increasing order.

const tk::Table<1> walker::prod_A05L

Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous Rayleigh-Taylor instability. A = 0.5, IC: light >> heavy.

Definition of turbulent kinetic energy production:

where is the turbulent kinetic energy and is the the dissipation rate of turbulent kinetic energy. The data contains P/eps, a measure of the non-equilibrium nature of the turbulent flow.

Configuration:

Atwood number = 0.5
Initial condition: light = heavy, Ytilde = 0.49

Produced from DNS data in two steps:

In gnuplot:

gnuplot> set table "prod_A0.5_L"
gnuplot> d2(x,y) = ($0 == 0) ? (x1 = x, y1 = y, 1/0) : (x2 = x1, x1 = x, y2 = y1, y1 = y, (y1-y2)/(x1-x2)); dx = 0.005; plot [0.01:] "< paste asymmetric_runs/0.5_L/M_stats/Mktaib.dat asymmetric_runs/0.5_L/M_stats/Mrhokeq.dat asymmetric_runs/0.5_L/stats/var.dat asymmetric_runs/0.5_L/stats/avg.dat asymmetric_runs/0.5_L/M_stats/Mskew.dat" u 1:((d2($1,$2)-$12/$23)/(-$12/$23)) w lp pt 7 ps 0.5 t "P/e, L, Yt=0.49"
gnuplot> unset table

In unix shell: cat prod_A0.5_L | awk '{print "{ " $1 ", " $2 " }," }'

The resulting data is simply a y = f(x) function, where the x is the first, and the y is the second column. The x column is assumed to be in increasing order.

const tk::Table<1> walker::prod_A075H

Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous Rayleigh-Taylor instability. A = 0.75, IC: light << heavy.

Definition of turbulent kinetic energy production:

where is the turbulent kinetic energy and is the the dissipation rate of turbulent kinetic energy. The data contains P/eps, a measure of the non-equilibrium nature of the turbulent flow.

Configuration:

Atwood number = 0.75
Initial condition: light << heavy, Ytilde = 0.049

Produced from DNS data in two steps:

In gnuplot:

gnuplot> set table "prod_A0.75_H"
gnuplot> d2(x,y) = ($0 == 0) ? (x1 = x, y1 = y, 1/0) : (x2 = x1, x1 = x, y2 = y1, y1 = y, (y1-y2)/(x1-x2)); dx = 0.005; plot [0.01:30] "< paste asymmetric_runs/0.75_H/M_stats/Mktaib.dat asymmetric_runs/0.75_H/M_stats/Mrhokeq.dat asymmetric_runs/0.75_H/stats/var.dat asymmetric_runs/0.75_H/stats/avg.dat asymmetric_runs/0.75_H/M_stats/Mskew.dat" u 1:((d2($1,$2)-$12/$23)/(-$12/$23)) w lp pt 7 ps 0.5 t "P/e, H, Yt=0.049"
gnuplot> unset table

In unix shell: cat prod_A0.75_H | awk '{print "{ " $1 ", " $2 " }," }'

The resulting data is simply a y = f(x) function, where the x is the first, and the y is the second column. The x column is assumed to be in increasing order.

const tk::Table<1> walker::prod_A075S

Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous Rayleigh-Taylor instability. A = 0.75, IC: light = heavy.

Definition of turbulent kinetic energy production:

where is the turbulent kinetic energy and is the the dissipation rate of turbulent kinetic energy. The data contains P/eps, a measure of the non-equilibrium nature of the turbulent flow.

Configuration:

Atwood number = 0.75
Initial condition: light = heavy, Ytilde = 0.127

Produced from DNS data in two steps:

In gnuplot:

gnuplot> set table "prod_A0.75_S"
gnuplot> d2(x,y) = ($0 == 0) ? (x1 = x, y1 = y, 1/0) : (x2 = x1, x1 = x, y2 = y1, y1 = y, (y1-y2)/(x1-x2)); dx = 0.005; plot [0.01:30] "< paste sym_runs/0.75/M_stats/Mktaib.dat sym_runs/0.75/M_stats/Mrhokeq.dat sym_runs/0.75/stats/var.dat sym_runs/0.75/stats/avg.dat sym_runs/0.75/M_stats/Mskew.dat" u 1:((d2($1,$2)-$12/$23)/(-$12/$23)) w lp pt 7 ps 0.5 t "P/e, S, Yt=0.127"
gnuplot> unset table

In unix shell: cat prod_A0.75_S | awk '{print "{ " $1 ", " $2 " }," }'

The resulting data is simply a y = f(x) function, where the x is the first, and the y is the second column. The x column is assumed to be in increasing order.

const tk::Table<1> walker::prod_A075L

Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous Rayleigh-Taylor instability. A = 0.75, IC: light >> heavy.

Definition of turbulent kinetic energy production:

where is the turbulent kinetic energy and is the the dissipation rate of turbulent kinetic energy. The data contains P/eps, a measure of the non-equilibrium nature of the turbulent flow.

Configuration:

Atwood number = 0.75
Initial condition: light = heavy, Ytilde = 0.291

Produced from DNS data in two steps:

In gnuplot:

gnuplot> set table "prod_A0.75_L"
gnuplot> d2(x,y) = ($0 == 0) ? (x1 = x, y1 = y, 1/0) : (x2 = x1, x1 = x, y2 = y1, y1 = y, (y1-y2)/(x1-x2)); dx = 0.005; plot [0.01:35] "< paste asymmetric_runs/0.75_L/M_stats/Mktaib.dat asymmetric_runs/0.75_L/M_stats/Mrhokeq.dat asymmetric_runs/0.75_L/stats/var.dat asymmetric_runs/0.75_L/stats/avg.dat asymmetric_runs/0.75_L/M_stats/Mskew.dat" u 1:((d2($1,$2)-$12/$23)/(-$12/$23)) w lp pt 7 ps 0.5 t "P/e, L, Yt=0.291"
gnuplot> unset table

In unix shell: cat prod_A0.75_L | awk '{print "{ " $1 ", " $2 " }," }'

The resulting data is simply a y = f(x) function, where the x is the first, and the y is the second column. The x column is assumed to be in increasing order.

const tk::Table<1> walker::invhts_eq_A005H

Inverse equilibrium hydrodynamics time scale from DNS of homogeneous Rayleigh-Taylor instability, tau_eq, A = 0.05, IC: light << heavy.

Deffinition of this time scale:

Configuration:

Atwood number = 0.05
Initial condition: light << heavy, Ytilde = 0.25

Produced from DNS data in two steps:

In gnuplot:

gnuplot> set table "eok_A0.05_H"
gnuplot> plot "< paste asymmetric_runs/0.05_H/M_stats/Mktaib.dat asymmetric_runs/0.05_H/M_stats/Mrhokeq.dat asymmetric_runs/0.05_H/stats/var.dat asymmetric_runs/0.05_H/stats/avg.dat asymmetric_runs/0.05_H/M_stats/Mskew.dat" u 1:((-$12/$23)/$2) pt 7 ps 0.5 t "eps/k H, Yt=0.25"
gnuplot> unset table

In unix shell: cat eok_A0.05_H | awk '{print "{ " $1 ", " $2 " }," }'

The resulting data is simply a y = f(x) function, where the x is the first, and the y is the second column. The x column is assumed to be in increasing order.

const tk::Table<1> walker::invhts_eq_A005S

Inverse equilibrium hydrodynamics time scale from DNS of homogeneous Rayleigh-Taylor instability, tau_eq, A = 0.05, IC: light = heavy.

Deffinition of this time scale:

Configuration:

Atwood number = 0.05
Initial condition: light = heavy, Ytilde = 0.48

Produced from DNS data in two steps:

In gnuplot:

gnuplot> set table "eok_A0.05_S"
gnuplot> plot "< paste sym_runs/0.05/M_stats/Mktaib.dat sym_runs/0.05/M_stats/Mrhokeq.dat sym_runs/0.05/stats/var.dat sym_runs/0.05/stats/avg.dat sym_runs/0.05/M_stats/Mskew.dat" u 1:((-$12/$23)/$2) pt 7 ps 0.5 t "eps/k S, Yt=0.48"
gnuplot> unset table

In unix shell: cat eok_A0.05_S | awk '{print "{ " $1 ", " $2 " }," }'

The resulting data is simply a y = f(x) function, where the x is the first, and the y is the second column. The x column is assumed to be in increasing order.

const tk::Table<1> walker::invhts_eq_A005L

Inverse equilibrium hydrodynamics time scale from DNS of homogeneous Rayleigh-Taylor instability, tau_eq, A = 0.05, IC: light >> heavy.

Deffinition of this time scale:

Configuration:

Atwood number = 0.05
Initial condition: light >> heavy, Ytilde = 0.723

Produced from DNS data in two steps:

In gnuplot:

gnuplot> set table "eok_A0.05_L"
gnuplot> plot "< paste asymmetric_runs/0.05_L/M_stats/Mktaib.dat asymmetric_runs/0.05_L/M_stats/Mrhokeq.dat asymmetric_runs/0.05_L/stats/var.dat asymmetric_runs/0.05_L/stats/avg.dat asymmetric_runs/0.05_L/M_stats/Mskew.dat" u 1:((-$12/$23)/$2) pt 7 ps 0.5 t "eps/k H, Yt=0.723"
gnuplot> unset table

In unix shell: cat eok_A0.05_L | awk '{print "{ " $1 ", " $2 " }," }'

The resulting data is simply a y = f(x) function, where the x is the first, and the y is the second column. The x column is assumed to be in increasing order.

const tk::Table<1> walker::invhts_eq_A05H

Inverse equilibrium hydrodynamics time scale from DNS of homogeneous Rayleigh-Taylor instability, tau_eq, A = 0.5, IC: light << heavy.

Deffinition of this time scale:

Configuration:

Atwood number = 0.5
Initial condition: light << heavy, Ytilde = 0.107

Produced from DNS data in two steps:

In gnuplot:

gnuplot> set table "eok_A0.5_H"
gnuplot> plot "< paste asymmetric_runs/0.5_H/M_stats/Mktaib.dat asymmetric_runs/0.5_H/M_stats/Mrhokeq.dat asymmetric_runs/0.5_H/stats/var.dat asymmetric_runs/0.5_H/stats/avg.dat asymmetric_runs/0.5_H/M_stats/Mskew.dat" u 1:((-$12/$23)/$2) pt 7 ps 0.5 t "eps/k H, Yt=0.107"
gnuplot> unset table

In unix shell: cat eok_A0.5_H | awk '{print "{ " $1 ", " $2 " }," }'

The resulting data is simply a y = f(x) function, where the x is the first, and the y is the second column. The x column is assumed to be in increasing order.

const tk::Table<1> walker::invhts_eq_A05S

Inverse equilibrium hydrodynamics time scale from DNS of homogeneous Rayleigh-Taylor instability, tau_eq, A = 0.5, IC: light = heavy.

Deffinition of this time scale:

Configuration:

Atwood number = 0.5
Initial condition: light = heavy, Ytilde = 0.25

Produced from DNS data in two steps:

In gnuplot:

gnuplot> set table "eok_A0.5_S"
gnuplot> plot "< paste sym_runs/0.5/M_stats/Mktaib.dat sym_runs/0.5/M_stats/Mrhokeq.dat sym_runs/0.5/stats/var.dat sym_runs/0.5/stats/avg.dat sym_runs/0.5/M_stats/Mskew.dat" u 1:((-$12/$23)/$2) pt 7 ps 0.5 t "eps/k S, Yt=0.25"
gnuplot> unset table

In unix shell: cat eok_A0.5_S | awk '{print "{ " $1 ", " $2 " }," }'

The resulting data is simply a y = f(x) function, where the x is the first, and the y is the second column. The x column is assumed to be in increasing order.

const tk::Table<1> walker::invhts_eq_A05L

Inverse equilibrium hydrodynamics time scale from DNS of homogeneous Rayleigh-Taylor instability, tau_eq, A = 0.5, IC: light >> heavy.

Deffinition of this time scale:

Configuration:

Atwood number = 0.5
Initial condition: light >> heavy, Ytilde = 0.49

Produced from DNS data in two steps:

In gnuplot:

gnuplot> set table "eok_A0.5_L"
gnuplot> plot "< paste asymmetric_runs/0.5_L/M_stats/Mktaib.dat asymmetric_runs/0.5_L/M_stats/Mrhokeq.dat asymmetric_runs/0.5_L/stats/var.dat asymmetric_runs/0.5_L/stats/avg.dat asymmetric_runs/0.5_L/M_stats/Mskew.dat" u 1:((-$12/$23)/$2) pt 7 ps 0.5 t "eps/k H, Yt=0.49"
gnuplot> unset table

In unix shell: cat eok_A0.5_L | awk '{print "{ " $1 ", " $2 " }," }'

The resulting data is simply a y = f(x) function, where the x is the first, and the y is the second column. The x column is assumed to be in increasing order.

const tk::Table<1> walker::invhts_eq_A075H

Inverse equilibrium hydrodynamics time scale from DNS of homogeneous Rayleigh-Taylor instability, tau_eq, A = 0.75, IC: light << heavy.

Deffinition of this time scale:

Configuration:

Atwood number = 0.75
Initial condition: light << heavy, Ytilde = 0.049

Produced from DNS data in two steps:

In gnuplot:

gnuplot> set table "eok_A0.75_H"
gnuplot> plot "< paste asymmetric_runs/0.75_H/M_stats/Mktaib.dat asymmetric_runs/0.75_H/M_stats/Mrhokeq.dat asymmetric_runs/0.75_H/stats/var.dat asymmetric_runs/0.75_H/stats/avg.dat asymmetric_runs/0.75_H/M_stats/Mskew.dat" u 1:((-$12/$23)/$2) pt 7 ps 0.5 t "eps/k H, Yt=0.049"
gnuplot> unset table

In unix shell: cat eok_A0.75_H | awk '{print "{ " $1 ", " $2 " }," }'

The resulting data is simply a y = f(x) function, where the x is the first, and the y is the second column. The x column is assumed to be in increasing order.

const tk::Table<1> walker::invhts_eq_A075S

Inverse equilibrium hydrodynamics time scale from DNS of homogeneous Rayleigh-Taylor instability, tau_eq, A = 0.75, IC: light = heavy.

Deffinition of this time scale:

Configuration:

Atwood number = 0.75
Initial condition: light = heavy, Ytilde = 0.127

Produced from DNS data in two steps:

In gnuplot:

gnuplot> set table "eok_A0.75_S"
gnuplot> plot "< paste sym_runs/0.75/M_stats/Mktaib.dat sym_runs/0.75/M_stats/Mrhokeq.dat sym_runs/0.75/stats/var.dat sym_runs/0.75/stats/avg.dat sym_runs/0.75/M_stats/Mskew.dat" u 1:((-$12/$23)/$2) pt 7 ps 0.5 t "eps/k S, Yt=0.127"
gnuplot> unset table

In unix shell: cat eok_A0.75_S | awk '{print "{ " $1 ", " $2 " }," }'

The resulting data is simply a y = f(x) function, where the x is the first, and the y is the second column. The x column is assumed to be in increasing order.

const tk::Table<1> walker::invhts_eq_A075L

Inverse equilibrium hydrodynamics time scale from DNS of homogeneous Rayleigh-Taylor instability, tau_eq, A = 0.75, IC: light >> heavy.

Deffinition of this time scale:

Configuration:

Atwood number = 0.75
Initial condition: light >> heavy, Ytilde = 0.291

Produced from DNS data in two steps:

In gnuplot:

gnuplot> set table "eok_A0.75_L"
gnuplot> plot "< paste asymmetric_runs/0.75_L/M_stats/Mktaib.dat asymmetric_runs/0.75_L/M_stats/Mrhokeq.dat asymmetric_runs/0.75_L/stats/var.dat asymmetric_runs/0.75_L/stats/avg.dat asymmetric_runs/0.75_L/M_stats/Mskew.dat" u 1:((-$12/$23)/$2) pt 7 ps 0.5 t "eps/k H, Yt=0.291"
gnuplot> unset table

In unix shell: cat eok_A0.75_L | awk '{print "{ " $1 ", " $2 " }," }'

The resulting data is simply a y = f(x) function, where the x is the first, and the y is the second column. The x column is assumed to be in increasing order.

std::vector<DiffEq> walker::g_diffeqs

Differential equations selected by user

This vector is in global scope, because it holds polymorphic objects, and thus must be distributed to all PEs during initialization. Once distributed by the runtime system, the objects do not change.

CProxy_Distributor walker::g_DistributorProxy

Distributor Charm++ proxy facilitating call-back to Distributor by the individual integrators

CkReduction::reducerType walker::PDFMerger

Charm++ PDF merger reducer.

This variable is defined here in the .C file and declared as extern in Collector.h. If instead one defines it in the header (as static), a new version of the variable is created any time the header file is included, yielding no compilation nor linking errors. However, that leads to runtime errors, since Collector::registerPDFMerger(), a Charm++ "initnode" entry method, may fill one while contribute() may use the other (unregistered) one. Result: undefined behavior, segfault, and formatting the internet ...

walker namespace

Contents

Namespaces

Classes

Typedefs

Functions

Variables

Function documentation

void walker::registerBeta(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

std::vector<std::pair<std::string, std::string>> walker::infoBeta(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

void walker::registerMassFractionBeta(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

std::vector<std::pair<std::string, std::string>> walker::infoMassFractionBeta(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

void walker::registerMixMassFractionBeta(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

std::vector<std::pair<std::string, std::string>> walker::infoMixMassFractionBeta(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

void walker::registerMixNumberFractionBeta(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

std::vector<std::pair<std::string, std::string>> walker::infoMixNumberFractionBeta(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

void walker::registerNumberFractionBeta(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

std::vector<std::pair<std::string, std::string>> walker::infoNumberFractionBeta(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

template<typename eq, typename coupledeq, typename id> void walker::coupledInfo(std::size_t system, std::string&& coupled_eq_name, std::vector<std::pair<std::string, std::string>> nfo)

template<typename eq, typename coupledeq> bool walker::coupled(std::size_t system)

template<typename eq, typename coupledeq> char walker::depvar(std::size_t system)

template<typename eq, typename coupledeq, typename id> std::size_t walker::system_id(std::size_t system)

template<typename eq, typename coupledeq, typename id> std::size_t walker::offset(std::size_t system)

template<typename eq, typename coupledeq, typename id> std::size_t walker::ncomp(std::size_t system)

template<typename V> std::string walker::parameters(const V& v)

template<class Option, class OptTypeVec> std::string walker::options(const Option& opt, const OptTypeVec& v)

template<typename Info, typename VV> void walker::spikes(Info& nfo, const VV& spike)

template<typename Info, typename VV> void walker::betapdfs(Info& nfo, const VV& betapdf)

void walker::registerDirichlet(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

std::vector<std::pair<std::string, std::string>> walker::infoDirichlet(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

void walker::registerGenDir(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

std::vector<std::pair<std::string, std::string>> walker::infoGenDir(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

void walker::registerMixDirichlet(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

std::vector<std::pair<std::string, std::string>> walker::infoMixDirichlet(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

std::vector<kw::sde_r::info::expect::type> walker::MixDir_r(const std::vector<kw::sde_rho::info::expect::type>& rho, ctr::NormalizationType norm)

void walker::registerDissipation(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

std::vector<std::pair<std::string, std::string>> walker::infoDissipation(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

void walker::registerGamma(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

std::vector<std::pair<std::string, std::string>> walker::infoGamma(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

void walker::registerDiagOrnsteinUhlenbeck(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

std::vector<std::pair<std::string, std::string>> walker::infoDiagOrnsteinUhlenbeck(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

void walker::registerOrnsteinUhlenbeck(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

std::vector<std::pair<std::string, std::string>> walker::infoOrnsteinUhlenbeck(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

void walker::registerPosition(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

std::vector<std::pair<std::string, std::string>> walker::infoPosition(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

void walker::registerSkewNormal(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

std::vector<std::pair<std::string, std::string>> walker::infoSkewNormal(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

void walker::registerVelocity(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

std::vector<std::pair<std::string, std::string>> walker::infoVelocity(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

std::array<tk::real, 9> walker::slm(tk::real hts, tk::real C0)

std::array<tk::real, 9> walker::glm(tk::real hts, tk::real C0, const std::array<tk::real, 6>& rs, const std::array<tk::real, 9>& dU)

std::array<tk::real, 6> walker::reynoldsStress(char depvar, ctr::DepvarType solve, const std::map<tk::ctr::Product, tk::real>& moments)

tk::real walker::tke(char depvar, ctr::DepvarType solve, const std::map<tk::ctr::Product, tk::real>& moments)

void walker::registerWrightFisher(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

std::vector<std::pair<std::string, std::string>> walker::infoWrightFisher(std::map<ctr::DiffEqType, tk::ctr::ncomp_t>& cnt)

void walker::operator|(PUP::er& p, std::map<tk::ctr::RawRNGType, tk::RNG>& rng)

void walker::operator|(PUP::er& p, std::vector<DiffEq>& eqs)

Variable documentation

ctr::InputDeck walker::g_inputdeck

ctr::InputDeck walker::g_inputdeck_defaults

std::map<tk::ctr::RawRNGType, tk::RNG> walker::g_rng

const tk::Table<1> walker::prod_A005H

const tk::Table<1> walker::prod_A005S

const tk::Table<1> walker::prod_A005L

const tk::Table<1> walker::prod_A05H

const tk::Table<1> walker::prod_A05S

const tk::Table<1> walker::prod_A05L

const tk::Table<1> walker::prod_A075H

const tk::Table<1> walker::prod_A075S

const tk::Table<1> walker::prod_A075L

const tk::Table<1> walker::invhts_eq_A005H

const tk::Table<1> walker::invhts_eq_A005S

const tk::Table<1> walker::invhts_eq_A005L

const tk::Table<1> walker::invhts_eq_A05H

const tk::Table<1> walker::invhts_eq_A05S

const tk::Table<1> walker::invhts_eq_A05L

const tk::Table<1> walker::invhts_eq_A075H

const tk::Table<1> walker::invhts_eq_A075S

const tk::Table<1> walker::invhts_eq_A075L

std::vector<DiffEq> walker::g_diffeqs

template<typename eq, typename coupledeq, typename id>
void walker::coupledInfo(std::size_t system, std::string&& coupled_eq_name, std::vector<std::pair<std::string, std::string>> nfo)

template<typename eq, typename coupledeq>
bool walker::coupled(std::size_t system)

template<typename eq, typename coupledeq>
char walker::depvar(std::size_t system)

template<typename eq, typename coupledeq, typename id>
std::size_t walker::system_id(std::size_t system)

template<typename eq, typename coupledeq, typename id>
std::size_t walker::offset(std::size_t system)

template<typename eq, typename coupledeq, typename id>
std::size_t walker::ncomp(std::size_t system)

template<typename V>
std::string walker::parameters(const V& v)

template<class Option, class OptTypeVec>
std::string walker::options(const Option& opt, const OptTypeVec& v)

template<typename Info, typename VV>
void walker::spikes(Info& nfo, const VV& spike)

template<typename Info, typename VV>
void walker::betapdfs(Info& nfo, const VV& betapdf)