walker namespace

Walker declarations and definitions.

Contents

Everything that contributes to the walker executable.

Namespaces

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

Classes

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

Typedefs

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

Functions

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

Variables

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

Function documentation

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

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::grm::couple in Control/Walker/InputDeck/Grammar.h
Parameters
system in Relative equation system id of equation 'eq'
coupled_eq_name in Coupled equation name
nfo in/out Info vector to augment

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

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

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

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

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

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

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

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

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

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

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

Convert and return values from vector as string.

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

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

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

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

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

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

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

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

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

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

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

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 Ornstein-Uhlenbeck 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 Ornstein-Uhlenbeck SDE.

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

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

Register Ornstein-Uhlenbeck 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 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
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 skew-normal 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 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
f in/out Differential equation factory to register to
t in/out Counters for equation types registered

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

Return information on the velocity SDE.

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

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

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

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

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

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

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

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

Compute the Reynolds stress tensor.

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

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

Compute the turbulent kinetic energy.

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

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

Register Wright-Fisher 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 Wright-Fisher SDE.

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

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

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

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

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

Variable documentation

ctr::InputDeck walker::g_inputdeck

Input deck filled by parser, containing all input data

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

ctr::InputDeck walker::g_inputdeck_defaults

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

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

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

Random number generators selected by user

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

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

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

Definition of turbulent kinetic energy production:

\[ 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<1> walker::prod_A005S

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

Definition of turbulent kinetic energy production:

\[ 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<1> walker::prod_A005L

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

Definition of turbulent kinetic energy production:

\[ 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<1> walker::prod_A05H

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

Definition of turbulent kinetic energy production:

\[ 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<1> walker::prod_A05S

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

Definition of turbulent kinetic energy production:

\[ 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<1> walker::prod_A05L

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

Definition of turbulent kinetic energy production:

\[ 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<1> walker::prod_A075H

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

Definition of turbulent kinetic energy production:

\[ 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<1> walker::prod_A075S

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

Definition of turbulent kinetic energy production:

\[ 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<1> walker::prod_A075L

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

Definition of turbulent kinetic energy production:

\[ 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<1> walker::invhts_eq_A005H

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

Deffinition of this time scale:

\[ \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<1> walker::invhts_eq_A005S

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

Deffinition of this time scale:

\[ \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<1> walker::invhts_eq_A005L

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

Deffinition of this time scale:

\[ \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<1> walker::invhts_eq_A05H

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

Deffinition of this time scale:

\[ \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<1> walker::invhts_eq_A05S

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

Deffinition of this time scale:

\[ \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<1> walker::invhts_eq_A05L

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

Deffinition of this time scale:

\[ \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<1> walker::invhts_eq_A075H

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

Deffinition of this time scale:

\[ \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<1> walker::invhts_eq_A075S

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

Deffinition of this time scale:

\[ \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<1> walker::invhts_eq_A075L

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

Deffinition of this time scale:

\[ \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 ...