Branch data Line data Source code
1 : : // *****************************************************************************
2 : : /*!
3 : : \file src/Control/Walker/InputDeck/Grammar.hpp
4 : : \copyright 2012-2015 J. Bakosi,
5 : : 2016-2018 Los Alamos National Security, LLC.,
6 : : 2019-2021 Triad National Security, LLC.
7 : : All rights reserved. See the LICENSE file for details.
8 : : \brief Walker's input deck grammar definition
9 : : \details Walker's input deck grammar definition. We use the Parsing
10 : : Expression Grammar Template Library (PEGTL) to create the grammar and the
11 : : associated parser. Word of advice: read from the bottom up.
12 : : */
13 : : // *****************************************************************************
14 : : #ifndef WalkerInputDeckGrammar_h
15 : : #define WalkerInputDeckGrammar_h
16 : :
17 : : #include <limits>
18 : : #include <algorithm>
19 : :
20 : : #include "Macro.hpp"
21 : : #include "Exception.hpp"
22 : : #include "Walker/Types.hpp"
23 : : #include "Keywords.hpp"
24 : : #include "CommonGrammar.hpp"
25 : : #include "QuinoaConfig.hpp"
26 : : #include "Walker/Options/InitPolicy.hpp"
27 : : #include "Walker/Options/CoeffPolicy.hpp"
28 : : #include "Walker/Options/HydroTimeScales.hpp"
29 : : #include "Walker/Options/HydroProductions.hpp"
30 : :
31 : : #ifdef HAS_MKL
32 : : #include "MKLGrammar.hpp"
33 : : #endif
34 : : #ifdef HAS_RNGSSE2
35 : : #include "RNGSSEGrammar.hpp"
36 : : #endif
37 : : #include "Random123Grammar.hpp"
38 : :
39 : : namespace walker {
40 : :
41 : : extern ctr::InputDeck g_inputdeck_defaults;
42 : :
43 : : //! Walker input deck facilitating user input for integrating SDEs
44 : : namespace deck {
45 : :
46 : : //! \brief Specialization of tk::grm::use for Walker's input deck parser
47 : : template< typename keyword >
48 : : using use = tk::grm::use< keyword, ctr::InputDeck::keywords >;
49 : :
50 : : // Walker's InputDeck state
51 : :
52 : : //! \brief Number of registered equations
53 : : //! \details Counts the number of parsed equation blocks during parsing.
54 : : static tk::TaggedTuple< brigand::list<
55 : : tag::dirichlet, std::size_t
56 : : , tag::mixdirichlet, std::size_t
57 : : , tag::gendir, std::size_t
58 : : , tag::wrightfisher, std::size_t
59 : : , tag::ou, std::size_t
60 : : , tag::diagou, std::size_t
61 : : , tag::skewnormal, std::size_t
62 : : , tag::gamma, std::size_t
63 : : , tag::velocity, std::size_t
64 : : , tag::position, std::size_t
65 : : , tag::dissipation, std::size_t
66 : : , tag::beta, std::size_t
67 : : , tag::numfracbeta, std::size_t
68 : : , tag::massfracbeta, std::size_t
69 : : , tag::mixnumfracbeta, std::size_t
70 : : , tag::mixmassfracbeta, std::size_t
71 : : > > neq;
72 : :
73 : : } // ::deck
74 : : } // ::walker
75 : :
76 : : namespace tk {
77 : : namespace grm {
78 : :
79 : : using namespace tao;
80 : :
81 : : // Note that PEGTL action specializations must be in the same namespace as the
82 : : // template being specialized. See http://stackoverflow.com/a/3052604.
83 : :
84 : : // Walker's InputDeck actions
85 : :
86 : : //! Rule used to trigger action
87 : : template< class Option, typename... tags >
88 : : struct store_walker_option : pegtl::success {};
89 : : //! \brief Put option in state at position given by tags
90 : : //! \details This is simply a wrapper around tk::grm::store_option passing the
91 : : //! stack defaults for walker.
92 : : template< class Option, typename... tags >
93 : : struct action< store_walker_option< Option, tags... > > {
94 : : template< typename Input, typename Stack >
95 : : static void apply( const Input& in, Stack& stack ) {
96 : : store_option< Stack, walker::deck::use, Option, walker::ctr::InputDeck,
97 : : Input, tags... >
98 [ + - ][ + - ]: 55 : ( stack, in, walker::g_inputdeck_defaults );
[ + - ][ + - ]
[ + - ]
99 : : }
100 : : };
101 : :
102 : : //! Rule used to trigger action
103 : : template< class eq > struct register_eq : pegtl::success {};
104 : : //! \brief Register differential equation after parsing its block
105 : : //! \details This is used by the error checking functors (check_*) during
106 : : //! parsing to identify the recently-parsed block.
107 : : template< class eq >
108 : : struct action< register_eq< eq > > {
109 : : template< typename Input, typename Stack >
110 : : static void apply( const Input&, Stack& ) {
111 : : using walker::deck::neq;
112 : 86 : ++neq.get< eq >();
113 : : }
114 : : };
115 : :
116 : : //! Rule used to trigger action
117 : : template< class eq, class vec, MsgKey key >
118 : : struct check_vector_exists : pegtl::success {};
119 : : //! \brief Check the existence of a vector (required for a block)
120 : : //! \details This functor can be used to check the existence of a
121 : : //! user-specified vector, e.g., at the end of a diffeq ... end block, that
122 : : //! is required for that block. If the vector does not exist, we error out.
123 : : //! \note This functor only checks existence. If the vector exists, the size
124 : : //! of it can be checked by check_vector_size.
125 : : template< class eq, class vec, MsgKey Key >
126 : : struct action< check_vector_exists< eq, vec, Key > > {
127 : : template< typename Input, typename Stack >
128 : : static void apply( const Input& in, Stack& stack ) {
129 : : const auto& vv = stack.template get< tag::param, eq, vec >();
130 : : using walker::deck::neq;
131 [ - + ][ - + ]: 10 : if (vv.size() != neq.get< eq >())
132 : 0 : Message< Stack, ERROR, Key >( stack, in );
133 : : }
134 : : };
135 : :
136 : : //! Rule used to trigger action
137 : : template< class eq, class vec > struct check_vector_size : pegtl::success {};
138 : : //! \brief Do error checking of a vector (required for a block)
139 : : //! \details This functor can be used to verify the correct size of an already
140 : : //! existing vector, specified by the user in a given block. The vector is
141 : : //! required to be non-empty.
142 : : //! \note This functor does not check existence of a vector. If the vector
143 : : //! does not even exist, it will throw an exception in DEBUG mode, while in
144 : : //! RELEASE mode it will attempt to access unallocated memory yielding a
145 : : //! segfault. The existence of the vector should be checked by
146 : : //! check_vector_exists first.
147 : : template< class eq, class vec >
148 : : struct action< check_vector_size< eq, vec > > {
149 : : template< typename Input, typename Stack >
150 : : static void apply( const Input& in, Stack& stack ) {
151 : : const auto& vv = stack.template get< tag::param, eq, vec >();
152 : : Assert( !vv.empty(), "Vector of vectors checked must not be empty" );
153 : : const auto& v = vv.back();
154 [ - - ][ - - ]: 10 : if (v.empty())
[ - + ][ - + ]
155 : 0 : Message< Stack, ERROR, MsgKey::WRONGSIZE >( stack, in );
156 : : }
157 : : };
158 : :
159 : : //! Rule used to trigger action
160 : : template< class eq, class vec >
161 : : struct check_mean_gradient : pegtl::success {};
162 : : //! Do error checking for a vector of prescribed mean gradient
163 : : template< class eq, class vec >
164 : : struct action< check_mean_gradient< eq, vec > > {
165 : : template< typename Input, typename Stack >
166 : : static void apply( const Input& in, Stack& stack ) {
167 : : auto& vv = stack.template get< tag::param, eq, vec >();
168 : : Assert( !vv.empty(), "Vector of vectors checked must not be empty" );
169 [ - - ]: 0 : if (vv.back().size() != 3)
170 : 0 : Message< Stack, ERROR, MsgKey::WRONGSIZE >( stack, in );
171 : : }
172 : : };
173 : :
174 : : //! Rule used to trigger action
175 : : template< class eq, class vec >
176 : : struct check_gravity : pegtl::success {};
177 : : //! Do error checking for a vector of prescribed mean gradient
178 : : template< class eq, class vec >
179 : : struct action< check_gravity< eq, vec > > {
180 : : template< typename Input, typename Stack >
181 : : static void apply( const Input& in, Stack& stack ) {
182 : : auto& vv = stack.template get< tag::param, eq, vec >();
183 : : Assert( !vv.empty(), "Vector of vectors checked must not be empty" );
184 [ - - ]: 0 : if (vv.back().size() != 3)
185 : 0 : Message< Stack, ERROR, MsgKey::WRONGSIZE >( stack, in );
186 : : }
187 : : };
188 : :
189 : : //! Rule used to trigger action
190 : : template< class eq > struct check_eq : pegtl::success {};
191 : : //! \brief Do general error checking on the differential equation block
192 : : //! \details This is error checking that all equation types must satisfy.
193 : : template< class eq >
194 : : struct action< check_eq< eq > > {
195 : : template< typename Input, typename Stack >
196 [ + - ]: 86 : static void apply( const Input& in, Stack& stack ) {
197 : : using walker::deck::neq;
198 : : // Error out if no dependent variable has been selected
199 : : const auto& depvar =
200 : : stack.template get< tag::param, eq, tag::depvar >();
201 [ + - ][ - + ]: 86 : if (depvar.empty() || depvar.size() != neq.get< eq >())
202 : 0 : Message< Stack, ERROR, MsgKey::NODEPVAR >( stack, in );
203 : :
204 : : // Error out if no number of components has been selected
205 : : const auto& ncomp = stack.template get< tag::component, eq >();
206 [ + - ][ - + ]: 86 : if (ncomp.empty() || ncomp.size() != neq.get< eq >())
207 : 0 : Message< Stack, ERROR, MsgKey::NONCOMP >( stack, in );
208 : :
209 : : // Error out if no RNG has been selected
210 : : const auto& rng = stack.template get< tag::param, eq, tag::rng >();
211 [ + - ][ - + ]: 86 : if (rng.empty() || rng.size() != neq.get< eq >())
212 : 0 : Message< Stack, ERROR, MsgKey::NORNG >( stack, in );
213 : :
214 : : // Error out if no initialization policy has been selected
215 : : const auto& init =
216 : : stack.template get< tag::param, eq, tag::initpolicy >();
217 [ + - ][ - + ]: 86 : if (init.empty() || init.size() != neq.get< eq >())
218 : 0 : Message< Stack, ERROR, MsgKey::NOINIT >( stack, in );
219 : :
220 : : // Error out if no coefficients policy has been selected
221 : : const auto& coeff =
222 : : stack.template get< tag::param, eq, tag::coeffpolicy >();
223 [ + - ][ - + ]: 86 : if (coeff.empty() || coeff.size() != neq.get< eq >())
224 : 0 : Message< Stack, ERROR, MsgKey::NOCOEFF >( stack, in );
225 : 86 : }
226 : : };
227 : :
228 : : //! Rule used to trigger action
229 : : template< class eq > struct check_init : pegtl::success {};
230 : : //! \brief Do error checking on the selected initialization policy
231 : : template< class eq >
232 : : struct action< check_init< eq > > {
233 : : template< typename Input, typename Stack >
234 : 86 : static void apply( const Input& in, Stack& stack ) {
235 : : using walker::deck::neq;
236 : : const auto& initpolicy =
237 : : stack.template get< tag::param, eq, tag::initpolicy >();
238 : : // Error checks for joint delta initpolicy
239 [ + - ]: 86 : if (initpolicy.size() == neq.get< eq >() &&
240 [ + + ]: 86 : initpolicy.back() == walker::ctr::InitPolicyType::JOINTDELTA) {
241 : : // Make sure there was an icdelta...end block with at least a single
242 : : // spike...end block
243 : : const auto& spike =
244 : : stack.template get< tag::param, eq, tag::init, tag::spike >();
245 [ + - ][ - + ]: 4 : if (!spike.empty() && spike.back().empty())
246 : 0 : Message< Stack, ERROR, MsgKey::NODELTA >( stack, in );
247 : : }
248 : : // Error checks for joint beta initpolicy
249 [ + - ]: 86 : if (initpolicy.size() == neq.get< eq >() &&
250 [ + + ]: 86 : initpolicy.back() == walker::ctr::InitPolicyType::JOINTBETA) {
251 : : // Make sure there was an icbeta...end block with at least a single
252 : : // betapdf...end block
253 : : const auto& betapdf =
254 : : stack.template get< tag::param, eq, tag::init, tag::betapdf >();
255 [ + - ][ - + ]: 5 : if (!betapdf.empty() && betapdf.back().empty())
256 : 0 : Message< Stack, ERROR, MsgKey::NOBETA >( stack, in );
257 : : }
258 : : // Error checks for joint gamma initpolicy
259 [ + - ]: 86 : if (initpolicy.size() == neq.get< eq >() &&
260 [ + + ]: 86 : initpolicy.back() == walker::ctr::InitPolicyType::JOINTGAMMA) {
261 : : // Make sure there was an icgamma...end block with at least a single
262 : : // gammapdf...end block
263 : : const auto& gammapdf =
264 : : stack.template get< tag::param, eq, tag::init, tag::gamma >();
265 [ + - ][ - + ]: 6 : if (!gammapdf.empty() && gammapdf.back().empty())
266 : 0 : Message< Stack, ERROR, MsgKey::NOGAMMA >( stack, in );
267 : : }
268 : : // Error checks for joint correlated Gaussian initpolicy
269 [ + - ]: 86 : if (initpolicy.size() == neq.get< eq >() &&
270 [ - + ]: 86 : initpolicy.back() == walker::ctr::InitPolicyType::JOINTCORRGAUSSIAN) {
271 : : // Ensure there was a mean vector and covaraiance matrix configured
272 : : const auto& mean =
273 : : stack.template get< tag::param, eq, tag::init, tag::mean >();
274 [ - - ][ - - ]: 0 : if (mean.empty() || mean.back().empty())
275 : 0 : Message< Stack, ERROR, MsgKey::NOMEAN >( stack, in );
276 : : const auto& cov =
277 : : stack.template get< tag::param, eq, tag::init, tag::cov >();
278 [ - - ][ - - ]: 0 : if (cov.empty() || cov.back().empty())
279 : 0 : Message< Stack, ERROR, MsgKey::NOCOV >( stack, in );
280 : : // Ensure that an MKL RNG is configured if initpolicy is corr-Gaussian
281 : : const auto& rng = stack.template get< tag::param, eq, tag::rng >();
282 [ - - ][ - - ]: 0 : if (tk::ctr::RNG().lib( rng.back() ) != tk::ctr::RNGLibType::MKL)
283 : 0 : Message< Stack, ERROR, MsgKey::NOMKLRNG >( stack, in );
284 : : }
285 : 86 : }
286 : : };
287 : :
288 : : //! Setup coupling between two equations
289 : : //! \tparam eq Tag of equation to be coupled
290 : : //! \tparam coupledeq Tag of equation coupled to eq
291 : : //! \tparam id Tag to vector to hold (relative) system ids of DiffEqs
292 : : //! coupled to eq among other DiffEqs of type coupledeq
293 : : //! \tparam depvar_msg Error message key to use on missing coupled depvar
294 : : //! \param[in] in Parser input
295 : : //! \param[in,out] stack Grammar stack to work with
296 : : //! \param[in] missing Error message key to use on missing coupled equation
297 : : //! if the coupling is required. Pass MsgKey::OPTIONAL as missing if the
298 : : //! coupling is optional.
299 : : //! \details This function computes and assigns the relative system id of a
300 : : //! an equation coupled to another equation. The two equations being coupled
301 : : //! are given by the two template arguments 'eq' and 'coupledeq'. The goal
302 : : //! is to compute the id of the coupled eq that identifies it among
303 : : //! potentially multiple coupled equations. Ths id is simply an integer
304 : : //! which is a relative index, starting from zero, and uniquely identifies
305 : : //! the equation system coupled to eq. As a result, when eq is instantiated,
306 : : //! this id can be used to query any detail of the user configuration for
307 : : //! the coupledeq equation coupled to eq.
308 : : //! \note This function is intended to be called at the very end of parsing,
309 : : //! when all equation systems and their configuration have been parsed so
310 : : //! the dependent variables, identifying equation systems, and the
311 : : //! specifications of their coupling, via referring to dependent variables
312 : : //! of equations coupled, have all been specified and thus known.
313 : : //! \note This function is intended to be called once per coupling an equation
314 : : //! type (a system) to another equation (system). Example: if the velocity
315 : : //! eqation is coupled to three other equation systems (say, position,
316 : : //! dissipation, mixmassfracbeta, this function must be called three times
317 : : //! with eq = velocity, and coupledeq = position, dissipation, and
318 : : //! mixmassfracbeta so that the proper coupling information is setup for
319 : : //! each of the three couplings.
320 : : template< typename eq, typename coupledeq, typename id, MsgKey depvar_msg,
321 : : typename Input, typename Stack >
322 : 43 : static void couple( const Input& in, Stack& stack, MsgKey missing )
323 : : {
324 : : // get coupled eq configuration
325 : : const auto& ceq = stack.template get< tag::param, eq, coupledeq >();
326 : : // get dependent variables of coupled equation
327 : : const auto& coupled_depvar =
328 : : stack.template get< tag::param, coupledeq, tag::depvar >();
329 : : // get access to coupled eq relative id vector to be filled
330 : : auto& coupled_eq_id = stack.template get< tag::param, eq, id >();
331 : :
332 : : // Note that the size of depvar vector must equal the size of the coupledeq
333 : : // configuration vector, ceq. The depvar stores the dependent variables
334 : : // (characters) of all the eqs configured, e.g., potentially multiple eqs.
335 : : // The coupledeq config vector stores the dependent variables each eq is
336 : : // potentially coupled to. Thus the position/index in these two vectors are
337 : : // used to identify which system is being coupled to which other system. If
338 : : // ceq[i] = '-', then eq[i] is NOT coupled to ceq[i]. ceq must be filled
339 : : // after a particular equation system block is finished parsing by
340 : : // check_coupling, which does error checking but is supposed to fill in the
341 : : // coupledeq depvar. If there is no coupling, it must put in '-'.
342 : : Assert( ( ceq.size() ==
343 : : stack.template get< tag::param, eq, tag::depvar >().size() ),
344 : : "Size mismatch" );
345 : :
346 : : // Find relative system ids for all coupledeqs coupled to eqs. Note that we
347 : : // loop through all ceqs (whose size equals to depvar, the number of eqs
348 : : // configured) and try to find all ceq depvars among the coupledeq depvars.
349 [ + + ]: 86 : for (auto ev : ceq) { // for all depvars coupled to eq
350 : 43 : std::size_t c = 0;
351 [ + + ]: 67 : for (auto cv : coupled_depvar) { // for all depvars of a coupled eq
352 [ + - ][ + - ]: 24 : if (ev == cv) coupled_eq_id.push_back( c );
353 : 24 : ++c;
354 : : }
355 : : // If eq is not coupled we put in a large number as a placeholder to
356 : : // keep the vector sizes of ceq and coupled_eq_id equal, this id
357 : : // will surely trigger a problem if ends up being used.
358 [ + + ]: 43 : if (ev == '-')
359 [ + - ]: 19 : coupled_eq_id.push_back( std::numeric_limits<std::size_t>::max() );
360 : : }
361 : :
362 : : // Ensure all coupled ids are filled.
363 : : Assert( ceq.size() == coupled_eq_id.size(), "Not all coupled eqs found" );
364 : :
365 : : // Error out if the coupling is required and at least one of the
366 : : // potentially multiple eqs is not coupled. Since this function is called
367 : : // for potentially multiple eqs, ceq is a vector. If the coupling between eq
368 : : // and coupledeq is required, ceq should not contatain a '-'.
369 [ + + ][ - + ]: 55 : if ( missing != MsgKey::OPTIONAL &&
370 : 12 : std::any_of( ceq.cbegin(), ceq.cend(),
371 : : []( char v ){ return v == '-'; } ) )
372 : : {
373 : 0 : Message< Stack, ERROR, depvar_msg >( stack, in );
374 : : }
375 : 43 : }
376 : :
377 : : //! Query if equation 'eq' has been coupled to equation 'coupledeq'
378 : : //! \tparam eq Tag of the equation to query
379 : : //! \tparam coupledeq Tag of the equation that is potentially coupled to
380 : : //! equation 'eq'
381 : : //! \param[in] stack Grammar stack to work with
382 : : //! \return True if equation 'eq' is coupled to equation 'coupledeq'
383 : : //! \note Always the eq system that is parsed last is interrogated.
384 : : template< typename eq, typename coupledeq, typename Stack >
385 : : static bool coupled( const Stack& stack ) {
386 : 0 : return stack.template get< tag::param, eq, coupledeq >().back() != '-';
387 : : }
388 : :
389 : : //! Query number of components of coupled equation
390 : : //! \tparam eq Tag of the equation that is coupled
391 : : //! \tparam coupledeq Tag of the equation that is coupled to equation 'eq'
392 : : //! \tparam id Tag to access the coupled equation 'eq' (relative) ids, see
393 : : //! tk::grm::couple.
394 : : //! \param[in] stack Grammar stack to work with
395 : : //! \return Number of scalar components of coupled equation
396 : : //! \note Always the eq system that is parsed last is interrogated.
397 : : template< typename eq, typename coupledeq, typename id, typename Stack >
398 [ - - ]: 0 : static std::size_t ncomp_coupled( const Stack& stack ) {
399 : : Assert( (coupled< eq, coupledeq >( stack )), "Eq must be coupled" );
400 : : // Query relative id of coupled eq
401 [ - - ]: 0 : auto cid = stack.template get< tag::param, eq, id >().back();
402 : 0 : return stack.template get< tag::component, coupledeq >().at( cid );
403 : : }
404 : :
405 : : //! Rule used to trigger action
406 : : struct check_velocity : pegtl::success {};
407 : : //! \brief Do error checking on the velocity eq block
408 : : template<>
409 : : struct action< check_velocity > {
410 : : template< typename Input, typename Stack >
411 : 74 : static void apply( const Input& in, Stack& stack ) {
412 : : using walker::deck::neq;
413 : : // if there was a velocity eq block defined
414 [ + + ]: 74 : if (neq.get< tag::velocity >() > 0) {
415 : : // Ensure a coupled position model is configured
416 : : couple< tag::velocity,
417 : : tag::position, tag::position_id, MsgKey::POSITION_DEPVAR >
418 : 7 : ( in, stack, MsgKey::OPTIONAL );
419 : : // Compute equation id if a coupled dissipation model is configured
420 : : couple< tag::velocity,
421 : : tag::dissipation, tag::dissipation_id, MsgKey::DISSIPATION_DEPVAR >
422 : 7 : ( in, stack, MsgKey::OPTIONAL );
423 : : // Compute equation id if a coupled mass fraction model is configured
424 : : couple< tag::velocity, tag::mixmassfracbeta, tag::mixmassfracbeta_id,
425 : : MsgKey::MIXMASSFRACBETA_DEPVAR >
426 : 7 : ( in, stack, MsgKey::OPTIONAL );
427 : : // Error out if no dependent variable to solve for was selected
428 : : const auto& solve =
429 : : stack.template get< tag::param, tag::velocity, tag::solve >();
430 [ - + ]: 7 : if (solve.size() != neq.get< tag::velocity >())
431 : 0 : Message< Stack, ERROR, MsgKey::NOSOLVE >( stack, in );
432 : :
433 : : // Increase number of components by the number of particle densities if
434 : : // we solve for particle momentum, coupled to mass fractions. This is
435 : : // to allocate storage for particle velocity as variables derived from
436 : : // momentum.
437 [ + - ]: 7 : if ( !solve.empty() &&
438 [ + - ][ - + ]: 7 : ( solve.back() == walker::ctr::DepvarType::PRODUCT ||
439 : : solve.back() == walker::ctr::DepvarType::FLUCTUATING_MOMENTUM ) )
440 : : {
441 : : //! Error out if not coupled to mixmassfracbeta
442 [ - - ]: 0 : if (!coupled< tag::velocity, tag::mixmassfracbeta >( stack )) {
443 : 0 : Message< Stack, ERROR, MsgKey::MIXMASSFRACBETA_DEPVAR >(stack,in);
444 : : } else {
445 : : // access number of components of velocity eq just parsed
446 : : auto& ncomp = stack.template get< tag::component, tag::velocity >();
447 : : // query number of components of coupled mixmassfracbeta model
448 : : auto nc = ncomp_coupled< tag::velocity, tag::mixmassfracbeta,
449 : 0 : tag::mixmassfracbeta_id >( stack );
450 : : // Augment storage of velocity equation, solving for momentum by
451 : : // the number of scalar components the coupled mixmassfracbeta mix
452 : : // model solves for. The magic number, 4, below is
453 : : // MixMassFractionBeta::NUMDERIVED + 1, and the 3 is the number of
454 : : // velocity components derived from momentum.
455 : 0 : ncomp.back() += (nc/4)*3;
456 : : }
457 : : }
458 : :
459 : : // Set C0 = 2.1 if not specified
460 : : auto& C0 = stack.template get< tag::param, tag::velocity, tag::c0 >();
461 [ + - ]: 7 : if (C0.size() != neq.get< tag::velocity >()) C0.push_back( 2.1 );
462 : : // Set SLM if not specified
463 : : auto& variant =
464 : : stack.template get< tag::param, tag::velocity, tag::variant >();
465 [ + + ]: 7 : if (variant.size() != neq.get< tag::velocity >())
466 : 4 : variant.push_back( walker::ctr::VelocityVariantType::SLM );
467 : :
468 : : // Set gravity to {0,0,0} if unspecified
469 : : auto& gravity =
470 : : stack.template get< tag::param, tag::velocity, tag::gravity >();
471 [ + - ]: 7 : if (gravity.size() != neq.get< tag::velocity >())
472 [ + - ]: 14 : gravity.push_back( { 0.0, 0.0, 0.0 } );
473 : : }
474 : 74 : }
475 : : };
476 : :
477 : : //! Rule used to trigger action
478 : : struct check_position : pegtl::success {};
479 : : //! \brief Do error checking on the position eq block and compute coupling
480 : : template<>
481 : : struct action< check_position > {
482 : : template< typename Input, typename Stack >
483 : 74 : static void apply( const Input& in, Stack& stack ) {
484 : : using walker::deck::neq;
485 : : // if there was a position eq block defined
486 [ + + ]: 74 : if (neq.get< tag::position >() > 0) {
487 : : // Ensure a coupled velocity model is configured
488 : : couple< tag::position,
489 : : tag::velocity, tag::velocity_id, MsgKey::VELOCITY_DEPVAR >
490 : 6 : ( in, stack, MsgKey::VELOCITY_MISSING );
491 : : // Error out if no dependent variable to solve for was selected
492 : : const auto& solve =
493 : : stack.template get< tag::param, tag::position, tag::solve >();
494 [ - + ]: 6 : if (solve.size() != neq.get< tag::position >())
495 : 0 : Message< Stack, ERROR, MsgKey::NOSOLVE >( stack, in );
496 : : }
497 : 74 : }
498 : : };
499 : :
500 : : //! Rule used to trigger action
501 : : struct check_dissipation : pegtl::success {};
502 : : //! \brief Do error checking on the dissipation eq block and compute coupling
503 : : template<>
504 : : struct action< check_dissipation > {
505 : : template< typename Input, typename Stack >
506 : 74 : static void apply( const Input& in, Stack& stack ) {
507 : : using walker::deck::neq;
508 : : using eq = tag::dissipation;
509 : : using param = tag::param;
510 : : // if there was a dissipation eq block defined
511 [ + + ]: 74 : if (neq.get< eq >() > 0) {
512 : : // Ensure a coupled velocity model is configured
513 : : couple< eq, tag::velocity, tag::velocity_id,
514 : : MsgKey::VELOCITY_DEPVAR >
515 : 6 : ( in, stack, MsgKey::VELOCITY_MISSING );
516 : : // Set C3 if not specified
517 : : auto& C3 = stack.template get< param, eq, tag::c3 >();
518 [ + - ]: 6 : if (C3.size() != neq.get< eq >()) C3.push_back( 1.0 );
519 : : // Set C4 if not specified
520 : : auto& C4 = stack.template get< param, eq, tag::c4 >();
521 [ + - ]: 6 : if (C4.size() != neq.get< eq >()) C4.push_back( 0.25 );
522 : : // Set COM1 if not specified
523 : : auto& COM1 = stack.template get< param, eq, tag::com1 >();
524 [ + - ]: 6 : if (COM1.size() != neq.get< eq >()) COM1.push_back( 0.44 );
525 : : // Set COM2 if not specified
526 : : auto& COM2 = stack.template get< param, eq, tag::com2 >();
527 [ + - ]: 6 : if (COM2.size() != neq.get< eq >()) COM2.push_back( 0.9 );
528 : : }
529 : 74 : }
530 : : };
531 : :
532 : : //! Rule used to trigger action
533 : : struct check_mixmassfracbeta : pegtl::success {};
534 : : //! \brief Do error checking on a mass fraction eq block
535 : : template<>
536 : : struct action< check_mixmassfracbeta > {
537 : : template< typename Input, typename Stack >
538 : 74 : static void apply( const Input& in, Stack& stack ) {
539 : : using walker::deck::neq;
540 : : using eq = tag::mixmassfracbeta;
541 : : // Error out if no dependent variable to solve for was selected
542 : : const auto& solve = stack.template get< tag::param, eq, tag::solve >();
543 [ - + ]: 74 : if (solve.size() != neq.get< eq >())
544 : 0 : Message< Stack, ERROR, MsgKey::NOSOLVE >( stack, in );
545 : : // if there was a mixmassfracbeta eq block defined
546 [ + + ]: 74 : if (neq.get< eq >() > 0) {
547 : : // Compute equation id if a coupled velocity model is configured
548 : : couple< eq, tag::velocity, tag::velocity_id,
549 : : MsgKey::VELOCITY_DEPVAR >
550 : 5 : ( in, stack, MsgKey::OPTIONAL );
551 : : // Compute equation id if a coupled dissipation model is configured
552 : : couple< eq, tag::dissipation, tag::dissipation_id,
553 : : MsgKey::DISSIPATION_DEPVAR >
554 : 5 : ( in, stack, MsgKey::OPTIONAL );
555 : : }
556 : 74 : }
557 : : };
558 : :
559 : : //! Rule used to trigger action
560 : : struct check_mixdirichlet : pegtl::success {};
561 : : //! \brief Error checks for the mixdirichlet sde
562 : : template<>
563 : : struct action< check_mixdirichlet > {
564 : : template< typename Input, typename Stack >
565 [ - + ]: 8 : static void apply( const Input& in, Stack& stack ) {
566 : : using eq = tag::mixdirichlet;
567 : : using walker::deck::neq;
568 : :
569 : : // Ensure correct size for parameter vector rho
570 : : auto& rho = stack.template get< tag::param, eq, tag::rho >().back();
571 : 8 : auto ncomp = stack.template get< tag::component, eq >().back();
572 [ - + ]: 8 : if (rho.size() != ncomp-2)
573 : 0 : Message< Stack, ERROR, MsgKey::MIXDIR_RHO >( stack, in );
574 : :
575 : : // If normalization is not set, set default
576 : : auto& normv = stack.template get< tag::param, eq, tag::normalization >();
577 [ - + ]: 8 : if (normv.size() != neq.get< eq >())
578 : 0 : normv.push_back( walker::ctr::NormalizationType::LIGHT );
579 : :
580 : : // Sort parameter vector rho to correct order depending on normalization
581 [ + + ]: 8 : if (normv.back() == walker::ctr::NormalizationType::HEAVY)
582 : 3 : std::sort( rho.begin(), rho.end() );
583 : : else
584 : 5 : std::sort( rho.begin(), rho.end(), std::greater< tk::real >() );
585 : 8 : }
586 : : };
587 : :
588 : : //! Rule used to trigger action
589 : : template< typename eq, typename coupledeq >
590 : : struct check_coupling : pegtl::success {};
591 : : //! Put in coupled eq depvar as '-' if no coupling is given
592 : : template< typename eq, typename coupledeq >
593 : : struct action< check_coupling< eq, coupledeq > > {
594 : : template< typename Input, typename Stack >
595 : : static void apply( const Input&, Stack& stack ) {
596 : : auto& ceq = stack.template get< tag::param, eq, coupledeq >();
597 : : const auto& depvar = stack.template get< tag::param, eq, tag::depvar >();
598 : : // A depvar of '-' means no coupling. This keeps the coupled eq vector
599 : : // size the same as that of the depvar vector, so we keep track of which
600 : : // eq is coupled to which coupled eq (and also which eq is not coupled to
601 : : // any other eq).
602 : : if (depvar.size() > ceq.size()) ceq.push_back( '-' );
603 : : Assert( depvar.size() == ceq.size(), "Vector size mismatch" );
604 : : }
605 : : };
606 : :
607 : : //! Rule used to trigger action
608 : : struct velocity_defaults : pegtl::success {};
609 : : //! \brief Set defaults for the velocity model
610 : : template<>
611 : : struct action< velocity_defaults > {
612 : : template< typename Input, typename Stack >
613 : : static void apply( const Input&, Stack& stack ) {
614 : : // Set number of components: always 3 velocity components
615 : : auto& ncomp = stack.template get< tag::component, tag::velocity >();
616 [ + - ]: 7 : ncomp.push_back( 3 );
617 : : }
618 : : };
619 : :
620 : : //! Rule used to trigger action
621 : : struct position_defaults : pegtl::success {};
622 : : //! \brief Set defaults for all Lagrangian particle position models
623 : : template<>
624 : : struct action< position_defaults > {
625 : : template< typename Input, typename Stack >
626 : 6 : static void apply( const Input&, Stack& stack ) {
627 : : // Set number of components: always 3 position components
628 : : auto& ncomp = stack.template get< tag::component, tag::position >();
629 [ - + ]: 6 : ncomp.push_back( 3 );
630 : : // Set RNG if no RNG has been selected (not all position models use this,
631 : : // so don't impose on the user to define one). Pick a Random123 generator,
632 : : // as that is always available.
633 : : using walker::deck::neq;
634 : : auto& rngs = stack.template get< tag::selected, tag::rng >();
635 : : auto& rng = stack.template get< tag::param, tag::position, tag::rng >();
636 [ - + ][ - - ]: 6 : if (rng.empty() || rng.size() != neq.get< tag::position >()) {
637 : : // add RNG to the list of selected RNGs (as it has been parsed)
638 [ + - ][ - + ]: 12 : rngs.push_back( tk::ctr::RNG().value( kw::r123_philox::string() ) );
[ - - ]
639 : : // select RNG for position equation (as it has been parsed)
640 : 6 : rng.push_back( tk::ctr::RNGType::R123_PHILOX );
641 : : }
642 : 6 : }
643 : : };
644 : :
645 : : //! Rule used to trigger action
646 : : struct dissipation_defaults : pegtl::success {};
647 : : //! \brief Set defaults for all Lagrangian particle dissipation models
648 : : template<>
649 : : struct action< dissipation_defaults > {
650 : : template< typename Input, typename Stack >
651 : : static void apply( const Input&, Stack& stack ) {
652 : : // Set number of components: always 1 dissipation component
653 : : auto& ncomp = stack.template get< tag::component, tag::dissipation >();
654 [ + - ]: 6 : ncomp.push_back( 1 );
655 : : }
656 : : };
657 : :
658 : : } // ::grm
659 : : } // ::tk
660 : :
661 : : namespace walker {
662 : :
663 : : //! Walker input deck facilitating user input for integrating SDEs
664 : : namespace deck {
665 : :
666 : : using namespace tao;
667 : :
668 : : // Walker's InputDeck grammar
669 : :
670 : : //! scan and store_back sde keyword and option
671 : : template< typename keyword, class eq >
672 : : struct scan_sde :
673 : : tk::grm::scan< typename keyword::pegtl_string,
674 : : tk::grm::store_back_option< use,
675 : : ctr::DiffEq,
676 : : tag::selected,
677 : : tag::diffeq >,
678 : : // start new vector or vectors of spikes for a potential
679 : : // jointdelta initpolicy
680 : : tk::grm::start_vector< tag::param,
681 : : eq,
682 : : tag::init,
683 : : tag::spike >,
684 : : // start new vector or vectors of beta parameters for a
685 : : // potential jointbeta initpolicy
686 : : tk::grm::start_vector< tag::param,
687 : : eq,
688 : : tag::init,
689 : : tag::betapdf >,
690 : : // start new vector or vectors of gamma parameters for a
691 : : // potential jointgamma initpolicy
692 : : tk::grm::start_vector< tag::param,
693 : : eq,
694 : : tag::init,
695 : : tag::gamma >,
696 : : // start new vector or vectors of gaussian parameters
697 : : // for a potential jointgaussian initpolicy
698 : : tk::grm::start_vector< tag::param,
699 : : eq,
700 : : tag::init,
701 : : tag::gaussian > > {};
702 : :
703 : : //! Discretization parameters
704 : : struct discretization_parameters :
705 : : pegtl::sor< tk::grm::discrparam< use, kw::npar, tag::npar >,
706 : : tk::grm::discrparam< use, kw::nstep, tag::nstep >,
707 : : tk::grm::discrparam< use, kw::term, tag::term >,
708 : : tk::grm::discrparam< use, kw::dt, tag::dt >,
709 : : tk::grm::interval_iter< use< kw::ttyi >,
710 : : tag::output, tag::iter, tag::tty >,
711 : : tk::grm::interval_iter< use< kw::pari >,
712 : : tag::output, tag::iter, tag::particles >
713 : : > {};
714 : :
715 : : //! rngs
716 : : struct rngs :
717 : : pegtl::sor<
718 : : #ifdef HAS_MKL
719 : : tk::mkl::rngs< use,
720 : : tag::selected, tag::rng,
721 : : tag::param, tag::rngmkl >,
722 : : #endif
723 : : #ifdef HAS_RNGSSE2
724 : : tk::rngsse::rngs< use,
725 : : tag::selected, tag::rng,
726 : : tag::param, tag::rngsse >,
727 : : #endif
728 : : tk::random123::rngs< use,
729 : : tag::selected, tag::rng,
730 : : tag::param, tag::rng123 > > {};
731 : :
732 : : //! SDE parameter vector
733 : : template< class keyword,
734 : : template< class, class, class... > class check_vector,
735 : : class eq, class param, class... xparams >
736 : : struct sde_parameter_vector :
737 : : tk::grm::parameter_vector< use,
738 : : use< keyword >,
739 : : tk::grm::Store_back_back,
740 : : tk::grm::start_vector,
741 : : check_vector,
742 : : eq,
743 : : param,
744 : : xparams... > {};
745 : :
746 : : //! scan icdelta ... end block
747 : : template< class eq >
748 : : struct icdelta :
749 : : pegtl::if_must<
750 : : tk::grm::readkw< use< kw::icdelta >::pegtl_string >,
751 : : // parse a spike ... end block (there can be multiple)
752 : : tk::grm::block< use< kw::end >,
753 : : tk::grm::parameter_vector<
754 : : use,
755 : : use< kw::spike >,
756 : : tk::grm::Store_back_back_back,
757 : : tk::grm::start_vector_back,
758 : : tk::grm::check_spikes,
759 : : eq,
760 : : tag::init,
761 : : tag::spike > > > {};
762 : :
763 : : //! scan icbeta ... end block
764 : : template< class eq >
765 : : struct icbeta :
766 : : pegtl::if_must<
767 : : tk::grm::readkw< use< kw::icbeta >::pegtl_string >,
768 : : // parse a betapdf ... end block (there can be multiple)
769 : : tk::grm::block< use< kw::end >,
770 : : tk::grm::parameter_vector<
771 : : use,
772 : : use< kw::betapdf >,
773 : : tk::grm::Store_back_back_back,
774 : : tk::grm::start_vector_back,
775 : : tk::grm::check_betapdfs,
776 : : eq,
777 : : tag::init,
778 : : tag::betapdf > > > {};
779 : :
780 : : //! scan icgamma ... end block
781 : : template< class eq >
782 : : struct icgamma :
783 : : pegtl::if_must<
784 : : tk::grm::readkw< use< kw::icgamma >::pegtl_string >,
785 : : // parse a gammapdf ... end block (there can be multiple)
786 : : tk::grm::block< use< kw::end >,
787 : : tk::grm::parameter_vector<
788 : : use,
789 : : use< kw::gammapdf >,
790 : : tk::grm::Store_back_back_back,
791 : : tk::grm::start_vector_back,
792 : : tk::grm::check_gammapdfs,
793 : : eq,
794 : : tag::init,
795 : : tag::gamma > > > {};
796 : :
797 : : //! scan icdirichlet ... end block
798 : : template< class eq >
799 : : struct icdirichlet :
800 : : pegtl::if_must<
801 : : tk::grm::readkw< use< kw::icdirichlet >::pegtl_string >,
802 : : // parse a dirichletpdf ... end block (there can be multiple)
803 : : tk::grm::block<
804 : : use< kw::end >,
805 : : sde_parameter_vector< kw::dirichletpdf,
806 : : tk::grm::check_dirichletpdf,
807 : : eq,
808 : : tag::init,
809 : : tag::dirichlet > > > {};
810 : :
811 : : //! scan icgaussian ... end block
812 : : template< class eq >
813 : : struct icgaussian :
814 : : pegtl::if_must<
815 : : tk::grm::readkw< use< kw::icgaussian >::pegtl_string >,
816 : : // parse a gaussian ... end block (there can be multiple)
817 : : tk::grm::block< use< kw::end >,
818 : : tk::grm::parameter_vector<
819 : : use,
820 : : use< kw::gaussian >,
821 : : tk::grm::Store_back_back_back,
822 : : tk::grm::start_vector_back,
823 : : tk::grm::check_gaussians,
824 : : eq,
825 : : tag::init,
826 : : tag::gaussian > > > {};
827 : :
828 : : //! scan icjointgaussian ... end block
829 : : template< class eq >
830 : : struct icjointgaussian :
831 : : pegtl::if_must<
832 : : tk::grm::readkw< use< kw::icjointgaussian >::pegtl_string >,
833 : : // parse a jointgaussian ... end block
834 : : tk::grm::block< use< kw::end >,
835 : : sde_parameter_vector< kw::sde_mean,
836 : : tk::grm::check_vector,
837 : : eq,
838 : : tag::init,
839 : : tag::mean >,
840 : : sde_parameter_vector< kw::sde_cov,
841 : : tk::grm::check_vector,
842 : : eq,
843 : : tag::init,
844 : : tag::cov > > > {};
845 : :
846 : : //! Error checks after an equation ... end block has been parsed
847 : : template< class eq, class... extra_checks >
848 : : struct check_errors :
849 : : pegtl::seq<
850 : : // register differential equation block
851 : : tk::grm::register_eq< eq >,
852 : : // performe extra pegtl actions, e.g., performing extra checks
853 : : extra_checks...,
854 : : // do error checking on this block
855 : : tk::grm::check_eq< eq >,
856 : : // do error checking on the init policy
857 : : tk::grm::check_init< eq > > {};
858 : :
859 : : //! SDE option vector
860 : : template< class Option, class keyword, class eq, class param,
861 : : template< class, class > class check >
862 : : struct sde_option_vector :
863 : : tk::grm::option_vector< use,
864 : : use< keyword >,
865 : : Option,
866 : : tk::grm::Store_back_back,
867 : : tk::grm::start_vector,
868 : : check,
869 : : eq,
870 : : param > {};
871 : :
872 : : //! Diagonal Ornstein-Uhlenbeck SDE
873 : : struct diag_ou :
874 : : pegtl::if_must<
875 : : scan_sde< use< kw::diag_ou >, tag::diagou >,
876 : : tk::grm::block< use< kw::end >,
877 : : tk::grm::depvar< use,
878 : : tag::diagou,
879 : : tag::depvar >,
880 : : tk::grm::component< use< kw::ncomp >,
881 : : tag::diagou >,
882 : : tk::grm::rng< use,
883 : : use< kw::rng >,
884 : : tk::ctr::RNG,
885 : : tag::diagou,
886 : : tag::rng >,
887 : : tk::grm::policy< use,
888 : : use< kw::init >,
889 : : ctr::InitPolicy,
890 : : tag::diagou,
891 : : tag::initpolicy >,
892 : : tk::grm::policy< use,
893 : : use< kw::coeff >,
894 : : ctr::CoeffPolicy,
895 : : tag::diagou,
896 : : tag::coeffpolicy >,
897 : : icdelta< tag::diagou >,
898 : : icbeta< tag::diagou >,
899 : : icgamma< tag::diagou >,
900 : : icgaussian< tag::diagou >,
901 : : icjointgaussian< tag::diagou >,
902 : : sde_parameter_vector< kw::sde_sigmasq,
903 : : tk::grm::check_vector,
904 : : tag::diagou,
905 : : tag::sigmasq >,
906 : : sde_parameter_vector< kw::sde_theta,
907 : : tk::grm::check_vector,
908 : : tag::diagou,
909 : : tag::theta >,
910 : : sde_parameter_vector< kw::sde_mu,
911 : : tk::grm::check_vector,
912 : : tag::diagou,
913 : : tag::mu > >,
914 : : check_errors< tag::diagou > > {};
915 : :
916 : : //! Ornstein-Uhlenbeck SDE
917 : : struct ornstein_uhlenbeck :
918 : : pegtl::if_must<
919 : : scan_sde< use< kw::ornstein_uhlenbeck >, tag::ou >,
920 : : tk::grm::block< use< kw::end >,
921 : : tk::grm::depvar< use,
922 : : tag::ou,
923 : : tag::depvar >,
924 : : tk::grm::component< use< kw::ncomp >,
925 : : tag::ou >,
926 : : tk::grm::rng< use,
927 : : use< kw::rng >,
928 : : tk::ctr::RNG,
929 : : tag::ou,
930 : : tag::rng >,
931 : : tk::grm::policy< use,
932 : : use< kw::init >,
933 : : ctr::InitPolicy,
934 : : tag::ou,
935 : : tag::initpolicy >,
936 : : tk::grm::policy< use,
937 : : use< kw::coeff >,
938 : : ctr::CoeffPolicy,
939 : : tag::ou,
940 : : tag::coeffpolicy >,
941 : : icdelta< tag::ou >,
942 : : icbeta< tag::ou >,
943 : : icgamma< tag::ou >,
944 : : icgaussian< tag::ou >,
945 : : icjointgaussian< tag::ou >,
946 : : sde_parameter_vector< kw::sde_sigmasq,
947 : : tk::grm::check_vector,
948 : : tag::ou,
949 : : tag::sigmasq >,
950 : : sde_parameter_vector< kw::sde_theta,
951 : : tk::grm::check_vector,
952 : : tag::ou,
953 : : tag::theta >,
954 : : sde_parameter_vector< kw::sde_mu,
955 : : tk::grm::check_vector,
956 : : tag::ou,
957 : : tag::mu > >,
958 : : check_errors< tag::ou > > {};
959 : :
960 : : //! Skew-normal SDE
961 : : struct skewnormal :
962 : : pegtl::if_must<
963 : : scan_sde< use< kw::skewnormal >, tag::skewnormal >,
964 : : tk::grm::block< use< kw::end >,
965 : : tk::grm::depvar< use,
966 : : tag::skewnormal,
967 : : tag::depvar >,
968 : : tk::grm::component< use< kw::ncomp >,
969 : : tag::skewnormal >,
970 : : tk::grm::rng< use,
971 : : use< kw::rng >,
972 : : tk::ctr::RNG,
973 : : tag::skewnormal,
974 : : tag::rng >,
975 : : tk::grm::policy< use,
976 : : use< kw::init >,
977 : : ctr::InitPolicy,
978 : : tag::skewnormal,
979 : : tag::initpolicy >,
980 : : tk::grm::policy< use,
981 : : use< kw::coeff >,
982 : : ctr::CoeffPolicy,
983 : : tag::skewnormal,
984 : : tag::coeffpolicy >,
985 : : icdelta< tag::skewnormal >,
986 : : icbeta< tag::skewnormal >,
987 : : icgamma< tag::skewnormal >,
988 : : icgaussian< tag::skewnormal >,
989 : : icjointgaussian< tag::skewnormal >,
990 : : sde_parameter_vector< kw::sde_T,
991 : : tk::grm::check_vector,
992 : : tag::skewnormal,
993 : : tag::timescale >,
994 : : sde_parameter_vector< kw::sde_sigmasq,
995 : : tk::grm::check_vector,
996 : : tag::skewnormal,
997 : : tag::sigmasq >,
998 : : sde_parameter_vector< kw::sde_lambda,
999 : : tk::grm::check_vector,
1000 : : tag::skewnormal,
1001 : : tag::lambda > >,
1002 : : check_errors< tag::skewnormal > > {};
1003 : :
1004 : : //! Beta SDE
1005 : : struct beta :
1006 : : pegtl::if_must<
1007 : : scan_sde< use< kw::beta >, tag::beta >,
1008 : : tk::grm::block< use< kw::end >,
1009 : : tk::grm::depvar< use,
1010 : : tag::beta,
1011 : : tag::depvar >,
1012 : : tk::grm::component< use< kw::ncomp >,
1013 : : tag::beta >,
1014 : : tk::grm::rng< use,
1015 : : use< kw::rng >,
1016 : : tk::ctr::RNG,
1017 : : tag::beta,
1018 : : tag::rng >,
1019 : : tk::grm::policy< use,
1020 : : use< kw::init >,
1021 : : ctr::InitPolicy,
1022 : : tag::beta,
1023 : : tag::initpolicy >,
1024 : : tk::grm::policy< use,
1025 : : use< kw::coeff >,
1026 : : ctr::CoeffPolicy,
1027 : : tag::beta,
1028 : : tag::coeffpolicy >,
1029 : : icdelta< tag::beta >,
1030 : : icbeta< tag::beta >,
1031 : : icgamma< tag::beta >,
1032 : : icgaussian< tag::beta >,
1033 : : icjointgaussian< tag::beta >,
1034 : : sde_parameter_vector< kw::sde_b,
1035 : : tk::grm::check_vector,
1036 : : tag::beta,
1037 : : tag::b >,
1038 : : sde_parameter_vector< kw::sde_S,
1039 : : tk::grm::check_vector,
1040 : : tag::beta,
1041 : : tag::S >,
1042 : : sde_parameter_vector< kw::sde_kappa,
1043 : : tk::grm::check_vector,
1044 : : tag::beta,
1045 : : tag::kappa > >,
1046 : : check_errors< tag::beta > > {};
1047 : :
1048 : : //! Number-fraction beta SDE
1049 : : struct numfracbeta :
1050 : : pegtl::if_must<
1051 : : scan_sde< use< kw::numfracbeta >, tag::numfracbeta >,
1052 : : tk::grm::block< use< kw::end >,
1053 : : tk::grm::depvar< use,
1054 : : tag::numfracbeta,
1055 : : tag::depvar >,
1056 : : tk::grm::component< use< kw::ncomp >,
1057 : : tag::numfracbeta >,
1058 : : tk::grm::rng< use,
1059 : : use< kw::rng >,
1060 : : tk::ctr::RNG,
1061 : : tag::numfracbeta,
1062 : : tag::rng >,
1063 : : tk::grm::policy< use,
1064 : : use< kw::init >,
1065 : : ctr::InitPolicy,
1066 : : tag::numfracbeta,
1067 : : tag::initpolicy >,
1068 : : tk::grm::policy< use,
1069 : : use< kw::coeff >,
1070 : : ctr::CoeffPolicy,
1071 : : tag::numfracbeta,
1072 : : tag::coeffpolicy >,
1073 : : icdelta< tag::numfracbeta >,
1074 : : icbeta< tag::numfracbeta >,
1075 : : icgamma< tag::numfracbeta >,
1076 : : icgaussian< tag::numfracbeta >,
1077 : : icjointgaussian< tag::numfracbeta >,
1078 : : sde_parameter_vector< kw::sde_b,
1079 : : tk::grm::check_vector,
1080 : : tag::numfracbeta,
1081 : : tag::b >,
1082 : : sde_parameter_vector< kw::sde_S,
1083 : : tk::grm::check_vector,
1084 : : tag::numfracbeta,
1085 : : tag::S >,
1086 : : sde_parameter_vector< kw::sde_kappa,
1087 : : tk::grm::check_vector,
1088 : : tag::numfracbeta,
1089 : : tag::kappa >,
1090 : : sde_parameter_vector< kw::sde_rho2,
1091 : : tk::grm::check_vector,
1092 : : tag::numfracbeta,
1093 : : tag::rho2 >,
1094 : : sde_parameter_vector< kw::sde_rcomma,
1095 : : tk::grm::check_vector,
1096 : : tag::numfracbeta,
1097 : : tag::rcomma > >,
1098 : : check_errors< tag::numfracbeta > > {};
1099 : :
1100 : : //! Mass-fraction beta SDE
1101 : : struct massfracbeta :
1102 : : pegtl::if_must<
1103 : : scan_sde< use< kw::massfracbeta >, tag::massfracbeta >,
1104 : : tk::grm::block< use< kw::end >,
1105 : : tk::grm::depvar< use,
1106 : : tag::massfracbeta,
1107 : : tag::depvar >,
1108 : : tk::grm::component< use< kw::ncomp >,
1109 : : tag::massfracbeta >,
1110 : : tk::grm::rng< use,
1111 : : use< kw::rng >,
1112 : : tk::ctr::RNG,
1113 : : tag::massfracbeta,
1114 : : tag::rng >,
1115 : : tk::grm::policy< use,
1116 : : use< kw::init >,
1117 : : ctr::InitPolicy,
1118 : : tag::massfracbeta,
1119 : : tag::initpolicy >,
1120 : : tk::grm::policy< use,
1121 : : use< kw::coeff >,
1122 : : ctr::CoeffPolicy,
1123 : : tag::massfracbeta,
1124 : : tag::coeffpolicy >,
1125 : : icdelta< tag::massfracbeta >,
1126 : : icbeta< tag::massfracbeta >,
1127 : : icgamma< tag::massfracbeta >,
1128 : : icgaussian< tag::massfracbeta >,
1129 : : icjointgaussian< tag::massfracbeta >,
1130 : : sde_parameter_vector< kw::sde_b,
1131 : : tk::grm::check_vector,
1132 : : tag::massfracbeta,
1133 : : tag::b >,
1134 : : sde_parameter_vector< kw::sde_S,
1135 : : tk::grm::check_vector,
1136 : : tag::massfracbeta,
1137 : : tag::S >,
1138 : : sde_parameter_vector< kw::sde_kappa,
1139 : : tk::grm::check_vector,
1140 : : tag::massfracbeta,
1141 : : tag::kappa >,
1142 : : sde_parameter_vector< kw::sde_rho2,
1143 : : tk::grm::check_vector,
1144 : : tag::massfracbeta,
1145 : : tag::rho2 >,
1146 : : sde_parameter_vector< kw::sde_r,
1147 : : tk::grm::check_vector,
1148 : : tag::massfracbeta,
1149 : : tag::r > >,
1150 : : check_errors< tag::massfracbeta > > {};
1151 : :
1152 : : //! Mix number-fraction beta SDE
1153 : : struct mixnumfracbeta :
1154 : : pegtl::if_must<
1155 : : scan_sde< use< kw::mixnumfracbeta >, tag::mixnumfracbeta >,
1156 : : tk::grm::block< use< kw::end >,
1157 : : tk::grm::depvar< use,
1158 : : tag::mixnumfracbeta,
1159 : : tag::depvar >,
1160 : : tk::grm::component< use< kw::ncomp >,
1161 : : tag::mixnumfracbeta >,
1162 : : tk::grm::rng< use,
1163 : : use< kw::rng >,
1164 : : tk::ctr::RNG,
1165 : : tag::mixnumfracbeta,
1166 : : tag::rng >,
1167 : : tk::grm::policy< use,
1168 : : use< kw::init >,
1169 : : ctr::InitPolicy,
1170 : : tag::mixnumfracbeta,
1171 : : tag::initpolicy >,
1172 : : tk::grm::policy< use,
1173 : : use< kw::coeff >,
1174 : : ctr::CoeffPolicy,
1175 : : tag::mixnumfracbeta,
1176 : : tag::coeffpolicy >,
1177 : : icdelta< tag::mixnumfracbeta >,
1178 : : icbeta< tag::mixnumfracbeta >,
1179 : : icgamma< tag::mixnumfracbeta >,
1180 : : icgaussian< tag::mixnumfracbeta >,
1181 : : icjointgaussian< tag::mixnumfracbeta >,
1182 : : sde_parameter_vector< kw::sde_bprime,
1183 : : tk::grm::check_vector,
1184 : : tag::mixnumfracbeta,
1185 : : tag::bprime >,
1186 : : sde_parameter_vector< kw::sde_S,
1187 : : tk::grm::check_vector,
1188 : : tag::mixnumfracbeta,
1189 : : tag::S >,
1190 : : sde_parameter_vector< kw::sde_kappaprime,
1191 : : tk::grm::check_vector,
1192 : : tag::mixnumfracbeta,
1193 : : tag::kappaprime >,
1194 : : sde_parameter_vector< kw::sde_rho2,
1195 : : tk::grm::check_vector,
1196 : : tag::mixnumfracbeta,
1197 : : tag::rho2 >,
1198 : : sde_parameter_vector< kw::sde_rcomma,
1199 : : tk::grm::check_vector,
1200 : : tag::mixnumfracbeta,
1201 : : tag::rcomma > >,
1202 : : check_errors< tag::mixnumfracbeta > > {};
1203 : :
1204 : : //! Mix mass-fraction beta SDE
1205 : : struct mixmassfracbeta :
1206 : : pegtl::if_must<
1207 : : scan_sde< use< kw::mixmassfracbeta >, tag::mixmassfracbeta >,
1208 : : tk::grm::block< use< kw::end >,
1209 : : tk::grm::depvar< use,
1210 : : tag::mixmassfracbeta,
1211 : : tag::depvar >,
1212 : : tk::grm::component< use< kw::ncomp >,
1213 : : tag::mixmassfracbeta >,
1214 : : tk::grm::rng< use,
1215 : : use< kw::rng >,
1216 : : tk::ctr::RNG,
1217 : : tag::mixmassfracbeta,
1218 : : tag::rng >,
1219 : : tk::grm::policy< use,
1220 : : use< kw::init >,
1221 : : ctr::InitPolicy,
1222 : : tag::mixmassfracbeta,
1223 : : tag::initpolicy >,
1224 : : tk::grm::policy< use,
1225 : : use< kw::coeff >,
1226 : : ctr::CoeffPolicy,
1227 : : tag::mixmassfracbeta,
1228 : : tag::coeffpolicy >,
1229 : : tk::grm::policy< use,
1230 : : use< kw::solve >,
1231 : : ctr::Depvar,
1232 : : tag::mixmassfracbeta,
1233 : : tag::solve >,
1234 : : icdelta< tag::mixmassfracbeta >,
1235 : : icbeta< tag::mixmassfracbeta >,
1236 : : icgamma< tag::mixmassfracbeta >,
1237 : : icgaussian< tag::mixmassfracbeta >,
1238 : : icjointgaussian< tag::mixmassfracbeta >,
1239 : : sde_option_vector< ctr::HydroTimeScales,
1240 : : kw::hydrotimescales,
1241 : : tag::mixmassfracbeta,
1242 : : tag::hydrotimescales,
1243 : : tk::grm::check_vector_size >,
1244 : : sde_option_vector< ctr::HydroProductions,
1245 : : kw::hydroproductions,
1246 : : tag::mixmassfracbeta,
1247 : : tag::hydroproductions,
1248 : : tk::grm::check_vector_size >,
1249 : : sde_parameter_vector< kw::sde_bprime,
1250 : : tk::grm::check_vector,
1251 : : tag::mixmassfracbeta,
1252 : : tag::bprime >,
1253 : : sde_parameter_vector< kw::sde_S,
1254 : : tk::grm::check_vector,
1255 : : tag::mixmassfracbeta,
1256 : : tag::S >,
1257 : : sde_parameter_vector< kw::sde_kappaprime,
1258 : : tk::grm::check_vector,
1259 : : tag::mixmassfracbeta,
1260 : : tag::kappaprime >,
1261 : : sde_parameter_vector< kw::sde_rho2,
1262 : : tk::grm::check_vector,
1263 : : tag::mixmassfracbeta,
1264 : : tag::rho2 >,
1265 : : sde_parameter_vector< kw::sde_r,
1266 : : tk::grm::check_vector,
1267 : : tag::mixmassfracbeta,
1268 : : tag::r >,
1269 : : sde_parameter_vector< kw::mean_gradient,
1270 : : tk::grm::check_mean_gradient,
1271 : : tag::mixmassfracbeta,
1272 : : tag::mean_gradient >,
1273 : : tk::grm::process<
1274 : : use< kw::velocitysde >,
1275 : : tk::grm::Store_back< tag::param,
1276 : : tag::mixmassfracbeta,
1277 : : tag::velocity >,
1278 : : pegtl::alpha >,
1279 : : tk::grm::process<
1280 : : use< kw::dissipation >,
1281 : : tk::grm::Store_back< tag::param,
1282 : : tag::mixmassfracbeta,
1283 : : tag::dissipation >,
1284 : : pegtl::alpha > >,
1285 : : check_errors< tag::mixmassfracbeta,
1286 : : tk::grm::check_vector_exists<
1287 : : tag::mixmassfracbeta,
1288 : : tag::hydrotimescales,
1289 : : tk::grm::MsgKey::HYDROTIMESCALES >,
1290 : : tk::grm::check_vector_exists<
1291 : : tag::mixmassfracbeta,
1292 : : tag::hydroproductions,
1293 : : tk::grm::MsgKey::HYDROPRODUCTIONS >,
1294 : : tk::grm::check_coupling< tag::mixmassfracbeta,
1295 : : tag::dissipation >,
1296 : : tk::grm::check_coupling< tag::mixmassfracbeta,
1297 : : tag::velocity > > > {};
1298 : :
1299 : : //! Gamma SDE
1300 : : struct gamma :
1301 : : pegtl::if_must<
1302 : : scan_sde< use< kw::gamma >, tag::gamma >,
1303 : : tk::grm::block< use< kw::end >,
1304 : : tk::grm::depvar< use,
1305 : : tag::gamma,
1306 : : tag::depvar >,
1307 : : tk::grm::component< use< kw::ncomp >,
1308 : : tag::gamma >,
1309 : : tk::grm::rng< use,
1310 : : use< kw::rng >,
1311 : : tk::ctr::RNG,
1312 : : tag::gamma,
1313 : : tag::rng >,
1314 : : tk::grm::policy< use,
1315 : : use< kw::init >,
1316 : : ctr::InitPolicy,
1317 : : tag::gamma,
1318 : : tag::initpolicy >,
1319 : : tk::grm::policy< use,
1320 : : use< kw::coeff >,
1321 : : ctr::CoeffPolicy,
1322 : : tag::gamma,
1323 : : tag::coeffpolicy >,
1324 : : icdelta< tag::gamma >,
1325 : : icbeta< tag::gamma >,
1326 : : icgamma< tag::gamma >,
1327 : : icgaussian< tag::gamma >,
1328 : : icjointgaussian< tag::gamma >,
1329 : : sde_parameter_vector< kw::sde_b,
1330 : : tk::grm::check_vector,
1331 : : tag::gamma,
1332 : : tag::b >,
1333 : : sde_parameter_vector< kw::sde_S,
1334 : : tk::grm::check_vector,
1335 : : tag::gamma,
1336 : : tag::S >,
1337 : : sde_parameter_vector< kw::sde_kappa,
1338 : : tk::grm::check_vector,
1339 : : tag::gamma,
1340 : : tag::kappa > >,
1341 : : check_errors< tag::gamma > > {};
1342 : :
1343 : : //! Dirichlet SDE
1344 : : struct dirichlet :
1345 : : pegtl::if_must<
1346 : : scan_sde< use< kw::dirichlet >, tag::dirichlet >,
1347 : : tk::grm::block< use< kw::end >,
1348 : : tk::grm::depvar< use,
1349 : : tag::dirichlet,
1350 : : tag::depvar >,
1351 : : tk::grm::component< use< kw::ncomp >,
1352 : : tag::dirichlet >,
1353 : : tk::grm::rng< use,
1354 : : use< kw::rng >,
1355 : : tk::ctr::RNG,
1356 : : tag::dirichlet,
1357 : : tag::rng >,
1358 : : tk::grm::policy< use,
1359 : : use< kw::init >,
1360 : : ctr::InitPolicy,
1361 : : tag::dirichlet,
1362 : : tag::initpolicy >,
1363 : : tk::grm::policy< use,
1364 : : use< kw::coeff >,
1365 : : ctr::CoeffPolicy,
1366 : : tag::dirichlet,
1367 : : tag::coeffpolicy >,
1368 : : icdelta< tag::dirichlet >,
1369 : : icbeta< tag::dirichlet >,
1370 : : icgamma< tag::dirichlet >,
1371 : : icgaussian< tag::dirichlet >,
1372 : : icjointgaussian< tag::dirichlet >,
1373 : : sde_parameter_vector< kw::sde_b,
1374 : : tk::grm::check_vector,
1375 : : tag::dirichlet,
1376 : : tag::b >,
1377 : : sde_parameter_vector< kw::sde_S,
1378 : : tk::grm::check_vector,
1379 : : tag::dirichlet,
1380 : : tag::S >,
1381 : : sde_parameter_vector< kw::sde_kappa,
1382 : : tk::grm::check_vector,
1383 : : tag::dirichlet,
1384 : : tag::kappa >
1385 : : >,
1386 : : check_errors< tag::dirichlet > > {};
1387 : :
1388 : : //! MixDirichlet SDE
1389 : : struct mixdirichlet :
1390 : : pegtl::if_must<
1391 : : scan_sde< use< kw::mixdirichlet >, tag::mixdirichlet >,
1392 : : tk::grm::block< use< kw::end >,
1393 : : tk::grm::depvar< use,
1394 : : tag::mixdirichlet,
1395 : : tag::depvar >,
1396 : : tk::grm::component< use< kw::ncomp >,
1397 : : tag::mixdirichlet >,
1398 : : tk::grm::rng< use,
1399 : : use< kw::rng >,
1400 : : tk::ctr::RNG,
1401 : : tag::mixdirichlet,
1402 : : tag::rng >,
1403 : : tk::grm::policy< use,
1404 : : use< kw::init >,
1405 : : ctr::InitPolicy,
1406 : : tag::mixdirichlet,
1407 : : tag::initpolicy >,
1408 : : tk::grm::policy< use,
1409 : : use< kw::coeff >,
1410 : : ctr::CoeffPolicy,
1411 : : tag::mixdirichlet,
1412 : : tag::coeffpolicy >,
1413 : : tk::grm::policy< use,
1414 : : use< kw::normalization >,
1415 : : ctr::Normalization,
1416 : : tag::mixdirichlet,
1417 : : tag::normalization >,
1418 : : icdelta< tag::mixdirichlet >,
1419 : : icbeta< tag::mixdirichlet >,
1420 : : icgamma< tag::mixdirichlet >,
1421 : : icdirichlet< tag::mixdirichlet >,
1422 : : icgaussian< tag::mixdirichlet >,
1423 : : icjointgaussian< tag::mixdirichlet >,
1424 : : sde_parameter_vector< kw::sde_b,
1425 : : tk::grm::check_vector,
1426 : : tag::mixdirichlet,
1427 : : tag::b >,
1428 : : sde_parameter_vector< kw::sde_S,
1429 : : tk::grm::check_vector,
1430 : : tag::mixdirichlet,
1431 : : tag::S >,
1432 : : sde_parameter_vector< kw::sde_kappaprime,
1433 : : tk::grm::check_vector,
1434 : : tag::mixdirichlet,
1435 : : tag::kappaprime >,
1436 : : sde_parameter_vector< kw::sde_rho,
1437 : : tk::grm::check_vector,
1438 : : tag::mixdirichlet,
1439 : : tag::rho >
1440 : : >,
1441 : : check_errors< tag::mixdirichlet,
1442 : : tk::grm::check_mixdirichlet > > {};
1443 : :
1444 : : //! Generalized Dirichlet SDE
1445 : : struct gendir :
1446 : : pegtl::if_must<
1447 : : scan_sde< use< kw::gendir >, tag::gendir >,
1448 : : tk::grm::block< use< kw::end >,
1449 : : tk::grm::depvar< use,
1450 : : tag::gendir,
1451 : : tag::depvar >,
1452 : : tk::grm::component< use< kw::ncomp >,
1453 : : tag::gendir >,
1454 : : tk::grm::rng< use,
1455 : : use< kw::rng >,
1456 : : tk::ctr::RNG,
1457 : : tag::gendir,
1458 : : tag::rng >,
1459 : : tk::grm::policy< use,
1460 : : use< kw::init >,
1461 : : ctr::InitPolicy,
1462 : : tag::gendir,
1463 : : tag::initpolicy >,
1464 : : tk::grm::policy< use,
1465 : : use< kw::coeff >,
1466 : : ctr::CoeffPolicy,
1467 : : tag::gendir,
1468 : : tag::coeffpolicy >,
1469 : : icdelta< tag::gendir >,
1470 : : icbeta< tag::gendir >,
1471 : : icgamma< tag::gendir >,
1472 : : icgaussian< tag::gendir >,
1473 : : icjointgaussian< tag::gendir >,
1474 : : sde_parameter_vector< kw::sde_b,
1475 : : tk::grm::check_vector,
1476 : : tag::gendir,
1477 : : tag::b >,
1478 : : sde_parameter_vector< kw::sde_S,
1479 : : tk::grm::check_vector,
1480 : : tag::gendir,
1481 : : tag::S >,
1482 : : sde_parameter_vector< kw::sde_kappa,
1483 : : tk::grm::check_vector,
1484 : : tag::gendir,
1485 : : tag::kappa >,
1486 : : sde_parameter_vector< kw::sde_c,
1487 : : tk::grm::check_vector,
1488 : : tag::gendir,
1489 : : tag::c > >,
1490 : : check_errors< tag::gendir > > {};
1491 : :
1492 : : //! Wright-Fisher SDE
1493 : : struct wright_fisher :
1494 : : pegtl::if_must<
1495 : : scan_sde< use< kw::wrightfisher >, tag::wrightfisher >,
1496 : : tk::grm::block< use< kw::end >,
1497 : : tk::grm::depvar< use,
1498 : : tag::wrightfisher,
1499 : : tag::depvar >,
1500 : : tk::grm::component< use< kw::ncomp >,
1501 : : tag::wrightfisher >,
1502 : : tk::grm::rng< use,
1503 : : use< kw::rng >,
1504 : : tk::ctr::RNG,
1505 : : tag::wrightfisher,
1506 : : tag::rng >,
1507 : : tk::grm::policy< use,
1508 : : use< kw::init >,
1509 : : ctr::InitPolicy,
1510 : : tag::wrightfisher,
1511 : : tag::initpolicy >,
1512 : : tk::grm::policy< use,
1513 : : use< kw::coeff >,
1514 : : ctr::CoeffPolicy,
1515 : : tag::wrightfisher,
1516 : : tag::coeffpolicy >,
1517 : : icdelta< tag::wrightfisher >,
1518 : : icbeta< tag::wrightfisher >,
1519 : : icgamma< tag::wrightfisher >,
1520 : : icgaussian< tag::wrightfisher >,
1521 : : icjointgaussian< tag::wrightfisher >,
1522 : : sde_parameter_vector< kw::sde_omega,
1523 : : tk::grm::check_vector,
1524 : : tag::wrightfisher,
1525 : : tag::omega > >,
1526 : : check_errors< tag::wrightfisher > > {};
1527 : :
1528 : : //! Velocity SDE
1529 : : struct velocity :
1530 : : pegtl::if_must<
1531 : : scan_sde< use< kw::velocitysde >, tag::velocity >,
1532 : : tk::grm::block< use< kw::end >,
1533 : : tk::grm::depvar< use,
1534 : : tag::velocity,
1535 : : tag::depvar >,
1536 : : tk::grm::rng< use,
1537 : : use< kw::rng >,
1538 : : tk::ctr::RNG,
1539 : : tag::velocity,
1540 : : tag::rng >,
1541 : : tk::grm::policy< use,
1542 : : use< kw::init >,
1543 : : ctr::InitPolicy,
1544 : : tag::velocity,
1545 : : tag::initpolicy >,
1546 : : tk::grm::policy< use,
1547 : : use< kw::coeff >,
1548 : : ctr::CoeffPolicy,
1549 : : tag::velocity,
1550 : : tag::coeffpolicy >,
1551 : : tk::grm::policy< use,
1552 : : use< kw::solve >,
1553 : : ctr::Depvar,
1554 : : tag::velocity,
1555 : : tag::solve >,
1556 : : tk::grm::policy< use,
1557 : : use< kw::variant >,
1558 : : ctr::VelocityVariant,
1559 : : tag::velocity,
1560 : : tag::variant >,
1561 : : sde_parameter_vector< kw::gravity,
1562 : : tk::grm::check_gravity,
1563 : : tag::velocity,
1564 : : tag::gravity >,
1565 : : icdelta< tag::velocity >,
1566 : : icbeta< tag::velocity >,
1567 : : icgamma< tag::velocity >,
1568 : : icgaussian< tag::velocity >,
1569 : : icjointgaussian< tag::velocity >,
1570 : : sde_option_vector< ctr::HydroTimeScales,
1571 : : kw::hydrotimescales,
1572 : : tag::velocity,
1573 : : tag::hydrotimescales,
1574 : : tk::grm::check_vector_size >,
1575 : : sde_option_vector< ctr::HydroProductions,
1576 : : kw::hydroproductions,
1577 : : tag::velocity,
1578 : : tag::hydroproductions,
1579 : : tk::grm::check_vector_size >,
1580 : : tk::grm::process<
1581 : : use< kw::sde_c0 >,
1582 : : tk::grm::Store_back< tag::param,
1583 : : tag::velocity,
1584 : : tag::c0 > >,
1585 : : tk::grm::process<
1586 : : use< kw::position >,
1587 : : tk::grm::Store_back< tag::param,
1588 : : tag::velocity,
1589 : : tag::position >,
1590 : : pegtl::alpha >,
1591 : : tk::grm::process<
1592 : : use< kw::dissipation >,
1593 : : tk::grm::Store_back< tag::param,
1594 : : tag::velocity,
1595 : : tag::dissipation >,
1596 : : pegtl::alpha >,
1597 : : tk::grm::process<
1598 : : use< kw::mixmassfracbeta >,
1599 : : tk::grm::Store_back< tag::param,
1600 : : tag::velocity,
1601 : : tag::mixmassfracbeta >,
1602 : : pegtl::alpha > >,
1603 : : check_errors< tag::velocity,
1604 : : tk::grm::velocity_defaults,
1605 : : tk::grm::check_coupling< tag::velocity,
1606 : : tag::position >,
1607 : : tk::grm::check_coupling< tag::velocity,
1608 : : tag::dissipation >,
1609 : : tk::grm::check_coupling< tag::velocity,
1610 : : tag::mixmassfracbeta > > > {};
1611 : :
1612 : : //! position equation
1613 : : struct position :
1614 : : pegtl::if_must<
1615 : : scan_sde< use< kw::position >, tag::position >,
1616 : : tk::grm::block< use< kw::end >,
1617 : : tk::grm::depvar< use,
1618 : : tag::position,
1619 : : tag::depvar >,
1620 : : tk::grm::rng< use,
1621 : : use< kw::rng >,
1622 : : tk::ctr::RNG,
1623 : : tag::position,
1624 : : tag::rng >,
1625 : : tk::grm::policy< use,
1626 : : use< kw::init >,
1627 : : ctr::InitPolicy,
1628 : : tag::position,
1629 : : tag::initpolicy >,
1630 : : tk::grm::policy< use,
1631 : : use< kw::coeff >,
1632 : : ctr::CoeffPolicy,
1633 : : tag::position,
1634 : : tag::coeffpolicy >,
1635 : : tk::grm::policy< use,
1636 : : use< kw::solve >,
1637 : : ctr::Depvar,
1638 : : tag::position,
1639 : : tag::solve >,
1640 : : icdelta< tag::position >,
1641 : : icbeta< tag::position >,
1642 : : icgamma< tag::position >,
1643 : : icgaussian< tag::position >,
1644 : : icjointgaussian< tag::position >,
1645 : : tk::grm::process<
1646 : : use< kw::velocitysde >,
1647 : : tk::grm::Store_back< tag::param,
1648 : : tag::position,
1649 : : tag::velocity >,
1650 : : pegtl::alpha > >,
1651 : : check_errors< tag::position,
1652 : : tk::grm::position_defaults,
1653 : : tk::grm::check_coupling< tag::position,
1654 : : tag::velocity > > > {};
1655 : :
1656 : : //! dissipation equation
1657 : : struct dissipation :
1658 : : pegtl::if_must<
1659 : : scan_sde< use< kw::dissipation >, tag::dissipation >,
1660 : : tk::grm::block< use< kw::end >,
1661 : : tk::grm::depvar< use,
1662 : : tag::dissipation,
1663 : : tag::depvar >,
1664 : : tk::grm::rng< use,
1665 : : use< kw::rng >,
1666 : : tk::ctr::RNG,
1667 : : tag::dissipation,
1668 : : tag::rng >,
1669 : : tk::grm::policy< use,
1670 : : use< kw::init >,
1671 : : ctr::InitPolicy,
1672 : : tag::dissipation,
1673 : : tag::initpolicy >,
1674 : : tk::grm::policy< use,
1675 : : use< kw::coeff >,
1676 : : ctr::CoeffPolicy,
1677 : : tag::dissipation,
1678 : : tag::coeffpolicy >,
1679 : : tk::grm::process<
1680 : : use< kw::sde_c3 >,
1681 : : tk::grm::Store_back< tag::param,
1682 : : tag::dissipation,
1683 : : tag::c3 > >,
1684 : : tk::grm::process<
1685 : : use< kw::sde_c4 >,
1686 : : tk::grm::Store_back< tag::param,
1687 : : tag::dissipation,
1688 : : tag::c4 > >,
1689 : : tk::grm::process<
1690 : : use< kw::sde_com1 >,
1691 : : tk::grm::Store_back< tag::param,
1692 : : tag::dissipation,
1693 : : tag::com1 > >,
1694 : : tk::grm::process<
1695 : : use< kw::sde_com2 >,
1696 : : tk::grm::Store_back< tag::param,
1697 : : tag::dissipation,
1698 : : tag::com2 > >,
1699 : : icdelta< tag::dissipation >,
1700 : : icbeta< tag::dissipation >,
1701 : : icgamma< tag::dissipation >,
1702 : : icgaussian< tag::dissipation >,
1703 : : icjointgaussian< tag::dissipation >,
1704 : : tk::grm::process<
1705 : : use< kw::velocitysde >,
1706 : : tk::grm::Store_back< tag::param,
1707 : : tag::dissipation,
1708 : : tag::velocity >,
1709 : : pegtl::alpha > >,
1710 : : check_errors< tag::dissipation,
1711 : : tk::grm::dissipation_defaults,
1712 : : tk::grm::check_coupling< tag::dissipation,
1713 : : tag::velocity > > > {};
1714 : :
1715 : : //! stochastic differential equations
1716 : : struct sde :
1717 : : pegtl::sor< dirichlet,
1718 : : mixdirichlet,
1719 : : gendir,
1720 : : wright_fisher,
1721 : : ornstein_uhlenbeck,
1722 : : diag_ou,
1723 : : skewnormal,
1724 : : gamma,
1725 : : beta,
1726 : : numfracbeta,
1727 : : massfracbeta,
1728 : : mixnumfracbeta,
1729 : : mixmassfracbeta,
1730 : : position,
1731 : : dissipation,
1732 : : velocity > {};
1733 : :
1734 : :
1735 : : //! 'walker' block
1736 : : struct walker :
1737 : : pegtl::if_must<
1738 : : tk::grm::readkw< use< kw::walker >::pegtl_string >,
1739 : : pegtl::sor<
1740 : : pegtl::seq<
1741 : : tk::grm::block<
1742 : : use< kw::end >,
1743 : : discretization_parameters,
1744 : : sde,
1745 : : tk::grm::rngblock< use, rngs >,
1746 : : tk::grm::statistics< use, tk::grm::store_walker_option >,
1747 : : tk::grm::pdfs< use, tk::grm::store_walker_option > >,
1748 : : tk::grm::check_velocity,
1749 : : tk::grm::check_position,
1750 : : tk::grm::check_dissipation,
1751 : : tk::grm::check_mixmassfracbeta >,
1752 : : tk::grm::msg< tk::grm::MsgType::ERROR,
1753 : : tk::grm::MsgKey::UNFINISHED > > > {};
1754 : :
1755 : : //! main keywords
1756 : : struct keywords :
1757 : : pegtl::sor< tk::grm::title< use >, walker > {};
1758 : :
1759 : : //! entry point: parse keywords and ignores until eof
1760 : : struct read_file :
1761 : : tk::grm::read_file< keywords, tk::grm::ignore > {};
1762 : :
1763 : : } // deck::
1764 : : } // walker::
1765 : :
1766 : : #endif // WalkerInputDeckGrammar_h
|
