walker namespace

Walker declarations and definitions.

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

template<class Init, class Coefficients>
class Beta
Beta SDE used polymorphically with DiffEq.
class BetaCoeffConst
Beta constant coefficients policity: constants in time.
class CmdLineParser
CmdLineParser : StringParser.
class Collector
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.
class DiffEq
Differential equation.
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 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.
class Distributor
Distributor drives the time integration of differential equations.
template<class Init, class Coefficients>
class Gamma
Gamma SDE used polymorphically with DiffEq.
class GammaCoeffConst
Gamma 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.
struct InitBeta
Beta initialization policy: generate samples from a joint beta PDF.
struct InitCorrGaussian
Gaussian initialization policy: generate samples from a joint correlated Gaussian PDF.
struct InitDelta
Delta initialization policy: put in delta-spikes as the joint PDF.
struct InitGamma
Gamma initialization policy: generate samples from a joint gamma PDF.
struct InitGaussian
struct InitRaw
Raw initialization policy: leave memory uninitialized.
struct InitZero
Zero initialization policy: zero particle properties.
class InputDeckParser
InputDeckParser : FileParser.
class Integrator
Integrator Charm++ chare used to advance differential equations 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 MixDirichlet
MixDirichlet SDE used polymorphically with DiffEq.
class MixDirichletHomCoeffConst
class MixMassFracBetaCoeffDecay
Mix mass-fraction beta SDE decay coefficients policy.
class MixMassFracBetaCoeffHomDecay
Mix mass-fraction beta SDE homogneous 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.
class MixMassFracBetaCoeffMonteCarloHomDecay
Mix mass-fraction beta SDE Monte Carlo homogenous decay coefficients policy.
template<class Init, class Coefficients>
class MixMassFractionBeta
MixMassFractionBeta SDE used polymorphically with DiffEq.
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 NumberFractionBetaCoeffConst
Number-fraction beta SDE 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 Position_ConstShear
Position equation coefficients policy using a prescribed constant mean velocity gradient for homogeneous shear flow.
class Position_InstantaneousVelocity
Position equation coefficients policy given by the instantaneous velocity.
template<template<class, class> class Eq>
struct registerDiffEq
Function object for registering a differential equation into the differential equation factory.
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 VelocityCoeffHydroTimeScale
class VelocityCoeffStationary
Velocity equation coefficients policy yielding a statistically stationary state.
class WalkerDriver
Walker driver used polymorphically with Driver.
class WalkerPrint
WalkerPrint : tk::RNGPrint.
template<class Init, class Coefficients>
class WrightFisher
Wright-Fisher SDE used polymorphically with DiffEq.
class WrightFisherCoeffConst
Wright-Fisher constant coefficients policity: constants in time.

Typedefs

using BetaCoeffPolicies = brigand::list<BetaCoeffConst>
List of all beta's coefficients policies.
using DiagOrnsteinUhlenbeckCoeffPolicies = brigand::list<DiagOrnsteinUhlenbeckCoeffConst>
List of all Ornstein-Uhlenbeck's coefficients policies.
using DiffEqFactory = std::map<ctr::DiffEqKey, std::function<DiffEq(const tk::ctr::ncomp_type&)>>
Differential equation factory: keys associated to their constructors.
using DirichletCoeffPolicies = brigand::list<DirichletCoeffConst>
List of all Dirichlet'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 GeneralizedDirichletCoeffPolicies = brigand::list<GeneralizedDirichletCoeffConst>
List of all generalized Dirichlet's coefficients policies.
using InitPolicies = brigand::list<InitRaw, InitZero, InitDelta, InitBeta, InitGaussian, InitCorrGaussian, InitGamma>
List of all initialization policies.
using MassFractionBetaCoeffPolicies = brigand::list<MassFractionBetaCoeffConst>
List of all mass-fraction beta's coefficients policies.
using MixDirichletCoeffPolicies = brigand::list<MixDirichletHomCoeffConst>
List of all MixDirichlet'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<NumberFractionBetaCoeffConst>
List of all number-fraction beta's coefficients policies.
using OrnsteinUhlenbeckCoeffPolicies = brigand::list<OrnsteinUhlenbeckCoeffConst>
List of all Ornstein-Uhlenbeck's coefficients policies.
using PositionCoeffPolicies = brigand::list<Position_InstantaneousVelocity, Position_ConstShear>
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_type>& cnt) -> std::vector<std::pair<std::string, std::string>>
Return information on the beta 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_type>& cnt) -> std::vector<std::pair<std::string, std::string>>
Return information on the diagonal Ornstein-Uhlenbeck SDE.
void registerDirichlet(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)
Register Dirichlet SDE into DiffEq factory.
auto infoDirichlet(std::map<ctr::DiffEqType, tk::ctr::ncomp_type>& cnt) -> std::vector<std::pair<std::string, std::string>>
Return information on the Dirichlet SDE.
void registerDissipation(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)
Register dissipation SDE into DiffEq factory.
auto infoDissipation(std::map<ctr::DiffEqType, tk::ctr::ncomp_type>& 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_type>& cnt) -> std::vector<std::pair<std::string, std::string>>
Return information on the gamma 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_type>& cnt) -> std::vector<std::pair<std::string, std::string>>
Return information on the generlized Dirichlet 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_type>& cnt) -> std::vector<std::pair<std::string, std::string>>
Return information on the beta 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_type>& cnt) -> std::vector<std::pair<std::string, std::string>>
Return information on the MixDirichlet 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_type>& 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_type>& 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_type>& cnt) -> std::vector<std::pair<std::string, std::string>>
Return information on the beta 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_type>& 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_type>& 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_type>& 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_type>& cnt) -> std::vector<std::pair<std::string, std::string>>
Return information on the velocity SDE.
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_type>& cnt) -> std::vector<std::pair<std::string, std::string>>
Return information on the Wright-Fisher 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 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.
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.
static auto MixDir_r(const std::vector<kw::sde_rho::info::expect::type>& rho) -> std::vector<kw::sde_r::info::expect::type>
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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 invhts_eq_A075L
Inverse equilibrium hydrodynamics time scale from DNS of homogeneous Rayleigh-Taylor instability, tau_eq, A = 0.75, IC: light >> heavy.
const std::size_t MIXDIR_NUMDERIVED
Number of derived variables computed by the MixDirichlet SDE.
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)

Register beta SDE into DiffEq factory.

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

std::vector<std::pair<std::string, std::string>> walker::infoBeta(std::map<ctr::DiffEqType, tk::ctr::ncomp_type>& 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::registerDiagOrnsteinUhlenbeck(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

Register diagonal Ornstein-Uhlenbeck SDE into DiffEq factory.

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

std::vector<std::pair<std::string, std::string>> walker::infoDiagOrnsteinUhlenbeck(std::map<ctr::DiffEqType, tk::ctr::ncomp_type>& 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::registerDirichlet(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

Register Dirichlet SDE into DiffEq factory.

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

std::vector<std::pair<std::string, std::string>> walker::infoDirichlet(std::map<ctr::DiffEqType, tk::ctr::ncomp_type>& 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::registerDissipation(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

Register dissipation SDE into DiffEq factory.

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

std::vector<std::pair<std::string, std::string>> walker::infoDissipation(std::map<ctr::DiffEqType, tk::ctr::ncomp_type>& 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)

Register gamma SDE into DiffEq factory.

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

std::vector<std::pair<std::string, std::string>> walker::infoGamma(std::map<ctr::DiffEqType, tk::ctr::ncomp_type>& 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::registerGenDir(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

Register generalized Dirichlet SDE into DiffEq factory.

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

std::vector<std::pair<std::string, std::string>> walker::infoGenDir(std::map<ctr::DiffEqType, tk::ctr::ncomp_type>& 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::registerMassFractionBeta(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

Register beta SDE into DiffEq factory.

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

std::vector<std::pair<std::string, std::string>> walker::infoMassFractionBeta(std::map<ctr::DiffEqType, tk::ctr::ncomp_type>& 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::registerMixDirichlet(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

Register MixDirichlet SDE into DiffEq factory.

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

std::vector<std::pair<std::string, std::string>> walker::infoMixDirichlet(std::map<ctr::DiffEqType, tk::ctr::ncomp_type>& 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

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

Register beta SDE into DiffEq factory.

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

std::vector<std::pair<std::string, std::string>> walker::infoMixMassFractionBeta(std::map<ctr::DiffEqType, tk::ctr::ncomp_type>& 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)

Register beta SDE into DiffEq factory.

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

std::vector<std::pair<std::string, std::string>> walker::infoMixNumberFractionBeta(std::map<ctr::DiffEqType, tk::ctr::ncomp_type>& 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)

Register beta SDE into DiffEq factory.

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

std::vector<std::pair<std::string, std::string>> walker::infoNumberFractionBeta(std::map<ctr::DiffEqType, tk::ctr::ncomp_type>& 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::registerOrnsteinUhlenbeck(DiffEqFactory& f, std::set<ctr::DiffEqType>& t)

Register Ornstein-Uhlenbeck SDE into DiffEq factory.

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

std::vector<std::pair<std::string, std::string>> walker::infoOrnsteinUhlenbeck(std::map<ctr::DiffEqType, tk::ctr::ncomp_type>& 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)

Register position SDE into DiffEq factory.

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

std::vector<std::pair<std::string, std::string>> walker::infoPosition(std::map<ctr::DiffEqType, tk::ctr::ncomp_type>& 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)

Register skew-normal SDE into DiffEq factory.

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

std::vector<std::pair<std::string, std::string>> walker::infoSkewNormal(std::map<ctr::DiffEqType, tk::ctr::ncomp_type>& 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)

Register velocity SDE into DiffEq factory.

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

std::vector<std::pair<std::string, std::string>> walker::infoVelocity(std::map<ctr::DiffEqType, tk::ctr::ncomp_type>& 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

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

Register Wright-Fisher SDE into DiffEq factory.

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

std::vector<std::pair<std::string, std::string>> walker::infoWrightFisher(std::map<ctr::DiffEqType, tk::ctr::ncomp_type>& 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

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 V>
std::string walker::parameters(const V& v)

Convert and return values from vector as string.

Parameters
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)
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

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

static std::vector<kw::sde_r::info::expect::type> walker::MixDir_r(const std::vector<kw::sde_rho::info::expect::type>& rho)

Parameters
rho in Parameter vector rho to MixDirichlet
Returns Parameter vector r, determined by parameter vector rho

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.

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 and available to all PEs.

const tk::Table 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:

\[ P = \frac{\mathrm{d}k}{\mathrm{d}t} + \epsilon \]

where $k$ is the turbulent kinetic energy and $\epsilon$ 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:

  1. 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
  2. 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 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:

\[ P = \frac{\mathrm{d}k}{\mathrm{d}t} + \epsilon \]

where $k$ is the turbulent kinetic energy and $\epsilon$ 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:

  1. 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
  2. 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 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:

\[ P = \frac{\mathrm{d}k}{\mathrm{d}t} + \epsilon \]

where $k$ is the turbulent kinetic energy and $\epsilon$ 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:

  1. 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
  2. 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 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:

\[ P = \frac{\mathrm{d}k}{\mathrm{d}t} + \epsilon \]

where $k$ is the turbulent kinetic energy and $\epsilon$ 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:

  1. 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
  2. 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 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:

\[ P = \frac{\mathrm{d}k}{\mathrm{d}t} + \epsilon \]

where $k$ is the turbulent kinetic energy and $\epsilon$ 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:

  1. 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
  2. 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 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:

\[ P = \frac{\mathrm{d}k}{\mathrm{d}t} + \epsilon \]

where $k$ is the turbulent kinetic energy and $\epsilon$ 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:

  1. 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
  2. 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 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:

\[ P = \frac{\mathrm{d}k}{\mathrm{d}t} + \epsilon \]

where $k$ is the turbulent kinetic energy and $\epsilon$ 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:

  1. 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
  2. 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 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:

\[ P = \frac{\mathrm{d}k}{\mathrm{d}t} + \epsilon \]

where $k$ is the turbulent kinetic energy and $\epsilon$ 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:

  1. 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
  2. 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 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:

\[ P = \frac{\mathrm{d}k}{\mathrm{d}t} + \epsilon \]

where $k$ is the turbulent kinetic energy and $\epsilon$ 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:

  1. 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
  2. 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 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:

\[ \frac{1}{\tau_\mathrm{eq}} = \frac{\epsilon}{k} \]

Configuration:

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

Produced from DNS data in two steps:

  1. 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
  2. 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 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:

\[ \frac{1}{\tau_\mathrm{eq}} = \frac{\epsilon}{k} \]

Configuration:

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

Produced from DNS data in two steps:

  1. 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
  2. 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 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:

\[ \frac{1}{\tau_\mathrm{eq}} = \frac{\epsilon}{k} \]

Configuration:

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

Produced from DNS data in two steps:

  1. 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
  2. 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 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:

\[ \frac{1}{\tau_\mathrm{eq}} = \frac{\epsilon}{k} \]

Configuration:

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

Produced from DNS data in two steps:

  1. 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
  2. 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 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:

\[ \frac{1}{\tau_\mathrm{eq}} = \frac{\epsilon}{k} \]

Configuration:

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

Produced from DNS data in two steps:

  1. 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
  2. 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 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:

\[ \frac{1}{\tau_\mathrm{eq}} = \frac{\epsilon}{k} \]

Configuration:

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

Produced from DNS data in two steps:

  1. 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
  2. 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 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:

\[ \frac{1}{\tau_\mathrm{eq}} = \frac{\epsilon}{k} \]

Configuration:

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

Produced from DNS data in two steps:

  1. 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
  2. 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 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:

\[ \frac{1}{\tau_\mathrm{eq}} = \frac{\epsilon}{k} \]

Configuration:

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

Produced from DNS data in two steps:

  1. 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
  2. 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 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:

\[ \frac{1}{\tau_\mathrm{eq}} = \frac{\epsilon}{k} \]

Configuration:

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

Produced from DNS data in two steps:

  1. 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
  2. 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 ...