walker namespace
Walker declarations and definitions.
Contents
 Reference
Everything that contributes to the walker executable.
Namespaces
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 OrnsteinUhlenbeck SDE used polymorphically with DiffEq.
 class DiagOrnsteinUhlenbeckCoeffConst
 Diagonal OrnsteinUhlenbeck 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 deltaspikes as the joint PDF.
 struct InitDirichlet
 Dirichlet initialization policy: generate samples from a Dirichlet 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
 Massfraction beta SDE 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
 class MixMassFracBetaCoeffDecay
 Mix massfraction beta SDE decay coefficients policy.
 class MixMassFracBetaCoeffHomDecay
 Mix massfraction beta SDE homogneous decay coefficients policy.
 class MixMassFracBetaCoeffHydroTimeScale
 Mix massfraction beta SDE coefficients policy with DNS hydrodynamics time scale.
 class MixMassFracBetaCoeffInstVel
 Mix massfraction beta SDE coefficients policy coupled to velocity.
 class MixMassFracBetaCoeffMonteCarloHomDecay
 Mix massfraction 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 numberfraction beta SDE decay coefficients policity.

template<class Init, class Coefficients>class NumberFractionBeta
 NumberFractionBeta SDE used polymorphically with DiffEq.
 class NumFracBetaCoeffConst
 Numberfraction beta SDE constant coefficients policity: constants in time.

template<class Init, class Coefficients>class OrnsteinUhlenbeck
 OrnsteinUhlenbeck SDE used polymorphically with DiffEq.
 class OrnsteinUhlenbeckCoeffConst
 OrnsteinUhlenbeck constant coefficients policity: constants in time.

template<class Init, class Coefficients>class Position
 Position equation used polymorphically with DiffEq.
 class PositionConstShear
 Position equation coefficients policy using a prescribed constant mean velocity gradient for homogeneous shear flow.
 class PositionInstVel
 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
 Skewnormal SDE used polymorphically with DiffEq.
 class SkewNormalCoeffConst
 Skewnormal 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
 WrightFisher SDE used polymorphically with DiffEq.
 class WrightFisherCoeffConst
 WrightFisher constant coefficients policity: constants in time.
Typedefs
 using BetaCoeffPolicies = brigand::list<BetaCoeffConst>
 List of all beta's coefficients policies.
 using MassFractionBetaCoeffPolicies = brigand::list<MassFractionBetaCoeffConst>
 List of all massfraction beta's coefficients policies.
 using MixMassFracBetaCoeffPolicies = brigand::list<MixMassFracBetaCoeffDecay, MixMassFracBetaCoeffHomDecay, MixMassFracBetaCoeffMonteCarloHomDecay, MixMassFracBetaCoeffHydroTimeScale, MixMassFracBetaCoeffInstVel>
 List of all mix massfraction beta's coefficients policies.
 using MixNumFracBetaCoeffPolicies = brigand::list<MixNumFracBetaCoeffDecay>
 List of all mix numberffraction beta's coefficients policies.
 using NumberFractionBetaCoeffPolicies = brigand::list<NumFracBetaCoeffConst>
 List of all numberfraction 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 OrnsteinUhlenbeck's coefficients policies.
 using OrnsteinUhlenbeckCoeffPolicies = brigand::list<OrnsteinUhlenbeckCoeffConst>
 List of all OrnsteinUhlenbeck's coefficients policies.
 using PositionCoeffPolicies = brigand::list<PositionInstVel, PositionConstShear>
 List of all position eq coefficients policies.
 using SkewNormalCoeffPolicies = brigand::list<SkewNormalCoeffConst>
 List of all Skewnormal 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 WrightFisher'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:: >& cnt) > std::vector<std::pair<std::string, std::string>>ncomp_t  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:: >& cnt) > std::vector<std::pair<std::string, std::string>>ncomp_t  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:: >& cnt) > std::vector<std::pair<std::string, std::string>>ncomp_t  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:: >& cnt) > std::vector<std::pair<std::string, std::string>>ncomp_t  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:: >& cnt) > std::vector<std::pair<std::string, std::string>>ncomp_t  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:: >& cnt) > std::vector<std::pair<std::string, std::string>>ncomp_t  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:: >& cnt) > std::vector<std::pair<std::string, std::string>>ncomp_t  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:: >& cnt) > std::vector<std::pair<std::string, std::string>>ncomp_t  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:: >& cnt) > std::vector<std::pair<std::string, std::string>>ncomp_t  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:: >& cnt) > std::vector<std::pair<std::string, std::string>>ncomp_t  Return information on the gamma SDE.

void registerDiagOrnsteinUhlenbeck(DiffEqFactory& f,
std::set<ctr::
DiffEqType >& t)  Register diagonal OrnsteinUhlenbeck SDE into DiffEq factory.

auto infoDiagOrnsteinUhlenbeck(std::map<ctr::
DiffEqType , tk::ctr:: >& cnt) > std::vector<std::pair<std::string, std::string>>ncomp_t  Return information on the diagonal OrnsteinUhlenbeck SDE.

void registerOrnsteinUhlenbeck(DiffEqFactory& f,
std::set<ctr::
DiffEqType >& t)  Register OrnsteinUhlenbeck SDE into DiffEq factory.

auto infoOrnsteinUhlenbeck(std::map<ctr::
DiffEqType , tk::ctr:: >& cnt) > std::vector<std::pair<std::string, std::string>>ncomp_t  Return information on the OrnsteinUhlenbeck SDE.

void registerPosition(DiffEqFactory& f,
std::set<ctr::
DiffEqType >& t)  Register position SDE into DiffEq factory.

auto infoPosition(std::map<ctr::
DiffEqType , tk::ctr:: >& cnt) > std::vector<std::pair<std::string, std::string>>ncomp_t  Return information on the position SDE.

void registerSkewNormal(DiffEqFactory& f,
std::set<ctr::
DiffEqType >& t)  Register skewnormal SDE into DiffEq factory.

auto infoSkewNormal(std::map<ctr::
DiffEqType , tk::ctr:: >& cnt) > std::vector<std::pair<std::string, std::string>>ncomp_t  Return information on the skewnormal SDE.

void registerVelocity(DiffEqFactory& f,
std::set<ctr::
DiffEqType >& t)  Register velocity SDE into DiffEq factory.

auto infoVelocity(std::map<ctr::
DiffEqType , tk::ctr:: >& cnt) > std::vector<std::pair<std::string, std::string>>ncomp_t  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:: , tk::Product real >& moments) > std::array<tk::real , 6>  Compute the Reynolds stress tensor.

auto tke(char depvar,
ctr::
DepvarType solve, const std::map<tk::ctr:: , tk::Product real >& moments) > tk::real  Compute the turbulent kinetic energy.

void registerWrightFisher(DiffEqFactory& f,
std::set<ctr::
DiffEqType >& t)  Register WrightFisher SDE into DiffEq factory.

auto infoWrightFisher(std::map<ctr::
DiffEqType , tk::ctr:: >& cnt) > std::vector<std::pair<std::string, std::string>>ncomp_t  Return information on the WrightFisher SDE.

void operator(PUP::er& p,
std::map<tk::
ctr:: , tk::RawRNGType 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:: , tk::RawRNGType RNG > g_rng  const tk::
Table prod_A005H  Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous RayleighTaylor 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 RayleighTaylor 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 RayleighTaylor 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 RayleighTaylor 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 RayleighTaylor 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 RayleighTaylor 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 RayleighTaylor 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 RayleighTaylor 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 RayleighTaylor instability. A = 0.75, IC: light >> heavy.
 const tk::
Table invhts_eq_A005H  Inverse equilibrium hydrodynamics time scale from DNS of homogeneous RayleighTaylor instability, tau_eq, A = 0.05, IC: light << heavy.
 const tk::
Table invhts_eq_A005S  Inverse equilibrium hydrodynamics time scale from DNS of homogeneous RayleighTaylor instability, tau_eq, A = 0.05, IC: light = heavy.
 const tk::
Table invhts_eq_A005L  Inverse equilibrium hydrodynamics time scale from DNS of homogeneous RayleighTaylor instability, tau_eq, A = 0.05, IC: light >> heavy.
 const tk::
Table invhts_eq_A05H  Inverse equilibrium hydrodynamics time scale from DNS of homogeneous RayleighTaylor instability, tau_eq, A = 0.5, IC: light << heavy.
 const tk::
Table invhts_eq_A05S  Inverse equilibrium hydrodynamics time scale from DNS of homogeneous RayleighTaylor instability, tau_eq, A = 0.5, IC: light = heavy.
 const tk::
Table invhts_eq_A05L  Inverse equilibrium hydrodynamics time scale from DNS of homogeneous RayleighTaylor instability, tau_eq, A = 0.5, IC: light >> heavy.
 const tk::
Table invhts_eq_A075H  Inverse equilibrium hydrodynamics time scale from DNS of homogeneous RayleighTaylor instability, tau_eq, A = 0.75, IC: light << heavy.
 const tk::
Table invhts_eq_A075S  Inverse equilibrium hydrodynamics time scale from DNS of homogeneous RayleighTaylor instability, tau_eq, A = 0.75, IC: light = heavy.
 const tk::
Table invhts_eq_A075L  Inverse equilibrium hydrodynamics time scale from DNS of homogeneous RayleighTaylor 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)
Register beta SDE into DiffEq factory.
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)
Register beta SDE into DiffEq factory.
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)
Register beta SDE into DiffEq factory.
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)
Register beta SDE into DiffEq factory.
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)
Register beta SDE into DiffEq factory.
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:: 
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:: 
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:: 
Parameters  
system in  Relative equation system id of equation 'eq' 
Returns  System offset of coupled equation in tk:: 
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:: 
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::
Parameters  

opt in  Option instance (inheriting from tk:: 
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 stringpairs 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 stringpairs to insert to 
betapdf in  Vector of vectors specifying betapdf info 
void walker:: registerDirichlet(DiffEqFactory& f,
std::set<ctr::DiffEqType >& t)
Register Dirichlet SDE into DiffEq factory.
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)
Register generalized Dirichlet SDE into DiffEq factory.
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)
Register MixDirichlet SDE into DiffEq factory.
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)
Register dissipation SDE into DiffEq factory.
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)
Register gamma SDE into DiffEq factory.
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)
Register diagonal OrnsteinUhlenbeck SDE into DiffEq factory.
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 OrnsteinUhlenbeck 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 OrnsteinUhlenbeck SDE into DiffEq factory.
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 OrnsteinUhlenbeck 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  

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)
Register skewnormal SDE into DiffEq factory.
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 skewnormal 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  

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:: 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)
Register WrightFisher SDE into DiffEq factory.
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 WrightFisher 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 noop. We could initialize the stack in RNGTestDriver's constructor and let this function recreate 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 recreate (when unpacking) the stack, which eliminates the need for precreating 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 noop. We could initialize the factory in WalkerDriver's constructor and let this function recreate 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 recreate (when unpacking) the factory, which eliminates the need for precreating 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
Globalscope 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 readonly. See also http:/
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 walker::prod_A005H
Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous RayleighTaylor 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 nonequilibrium 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, (y1y2)/(x1x2)); 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 walker::prod_A005S
Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous RayleighTaylor 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 nonequilibrium 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, (y1y2)/(x1x2)); 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 walker::prod_A005L
Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous RayleighTaylor 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 nonequilibrium 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, (y1y2)/(x1x2)); 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 walker::prod_A05H
Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous RayleighTaylor 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 nonequilibrium 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, (y1y2)/(x1x2)); 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 walker::prod_A05S
Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous RayleighTaylor 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 nonequilibrium 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, (y1y2)/(x1x2)); 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 walker::prod_A05L
Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous RayleighTaylor 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 nonequilibrium 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, (y1y2)/(x1x2)); 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 walker::prod_A075H
Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous RayleighTaylor 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 nonequilibrium 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, (y1y2)/(x1x2)); 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 walker::prod_A075S
Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous RayleighTaylor 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 nonequilibrium 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, (y1y2)/(x1x2)); 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 walker::prod_A075L
Hydrodynamics (turbulent kinetic energy) production divided by the dissipatation rate evolution from DNS of homomgeneous RayleighTaylor 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 nonequilibrium 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, (y1y2)/(x1x2)); 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 walker::invhts_eq_A005H
Inverse equilibrium hydrodynamics time scale from DNS of homogeneous RayleighTaylor 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 walker::invhts_eq_A005S
Inverse equilibrium hydrodynamics time scale from DNS of homogeneous RayleighTaylor 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 walker::invhts_eq_A005L
Inverse equilibrium hydrodynamics time scale from DNS of homogeneous RayleighTaylor 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 walker::invhts_eq_A05H
Inverse equilibrium hydrodynamics time scale from DNS of homogeneous RayleighTaylor 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 walker::invhts_eq_A05S
Inverse equilibrium hydrodynamics time scale from DNS of homogeneous RayleighTaylor 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 walker::invhts_eq_A05L
Inverse equilibrium hydrodynamics time scale from DNS of homogeneous RayleighTaylor 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 walker::invhts_eq_A075H
Inverse equilibrium hydrodynamics time scale from DNS of homogeneous RayleighTaylor 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 walker::invhts_eq_A075S
Inverse equilibrium hydrodynamics time scale from DNS of homogeneous RayleighTaylor 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 walker::invhts_eq_A075L
Inverse equilibrium hydrodynamics time scale from DNS of homogeneous RayleighTaylor 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.
CProxy_Distributor walker::g_DistributorProxy
Distributor Charm++ proxy facilitating callback 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::