Branch data Line data Source code
1 : : // *****************************************************************************
2 : : /*!
3 : : \file src/Control/Keywords.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 Definition of all keywords
9 : : \details This file contains the definition of all keywords, including those
10 : : of command-line argument parsers as well as input, i.e., control, file
11 : : parsers. All keywords are shared among all parsers of all executables.
12 : :
13 : : All keywords are case-sensitive.
14 : :
15 : : The information contained in this file is used to build data structures for
16 : : on-screen help on the command-line arguments and control file keywords,
17 : : available via the --help, --helpctr, and --helpkw command-line arguments.
18 : :
19 : : A note on design: Defining structs that have static member functions
20 : : returning a std::string is a way of storing C++-style strings at
21 : : compile-time (which is not possible in a straightforward manner at this
22 : : time). This could also be done with C-style const char* as well. The
23 : : '*_info' structs store these strings, which then is used to specialize the
24 : : _kw::keyword_ template, defined in Control/Keyword.hpp. Specializing the
25 : : _keyword_ template also requires a specification of the precise string of
26 : : characters that make up a keyword eventually matched by the parsers. Since
27 : : these are all template arguments, the construction of keywords, their help,
28 : : as well as all grammars, are entirely assembled at compile-time. Since the
29 : : '*_info' struct member functions are static, they can be called without
30 : : instantiating an object and thus available at compile-time.
31 : :
32 : : The definition of an '*_info' struct _requires_ at least the name, short,
33 : : and long descriptions, defined by member functions _name()_,
34 : : _shortDescription()_, and _longDescription()_, respectively. Everything else
35 : : is optional. However, when adding a new keyword it is highly recommended to
36 : : define all of the _optional_ members if they make sense for the given
37 : : keyword. If an expect value type is also given, that can be hooked up into
38 : : where it is used.
39 : :
40 : : The most general definition of a keyword is as follows:
41 : :
42 : : \code{.cpp}
43 : : // Keyword info definition
44 : : struct keyword_info {
45 : :
46 : : // Required very short name, usually a single word or (for e.g.
47 : : // policies) a single character. This can be the keyword itself, but
48 : : // does not have to be. This field is used as an id of the option or
49 : : // setting.
50 : : static std::string name() { return "Name"; }
51 : :
52 : : // Required short keyword description
53 : : static std::string shortDescription() { return "Short description"; }
54 : :
55 : : // Required detailed keyword description. This returns a string literal,
56 : : // since this is usually multi-line and it is less work to maintain this
57 : : // way.
58 : : static std::string longDescription() { return
59 : : R"(Longer, possibly multi-line description of the keyword. Example
60 : : usage of the keyword is welcome here. Don't worry about formatting:
61 : : when this field is printed, extra spaces will be removed and line
62 : : breaks will be inserted.)";
63 : : }
64 : :
65 : : // Optional keyword alias. See also kw::Alias and
66 : : // <tpl_install_dir>/include/pegtl/pegtl/constants.hh for examples
67 : : // of what can be passed as template arguments (basically single
68 : : // characters). The one below defines the character 'c' as the alias.
69 : : // Aliases are single character long. The idea of an alias is to have a
70 : : // long as well as a short keyword for the same functionality.
71 : : // Currently, this is only hooked up for command-line arguments and not
72 : : // for control-file keywords, which is intentional. Command-line
73 : : // arguments are a lot less than control file keywords and are more
74 : : // frequently typed by the user. Thus command-line argument aliases are
75 : : // user-friendly. There are many control file keywords and aliases would
76 : : // only cause confusion. Defining an alias for a command-line argument
77 : : // enables the command-line parser to match on '--longer_keyword' as
78 : : // well as on '-c'. Depending on whether the alias typedef is defined
79 : : // for a keyword or not, the correct grammar is automatically generated
80 : : // at compile-time, matching on both the longer keyword as well as on
81 : : // the alias. Defining an alias for a control file keyword can be done
82 : : // but has no effect in a control file parser.
83 : : using alias = Alias< c >;
84 : :
85 : : // Optional single-character (policy) code. See also kw::Code and
86 : : // <tpl_install_dir/include/pegtl/pegtl/constants.hh for examples
87 : : // of what can be passed as template arguments (basically single
88 : : // characters). The one below defines the character 'C' as the (policy)
89 : : // code. This code is used for abbreviating policies used to configure
90 : : // various orthogonal behaviors of classes using policy-based design.
91 : : using code = Code< C >;
92 : :
93 : : // Optional expected data for the keyword - bundled to struct expect.
94 : : // This struct is entirely optional within a keyword definition.
95 : : // However, if it is defined, it must at least define the static member
96 : : // function description() which returns the description of the type the
97 : : // keyword expects. It may also optionally define the following fields:
98 : : //
99 : : // - type - defining the expected type
100 : : // - lower - lower bound of the expected value
101 : : // - upper - upper bound of the expected value
102 : : // - choices - valid choices for the expected value
103 : : //
104 : : struct expect {
105 : :
106 : : // If this struct is defined, required expected type description, max
107 : : // 10 characters long
108 : : static std::string description() { return "int"; }
109 : :
110 : : // Optional expected type
111 : : using type = std::streamsize;
112 : :
113 : : // Optional expected value lower bound
114 : : static const type lower = 1;
115 : :
116 : : // Optional expected value upper bound
117 : : static const type upper = 10;
118 : :
119 : : // Optional expected valid choices description, here giving
120 : : // information on the expected type and the valid bounds. Note that
121 : : // this can be any string, but if they exist, it is a good idea give
122 : : // at least some information on the bounds, as below, since the bounds
123 : : // are NOT displayed in the help for a keyword. This decision keeps
124 : : // the bounds specifications generic since they can be any type. As a
125 : : // result, the help structures, defined in HelpFactory.hpp, are simpler
126 : : // as they do not have to be parameterized by the type of the bounds,
127 : : // which greatly simplifies that code.
128 : : static std::string choices() {
129 : : return "integer [" + std::to_string(lower) + "..." +
130 : : std::to_string(upper) + ']';
131 : : }
132 : :
133 : : };
134 : :
135 : : };
136 : :
137 : : // Keyword definition, passing the above info struct as the first
138 : : // template argument, and the rest of the template arguments are the
139 : : // characters of the keyword to be matched by the parser. Remember: all
140 : : // keywords are case-sensitive. This one contrived example below defines
141 : : // keyword 'kw', matching the keyword 'KeYwOrD'.
142 : : using kw = keyword< keyword_info, K,e,Y,w,O,r,D >;
143 : : \endcode
144 : : \see Control/Keyword.hpp
145 : : \see Control/HelpFactory.hpp
146 : : */
147 : : // *****************************************************************************
148 : : #ifndef Keywords_h
149 : : #define Keywords_h
150 : :
151 : : #include <limits>
152 : :
153 : : #undef I
154 : : #include <pegtl/contrib/alphabet.hpp>
155 : :
156 : : #include "Types.hpp"
157 : : #include "Keyword.hpp"
158 : : #include "WalkerBuildConfig.hpp"
159 : :
160 : : //! Keywords used by all input deck and command line parsers
161 : : namespace kw {
162 : :
163 : : using namespace tao::pegtl::alphabet;
164 : :
165 : : struct title_info {
166 : : static std::string name() { return "title"; }
167 [ + - ]: 1382 : static std::string shortDescription() { return "Set analysis title"; }
168 : 691 : static std::string longDescription() { return
169 [ + - ]: 1382 : R"(The analysis title may be specified in the input file using the 'title'
170 : : keyword. The 'title' keyword must be followed by a double-quoted string
171 : : specifying the analysis title. Example: title "Example problem".
172 : : Specifying a title is optional.)";
173 : : }
174 : : struct expect {
175 : : using type = std::string;
176 [ + - ]: 1382 : static std::string description() { return "string"; }
177 : : };
178 : : };
179 : : using title = keyword< title_info, TAOCPP_PEGTL_STRING("title") >;
180 : :
181 : : struct end_info {
182 : : static std::string name() { return "end"; }
183 [ + - ]: 1382 : static std::string shortDescription() { return "End of an input block"; }
184 : 691 : static std::string longDescription() { return
185 [ + - ]: 1382 : R"(The end of a block is given by the 'end' keyword in the input file.
186 : : Example: "rngs ... end".)";
187 : : }
188 : : };
189 : : using end = keyword< end_info, TAOCPP_PEGTL_STRING("end") >;
190 : :
191 : : struct help_info {
192 : : static std::string name() { return "help"; }
193 : 1484 : static std::string shortDescription() { return
194 [ + - ]: 2968 : R"(Display one-liner help on all command-line arguments)"; }
195 : 1484 : static std::string longDescription() { return
196 [ + - ]: 2968 : R"(Get a short one-liner help on all command-line arguments from an
197 : : executable. It also triggers the help from the Charm++ runtime system and in
198 : : addition to that of the executable, it also lists command-line arguments
199 : : from Converse Machine, Tracing, Load Balancer, Record/Replay, and Charm++
200 : : command-line parameters.)";
201 : : }
202 : : using alias = Alias< h >;
203 : : };
204 : : using help = keyword< help_info, TAOCPP_PEGTL_STRING("help") >;
205 : :
206 : : struct helpctr_info {
207 : : static std::string name() { return "helpctr"; }
208 : 1479 : static std::string shortDescription() { return
209 [ + - ]: 2958 : "Display one-liner help on all control file keywords"; }
210 : 1479 : static std::string longDescription() { return
211 [ + - ]: 2958 : R"(This keyword can be used to get a short one-liner help on all control
212 : : file keywords from an executable.)";
213 : : }
214 : : using alias = Alias< C >;
215 : : };
216 : : using helpctr = keyword< helpctr_info, TAOCPP_PEGTL_STRING("helpctr") >;
217 : :
218 : : struct helpkw_info {
219 : : static std::string name() { return "helpkw"; }
220 : 1484 : static std::string shortDescription() { return
221 [ + - ]: 2968 : "Display verbose help on a single keyword"; }
222 : 1484 : static std::string longDescription() { return
223 [ + - ]: 2968 : R"(This keyword can be used to get a verbose help on a single command-line
224 : : argument or control-file keyword (i.e., help on keyword) from an
225 : : executable.)";
226 : : }
227 : : using alias = Alias< H >;
228 : : struct expect {
229 : : using type = std::string;
230 [ + - ]: 2968 : static std::string description() { return "string"; }
231 : : };
232 : : };
233 : : using helpkw = keyword< helpkw_info, TAOCPP_PEGTL_STRING("helpkw") >;
234 : :
235 : : struct seed_info {
236 : : static std::string name() { return "seed"; }
237 : 691 : static std::string shortDescription() { return
238 [ + - ]: 1382 : "Set random number generator seed"; }
239 : 691 : static std::string longDescription() { return
240 [ + - ]: 1382 : R"(This keyword is used to specify a seed for a random number generator
241 : : Example: rngmkl_mcg31 seed 1234 end)";
242 : : }
243 : : struct expect {
244 : : using type = unsigned int;
245 [ + - ]: 1382 : static std::string description() { return "uint"; }
246 : : };
247 : : };
248 : : using seed = keyword< seed_info, TAOCPP_PEGTL_STRING("seed") >;
249 : :
250 : : struct mkl_mcg31_info {
251 [ + - ]: 3408 : static std::string name() { return "MKL MCG311"; }
252 : 691 : static std::string shortDescription() { return
253 [ + - ]: 1382 : "Select Intel MKL MCG31 RNG"; }
254 : 691 : static std::string longDescription() { return
255 [ + - ]: 1382 : R"(This keyword is used to select 'VSL_BRNG_MCG31', a 31-bit multiplicative
256 : : congruential random number generator, provided by Intel's Math Kernel
257 : : Library (MKL).)";
258 : : }
259 : : };
260 : : using mkl_mcg31 = keyword< mkl_mcg31_info, TAOCPP_PEGTL_STRING("mkl_mcg31") >;
261 : :
262 : : struct mkl_r250_info {
263 [ + - ]: 3408 : static std::string name() { return "MKL R250"; }
264 : 691 : static std::string shortDescription() { return
265 [ + - ]: 1382 : "Select Intel MKL R250 RNG"; }
266 : 691 : static std::string longDescription() { return
267 [ + - ]: 1382 : R"(This keyword is used to select 'VSL_BRNG_R250', a generalized feedback
268 : : shift register random number generator, provided by Intel's Math Kernel
269 : : Library (MKL).)";
270 : : }
271 : : };
272 : : using mkl_r250 = keyword< mkl_r250_info, TAOCPP_PEGTL_STRING("mkl_r250") >;
273 : :
274 : : struct mkl_mrg32k3a_info {
275 [ + - ]: 3408 : static std::string name() { return "MKL MRG32K3A"; }
276 : 691 : static std::string shortDescription() { return
277 [ + - ]: 1382 : "Select Intel MKL MRG32K3A RNG"; }
278 : 691 : static std::string longDescription() { return
279 [ + - ]: 1382 : R"(This keyword is used to select 'VSL_BRNG_MRG32K3A', a combined multiple
280 : : recursive random number generator with two components of order 3,
281 : : provided by Intel's Math Kernel Library (MKL).)";
282 : : }
283 : : };
284 : : using mkl_mrg32k3a =
285 : : keyword< mkl_mrg32k3a_info, TAOCPP_PEGTL_STRING("mkl_mrg32k3a") >;
286 : :
287 : : struct mkl_mcg59_info {
288 [ + - ]: 3408 : static std::string name() { return "MKL MCG59"; }
289 : 691 : static std::string shortDescription() { return
290 [ + - ]: 1382 : "Select Intel MKL MCG59 RNG"; }
291 : 691 : static std::string longDescription() { return
292 [ + - ]: 1382 : R"(This keyword is used to select 'VSL_BRNG_MCG59', a 59-bit multiplicative
293 : : congruential random number generator, provided by Intel's Math Kernel
294 : : Library (MKL).)";
295 : : }
296 : : };
297 : :
298 : : using mkl_mcg59 = keyword< mkl_mcg59_info, TAOCPP_PEGTL_STRING("mkl_mcg59") >;
299 : :
300 : : struct mkl_wh_info {
301 [ + - ]: 3408 : static std::string name() { return "MKL WH"; }
302 : 691 : static std::string shortDescription() { return
303 [ + - ]: 1382 : "Select Intel MKL WH RNG"; }
304 : 691 : static std::string longDescription() { return
305 [ + - ]: 1382 : R"(This keyword is used to select 'VSL_BRNG_WH', a set of 273 Wichmann-Hill
306 : : combined multiplicative congruential random number generators, provided
307 : : by Intel's Math Kernel Library (MKL).)";
308 : : }
309 : : };
310 : : using mkl_wh = keyword< mkl_wh_info, TAOCPP_PEGTL_STRING("mkl_wh") >;
311 : :
312 : : struct mkl_mt19937_info {
313 [ + - ]: 3408 : static std::string name() { return "MKL MT19937"; }
314 : 691 : static std::string shortDescription() { return
315 [ + - ]: 1382 : "Select Intel MKL MT19937 RNG"; }
316 : 691 : static std::string longDescription() { return
317 [ + - ]: 1382 : R"(This keyword is used to select 'VSL_BRNG_MT19937', a Mersenne Twister
318 : : pseudorandom number generator, provided by Intel's Math Kernel Library
319 : : (MKL).)";
320 : : }
321 : : };
322 : : using mkl_mt19937 =
323 : : keyword< mkl_mt19937_info, TAOCPP_PEGTL_STRING("mkl_mt19937") >;
324 : :
325 : : struct mkl_mt2203_info {
326 [ + - ]: 3408 : static std::string name() { return "MKL MT2203"; }
327 : 691 : static std::string shortDescription() { return
328 [ + - ]: 1382 : "Select Intel MKL MT2203 RNG"; }
329 : 691 : static std::string longDescription() { return
330 [ + - ]: 1382 : R"(This keyword is used to select 'VSL_BRNG_MT2203', a set of 6024 Mersenne
331 : : Twister pseudorandom number generators, available in Intel's Math Kernel
332 : : Library (MKL).)";
333 : : }
334 : : };
335 : : using mkl_mt2203 = keyword< mkl_mt2203_info, TAOCPP_PEGTL_STRING("mkl_mt2203") >;
336 : :
337 : : struct mkl_sfmt19937_info {
338 [ + - ]: 3408 : static std::string name() { return "MKL SFMT19937"; }
339 : 691 : static std::string shortDescription() { return
340 [ + - ]: 1382 : "Select Intel MKL SFMT19937 RNG"; }
341 : 691 : static std::string longDescription() { return
342 [ + - ]: 1382 : R"(This keyword is used to select 'VSL_BRNG_SFMT19937', a SIMD-oriented Fast
343 : : Mersenne Twister pseudorandom number generator, provided by Intel's Math
344 : : Kernel Library (MKL).)";
345 : : }
346 : : };
347 : : using mkl_sfmt19937 =
348 : : keyword< mkl_sfmt19937_info, TAOCPP_PEGTL_STRING("mkl_sfmt19937") >;
349 : :
350 : : struct mkl_sobol_info {
351 [ + - ]: 3408 : static std::string name() { return "MKL SOBOL"; }
352 : 691 : static std::string shortDescription() { return
353 [ + - ]: 1382 : "Select Intel MKL SOBOL RNG"; }
354 : 691 : static std::string longDescription() { return
355 [ + - ]: 1382 : R"(This keyword is used to select 'VSL_BRNG_SOBOL', a 32-bit Gray code-based
356 : : random number generator, producing low-discrepancy sequences for
357 : : dimensions 1 .le. s .le. 40 with available user-defined dimensions, provided
358 : : by Intel's Math Kernel Library (MKL).)";
359 : : }
360 : : };
361 : : using mkl_sobol = keyword< mkl_sobol_info, TAOCPP_PEGTL_STRING("mkl_sobol") >;
362 : :
363 : : struct mkl_niederr_info {
364 [ + - ]: 3408 : static std::string name() { return "MKL NIEDERR"; }
365 : 691 : static std::string shortDescription() { return
366 [ + - ]: 1382 : "Select Intel MKL NIEDERR RNG"; }
367 : 691 : static std::string longDescription() { return
368 [ + - ]: 1382 : R"(This keyword is used to select 'VSL_BRNG_NIEDERR', a 32-bit Gray
369 : : code-based random number generator, producing low-discrepancy sequences
370 : : for dimensions 1 .le. s .le. 318 with available user-defined dimensions,
371 : : provided by Intel's Math Kernel Library (MKL).)";
372 : : }
373 : : };
374 : : using mkl_niederr = keyword< mkl_niederr_info, TAOCPP_PEGTL_STRING("mkl_niederr") >;
375 : :
376 : : struct mkl_iabstract_info {
377 : : static std::string name() { return "MKL IABSTRACT"; }
378 : : static std::string shortDescription() { return
379 : : "Select Intel MKL IABSTRACT RNG"; }
380 : : static std::string longDescription() { return
381 : : R"(This keyword is used to select 'VSL_BRNG_IABSTRACT', an abstract random
382 : : number generator for integer arrays, provided by Intel's Math Kernel
383 : : Library (MKL).)";
384 : : }
385 : : };
386 : : using mkl_iabstract =
387 : : keyword< mkl_iabstract_info, TAOCPP_PEGTL_STRING("mkl_iabstract") >;
388 : :
389 : : struct mkl_dabstract_info {
390 : : static std::string name() { return "MKL DABSTRACT"; }
391 : : static std::string shortDescription() { return
392 : : "Select Intel MKL DABSTRACT RNG"; }
393 : : static std::string longDescription() { return
394 : : R"(This keyword is used to select 'VSL_BRNG_DABSTRACT', an abstract random
395 : : number generator for double-precision floating-point arrays, provided by
396 : : Intel's Math Kernel Library (MKL).)";
397 : : }
398 : : };
399 : : using mkl_dabstract =
400 : : keyword< mkl_dabstract_info, TAOCPP_PEGTL_STRING("mkl_dabstract") >;
401 : :
402 : : struct mkl_sabstract_info {
403 : : static std::string name() { return "MKL SABSTRACT"; }
404 : : static std::string shortDescription() { return
405 : : "Select Intel MKL SABSTRACT RNG"; }
406 : : static std::string longDescription() { return
407 : : R"(This keyword is used to select 'VSL_BRNG_SABSTRACT', an abstract random
408 : : number generator for single-precision floating-point arrays, provided by
409 : : Intel's Math Kernel Library (MKL).)";
410 : : }
411 : : };
412 : : using mkl_sabstract =
413 : : keyword< mkl_sabstract_info, TAOCPP_PEGTL_STRING("mkl_sabstract") >;
414 : :
415 : : struct mkl_nondeterm_info {
416 [ + - ]: 3408 : static std::string name() { return "MKL NONDETERM"; }
417 : 691 : static std::string shortDescription() { return
418 [ + - ]: 1382 : "Select Intel MKL NONDETERM RNG"; }
419 : 691 : static std::string longDescription() { return
420 [ + - ]: 1382 : R"(This keyword is used to select 'VSL_BRNG_NONDETERM', a non-deterministic
421 : : random number generator, provided by Intel's Math Kernel Library (MKL).)";
422 : : }
423 : : };
424 : : using mkl_nondeterm =
425 : : keyword< mkl_nondeterm_info, TAOCPP_PEGTL_STRING("mkl_nondeterm") >;
426 : :
427 : : struct standard_info {
428 [ + - ]: 766 : static std::string name() { return "standard"; }
429 : 691 : static std::string shortDescription() { return
430 [ + - ]: 1382 : "Select the standard algorithm for uniform RNG"; }
431 : 691 : static std::string longDescription() { return
432 [ + - ]: 1382 : R"(This keyword is used to select the standard method used to generate
433 : : uniform random numbers using the Intel Math Kernel Library (MKL) random
434 : : number generators. Valid options are 'standard' and 'accurate'.)";
435 : : }
436 : : };
437 : : using standard = keyword< standard_info, TAOCPP_PEGTL_STRING("standard") >;
438 : :
439 : : struct accurate_info {
440 [ + - ]: 766 : static std::string name() { return "accurate"; }
441 : 691 : static std::string shortDescription() { return
442 [ + - ]: 1382 : "Select the accurate algorithm for uniform RNG"; }
443 : 691 : static std::string longDescription() { return
444 [ + - ]: 1382 : R"(This keyword is used to select the accurate method used to generate
445 : : uniform random numbers using the Intel Math Kernel Library (MKL) random
446 : : number generators. Valid options are 'standard' and 'accurate'.)";
447 : : }
448 : : };
449 : : using accurate = keyword< accurate_info, TAOCPP_PEGTL_STRING("accurate") >;
450 : :
451 : : struct uniform_method_info {
452 : : static std::string name() { return "uniform method"; }
453 : 691 : static std::string shortDescription() { return
454 [ + - ]: 1382 : "Select an Intel MKL uniform RNG method"; }
455 : 691 : static std::string longDescription() { return
456 [ + - ]: 1382 : R"(This keyword is used to specify the method used to generate uniform
457 : : random numbers using the Intel Math Kernel Library (MKL) random number
458 : : generators. Valid options are 'standard' and 'accurate'.)";
459 : : }
460 : : struct expect {
461 [ + - ]: 1382 : static std::string description() { return "string"; }
462 : 691 : static std::string choices() {
463 [ + - ][ + - ]: 1382 : return '\'' + standard::string() + "\' | \'"
[ + - ]
464 [ + - ][ + - ]: 2764 : + accurate::string() + '\'';
465 : : }
466 : : };
467 : : };
468 : : using uniform_method =
469 : : keyword< uniform_method_info, TAOCPP_PEGTL_STRING("uniform_method") >;
470 : :
471 : : struct boxmuller_info {
472 [ + - ]: 1368 : static std::string name() { return "Box-Muller"; }
473 : 691 : static std::string shortDescription() { return
474 [ + - ]: 1382 : "Select the Box-Muller algorithm for sampling a Gaussian"; }
475 : 691 : static std::string longDescription() { return
476 [ + - ]: 1382 : R"(This keyword is used to select the Box-Muller method used to generate
477 : : Gaussian random numbers using the Intel Math Kernel Library (MKL) random
478 : : random number generators. Valid options are 'boxmuller', 'boxmuller2',
479 : : and 'icdf'.)";
480 : : }
481 : : };
482 : : using boxmuller = keyword< boxmuller_info, TAOCPP_PEGTL_STRING("boxmuller") >;
483 : :
484 : : struct boxmuller2_info {
485 [ + - ]: 1368 : static std::string name() { return "Box-Muller 2"; }
486 : 691 : static std::string shortDescription() { return
487 [ + - ]: 1382 : "Select the Box-Muller 2 algorithm for sampling a Gaussian"; }
488 : 691 : static std::string longDescription() { return
489 [ + - ]: 1382 : R"(This keyword is used to specify the Box-Muller 2 method used to generate
490 : : Gaussian random numbers using the Intel Math Kernel Library (MKL) random
491 : : number generators.)";
492 : : }
493 : : };
494 : : using boxmuller2 = keyword< boxmuller2_info, TAOCPP_PEGTL_STRING("boxmuller2") >;
495 : :
496 : : struct icdf_info {
497 [ + - ]: 1368 : static std::string name() { return "ICDF"; }
498 : 691 : static std::string shortDescription() { return
499 [ + - ]: 1382 : R"(Use inverse cumulative distribution function for sampling a Gaussian)"; }
500 : 691 : static std::string longDescription() { return
501 [ + - ]: 1382 : R"(This keyword is used to specify the inverse cumulative distribution
502 : : function (ICDF) method used to generate Gaussian random numbers using the
503 : : Intel Math Kernel Library (MKL) random number generators.)";
504 : : }
505 : : };
506 : : using icdf = keyword< icdf_info, TAOCPP_PEGTL_STRING("icdf") >;
507 : :
508 : : struct gaussian_method_info {
509 : : static std::string name() { return "Gaussian method"; }
510 : 691 : static std::string shortDescription() { return
511 [ + - ]: 1382 : "Select an Intel MKL Gaussian RNG method"; }
512 : 691 : static std::string longDescription() { return
513 [ + - ]: 1382 : R"(This keyword is used to specify the method used to generate Gaussian
514 : : random numbers using the Intel Math Kernel Library (MKL) random number
515 : : generators. Valid options are 'boxmuller', 'boxmuller2', and 'icdf'.)";
516 : : }
517 : : struct expect {
518 [ + - ]: 1382 : static std::string description() { return "string"; }
519 : 691 : static std::string choices() {
520 [ + - ][ + - ]: 1382 : return '\'' + boxmuller::string() + "\' | \'"
[ + - ]
521 [ + - ][ + - ]: 2764 : + boxmuller2::string() + "\' | \'"
[ + - ]
522 [ + - ][ + - ]: 2764 : + icdf::string() + '\'';
523 : : }
524 : : };
525 : : };
526 : : using gaussian_method =
527 : : keyword< gaussian_method_info, TAOCPP_PEGTL_STRING("gaussian_method") >;
528 : :
529 : : struct gaussianmv_method_info {
530 : : static std::string name() { return "multi-variate Gaussian method"; }
531 : 691 : static std::string shortDescription() { return
532 [ + - ]: 1382 : "Select an Intel MKL multi-variate Gaussian RNG method"; }
533 : 691 : static std::string longDescription() { return
534 [ + - ]: 1382 : R"(This keyword is used to specify the method used to generate multi-variate
535 : : Gaussian random numbers using the Intel Math Kernel Library (MKL) random
536 : : number generators. Valid options are 'boxmuller', 'boxmuller2', and
537 : : 'icdf'.)";
538 : : }
539 : : struct expect {
540 [ + - ]: 1382 : static std::string description() { return "string"; }
541 : 691 : static std::string choices() {
542 [ + - ][ + - ]: 1382 : return '\'' + boxmuller::string() + "\' | \'"
[ + - ]
543 [ + - ][ + - ]: 2764 : + boxmuller2::string() + "\' | \'"
[ + - ]
544 [ + - ][ + - ]: 2764 : + icdf::string() + '\'';
545 : : }
546 : : };
547 : : };
548 : : using gaussianmv_method =
549 : : keyword< gaussianmv_method_info, TAOCPP_PEGTL_STRING("gaussianmv_method") >;
550 : :
551 : : struct cja_info {
552 [ + - ]: 758 : static std::string name() { return "CJA"; }
553 : 691 : static std::string shortDescription() { return
554 [ + - ]: 1382 : "Select the Cheng, Johnk, Atkinson algorithm for sampling a beta"; }
555 : 691 : static std::string longDescription() { return
556 [ + - ]: 1382 : R"(This keyword is used to select the Cheng-Johnk-Atkinson method used to
557 : : generate beta random numbers using the Intel Math Kernel Library (MKL)
558 : : random number generators.)";
559 : : }
560 : : };
561 : : using cja = keyword< cja_info, TAOCPP_PEGTL_STRING("cja") >;
562 : :
563 : : struct cja_accurate_info {
564 [ + - ]: 758 : static std::string name() { return "CJA accurate"; }
565 : 691 : static std::string shortDescription() { return
566 [ + - ]: 1382 : "Select the accurate Cheng, Johnk, Atkinson algorithm for sampling a beta"; }
567 : 691 : static std::string longDescription() { return
568 [ + - ]: 1382 : R"(This keyword is used to select the accurate version of the
569 : : Cheng-Johnk-Atkinson method used to generate beta random numbers using the
570 : : Intel Math Kernel Library (MKL) random number generators.)";
571 : : }
572 : : };
573 : : using cja_accurate =
574 : : keyword< cja_accurate_info, TAOCPP_PEGTL_STRING("cja_accurate") >;
575 : :
576 : : struct beta_method_info {
577 : : static std::string name() { return "Beta method"; }
578 : 691 : static std::string shortDescription() { return
579 [ + - ]: 1382 : "Select an Intel MKL beta RNG method"; }
580 : 691 : static std::string longDescription() { return
581 [ + - ]: 1382 : R"(This keyword is used to specify the method used to generate beta
582 : : random numbers using the Intel Math Kernel Library (MKL) random number
583 : : generators. Valid options are 'cja' and 'cja_accurate'.)";
584 : : }
585 : : struct expect {
586 [ + - ]: 1382 : static std::string description() { return "string"; }
587 : 691 : static std::string choices() {
588 [ + - ][ + - ]: 1382 : return '\'' + cja::string() + "\' | \'"
[ + - ]
589 [ + - ][ + - ]: 2764 : + cja_accurate::string() + '\'';
590 : : }
591 : : };
592 : : };
593 : : using beta_method =
594 : : keyword< beta_method_info, TAOCPP_PEGTL_STRING("beta_method") >;
595 : :
596 : : struct gnorm_info {
597 [ + - ]: 758 : static std::string name() { return "GNORM"; }
598 : 691 : static std::string shortDescription() { return
599 [ + - ]: 1382 : "Select the GNORM (see MKL doc) algorithm for sampling a gamma"; }
600 : 691 : static std::string longDescription() { return
601 [ + - ]: 1382 : R"(This keyword is used to select the GNORM method used to
602 : : generate gamma random numbers using the Intel Math Kernel Library (MKL)
603 : : random number generators.)";
604 : : }
605 : : };
606 : : using gnorm = keyword< gnorm_info, TAOCPP_PEGTL_STRING("gnorm") >;
607 : :
608 : : struct gnorm_accurate_info {
609 [ + - ]: 758 : static std::string name() { return "GNORM accurate"; }
610 : 691 : static std::string shortDescription() { return
611 [ + - ]: 1382 : "Select the accurate GNORM (see MKL doc) algorithm for sampling a gamma"; }
612 : 691 : static std::string longDescription() { return
613 [ + - ]: 1382 : R"(This keyword is used to select the accurate version of the
614 : : GNORM method used to generate gamma random numbers using the
615 : : Intel Math Kernel Library (MKL) random number generator.)";
616 : : }
617 : : };
618 : : using gnorm_accurate =
619 : : keyword< gnorm_accurate_info, TAOCPP_PEGTL_STRING("gnorm_accurate") >;
620 : :
621 : : struct gamma_method_info {
622 : : static std::string name() { return "Gamma method"; }
623 : 691 : static std::string shortDescription() { return
624 [ + - ]: 1382 : "Select an Intel MKL gamma RNG method"; }
625 : 691 : static std::string longDescription() { return
626 [ + - ]: 1382 : R"(This keyword is used to specify the method used to generate gamma
627 : : random numbers using the Intel Math Kernel Library (MKL) random number
628 : : generators. Valid options are 'gnorm' and 'gnorm_accurate'.)";
629 : : }
630 : : struct expect {
631 [ + - ]: 1382 : static std::string description() { return "string"; }
632 : 691 : static std::string choices() {
633 [ + - ][ + - ]: 1382 : return '\'' + gnorm::string() + "\' | \'"
[ + - ]
634 [ + - ][ + - ]: 2764 : + gnorm_accurate::string() + '\'';
635 : : }
636 : : };
637 : : };
638 : : using gamma_method =
639 : : keyword< gamma_method_info, TAOCPP_PEGTL_STRING("gamma_method") >;
640 : :
641 : : struct rngsse_gm19_info {
642 [ + - ]: 3408 : static std::string name() { return "RNGSSE GM19"; }
643 : 691 : static std::string shortDescription() { return
644 [ + - ]: 1382 : "Select RNGSSE GM19 RNG"; }
645 : 691 : static std::string longDescription() { return
646 [ + - ]: 1382 : R"(This keyword is used to select the GM19 random number generator, using a
647 : : method based on parallel evolution of an ensemble of transformations of
648 : : a two-dimensional torus, provided by the RNGSSE2 random number generator
649 : : library. For more info on RNGSSE see
650 : : https://doi.org/10.1016/j.cpc.2011.03.022.)";
651 : : }
652 : : };
653 : : using rngsse_gm19 =
654 : : keyword< rngsse_gm19_info, TAOCPP_PEGTL_STRING("rngsse_gm19") >;
655 : :
656 : : struct rngsse_gm29_info {
657 [ + - ]: 3408 : static std::string name() { return "RNGSSE GM29"; }
658 : 691 : static std::string shortDescription() { return
659 [ + - ]: 1382 : "Select RNGSSE GM29 RNG"; }
660 : 691 : static std::string longDescription() { return
661 [ + - ]: 1382 : R"(This keyword is used to select the GM29 generator, using a method based
662 : : on parallel evolution of an ensemble of transformations of a
663 : : two-dimensional torus, provided by the RNGSSE2 random number generator
664 : : library. For more info on RNGSSE see
665 : : https://doi.org/10.1016/j.cpc.2011.03.022.)";
666 : : }
667 : : };
668 : : using rngsse_gm29 =
669 : : keyword< rngsse_gm29_info, TAOCPP_PEGTL_STRING("rngsse_gm29") >;
670 : :
671 : : struct rngsse_gm31_info {
672 [ + - ]: 3408 : static std::string name() { return "RNGSSE GM31"; }
673 : 691 : static std::string shortDescription() { return
674 [ + - ]: 1382 : "Select RNGSSE GM31 RNG"; }
675 : 691 : static std::string longDescription() { return
676 [ + - ]: 1382 : R"(This keyword is used to select the GM31 generator, using a method based
677 : : on parallel evolution of an ensemble of transformations of a
678 : : two-dimensional torus, provided by the RNGSSE2 random number generator
679 : : library. For more info on RNGSSE see
680 : : https://doi.org/10.1016/j.cpc.2011.03.022.)";
681 : : }
682 : : };
683 : : using rngsse_gm31 =
684 : : keyword< rngsse_gm31_info, TAOCPP_PEGTL_STRING("rngsse_gm31") >;
685 : :
686 : : struct rngsse_gm55_info {
687 [ + - ]: 3408 : static std::string name() { return "RNGSSE GM55"; }
688 : 691 : static std::string shortDescription() { return
689 [ + - ]: 1382 : "Select RNGSSE GM55 RNG"; }
690 : 691 : static std::string longDescription() { return
691 [ + - ]: 1382 : R"(This keyword is used to select the GM55 generator, using a method based
692 : : on parallel evolution of an ensemble of transformations of a
693 : : two-dimensional torus, provided by the RNGSSE2 random number generator
694 : : library. For more info on RNGSSE see
695 : : https://doi.org/10.1016/j.cpc.2011.03.022.)";
696 : : }
697 : : };
698 : : using rngsse_gm55 =
699 : : keyword< rngsse_gm55_info, TAOCPP_PEGTL_STRING("rngsse_gm55") >;
700 : :
701 : : struct rngsse_gm61_info {
702 [ + - ]: 3408 : static std::string name() { return "RNGSSE GM61"; }
703 : 691 : static std::string shortDescription() { return
704 [ + - ]: 1382 : "Select RNGSSE GM61 RNG"; }
705 : 691 : static std::string longDescription() { return
706 [ + - ]: 1382 : R"(This keyword is used to select the GM61 generator, using a method based
707 : : on parallel evolution of an ensemble of transformations of a
708 : : two-dimensional torus, provided by the RNGSSE2 random number generator
709 : : library. For more info on RNGSSE see
710 : : https://doi.org/10.1016/j.cpc.2011.03.022.)";
711 : : }
712 : : };
713 : : using rngsse_gm61 =
714 : : keyword< rngsse_gm61_info, TAOCPP_PEGTL_STRING("rngsse_gm61") >;
715 : :
716 : : struct rngsse_gq581_info {
717 [ + - ]: 3408 : static std::string name() { return "RNGSSE GQ58.1"; }
718 : 691 : static std::string shortDescription() { return
719 [ + - ]: 1382 : "Select RNGSSE GQ58.1 RNG"; }
720 : 691 : static std::string longDescription() { return
721 [ + - ]: 1382 : R"(This keyword is used to select the GQ58.1 generator, using a method based
722 : : on parallel evolution of an ensemble of transformations of a
723 : : two-dimensional torus, provided by the RNGSSE2 random number generator
724 : : library. For more info on RNGSSE see
725 : : https://doi.org/10.1016/j.cpc.2011.03.022.)";
726 : : }
727 : : };
728 : : using rngsse_gq581 =
729 : : keyword< rngsse_gq581_info, TAOCPP_PEGTL_STRING("rngsse_gq58.1") >;
730 : :
731 : : struct rngsse_gq583_info {
732 [ + - ]: 3408 : static std::string name() { return "RNGSSE GQ58.3"; }
733 : 691 : static std::string shortDescription() { return
734 [ + - ]: 1382 : "Select RNGSSE GQ58.3 RNG"; }
735 : 691 : static std::string longDescription() { return
736 [ + - ]: 1382 : R"(This keyword is used to select the GQ58.3 generator, using a method based
737 : : on parallel evolution of an ensemble of transformations of a
738 : : two-dimensional torus, provided by the RNGSS2 random number generator
739 : : library. For more info on RNGSSE see
740 : : https://doi.org/10.1016/j.cpc.2011.03.022.)";
741 : : }
742 : : };
743 : : using rngsse_gq583 =
744 : : keyword< rngsse_gq583_info, TAOCPP_PEGTL_STRING("rngsse_gq58.3") >;
745 : :
746 : : struct rngsse_gq584_info {
747 [ + - ]: 3408 : static std::string name() { return "RNGSSE GQ58.4"; }
748 : 691 : static std::string shortDescription() { return
749 [ + - ]: 1382 : "Select RNGSSE GQ58.4 RNG"; }
750 : 691 : static std::string longDescription() { return
751 [ + - ]: 1382 : R"(This keyword is used to select the GQ58.4 generator, using a method based
752 : : on parallel evolution of an ensemble of transformations of a
753 : : two-dimensional torus, provided by the RNGSSE2 random number generator
754 : : library. For more info on RNGSSE see
755 : : https://doi.org/10.1016/j.cpc.2011.03.022.)";
756 : : }
757 : : };
758 : : using rngsse_gq584 =
759 : : keyword< rngsse_gq584_info, TAOCPP_PEGTL_STRING("rngsse_gq58.4") >;
760 : :
761 : : struct rngsse_mt19937_info {
762 [ + - ]: 3408 : static std::string name() { return "RNGSSE MT19937"; }
763 : 691 : static std::string shortDescription() { return
764 [ + - ]: 1382 : "Select RNGSSE MT19937 RNG"; }
765 : 691 : static std::string longDescription() { return
766 [ + - ]: 1382 : R"(This keyword is used to select the MT19937 generator, a Mersenne Twister
767 : : generator, provided by the RNGSSE2 random number generator library. For
768 : : more info on RNGSSE see https://doi.org/10.1016/j.cpc.2011.03.022.)";
769 : : }
770 : : };
771 : : using rngsse_mt19937 =
772 : : keyword< rngsse_mt19937_info, TAOCPP_PEGTL_STRING("rngsse_mt19937") >;
773 : :
774 : : struct rngsse_lfsr113_info {
775 [ + - ]: 3408 : static std::string name() { return "RNGSSE LSFR113"; }
776 : 691 : static std::string shortDescription() { return
777 [ + - ]: 1382 : "Select RNGSSE LFSR113 RNG"; }
778 : 691 : static std::string longDescription() { return
779 [ + - ]: 1382 : R"(This keyword is used to select the LFSR113 generator, provided by the
780 : : RNGSSE2 random number generator library. For more info on RNGSSE see
781 : : https://doi.org/10.1016/j.cpc.2011.03.022.)";
782 : : }
783 : : };
784 : : using rngsse_lfsr113 =
785 : : keyword< rngsse_lfsr113_info, TAOCPP_PEGTL_STRING("rngsse_lfsr113") >;
786 : :
787 : : struct rngsse_mrg32k3a_info {
788 [ + - ]: 3408 : static std::string name() { return "RNGSSE MRG32K3A"; }
789 : 691 : static std::string shortDescription() { return
790 [ + - ]: 1382 : "Select RNGSSE MRG32K3A RNG"; }
791 : 691 : static std::string longDescription() { return
792 [ + - ]: 1382 : R"(This keyword is used to select the MRG32K3A generator, a combined
793 : : multiple recursive random number generator with two components of order
794 : : 3, provided by the RNGSS2 random number generator library. For more info
795 : : on RNGSSE see https://doi.org/10.1016/j.cpc.2011.03.022.)";
796 : : }
797 : : };
798 : : using rngsse_mrg32k3a =
799 : : keyword< rngsse_mrg32k3a_info, TAOCPP_PEGTL_STRING("rngsse_mrg32k3a") >;
800 : :
801 : : struct seq_short_info {
802 [ + - ]: 10 : static std::string name() { return "short"; }
803 : : static std::string shortDescription() { return
804 : : "Select the short sequence length for an RNGSSE2 RNG"; }
805 : : static std::string longDescription() { return
806 : : R"(This keyword is used to select the short sequence length used by the
807 : : RNGSSE2 random number generator library. Valid options are 'short',
808 : : 'medium', and 'long'. For more info on RNGSSE see
809 : : https://doi.org/10.1016/j.cpc.2011.03.022.)";
810 : : }
811 : : };
812 : : using seq_short = keyword< seq_short_info, TAOCPP_PEGTL_STRING("short") >;
813 : :
814 : : struct seq_med_info {
815 [ + - ]: 10 : static std::string name() { return "medium"; }
816 : : static std::string shortDescription() { return
817 : : "Select the medium sequence length for an RNGSSE2 RNG"; }
818 : : static std::string longDescription() { return
819 : : R"(This keyword is used to select the medium sequence length used by the
820 : : RNGSSE2 random number generator library. Valid options are 'short',
821 : : 'medium', and 'long'. For more info on RNGSSE see
822 : : https://doi.org/10.1016/j.cpc.2011.03.022.)";
823 : : }
824 : : };
825 : : using seq_med = keyword< seq_med_info, TAOCPP_PEGTL_STRING("medium") >;
826 : :
827 : : struct seq_long_info {
828 [ + - ]: 10 : static std::string name() { return "long"; }
829 : : static std::string shortDescription() { return
830 : : "Select the long sequence length for an RNGSSE2 RNG"; }
831 : : static std::string longDescription() { return
832 : : R"(This keyword is used to select the medium sequence length used by the
833 : : RNGSSE2 random number generator library. Valid options are 'short',
834 : : 'medium', and 'long'. For more info on RNGSSE see
835 : : https://doi.org/10.1016/j.cpc.2011.03.022.)";
836 : : }
837 : : };
838 : : using seq_long = keyword< seq_long_info, TAOCPP_PEGTL_STRING("long") >;
839 : :
840 : : struct seqlen_info {
841 : : static std::string name() { return "RNGSSE2 sequence length"; }
842 : 691 : static std::string shortDescription() { return
843 [ + - ]: 1382 : "Specify the RNGSSE RNG sequence length"; }
844 : 691 : static std::string longDescription() { return
845 [ + - ]: 1382 : R"(This keyword is used to select a random number generator sequence length,
846 : : used by the RNGSSE2 random number generator library. Valid options are
847 : : 'short', 'medium', and 'long'. For more info on RNGSSE see
848 : : https://doi.org/10.1016/j.cpc.2011.03.022.)";
849 : : }
850 : : struct expect {
851 [ + - ]: 1382 : static std::string description() { return "string"; }
852 : 691 : static std::string choices() {
853 [ + - ][ + - ]: 1382 : return '\'' + seq_short::string() + "\' | \'"
[ + - ]
854 [ + - ][ + - ]: 2764 : + seq_med::string() + "\' | \'"
[ + - ]
855 [ + - ][ + - ]: 2764 : + seq_long::string() + '\'';
856 : : }
857 : : };
858 : : };
859 : : using seqlen = keyword< seqlen_info, TAOCPP_PEGTL_STRING("seqlen") >;
860 : :
861 : : struct r123_threefry_info {
862 [ + - ]: 3408 : static std::string name() { return "Random123 ThreeFry"; }
863 : 691 : static std::string shortDescription() { return
864 [ + - ]: 1382 : "Select Random123 ThreeFry RNG"; }
865 : 691 : static std::string longDescription() { return
866 [ + - ]: 1382 : R"(This keyword is used to select the ThreeFry generator, related to the
867 : : Threefish block cipher from Skein Hash Function, provided by the Random123
868 : : random number generator library. For more info on Random123 see
869 : : http://dl.acm.org/citation.cfm?doid=2063405.)";
870 : : }
871 : : };
872 : : using r123_threefry =
873 : : keyword< r123_threefry_info, TAOCPP_PEGTL_STRING("r123_threefry") >;
874 : :
875 : : struct r123_philox_info {
876 [ + - ]: 3408 : static std::string name() { return "Random123 Philox"; }
877 : 691 : static std::string shortDescription() { return
878 [ + - ]: 1382 : "Select Random123 Philox RNG"; }
879 : 691 : static std::string longDescription() { return
880 [ + - ]: 1382 : R"(This keyword is used to select the Philox generator, based on Feistel
881 : : network and integer multiplication, provided by the Random123
882 : : random number generator library. For more info on Random123 see
883 : : http://dl.acm.org/citation.cfm?doid=2063405.)";
884 : : }
885 : : };
886 : : using r123_philox =
887 : : keyword< r123_philox_info, TAOCPP_PEGTL_STRING("r123_philox") >;
888 : :
889 : : struct pdfs_info {
890 : : static std::string name() { return "PDFs block"; }
891 : 655 : static std::string shortDescription() { return
892 [ + - ]: 1310 : "Start of probability density function (PDF) input block"; }
893 : 655 : static std::string longDescription() { return
894 [ + - ]: 1310 : R"(This keyword is used to start a block in the input file containing the
895 : : descriptions and settings of requested output for probability density
896 : : functions (PDFs). Example: "pdfs mypdf( y1 : 1.0e-2 ) end", which
897 : : requests a single-variate PDF to be output to file, whose sample space
898 : : variable is y1, using automatic determination of the bounds of the sample
899 : : space, using 1.0e-2 as the sample space bin size, and call the PDF
900 : : "mypdf". For more info on the structure of the pdfs ... end block, see
901 : : doc/pages/statistics_output.dox.)";
902 : : }
903 : : };
904 : : using pdfs = keyword< pdfs_info, TAOCPP_PEGTL_STRING("pdfs") >;
905 : :
906 : : struct txt_info {
907 [ + - ]: 64 : static std::string name() { return "txt"; }
908 : 655 : static std::string shortDescription() { return
909 [ + - ]: 1310 : "Select ASCII output for outputing PDFs"; }
910 : 655 : static std::string longDescription() { return
911 [ + - ]: 1310 : R"(This keyword is used to select the text
912 : : output file type of a requested probability density function (PDF) within
913 : : a pdfs ... end block. Example: "filetype txt", which selects text-file
914 : : output. Valid options are 'txt', 'gmshtxt', 'gmshbin', and 'exodusii'.
915 : : For more info on the structure of the pdfs ... end block, see
916 : : doc/pages/statistics_output.dox.)"; }
917 : : };
918 : : using txt = keyword< txt_info, TAOCPP_PEGTL_STRING("txt") >;
919 : :
920 : : struct gmshtxt_info {
921 [ + - ]: 64 : static std::string name() { return "gmshtxt"; }
922 : 655 : static std::string shortDescription() { return
923 [ + - ]: 1310 : "Select Gmsh ASCII output for outputing PDFs"; }
924 : 655 : static std::string longDescription() { return
925 [ + - ]: 1310 : R"(This keyword is used to select the ASCII
926 : : (text) output file type readable by Gmsh of a requested probability
927 : : density function (PDF) within a pdfs ... end block. Example: "filetype
928 : : gmshtxt", which selects Gmsh ASCII file output. Valid options are 'txt',
929 : : 'gmshtxt', 'gmshbin', and 'exodusii'. For more info on the structure of
930 : : the pdfs ... end block, see doc/pages/statistics_output.dox. For more
931 : : info on Gmsh, see http://www.geuz.org/gmsh.)"; }
932 : : };
933 : : using gmshtxt = keyword< gmshtxt_info, TAOCPP_PEGTL_STRING("gmshtxt") >;
934 : :
935 : : struct gmshbin_info {
936 [ + - ]: 64 : static std::string name() { return "gmshbin"; }
937 : 655 : static std::string shortDescription() { return
938 [ + - ]: 1310 : "Select Gmsh binary output for outputing PDFs"; }
939 : 655 : static std::string longDescription() { return
940 [ + - ]: 1310 : R"(This keyword is used to select the
941 : : binary output file type readable by Gmsh of a requested probability
942 : : density function (PDF) within a pdfs ... end block. Example: "filetype
943 : : gmshbin", which selects Gmsh binary file output. Valid options are 'txt',
944 : : 'gmshtxt', 'gmshbin', and 'exodusii'. For more info on the structure of
945 : : the pdfs ... end block, see doc/pages/statistics_output.dox. For more
946 : : info on Gmsh, see http://www.geuz.org/gmsh.)"; }
947 : : };
948 : : using gmshbin = keyword< gmshbin_info, TAOCPP_PEGTL_STRING("gmshbin") >;
949 : :
950 : : struct exodusii_info {
951 [ + - ]: 64 : static std::string name() { return "exo"; }
952 : 655 : static std::string shortDescription() { return
953 [ + - ]: 1310 : "Select ExodusII output"; }
954 : 655 : static std::string longDescription() { return
955 [ + - ]: 1310 : R"(This keyword is used to select the
956 : : ExodusII output file type readable by, e.g., ParaView of either a requested
957 : : probability density function (PDF) within a pdfs ... end block or for
958 : : mesh-based field output in a field_output ... end block. Example:
959 : : "filetype exodusii", which selects ExodusII file output. For more info on
960 : : ExodusII, see http://sourceforge.net/projects/exodusii.)";
961 : : }
962 : : };
963 : : using exodusii = keyword< exodusii_info, TAOCPP_PEGTL_STRING("exodusii") >;
964 : :
965 : : struct root_info {
966 : : static std::string name() { return "root"; }
967 : : static std::string shortDescription() { return
968 : : "Select Root output"; }
969 : : static std::string longDescription() { return
970 : : R"(This keyword is used to select the Root output file type readable by the
971 : : Root framework from CERN for mesh-based field output in a field_output ...
972 : : end block. Example: "filetype root", which selects the root file output
973 : : format. For more info on Root, see https://root.cern.ch.)";
974 : : }
975 : : };
976 : : using root = keyword< root_info, TAOCPP_PEGTL_STRING("root") >;
977 : :
978 : : struct filetype_info {
979 : : static std::string name() { return "filetype"; }
980 : 655 : static std::string shortDescription() { return
981 [ + - ]: 1310 : "Select output file type"; }
982 : 655 : static std::string longDescription() { return
983 [ + - ]: 1310 : R"(This keyword is used to specify the output file type of a requested
984 : : probability density function (PDF) within a pdfs ... end block or for
985 : : mesh-based field output in a field_output ... end block. Example:
986 : : "filetype exodusii", which selects ExodusII output. Valid options depend on
987 : : which block the keyword is used: in a pdfs ... end the valid choices are
988 : : 'txt', 'gmshtxt', 'gmshbin', and 'exodusii', in a field_output ... end
989 : : block the valid choices are 'exodusii' and 'root'.)"; }
990 : : struct expect {
991 [ + - ]: 1310 : static std::string description() { return "string"; }
992 : 655 : static std::string choices() {
993 [ + - ][ + - ]: 1310 : return '\'' + txt::string() + "\' | \'"
[ + - ]
994 [ + - ][ + - ]: 2620 : + gmshtxt::string() + "\' | \'"
[ + - ]
995 [ + - ][ + - ]: 2620 : + gmshbin::string() + "\' | \'"
[ + - ]
996 [ + - ][ + - ]: 2620 : + root::string() + "\' | \'"
[ + - ]
997 [ + - ][ + - ]: 2620 : + exodusii::string() + '\'';
998 : : }
999 : : };
1000 : :
1001 : : };
1002 : : using filetype = keyword< filetype_info, TAOCPP_PEGTL_STRING("filetype") >;
1003 : :
1004 : : struct overwrite_info {
1005 [ + - ]: 64 : static std::string name() { return "overwrite"; }
1006 : 655 : static std::string shortDescription() { return
1007 [ + - ]: 1310 : "Select PDF output policy overwrite"; }
1008 : 655 : static std::string longDescription() { return
1009 [ + - ]: 1310 : R"(This keyword is used to select the
1010 : : the 'overwrite' output file policy for requested probability density
1011 : : functions (PDFs) within a pdfs ... end block. Example: "policy
1012 : : overwrite", which selects the overwrite output file policy. The
1013 : : overwrite policy overwrites the same output file containing a single time
1014 : : step. Valid PDF policy options are 'overwrite', 'multiple', and
1015 : : 'evolution'. For more info on the structure of the pdfs ... end block,
1016 : : see doc/pages/statistics_output.dox.)"; }
1017 : : };
1018 : : using overwrite = keyword< overwrite_info, TAOCPP_PEGTL_STRING("overwrite") >;
1019 : :
1020 : : struct multiple_info {
1021 [ + - ]: 64 : static std::string name() { return "multiple"; }
1022 : 655 : static std::string shortDescription() { return
1023 [ + - ]: 1310 : "Select PDF output policy multiple"; }
1024 : 655 : static std::string longDescription() { return
1025 [ + - ]: 1310 : R"(This keyword is used to select
1026 : : the 'multiple' output file policy for requested probability density
1027 : : functions (PDFs) within a pdfs ... end block. Example: "policy
1028 : : multiple", which selects the multiple output file policy. The
1029 : : multiple policy output creates a new file for each time step. Valid PDF
1030 : : policy options are 'overwrite', 'multiple', and 'evolution'. For more
1031 : : info on the structure of the pdfs ... end block, see
1032 : : doc/pages/statistics_output.dox.)"; }
1033 : : };
1034 : : using multiple = keyword< multiple_info, TAOCPP_PEGTL_STRING("multiple") >;
1035 : :
1036 : : struct evolution_info {
1037 [ + - ]: 64 : static std::string name() { return "evolution"; }
1038 : 655 : static std::string shortDescription() { return
1039 [ + - ]: 1310 : "Select PDF output policy evolution"; }
1040 : 655 : static std::string longDescription() { return
1041 [ + - ]: 1310 : R"(This keyword is used to select
1042 : : the 'evolution' output file policy for requested probability density
1043 : : functions (PDFs) within a pdfs ... end block. Example: "policy
1044 : : evolution", which selects the evolution output file policy. The
1045 : : evolution policy output appends new time step to the same output file for
1046 : : each time instant, yielding a time evolution of data in a single file.
1047 : : Valid PDF policy options are 'overwrite', 'multiple', and 'evolution'. For
1048 : : more info on the structure of the pdfs ... end block, see
1049 : : doc/pages/statistics_output.dox.)";
1050 : : }
1051 : : };
1052 : : using evolution = keyword< evolution_info, TAOCPP_PEGTL_STRING("evolution") >;
1053 : :
1054 : : struct policy_info {
1055 : : static std::string name() { return "policy"; }
1056 : 655 : static std::string shortDescription() { return
1057 [ + - ]: 1310 : "Select PDF output file policy"; }
1058 : 655 : static std::string longDescription() { return
1059 [ + - ]: 1310 : R"(This keyword is used to select
1060 : : the output file policy for requested probability density functions
1061 : : (PDFs) within a pdfs ... end block. Example: "policy overwrite", which
1062 : : selects the overwrite output file policy. Valid options are 'overwrite',
1063 : : 'multiple', and 'evolution'. For more info on the structure of the
1064 : : pdfs ... end block, see doc/pages/statistics_output.dox.)";
1065 : : }
1066 : : struct expect {
1067 [ + - ]: 1310 : static std::string description() { return "string"; }
1068 : 655 : static std::string choices() {
1069 [ + - ][ + - ]: 1310 : return '\'' + overwrite::string() + "\' | \'"
[ + - ]
1070 [ + - ][ + - ]: 2620 : + multiple::string() + "\' | \'"
[ + - ]
1071 [ + - ][ + - ]: 2620 : + evolution::string() + '\'';
1072 : : }
1073 : : };
1074 : : };
1075 : : using pdf_policy = keyword< policy_info, TAOCPP_PEGTL_STRING("policy") >;
1076 : :
1077 : : struct txt_float_default_info {
1078 [ + - ]: 254 : static std::string name() { return "default"; }
1079 : 655 : static std::string shortDescription() { return
1080 [ + - ]: 1310 : "Select the default ASCII floating-point output"; }
1081 : 655 : static std::string longDescription() { return
1082 [ + - ]: 1310 : R"(This keyword is used to select the
1083 : : 'default' floating-point output format for ASCII floating-point real
1084 : : number output. Example: "format default", which selects the default
1085 : : floating-point output. Valid options are 'default', 'fixed', and
1086 : : 'scientific'. For more info on these various formats, see
1087 : : http://en.cppreference.com/w/cpp/io/manip/fixed.)";
1088 : : }
1089 : : };
1090 : : using txt_float_default =
1091 : : keyword< txt_float_default_info, TAOCPP_PEGTL_STRING("default") >;
1092 : :
1093 : : struct txt_float_scientific_info {
1094 [ + - ]: 254 : static std::string name() { return "scientific"; }
1095 : 655 : static std::string shortDescription() { return
1096 [ + - ]: 1310 : "Select the scientific ASCII floating-point output"; }
1097 : 655 : static std::string longDescription() { return
1098 [ + - ]: 1310 : R"(This keyword is used to select the
1099 : : 'scientific' floating-point output format for ASCII floating-point real
1100 : : number output. Example: "format scientific", which selects the
1101 : : scientific floating-point output. Valid options are 'default', 'fixed',
1102 : : and 'scientific'. For more info on these various formats, see
1103 : : http://en.cppreference.com/w/cpp/io/manip/fixed.)";
1104 : : }
1105 : : };
1106 : : using txt_float_scientific =
1107 : : keyword< txt_float_scientific_info, TAOCPP_PEGTL_STRING("scientific") >;
1108 : :
1109 : : struct txt_float_fixed_info {
1110 [ + - ]: 254 : static std::string name() { return "fixed"; }
1111 : 655 : static std::string shortDescription() { return
1112 [ + - ]: 1310 : "Select the fixed ASCII floating-point output"; }
1113 : 655 : static std::string longDescription() { return
1114 [ + - ]: 1310 : R"(This keyword is used to select the
1115 : : 'fixed' floating-point output format for ASCII floating-point real
1116 : : number output. Example: \"format fixed\", which selects the fixed
1117 : : floating-point output. Valid options are 'default', 'fixed', and
1118 : : 'scientific'. For more info on these various formats, see
1119 : : http://en.cppreference.com/w/cpp/io/manip/fixed.)";
1120 : : }
1121 : : };
1122 : : using txt_float_fixed = keyword< txt_float_fixed_info, TAOCPP_PEGTL_STRING("fixed") >;
1123 : :
1124 : : struct txt_float_format_info {
1125 : : static std::string name() { return "float format"; }
1126 : 655 : static std::string shortDescription() { return
1127 [ + - ]: 1310 : "Specify the ASCII floating-point output format"; }
1128 : 655 : static std::string longDescription() { return
1129 [ + - ]: 1310 : R"(This keyword is used to select the
1130 : : floating-point output format for ASCII floating-point number output.
1131 : : Example: "format scientific", which selects the scientific
1132 : : floating-point output. Valid options are 'default', 'fixed', and
1133 : : 'scientific'. For more info on these various formats, see
1134 : : http://en.cppreference.com/w/cpp/io/manip/fixed.)"; }
1135 : : struct expect {
1136 [ + - ]: 1310 : static std::string description() { return "string"; }
1137 : 655 : static std::string choices() {
1138 [ + - ][ + - ]: 1310 : return '\'' + txt_float_default::string() + "\' | \'"
[ + - ]
1139 [ + - ][ + - ]: 2620 : + txt_float_scientific::string() + "\' | \'"
[ + - ]
1140 [ + - ][ + - ]: 2620 : + txt_float_fixed::string() + '\'';
1141 : : }
1142 : : };
1143 : : };
1144 : : using txt_float_format =
1145 : : keyword< txt_float_format_info, TAOCPP_PEGTL_STRING("format") >;
1146 : :
1147 : : struct precision_info {
1148 : : static std::string name() { return "precision"; }
1149 : 655 : static std::string shortDescription() { return
1150 [ + - ]: 1310 : R"(Precision in digits for ASCII floating-point output)"; }
1151 : 655 : static std::string longDescription() { return
1152 [ + - ]: 1310 : R"(This keyword is used to select
1153 : : the precision in digits for ASCII floating-point real number output.
1154 : : Example: "precision 10", which selects ten digits for floating-point
1155 : : output, e.g., 3.141592654. The number of digits must be larger than zero
1156 : : and lower than the maximum representable digits for the given floating-point
1157 : : type. For more info on setting the precision in C++, see
1158 : : http://en.cppreference.com/w/cpp/io/manip/setprecision, and
1159 : : http://en.cppreference.com/w/cpp/types/numeric_limits/digits10)";
1160 : : }
1161 : : struct expect {
1162 : : using type = std::streamsize;
1163 : : static constexpr type lower = 1;
1164 : : static constexpr type upper = std::numeric_limits< tk::real >::digits10 + 1;
1165 [ + - ]: 1310 : static std::string description() { return "int"; }
1166 : 655 : static std::string choices() {
1167 [ + - ][ + - ]: 1310 : return "integer between [" + std::to_string(lower) + "..." +
[ + - ]
1168 [ + - ][ + - ]: 1965 : std::to_string(upper) + "] (both inclusive)";
1169 : : }
1170 : : };
1171 : : };
1172 : : using precision = keyword< precision_info, TAOCPP_PEGTL_STRING("precision") >;
1173 : :
1174 : : struct elem_info {
1175 [ + - ]: 64 : static std::string name() { return "elem"; }
1176 : 655 : static std::string shortDescription() { return
1177 [ + - ]: 1310 : "Specify elem-centering for output"; }
1178 : 655 : static std::string longDescription() { return
1179 [ + - ]: 1310 : R"(This keyword is used to select elem-centering for variable output. In
1180 : : walker for example, this is used to configure probability values on the
1181 : : sample space grid for file output of probability density functions (PDFs).
1182 : : Example: "centering elem", which selects element-centered values. Valid
1183 : : options are 'elem' and 'node', denoting cell-centered and point-centered
1184 : : output, respectively. In inciter this keyword is used in output variable
1185 : : specification blocks, prefixing variable names by either 'node' or 'elem',
1186 : : to specify their centering for output to file.)"; }
1187 : : };
1188 : : using elem = keyword< elem_info, TAOCPP_PEGTL_STRING("elem") >;
1189 : :
1190 : : struct node_info {
1191 [ + - ]: 64 : static std::string name() { return "node"; }
1192 : 655 : static std::string shortDescription() { return
1193 [ + - ]: 1310 : "Specify node-centering for output"; }
1194 : 655 : static std::string longDescription() { return
1195 [ + - ]: 1310 : R"(This keyword is used to select node-centering for variable output. In
1196 : : walker for example, this is used to configure probability values on the
1197 : : sample space grid for file output of probability density functions (PDFs).
1198 : : Example: "centering elem", which selects element-centered values. Valid
1199 : : options are 'elem' and 'node', denoting cell-centered and point-centered
1200 : : output, respectively. In inciter this keyword is used in output variable
1201 : : specification blocks, prefixing variable names by either 'node' or 'elem',
1202 : : to specify their centering for output to file.)"; }
1203 : : };
1204 : : using node = keyword< node_info, TAOCPP_PEGTL_STRING("node") >;
1205 : :
1206 : : struct centering_info {
1207 : : static std::string name() { return "centering"; }
1208 : 655 : static std::string shortDescription() { return
1209 [ + - ]: 1310 : "Specify data-centering for PDF output"; }
1210 : 655 : static std::string longDescription() { return
1211 [ + - ]: 1310 : R"(This keyword is used to select the data
1212 : : centering of the probability value output on the sample space grid for
1213 : : file output of probability density functions (PDFs). Example: "centering
1214 : : elem", which selects element-centered values. Valid options are 'elem'
1215 : : and 'node', denoting cell-centered and point-centered output,
1216 : : respectively.)";
1217 : : }
1218 : : struct expect {
1219 [ + - ]: 1310 : static std::string description() { return "string"; }
1220 : 655 : static std::string choices() {
1221 [ + - ][ + - ]: 1310 : return '\'' + elem::string() + "\' | \'"
[ + - ]
1222 [ + - ][ + - ]: 2620 : + node::string() + '\'';
1223 : : }
1224 : : };
1225 : : };
1226 : : using pdf_centering = keyword< centering_info, TAOCPP_PEGTL_STRING("centering") >;
1227 : :
1228 : : struct raw_info {
1229 : : using code = Code< R >;
1230 [ + - ]: 808 : static std::string name() { return "raw"; }
1231 : 655 : static std::string shortDescription() { return
1232 [ + - ]: 1310 : "Select the raw initialization policy"; }
1233 : 655 : static std::string longDescription() { return
1234 [ + - ]: 1310 : R"(This keyword is used to select the raw
1235 : : initialization policy. The initialization policy is used to specify how
1236 : : the initial conditions are set at t = 0 before time-integration.
1237 : : Example: "init raw", which selects raw initialization policy, which
1238 : : leaves the memory uninitialized. Note that this option may behave
1239 : : differently depending on the particular equation or physical model. See the
1240 : : the init policies in DiffEq/InitPolicy.hpp for valid options.)"; }
1241 : : };
1242 : : using raw = keyword< raw_info, TAOCPP_PEGTL_STRING("raw") >;
1243 : :
1244 : : struct zero_info {
1245 : : using code = Code< Z >;
1246 [ + - ]: 808 : static std::string name() { return "zero"; }
1247 : 655 : static std::string shortDescription() { return
1248 [ + - ]: 1310 : "Select the zero initialization policy"; }
1249 : 655 : static std::string longDescription() { return
1250 [ + - ]: 1310 : R"(This keyword is used to select the zero
1251 : : initialization policy. The initialization policy is used to specify how
1252 : : the initial conditions are set at t = 0 before time-integration.
1253 : : Example: "init zero", which selects zero initialization policy, which
1254 : : puts zeros in memory. Note that this option may behave differently
1255 : : depending on the particular equation or physical model. See the init
1256 : : policies in DiffEq/InitPolicy.hpp for valid options.)"; }
1257 : : };
1258 : : using zero = keyword< zero_info, TAOCPP_PEGTL_STRING("zero") >;
1259 : :
1260 : : struct jointdelta_info {
1261 : : using code = Code< D >;
1262 [ + - ]: 808 : static std::string name() { return "delta"; }
1263 : 655 : static std::string shortDescription() { return
1264 [ + - ]: 1310 : "Select the joint delta initialization policy"; }
1265 : 655 : static std::string longDescription() { return
1266 [ + - ]: 1310 : R"(This keyword is used to select the joint delta initialization policy.
1267 : : The initialization policy is used to specify how the initial conditions are
1268 : : set at t = 0 before time-integration. Example: "init zero", which selects
1269 : : zero initialization policy, which puts zeros in memory. Note that this
1270 : : option may behave differently depending on the particular equation or
1271 : : physical model. For an example, see tk::InitPolicies in
1272 : : DiffEq/InitPolicy.hpp for valid options.) The joint delta initialization
1273 : : policy can be used to prescribe delta-spikes on the sample space with given
1274 : : heights, i.e., probabilities. Example: "init jointdelta" - select delta
1275 : : init-policy, "delta spike 0.1 0.3 0.8 0.7 end end" - prescribe two
1276 : : delta-spikes at sample space positions 0.1 and 0.8 with spike heights 0.3
1277 : : and 0.7, respectively. Note that the sum of the heights must add up to
1278 : : unity. See also the help on keyword spike.)"; }
1279 : : };
1280 : : using jointdelta = keyword< jointdelta_info, TAOCPP_PEGTL_STRING("jointdelta") >;
1281 : :
1282 : : struct jointgaussian_info {
1283 : : using code = Code< G >;
1284 [ + - ]: 808 : static std::string name() { return "Gaussian"; }
1285 : 655 : static std::string shortDescription() { return
1286 [ + - ]: 1310 : "Select the joint Gaussian initialization policy"; }
1287 : 655 : static std::string longDescription() { return
1288 [ + - ]: 1310 : R"(This keyword is used to select the joint Gaussian initialization policy.
1289 : : The initialization policy is used to specify how the initial conditions are
1290 : : set at t = 0 before time-integration. Example: "init zero", which selects
1291 : : zero initialization policy, which puts zeros in memory. Note that this
1292 : : option may behave differently depending on the particular equation or
1293 : : physical model. For an example, see tk::InitPolicies in
1294 : : DiffEq/InitPolicy.hpp for valid options.) The joint Gaussian initialization
1295 : : policy can be used to prescribe a joint Gaussian (joint Gaussian) on the
1296 : : sample space with given variances. Example: "init jointgaussian" - select
1297 : : (joint) Gaussian init-policy, "gaussian 0.1 0.3 0.8 0.7 end" - prescribe two
1298 : : Gaussians with mean 0.1 and variance 0.3, and with mean 0.8 and 0.7,
1299 : : respectively. Note that the means can be any real number while the
1300 : : variances must be positive. No correlations between the Gaussians (as the
1301 : : initial conditions) are supported.)"; }
1302 : : };
1303 : : using jointgaussian =
1304 : : keyword< jointgaussian_info, TAOCPP_PEGTL_STRING("jointgaussian") >;
1305 : :
1306 : : struct jointcorrgaussian_info {
1307 : : using code = Code< C >;
1308 [ + - ]: 808 : static std::string name() { return "correlated Gaussian"; }
1309 : 655 : static std::string shortDescription() { return
1310 [ + - ]: 1310 : "Select the joint correlated Gaussian initialization policy"; }
1311 : 655 : static std::string longDescription() { return
1312 [ + - ]: 1310 : R"(This keyword is used to select the joint correlated Gaussian
1313 : : initialization policy. The initialization policy is used to specify how the
1314 : : initial conditions are
1315 : : set at t = 0 before time-integration. Example: "init zero", which selects
1316 : : zero initialization policy, which puts zeros in memory. Note that this
1317 : : option may behave differently depending on the particular equation or
1318 : : physical model. For an example, see tk::InitPolicies in
1319 : : DiffEq/InitPolicy.hpp for valid options.) The joint correlated Gaussian
1320 : : initialization policy can be used to prescribe a joint correlated Gaussian
1321 : : on the sample space with a given covariance matrix. Example:
1322 : : "init jointcorrgaussian
1323 : : icjointgaussian
1324 : : mean 0.0 0.5 1.0 end
1325 : : cov
1326 : : 4.0 2.5 1.1
1327 : : 32.0 5.6
1328 : : 23.0
1329 : : end
1330 : : end")"; }
1331 : : };
1332 : : using jointcorrgaussian =
1333 : : keyword< jointcorrgaussian_info, TAOCPP_PEGTL_STRING("jointcorrgaussian") >;
1334 : :
1335 : : struct jointbeta_info {
1336 : : using code = Code< B >;
1337 [ + - ]: 808 : static std::string name() { return "beta"; }
1338 : 655 : static std::string shortDescription() { return
1339 [ + - ]: 1310 : "Select the joint beta initialization policy"; }
1340 : 655 : static std::string longDescription() { return
1341 [ + - ]: 1310 : R"(This keyword is used to select the joint beta initialization policy.
1342 : : The initialization policy is used to specify how the initial conditions are
1343 : : set at t = 0 before time-integration. Example: "init zero", which selects
1344 : : zero initialization policy, which puts zeros in memory. Note that this
1345 : : option may behave differently depending on the particular equation or
1346 : : physical model. For an example, see tk::InitPolicies in
1347 : : DiffEq/InitPolicy.hpp for valid options.) The joint beta initialization
1348 : : policy can be used to prescribe a multi-dimensional sample space where the
1349 : : samples are generated from a joint beta distribution with independent
1350 : : marginal univariate beta distributions.)";
1351 : : }
1352 : : };
1353 : : using jointbeta = keyword< jointbeta_info, TAOCPP_PEGTL_STRING("jointbeta") >;
1354 : :
1355 : : struct jointgamma_info {
1356 : : using code = Code< A >;
1357 [ + - ]: 808 : static std::string name() { return "gamma"; }
1358 : 655 : static std::string shortDescription() { return
1359 [ + - ]: 1310 : "Select the joint gamma initialization policy"; }
1360 : 655 : static std::string longDescription() { return
1361 [ + - ]: 1310 : R"(This keyword is used to select the joint gamma initialization policy.
1362 : : The initialization policy is used to specify how the initial conditions are
1363 : : set at t = 0 before time-integration. Example: "init zero", which selects
1364 : : zero initialization policy, which puts zeros in memory. Note that this
1365 : : option may behave differently depending on the particular equation or
1366 : : physical model. For an example, see tk::InitPolicies in
1367 : : DiffEq/InitPolicy.hpp for valid options.) The joint gamma initialization
1368 : : policy can be used to prescribe a joint gamma distribution on the
1369 : : sample space with given shape and scale parameters. Example: "init
1370 : : jointgamma" - select the (joint) gamma init-policy, "gammapdf 0.1 0.3
1371 : : end" - prescribe a gamma distribution with shape 0.1 and scale 0.3
1372 : : parameters, respectively. Note that both shape and scale
1373 : : must be positive. Multiple independent gamma PDFs can be specified and the
1374 : : they will be used for the different scalar components configured for the
1375 : : equation. No correlations between the gamma distributions (as the
1376 : : initial conditions) are supported.)"; }
1377 : : };
1378 : : using jointgamma =
1379 : : keyword< jointgamma_info, TAOCPP_PEGTL_STRING("jointgamma") >;
1380 : :
1381 : : struct jointdirichlet_info {
1382 : : using code = Code< I >;
1383 [ + - ]: 808 : static std::string name() { return "Dirichlet"; }
1384 : 655 : static std::string shortDescription() { return
1385 [ + - ]: 1310 : "Select the Dirichlet initialization policy"; }
1386 : 655 : static std::string longDescription() { return
1387 [ + - ]: 1310 : R"(This keyword is used to select the Dirichlet initialization policy.
1388 : : The initialization policy is used to specify how the initial conditions are
1389 : : set at t = 0 before time-integration. Example: "init zero", which selects
1390 : : zero initialization policy, which puts zeros in memory. Note that this
1391 : : option may behave differently depending on the particular equation or
1392 : : physical model. For an example, see tk::InitPolicies in
1393 : : DiffEq/InitPolicy.hpp for valid options.) The Dirichlet initialization
1394 : : policy can be used to prescribe a Dirichlet distribution on the
1395 : : sample space with given shape parameters. Example: "init
1396 : : jointdirichlet" - select the Dirichlet init-policy, "dirichletpdf 0.1 0.3
1397 : : 0.2 end" - prescribe a Dirichlet distribution with shape parameters 0.1,
1398 : : 0.3, and 0.2. All shape parameters must be positive.)"; }
1399 : : };
1400 : : using jointdirichlet =
1401 : : keyword< jointdirichlet_info, TAOCPP_PEGTL_STRING("jointdirichlet") >;
1402 : :
1403 : : struct init_info {
1404 : : using code = Code< i >;
1405 [ + - ]: 186 : static std::string name() { return "initialization policy"; }
1406 : 655 : static std::string shortDescription() { return
1407 [ + - ]: 1310 : "Select initialization policy"; }
1408 : 655 : static std::string longDescription() { return
1409 [ + - ]: 1310 : R"(This keyword is used to select an
1410 : : initialization policy. This is used to specify how the initial conditions
1411 : : are set at t = 0 before time-integration. Example: "init raw", which
1412 : : selects raw initialization policy, which leaves the memory uninitialized.
1413 : : Note that this option may behave differently depending on the particular
1414 : : equation or physical model. See the init policies in
1415 : : DiffEq/InitPolicy.hpp for valid options.)"; }
1416 : : struct expect {
1417 [ + - ]: 1310 : static std::string description() { return "string"; }
1418 : 655 : static std::string choices() {
1419 [ + - ][ + - ]: 1310 : return '\'' + raw::string() + "\' | \'"
[ + - ]
1420 [ + - ][ + - ]: 2620 : + zero::string() + "\' | \'"
[ + - ]
1421 [ + - ][ + - ]: 2620 : + jointdelta::string() + "\' | \'"
[ + - ]
1422 [ + - ][ + - ]: 2620 : + jointbeta::string() + "\' | \'"
[ + - ]
1423 [ + - ][ + - ]: 2620 : + jointgaussian::string() + "\' | \'"
[ + - ]
1424 [ + - ][ + - ]: 2620 : + jointcorrgaussian::string() + "\' | \'"
[ + - ]
1425 [ + - ][ + - ]: 2620 : + jointgamma::string() + '\'';
1426 : : }
1427 : : };
1428 : : };
1429 : : using init = keyword< init_info, TAOCPP_PEGTL_STRING("init") >;
1430 : :
1431 : : struct constcoeff_info {
1432 : : using code = Code< C >;
1433 [ + - ]: 792 : static std::string name() { return "constant coefficients"; }
1434 : 655 : static std::string shortDescription() { return
1435 [ + - ]: 1310 : "Select constant coefficients policy"; }
1436 : 655 : static std::string longDescription() { return
1437 [ + - ]: 1310 : R"(This keyword is used to select the 'constant coefficients' coefficients
1438 : : policy. A coefficients policy is used to specify how the coefficients are
1439 : : set at each time step during time-integration. Example: "coeff
1440 : : const_coeff", which selects 'constant coefficients' coefficients policy,
1441 : : which sets constant coefficients before t = 0 and leaves the coefficients
1442 : : unchanged during time integration. Note that this option may behave
1443 : : differently depending on the particular equation or physical model.)"; }
1444 : : };
1445 : : using constcoeff =
1446 : : keyword< constcoeff_info, TAOCPP_PEGTL_STRING("const_coeff") >;
1447 : :
1448 : : struct decay_info {
1449 : : using code = Code< D >;
1450 [ + - ]: 792 : static std::string name() { return "decay"; }
1451 : 655 : static std::string shortDescription() { return
1452 [ + - ]: 1310 : "Select decay coefficients policy"; }
1453 : 655 : static std::string longDescription() { return
1454 [ + - ]: 1310 : R"(This keyword is used to select the decay coefficients policy. This policy
1455 : : (or model) is used to constrain a beta stochastic differential equation so
1456 : : that its variance, <y^2>, always decays. A coefficients policy, in general,
1457 : : is used to specify how the coefficients are set at each time step during
1458 : : time-integration. Example: "coeff const", which selects constant
1459 : : coefficients policy, which sets constant coefficients before t = 0 and
1460 : : leaves the coefficients unchanged during time integration. Note that this
1461 : : option may behave differently depending on the particular equation or
1462 : : physical model.)"; }
1463 : : };
1464 : : using decay = keyword< decay_info, TAOCPP_PEGTL_STRING("decay") >;
1465 : :
1466 : : struct homogeneous_info {
1467 : : using code = Code< H >;
1468 [ + - ]: 792 : static std::string name() { return "homogeneous"; }
1469 : 655 : static std::string shortDescription() { return
1470 [ + - ]: 1310 : "Select homogeneous coefficients policy"; }
1471 : 655 : static std::string longDescription() { return
1472 [ + - ]: 1310 : R"(This keyword is used to select the homogeneous coefficients policy.
1473 : : This policy (or model) is used to constrain a Dirichlet stochastic
1474 : : differential equation so that its mean density stays constant.
1475 : : A coefficients policy, in general, is used to specify how the
1476 : : coefficients are set at each time step during time-integration. Example:
1477 : : "coeff const", which selects constant coefficients policy, which sets
1478 : : constant coefficients before t = 0 and leaves the coefficients unchanged
1479 : : during time integration. Note that this option may behave differently
1480 : : depending on the particular equation or physical model.)"; }
1481 : : };
1482 : : using homogeneous =
1483 : : keyword< homogeneous_info, TAOCPP_PEGTL_STRING("homogeneous") >;
1484 : :
1485 : : struct homdecay_info {
1486 : : using code = Code< Y >;
1487 [ + - ]: 792 : static std::string name() { return "homogeneous decay"; }
1488 : 655 : static std::string shortDescription() { return
1489 [ + - ]: 1310 : "Select homogeneous decay coefficients policy"; }
1490 : 655 : static std::string longDescription() { return
1491 [ + - ]: 1310 : R"(This keyword is used to select the homogeneous decay coefficients policy.
1492 : : This policy (or model) is used to constrain a beta stochastic differential
1493 : : equation so that its variance, <y^2>, always decays and its mean, <R> =
1494 : : rho2/(1+r<RY>/<R>), where Y = <Y> + y, does not change in time. Note that
1495 : : R = rho2/(1+rY). This policy is similar to 'montecarlo_homdecay', but
1496 : : computes the SDE coefficient S in a different but statistically equivalent
1497 : : way. While 'homdecay' only requires the estimation of statistics, <R>,
1498 : : <r^2>, and <r^3>, 'montecarlo_homdecay' requires <R^2>, <YR^2>, and
1499 : : <Y(1-Y)R^3>. A coefficients policy, in general, is used to specify how the
1500 : : coefficients are set at each time step during time-integration. Example:
1501 : : "coeff const", which selects constant coefficients policy, which sets
1502 : : constant coefficients before t = 0 and leaves the coefficients unchanged
1503 : : during time integration. Note that this option may behave differently
1504 : : depending on the particular equation or physical model.)"; }
1505 : : };
1506 : : using homdecay = keyword< homdecay_info, TAOCPP_PEGTL_STRING("homdecay") >;
1507 : :
1508 : : struct montecarlo_homdecay_info {
1509 : : using code = Code< M >;
1510 [ + - ]: 792 : static std::string name() { return "Monte Carlo homogeneous decay"; }
1511 : 655 : static std::string shortDescription() { return
1512 [ + - ]: 1310 : "Select Monte Carlo homogeneous decay coefficients policy"; }
1513 : 655 : static std::string longDescription() { return
1514 [ + - ]: 1310 : R"(This keyword is used to select the Monte Carlo homogeneous decay
1515 : : coefficients policy. This policy (or model) is used to constrain a beta
1516 : : stochastic differential equation (SDE) so that its variance, <y^2>, always
1517 : : decays and its mean, <R> = rho2/(1+r<RY>/<R>), where Y = <Y> + y, does not
1518 : : change in time. Note that R = rho2/(1+rY). This policy is similar to
1519 : : 'homdecay', but computes the the SDE coefficient S in a different but
1520 : : statistically equivalent way. While 'homdecay' only requires the estimation
1521 : : of statistics, <R>, <r^2>, and <r^3>, 'montecarlo_homdecay' requires <R^2>,
1522 : : <YR^2>, and <Y(1-Y)R^3>. A coefficients policy, in general, is used to
1523 : : specify how the coefficients are set at each time step during
1524 : : time-integration. Example: "coeff const", which selects constant
1525 : : coefficients policy, which sets constant coefficients before t = 0 and
1526 : : leaves the coefficients unchanged during time integration. Note that this
1527 : : option may behave differently depending on the particular equation or
1528 : : physical model.)"; }
1529 : : };
1530 : : using montecarlo_homdecay =
1531 : : keyword< montecarlo_homdecay_info, TAOCPP_PEGTL_STRING("montecarlo_homdecay") >;
1532 : :
1533 : : struct hydrotimescale_info {
1534 : : using code = Code< T >;
1535 [ + - ]: 792 : static std::string name() { return "hydro-timescale"; }
1536 : 655 : static std::string shortDescription() { return
1537 [ + - ]: 1310 : "Select hydro-timescale coefficients policy"; }
1538 : 655 : static std::string longDescription() { return
1539 [ + - ]: 1310 : R"(This keyword is used to select the hydrodynamics-timescale
1540 : : coefficients policy. This policy (or model) is used to constrain a
1541 : : beta stochastic differential equation (SDE) so that its variance, <y^2>,
1542 : : always decays and its mean, <R> = rho2/(1+r<RY>/<R>), where Y = <Y> + y,
1543 : : does not change in time. Note that R = rho2/(1+rY). This policy is similar
1544 : : to 'homdecay' as well as 'montecarlo_homdecay', but instead of simply
1545 : : constraining b' and kappa' to ensure decay in the evolution of <y^2>, b' and
1546 : : kappa' are specified as functions of an externally-specified hydrodynamics
1547 : : time scale, as a function of time. This policy is more similar to 'homdecay'
1548 : : than to 'montecarlo_homdecay' in that only requires the estimation
1549 : : of statistics, <R>, <r^2>, and <r^3>. A coefficients policy, in general, is
1550 : : used to specify how the coefficients are set at each time step during
1551 : : time-integration. Example: "coeff const", which selects constant
1552 : : coefficients policy, which sets constant coefficients before t = 0 and
1553 : : leaves the coefficients unchanged during time integration. Note that this
1554 : : option may behave differently depending on the particular equation or
1555 : : physical model.)"; }
1556 : : };
1557 : : using hydrotimescale =
1558 : : keyword< hydrotimescale_info, TAOCPP_PEGTL_STRING("hydrotimescale") >;
1559 : :
1560 : : struct const_shear_info {
1561 : : using code = Code< S >;
1562 [ + - ]: 792 : static std::string name() { return "prescribed constant shear"; }
1563 : 655 : static std::string shortDescription() { return
1564 [ + - ]: 1310 : "Select constant shear coefficients policy"; }
1565 : 655 : static std::string longDescription() { return
1566 [ + - ]: 1310 : R"(This keyword is used to select the prescribed constant shear
1567 : : coefficients policy, used to compute a homogeneous free shear flow using the
1568 : : Langevin model. This policy (or model) prescribes a constant mean shear in
1569 : : the y direction and computes the dissipation of turbulent kinetic energy
1570 : : specifically for this flow. The flow is a fully developed homogeneous
1571 : : turbulent shear flow with a uniform mean velocity gradient in one direction
1572 : : (y) and the mean flow is in predominantly in the x direction. The flow is
1573 : : considered to be far from solid boundaries. See Pope, S.B. (2000). Turbulent
1574 : : flows (Cambridge: Cambridge University Press).)"; }
1575 : : };
1576 : : using const_shear =
1577 : : keyword< const_shear_info, TAOCPP_PEGTL_STRING("const_shear") >;
1578 : :
1579 : : struct stationary_info {
1580 : : using code = Code< B >;
1581 [ + - ]: 792 : static std::string name() { return "stationary"; }
1582 : 655 : static std::string shortDescription() { return
1583 [ + - ]: 1310 : "Select the stationary coefficients policy"; }
1584 : 655 : static std::string longDescription() { return
1585 [ + - ]: 1310 : R"(This keyword is used to select the stationary coefficients
1586 : : policy. This policy will keep a stochastic differential equation at a
1587 : : constant statistically stationary state.)";
1588 : : }
1589 : : };
1590 : : using stationary =
1591 : : keyword< stationary_info, TAOCPP_PEGTL_STRING("stationary") >;
1592 : :
1593 : : struct inst_velocity_info {
1594 : : using code = Code< V >;
1595 [ + - ]: 792 : static std::string name() { return "instantaneous velocity"; }
1596 : 655 : static std::string shortDescription() { return
1597 [ + - ]: 1310 : "Select the instantaneous velocity coefficients policy"; }
1598 : 655 : static std::string longDescription() { return
1599 [ + - ]: 1310 : R"(This keyword is used to select the instantaneous velocity coefficients
1600 : : policy. This is used to prescribe a coupling for instantaneous velocity to
1601 : : some other differential equation, e.g., to update Lagrangian particle
1602 : : position or to couple a mix model to velocity.)"; }
1603 : : };
1604 : : using inst_velocity =
1605 : : keyword< inst_velocity_info, TAOCPP_PEGTL_STRING("inst_velocity") >;
1606 : :
1607 : : struct coeff_info {
1608 : : using code = Code< c >;
1609 [ + - ]: 186 : static std::string name() { return "coefficients policy"; }
1610 : 655 : static std::string shortDescription() { return
1611 [ + - ]: 1310 : "Select the coefficients policy"; }
1612 : 655 : static std::string longDescription() { return
1613 [ + - ]: 1310 : R"(This keyword is used to select a
1614 : : coefficients policy. This is used to specify how the coefficients are set
1615 : : at each time step during time-integration. Example: "coeff const",
1616 : : which selects constant coefficients policy, which sets constant
1617 : : coefficients before t = 0 and leaves the coefficients unchanged during
1618 : : time integration. Note that this option may behave differently depending
1619 : : on the particular equation or physical model.)"; }
1620 : : struct expect {
1621 [ + - ]: 1310 : static std::string description() { return "string"; }
1622 : 655 : static std::string choices() {
1623 : 0 : return '\'' +
1624 [ + - ][ + - ]: 1310 : kw::constcoeff::string() + "\' | \'" +
[ + - ]
1625 [ + - ][ + - ]: 2620 : kw::decay::string() + "\' | \'" +
[ + - ]
1626 [ + - ][ + - ]: 2620 : kw::homogeneous::string() + "\' | \'" +
[ + - ]
1627 [ + - ][ + - ]: 2620 : kw::homdecay::string() + "\' | \'" +
[ + - ]
1628 [ + - ][ + - ]: 2620 : kw::montecarlo_homdecay::string() + "\' | \'" +
[ + - ]
1629 [ + - ][ + - ]: 2620 : kw::hydrotimescale::string() + "\' | \'" +
[ + - ]
1630 [ + - ][ + - ]: 2620 : kw::const_shear::string() + "\' | \'" +
[ + - ]
1631 [ + - ][ + - ]: 2620 : kw::stationary::string() + "\' | \'" +
[ + - ]
1632 [ + - ][ + - ]: 1965 : kw::inst_velocity::string() + '\'';
1633 : : }
1634 : : };
1635 : : };
1636 : : using coeff = keyword< coeff_info, TAOCPP_PEGTL_STRING("coeff") >;
1637 : :
1638 : : struct walker_info {
1639 : : static std::string name() { return "walker"; }
1640 : 655 : static std::string shortDescription() { return
1641 [ + - ]: 1310 : "Start configuration block of the random walker"; }
1642 : 655 : static std::string longDescription() { return
1643 [ + - ]: 1310 : R"(This keyword is used to select the walker. Walker, is a random walker,
1644 : : that allows temporal integration of a system of ordinary or stochastic
1645 : : differential equations (SDEs) of various types and the collection of
1646 : : arbitrary coupled statistics and probability density functions. Walker is
1647 : : intended as a general mathematical tool to analyze the behavior of SDEs
1648 : : and its statistics.)";
1649 : : }
1650 : : };
1651 : : using walker = keyword< walker_info, TAOCPP_PEGTL_STRING("walker") >;
1652 : :
1653 : : struct npar_info {
1654 : : static std::string name() { return "npar"; }
1655 : 655 : static std::string shortDescription() { return
1656 [ + - ]: 1310 : "Set total number of particles"; }
1657 : 655 : static std::string longDescription() { return
1658 [ + - ]: 1310 : R"(This keyword is used to specify the total number of particles in a
1659 : : simulation.)";
1660 : : }
1661 : : struct expect {
1662 : : using type = uint64_t;
1663 : : static constexpr type lower = 1;
1664 [ + - ]: 1310 : static std::string description() { return "uint"; }
1665 : : };
1666 : : };
1667 : : using npar = keyword< npar_info, TAOCPP_PEGTL_STRING("npar") >;
1668 : :
1669 : : struct nstep_info {
1670 : : static std::string name() { return "nstep"; }
1671 : 655 : static std::string shortDescription() { return
1672 [ + - ]: 1310 : "Set number of time steps to take"; }
1673 : 655 : static std::string longDescription() { return
1674 [ + - ]: 1310 : R"(This keyword is used to specify the number of time steps to take in a
1675 : : simulation. The number of time steps are used in conjunction with the
1676 : : maximmum time specified by keyword 'term': the simulation stops whichever is
1677 : : reached first. Both 'nstep' and 'term' can be left unspecified, in which
1678 : : case their default values are used. See also 'term'.)";
1679 : : }
1680 : : struct expect {
1681 : : using type = uint64_t;
1682 : : static constexpr type lower = 1;
1683 [ + - ]: 1310 : static std::string description() { return "uint"; }
1684 : : };
1685 : : };
1686 : : using nstep = keyword< nstep_info, TAOCPP_PEGTL_STRING("nstep") >;
1687 : :
1688 : : struct term_info {
1689 : : static std::string name() { return "term"; }
1690 : 655 : static std::string shortDescription() { return
1691 [ + - ]: 1310 : "Set maximum non-dimensional time to simulate"; }
1692 : 655 : static std::string longDescription() { return
1693 [ + - ]: 1310 : R"(This keyword is used to specify the termination time in a simulation. The
1694 : : termination time and number of time steps, specified by 'nstep', are used in
1695 : : conjunction to determine when to stop a simulation: whichever is
1696 : : reached first. Both 'nstep' and 'term' can be left unspecified, in which
1697 : : case their default values are used. See also 'nstep'.)";
1698 : : }
1699 : : struct expect {
1700 : : using type = tk::real;
1701 : : static constexpr type lower = 0.0;
1702 [ + - ]: 1310 : static std::string description() { return "real"; }
1703 : : };
1704 : : };
1705 : : using term = keyword< term_info, TAOCPP_PEGTL_STRING("term") >;
1706 : :
1707 : : struct t0_info {
1708 : : static std::string name() { return "t0"; }
1709 : : static std::string shortDescription() { return
1710 : : "Set starting non-dimensional time"; }
1711 : : static std::string longDescription() { return
1712 : : R"(This keyword is used to specify the starting time in a simulation.)";
1713 : : }
1714 : : struct expect {
1715 : : using type = tk::real;
1716 : : static constexpr type lower = 0.0;
1717 : : static std::string description() { return "real"; }
1718 : : };
1719 : : };
1720 : : using t0 = keyword< t0_info, TAOCPP_PEGTL_STRING("t0") >;
1721 : :
1722 : : struct dt_info {
1723 : : static std::string name() { return "dt"; }
1724 : 655 : static std::string shortDescription() { return
1725 [ + - ]: 1310 : "Select constant time step size"; }
1726 : 655 : static std::string longDescription() { return
1727 [ + - ]: 1310 : R"(This keyword is used to specify the time step size that used as a
1728 : : constant during simulation. Setting 'cfl' and 'dt' are mutually
1729 : : exclusive. If both 'cfl' and 'dt' are set, 'dt' wins.)";
1730 : : }
1731 : : struct expect {
1732 : : using type = tk::real;
1733 : : static constexpr type lower = 0.0;
1734 [ + - ]: 1310 : static std::string description() { return "real"; }
1735 : : };
1736 : : };
1737 : : using dt = keyword< dt_info, TAOCPP_PEGTL_STRING("dt") >;
1738 : :
1739 : : struct cfl_info {
1740 : : static std::string name() { return "CFL"; }
1741 : : static std::string shortDescription() { return
1742 : : "Set the Courant-Friedrichs-Lewy (CFL) coefficient"; }
1743 : : static std::string longDescription() { return
1744 : : R"(This keyword is used to specify the CFL coefficient for
1745 : : variable-time-step-size simulations. Setting 'cfl' and 'dt' are mutually
1746 : : exclusive. If both 'cfl' and 'dt' are set, 'dt' wins.)";
1747 : : }
1748 : : struct expect {
1749 : : using type = tk::real;
1750 : : static constexpr type lower = 0.0;
1751 : : static std::string description() { return "real"; }
1752 : : };
1753 : : };
1754 : : using cfl = keyword< cfl_info, TAOCPP_PEGTL_STRING("cfl") >;
1755 : :
1756 : : struct dvcfl_info {
1757 : : static std::string name() { return "dvCFL"; }
1758 : : static std::string shortDescription() { return
1759 : : "Set the volume-change Courant-Friedrichs-Lewy (CFL) coefficient"; }
1760 : : static std::string longDescription() { return
1761 : : R"(This keyword is used to specify the volume-change (dV/dt) CFL coefficient
1762 : : for variable-time-step-size simulations due to volume change in time in
1763 : : arbitrary-Lagrangian-Eulerian (ALE) calculations. Setting 'dvcfl' only has
1764 : : effect in ALE calculations and used together with 'cfl'. See also J. Waltz,
1765 : : N.R. Morgan, T.R. Canfield, M.R.J. Charest, L.D. Risinger, J.G. Wohlbier, A
1766 : : three-dimensional finite element arbitrary Lagrangian–Eulerian method for
1767 : : shock hydrodynamics on unstructured grids, Computers & Fluids, 92: 172-187,
1768 : : 2014.)";
1769 : : }
1770 : : struct expect {
1771 : : using type = tk::real;
1772 : : static constexpr type lower = 0.01;
1773 : : static std::string description() { return "real"; }
1774 : : };
1775 : : };
1776 : : using dvcfl = keyword< dvcfl_info, TAOCPP_PEGTL_STRING("dvcfl") >;
1777 : :
1778 : : struct vortmult_info {
1779 : : static std::string name() { return "vortmult"; }
1780 : : static std::string shortDescription() { return
1781 : : "Configure vorticity multiplier for ALE mesh velocity"; }
1782 : : static std::string longDescription() { return
1783 : : R"(This keyword is used to configure the multiplier for the vorticity term
1784 : : in the mesh velocity smoother (mesh_velocity=fluid) or for the potential
1785 : : gradient for the Helmholtz mesh velocity (mesh_velocity=helmholtz) for ALE
1786 : : mesh motion. For 'fluid' this is coefficient c2 in Eq.(36) of Waltz,
1787 : : Morgan, Canfield, Charest, Risinger, Wohlbier, A three-dimensional finite
1788 : : element arbitrary Lagrangian–Eulerian method for shock hydrodynamics on
1789 : : unstructured grids, Computers & Fluids, 2014, and for 'helmholtz', this is
1790 : : coefficient a1 in Eq.(23) of Bakosi, Waltz, Morgan, Improved ALE mesh
1791 : : velocities for complex flows, International Journal for Numerical Methods
1792 : : in Fluids, 2017. )";
1793 : : }
1794 : : struct expect {
1795 : : using type = tk::real;
1796 : : static constexpr type lower = 0.0;
1797 : : static constexpr type upper = 1.0;
1798 : : static std::string description() { return "real"; }
1799 : : };
1800 : : };
1801 : : using vortmult = keyword< vortmult_info, TAOCPP_PEGTL_STRING("vortmult") >;
1802 : :
1803 : : struct meshvel_maxit_info {
1804 : : static std::string name() {
1805 : : return "mesh velocity linear solve max number of iterations"; }
1806 : : static std::string shortDescription() { return
1807 : : "Set the max number of iterations for the mesh velocity linear solve "
1808 : : "for ALE"; }
1809 : : static std::string longDescription() { return
1810 : : R"(This keyword is used to specify the maximum number of linear solver
1811 : : iterations taken to converge the mesh velocity linear solve in
1812 : : arbitrary-Lagrangian-Eulerian (ALE) calculations. See also J. Waltz,
1813 : : N.R. Morgan, T.R. Canfield, M.R.J. Charest, L.D. Risinger, J.G. Wohlbier, A
1814 : : three-dimensional finite element arbitrary Lagrangian–Eulerian method for
1815 : : shock hydrodynamics on unstructured grids, Computers & Fluids, 92: 172-187,
1816 : : 2014.)";
1817 : : }
1818 : : struct expect {
1819 : : using type = std::size_t;
1820 : : static std::string description() { return "int"; }
1821 : : };
1822 : : };
1823 : : using meshvel_maxit =
1824 : : keyword< meshvel_maxit_info, TAOCPP_PEGTL_STRING("maxit") >;
1825 : :
1826 : : struct meshvel_tolerance_info {
1827 : : static std::string name() {
1828 : : return "mesh velocity linear solve tolerance "; }
1829 : : static std::string shortDescription() { return
1830 : : "Set the tolerance for the mesh velocity linear solve for ALE"; }
1831 : : static std::string longDescription() { return
1832 : : R"(This keyword is used to specify the tolerance to converge the mesh
1833 : : velocity linear solve for in
1834 : : arbitrary-Lagrangian-Eulerian (ALE) calculations. See also J. Waltz,
1835 : : N.R. Morgan, T.R. Canfield, M.R.J. Charest, L.D. Risinger, J.G. Wohlbier, A
1836 : : three-dimensional finite element arbitrary Lagrangian–Eulerian method for
1837 : : shock hydrodynamics on unstructured grids, Computers & Fluids, 92: 172-187,
1838 : : 2014.)";
1839 : : }
1840 : : struct expect {
1841 : : using type = tk::real;
1842 : : static std::string description() { return "real"; }
1843 : : };
1844 : : };
1845 : : using meshvel_tolerance =
1846 : : keyword< meshvel_tolerance_info, TAOCPP_PEGTL_STRING("tolerance") >;
1847 : :
1848 : : struct ncomp_info {
1849 : : static std::string name() { return "ncomp"; }
1850 : 655 : static std::string shortDescription() { return
1851 [ + - ]: 1310 : "Set number of scalar components for a system of differential equations"; }
1852 : 655 : static std::string longDescription() { return
1853 [ + - ]: 1310 : R"(This keyword is used to specify the number of scalar
1854 : : components of a vector. 'ncomp' means "number of components". It is also
1855 : : used for specifying the number of scalar components of a transporter scalar
1856 : : (see also the keywords 'transport').)";
1857 : : }
1858 : : struct expect {
1859 : : using type = std::size_t;
1860 : : static constexpr type lower = 1;
1861 [ + - ]: 1310 : static std::string description() { return "uint"; }
1862 : : };
1863 : : };
1864 : : using ncomp = keyword< ncomp_info, TAOCPP_PEGTL_STRING("ncomp") >;
1865 : :
1866 : : struct nmat_info {
1867 : : static std::string name() { return "nmat"; }
1868 : : static std::string shortDescription() { return
1869 : : "Set number of materials for a system of differential equations"; }
1870 : : static std::string longDescription() { return
1871 : : R"(This keyword is used to specify the number of materials, e.g., for
1872 : : multi-material flow, see also the keyword 'multimat' and 'veleq'.)";
1873 : : }
1874 : : struct expect {
1875 : : using type = std::size_t;
1876 : : static constexpr type lower = 1;
1877 : : static std::string description() { return "uint"; }
1878 : : };
1879 : : };
1880 : : using nmat = keyword< nmat_info, TAOCPP_PEGTL_STRING("nmat") >;
1881 : :
1882 : : struct ttyi_info {
1883 : : static std::string name() { return "ttyi"; }
1884 : 655 : static std::string shortDescription() { return
1885 [ + - ]: 1310 : "Set screen output interval"; }
1886 : 655 : static std::string longDescription() { return
1887 [ + - ]: 1310 : R"(This keyword is used to specify the interval in time steps for screen
1888 : : output during a simulation.)";
1889 : : }
1890 : : struct expect {
1891 : : using type = uint32_t;
1892 : : static constexpr type lower = 0;
1893 [ + - ]: 1310 : static std::string description() { return "uint"; }
1894 : : };
1895 : : };
1896 : : using ttyi = keyword< ttyi_info, TAOCPP_PEGTL_STRING("ttyi") >;
1897 : :
1898 : : struct pari_info {
1899 : : static std::string name() { return "pari"; }
1900 : 655 : static std::string shortDescription() { return
1901 [ + - ]: 1310 : "Set particles output interval"; }
1902 : 655 : static std::string longDescription() { return
1903 [ + - ]: 1310 : R"(This keyword is used to specify the interval in time steps for particles
1904 : : output during a simulation.)";
1905 : : }
1906 : : struct expect {
1907 : : using type = uint32_t;
1908 : : static constexpr type lower = 1;
1909 [ + - ]: 1310 : static std::string description() { return "uint"; }
1910 : : };
1911 : : };
1912 : : using pari = keyword< pari_info, TAOCPP_PEGTL_STRING("pari") >;
1913 : :
1914 : : struct interval_iter_info {
1915 : : static std::string name() { return "interval"; }
1916 : 655 : static std::string shortDescription() { return
1917 [ + - ]: 1310 : "Set interval (in units of iteration count)"; }
1918 : 655 : static std::string longDescription() { return
1919 [ + - ]: 1310 : R"(This keyword is used to specify an interval in units of iteration count
1920 : : (i.e., number of time steps). This must be used within a relevant block.)";
1921 : : }
1922 : : struct expect {
1923 : : using type = uint32_t;
1924 : : static constexpr type lower = 0;
1925 [ + - ]: 1310 : static std::string description() { return "uint"; }
1926 : : };
1927 : : };
1928 : : using interval_iter =
1929 : : keyword< interval_iter_info, TAOCPP_PEGTL_STRING("interval") >;
1930 : :
1931 : : struct interval_time_info {
1932 : : static std::string name() { return "time_interval"; }
1933 : : static std::string shortDescription() { return
1934 : : "Set interval (in units of physics time)"; }
1935 : : static std::string longDescription() { return
1936 : : R"(This keyword is used to specify an interval in units of physics time.
1937 : : This must be used within a relevant block.)";
1938 : : }
1939 : : struct expect {
1940 : : using type = tk::real;
1941 : : static constexpr type lower = std::numeric_limits< tk::real >::epsilon();
1942 : : static std::string description() { return "real"; }
1943 : : };
1944 : : };
1945 : : using interval_time =
1946 : : keyword< interval_time_info, TAOCPP_PEGTL_STRING("time_interval") >;
1947 : :
1948 : : struct time_range_info {
1949 : : static std::string name() { return "time_range"; }
1950 : : static std::string shortDescription() { return
1951 : : "Configure physics time range for output (in units of physics time)"; }
1952 : : static std::string longDescription() { return
1953 : : R"(This keyword is used to configure field-, or history-output, specifying
1954 : : a start time, a stop time, and an output frequency in physics time units.
1955 : : Example: 'time_range 0.2 0.3 0.001 end', which specifies that from t=0.2 to
1956 : : t=0.3 output should happen at physics time units of dt=0.001. This must be
1957 : : used within a relevant block.)";
1958 : : }
1959 : : struct expect {
1960 : : using type = tk::real;
1961 : : static std::string description() { return "3 reals"; }
1962 : : };
1963 : : };
1964 : : using time_range =
1965 : : keyword< time_range_info, TAOCPP_PEGTL_STRING("time_range") >;
1966 : :
1967 : : struct statistics_info {
1968 : : static std::string name() { return "statistics"; }
1969 : 655 : static std::string shortDescription() { return
1970 [ + - ]: 1310 : "Start of statistics input block"; }
1971 : 655 : static std::string longDescription() { return
1972 [ + - ]: 1310 : R"(This keyword is used to start a block in the input file containing the
1973 : : descriptions and settings of requested output for statistical moments.
1974 : : Example: "statistics <Y> <yy> end", which requests the first two moments of
1975 : : the flutcutating variable 'Y'. For more info on the structure of the
1976 : : statistics ... end block, see doc/pages/statistics_output.dox.)";
1977 : : }
1978 : : };
1979 : : using statistics = keyword< statistics_info, TAOCPP_PEGTL_STRING("statistics") >;
1980 : :
1981 : : struct history_output_info {
1982 : : static std::string name() { return "history_output"; }
1983 : : static std::string shortDescription() { return
1984 : : "Start of history_output input block"; }
1985 : : static std::string longDescription() { return
1986 : : R"(This keyword is used to start a block in the input file containing the
1987 : : descriptions and settings of requested history output.)";
1988 : : }
1989 : : };
1990 : : using history_output =
1991 : : keyword< history_output_info, TAOCPP_PEGTL_STRING("history_output") >;
1992 : :
1993 : : struct field_output_info {
1994 : : static std::string name() { return "field_output"; }
1995 : : static std::string shortDescription() { return
1996 : : "Start of field_output input block"; }
1997 : : static std::string longDescription() { return
1998 : : R"(This keyword is used to start a block in the input file containing the
1999 : : list and settings of requested field output.)";
2000 : : }
2001 : : };
2002 : : using field_output =
2003 : : keyword< field_output_info, TAOCPP_PEGTL_STRING("field_output") >;
2004 : :
2005 : : struct outvar_density_info {
2006 : : static std::string name() { return "density"; }
2007 : : static std::string shortDescription() { return "Request density"; }
2008 : : static std::string longDescription() { return
2009 : : R"(This keyword is used to request the fluid density as an output
2010 : : variable.)";
2011 : : }
2012 : : };
2013 : : using outvar_density =
2014 : : keyword< outvar_density_info, TAOCPP_PEGTL_STRING("density") >;
2015 : :
2016 : : struct outvar_xmomentum_info {
2017 : : static std::string name() { return "x-momentum"; }
2018 : : static std::string shortDescription() { return "Request x-momentum"; }
2019 : : static std::string longDescription() { return
2020 : : R"(This keyword is used to request the fluid x-momentum as an output
2021 : : variable.)";
2022 : : }
2023 : : };
2024 : : using outvar_xmomentum =
2025 : : keyword< outvar_xmomentum_info, TAOCPP_PEGTL_STRING("x-momentum") >;
2026 : :
2027 : : struct outvar_ymomentum_info {
2028 : : static std::string name() { return "y-momentum"; }
2029 : : static std::string shortDescription() { return "Request y-momentum"; }
2030 : : static std::string longDescription() { return
2031 : : R"(This keyword is used to request the fluid y-momentum as an output
2032 : : variable.)";
2033 : : }
2034 : : };
2035 : : using outvar_ymomentum =
2036 : : keyword< outvar_ymomentum_info, TAOCPP_PEGTL_STRING("y-momentum") >;
2037 : :
2038 : : struct outvar_zmomentum_info {
2039 : : static std::string name() { return "z-momentum"; }
2040 : : static std::string shortDescription() { return "Request z-momentum"; }
2041 : : static std::string longDescription() { return
2042 : : R"(This keyword is used to request the fluid z-momentum as an output
2043 : : variable.)";
2044 : : }
2045 : : };
2046 : : using outvar_zmomentum =
2047 : : keyword< outvar_zmomentum_info, TAOCPP_PEGTL_STRING("z-momentum") >;
2048 : :
2049 : : struct outvar_specific_total_energy_info {
2050 : : static std::string name() { return "specific_total_energy"; }
2051 : : static std::string shortDescription() {
2052 : : return "Request total specific energy"; }
2053 : : static std::string longDescription() { return
2054 : : R"(This keyword is used to request the specific total energy as an output
2055 : : variable.)";
2056 : : }
2057 : : };
2058 : : using outvar_specific_total_energy =
2059 : : keyword< outvar_specific_total_energy_info,
2060 : : TAOCPP_PEGTL_STRING("specific_total_energy") >;
2061 : :
2062 : : struct outvar_volumetric_total_energy_info {
2063 : : static std::string name() { return "volumetric_total_energy"; }
2064 : : static std::string shortDescription() {
2065 : : return "Request total volumetric energy"; }
2066 : : static std::string longDescription() { return
2067 : : R"(This keyword is used to request the volumetric total energy as an output
2068 : : variable.)";
2069 : : }
2070 : : };
2071 : : using outvar_volumetric_total_energy =
2072 : : keyword< outvar_volumetric_total_energy_info,
2073 : : TAOCPP_PEGTL_STRING("volumetric_total_energy") >;
2074 : :
2075 : : struct outvar_xvelocity_info {
2076 : : static std::string name() { return "x-velocity"; }
2077 : : static std::string shortDescription() { return "Request x-velocity"; }
2078 : : static std::string longDescription() { return
2079 : : R"(This keyword is used to request the fluid x-velocity as an output
2080 : : variable.)";
2081 : : }
2082 : : };
2083 : : using outvar_xvelocity =
2084 : : keyword< outvar_xvelocity_info, TAOCPP_PEGTL_STRING("x-velocity") >;
2085 : :
2086 : : struct outvar_yvelocity_info {
2087 : : static std::string name() { return "y-velocity"; }
2088 : : static std::string shortDescription() { return "Request y-velocity"; }
2089 : : static std::string longDescription() { return
2090 : : R"(This keyword is used to request the fluid y-velocity as an output
2091 : : variable.)";
2092 : : }
2093 : : };
2094 : : using outvar_yvelocity =
2095 : : keyword< outvar_yvelocity_info, TAOCPP_PEGTL_STRING("y-velocity") >;
2096 : :
2097 : : struct outvar_zvelocity_info {
2098 : : static std::string name() { return "z-velocity"; }
2099 : : static std::string shortDescription() { return "Request z-velocity"; }
2100 : : static std::string longDescription() { return
2101 : : R"(This keyword is used to request the fluid z-velocity as an output
2102 : : variable.)";
2103 : : }
2104 : : };
2105 : : using outvar_zvelocity =
2106 : : keyword< outvar_zvelocity_info, TAOCPP_PEGTL_STRING("z-velocity") >;
2107 : :
2108 : : struct outvar_pressure_info {
2109 : : static std::string name() { return "pressure"; }
2110 : : static std::string shortDescription() { return "Request pressure"; }
2111 : : static std::string longDescription() { return
2112 : : R"(This keyword is used to request the fluid pressure as an output
2113 : : variable.)";
2114 : : }
2115 : : };
2116 : : using outvar_pressure =
2117 : : keyword< outvar_pressure_info, TAOCPP_PEGTL_STRING("pressure") >;
2118 : :
2119 : : struct outvar_material_indicator_info {
2120 : : static std::string name() { return "material_indicator"; }
2121 : : static std::string shortDescription() { return "Request material_indicator"; }
2122 : : static std::string longDescription() { return
2123 : : R"(This keyword is used to request the material indicator function as an
2124 : : output variable.)";
2125 : : }
2126 : : };
2127 : : using outvar_material_indicator =
2128 : : keyword< outvar_material_indicator_info,
2129 : : TAOCPP_PEGTL_STRING("material_indicator") >;
2130 : :
2131 : : struct outvar_analytic_info {
2132 : : static std::string name() { return "analytic"; }
2133 : : static std::string shortDescription() { return "Request analytic solution"; }
2134 : : static std::string longDescription() { return
2135 : : R"(This keyword is used to request the analytic solution (if exist) as an
2136 : : output variable.)";
2137 : : }
2138 : : };
2139 : : using outvar_analytic =
2140 : : keyword< outvar_analytic_info, TAOCPP_PEGTL_STRING("analytic") >;
2141 : :
2142 : : struct outvar_info {
2143 : : static std::string name() { return "outvar"; }
2144 : : static std::string shortDescription() { return
2145 : : "Start of var ... end input block"; }
2146 : : static std::string longDescription() { return
2147 : : R"(This keyword is used to start a block in the input file containing a
2148 : : list of physics variables for output. The following keywords are allowed
2149 : : in an var ... end block:)"
2150 : : + std::string("\'")
2151 : : + outvar_density::string()+ "\', \'"
2152 : : + outvar_xmomentum::string()+ "\', \'"
2153 : : + outvar_ymomentum::string()+ "\', \'"
2154 : : + outvar_zmomentum::string()+ "\', \'"
2155 : : + outvar_specific_total_energy::string() + "\', \'"
2156 : : + outvar_volumetric_total_energy::string() + "\', \'"
2157 : : + outvar_xvelocity::string() + "\', \'"
2158 : : + outvar_yvelocity::string() + "\', \'"
2159 : : + outvar_zvelocity::string() + "\', \'"
2160 : : + outvar_pressure::string() + "\', \'"
2161 : : + outvar_material_indicator::string() + "\', \'"
2162 : : + outvar_analytic::string() + "\'.";
2163 : : }
2164 : : };
2165 : : using outvar = keyword< outvar_info, TAOCPP_PEGTL_STRING("var") >;
2166 : :
2167 : : struct rngs_info {
2168 : : static std::string name() { return "rngs"; }
2169 : 655 : static std::string shortDescription() { return
2170 [ + - ]: 1310 : "Start of a random number generators description input block"; }
2171 : 655 : static std::string longDescription() { return
2172 [ + - ]: 1310 : R"(This keyword is used to start a block in the input file containing the
2173 : : descriptions and settings of requested random number generators.
2174 : : Example: "rngs mkl_mcg59 seed 2134 uniform_method accurate end end" which
2175 : : enables the MCG59 generator from MKL using the seed 2134. For more info on
2176 : : the structure of the rngs ... end block, see
2177 : : doc/pages/rngs_input.dox.)";
2178 : : }
2179 : : };
2180 : : using rngs = keyword< rngs_info, TAOCPP_PEGTL_STRING("rngs") >;
2181 : :
2182 : : struct rng_info {
2183 : : static std::string name() { return "rng"; }
2184 : 655 : static std::string shortDescription() { return
2185 [ + - ]: 1310 : "Select random number generator (RNG) from pool of enabled RNGs"; }
2186 : 655 : static std::string longDescription() { return
2187 [ + - ]: 1310 : R"(This keyword is used to select a particular random number generator (RNG)
2188 : : from a pre-selected set of (enabled and configured) pool of RNGs. The pool
2189 : : is specified by the 'rngs ... end' block and it must precede the selection
2190 : : of an RNG.)";
2191 : : }
2192 : : struct expect {
2193 [ + - ]: 1310 : static std::string description() { return "string"; }
2194 : 655 : static std::string choices() {
2195 [ + - ][ + - ]: 1310 : return '\'' + r123_threefry::string() + "\' | \'"
[ + - ]
2196 [ + - ][ + - ]: 2620 : + r123_philox::string()
2197 : : #ifdef HAS_RNGSSE2
2198 [ + - ]: 1310 : + "\' | \'"
2199 [ + - ][ + - ]: 2620 : + rngsse_gm19::string() + "\' | \'"
[ + - ]
2200 [ + - ][ + - ]: 2620 : + rngsse_gm29::string() + "\' | \'"
[ + - ]
2201 [ + - ][ + - ]: 2620 : + rngsse_gm31::string() + "\' | \'"
[ + - ]
2202 [ + - ][ + - ]: 2620 : + rngsse_gm55::string() + "\' | \'"
[ + - ]
2203 [ + - ][ + - ]: 2620 : + rngsse_gm61::string() + "\' | \'"
[ + - ]
2204 [ + - ][ + - ]: 2620 : + rngsse_gq581::string() + "\' | \'"
[ + - ]
2205 [ + - ][ + - ]: 2620 : + rngsse_gq583::string() + "\' | \'"
[ + - ]
2206 [ + - ][ + - ]: 2620 : + rngsse_gq584::string() + "\' | \'"
[ + - ]
2207 [ + - ][ + - ]: 2620 : + rngsse_mt19937::string() + "\' | \'"
[ + - ]
2208 [ + - ][ + - ]: 2620 : + rngsse_lfsr113::string() + "\' | \'"
[ + - ]
2209 [ + - ][ + - ]: 2620 : + rngsse_mrg32k3a::string()
2210 : : #endif
2211 : : #ifdef HAS_MKL
2212 [ + - ]: 1310 : + "\' | \'"
2213 [ + - ][ + - ]: 2620 : + mkl_mcg31::string() + "\' | \'"
[ + - ]
2214 [ + - ][ + - ]: 2620 : + mkl_r250::string() + "\' | \'"
[ + - ]
2215 [ + - ][ + - ]: 2620 : + mkl_mrg32k3a::string() + "\' | \'"
[ + - ]
2216 [ + - ][ + - ]: 2620 : + mkl_mcg59::string() + "\' | \'"
[ + - ]
2217 [ + - ][ + - ]: 2620 : + mkl_wh::string() + "\' | \'"
[ + - ]
2218 [ + - ][ + - ]: 2620 : + mkl_mt19937::string() + "\' | \'"
[ + - ]
2219 [ + - ][ + - ]: 2620 : + mkl_mt2203::string() + "\' | \'"
[ + - ]
2220 [ + - ][ + - ]: 2620 : + mkl_sfmt19937::string() + "\' | \'"
[ + - ]
2221 [ + - ][ + - ]: 2620 : + mkl_sobol::string() + "\' | \'"
[ + - ]
2222 [ + - ][ + - ]: 2620 : + mkl_niederr::string() + "\' | \'"
[ + - ]
2223 [ + - ][ + - ]: 2620 : + mkl_iabstract::string() + "\' | \'"
[ + - ]
2224 [ + - ][ + - ]: 2620 : + mkl_dabstract::string() + "\' | \'"
[ + - ]
2225 [ + - ][ + - ]: 2620 : + mkl_sabstract::string() + "\' | \'"
[ + - ]
2226 [ + - ][ + - ]: 2620 : + mkl_nondeterm::string() + "\' "
2227 : : #else
2228 : : + "\' "
2229 : : #endif
2230 : : + "Remember: the RNG must be listed in the pool before it can be "
2231 [ + - ]: 1310 : "selected via this keyword!";
2232 : : }
2233 : : };
2234 : : };
2235 : : using rng = keyword< rng_info, TAOCPP_PEGTL_STRING("rng") >;
2236 : :
2237 : : struct sde_omega_info {
2238 : : static std::string name() { return "omega"; }
2239 : 655 : static std::string shortDescription() { return
2240 [ + - ]: 1310 : R"(Set SDE parameter(s) omega)"; }
2241 : 655 : static std::string longDescription() { return
2242 [ + - ]: 1310 : R"(This keyword is used to specify a vector of real numbers used to
2243 : : parameterize a system of stochastic differential equations. Example:
2244 : : "omega 5.0 2.0 3.0 end". The length of the vector depends on the particular
2245 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
2246 : : struct expect {
2247 : : using type = tk::real;
2248 [ + - ]: 1310 : static std::string description() { return "real(s)"; }
2249 : : };
2250 : : };
2251 : : using sde_omega = keyword< sde_omega_info, TAOCPP_PEGTL_STRING("omega") >;
2252 : :
2253 : : struct sde_c0_info {
2254 : : static std::string name() { return "C0"; }
2255 : 655 : static std::string shortDescription() { return
2256 [ + - ]: 1310 : R"(Set Langevin SDE parameter C0)"; }
2257 : 655 : static std::string longDescription() { return
2258 [ + - ]: 1310 : R"(This keyword is used to specify a real number used to parameterize the
2259 : : Langevin model for the fluctuating velocity in homogeneous variable-density
2260 : : turbulence. Example: "C0 2.1".)"; }
2261 : : struct expect {
2262 : : using type = tk::real;
2263 [ + - ]: 1310 : static std::string description() { return "real"; }
2264 : : };
2265 : : };
2266 : : using sde_c0 = keyword< sde_c0_info, TAOCPP_PEGTL_STRING("C0") >;
2267 : :
2268 : : struct gravity_info {
2269 : : static std::string name() { return "gravity"; }
2270 : 655 : static std::string shortDescription() { return
2271 [ + - ]: 1310 : R"(Set Langevin SDE parameter gravity)"; }
2272 : 655 : static std::string longDescription() { return
2273 [ + - ]: 1310 : R"(This keyword is used to specify a vector of 3 real numbers used to
2274 : : parameterize the Langevin model for the fluctuating velocity in homogeneous
2275 : : variable-density turbulence, prescribing a gravy body force in the three
2276 : : coordinate directions, x, y, z. Example: "gravity 0.0 0.2 1.0 end".)"; }
2277 : : struct expect {
2278 : : using type = tk::real;
2279 [ + - ]: 1310 : static std::string description() { return "3 reals"; }
2280 : : };
2281 : : };
2282 : : using gravity = keyword< gravity_info, TAOCPP_PEGTL_STRING("gravity") >;
2283 : :
2284 : : struct sde_c3_info {
2285 : : static std::string name() { return "C3"; }
2286 : 655 : static std::string shortDescription() { return
2287 [ + - ]: 1310 : R"(Set gamma (dissipation) SDE parameter C3)"; }
2288 : 655 : static std::string longDescription() { return
2289 [ + - ]: 1310 : R"(This keyword is used to specify a real number used to parameterize the
2290 : : gamma distribution dissipation (turbulence frequency) model for particles
2291 : : Example: "C3 1.0".)"; }
2292 : : struct expect {
2293 : : using type = tk::real;
2294 : : static constexpr type lower = 0.0;
2295 [ + - ]: 1310 : static std::string description() { return "real"; }
2296 : : };
2297 : : };
2298 : : using sde_c3 = keyword< sde_c3_info, TAOCPP_PEGTL_STRING("C3") >;
2299 : :
2300 : : struct sde_c4_info {
2301 : : static std::string name() { return "C4"; }
2302 : 655 : static std::string shortDescription() { return
2303 [ + - ]: 1310 : R"(Set gamma (dissipation) SDE parameter C4)"; }
2304 : 655 : static std::string longDescription() { return
2305 [ + - ]: 1310 : R"(This keyword is used to specify a real number used to parameterize the
2306 : : gamma distribution dissipation (turbulence frequency) model for particles
2307 : : Example: "C4 0.25".)"; }
2308 : : struct expect {
2309 : : using type = tk::real;
2310 : : static constexpr type lower = 0.0;
2311 [ + - ]: 1310 : static std::string description() { return "real"; }
2312 : : };
2313 : : };
2314 : : using sde_c4 = keyword< sde_c4_info, TAOCPP_PEGTL_STRING("C4") >;
2315 : :
2316 : : struct sde_com1_info {
2317 : : static std::string name() { return "COM1"; }
2318 : 655 : static std::string shortDescription() { return
2319 [ + - ]: 1310 : R"(Set gamma (dissipation) SDE parameter COM1)"; }
2320 : 655 : static std::string longDescription() { return
2321 [ + - ]: 1310 : R"(This keyword is used to specify a real number used to parameterize the
2322 : : gamma distribution dissipation (turbulence frequency) model for particles
2323 : : Example: "COM1 0.44".)"; }
2324 : : struct expect {
2325 : : using type = tk::real;
2326 : : static constexpr type lower = 0.0;
2327 [ + - ]: 1310 : static std::string description() { return "real"; }
2328 : : };
2329 : : };
2330 : : using sde_com1 = keyword< sde_com1_info, TAOCPP_PEGTL_STRING("COM1") >;
2331 : :
2332 : : struct sde_com2_info {
2333 : : static std::string name() { return "COM2"; }
2334 : 655 : static std::string shortDescription() { return
2335 [ + - ]: 1310 : R"(Set gamma (dissipation) SDE parameter COM2)"; }
2336 : 655 : static std::string longDescription() { return
2337 [ + - ]: 1310 : R"(This keyword is used to specify a real number used to parameterize the
2338 : : gamma distribution dissipation (turbulence frequency) model for particles
2339 : : Example: "COM2 0.9".)"; }
2340 : : struct expect {
2341 : : using type = tk::real;
2342 : : static constexpr type lower = 0.0;
2343 [ + - ]: 1310 : static std::string description() { return "real"; }
2344 : : };
2345 : : };
2346 : : using sde_com2 = keyword< sde_com2_info, TAOCPP_PEGTL_STRING("COM2") >;
2347 : :
2348 : : struct sde_b_info {
2349 : : static std::string name() { return "b"; }
2350 : 655 : static std::string shortDescription() { return
2351 [ + - ]: 1310 : R"(Set SDE parameter(s) b)"; }
2352 : 655 : static std::string longDescription() { return
2353 [ + - ]: 1310 : R"(This keyword is used to specify a vector of real numbers used to
2354 : : parameterize a system of stochastic differential equations. Example:
2355 : : "b 5.0 2.0 3.0 end". The length of the vector depends on the particular
2356 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
2357 : : struct expect {
2358 : : using type = tk::real;
2359 [ + - ]: 1310 : static std::string description() { return "real(s)"; }
2360 : : };
2361 : : };
2362 : : using sde_b = keyword< sde_b_info, TAOCPP_PEGTL_STRING("b") >;
2363 : :
2364 : : struct sde_S_info {
2365 : : static std::string name() { return "S"; }
2366 : 655 : static std::string shortDescription() { return
2367 [ + - ]: 1310 : R"(Set SDE parameter(s) S)"; }
2368 : 655 : static std::string longDescription() { return
2369 [ + - ]: 1310 : R"(This keyword is used to specify a vector of real numbers used to
2370 : : parameterize a system of stochastic differential equations. Example:
2371 : : "S 5.0 2.0 3.0 end". The length of the vector depends on the particular
2372 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
2373 : : struct expect {
2374 : : using type = tk::real;
2375 [ + - ]: 1310 : static std::string description() { return "real(s)"; }
2376 : : };
2377 : : };
2378 : : using sde_S = keyword< sde_S_info, TAOCPP_PEGTL_STRING("S") >;
2379 : :
2380 : : struct sde_kappa_info {
2381 : : static std::string name() { return "kappa"; }
2382 : 655 : static std::string shortDescription() { return
2383 [ + - ]: 1310 : R"(Set SDE parameter(s) kappa)"; }
2384 : 655 : static std::string longDescription() { return
2385 [ + - ]: 1310 : R"(This keyword is used to specify a vector of real numbers used to
2386 : : parameterize a system of stochastic differential equations. Example:
2387 : : "kappa 5.0 2.0 3.0 end". The length of the vector depends on the particular
2388 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
2389 : : struct expect {
2390 : : using type = tk::real;
2391 [ + - ]: 1310 : static std::string description() { return "real(s)"; }
2392 : : };
2393 : : };
2394 : : using sde_kappa = keyword< sde_kappa_info, TAOCPP_PEGTL_STRING("kappa") >;
2395 : :
2396 : : struct sde_bprime_info {
2397 : : static std::string name() { return "bprime"; }
2398 : 655 : static std::string shortDescription() { return
2399 [ + - ]: 1310 : R"(Set SDE parameter(s) bprime)"; }
2400 : 655 : static std::string longDescription() { return
2401 [ + - ]: 1310 : R"(This keyword is used to specify a vector of real numbers used to
2402 : : parameterize a system of stochastic differential equations. Example:
2403 : : "bprime 5.0 2.0 3.0 end". The length of the vector depends on the particular
2404 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
2405 : : struct expect {
2406 : : using type = sde_b_info::expect::type;
2407 [ + - ]: 1310 : static std::string description() { return "real(s)"; }
2408 : : };
2409 : : };
2410 : : using sde_bprime = keyword< sde_bprime_info, TAOCPP_PEGTL_STRING("bprime") >;
2411 : :
2412 : : struct sde_kappaprime_info {
2413 : : static std::string name() { return "kappaprime"; }
2414 : 655 : static std::string shortDescription() { return
2415 [ + - ]: 1310 : R"(Set SDE parameter(s) kappaprime)"; }
2416 : 655 : static std::string longDescription() { return
2417 [ + - ]: 1310 : R"(This keyword is used to specify a vector of real numbers used to
2418 : : parameterize a system of stochastic differential equations. Example:
2419 : : "kappaprime 5.0 2.0 3.0 end". The length of the vector depends on the
2420 : : particular type of SDE system and is controlled by the preceding keyword
2421 : : 'ncomp'.)"; }
2422 : : struct expect {
2423 : : using type = sde_kappa_info::expect::type;
2424 [ + - ]: 1310 : static std::string description() { return "real(s)"; }
2425 : : };
2426 : : };
2427 : : using sde_kappaprime = keyword< sde_kappaprime_info, TAOCPP_PEGTL_STRING("kappaprime") >;
2428 : :
2429 : : struct sde_c_info {
2430 : : static std::string name() { return "c"; }
2431 : 655 : static std::string shortDescription() { return
2432 [ + - ]: 1310 : R"(Set SDE parameter(s) c)"; }
2433 : 655 : static std::string longDescription() { return
2434 [ + - ]: 1310 : R"(This keyword is used to specify a vector of real numbers used to
2435 : : parameterize a system of stochastic differential equations. Example:
2436 : : "c 5.0 2.0 3.0 end". The length of the vector depends on the particular type
2437 : : of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
2438 : : struct expect {
2439 : : using type = tk::real;
2440 [ + - ]: 1310 : static std::string description() { return "real(s)"; }
2441 : : };
2442 : : };
2443 : : using sde_c = keyword< sde_c_info, TAOCPP_PEGTL_STRING("c") >;
2444 : :
2445 : : struct sde_sigmasq_info {
2446 : : static std::string name() { return "sigmasq"; }
2447 : 655 : static std::string shortDescription() { return
2448 [ + - ]: 1310 : R"(Set SDE parameter(s) sigmasq)"; }
2449 : 655 : static std::string longDescription() { return
2450 [ + - ]: 1310 : R"(This keyword is used to specify a vector of real numbers used to
2451 : : parameterize a system of stochastic differential equations. Example:
2452 : : "sigmasq
2453 : : 4.0 2.5 1.1
2454 : : 32.0 5.6
2455 : : 23.0
2456 : : end"
2457 : : The length of the vector depends on the
2458 : : particular type of SDE system and is controlled by the preceding keyword
2459 : : 'ncomp'.)"; }
2460 : : struct expect {
2461 : : using type = tk::real;
2462 [ + - ]: 1310 : static std::string description() { return "real(s)"; }
2463 : : };
2464 : : };
2465 : : using sde_sigmasq = keyword< sde_sigmasq_info, TAOCPP_PEGTL_STRING("sigmasq") >;
2466 : :
2467 : : struct sde_cov_info {
2468 : : static std::string name() { return "cov"; }
2469 : 655 : static std::string shortDescription() { return
2470 [ + - ]: 1310 : R"(Set SDE parameter(s) cov)"; }
2471 : 655 : static std::string longDescription() { return
2472 [ + - ]: 1310 : R"(This keyword is used to specify a vector of real numbers used to
2473 : : parameterize a system of stochastic differential equations. Example:
2474 : : "cov
2475 : : 4.0 2.5 1.1
2476 : : 32.0 5.6
2477 : : 23.0
2478 : : end"
2479 : : The length of the vector depends on the
2480 : : particular type of SDE system and is controlled by the preceding keyword
2481 : : 'ncomp'.)"; }
2482 : : struct expect {
2483 : : using type = tk::real;
2484 [ + - ]: 1310 : static std::string description() { return "real(s)"; }
2485 : : };
2486 : : };
2487 : : using sde_cov = keyword< sde_cov_info, TAOCPP_PEGTL_STRING("cov") >;
2488 : :
2489 : : struct sde_theta_info {
2490 : : static std::string name() { return "theta"; }
2491 : 655 : static std::string shortDescription() { return
2492 [ + - ]: 1310 : R"(Set SDE parameter(s) theta)"; }
2493 : 655 : static std::string longDescription() { return
2494 [ + - ]: 1310 : R"(This keyword is used to specify a vector of real numbers used to
2495 : : parameterize a system of stochastic differential equations. Example:
2496 : : "theta 5.0 2.0 3.0 end". The length of the vector depends on the particular
2497 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
2498 : : struct expect {
2499 : : using type = tk::real;
2500 [ + - ]: 1310 : static std::string description() { return "real(s)"; }
2501 : : };
2502 : : };
2503 : : using sde_theta = keyword< sde_theta_info, TAOCPP_PEGTL_STRING("theta") >;
2504 : :
2505 : : struct sde_mu_info {
2506 : : static std::string name() { return "mu"; }
2507 : 655 : static std::string shortDescription() { return
2508 [ + - ]: 1310 : R"(Set SDE parameter(s) mu)"; }
2509 : 655 : static std::string longDescription() { return
2510 [ + - ]: 1310 : R"(This keyword is used to specify a vector of real numbers used to
2511 : : parameterize a system of stochastic differential equations. Example:
2512 : : "mu 5.0 2.0 3.0 end". The length of the vector depends on the particular
2513 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
2514 : : struct expect {
2515 : : using type = tk::real;
2516 [ + - ]: 1310 : static std::string description() { return "real(s)"; }
2517 : : };
2518 : : };
2519 : : using sde_mu = keyword< sde_mu_info, TAOCPP_PEGTL_STRING("mu") >;
2520 : :
2521 : : struct sde_mean_info {
2522 : : static std::string name() { return "mean"; }
2523 : 655 : static std::string shortDescription() { return
2524 [ + - ]: 1310 : R"(Set SDE parameter(s) mean)"; }
2525 : 655 : static std::string longDescription() { return
2526 [ + - ]: 1310 : R"(This keyword is used to specify a vector of real numbers used to
2527 : : parameterize a system of stochastic differential equations. Example:
2528 : : "mean 5.0 2.0 3.0 end". The length of the vector depends on the particular
2529 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
2530 : : struct expect {
2531 : : using type = tk::real;
2532 [ + - ]: 1310 : static std::string description() { return "real(s)"; }
2533 : : };
2534 : : };
2535 : : using sde_mean = keyword< sde_mean_info, TAOCPP_PEGTL_STRING("mean") >;
2536 : :
2537 : : struct sde_T_info {
2538 : : static std::string name() { return "T"; }
2539 : 655 : static std::string shortDescription() { return
2540 [ + - ]: 1310 : R"(Set SDE parameter(s) T)"; }
2541 : 655 : static std::string longDescription() { return
2542 [ + - ]: 1310 : R"(This keyword is used to specify a vector of real numbers used to
2543 : : parameterize a system of stochastic differential equations. Example:
2544 : : "T 5.0 2.0 3.0 end". The length of the vector depends on the particular
2545 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
2546 : : struct expect {
2547 : : using type = tk::real;
2548 [ + - ]: 1310 : static std::string description() { return "real(s)"; }
2549 : : };
2550 : : };
2551 : : using sde_T = keyword< sde_T_info, TAOCPP_PEGTL_STRING("T") >;
2552 : :
2553 : : struct sde_lambda_info {
2554 : : static std::string name() { return "lambda"; }
2555 : 655 : static std::string shortDescription() { return
2556 [ + - ]: 1310 : R"(Set SDE parameter(s) lambda)"; }
2557 : 655 : static std::string longDescription() { return
2558 [ + - ]: 1310 : R"(This keyword is used to specify a vector of real numbers used to
2559 : : parameterize a system of stochastic differential equations. Example:
2560 : : "lambda 5.0 2.0 3.0 end". The length of the vector depends on the particular
2561 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
2562 : : struct expect {
2563 : : using type = tk::real;
2564 [ + - ]: 1310 : static std::string description() { return "real(s)"; }
2565 : : };
2566 : : };
2567 : : using sde_lambda = keyword< sde_lambda_info, TAOCPP_PEGTL_STRING("lambda") >;
2568 : :
2569 : : struct spike_info {
2570 : : static std::string name() { return "spike"; }
2571 : 655 : static std::string shortDescription() { return
2572 [ + - ]: 1310 : R"(Configure a delta spike)"; }
2573 : 655 : static std::string longDescription() { return
2574 [ + - ]: 1310 : R"(This keyword is used to specify the configuration of delta spikes for,
2575 : : the delta initialization policy. The configuration is given by an even set
2576 : : of real numbers inside a spike...end block. Example: "spike 0.1 1.0 end",
2577 : : which specifies a delta spike at sample space position 0.1 with relative
2578 : : height 1.0. The height must be between [0.0...1.0] inclusive and specifies a
2579 : : relative probability. See also the help on keyword icdelta.)"; }
2580 : : struct expect {
2581 : : using type = tk::real;
2582 [ + - ]: 1310 : static std::string description() { return "even reals"; }
2583 : : };
2584 : : };
2585 : : using spike = keyword< spike_info, TAOCPP_PEGTL_STRING("spike") >;
2586 : :
2587 : : struct icdelta_info {
2588 : : static std::string name() { return "icdelta"; }
2589 : 655 : static std::string shortDescription() { return
2590 [ + - ]: 1310 : R"(Introduce a icdelta...end block used to configure delta spikes)"; }
2591 : 655 : static std::string longDescription() { return
2592 [ + - ]: 1310 : R"(This keyword is used to introduce a icdelta...end block in which delta
2593 : : spikes are configured for the delta initialization policy. Example:
2594 : : "init jointdelta" - select joint delta init-policy,"icdelta spike 0.1 0.3
2595 : : 0.9 0.7 end end" - prescribe a univariate distribution that consists of two
2596 : : delta-spikes at sample space positions 0.1 and 0.9 with spike heights 0.3
2597 : : and 0.7, respectively. Note that the sum of the heights must add up to
2598 : : unity. See also the help on keyword jointdelta and spike.)"; }
2599 : : };
2600 : : using icdelta = keyword< icdelta_info, TAOCPP_PEGTL_STRING("icdelta") >;
2601 : :
2602 : : struct betapdf_info {
2603 : : static std::string name() { return "betapdf"; }
2604 : 655 : static std::string shortDescription() { return
2605 [ + - ]: 1310 : R"(Configure a beta distribution)"; }
2606 : 655 : static std::string longDescription() { return
2607 [ + - ]: 1310 : R"(This keyword is used to specify the configuration of beta distributions
2608 : : for the beta initialization policy. The configuration is given by four
2609 : : real numbers inside a betapdf...end block. Example: "betapdf 0.2 0.3 0.0 1.0
2610 : : end", which specifies a univariate beta distribution with shape parameters
2611 : : 0.2 and 0.3, displacement 0.0, and scale 1.0. See also the help on keyword
2612 : : icbeta.)"; }
2613 : : struct expect {
2614 : : using type = tk::real;
2615 [ + - ]: 1310 : static std::string description() { return "4 reals"; }
2616 : : };
2617 : : };
2618 : : using betapdf = keyword< betapdf_info, TAOCPP_PEGTL_STRING("betapdf") >;
2619 : :
2620 : : struct gaussian_info {
2621 : : static std::string name() { return "Gaussian"; }
2622 : 655 : static std::string shortDescription() { return
2623 [ + - ]: 1310 : R"(Configure a Gaussian distribution)"; }
2624 : 655 : static std::string longDescription() { return
2625 [ + - ]: 1310 : R"(This keyword is used to specify the configuration of Gaussian
2626 : : distributions for the jointgaussian initialization policy. The configuration
2627 : : is given by two real numbers inside a gaussian...end block. Example:
2628 : : "gaussian 0.2 0.3 end", which specifies a Gaussian distribution with 0.2
2629 : : mean and 0.3 variance. See also the help on keyword icgaussian.)"; }
2630 : : struct expect {
2631 : : using type = tk::real;
2632 [ + - ]: 1310 : static std::string description() { return "2 reals"; }
2633 : : };
2634 : : };
2635 : : using gaussian = keyword< gaussian_info, TAOCPP_PEGTL_STRING("gaussian") >;
2636 : :
2637 : : struct icbeta_info {
2638 : : static std::string name() { return "icbeta"; }
2639 : 655 : static std::string shortDescription() { return
2640 [ + - ]: 1310 : R"(Introduce an icbeta...end block used to configure beta distributions)"; }
2641 : 655 : static std::string longDescription() { return
2642 [ + - ]: 1310 : R"(This keyword is used to introduce an icbeta...end block in which beta
2643 : : distributions are configured for the beta initialization policy. Example:
2644 : : "init jointbeta" - select beta init-policy,"icbeta betapdf 0.2 0.3 0.0 1.0
2645 : : end end" - prescribe a univariate beta distribution with shape parameters
2646 : : 0.2 and 0.3, displacement 0.0, and scale 1.0. See also the help on keyword
2647 : : jointbeta and betapdf.)"; }
2648 : : };
2649 : : using icbeta = keyword< icbeta_info, TAOCPP_PEGTL_STRING("icbeta") >;
2650 : :
2651 : : struct icgaussian_info {
2652 : : static std::string name() { return "icgaussian"; }
2653 : 655 : static std::string shortDescription() {
2654 [ + - ]: 1310 : return R"(Configure a joint uncorrelated Gaussian as initial condition)"; }
2655 : 655 : static std::string longDescription() { return
2656 [ + - ]: 1310 : R"(This keyword is used to introduce an icgaussian...end block in which
2657 : : Gaussian distributions are configured for the jointgaussian initialization
2658 : : policy. Example: "init jointgaussian" - select jointgaussian
2659 : : init-policy,"icgaussian gaussian 0.2 0.3 end end" - prescribes a univariate
2660 : : Gaussian distribution with 0.2 mean and 0.3 variance. See also the help on
2661 : : keyword jointgaussian and gaussian.)"; }
2662 : : };
2663 : : using icgaussian = keyword< icgaussian_info, TAOCPP_PEGTL_STRING("icgaussian") >;
2664 : :
2665 : : struct icjointgaussian_info {
2666 : : static std::string name() { return "icjointgaussian"; }
2667 : 655 : static std::string shortDescription() {
2668 [ + - ]: 1310 : return R"(Configure an joint correlated Gaussian as initial condition)"; }
2669 : 655 : static std::string longDescription() { return
2670 [ + - ]: 1310 : R"(This keyword is used to introduce an icjointgaussian...end block in which
2671 : : a multi-variate joint Gaussian distribution is configured for the
2672 : : jointgaussian initialization policy. Example: "init jointgaussian" - select
2673 : : jointgaussian init-policy, "
2674 : : icjointgaussian
2675 : : mean 0.0 0.5 1.0 end
2676 : : cov
2677 : : 4.0 2.5 1.1
2678 : : 32.0 5.6
2679 : : 23.0
2680 : : end
2681 : : end" - prescribes a tri-variate joint Gaussian distribution with means
2682 : : 0.0, 0.5 and 1.0, and a covariance matrix which must be symmetric positive
2683 : : definite. See also the help on keyword jointgaussian and gaussian.)"; }
2684 : : };
2685 : : using icjointgaussian =
2686 : : keyword< icjointgaussian_info, TAOCPP_PEGTL_STRING("icjointgaussian") >;
2687 : :
2688 : : struct gammapdf_info {
2689 : : static std::string name() { return "gammapdf"; }
2690 : 655 : static std::string shortDescription() { return
2691 [ + - ]: 1310 : R"(Configure a gamma distribution)"; }
2692 : 655 : static std::string longDescription() { return
2693 [ + - ]: 1310 : R"(This keyword is used to specify the configuration of gamma distributions
2694 : : for the gamma initialization policy. The configuration is given by two
2695 : : real numbers inside a gammapdf...end block. Example: "gammapdf 0.2 0.3
2696 : : end", which specifies a univariate gamma distribution with shape and scale
2697 : : parameters 0.2 and 0.3, respectively. See also the help on keyword
2698 : : icgamma.)"; }
2699 : : struct expect {
2700 : : using type = tk::real;
2701 [ + - ]: 1310 : static std::string description() { return "2 reals"; }
2702 : : };
2703 : : };
2704 : : using gammapdf = keyword< gammapdf_info, TAOCPP_PEGTL_STRING("gammapdf") >;
2705 : :
2706 : : struct icgamma_info {
2707 : : static std::string name() { return "icgamma"; }
2708 : 655 : static std::string shortDescription() { return
2709 [ + - ]: 1310 : R"(Configure a gamma distribution as initial condition)"; }
2710 : 655 : static std::string longDescription() { return
2711 [ + - ]: 1310 : R"(This keyword is used to introduce an icgamma...end block in which gamma
2712 : : distributions are configured for the gamma initialization policy. Example:
2713 : : "init jointgamma" - select gamma init-policy,"icgamma gammapdf 0.2 0.3
2714 : : end end" - prescribe a univariate gamma distribution with shape and scale
2715 : : parameters 0.2 and 0.3, respectively. See also the help on keyword
2716 : : jointgamma and gammapdf.)"; }
2717 : : };
2718 : : using icgamma = keyword< icgamma_info, TAOCPP_PEGTL_STRING("icgamma") >;
2719 : :
2720 : : struct dirichletpdf_info {
2721 : : static std::string name() { return "dirichletpdf"; }
2722 : 655 : static std::string shortDescription() { return
2723 [ + - ]: 1310 : R"(Configure a Dirichlet distribution)"; }
2724 : 655 : static std::string longDescription() { return
2725 [ + - ]: 1310 : R"(This keyword is used to specify the configuration of a Dirichlet
2726 : : distribution for the Dirichlet initialization policy. The configuration is
2727 : : given by a vector of positive real numbers inside a dirichletpdf...end
2728 : : block. Example: "dirichletpdf 0.1 0.3 0.2 end" - prescribe a Dirichlet
2729 : : distribution with shape parameters 0.1, 0.3, and 0.2. See also the help on
2730 : : keyword icdirichlet.)"; }
2731 : : struct expect {
2732 : : using type = tk::real;
2733 [ + - ]: 1310 : static std::string description() { return "reals"; }
2734 : : };
2735 : : };
2736 : : using dirichletpdf =
2737 : : keyword< dirichletpdf_info, TAOCPP_PEGTL_STRING("dirichletpdf") >;
2738 : :
2739 : : struct icdirichlet_info {
2740 : : static std::string name() { return "icdirichlet"; }
2741 : 655 : static std::string shortDescription() { return
2742 [ + - ]: 1310 : R"(Configure a Dirichlet PDF as initial condition)"; }
2743 : 655 : static std::string longDescription() { return
2744 [ + - ]: 1310 : R"(This keyword is used to introduce an icdirichlet...end block in which a
2745 : : Dirichlet distribution is configured for the Dirichlet initialization
2746 : : policy)"; }
2747 : : };
2748 : : using icdirichlet =
2749 : : keyword< icdirichlet_info, TAOCPP_PEGTL_STRING("icdirichlet") >;
2750 : :
2751 : : struct velocity_info {
2752 [ + - ]: 39108 : static std::string name() { return "velocity"; }
2753 [ + - ]: 1310 : static std::string shortDescription() { return "Specify velocity"; }
2754 : 655 : static std::string longDescription() { return
2755 [ + - ]: 1310 : R"(This keyword is used to configure a velocity vector, used for, e.g.,
2756 : : boundary or initial conditions or as a keyword that selects velocity in some
2757 : : other context-specific way, e.g., 'velocity' as opposed to 'position'.)";
2758 : : }
2759 : : struct expect {
2760 : : using type = tk::real;
2761 [ + - ]: 1310 : static std::string description() { return "real(s)"; }
2762 : : };
2763 : : };
2764 : : using velocity = keyword< velocity_info, TAOCPP_PEGTL_STRING("velocity") >;
2765 : :
2766 : : struct acceleration_info {
2767 : : static std::string name() { return "acceleration"; }
2768 : : static std::string shortDescription() { return "Specify acceleration"; }
2769 : : static std::string longDescription() { return
2770 : : R"(This keyword is used as a keyword that selects acceleration in some
2771 : : other context-specific way, e.g., as opposed to 'velocity' or 'position'.)";
2772 : : }
2773 : : };
2774 : : using acceleration =
2775 : : keyword< acceleration_info, TAOCPP_PEGTL_STRING("acceleration") >;
2776 : :
2777 : : struct materialid_info {
2778 : : static std::string name() { return "materialid"; }
2779 : : static std::string shortDescription() { return "Specify material id"; }
2780 : : static std::string longDescription() { return
2781 : : R"(This keyword is used to configure the material id within a box as a part
2782 : : of the initialization.)";
2783 : : }
2784 : : struct expect {
2785 : : using type = std::size_t;
2786 : : static constexpr type lower = 1;
2787 : : static std::string description() { return "uint"; }
2788 : : };
2789 : : };
2790 : : using materialid = keyword< materialid_info,
2791 : : TAOCPP_PEGTL_STRING("materialid") >;
2792 : :
2793 : : struct mass_info {
2794 : : static std::string name() { return "mass"; }
2795 : : static std::string shortDescription() { return "Specify mass"; }
2796 : : static std::string longDescription() { return
2797 : : R"(This keyword is used to configure the mass
2798 : : and associated volume within a box.)";
2799 : : }
2800 : : struct expect {
2801 : : using type = tk::real;
2802 : : static std::string description() { return "real"; }
2803 : : };
2804 : : };
2805 : : using mass = keyword< mass_info, TAOCPP_PEGTL_STRING("mass") >;
2806 : :
2807 : : struct density_info {
2808 : : static std::string name() { return "density"; }
2809 : : static std::string shortDescription() { return "Specify density"; }
2810 : : static std::string longDescription() { return
2811 : : R"(This keyword is used to configure a density, used for, e.g., boundary or
2812 : : initial conditions.)";
2813 : : }
2814 : : struct expect {
2815 : : using type = tk::real;
2816 : : static std::string description() { return "real"; }
2817 : : };
2818 : : };
2819 : : using density = keyword< density_info, TAOCPP_PEGTL_STRING("density") >;
2820 : :
2821 : : struct pressure_info {
2822 : : static std::string name() { return "pressure"; }
2823 : : static std::string shortDescription() { return "Specify pressure"; }
2824 : : static std::string longDescription() { return
2825 : : R"(This keyword is used to configure a pressure, used for, e.g., boundary or
2826 : : initial conditions or as a keyword that selects pressure in some other
2827 : : context-specific way.)";
2828 : : }
2829 : : struct expect {
2830 : : using type = tk::real;
2831 : : static std::string description() { return "real"; }
2832 : : };
2833 : : };
2834 : : using pressure = keyword< pressure_info, TAOCPP_PEGTL_STRING("pressure") >;
2835 : :
2836 : : struct energy_info {
2837 : : static std::string name() { return "energy"; }
2838 : : static std::string shortDescription() { return
2839 : : "Specify energy per unit mass"; }
2840 : : static std::string longDescription() { return
2841 : : R"(This keyword is used to configure energy per unit mass, used for, e.g.,
2842 : : boundary or initial conditions.)"; }
2843 : : struct expect {
2844 : : using type = tk::real;
2845 : : static std::string description() { return "real"; }
2846 : : };
2847 : : };
2848 : : using energy = keyword< energy_info, TAOCPP_PEGTL_STRING("energy") >;
2849 : :
2850 : : struct energy_content_info {
2851 : : static std::string name() { return "energy_content"; }
2852 : : static std::string shortDescription() { return
2853 : : "Specify energy per unit volume";
2854 : : }
2855 : : static std::string longDescription() { return
2856 : : R"(This keyword is used to configure energy per unit volume, used for, e.g.,
2857 : : boundary or initial conditions.)"; }
2858 : : struct expect {
2859 : : using type = tk::real;
2860 : : static std::string description() { return "real"; }
2861 : : };
2862 : : };
2863 : : using energy_content =
2864 : : keyword< energy_content_info, TAOCPP_PEGTL_STRING("energy_content") >;
2865 : :
2866 : : struct temperature_info {
2867 : : static std::string name() { return "temperature"; }
2868 : : static std::string shortDescription() { return "Specify temperature"; }
2869 : : static std::string longDescription() { return
2870 : : R"(This keyword is used to configure temperature, used for, e.g.,
2871 : : boundary or initial conditions.)"; }
2872 : : struct expect {
2873 : : using type = tk::real;
2874 : : static std::string description() { return "real"; }
2875 : : };
2876 : : };
2877 : : using temperature =
2878 : : keyword< temperature_info, TAOCPP_PEGTL_STRING("temperature") >;
2879 : :
2880 : : struct lua_info {
2881 : : static std::string name() { return "lua"; }
2882 : : static std::string shortDescription() { return
2883 : : R"(Introduce a lua ... end block to inject lua code in control files)"; }
2884 : : static std::string longDescription() { return
2885 : : R"(This keyword is used to introduce a lua ... end block which can be used
2886 : : to inject arbitrary Lua code into control files. For more info on the lua
2887 : : language, see https://www.lua.org.)"; }
2888 : : };
2889 : : using lua = keyword< lua_info, TAOCPP_PEGTL_STRING("lua") >;
2890 : :
2891 : : struct xmin_info {
2892 : : static std::string name() { return "xmin"; }
2893 : : static std::string shortDescription() { return "Minimum x coordinate"; }
2894 : : static std::string longDescription() { return
2895 : : R"(This keyword used to configure a minimum x coordinate, e.g., to specify
2896 : : a box.)"; }
2897 : : struct expect {
2898 : : using type = tk::real;
2899 : : static std::string description() { return "real"; }
2900 : : };
2901 : : };
2902 : : using xmin = keyword< xmin_info, TAOCPP_PEGTL_STRING("xmin") >;
2903 : :
2904 : : struct xmax_info {
2905 : : static std::string name() { return "xmax"; }
2906 : : static std::string shortDescription() { return "Maximum x coordinate"; }
2907 : : static std::string longDescription() { return
2908 : : R"(This keyword used to configure a maximum x coordinate, e.g., to specify
2909 : : a box.)"; }
2910 : : struct expect {
2911 : : using type = tk::real;
2912 : : static std::string description() { return "real"; }
2913 : : };
2914 : : };
2915 : : using xmax = keyword< xmax_info, TAOCPP_PEGTL_STRING("xmax") >;
2916 : :
2917 : : struct ymin_info {
2918 : : static std::string name() { return "ymin"; }
2919 : : static std::string shortDescription() { return "Minimum y coordinate"; }
2920 : : static std::string longDescription() { return
2921 : : R"(This keyword used to configure a minimum y coordinate, e.g., to specify
2922 : : a box.)"; }
2923 : : struct expect {
2924 : : using type = tk::real;
2925 : : static std::string description() { return "real"; }
2926 : : };
2927 : : };
2928 : : using ymin = keyword< ymin_info, TAOCPP_PEGTL_STRING("ymin") >;
2929 : :
2930 : : struct ymax_info {
2931 : : static std::string name() { return "ymax"; }
2932 : : static std::string shortDescription() { return "Maximum y coordinate"; }
2933 : : static std::string longDescription() { return
2934 : : R"(This keyword used to configure a maximum y coordinate, e.g., to specify
2935 : : a box.)"; }
2936 : : struct expect {
2937 : : using type = tk::real;
2938 : : static std::string description() { return "real"; }
2939 : : };
2940 : : };
2941 : : using ymax = keyword< ymax_info, TAOCPP_PEGTL_STRING("ymax") >;
2942 : :
2943 : : struct zmin_info {
2944 : : static std::string name() { return "zmin"; }
2945 : : static std::string shortDescription() { return "Minimum z coordinate"; }
2946 : : static std::string longDescription() { return
2947 : : R"(This keyword used to configure a minimum z coordinate, e.g., to specify
2948 : : a box.)"; }
2949 : : struct expect {
2950 : : using type = tk::real;
2951 : : static std::string description() { return "real"; }
2952 : : };
2953 : : };
2954 : : using zmin = keyword< zmin_info, TAOCPP_PEGTL_STRING("zmin") >;
2955 : :
2956 : : struct zmax_info {
2957 : : static std::string name() { return "zmax"; }
2958 : : static std::string shortDescription() { return "Maximum z coordinate"; }
2959 : : static std::string longDescription() { return
2960 : : R"(This keyword used to configure a maximum z coordinate, e.g., to specify
2961 : : a box.)"; }
2962 : : struct expect {
2963 : : using type = tk::real;
2964 : : static std::string description() { return "real"; }
2965 : : };
2966 : : };
2967 : : using zmax = keyword< zmax_info, TAOCPP_PEGTL_STRING("zmax") >;
2968 : :
2969 : : struct impulse_info {
2970 : : static std::string name() { return "impulse"; }
2971 : : static std::string shortDescription() { return
2972 : : "Select the impulse initiation type, e.g., for a box IC"; }
2973 : : static std::string longDescription() { return
2974 : : R"(This keyword can be used to select the 'impulse' initiation/assignment
2975 : : type for box initial conditions. It simply assigns the prescribed values to
2976 : : mesh points within a configured box at t=0.)"; }
2977 : : };
2978 : : using impulse = keyword< impulse_info, TAOCPP_PEGTL_STRING("impulse") >;
2979 : :
2980 : : struct linear_info {
2981 : : static std::string name() { return "linear"; }
2982 : : static std::string shortDescription() { return
2983 : : "Select the linear initiation type, e.g., for a box IC"; }
2984 : : static std::string longDescription() { return
2985 : : R"(This keyword can be used to select the 'linear' initiation/assignment
2986 : : type for box initial conditions. Linear initiation uses a linear function
2987 : : in time and space, configured with an initiation point in space, an initial
2988 : : radius around the point, and a constant velocity that grows a sphere in time
2989 : : (and space) linearly and assigns values to mesh points falling within a
2990 : : growing sphere within a configured box.)"; }
2991 : : };
2992 : : using linear = keyword< linear_info, TAOCPP_PEGTL_STRING("linear") >;
2993 : :
2994 : : struct initiate_info {
2995 : : static std::string name() { return "initiate type"; }
2996 : : static std::string shortDescription() { return "Initiation/assignemt type"; }
2997 : : static std::string longDescription() { return
2998 : : R"(This keyword is used to select an initiation type to configure how
2999 : : values are assigned, e.g., for a box initial condition. This can be used to
3000 : : specify, how the values are assigned to mesh nodes within a box. Examples:
3001 : : (1) impulse: assign the full values at t=0 for all points in a box,
3002 : : (2) linear: use a linear function in time and space, configured with an
3003 : : initiation point in space, an initial radius around the point, and a
3004 : : velocity that grows a sphere in time (and space) linearly and assigns values
3005 : : to mesh points falling within a growing sphere within a configured box.)"; }
3006 : : struct expect {
3007 : : static std::string description() { return "string"; }
3008 : : static std::string choices() {
3009 : : return '\'' + impulse::string() + "\' | \'"
3010 : : + linear::string() + '\'';
3011 : : }
3012 : : };
3013 : : };
3014 : : using initiate = keyword< initiate_info, TAOCPP_PEGTL_STRING("initiate") >;
3015 : :
3016 : : struct box_info {
3017 : : static std::string name() { return "box"; }
3018 : : static std::string shortDescription() { return
3019 : : R"(Introduce a box ... end block used to assign initial conditions)"; }
3020 : : static std::string longDescription() { return
3021 : : R"(This keyword is used to introduce a box ... end block used to assign
3022 : : initial conditions within a box given by spatial coordinates. Example:
3023 : : box x- 0.5 x+ 1.5 y- -0.5 y+ 0.5 z- -0.5 z+ 0.5 density 1.2 end pressure
3024 : : 1.4 end end", which specifies a box with extends within which the density
3025 : : will be set to 1.2 and the pressure to be 1.4. Besides the box dimensions,
3026 : : the following physics keywords are allowed in a box ... end block:)"
3027 : : + std::string("\'")
3028 : : + materialid::string()+ "\', \'"
3029 : : + mass::string()+ "\', \'"
3030 : : + density::string()+ "\', \'"
3031 : : + velocity::string() + "\', \'"
3032 : : + energy::string() + "\', \'"
3033 : : + energy_content::string() + "\', \'"
3034 : : + temperature::string() + "\', \'"
3035 : : + pressure::string() + "\'."; }
3036 : : };
3037 : : using box = keyword< box_info, TAOCPP_PEGTL_STRING("box") >;
3038 : :
3039 : : struct ic_info {
3040 : : static std::string name() { return "ic"; }
3041 : : static std::string shortDescription() { return
3042 : : R"(Introduce an ic...end block used to configure initial conditions)"; }
3043 : : static std::string longDescription() { return
3044 : : R"(This keyword is used to introduce an ic...end block used to set initial
3045 : : conditions. Keywords allowed in a ic ... end block: )" + std::string("\'")
3046 : : + materialid::string()+ "\', \'"
3047 : : + mass::string()+ "\', \'"
3048 : : + density::string()+ "\', \'"
3049 : : + velocity::string() + "\', \'"
3050 : : + pressure::string() + "\', \'"
3051 : : + energy::string() + "\', \'"
3052 : : + temperature::string() + "\', \'"
3053 : : + box::string() + "\'.";
3054 : : }
3055 : : };
3056 : : using ic = keyword< ic_info, TAOCPP_PEGTL_STRING("ic") >;
3057 : :
3058 : : struct depvar_info {
3059 : : static std::string name() { return "depvar"; }
3060 : 655 : static std::string shortDescription() { return
3061 [ + - ]: 1310 : "Select dependent variable (in a relevant block)"; }
3062 : 655 : static std::string longDescription() { return
3063 [ + - ]: 1310 : R"(Dependent variable, e.g, in differential equations.)"; }
3064 : : struct expect {
3065 : : using type = char;
3066 [ + - ]: 1310 : static std::string description() { return "character"; }
3067 : : };
3068 : : };
3069 : : using depvar = keyword< depvar_info, TAOCPP_PEGTL_STRING("depvar") >;
3070 : :
3071 : : struct sde_rho2_info {
3072 : : static std::string name() { return "rho2"; }
3073 : 655 : static std::string shortDescription() { return
3074 [ + - ]: 1310 : R"(Set SDE parameter(s) rho2)"; }
3075 : 655 : static std::string longDescription() { return
3076 [ + - ]: 1310 : R"(This keyword is used to specify a vector of real numbers used to
3077 : : parameterize a system of stochastic differential equations. Example:
3078 : : "rho2 5.0 2.0 3.0 end". The length of the vector depends on the particular
3079 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
3080 : : struct expect {
3081 : : using type = tk::real;
3082 [ + - ]: 1310 : static std::string description() { return "real(s)"; }
3083 : : };
3084 : : };
3085 : : using sde_rho2 = keyword< sde_rho2_info, TAOCPP_PEGTL_STRING("rho2") >;
3086 : :
3087 : : struct sde_rho_info {
3088 : : static std::string name() { return "rho"; }
3089 : 655 : static std::string shortDescription() { return
3090 [ + - ]: 1310 : R"(Set SDE parameter(s) rho)"; }
3091 : 655 : static std::string longDescription() { return
3092 [ + - ]: 1310 : R"(This keyword is used to specify a vector of real numbers used to
3093 : : parameterize a system of stochastic differential equations. Example:
3094 : : "rho 5.0 2.0 3.0 end". The length of the vector depends on the particular
3095 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
3096 : : struct expect {
3097 : : using type = tk::real;
3098 [ + - ]: 1310 : static std::string description() { return "real(s)"; }
3099 : : };
3100 : : };
3101 : : using sde_rho = keyword< sde_rho_info, TAOCPP_PEGTL_STRING("rho") >;
3102 : :
3103 : : struct mean_gradient_info {
3104 : : static std::string name() { return "Prescribed mean gradient"; }
3105 : 655 : static std::string shortDescription() { return
3106 [ + - ]: 1310 : R"(Set prescribed mean gradient)"; }
3107 : 655 : static std::string longDescription() { return
3108 [ + - ]: 1310 : R"(This keyword is used to specify a vector of real numbers used to
3109 : : parameterize a system of stochastic differential equations. Example:
3110 : : "mean_gradient 1.0 1.0 0.0 end". One use of a mean gradient vector is to
3111 : : specify a prescribed mean scalar gradient in 3 spatial directions for a
3112 : : scalar transprot equation.)"; }
3113 : : struct expect {
3114 : : using type = tk::real;
3115 [ + - ]: 1310 : static std::string description() { return "real(s)"; }
3116 : : };
3117 : : };
3118 : : using mean_gradient = keyword< mean_gradient_info,
3119 : : TAOCPP_PEGTL_STRING("mean_gradient") >;
3120 : :
3121 : : struct sde_rcomma_info {
3122 : : static std::string name() { return "rcomma"; }
3123 : 655 : static std::string shortDescription() { return
3124 [ + - ]: 1310 : R"(Set SDE parameter(s) rcomma)"; }
3125 : 655 : static std::string longDescription() { return
3126 [ + - ]: 1310 : R"(This keyword is used to specify a vector of real numbers used to
3127 : : parameterize a system of stochastic differential equations. Example:
3128 : : "rcomma 5.0 2.0 3.0 end". The length of the vector depends on the particular
3129 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
3130 : : struct expect {
3131 : : using type = tk::real;
3132 [ + - ]: 1310 : static std::string description() { return "real(s)"; }
3133 : : };
3134 : : };
3135 : : using sde_rcomma = keyword< sde_rcomma_info, TAOCPP_PEGTL_STRING("rcomma") >;
3136 : :
3137 : : struct sde_r_info {
3138 : : static std::string name() { return "r"; }
3139 : 655 : static std::string shortDescription() { return
3140 [ + - ]: 1310 : R"(Set SDE parameter(s) r)"; }
3141 : 655 : static std::string longDescription() { return
3142 [ + - ]: 1310 : R"(This keyword is used to specify a vector of real numbers used to
3143 : : parameterize a system of stochastic differential equations. Example:
3144 : : "r 5.0 2.0 3.0 end". The length of the vector depends on the particular
3145 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
3146 : : struct expect {
3147 : : using type = tk::real;
3148 [ + - ]: 1310 : static std::string description() { return "real(s)"; }
3149 : : };
3150 : : };
3151 : : using sde_r = keyword< sde_r_info, TAOCPP_PEGTL_STRING("r") >;
3152 : :
3153 : : struct dirichlet_info {
3154 [ + - ]: 39108 : static std::string name() { return "Dirichlet"; }
3155 : 655 : static std::string shortDescription() { return
3156 [ + - ]: 1310 : "Start configuration block for the Dirichlet SDE"; }
3157 : 655 : static std::string longDescription() { return
3158 : : R"(This keyword is used to introduce a dirichlet ... end block, used to
3159 : : specify the configuration of a system of stochastic differential
3160 : : equations (SDEs), whose invariant is the Dirichlet distribution. For more
3161 : : details on the Dirichlet SDE, see https://doi.org/10.1155/2013/842981.
3162 [ + - ][ + - ]: 1310 : Keywords allowed in a dirichlet ... end block: )" + std::string("\'")
3163 [ + - ][ + - ]: 2620 : + depvar::string()+ "\', \'"
[ + - ]
3164 [ + - ][ + - ]: 2620 : + ncomp::string() + "\', \'"
[ + - ]
3165 [ + - ][ + - ]: 2620 : + rng::string() + "\', \'"
[ + - ]
3166 [ + - ][ + - ]: 2620 : + init::string() + "\', \'"
[ + - ]
3167 [ + - ][ + - ]: 2620 : + coeff::string() + "\', \'"
[ + - ]
3168 [ + - ][ + - ]: 2620 : + sde_b::string() + "\', \'"
[ + - ]
3169 [ + - ][ + - ]: 2620 : + sde_S::string() + "\', \'"
[ + - ]
3170 [ + - ][ + - ]: 2620 : + sde_kappa::string() + "\'. "
3171 [ + - ]: 1310 : + R"(For an example dirichlet ... end block, see
3172 : : doc/html/walker_example_dirichlet.html.)";
3173 : : }
3174 : : };
3175 : : using dirichlet = keyword< dirichlet_info, TAOCPP_PEGTL_STRING("dirichlet") >;
3176 : :
3177 : : struct mixdirichlet_info {
3178 [ + - ]: 39108 : static std::string name() { return "MixDirichlet"; }
3179 : 655 : static std::string shortDescription() { return
3180 [ + - ]: 1310 : "Start configuration block for the Mixture Dirichlet SDE"; }
3181 : 655 : static std::string longDescription() { return
3182 : : R"(This keyword is used to introduce a mixdirichlet ... end block, used to
3183 : : specify the configuration of a system of stochastic differential
3184 : : equations (SDEs), whose invariant is the Dirichlet distribution constrained
3185 : : to model multi-material mixing in turbulent flows. For more
3186 : : details on the Dirichlet SDE, see https://doi.org/10.1155/2013/842981.
3187 [ + - ][ + - ]: 1310 : Keywords allowed in a mixdirichlet ... end block: )" + std::string("\'")
3188 [ + - ][ + - ]: 2620 : + depvar::string()+ "\', \'"
[ + - ]
3189 [ + - ][ + - ]: 2620 : + ncomp::string() + "\', \'"
[ + - ]
3190 [ + - ][ + - ]: 2620 : + rng::string() + "\', \'"
[ + - ]
3191 [ + - ][ + - ]: 2620 : + init::string() + "\', \'"
[ + - ]
3192 [ + - ][ + - ]: 2620 : + coeff::string() + "\', \'"
[ + - ]
3193 [ + - ][ + - ]: 2620 : + sde_b::string() + "\', \'"
[ + - ]
3194 [ + - ][ + - ]: 2620 : + sde_S::string() + "\', \'"
[ + - ]
3195 [ + - ][ + - ]: 2620 : + sde_kappa::string() + "\', \'"
[ + - ]
3196 [ + - ][ + - ]: 2620 : + sde_rho2::string() + "\', \'"
[ + - ]
3197 [ + - ][ + - ]: 2620 : + sde_r::string() + "\'. "
3198 [ + - ]: 1310 : + R"(For an example mixdirichlet ... end block, see
3199 : : doc/html/walker_example_mixdirichlet.html.)";
3200 : : }
3201 : : };
3202 : : using mixdirichlet =
3203 : : keyword< mixdirichlet_info, TAOCPP_PEGTL_STRING("mixdirichlet") >;
3204 : :
3205 : : struct gendir_info {
3206 [ + - ]: 39108 : static std::string name() { return "Generalized Dirichlet"; }
3207 : 655 : static std::string shortDescription() { return
3208 [ + - ]: 1310 : "Start configuration block for the generalized Dirichlet SDE"; }
3209 : 655 : static std::string longDescription() { return
3210 : : R"(This keyword is used to introduce a gendir ... end
3211 : : block, used to specify the configuration of a system of stochastic
3212 : : differential equations (SDEs), whose invariant is Lochner's generalized
3213 : : Dirichlet distribution. For more details on the generalized Dirichlet
3214 : : SDE, see https://doi.org/10.1063/1.4822416. Keywords allowed in a gendir
3215 [ + - ][ + - ]: 1310 : ... end block: )" + std::string("\'")
3216 [ + - ][ + - ]: 2620 : + depvar::string()+ "\', \'"
[ + - ]
3217 [ + - ][ + - ]: 2620 : + ncomp::string() + "\', \'"
[ + - ]
3218 [ + - ][ + - ]: 2620 : + rng::string() + "\', \'"
[ + - ]
3219 [ + - ][ + - ]: 2620 : + init::string() + "\', \'"
[ + - ]
3220 [ + - ][ + - ]: 2620 : + coeff::string() + "\', \'"
[ + - ]
3221 [ + - ][ + - ]: 2620 : + sde_b::string() + "\', \'"
[ + - ]
3222 [ + - ][ + - ]: 2620 : + sde_S::string() + "\', \'"
[ + - ]
3223 [ + - ][ + - ]: 2620 : + sde_c::string() + "\', \'"
[ + - ]
3224 [ + - ][ + - ]: 2620 : + sde_kappa::string() + "\'. "
3225 [ + - ]: 1310 : + R"(For an example gendir... end block, see
3226 : : doc/html/walker_example_gendir.html.)";
3227 : : }
3228 : : };
3229 : : using gendir = keyword< gendir_info, TAOCPP_PEGTL_STRING("gendir") >;
3230 : :
3231 : : struct wrightfisher_info {
3232 [ + - ]: 39108 : static std::string name() { return "Wright-Fisher"; }
3233 : 655 : static std::string shortDescription() { return
3234 [ + - ]: 1310 : "Start configuration block for the Wright-Fisher SDE"; }
3235 : 655 : static std::string longDescription() { return
3236 : : R"(This keyword is used to introduce a wright_fisher ... end block, used
3237 : : to specify the configuration of a system of stochastic differential
3238 : : equations (SDEs), whose invariant is the Dirichlet distribution. For more
3239 : : details on the Wright-Fisher SDE, see
3240 : : http://www.sciencedirect.com/science/article/pii/S0040580912001013.
3241 [ + - ][ + - ]: 1310 : Keywords allowed in a wright-fisher... end block: )" + std::string("\'")
3242 [ + - ][ + - ]: 2620 : + depvar::string()+ "\', \'"
[ + - ]
3243 [ + - ][ + - ]: 2620 : + ncomp::string() + "\', \'"
[ + - ]
3244 [ + - ][ + - ]: 2620 : + rng::string() + "\', \'"
[ + - ]
3245 [ + - ][ + - ]: 2620 : + init::string() + "\', \'"
[ + - ]
3246 [ + - ][ + - ]: 2620 : + coeff::string() + "\', \'"
[ + - ]
3247 [ + - ][ + - ]: 2620 : + sde_omega::string() + "\'. "
3248 [ + - ]: 1310 : + R"(For an example wright-fisher ... end block, see
3249 : : doc/html/walker_example_wf.html.)";
3250 : : }
3251 : : };
3252 : : using wrightfisher =
3253 : : keyword< wrightfisher_info, TAOCPP_PEGTL_STRING("wright-fisher") >;
3254 : :
3255 : : struct skewnormal_info {
3256 [ + - ]: 39108 : static std::string name() { return "Skew-Normal"; }
3257 : 655 : static std::string shortDescription() { return
3258 [ + - ]: 1310 : "Start configuration block for the Skew-normal SDE"; }
3259 : 655 : static std::string longDescription() { return
3260 : : R"(This keyword is used to introduce a skew-normal ... end block, used
3261 : : to specify the configuration of a system of stochastic differential
3262 : : equations (SDEs), whose invariant is the joint skew-normal distribution.
3263 : : For more details on the skew-normal distribution, see
3264 : : http://www.jstor.org/stable/2337278. Keywords allowed in an skew-normal ...
3265 [ + - ][ + - ]: 1310 : end block: )" + std::string("\'")
3266 [ + - ][ + - ]: 2620 : + depvar::string()+ "\', \'"
[ + - ]
3267 [ + - ][ + - ]: 2620 : + ncomp::string() + "\', \'"
[ + - ]
3268 [ + - ][ + - ]: 2620 : + rng::string() + "\', \'"
[ + - ]
3269 [ + - ][ + - ]: 2620 : + init::string() + "\', \'"
[ + - ]
3270 [ + - ][ + - ]: 2620 : + coeff::string() + "\', \'"
[ + - ]
3271 [ + - ][ + - ]: 2620 : + sde_sigmasq::string() + "\', \'"
[ + - ]
3272 [ + - ][ + - ]: 2620 : + sde_T::string() + "\', \'"
[ + - ]
3273 [ + - ][ + - ]: 2620 : + sde_lambda::string() + "\'. "
3274 [ + - ]: 1310 : + R"(For an example skew-normal... end block, see
3275 : : doc/html/walker_example_skewnormal.html.)";
3276 : : }
3277 : : };
3278 : : using skewnormal = keyword< skewnormal_info, TAOCPP_PEGTL_STRING("skew-normal") >;
3279 : :
3280 : : struct beta_info {
3281 [ + - ]: 39108 : static std::string name() { return "Beta"; }
3282 : 655 : static std::string shortDescription() { return
3283 [ + - ]: 1310 : "Introduce the beta SDE input block"; }
3284 : 655 : static std::string longDescription() { return
3285 : : R"(This keyword is used to introduce a beta ... end block, used to specify
3286 : : the configuration of a system of stochastic differential equations (SDEs),
3287 : : with linear drift and quadratic diagonal diffusion, whose invariant is the
3288 : : joint beta distribution. For more details on the beta SDE, see
3289 : : https://doi.org/10.1080/14685248.2010.510843 and src/DiffEq/Beta/Beta.hpp.
3290 [ + - ][ + - ]: 1310 : Keywords allowed in a beta ... end block: )" + std::string("\'")
3291 [ + - ][ + - ]: 2620 : + depvar::string()+ "\', \'"
[ + - ]
3292 [ + - ][ + - ]: 2620 : + ncomp::string() + "\', \'"
[ + - ]
3293 [ + - ][ + - ]: 2620 : + rng::string() + "\', \'"
[ + - ]
3294 [ + - ][ + - ]: 2620 : + init::string() + "\', \'"
[ + - ]
3295 [ + - ][ + - ]: 2620 : + coeff::string() + "\', \'"
[ + - ]
3296 [ + - ][ + - ]: 2620 : + sde_b::string() + "\', \'"
[ + - ]
3297 [ + - ][ + - ]: 2620 : + sde_S::string() + "\', \'"
[ + - ]
3298 [ + - ][ + - ]: 2620 : + sde_kappa::string() + "\'. "
3299 [ + - ]: 1310 : + R"(For an example beta ... end block, see
3300 : : doc/html/walker_example_beta.html.)";
3301 : : }
3302 : : };
3303 : : using beta = keyword< beta_info, TAOCPP_PEGTL_STRING("beta") >;
3304 : :
3305 : : struct numfracbeta_info {
3306 [ + - ]: 39108 : static std::string name() { return "Number-fraction beta"; }
3307 : 655 : static std::string shortDescription() { return
3308 [ + - ]: 1310 : "Introduce the numfracbeta SDE input block"; }
3309 : 655 : static std::string longDescription() { return
3310 : : R"(This keyword is used to introduce a numfracbeta ... end block, used to
3311 : : specify the configuration of a system of number-fraction beta SDEs, a system
3312 : : of stochastic differential equations (SDEs), in which, in addition to the
3313 : : dependent variable, computed with linear drift and quadratic diagonal
3314 : : diffusion (whose invariant is joint beta), two additional variables are
3315 : : computed. In other words, this is a beta SDE but there are two additional
3316 : : stochastic variables computed based on the beta SDE. If X is governed by the
3317 : : beta SDE, then the number-fraction beta SDE additionally governs rho(X) and
3318 : : V(X), where both rho and V are random variables, computed by rho(X) = rho2
3319 : : ( 1 - r' X ), and V(X) = 1 / [ rho2 ( 1 - r'X ) ]. For more details on the
3320 : : beta SDE, see https://doi.org/10.1080/14685248.2010.510843 and
3321 : : src/DiffEq/Beta/Beta.hpp. Keywords allowed in a numfracbeta ... end block: )"
3322 [ + - ][ + - ]: 1310 : + std::string("\'")
3323 [ + - ][ + - ]: 2620 : + depvar::string()+ "\', \'"
[ + - ]
3324 [ + - ][ + - ]: 2620 : + ncomp::string() + "\', \'"
[ + - ]
3325 [ + - ][ + - ]: 2620 : + rng::string() + "\', \'"
[ + - ]
3326 [ + - ][ + - ]: 2620 : + init::string() + "\', \'"
[ + - ]
3327 [ + - ][ + - ]: 2620 : + coeff::string() + "\', \'"
[ + - ]
3328 [ + - ][ + - ]: 2620 : + sde_b::string() + "\', \'"
[ + - ]
3329 [ + - ][ + - ]: 2620 : + sde_S::string() + "\', \'"
[ + - ]
3330 [ + - ][ + - ]: 2620 : + sde_kappa::string() + "\', \'"
[ + - ]
3331 [ + - ][ + - ]: 2620 : + sde_rho2::string() + "\', \'"
[ + - ]
3332 [ + - ][ + - ]: 2620 : + sde_rcomma::string() + "\'. "
3333 [ + - ]: 1310 : + R"(For an example numfracbeta ... end block, see
3334 : : doc/html/walker_example_numfracbeta.html.)";
3335 : : }
3336 : : };
3337 : : using numfracbeta = keyword< numfracbeta_info, TAOCPP_PEGTL_STRING("numfracbeta") >;
3338 : :
3339 : : struct massfracbeta_info {
3340 [ + - ]: 39108 : static std::string name() { return "Mass-fraction beta"; }
3341 : 655 : static std::string shortDescription() { return
3342 [ + - ]: 1310 : "Introduce the massfracbeta SDE input block"; }
3343 : 655 : static std::string longDescription() { return
3344 : : R"(This keyword is used to introduce a massfracbeta ... end block, used to
3345 : : specify the configuration of a system of number-fraction beta SDEs, a system
3346 : : of stochastic differential equations (SDEs), in which, in addition to the
3347 : : dependent variable, computed with linear drift and quadratic diagonal
3348 : : diffusion (whose invariant is joint beta), two additional variables are
3349 : : computed. In other words, this is a beta SDE but there are two additional
3350 : : stochastic variables computed based on the beta SDE. If Y is governed by the
3351 : : beta SDE, then the mass-fraction beta SDE additionally governs rho(Y) and
3352 : : V(Y), where both rho and V are random variables, computed by rho(Y) = rho2 /
3353 : : ( 1 + r Y ), and V(Y) = ( 1 + r Y ) / rho2. For more details on the beta
3354 : : SDE, see
3355 : : https://doi.org/10.1080/14685248.2010.510843 and src/DiffEq/Beta/Beta.hpp.
3356 : : Keywords allowed in a massfracbeta ... end block: )"
3357 [ + - ][ + - ]: 1310 : + std::string("\'")
3358 [ + - ][ + - ]: 2620 : + depvar::string()+ "\', \'"
[ + - ]
3359 [ + - ][ + - ]: 2620 : + ncomp::string() + "\', \'"
[ + - ]
3360 [ + - ][ + - ]: 2620 : + rng::string() + "\', \'"
[ + - ]
3361 [ + - ][ + - ]: 2620 : + init::string() + "\', \'"
[ + - ]
3362 [ + - ][ + - ]: 2620 : + coeff::string() + "\', \'"
[ + - ]
3363 [ + - ][ + - ]: 2620 : + sde_b::string() + "\', \'"
[ + - ]
3364 [ + - ][ + - ]: 2620 : + sde_S::string() + "\', \'"
[ + - ]
3365 [ + - ][ + - ]: 2620 : + sde_kappa::string() + "\', \'"
[ + - ]
3366 [ + - ][ + - ]: 2620 : + sde_rho2::string() + "\', \'"
[ + - ]
3367 [ + - ][ + - ]: 2620 : + sde_r::string() + "\'. "
3368 [ + - ]: 1310 : + R"(For an example massfracbeta ... end block, see
3369 : : doc/html/walker_example_massfracbeta.html.)";
3370 : : }
3371 : : };
3372 : : using massfracbeta = keyword< massfracbeta_info, TAOCPP_PEGTL_STRING("massfracbeta") >;
3373 : :
3374 : : struct mixnumfracbeta_info {
3375 [ + - ]: 39108 : static std::string name() { return "Mix number-fraction beta"; }
3376 : 655 : static std::string shortDescription() { return
3377 [ + - ]: 1310 : "Introduce the mixnumfracbeta SDE input block"; }
3378 : 655 : static std::string longDescription() { return
3379 : : R"(This keyword is used to introduce a mixnumfracbeta ... end block, used
3380 : : to specify the configuration of a system of mix number-fraction beta SDEs, a
3381 : : system of stochastic differential equations (SDEs), whose solution is the
3382 : : joint beta distribution and in which the usual beta SDE parameters b and
3383 : : kappa are specified via functions that constrain the beta SDE to be
3384 : : consistent with the turbulent mixing process. The mix number-fraction beta
3385 : : SDE is similar to the number-fraction beta SDE, only the process is made
3386 : : consistent with the no-mix and fully mixed limits via the specification of
3387 : : the SDE coefficients b and kappa. As in the number-fraction beta SDE, X is
3388 : : governed by the beta SDE and two additional stochastic variables are
3389 : : computed. However, in the mix number-fraction beta SDE the parameters b and
3390 : : kappa are given by b = Theta * b' and kappa = kappa' * <x^2>, where Theta =
3391 : : 1 - <x^2> / [ <X> ( 1 - <X> ], the fluctuation about the mean, <X>, is
3392 : : defined as usual: x = X - <X>, and b' and kappa' are user-specified
3393 : : constants. Similar to the number-fraction beta SDE, there two additional
3394 : : random variables computed besides, X, and they are rho(X) and V(X). For more
3395 : : detail on the number-fraction beta SDE, see the help on keyword
3396 : : 'numfracbeta'. For more details on the beta SDE, see
3397 : : https://doi.org/10.1080/14685248.2010.510843 and src/DiffEq/Beta/Beta.h.
3398 : : Keywords allowed in a mixnumfracbeta ... end block: )"
3399 [ + - ][ + - ]: 1310 : + std::string("\'")
3400 [ + - ][ + - ]: 2620 : + depvar::string()+ "\', \'"
[ + - ]
3401 [ + - ][ + - ]: 2620 : + ncomp::string() + "\', \'"
[ + - ]
3402 [ + - ][ + - ]: 2620 : + rng::string() + "\', \'"
[ + - ]
3403 [ + - ][ + - ]: 2620 : + init::string() + "\', \'"
[ + - ]
3404 [ + - ][ + - ]: 2620 : + coeff::string() + "\', \'"
[ + - ]
3405 [ + - ][ + - ]: 2620 : + sde_bprime::string() + "\', \'"
[ + - ]
3406 [ + - ][ + - ]: 2620 : + sde_S::string() + "\', \'"
[ + - ]
3407 [ + - ][ + - ]: 2620 : + sde_kappaprime::string() + "\', \'"
[ + - ]
3408 [ + - ][ + - ]: 2620 : + sde_rho2::string() + "\', \'"
[ + - ]
3409 [ + - ][ + - ]: 2620 : + sde_rcomma::string() + "\'. "
3410 [ + - ]: 1310 : + R"(For an example mixnumfracbeta ... end block, see
3411 : : doc/html/walker_example_mixnumfracbeta.html.)";
3412 : : }
3413 : : };
3414 : : using mixnumfracbeta =
3415 : : keyword< mixnumfracbeta_info, TAOCPP_PEGTL_STRING("mixnumfracbeta") >;
3416 : :
3417 : : struct eq_A005H_info {
3418 [ + - ]: 62 : static std::string name() { return "eq_A005H"; }
3419 : 655 : static std::string shortDescription() { return "Select inverse equilibrium "
3420 [ + - ]: 1310 : "hydro time scale from DNS of HRT, A=0.05, IC:light<<heavy"; }
3421 : 655 : static std::string longDescription() { return
3422 [ + - ]: 1310 : R"(Inverse equilibrium hydrodynamics time scale from DNS of homogeneous
3423 : : Rayleigh-Taylor instability, tau_eq, A = 0.05, IC: light << heavy.)"; }
3424 : : };
3425 : : using eq_A005H = keyword< eq_A005H_info, TAOCPP_PEGTL_STRING("eq_A005H") >;
3426 : :
3427 : : struct eq_A005S_info {
3428 [ + - ]: 62 : static std::string name() { return "eq_A005S"; }
3429 : 655 : static std::string shortDescription() { return "Select inverse equilibrium "
3430 [ + - ]: 1310 : "hydro time scale from DNS of HRT, A=0.05, IC:light=heavy"; }
3431 : 655 : static std::string longDescription() { return
3432 [ + - ]: 1310 : R"(Inverse equilibrium hydrodynamics time scale from DNS of homogeneous
3433 : : Rayleigh-Taylor instability, tau_eq, A = 0.05, IC: light = heavy.)"; }
3434 : : };
3435 : : using eq_A005S = keyword< eq_A005S_info, TAOCPP_PEGTL_STRING("eq_A005S") >;
3436 : :
3437 : : struct eq_A005L_info {
3438 [ + - ]: 62 : static std::string name() { return "eq_A005L"; }
3439 : 655 : static std::string shortDescription() { return "Select inverse equilibrium "
3440 [ + - ]: 1310 : "hydro time scale from DNS of HRT, A=0.05, IC:light>>heavy"; }
3441 : 655 : static std::string longDescription() { return
3442 [ + - ]: 1310 : R"(Inverse equilibrium hydrodynamics time scale from DNS of homogeneous
3443 : : Rayleigh-Taylor instability, tau_eq, A = 0.05, IC: light >> heavy.)"; }
3444 : : };
3445 : : using eq_A005L = keyword< eq_A005L_info, TAOCPP_PEGTL_STRING("eq_A005L") >;
3446 : :
3447 : : struct eq_A05H_info {
3448 [ + - ]: 62 : static std::string name() { return "eq_A05H"; }
3449 : 655 : static std::string shortDescription() { return "Select inverse equilibrium "
3450 [ + - ]: 1310 : "hydro time scale from DNS of HRT, A=0.5, IC:light<<heavy"; }
3451 : 655 : static std::string longDescription() { return
3452 [ + - ]: 1310 : R"(Inverse equilibrium hydrodynamics time scale from DNS of homogeneous
3453 : : Rayleigh-Taylor instability, tau_eq, A = 0.5, IC: light << heavy.)"; }
3454 : : };
3455 : : using eq_A05H = keyword< eq_A05H_info, TAOCPP_PEGTL_STRING("eq_A05H") >;
3456 : :
3457 : : struct eq_A05S_info {
3458 [ + - ]: 62 : static std::string name() { return "eq_A05S"; }
3459 : 655 : static std::string shortDescription() { return "Select inverse equilibrium "
3460 [ + - ]: 1310 : "hydro time scale from DNS of HRT, A=0.5, IC:light=heavy"; }
3461 : 655 : static std::string longDescription() { return
3462 [ + - ]: 1310 : R"(Inverse equilibrium hydrodynamics time scale from DNS of homogeneous
3463 : : Rayleigh-Taylor instability, tau_eq, A = 0.5, IC: light = heavy.)"; }
3464 : : };
3465 : : using eq_A05S = keyword< eq_A05S_info, TAOCPP_PEGTL_STRING("eq_A05S") >;
3466 : :
3467 : : struct eq_A05L_info {
3468 [ + - ]: 62 : static std::string name() { return "eq_A05L"; }
3469 : 655 : static std::string shortDescription() { return "Select inverse equilibrium "
3470 [ + - ]: 1310 : "hydro time scale from DNS of HRT, A=0.5, IC:light>>heavy"; }
3471 : 655 : static std::string longDescription() { return
3472 [ + - ]: 1310 : R"(Inverse equilibrium hydrodynamics time scale from DNS of homogeneous
3473 : : Rayleigh-Taylor instability, tau_eq, A = 0.5, IC: light >> heavy.)"; }
3474 : : };
3475 : : using eq_A05L = keyword< eq_A05L_info, TAOCPP_PEGTL_STRING("eq_A05L") >;
3476 : :
3477 : : struct eq_A075H_info {
3478 [ + - ]: 62 : static std::string name() { return "eq_A075H"; }
3479 : 655 : static std::string shortDescription() { return "Select inverse equilibrium "
3480 [ + - ]: 1310 : "hydro time scale from DNS of HRT, A=0.75, IC:light<<heavy"; }
3481 : 655 : static std::string longDescription() { return
3482 [ + - ]: 1310 : R"(Inverse equilibrium hydrodynamics time scale from DNS of homogeneous
3483 : : Rayleigh-Taylor instability, tau_eq, A = 0.75, IC: light << heavy.)"; }
3484 : : };
3485 : : using eq_A075H = keyword< eq_A075H_info, TAOCPP_PEGTL_STRING("eq_A075H") >;
3486 : :
3487 : : struct eq_A075S_info {
3488 [ + - ]: 62 : static std::string name() { return "eq_A075S"; }
3489 : 655 : static std::string shortDescription() { return "Select inverse equilibrium "
3490 [ + - ]: 1310 : "hydro time scale from DNS of HRT, A=0.75, IC:light=heavy"; }
3491 : 655 : static std::string longDescription() { return
3492 [ + - ]: 1310 : R"(Inverse equilibrium hydrodynamics time scale from DNS of homogeneous
3493 : : Rayleigh-Taylor instability, tau_eq, A = 0.75, IC: light = heavy.)"; }
3494 : : };
3495 : : using eq_A075S = keyword< eq_A075S_info, TAOCPP_PEGTL_STRING("eq_A075S") >;
3496 : :
3497 : : struct eq_A075L_info {
3498 [ + - ]: 62 : static std::string name() { return "eq_A075L"; }
3499 : 655 : static std::string shortDescription() { return "Select inverse equilibrium "
3500 [ + - ]: 1310 : "hydro time scale from DNS of HRT, A=0.75, IC:light>>heavy"; }
3501 : 655 : static std::string longDescription() { return
3502 [ + - ]: 1310 : R"(Inverse equilibrium hydrodynamics time scale from DNS of homogeneous
3503 : : Rayleigh-Taylor instability, tau_eq, A = 0.75, IC: light >> heavy.)"; }
3504 : : };
3505 : : using eq_A075L = keyword< eq_A075L_info, TAOCPP_PEGTL_STRING("eq_A075L") >;
3506 : :
3507 : : struct hydrotimescales_info {
3508 : : static std::string name() { return "hydrotimescales"; }
3509 : 655 : static std::string shortDescription() { return
3510 [ + - ]: 1310 : R"(Set MixMassFractionBeta SDE parameter(s) hydrotimescales)"; }
3511 : 655 : static std::string longDescription() { return
3512 : : R"(This keyword is used to specify a vector of strings used to parameterize
3513 : : the system of stochastic differential equations, configured in a
3514 : : mixmassfracbeta ... end block. Within the mixmassfracbeta ... end block the
3515 : : coefficients policy must be set to 'hydrotimescale' in order for the
3516 : : hydrotimescales ... end block to be in effect. The 'hydrotimescales'
3517 : : keyword is then used to specify a list of strings, each specifying which
3518 : : inverse time scale should be used for the particular component integrated.
3519 : : Available time scales are defined in src/DiffEq/HydroTimescales.hpp.
3520 : : Example: "hydrotimescales eq_A05S eq_A05H eq_A05L eq_A05S eq_A05S end",
3521 : : which configures five inverse hydrodynamics time scales associated to 5
3522 : : components, i.e., 5 scalar stochastic differential equations, integrated,
3523 : : specified and configured within the given mixmassfracbeta ... end block. The
3524 : : length of the hydrotimescales vector depends on the number of scalar
3525 : : components and is controlled by the preceding keyword 'ncomp'. For
3526 : : mixmassfracbeta, ncomp is the actual number of scalar components * 4, since
3527 : : mixmassfractionbeta always computes 4 additional derived stochastic
3528 : : variables (in a diagnostic) fashion. See also MixMassFractionBeta::derived()
3529 : : in src/DiffEq/Beta/MixMassFractionBeta.hpp. Keywords allowed in a
3530 [ + - ][ + - ]: 1310 : hydrotimescales ... end block: )" + std::string("\'")
3531 [ + - ][ + - ]: 2620 : + eq_A005H::string() + "\', \'"
[ + - ]
3532 [ + - ][ + - ]: 2620 : + eq_A005S::string() + "\', \'"
[ + - ]
3533 [ + - ][ + - ]: 2620 : + eq_A005L::string() + "\', \'"
[ + - ]
3534 [ + - ][ + - ]: 2620 : + eq_A05H::string() + "\', \'"
[ + - ]
3535 [ + - ][ + - ]: 2620 : + eq_A05S::string() + "\', \'"
[ + - ]
3536 [ + - ][ + - ]: 2620 : + eq_A05L::string() + "\', \'"
[ + - ]
3537 [ + - ][ + - ]: 2620 : + eq_A075H::string() + "\', \'"
[ + - ]
3538 [ + - ][ + - ]: 2620 : + eq_A075S::string() + "\', \'"
[ + - ]
3539 [ + - ][ + - ]: 2620 : + eq_A075L::string() + "\'. "
3540 [ + - ]: 1310 : + R"(For an example hydrotimescales ... end block, see
3541 : : doc/html/walker_example_mixmassfracbeta.html.)"; }
3542 : : struct expect {
3543 : : using type = std::string;
3544 [ + - ]: 1310 : static std::string description() { return "string(s)"; }
3545 : : };
3546 : : };
3547 : : using hydrotimescales =
3548 : : keyword< hydrotimescales_info, TAOCPP_PEGTL_STRING("hydrotimescales") >;
3549 : :
3550 : : struct prod_A005H_info {
3551 [ + - ]: 62 : static std::string name() { return "prod_A005H"; }
3552 : 655 : static std::string shortDescription() { return "Select production divided by "
3553 [ + - ]: 1310 : "dissipation rate from DNS of HRT, A=0.05, IC:light<<heavy"; }
3554 : 655 : static std::string longDescription() { return
3555 [ + - ]: 1310 : R"(Production divided by dissipation rate from DNS of homogeneous
3556 : : Rayleigh-Taylor instability, P/e, A = 0.05, IC: light << heavy.)"; }
3557 : : };
3558 : : using prod_A005H = keyword< prod_A005H_info, TAOCPP_PEGTL_STRING("prod_A005H") >;
3559 : :
3560 : : struct prod_A005S_info {
3561 [ + - ]: 62 : static std::string name() { return "prod_A005S"; }
3562 : 655 : static std::string shortDescription() { return "Select production divided by "
3563 [ + - ]: 1310 : "dissipation rate from DNS of HRT, A=0.05, IC:light=heavy"; }
3564 : 655 : static std::string longDescription() { return
3565 [ + - ]: 1310 : R"(Production divided by dissipation rate from DNS of homogeneous
3566 : : Rayleigh-Taylor instability, P/e, A = 0.05, IC: light = heavy.)"; }
3567 : : };
3568 : : using prod_A005S = keyword< prod_A005S_info, TAOCPP_PEGTL_STRING("prod_A005S") >;
3569 : :
3570 : : struct prod_A005L_info {
3571 [ + - ]: 62 : static std::string name() { return "prod_A005L"; }
3572 : 655 : static std::string shortDescription() { return "Select production divided by "
3573 [ + - ]: 1310 : "dissipation rate from DNS of HRT, A=0.05, IC:light>>heavy"; }
3574 : 655 : static std::string longDescription() { return
3575 [ + - ]: 1310 : R"(Production divided by dissipation rate from DNS of homogeneous
3576 : : Rayleigh-Taylor instability, P/e, A = 0.05, IC: light >> heavy.)"; }
3577 : : };
3578 : : using prod_A005L = keyword< prod_A005L_info, TAOCPP_PEGTL_STRING("prod_A005L") >;
3579 : :
3580 : : struct prod_A05H_info {
3581 [ + - ]: 62 : static std::string name() { return "prod_A05H"; }
3582 : 655 : static std::string shortDescription() { return "Select production divided by "
3583 [ + - ]: 1310 : "dissipation rate from DNS of HRT, A=0.5, IC:light<<heavy"; }
3584 : 655 : static std::string longDescription() { return
3585 [ + - ]: 1310 : R"(Production divided by dissipation rate from DNS of homogeneous
3586 : : Rayleigh-Taylor instability, P/e, A = 0.5, IC: light << heavy.)"; }
3587 : : };
3588 : : using prod_A05H = keyword< prod_A05H_info, TAOCPP_PEGTL_STRING("prod_A05H") >;
3589 : :
3590 : : struct prod_A05S_info {
3591 [ + - ]: 62 : static std::string name() { return "prod_A05S"; }
3592 : 655 : static std::string shortDescription() { return "Select production divided by "
3593 [ + - ]: 1310 : "dissipation rate from DNS of HRT, A=0.5, IC:light=heavy"; }
3594 : 655 : static std::string longDescription() { return
3595 [ + - ]: 1310 : R"(Production divided by dissipation rate from DNS of homogeneous
3596 : : Rayleigh-Taylor instability, P/e, A = 0.5, IC: light = heavy.)"; }
3597 : : };
3598 : : using prod_A05S = keyword< prod_A05S_info, TAOCPP_PEGTL_STRING("prod_A05S") >;
3599 : :
3600 : : struct prod_A05L_info {
3601 [ + - ]: 62 : static std::string name() { return "prod_A05L"; }
3602 : 655 : static std::string shortDescription() { return "Select production divided by "
3603 [ + - ]: 1310 : "dissipation rate from DNS of HRT, A=0.5, IC:light>>heavy"; }
3604 : 655 : static std::string longDescription() { return
3605 [ + - ]: 1310 : R"(Production divided by dissipation rate from DNS of homogeneous
3606 : : Rayleigh-Taylor instability, P/e, A = 0.5, IC: light >> heavy.)"; }
3607 : : };
3608 : : using prod_A05L = keyword< prod_A05L_info, TAOCPP_PEGTL_STRING("prod_A05L") >;
3609 : :
3610 : : struct prod_A075H_info {
3611 [ + - ]: 62 : static std::string name() { return "prod_A075H"; }
3612 : 655 : static std::string shortDescription() { return "Select production divided by "
3613 [ + - ]: 1310 : "dissipation rate from DNS of HRT, A=0.75, IC:light<<heavy"; }
3614 : 655 : static std::string longDescription() { return
3615 [ + - ]: 1310 : R"(Production divided by dissipation rate from DNS of homogeneous
3616 : : Rayleigh-Taylor instability, P/e, A = 0.75, IC: light << heavy.)"; }
3617 : : };
3618 : : using prod_A075H = keyword< prod_A075H_info, TAOCPP_PEGTL_STRING("prod_A075H") >;
3619 : :
3620 : : struct prod_A075S_info {
3621 [ + - ]: 62 : static std::string name() { return "prod_A075S"; }
3622 : 655 : static std::string shortDescription() { return "Select production divided by "
3623 [ + - ]: 1310 : "dissipation rate from DNS of HRT, A=0.75, IC:light=heavy"; }
3624 : 655 : static std::string longDescription() { return
3625 [ + - ]: 1310 : R"(Production divided by dissipation rate from DNS of homogeneous
3626 : : Rayleigh-Taylor instability, P/e, A = 0.75, IC: light = heavy.)"; }
3627 : : };
3628 : : using prod_A075S = keyword< prod_A075S_info, TAOCPP_PEGTL_STRING("prod_A075S") >;
3629 : :
3630 : : struct prod_A075L_info {
3631 [ + - ]: 62 : static std::string name() { return "prod_A075L"; }
3632 : 655 : static std::string shortDescription() { return "Select production divided by "
3633 [ + - ]: 1310 : "dissipation rate from DNS of HRT, A=0.75, IC:light>>heavy"; }
3634 : 655 : static std::string longDescription() { return
3635 [ + - ]: 1310 : R"(Production divided by dissipation rate from DNS of homogeneous
3636 : : Rayleigh-Taylor instability, P/e, A = 0.75, IC: light >> heavy.)"; }
3637 : : };
3638 : : using prod_A075L = keyword< prod_A075L_info, TAOCPP_PEGTL_STRING("prod_A075L") >;
3639 : :
3640 : : struct hydroproductions_info {
3641 : : static std::string name() { return "P/eps"; }
3642 : 655 : static std::string shortDescription() { return
3643 [ + - ]: 1310 : R"(Set MixMassFractionBeta SDE parameter(s) productions)"; }
3644 : 655 : static std::string longDescription() { return
3645 : : R"(This keyword is used to specify a vector of strings used to parameterize
3646 : : the system of stochastic differential equations, configured in a
3647 : : mixmassfracbeta ... end block. Within the mixmassfracbeta ... end block the
3648 : : coefficients policy must be set to 'hydrotimescale' in order for the
3649 : : hydroproductions ... end block to be in effect. The 'hydroproductions'
3650 : : keyword is then used to specify a list of strings, each specifying which
3651 : : turbulent kinetic energy production dividied by the dissipation rate (P/eps)
3652 : : data (from direct numerical simulations) should be used for the particular
3653 : : component integrated. Available P/eps data are defined in
3654 : : src/DiffEq/HydroProductions.hpp. Example: "productions prod_A05S prod_A05H
3655 : : prod_A05L prod_A05S prod_A05S end", which
3656 : : configures five P/eps data sets associated to 5 components, i.e., 5 scalar
3657 : : stochastic differential equations, integrated, specified and configured
3658 : : within the given mixmassfracbeta ... end block. The length of the
3659 : : hydroproductions vector depends on the number of scalar components and is
3660 : : controlled by the preceding keyword 'ncomp'. For mixmassfracbeta, ncomp is
3661 : : the actual number of scalar components * 4, since mixmassfractionbeta always
3662 : : computes 4 additional derived stochastic variables (in a diagnostic)
3663 : : fashion. See also MixMassFractionBeta::derived() in
3664 : : src/DiffEq/MixMassFractionBeta.hpp. Keywords allowed in a hydroproductions
3665 [ + - ][ + - ]: 1310 : ... end block: )" + std::string("\'")
3666 [ + - ][ + - ]: 2620 : + prod_A005H::string() + "\', \'"
[ + - ]
3667 [ + - ][ + - ]: 2620 : + prod_A005S::string() + "\', \'"
[ + - ]
3668 [ + - ][ + - ]: 2620 : + prod_A005L::string() + "\', \'"
[ + - ]
3669 [ + - ][ + - ]: 2620 : + prod_A05H::string() + "\', \'"
[ + - ]
3670 [ + - ][ + - ]: 2620 : + prod_A05S::string() + "\', \'"
[ + - ]
3671 [ + - ][ + - ]: 2620 : + prod_A05L::string() + "\', \'"
[ + - ]
3672 [ + - ][ + - ]: 2620 : + prod_A075H::string() + "\', \'"
[ + - ]
3673 [ + - ][ + - ]: 2620 : + prod_A075S::string() + "\', \'"
[ + - ]
3674 [ + - ][ + - ]: 2620 : + prod_A075L::string() + "\'. "
3675 [ + - ]: 1310 : + R"(For an example hydroproductions ... end block, see
3676 : : doc/html/walker_example_mixmassfracbeta.html.)"; }
3677 : : struct expect {
3678 : : using type = std::string;
3679 [ + - ]: 1310 : static std::string description() { return "string(s)"; }
3680 : : };
3681 : : };
3682 : : using hydroproductions =
3683 : : keyword< hydroproductions_info, TAOCPP_PEGTL_STRING("hydroproductions") >;
3684 : :
3685 : : struct mixmassfracbeta_info {
3686 [ + - ]: 39108 : static std::string name() { return "Mix mass-fraction beta"; }
3687 : 655 : static std::string shortDescription() { return
3688 [ + - ]: 1310 : "Introduce the mixmassfracbeta SDE input block"; }
3689 : 655 : static std::string longDescription() { return
3690 : : R"(This keyword is used in multiple ways: (1) To introduce a mixmassfracbeta
3691 : : ... end block, used to specify the configuration of a system of mix
3692 : : mass-fraction beta SDEs, a system of stochastic differential equations
3693 : : (SDEs), whose solution is the joint beta distribution and in which the usual
3694 : : beta SDE parameters b and kappa are specified via functions that constrain
3695 : : the beta SDE to be consistent with the turbulent mixing process. The mix
3696 : : mass-fraction beta SDE is similar to the mass-fraction beta SDE, only the
3697 : : process is made consistent with the no-mix and fully mixed limits via the
3698 : : specification of the SDE coefficients b and kappa. As in the mass-fraction
3699 : : beta SDE, Y is governed by the beta SDE and two additional stochastic
3700 : : variables are computed. However, in the mix mass-fraction beta SDE the
3701 : : parameters b and kappa are given by b = Theta * b' and kappa = kappa' *
3702 : : <y^2>, where Theta = 1 - <y^2> / [ <Y> ( 1 - <Y> ], the fluctuation about
3703 : : the mean, <Y>, is defined as usual: y = Y - <Y>, and b' and kappa' are
3704 : : user-specified constants. Similar to the mass-fraction beta SDE, there two
3705 : : additional random variables computed besides, Y, and they are rho(Y) and
3706 : : V(Y). For more detail on the mass-fraction beta SDE, see the help on keyword
3707 : : 'massfracbeta'. For more details on the beta SDE, see
3708 : : https://doi.org/10.1080/14685248.2010.510843 and src/DiffEq/Beta/Beta.hpp.
3709 : : Keywords allowed in a mixmassfracbeta ... end block: )"
3710 [ + - ][ + - ]: 1310 : + std::string("\'")
3711 [ + - ][ + - ]: 2620 : + depvar::string()+ "\', \'"
[ + - ]
3712 [ + - ][ + - ]: 2620 : + ncomp::string() + "\', \'"
[ + - ]
3713 [ + - ][ + - ]: 2620 : + rng::string() + "\', \'"
[ + - ]
3714 [ + - ][ + - ]: 2620 : + init::string() + "\', \'"
[ + - ]
3715 [ + - ][ + - ]: 2620 : + coeff::string() + "\', \'"
[ + - ]
3716 [ + - ][ + - ]: 2620 : + sde_bprime::string() + "\', \'"
[ + - ]
3717 [ + - ][ + - ]: 2620 : + sde_S::string() + "\', \'"
[ + - ]
3718 [ + - ][ + - ]: 2620 : + sde_kappaprime::string() + "\', \'"
[ + - ]
3719 [ + - ][ + - ]: 2620 : + sde_rho2::string() + "\', \'"
[ + - ]
3720 [ + - ][ + - ]: 2620 : + hydrotimescales::string() + "\', \'"
[ + - ]
3721 [ + - ][ + - ]: 2620 : + hydroproductions::string() + "\', \'"
[ + - ]
3722 [ + - ][ + - ]: 1310 : + "velocity" + "\', \'"
3723 [ + - ][ + - ]: 1310 : + "dissipation" + "\', \'"
3724 [ + - ][ + - ]: 2620 : + sde_r::string() + "\'. "
3725 [ + - ]: 1310 : + R"(For an example mixmassfracbeta ... end block, see
3726 : : doc/html/walker_example_mixmassfracbeta.html. (2) To specify a dependent
3727 : : variable (by a character) used to couple a differential equation system, in
3728 : : which the 'mixmassfracbeta' keyword appears) to another labeled by a
3729 : : 'depvar'.)";
3730 : : }
3731 : : };
3732 : : using mixmassfracbeta =
3733 : : keyword< mixmassfracbeta_info, TAOCPP_PEGTL_STRING("mixmassfracbeta") >;
3734 : :
3735 : : struct fullvar_info {
3736 [ + - ]: 62 : static std::string name() { return "full variable"; }
3737 : 655 : static std::string shortDescription() { return
3738 [ + - ]: 1310 : "Select full variable (as the dependent variable) to solve for"; }
3739 : 655 : static std::string longDescription() { return
3740 [ + - ]: 1310 : R"(This keyword is used to select the full random (instantaneous) variable
3741 : : as what quantity to solve for, i.e., use as the dependent variable, in,
3742 : : e.g., a position or velocity model for a stochastic particle. This
3743 : : configures how statistics must be interpreted.)"; }
3744 : : struct expect {
3745 [ + - ]: 1310 : static std::string description() { return "string"; }
3746 : : };
3747 : : };
3748 : : using fullvar = keyword< fullvar_info, TAOCPP_PEGTL_STRING("fullvar") >;
3749 : :
3750 : : struct fluctuation_info {
3751 [ + - ]: 62 : static std::string name() { return "fluctuation"; }
3752 : 655 : static std::string shortDescription() { return
3753 [ + - ]: 1310 : "Select fluctuation (as the dependent variable) to solve for"; }
3754 : 655 : static std::string longDescription() { return
3755 [ + - ]: 1310 : R"(This keyword is used to select the fluctuation of a random variable as
3756 : : what quantity to solve for, i.e., use as the dependent variable, e.g., in a
3757 : : position or velocity model for a stochastic particle. This configures how
3758 : : statistics must be interpreted.)"; }
3759 : : struct expect {
3760 [ + - ]: 1310 : static std::string description() { return "string"; }
3761 : : };
3762 : : };
3763 : : using fluctuation =
3764 : : keyword< fluctuation_info, TAOCPP_PEGTL_STRING("fluctuation") >;
3765 : :
3766 : : struct product_info {
3767 [ + - ]: 62 : static std::string name() { return "product"; }
3768 : 655 : static std::string shortDescription() { return
3769 [ + - ]: 1310 : "Select product (as the dependent variable) to solve for"; }
3770 : 655 : static std::string longDescription() { return
3771 [ + - ]: 1310 : R"(This keyword is used to select the product of multiple random variables
3772 : : as what quantity to solve for, i.e., use as the dependent variable, e.g., in
3773 : : a velocity model, solve for the product of the full density and the full
3774 : : velocity, i.e., the full momentum, for a stochastic particle. This
3775 : : configures how statistics must be interpreted.)"; }
3776 : : struct expect {
3777 [ + - ]: 1310 : static std::string description() { return "string"; }
3778 : : };
3779 : : };
3780 : : using product =
3781 : : keyword< product_info, TAOCPP_PEGTL_STRING("product") >;
3782 : :
3783 : : struct fluctuating_momentum_info {
3784 [ + - ]: 62 : static std::string name() { return "fluctuating momentum"; }
3785 : 655 : static std::string shortDescription() { return
3786 [ + - ]: 1310 : "Select fluctuating moment (as the dependent variable) to solve for"; }
3787 : 655 : static std::string longDescription() { return
3788 [ + - ]: 1310 : R"(This keyword is used to select fluctuating moment as the dependent
3789 : : variable. This is a very specific quantity and used in conjunction with the
3790 : : Langevin equation for the velocity/momentum. The dependent variable is
3791 : : phi_i^* = rho^* u_i - <rho^* u_i^*>, where the star superscript means a full
3792 : : (i.e., not only a fluctuation about some mean) random variable, u_i is the
3793 : : fluctuating velocity, u_i = u^*_i - <u_i^*>, and angle brackets denote the
3794 : : ensemble average. This also configures how statistics must be
3795 : : interpreted.)"; }
3796 : : struct expect {
3797 [ + - ]: 1310 : static std::string description() { return "string"; }
3798 : : };
3799 : : };
3800 : : using fluctuating_momentum = keyword< fluctuating_momentum_info,
3801 : : TAOCPP_PEGTL_STRING("fluctuating_momentum") >;
3802 : :
3803 : : struct solve_info {
3804 : : static std::string name() { return "solve for"; }
3805 : 655 : static std::string shortDescription() { return
3806 [ + - ]: 1310 : "Select dependent variable to solve for"; }
3807 : 655 : static std::string longDescription() { return
3808 [ + - ]: 1310 : R"(This keyword is used to select an the quantity (the dependent variable)
3809 : : to solve for in walker's position and/or velocity model. This configures how
3810 : : statistics must be interpreted.)"; }
3811 : : struct expect {
3812 [ + - ]: 1310 : static std::string description() { return "string"; }
3813 : 655 : static std::string choices() {
3814 [ + - ][ + - ]: 1310 : return '\'' + fullvar::string() + "\' | \'"
[ + - ]
3815 [ + - ][ + - ]: 2620 : + fluctuation::string() + "\' | \'"
[ + - ]
3816 [ + - ][ + - ]: 2620 : + product::string() + "\' | \'"
[ + - ]
3817 [ + - ][ + - ]: 2620 : + fluctuating_momentum::string() + '\'';
3818 : : }
3819 : : };
3820 : : };
3821 : : using solve = keyword< solve_info, TAOCPP_PEGTL_STRING("solve") >;
3822 : :
3823 : : struct slm_info {
3824 [ + - ]: 20 : static std::string name() { return "slm"; }
3825 : 655 : static std::string shortDescription() { return
3826 [ + - ]: 1310 : "Select the simplified Langevin model (SLM) for the velocity PDF model"; }
3827 : 655 : static std::string longDescription() { return
3828 [ + - ]: 1310 : R"(This keyword is used to select the simplified Langevin model (SLM) for
3829 : : the Lagrangian velocity in turbulent flows.)"; }
3830 : : struct expect {
3831 [ + - ]: 1310 : static std::string description() { return "string"; }
3832 : : };
3833 : : };
3834 : : using slm = keyword< slm_info, TAOCPP_PEGTL_STRING("slm") >;
3835 : :
3836 : : struct glm_info {
3837 [ + - ]: 20 : static std::string name() { return "glm"; }
3838 : 655 : static std::string shortDescription() { return
3839 [ + - ]: 1310 : "Select the generalized Langevin model for the velocity PDF model"; }
3840 : 655 : static std::string longDescription() { return
3841 [ + - ]: 1310 : R"(This keyword is used to select the generalized Langevin model for the
3842 : : Lagrangian velocity in turbulent flows.)"; }
3843 : : struct expect {
3844 [ + - ]: 1310 : static std::string description() { return "string"; }
3845 : : };
3846 : : };
3847 : : using glm = keyword< glm_info, TAOCPP_PEGTL_STRING("glm") >;
3848 : :
3849 : : struct variant_info {
3850 : : static std::string name() { return "variant"; }
3851 : 655 : static std::string shortDescription() { return
3852 [ + - ]: 1310 : "Select velocity PDF model variant"; }
3853 : 655 : static std::string longDescription() { return
3854 [ + - ]: 1310 : R"(This keyword is used to select the velocity PDF model variant.)"; }
3855 : : struct expect {
3856 [ + - ]: 1310 : static std::string description() { return "string"; }
3857 : 655 : static std::string choices() {
3858 [ + - ][ + - ]: 1310 : return '\'' + slm::string() + "\' | \'"
[ + - ]
3859 [ + - ][ + - ]: 2620 : + glm::string() + '\'';
3860 : : }
3861 : : };
3862 : : };
3863 : : using variant = keyword< variant_info, TAOCPP_PEGTL_STRING("variant") >;
3864 : :
3865 : : struct light_info {
3866 [ + - ]: 32 : static std::string name() { return "light"; }
3867 : 655 : static std::string shortDescription() { return
3868 [ + - ]: 1310 : "Select the light-fluid normalization for the mixture Dirichlet SDE"; }
3869 : 655 : static std::string longDescription() { return
3870 [ + - ]: 1310 : R"(This keyword is used to select the light-fluid normalization for the
3871 : : mixture Dirichlet PDF/SDE model for multi-material mixing in turbulent
3872 : : flows.)"; }
3873 : : struct expect {
3874 [ + - ]: 1310 : static std::string description() { return "string"; }
3875 : : };
3876 : : };
3877 : : using light = keyword< light_info, TAOCPP_PEGTL_STRING("light") >;
3878 : :
3879 : : struct heavy_info {
3880 [ + - ]: 32 : static std::string name() { return "heavy"; }
3881 : 655 : static std::string shortDescription() { return
3882 [ + - ]: 1310 : "Select the heavy-fluid normalization for the mixture Dirichlet SDE"; }
3883 : 655 : static std::string longDescription() { return
3884 [ + - ]: 1310 : R"(This keyword is used to select the heavy-fluid normalization for the
3885 : : mixture Dirichlet PDF/SDE model for multi-material mixing in turbulent
3886 : : flows.)"; }
3887 : : struct expect {
3888 [ + - ]: 1310 : static std::string description() { return "string"; }
3889 : : };
3890 : : };
3891 : : using heavy = keyword< heavy_info, TAOCPP_PEGTL_STRING("heavy") >;
3892 : :
3893 : : struct normalization_info {
3894 : : static std::string name() { return "normalization"; }
3895 : 655 : static std::string shortDescription() { return
3896 [ + - ]: 1310 : "Select mixture Dirichlet PDF model normalization type"; }
3897 : 655 : static std::string longDescription() { return
3898 [ + - ]: 1310 : R"(This keyword is used to select the mixture Dirichlet PDF model
3899 : : normalization type.)"; }
3900 : : struct expect {
3901 [ + - ]: 1310 : static std::string description() { return "string"; }
3902 : 655 : static std::string choices() {
3903 [ + - ][ + - ]: 1310 : return '\'' + light::string() + "\' | \'"
[ + - ]
3904 [ + - ][ + - ]: 2620 : + heavy::string() + '\'';
3905 : : }
3906 : : };
3907 : : };
3908 : : using normalization =
3909 : : keyword< normalization_info, TAOCPP_PEGTL_STRING("normalization") >;
3910 : :
3911 : : struct position_info {
3912 [ + - ]: 39108 : static std::string name() { return "position"; }
3913 : 655 : static std::string shortDescription() { return
3914 [ + - ]: 1310 : "Introduce the (particle) position equation input block or coupling"; }
3915 : 655 : static std::string longDescription() { return
3916 : : R"(This keyword is used to introduce a position ...
3917 : : end block, used to specify the configuration of a system of deterministic or
3918 : : stochastic differential equations, governing particle positions usually in
3919 : : conjunction with velocity model, e.g, the Langevin, model. Note that the
3920 : : random number generator r123_philox is automatically put on the list as a
3921 : : selected RNG if no RNG is selected. Keywords allowed in a position ... end
3922 : 0 : block: )" +
3923 [ + - ][ + - ]: 1310 : std::string("\'")
3924 [ + - ][ + - ]: 2620 : + depvar::string()+ "\', \'"
[ + - ]
3925 [ + - ][ + - ]: 2620 : + rng::string() + "\', \'"
[ + - ]
3926 [ + - ][ + - ]: 2620 : + init::string() + "\', \'"
[ + - ]
3927 [ + - ][ + - ]: 2620 : + coeff::string() + "\', \'"
3928 [ + - ][ + - ]: 1310 : + "velocity" + "\', \'"
3929 [ + - ]: 1310 : + R"(For an example position ... end block, see
3930 : : doc/html/walker_example_position.html. (2) To specify a dependent
3931 : : variable (by a character) used to couple a differential equation system, in
3932 : : which the 'position' keyword appears) to another labeled by a 'depvar'.
3933 : : Note that this keyword can also be used as a keyword that selects position
3934 : : in some other context-specific way, e.g., 'position' as opposed to
3935 : : 'velocity'.)";
3936 : : }
3937 : : };
3938 : : using position = keyword< position_info, TAOCPP_PEGTL_STRING("position") >;
3939 : :
3940 : : struct dissipation_info {
3941 [ + - ]: 39108 : static std::string name() { return "dissipation"; }
3942 : 655 : static std::string shortDescription() { return
3943 [ + - ]: 1310 : "Introduce the (particle) dissipation equation input block or coupling"; }
3944 : 655 : static std::string longDescription() { return
3945 : : R"(This keyword is used to introduce a dissipation
3946 : : ... end block, used to specify the configuration of a system of
3947 : : deterministic or stochastic differential equations, governing a particle
3948 : : quantity that models the dissipation rate of turbulent kinetic energy, used
3949 : : to coupled to particle velocity model, e.g, the Langevin, model. Note that
3950 : : the random number generator r123_philox is automatically put on the list as
3951 : : a selected RNG if no RNG is selected. Keywords allowed in a dissipation ...
3952 : 0 : end block: )" +
3953 [ + - ][ + - ]: 1310 : std::string("\'")
3954 [ + - ][ + - ]: 2620 : + depvar::string()+ "\', \'"
[ + - ]
3955 [ + - ][ + - ]: 2620 : + rng::string() + "\', \'"
[ + - ]
3956 [ + - ][ + - ]: 2620 : + init::string() + "\', \'"
[ + - ]
3957 [ + - ][ + - ]: 2620 : + coeff::string() + "\', \'"
3958 [ + - ][ + - ]: 1310 : + "velocity" + "\', \'"
3959 [ + - ]: 1310 : + R"(For an example dissipation ... end block, see
3960 : : doc/html/walker_example_dissipation.html. (2) To specify a dependent
3961 : : variable (by a character) used to couple a differential equation system, in
3962 : : which the 'dissipation' keyword appears) to another labeled by a 'depvar'.)";
3963 : : }
3964 : : };
3965 : : using dissipation =
3966 : : keyword< dissipation_info, TAOCPP_PEGTL_STRING("dissipation") >;
3967 : :
3968 : : struct velocitysde_info {
3969 : : static std::string name() { return "velocity"; }
3970 : 655 : static std::string shortDescription() { return
3971 [ + - ]: 1310 : "Introduce the velocity equation input block or coupling"; }
3972 : 655 : static std::string longDescription() { return
3973 : : R"(This keyword is used to introduce a velocity ...
3974 : : end block, used to specify the configuration of a system of stochastic
3975 : : differential equations (SDEs), governed by the Langevin model for the
3976 : : fluctuating velocity in homogeneous variable-density turbulence. For more
3977 : : details on this Langevin model, see
3978 : : https://doi.org/10.1080/14685248.2011.554419 and
3979 : : src/DiffEq/Velocity/Velocity.hpp. Keywords allowed in a velocity ... end
3980 : 0 : block: )" +
3981 [ + - ][ + - ]: 1310 : std::string("\'")
3982 [ + - ][ + - ]: 2620 : + depvar::string()+ "\', \'"
[ + - ]
3983 [ + - ][ + - ]: 2620 : + rng::string() + "\', \'"
[ + - ]
3984 [ + - ][ + - ]: 2620 : + init::string() + "\', \'"
[ + - ]
3985 [ + - ][ + - ]: 2620 : + coeff::string() + "\', \'"
[ + - ]
3986 [ + - ][ + - ]: 2620 : + hydrotimescales::string() + "\', \'"
[ + - ]
3987 [ + - ][ + - ]: 2620 : + hydroproductions::string() + "\', \'"
[ + - ]
3988 [ + - ][ + - ]: 2620 : + sde_c0::string() + "\'. "
[ + - ]
3989 [ + - ][ + - ]: 2620 : + position::string() + "\', \'"
[ + - ]
3990 [ + - ][ + - ]: 2620 : + dissipation::string() + "\', \'"
[ + - ]
3991 [ + - ][ + - ]: 2620 : + mixmassfracbeta::string() + "\', \'"
3992 [ + - ]: 1310 : + R"(For an example velocity ... end block, see
3993 : : doc/html/walker_example_velocity.html. (2) To specify a dependent
3994 : : variable (by a character) used to couple a differential equation system, in
3995 : : which the 'velocity' keyword appears) to another labeled by a 'depvar'.)";
3996 : : }
3997 : : };
3998 : : using velocitysde = keyword< velocitysde_info, TAOCPP_PEGTL_STRING("velocity") >;
3999 : :
4000 : : struct gamma_info {
4001 [ + - ]: 39108 : static std::string name() { return "Gamma"; }
4002 : 655 : static std::string shortDescription() { return
4003 [ + - ]: 1310 : "Introduce the gamma SDE input block"; }
4004 : 655 : static std::string longDescription() { return
4005 [ + - ]: 1310 : R"(This keyword is used to introduce the gamma ... end block, used to
4006 : : specify the configuration of a system of stochastic differential equations
4007 : : (SDEs), with linear drift and linear diagonal diffusion, whose invariant
4008 : : is the joint gamma distribution.)";
4009 : : }
4010 : : };
4011 : : using gamma = keyword< gamma_info, TAOCPP_PEGTL_STRING("gamma") >;
4012 : :
4013 : : struct ornstein_uhlenbeck_info {
4014 [ + - ]: 39108 : static std::string name() { return "Ornstein-Uhlenbeck"; }
4015 : 655 : static std::string shortDescription() { return
4016 [ + - ]: 1310 : "Introduce the Ornstein-Uhlenbeck SDE input block"; }
4017 : 655 : static std::string longDescription() { return
4018 : : R"(This keyword is used to introduce an ornstein-uhlenbeck ... end block,
4019 : : used to specify the configuration of a system of stochastic differential
4020 : : equations (SDEs), with linear drift and constant diffusion, whose
4021 : : invariant is the joint normal distribution. Keywords allowed in an
4022 [ + - ][ + - ]: 1310 : ornstein-uhlenbeck ... end block: )" + std::string("\'")
4023 [ + - ][ + - ]: 2620 : + depvar::string()+ "\', \'"
[ + - ]
4024 [ + - ][ + - ]: 2620 : + ncomp::string() + "\', \'"
[ + - ]
4025 [ + - ][ + - ]: 2620 : + rng::string() + "\', \'"
[ + - ]
4026 [ + - ][ + - ]: 2620 : + init::string() + "\', \'"
[ + - ]
4027 [ + - ][ + - ]: 2620 : + coeff::string() + "\', \'"
[ + - ]
4028 [ + - ][ + - ]: 2620 : + sde_sigmasq::string() + "\', \'"
[ + - ]
4029 [ + - ][ + - ]: 2620 : + sde_theta::string() + "\', \'"
[ + - ]
4030 [ + - ][ + - ]: 2620 : + sde_mu::string() + "\'. "
4031 [ + - ]: 1310 : + R"(For an example ornstein-uhlenbeck ... end block, see
4032 : : doc/html/walker_example_ou.html.)";
4033 : : }
4034 : : };
4035 : : using ornstein_uhlenbeck =
4036 : : keyword< ornstein_uhlenbeck_info, TAOCPP_PEGTL_STRING("ornstein-uhlenbeck") >;
4037 : :
4038 : : struct diag_ou_info {
4039 [ + - ]: 39108 : static std::string name() { return "Diagonal Ornstein-Uhlenbeck"; }
4040 : 655 : static std::string shortDescription() { return
4041 [ + - ]: 1310 : "Introduce the diagonal Ornstein-Uhlenbeck SDE input block"; }
4042 : 655 : static std::string longDescription() { return
4043 : : R"(This keyword is used to introduce a diag_ou ... end
4044 : : block, where 'diag_ou' stands for diagonal Ornstein-Uhlenbeck' and is used
4045 : : to specify the configuration of a system of stochastic differential
4046 : : equations (SDEs), with linear drift and constant diagonal diffusion, whose
4047 : : invariant is the joint normal distribution. Keywords
4048 [ + - ][ + - ]: 1310 : allowed in a diagou ... end block: )" + std::string("\'")
4049 [ + - ][ + - ]: 2620 : + depvar::string()+ "\', \'"
[ + - ]
4050 [ + - ][ + - ]: 2620 : + ncomp::string() + "\', \'"
[ + - ]
4051 [ + - ][ + - ]: 2620 : + rng::string() + "\', \'"
[ + - ]
4052 [ + - ][ + - ]: 2620 : + init::string() + "\', \'"
[ + - ]
4053 [ + - ][ + - ]: 2620 : + coeff::string() + "\', \'"
[ + - ]
4054 [ + - ][ + - ]: 2620 : + sde_sigmasq::string() + "\', \'"
[ + - ]
4055 [ + - ][ + - ]: 2620 : + sde_theta::string() + "\', \'"
[ + - ]
4056 [ + - ][ + - ]: 2620 : + sde_mu::string() + "\'. "
4057 [ + - ]: 1310 : + R"(For an example diagou ... end block, see
4058 : : doc/html/walker_example_diagou.html.)";
4059 : : }
4060 : : };
4061 : : using diag_ou = keyword< diag_ou_info, TAOCPP_PEGTL_STRING("diag_ou") >;
4062 : :
4063 : : struct control_info {
4064 : : static std::string name() { return "control"; }
4065 : 1479 : static std::string shortDescription()
4066 [ + - ]: 2958 : { return "Specify the control file name [REQUIRED]"; }
4067 : 1479 : static std::string longDescription() { return
4068 [ + - ]: 2958 : R"(This keyword is used to specify the name of the control file from which
4069 : : detailed user input is parsed.)";
4070 : : }
4071 : : using alias = Alias< c >;
4072 : : struct expect {
4073 : : using type = std::string;
4074 [ + - ]: 2958 : static std::string description() { return "string"; }
4075 : : };
4076 : : };
4077 : : using control = keyword< control_info, TAOCPP_PEGTL_STRING("control") >;
4078 : :
4079 : : struct smallcrush_info {
4080 [ + - ]: 34 : static std::string name() { return "SmallCrush"; }
4081 : 36 : static std::string shortDescription() {
4082 [ + - ]: 72 : return "Select RNG battery SmallCrush"; }
4083 : 36 : static std::string longDescription() { return
4084 [ + - ]: 72 : R"(This keyword is used to introduce the description of the random number
4085 : : generator test suite, i.e., battery, 'SmallCrush'. SmallCrush is a
4086 : : battery of relatively small number, O(10), of tests, defined in TestU01,
4087 : : a library for the empirical testing of random number generators. For more "
4088 : : info, see http://www.iro.umontreal.ca/~simardr/testu01/tu01.html.)";
4089 : : }
4090 : : };
4091 : : using smallcrush = keyword< smallcrush_info, TAOCPP_PEGTL_STRING("smallcrush") >;
4092 : :
4093 : : struct crush_info {
4094 [ + - ]: 34 : static std::string name() { return "Crush"; }
4095 : 36 : static std::string shortDescription() { return
4096 [ + - ]: 72 : "Select RNG battery Crush"; }
4097 : 36 : static std::string longDescription() { return
4098 [ + - ]: 72 : R"(This keyword is used to introduce the description of the random number
4099 : : generator test suite, i.e., battery, 'Crush'. Crush is a suite of
4100 : : stringent statistical tests, O(100), defined in TestU01, a library for
4101 : : the empirical testing of random number generators. For more info, see
4102 : : http://www.iro.umontreal.ca/~simardr/testu01/tu01.html.)";
4103 : : }
4104 : : };
4105 : : using crush = keyword< crush_info, TAOCPP_PEGTL_STRING("crush") >;
4106 : :
4107 : : struct bigcrush_info {
4108 [ + - ]: 34 : static std::string name() { return "BigCrush"; }
4109 : 36 : static std::string shortDescription() { return
4110 [ + - ]: 72 : "Select RNG battery BigCrush"; }
4111 : 36 : static std::string longDescription() { return
4112 [ + - ]: 72 : R"(This keyword is used to introduce the description of the random number
4113 : : generator test suite, i.e., battery, 'BigCrush'. BigCrush is a
4114 : : suite of very stringent statistical tests, O(100), defined in TestU01, a
4115 : : library for the empirical testing of random number generators. For more
4116 : : info, see http://www.iro.umontreal.ca/~simardr/testu01/tu01.html.)";
4117 : : }
4118 : : };
4119 : : using bigcrush = keyword< bigcrush_info, TAOCPP_PEGTL_STRING("bigcrush") >;
4120 : :
4121 : : struct verbose_info {
4122 : : static std::string name() { return "verbose"; }
4123 : 1484 : static std::string shortDescription() { return
4124 [ + - ]: 2968 : "Select verbose screen output"; }
4125 : 1484 : static std::string longDescription() { return
4126 [ + - ]: 2968 : R"(This keyword is used to select verbose screen-output as opposed to the
4127 : : default quiet output. With quiet output only the most important messages
4128 : : are echoed to screen.)";
4129 : : }
4130 : : using alias = Alias< v >;
4131 : : };
4132 : : using verbose = keyword< verbose_info, TAOCPP_PEGTL_STRING("verbose") >;
4133 : :
4134 : : struct charestate_info {
4135 : : static std::string name() { return "charestate"; }
4136 : 1484 : static std::string shortDescription() { return
4137 [ + - ]: 2968 : "Enable verbose chare state screen output"; }
4138 : 1484 : static std::string longDescription() { return
4139 [ + - ]: 2968 : R"(This keyword is used to enable verbose Charm++ chare state collection and
4140 : : screen output. The chare state is displayed after a run is finished and the
4141 : : data collected is grouped by chare id (thisIndex), and within groups data
4142 : : is ordered by the time-stamp when a given chare member function is
4143 : : called. See src/Base/ChareState.hpp for details on what is collected. Note
4144 : : that to collect chare state, the given chare must be instrumented. Note that
4145 : : if quescence detection is enabled,
4146 : : chare state collection is also automatically enabled, but the chare state is
4147 : : only output if quiescence is detected (which also triggers an error).)";
4148 : : }
4149 : : using alias = Alias< S >;
4150 : : };
4151 : : using charestate = keyword< charestate_info, TAOCPP_PEGTL_STRING("state") >;
4152 : :
4153 : : struct benchmark_info {
4154 : : static std::string name() { return "benchmark"; }
4155 : : static std::string shortDescription() { return "Select benchmark mode"; }
4156 : : static std::string longDescription() { return
4157 : : R"(This keyword is used to select benchmark mode. In benchmark mode no large
4158 : : file output is performed, overriding the configuration in the control
4159 : : file.)";
4160 : : }
4161 : : using alias = Alias< b >;
4162 : : };
4163 : :
4164 : : using benchmark = keyword< benchmark_info, TAOCPP_PEGTL_STRING("benchmark") >;
4165 : :
4166 : : struct nonblocking_info {
4167 : : static std::string name() { return "nonblocking"; }
4168 : : static std::string shortDescription()
4169 : : { return "Select non-blocking migration"; }
4170 : : static std::string longDescription() { return
4171 : : R"(This keyword is used to select non-blocking, instead of the default
4172 : : blocking, migration. WARNING: This feature is experimental, not well
4173 : : tested, and may not always work as expected.)";
4174 : : }
4175 : : using alias = Alias< n >;
4176 : : };
4177 : :
4178 : : using nonblocking =
4179 : : keyword< nonblocking_info, TAOCPP_PEGTL_STRING("nonblocking") >;
4180 : :
4181 : : struct lbfreq_info {
4182 : : static std::string name() { return "Load balancing frequency"; }
4183 : : static std::string shortDescription()
4184 : : { return "Set load-balancing frequency during time stepping"; }
4185 : : static std::string longDescription() { return
4186 : : R"(This keyword is used to set the frequency of load-balancing during
4187 : : time stepping. The default is 1, which means that load balancing is
4188 : : initiated every time step. Note, however, that this does not necessarily
4189 : : mean that load balancing will be performed by the runtime system every
4190 : : time step, only that the Charm++ load-balancer is initiated. For more
4191 : : information, see the Charm++ manual.)";
4192 : : }
4193 : : using alias = Alias< l >;
4194 : : struct expect {
4195 : : using type = std::size_t;
4196 : : static constexpr type lower = 1;
4197 : : static constexpr type upper = std::numeric_limits< type >::max()-1;
4198 : : static std::string description() { return "int"; }
4199 : : static std::string choices() {
4200 : : return "integer between [" + std::to_string(lower) + "..." +
4201 : : std::to_string(upper) + "] (both inclusive)";
4202 : : }
4203 : : };
4204 : : };
4205 : : using lbfreq = keyword< lbfreq_info, TAOCPP_PEGTL_STRING("lbfreq") >;
4206 : :
4207 : : struct rsfreq_info {
4208 : : static std::string name() { return "Checkpoint/restart frequency"; }
4209 : : static std::string shortDescription()
4210 : : { return "Set checkpoint/restart frequency during time stepping"; }
4211 : : static std::string longDescription() { return
4212 : : R"(This keyword is used to set the frequency of dumping checkpoint/restart
4213 : : files during time stepping. The default is 1000, which means that
4214 : : checkpoint/restart files are dumped at every 1000th time step.)";
4215 : : }
4216 : : using alias = Alias< r >;
4217 : : struct expect {
4218 : : using type = std::size_t;
4219 : : static constexpr type lower = 1;
4220 : : static constexpr type upper = std::numeric_limits< type >::max()-1;
4221 : : static std::string description() { return "int"; }
4222 : : static std::string choices() {
4223 : : return "integer between [" + std::to_string(lower) + "..." +
4224 : : std::to_string(upper) + "] (both inclusive)";
4225 : : }
4226 : : };
4227 : : };
4228 : : using rsfreq = keyword< rsfreq_info, TAOCPP_PEGTL_STRING("rsfreq") >;
4229 : :
4230 : : struct feedback_info {
4231 : : static std::string name() { return "feedback"; }
4232 : : static std::string shortDescription() { return "Enable on-screen feedback"; }
4233 : : static std::string longDescription() { return
4234 : : R"(This keyword is used to enable more detailed on-screen feedback on
4235 : : particular tasks and sub-tasks as they happen. This is useful for large
4236 : : problems and debugging.)";
4237 : : }
4238 : : using alias = Alias< f >;
4239 : : };
4240 : : using feedback = keyword< feedback_info, TAOCPP_PEGTL_STRING("feedback") >;
4241 : :
4242 : : struct version_info {
4243 : : static std::string name() { return "Show version"; }
4244 [ + - ]: 2968 : static std::string shortDescription() { return "Show version information"; }
4245 : 1484 : static std::string longDescription() { return
4246 [ + - ]: 2968 : R"(This keyword is used to display version information for the
4247 : : executable/tool on the standard output and exit successfully.)";
4248 : : }
4249 : : using alias = Alias< V >;
4250 : : };
4251 : : using version = keyword< version_info, TAOCPP_PEGTL_STRING("version") >;
4252 : :
4253 : : struct license_info {
4254 : : static std::string name() { return "Show license"; }
4255 [ + - ]: 2968 : static std::string shortDescription() { return "Show license information"; }
4256 : 1484 : static std::string longDescription() { return
4257 [ + - ]: 2968 : R"(This keyword is used to display license information for the
4258 : : executable/tool on the standard output and exit successfully.)";
4259 : : }
4260 : : using alias = Alias< L >;
4261 : : };
4262 : : using license = keyword< license_info, TAOCPP_PEGTL_STRING("license") >;
4263 : :
4264 : : struct trace_info {
4265 : : static std::string name() { return "trace"; }
4266 : 1484 : static std::string shortDescription()
4267 [ + - ]: 2968 : { return "Disable call and stack trace"; }
4268 [ + - ]: 2968 : static std::string longDescription() { return R"(This keyword can be used to
4269 : : disable the on-screen call trace and stack trace after an exception is
4270 : : thrown. Trace output is on by default and in some cases, the call and
4271 : : stack trace can be huge and not very helpful, hence this command line
4272 : : option.)"; }
4273 : : using alias = Alias< t >;
4274 : : };
4275 : : using trace = keyword< trace_info, TAOCPP_PEGTL_STRING("trace") >;
4276 : :
4277 : : struct quiescence_info {
4278 : : static std::string name() { return "quiescence"; }
4279 : 1484 : static std::string shortDescription()
4280 [ + - ]: 2968 : { return "Enable quiescence detection"; }
4281 : 1484 : static std::string longDescription() { return
4282 [ + - ]: 2968 : R"(This keyword is used to enable the quiescence detection feature of
4283 : : Charm++, used to catch logic errors in the asynchronous control flow,
4284 : : resulting in deadlocks. This is useful for automated testing and
4285 : : debugging and does have some overhead, so it is off by default.)";
4286 : : }
4287 : : using alias = Alias< q >;
4288 : : };
4289 : : using quiescence =
4290 : : keyword< quiescence_info, TAOCPP_PEGTL_STRING("quiescence") >;
4291 : :
4292 : : struct virtualization_info {
4293 : : static std::string name() { return "virtualization"; }
4294 : 1403 : static std::string shortDescription() { return
4295 [ + - ]: 2806 : R"(Set degree of virtualization)"; }
4296 : 1403 : static std::string longDescription() { return
4297 [ + - ]: 2806 : R"(This option is used to set the degree of virtualization
4298 : : (over-decomposition). The virtualization parameter is a real number
4299 : : between 0.0 and 1.0, inclusive, which controls the degree of
4300 : : virtualization or over-decomposition. Independent of the value of
4301 : : virtualization the work is approximately evenly distributed among the
4302 : : available processing elements. For zero virtualization (no
4303 : : over-decomposition), the work is simply decomposed into
4304 : : total_work/numPEs, which yields the smallest number of Charm++ chares and
4305 : : the largest chunks of work units. The other extreme is unity
4306 : : virtualization, which decomposes the total work into the smallest size
4307 : : work units possible, yielding the largest number of Charm++ chares.
4308 : : Obviously, the optimum will be between 0.0 and 1.0, depending on the
4309 : : problem.)";
4310 : : }
4311 : : using alias = Alias< u >;
4312 : : struct expect {
4313 : : using type = tk::real;
4314 : : static constexpr type lower = 0.0;
4315 : : static constexpr type upper = 1.0;
4316 [ + - ]: 2806 : static std::string description() { return "real"; }
4317 : 1403 : static std::string choices() {
4318 [ + - ][ + - ]: 2806 : return "real between [" + std::to_string(lower) + "..." +
[ + - ]
4319 [ + - ][ + - ]: 4209 : std::to_string(upper) + "] (both inclusive)";
4320 : : }
4321 : : };
4322 : : };
4323 : : using virtualization =
4324 : : keyword< virtualization_info, TAOCPP_PEGTL_STRING("virtualization") >;
4325 : :
4326 : : struct pdf_info {
4327 : : static std::string name() { return "pdf"; }
4328 : 1403 : static std::string shortDescription() { return
4329 [ + - ]: 2806 : "Specify the name of the PDF output file"; }
4330 : 1403 : static std::string longDescription() { return
4331 [ + - ]: 2806 : R"(This keyword is used to specify the name of the output file in which to
4332 : : store probability density functions (PDFs) during a simulation.)";
4333 : : }
4334 : : using alias = Alias< p >;
4335 : : struct expect {
4336 : : using type = std::string;
4337 [ + - ]: 2806 : static std::string description() { return "string"; }
4338 : : };
4339 : : };
4340 : : using pdf = keyword< pdf_info, TAOCPP_PEGTL_STRING("pdf") >;
4341 : :
4342 : : struct stat_info {
4343 : : static std::string name() { return "stat"; }
4344 : 1403 : static std::string shortDescription() { return
4345 [ + - ]: 2806 : "Specify the name of the statistical moments output file"; }
4346 : 1403 : static std::string longDescription() { return
4347 [ + - ]: 2806 : R"(This keyword is used to specify the name of the output file in which to
4348 : : store statistical moments during a simulation.)";
4349 : : }
4350 : : using alias = Alias< s >;
4351 : : struct expect {
4352 : : using type = std::string;
4353 [ + - ]: 2806 : static std::string description() { return "string"; }
4354 : : };
4355 : : };
4356 : : using stat = keyword< stat_info, TAOCPP_PEGTL_STRING("stat") >;
4357 : :
4358 : : struct particles_info {
4359 : : static std::string name() { return "particles"; }
4360 : 1403 : static std::string shortDescription() { return
4361 [ + - ]: 2806 : "Specify the name of the particles position output file"; }
4362 : 1403 : static std::string longDescription() { return
4363 [ + - ]: 2806 : R"(This keyword is used to specify the name of the output file in which to
4364 : : store particles positions during a simulation.)";
4365 : : }
4366 : : using alias = Alias< x >;
4367 : : struct expect {
4368 : : using type = std::string;
4369 [ + - ]: 2806 : static std::string description() { return "string"; }
4370 : : };
4371 : : };
4372 : : using particles = keyword< particles_info, TAOCPP_PEGTL_STRING("particles") >;
4373 : :
4374 : : struct input_info {
4375 : : static std::string name() { return "input"; }
4376 : : static std::string shortDescription() { return "Specify the input file"; }
4377 : : static std::string longDescription() { return
4378 : : R"(This option is used to define the name of input file.)";
4379 : : }
4380 : : using alias = Alias< i >;
4381 : : struct expect {
4382 : : using type = std::string;
4383 : : static std::string description() { return "string"; }
4384 : : };
4385 : : };
4386 : : using input = keyword< input_info, TAOCPP_PEGTL_STRING("input") >;
4387 : :
4388 : : struct output_info {
4389 : : static std::string name() { return "output"; }
4390 : : static std::string shortDescription() { return "Specify the output file"; }
4391 : : static std::string longDescription() { return
4392 : : R"(This option is used to define the output file name. In MeshConv, this is
4393 : : used to specify the output mesh file name. In Inciter this is used to
4394 : : specify the output base filename. The base filename is appended by
4395 : : ".e-s.<meshid>.<numchares>.<chareid>", where 'e-s' probably stands for
4396 : : ExodusII sequence (the output file format), <meshid> counts the number of
4397 : : new meshes (this is incremented whenever the mesh is new compared to the
4398 : : previous iteration, due to, e.g., mesh refinement), <numchares> is the total
4399 : : number of mesh partitions, and <chareid> is the work unit (or mesh
4400 : : partition) id.)";
4401 : : }
4402 : : using alias = Alias< o >;
4403 : : struct expect {
4404 : : using type = std::string;
4405 : : static std::string description() { return "string"; }
4406 : : };
4407 : : };
4408 : : using output = keyword< output_info, TAOCPP_PEGTL_STRING("output") >;
4409 : :
4410 : : struct refined_info {
4411 : : static std::string name() { return "Refined field output"; }
4412 : : static std::string shortDescription() { return
4413 : : "Turn refined field output on/off"; }
4414 : : static std::string longDescription() { return
4415 : : R"(This keyword can be used to turn on/off refined field output, which
4416 : : refines the mesh and evaluates the solution on the refined mesh for saving
4417 : : the solution.)"; }
4418 : : struct expect {
4419 : : using type = bool;
4420 : : static std::string description() { return "string"; }
4421 : : static std::string choices() { return "true | false"; }
4422 : : };
4423 : : };
4424 : : using refined =keyword< refined_info, TAOCPP_PEGTL_STRING("refined") >;
4425 : :
4426 : : struct screen_info {
4427 : : static std::string name() { return "screen"; }
4428 : 1484 : static std::string shortDescription() {
4429 [ + - ]: 2968 : return "Specify the screen output file"; }
4430 : 1484 : static std::string longDescription() { return
4431 [ + - ]: 2968 : R"(This option is used to set the screen output file name. The default is
4432 : : "<executable>_screen.log".)";
4433 : : }
4434 : : using alias = Alias< O >;
4435 : : struct expect {
4436 : : using type = std::string;
4437 [ + - ]: 2968 : static std::string description() { return "string"; }
4438 : : };
4439 : : };
4440 : : using screen = keyword< screen_info, TAOCPP_PEGTL_STRING("screen") >;
4441 : :
4442 : : struct restart_info {
4443 : : static std::string name() { return "checkpoint/restart directory name"; }
4444 : : static std::string shortDescription()
4445 : : { return "Specify the directory for restart files"; }
4446 : : static std::string longDescription() { return
4447 : : R"(This option is used to specify the directory name in which to save
4448 : : checkpoint/restart files.)";
4449 : : }
4450 : : using alias = Alias< R >;
4451 : : struct expect {
4452 : : using type = std::string;
4453 : : static std::string description() { return "string"; }
4454 : : };
4455 : : };
4456 : : using restart = keyword< restart_info, TAOCPP_PEGTL_STRING("restart") >;
4457 : :
4458 : : struct l2_info {
4459 : : static std::string name() { return "L2"; }
4460 : : static std::string shortDescription() { return "Select the L2 norm"; }
4461 : : static std::string longDescription() { return
4462 : : R"(This keyword is used to enable computing the L2 norm. Example:
4463 : : "diagnostics error l2 end'.")"; }
4464 : : struct expect {
4465 : : static std::string description() { return "string"; }
4466 : : };
4467 : : };
4468 : : using l2 = keyword< l2_info, TAOCPP_PEGTL_STRING("l2") >;
4469 : :
4470 : : struct linf_info {
4471 : : static std::string name() { return "Linf"; }
4472 : : static std::string shortDescription() { return
4473 : : "Select the L_{infinity} norm"; }
4474 : : static std::string longDescription() { return
4475 : : R"(This keyword is used to enable computing the L-infinity norm. Example:
4476 : : "diagnostics error linf end'.")"; }
4477 : : struct expect {
4478 : : static std::string description() { return "string"; }
4479 : : };
4480 : : };
4481 : : using linf = keyword< linf_info, TAOCPP_PEGTL_STRING("linf") >;
4482 : :
4483 : : struct error_info {
4484 : : static std::string name() { return "error"; }
4485 : : static std::string shortDescription() { return "Select an error norm"; }
4486 : : static std::string longDescription() { return
4487 : : R"(This keyword is used to select, i.e., turn on, the estimation of an
4488 : : error norm. The keyword is used in a 'diagnostics ... end' block. Example:
4489 : : "diagnostics error l2 end", which configures computation of the L2 norm.)";
4490 : : }
4491 : : struct expect {
4492 : : static std::string description() { return "string"; }
4493 : : static std::string choices() {
4494 : : return '\'' + l2::string() + "\' | \'"
4495 : : + linf::string() + '\'';
4496 : : }
4497 : : };
4498 : : };
4499 : : using error = keyword< error_info, TAOCPP_PEGTL_STRING("error") >;
4500 : :
4501 : : struct diagnostics_cmd_info {
4502 : : static std::string name() { return "diagnostics"; }
4503 : : static std::string shortDescription()
4504 : : { return "Specify the diagnostics file name"; }
4505 : : static std::string longDescription() { return
4506 : : R"(This option is used to define the diagnostics file name.)";
4507 : : }
4508 : : using alias = Alias< d >;
4509 : : struct expect {
4510 : : using type = std::string;
4511 : : static std::string description() { return "string"; }
4512 : : };
4513 : : };
4514 : : using diagnostics_cmd =
4515 : : keyword< diagnostics_cmd_info, TAOCPP_PEGTL_STRING("diagnostics") >;
4516 : :
4517 : : struct diagnostics_info {
4518 : : static std::string name() { return "diagnostics"; }
4519 : : static std::string shortDescription()
4520 : : { return "Specify the diagnostics file name"; }
4521 : : static std::string longDescription() { return
4522 : : R"(This keyword is used to introduce the dagnostics ... end block, used to
4523 : : configure diagnostics output. Keywords allowed in this block: )"
4524 : : + std::string("\'")
4525 : : + interval_iter::string() + "\' | \'"
4526 : : + txt_float_format::string() + "\' | \'"
4527 : : + error::string() + "\' | \'"
4528 : : + precision::string() + "\'.";
4529 : : }
4530 : : };
4531 : : using diagnostics =
4532 : : keyword< diagnostics_info, TAOCPP_PEGTL_STRING("diagnostics") >;
4533 : :
4534 : : struct reorder_cmd_info {
4535 : : static std::string name() { return "reorder"; }
4536 : : static std::string shortDescription() { return "Reorder mesh nodes"; }
4537 : : static std::string longDescription() { return
4538 : : R"(This keyword is used as a command line argument to instruct the mesh
4539 : : converter to not only convert but also reorder the mesh nodes using the
4540 : : advancing front technique. Reordering is optional in meshconv and
4541 : : inciter.)";
4542 : : }
4543 : : using alias = Alias< r >;
4544 : : struct expect {
4545 : : using type = bool;
4546 : : static std::string description() { return "string"; }
4547 : : };
4548 : : };
4549 : : using reorder_cmd = keyword< reorder_cmd_info, TAOCPP_PEGTL_STRING("reorder") >;
4550 : :
4551 : : struct pelocal_reorder_info {
4552 : : static std::string name() { return "PE-local reorder"; }
4553 : : static std::string shortDescription() { return "PE-local reorder"; }
4554 : : static std::string longDescription() { return
4555 : : R"(This keyword is used in inciter as a keyword in the inciter...end block
4556 : : as "pelocal_reorder true" (or false) to do (or not do) a global distributed
4557 : : mesh reordering across all PEs that yields an approximately continous mesh
4558 : : node ID order as mesh partitions are assigned to PEs after mesh
4559 : : partitioning. This reordering is optional.)";
4560 : : }
4561 : : struct expect {
4562 : : using type = bool;
4563 : : static std::string choices() { return "true | false"; }
4564 : : static std::string description() { return "string"; }
4565 : : };
4566 : : };
4567 : : using pelocal_reorder =
4568 : : keyword< pelocal_reorder_info, TAOCPP_PEGTL_STRING("pelocal_reorder") >;
4569 : :
4570 : : struct operator_reorder_info {
4571 : : static std::string name() { return "operator_reorder"; }
4572 : : static std::string shortDescription() { return "Operator-access reorder"; }
4573 : : static std::string longDescription() { return
4574 : : R"(This keyword is used in inciter as a keyword in the inciter...end block
4575 : : as "operator_reorder on" (or off) to do (or not do) a local mesh node
4576 : : reordering based on the PDE operator access pattern. This reordering is
4577 : : optional.)";
4578 : : }
4579 : : struct expect {
4580 : : using type = bool;
4581 : : static std::string choices() { return "true | false"; }
4582 : : static std::string description() { return "string"; }
4583 : : };
4584 : : };
4585 : : using operator_reorder =
4586 : : keyword< operator_reorder_info, TAOCPP_PEGTL_STRING("operator_reorder") >;
4587 : :
4588 : : struct steady_state_info {
4589 : : static std::string name() { return "steady_state"; }
4590 : : static std::string shortDescription() { return "March to steady state"; }
4591 : : static std::string longDescription() { return
4592 : : R"(This keyword is used indicate that local time stepping should be used
4593 : : towards a stationary solution.)"; }
4594 : : struct expect {
4595 : : using type = bool;
4596 : : static std::string choices() { return "true | false"; }
4597 : : static std::string description() { return "string"; }
4598 : : };
4599 : : };
4600 : : using steady_state =
4601 : : keyword< steady_state_info, TAOCPP_PEGTL_STRING("steady_state") >;
4602 : :
4603 : : struct residual_info {
4604 : : static std::string name() { return "residual"; }
4605 : : static std::string shortDescription() { return
4606 : : "Set the convergence criterion for the residual to reach"; }
4607 : : static std::string longDescription() { return
4608 : : R"(This keyword is used to specify a convergence criterion for, e.g., local
4609 : : time stepping marching to steady state, below which the simulation is
4610 : : considered converged.)"; }
4611 : : struct expect {
4612 : : using type = tk::real;
4613 : : static constexpr type lower = 1.0e-14;
4614 : : static std::string description() { return "real"; }
4615 : : };
4616 : : };
4617 : : using residual = keyword< residual_info, TAOCPP_PEGTL_STRING("residual") >;
4618 : :
4619 : : struct rescomp_info {
4620 : : static std::string name() { return "rescomp"; }
4621 : : static std::string shortDescription() { return
4622 : : "Equation system component index for convergence"; }
4623 : : static std::string longDescription() { return
4624 : : R"(This keyword is used to specify a single integer that is used to denote
4625 : : the equation component index in the complete system of equation systems
4626 : : configured in an input file to use for the convergence criterion for local
4627 : : time stepping marching towards steady state.)";
4628 : : }
4629 : : struct expect {
4630 : : using type = uint32_t;
4631 : : static constexpr type lower = 1;
4632 : : static std::string description() { return "uint"; }
4633 : : };
4634 : : };
4635 : : using rescomp = keyword< rescomp_info, TAOCPP_PEGTL_STRING("rescomp") >;
4636 : :
4637 : : struct group_info {
4638 : : static std::string name() { return "group"; }
4639 : 5 : static std::string shortDescription() { return
4640 [ + - ]: 10 : "Select test group(s) to run"; }
4641 : 5 : static std::string longDescription() { return
4642 [ + - ]: 10 : R"(This option can be used to select one or more test groups to run by
4643 : : specifying the full or a partial name of a test group. All tests of a
4644 : : selected group will be executed. If this option is not given, all test
4645 : : groups are executed by default. Examples: '--group make_list' - run only
4646 : : the 'make_list' test group, '--group Parser' - run the test groups that have
4647 : : the string 'Parser' in their name, e.g., groups 'Control/FileParser' and
4648 : : 'Control/StringParser'.)";
4649 : : }
4650 : : using alias = Alias< g >;
4651 : : struct expect {
4652 : : using type = std::string;
4653 [ + - ]: 10 : static std::string description() { return "string"; }
4654 : : };
4655 : : };
4656 : : using group = keyword< group_info, TAOCPP_PEGTL_STRING("group") >;
4657 : :
4658 : : struct inciter_info {
4659 : : static std::string name() { return "inciter"; }
4660 : : static std::string shortDescription() { return
4661 : : "Start configuration block for inciter"; }
4662 : : static std::string longDescription() { return
4663 : : R"(This keyword is used to select inciter. Inciter, is a continuum-realm
4664 : : shock hydrodynamics tool, solving a PDE.)";
4665 : : }
4666 : : };
4667 : : using inciter = keyword< inciter_info, TAOCPP_PEGTL_STRING("inciter") >;
4668 : :
4669 : : struct user_defined_info {
4670 : : using code = Code< U >;
4671 : : static std::string name() { return "User-defined"; }
4672 : : static std::string shortDescription() { return
4673 : : "Select user-defined specification for a problem"; }
4674 : : static std::string longDescription() { return
4675 : : R"(This keyword is used to select the user-defined specification for an
4676 : : option. This could be a 'problem' to be solved by a partial differential
4677 : : equation, but can also be a 'user-defined' mesh velocity specification for
4678 : : ALE mesh motion.)"; }
4679 : : struct expect {
4680 : : static std::string description() { return "string"; }
4681 : : };
4682 : : };
4683 : :
4684 : : using user_defined =
4685 : : keyword< user_defined_info, TAOCPP_PEGTL_STRING("user_defined") >;
4686 : :
4687 : : struct shear_diff_info {
4688 : : using code = Code< S >;
4689 : : static std::string name() { return "Shear-diffusion"; }
4690 : : static std::string shortDescription() { return
4691 : : "Select the shear + diffusion test problem "; }
4692 : : static std::string longDescription() { return
4693 : : R"(This keyword is used to select the shear diffusion test problem. The
4694 : : initial and boundary conditions are specified to set up the test problem
4695 : : suitable to exercise and test the advection and diffusion terms of the
4696 : : scalar transport equation. Example: "problem shear_diff".)"; }
4697 : : struct expect {
4698 : : static std::string description() { return "string"; }
4699 : : };
4700 : : };
4701 : : using shear_diff = keyword< shear_diff_info, TAOCPP_PEGTL_STRING("shear_diff") >;
4702 : :
4703 : : struct slot_cyl_info {
4704 : : using code = Code< Z >;
4705 : : static std::string name() { return "Zalesak's slotted cylinder"; }
4706 : : static std::string shortDescription() { return
4707 : : "Select Zalesak's slotted cylinder test problem"; }
4708 : : static std::string longDescription() { return
4709 : : R"(This keyword is used to select the Zalesak's slotted cylinder test
4710 : : problem. The initial and boundary conditions are specified to set up the
4711 : : test problem suitable to exercise and test the advection and diffusion
4712 : : terms of the scalar transport equation. Example: "problem slot_cyl".)"; }
4713 : : struct expect {
4714 : : static std::string description() { return "string"; }
4715 : : };
4716 : : };
4717 : : using slot_cyl = keyword< slot_cyl_info, TAOCPP_PEGTL_STRING("slot_cyl") >;
4718 : :
4719 : : struct gauss_hump_info {
4720 : : using code = Code< G >;
4721 : : static std::string name() { return "Advection of 2D Gaussian hump"; }
4722 : : static std::string shortDescription() { return
4723 : : "Select advection of 2D Gaussian hump test problem"; }
4724 : : static std::string longDescription() { return
4725 : : R"(This keyword is used to select the advection of 2D Gaussian hump test
4726 : : problem. The initial and boundary conditions are specified to set up the
4727 : : test problem suitable to exercise and test the advection
4728 : : terms of the scalar transport equation. Example: "problem gauss_hump".)"; }
4729 : : struct expect {
4730 : : static std::string description() { return "string"; }
4731 : : };
4732 : : };
4733 : : using gauss_hump = keyword< gauss_hump_info, TAOCPP_PEGTL_STRING("gauss_hump") >;
4734 : :
4735 : : struct cyl_advect_info {
4736 : : using code = Code< C >;
4737 : : static std::string name() { return "Advection of cylinder"; }
4738 : : static std::string shortDescription() { return
4739 : : "Select advection of cylinder test problem"; }
4740 : : static std::string longDescription() { return
4741 : : R"(This keyword is used to select the advection of cylinder test
4742 : : problem. The initial and boundary conditions are specified to set up the
4743 : : test problem suitable to exercise and test the advection
4744 : : terms of the scalar transport equation. Example: "problem cyl_advect".)"; }
4745 : : struct expect {
4746 : : static std::string description() { return "string"; }
4747 : : };
4748 : : };
4749 : : using cyl_advect = keyword< cyl_advect_info, TAOCPP_PEGTL_STRING("cyl_advect") >;
4750 : :
4751 : : struct cyl_vortex_info {
4752 : : using code = Code< X >;
4753 : : static std::string name() { return "Deformation of cylinder in a vortex"; }
4754 : : static std::string shortDescription() { return
4755 : : "Select deformation of cylinder in a vortex test problem"; }
4756 : : static std::string longDescription() { return
4757 : : R"(This keyword is used to select the test problem which deforms a cylinder
4758 : : in a vortical velocity field. The initial and boundary conditions are
4759 : : specified to set up the test problem suitable to exercise and test the
4760 : : advection terms of the scalar transport equation.
4761 : : Example: "problem cyl_vortex".)"; }
4762 : : struct expect {
4763 : : static std::string description() { return "string"; }
4764 : : };
4765 : : };
4766 : : using cyl_vortex = keyword< cyl_vortex_info, TAOCPP_PEGTL_STRING("cyl_vortex") >;
4767 : :
4768 : : struct vortical_flow_info {
4769 : : using code = Code< V >;
4770 : : static std::string name() { return "Vortical flow"; }
4771 : : static std::string shortDescription() { return
4772 : : "Select the vortical flow test problem "; }
4773 : : static std::string longDescription() { return
4774 : : R"(This keyword is used to select the vortical flow test problem. The
4775 : : purpose of this test problem is to test velocity errors generated by spatial
4776 : : operators in the presence of 3D vorticity and in particluar the
4777 : : superposition of planar and vortical flows, analogous to voritcity
4778 : : stretching. Example: "problem vortical_flow. For more details, see Waltz,
4779 : : et. al, "Manufactured solutions for the three-dimensional Euler equations
4780 : : with relevance to Inertial Confinement Fusion", Journal of Computational
4781 : : Physics 267 (2014) 196-209.)"; }
4782 : : struct expect {
4783 : : static std::string description() { return "string"; }
4784 : : };
4785 : : };
4786 : : using vortical_flow =
4787 : : keyword< vortical_flow_info, TAOCPP_PEGTL_STRING("vortical_flow") >;
4788 : :
4789 : : struct nl_energy_growth_info {
4790 : : using code = Code< N >;
4791 : : static std::string name() { return "Nonlinear energy growth"; }
4792 : : static std::string shortDescription() { return
4793 : : "Select the nonlinear energy growth test problem ";}
4794 : : static std::string longDescription() { return
4795 : : R"(This keyword is used to select the nonlinear energy growth test problem.
4796 : : The purpose of this test problem is to test nonlinear, time dependent energy
4797 : : growth and the subsequent development of pressure gradients due to coupling
4798 : : between the internal energy and the equation of state. Example: "problem
4799 : : nl_energy_growth". For more details, see Waltz, et. al, "Manufactured
4800 : : solutions for the three-dimensional Euler equations with relevance to
4801 : : Inertial Confinement Fusion", Journal of Computational Physics 267 (2014)
4802 : : 196-209.)"; }
4803 : : struct expect {
4804 : : static std::string description() { return "string"; }
4805 : : };
4806 : : };
4807 : : using nl_energy_growth =
4808 : : keyword< nl_energy_growth_info, TAOCPP_PEGTL_STRING("nl_energy_growth") >;
4809 : :
4810 : : struct rayleigh_taylor_info {
4811 : : using code = Code< R >;
4812 : : static std::string name() { return "Rayleigh-Taylor"; }
4813 : : static std::string shortDescription() { return
4814 : : "Select the Rayleigh-Taylor test problem "; }
4815 : : static std::string longDescription() { return
4816 : : R"(This keyword is used to select the Rayleigh-Taylor unstable configuration
4817 : : test problem. The purpose of this test problem is to assess time dependent
4818 : : fluid motion in the presence of Rayleigh-Taylor unstable conditions, i.e.
4819 : : opposing density and pressure gradients. Example: "problem rayleigh_taylor".
4820 : : For more details, see Waltz, et. al, "Manufactured solutions for the
4821 : : three-dimensional Euler equations with relevance to Inertial Confinement
4822 : : Fusion", Journal of Computational Physics 267 (2014) 196-209.)"; }
4823 : : struct expect {
4824 : : static std::string description() { return "string"; }
4825 : : };
4826 : : };
4827 : : using rayleigh_taylor =
4828 : : keyword< rayleigh_taylor_info, TAOCPP_PEGTL_STRING("rayleigh_taylor") >;
4829 : :
4830 : : struct taylor_green_info {
4831 : : using code = Code< T >;
4832 : : static std::string name() { return "Taylor-Green"; }
4833 : : static std::string shortDescription() { return
4834 : : "Select the Taylor-Green test problem "; }
4835 : : static std::string longDescription() { return
4836 : : R"(This keyword is used to select the Taylor-Green vortex test problem. The
4837 : : purpose of this problem is to test time accuracy and the correctness of the
4838 : : discretization of the viscous term in the Navier-Stokes equation. Example:
4839 : : "problem taylor_green". For more details on the flow, see G.I. Taylor, A.E.
4840 : : Green, "Mechanism of the Production of Small Eddies from Large Ones", Proc.
4841 : : R. Soc. Lond. A 1937 158 499-521; DOI: 10.1098/rspa.1937.0036. Published 3
4842 : : February 1937.)"; }
4843 : : struct expect {
4844 : : static std::string description() { return "string"; }
4845 : : };
4846 : : };
4847 : : using taylor_green =
4848 : : keyword< taylor_green_info, TAOCPP_PEGTL_STRING("taylor_green") >;
4849 : :
4850 : : struct shedding_flow_info {
4851 : : using code = Code< F >;
4852 : : static std::string name() { return "Shedding flow over triangular wedge"; }
4853 : : static std::string shortDescription() { return
4854 : : "Select the Shedding flow test problem "; }
4855 : : static std::string longDescription() { return
4856 : : R"(This keyword is used to select the Shedding flow test problem. It
4857 : : describe a quasi-2D inviscid flow over a triangular wedge in tetrahedron
4858 : : grid. The purpose of this test problem is to test the capability of DG
4859 : : scheme for retaining the shape of vortices and also different error
4860 : : indicator behavior for this external flow problem when p-adaptive DG scheme
4861 : : is applied. Example: "problem shedding_flow".)"; }
4862 : : struct expect {
4863 : : static std::string description() { return "string"; }
4864 : : };
4865 : : };
4866 : : using shedding_flow =
4867 : : keyword< shedding_flow_info, TAOCPP_PEGTL_STRING("shedding_flow") >;
4868 : :
4869 : : struct sod_shocktube_info {
4870 : : using code = Code< H >;
4871 : : static std::string name() { return "Sod shock-tube"; }
4872 : : static std::string shortDescription() { return
4873 : : "Select the Sod shock-tube test problem "; }
4874 : : static std::string longDescription() { return
4875 : : R"(This keyword is used to select the Sod shock-tube test problem. The
4876 : : purpose of this test problem is to test the correctness of the
4877 : : approximate Riemann solver and its shock and interface capturing
4878 : : capabilities. Example: "problem sod_shocktube". For more details, see
4879 : : G. A. Sod, "A Survey of Several Finite Difference Methods for Systems of
4880 : : Nonlinear Hyperbolic Conservation Laws", J. Comput. Phys., 27 (1978)
4881 : : 1–31.)"; }
4882 : : struct expect {
4883 : : static std::string description() { return "string"; }
4884 : : };
4885 : : };
4886 : : using sod_shocktube =
4887 : : keyword< sod_shocktube_info, TAOCPP_PEGTL_STRING("sod_shocktube") >;
4888 : :
4889 : : struct sod_rotated_shocktube_info {
4890 : : using code = Code< O >;
4891 : : static std::string name() { return "Rotated Sod shock-tube"; }
4892 : : static std::string shortDescription() { return
4893 : : "Select the rotated Sod shock-tube test problem "; }
4894 : : static std::string longDescription() { return
4895 : : R"(This keyword is used to select the rotated Sod shock-tube test problem.
4896 : : This the same as Sod shocktube but the geometry is rotated about X, Y, Z
4897 : : each by 45 degrees (in that order) so that none of the domain boundary align
4898 : : with any of the coordinate directions. The purpose of this test problem is
4899 : : to test the correctness of the approximate Riemann solver and its shock and
4900 : : interface capturing capabilities in an arbitrarily oriented geometry.
4901 : : Example: "problem rotated_sod_shocktube". For more details on the Sod
4902 : : problem, see G. A. Sod, "A Survey of Several Finite Difference Methods for
4903 : : Systems of Nonlinear Hyperbolic Conservation Laws", J. Comput. Phys., 27
4904 : : (1978) 1–31.)"; }
4905 : : struct expect {
4906 : : static std::string description() { return "string"; }
4907 : : };
4908 : : };
4909 : : using rotated_sod_shocktube =
4910 : : keyword< sod_rotated_shocktube_info,
4911 : : TAOCPP_PEGTL_STRING("rotated_sod_shocktube") >;
4912 : :
4913 : : struct sedov_blastwave_info {
4914 : : using code = Code< B >;
4915 : : static std::string name() { return "Sedov blast-wave"; }
4916 : : static std::string shortDescription() { return
4917 : : "Select the Sedov blast-wave test problem "; }
4918 : : static std::string longDescription() { return
4919 : : R"(This keyword is used to select the Sedov blast-wave test problem. The
4920 : : purpose of this test problem is to test the correctness of the
4921 : : approximate Riemann solver and its strong shock and interface capturing
4922 : : capabilities. Example: "problem sedov_blastwave".)"; }
4923 : : struct expect {
4924 : : static std::string description() { return "string"; }
4925 : : };
4926 : : };
4927 : : using sedov_blastwave =
4928 : : keyword< sedov_blastwave_info, TAOCPP_PEGTL_STRING("sedov_blastwave") >;
4929 : :
4930 : : struct interface_advection_info {
4931 : : using code = Code< I >;
4932 : : static std::string name() { return "Interface advection"; }
4933 : : static std::string shortDescription() { return
4934 : : "Select the interface advection test problem "; }
4935 : : static std::string longDescription() { return
4936 : : R"(This keyword is used to select the interface advection test problem. The
4937 : : purpose of this test problem is to test the well-balancedness of the
4938 : : multi-material discretization and its interface capturing
4939 : : capabilities. Example: "problem interface_advection".)"; }
4940 : : struct expect {
4941 : : static std::string description() { return "string"; }
4942 : : };
4943 : : };
4944 : : using interface_advection =
4945 : : keyword< interface_advection_info,
4946 : : TAOCPP_PEGTL_STRING("interface_advection") >;
4947 : :
4948 : : struct gauss_hump_compflow_info {
4949 : : using code = Code< A >;
4950 : : static std::string name()
4951 : : { return "Advection of 2D Gaussian hump for Euler equations"; }
4952 : : static std::string shortDescription()
4953 : : { return "Select advection of 2D Gaussian hump test problem"; }
4954 : : static std::string longDescription() { return
4955 : : R"(This keyword is used to select the advection of 2D Gaussian hump test
4956 : : problem. The initial and boundary conditions are specified to set up the
4957 : : test problem suitable to exercise and test the advection terms of the
4958 : : Euler equations. The baseline of the density distribution in this testcase
4959 : : is 1 instead of 0 in gauss_hump_transport which enables it to be the
4960 : : regression testcase for p-adaptive DG scheme. Example: "problem
4961 : : gauss_hump_compflow".)"; }
4962 : : struct expect {
4963 : : static std::string description() { return "string"; }
4964 : : };
4965 : : };
4966 : : using gauss_hump_compflow = keyword< gauss_hump_compflow_info,
4967 : : TAOCPP_PEGTL_STRING("gauss_hump_compflow") >;
4968 : :
4969 : : struct waterair_shocktube_info {
4970 : : using code = Code< W >;
4971 : : static std::string name() { return "Water-air shock-tube"; }
4972 : : static std::string shortDescription() { return
4973 : : "Select the water-air shock-tube test problem "; }
4974 : : static std::string longDescription() { return
4975 : : R"(This keyword is used to select the Water-air shock-tube test problem. The
4976 : : purpose of this test problem is to test the correctness of the
4977 : : multi-material pressure relaxation procedure and its interface capturing
4978 : : capabilities. Example: "problem waterair_shocktube". For more details, see
4979 : : Chiapolino, A., Saurel, R., & Nkonga, B. (2017). Sharpening diffuse
4980 : : interfaces with compressible fluids on unstructured meshes. Journal of
4981 : : Computational Physics, 340, 389-417.)"; }
4982 : : struct expect {
4983 : : static std::string description() { return "string"; }
4984 : : };
4985 : : };
4986 : : using waterair_shocktube =
4987 : : keyword< waterair_shocktube_info, TAOCPP_PEGTL_STRING("waterair_shocktube") >;
4988 : :
4989 : : struct shock_hebubble_info {
4990 : : using code = Code< E >;
4991 : : static std::string name() { return "Shock He-bubble problem"; }
4992 : : static std::string shortDescription() { return
4993 : : "Select the shock He-bubble test problem "; }
4994 : : static std::string longDescription() { return
4995 : : R"(This keyword is used to select the shock He-bubble test problem. The
4996 : : purpose of this test problem is to test the correctness of the
4997 : : multi-material algorithm and its shock-interface interaction
4998 : : capabilities. Example: "problem shock_hebubble". For more details, see
4999 : : Quirk, J. J., & Karni, S. (1996). On the dynamics of a shock–bubble
5000 : : interaction. Journal of Fluid Mechanics, 318, 129-163.)"; }
5001 : : struct expect {
5002 : : static std::string description() { return "string"; }
5003 : : };
5004 : : };
5005 : : using shock_hebubble =
5006 : : keyword< shock_hebubble_info, TAOCPP_PEGTL_STRING("shock_hebubble") >;
5007 : :
5008 : : struct underwater_ex_info {
5009 : : using code = Code< D >;
5010 : : static std::string name() { return "Underwater explosion problem"; }
5011 : : static std::string shortDescription() { return
5012 : : "Select the underwater explosion test problem "; }
5013 : : static std::string longDescription() { return
5014 : : R"(This keyword is used to select the underwater explosion test problem. The
5015 : : purpose of this test problem is to test the correctness of the
5016 : : multi-material algorithm and its interface capturing capabilities in the
5017 : : presence of strong shocks and large deformations.
5018 : : Example: "problem underwater_ex". For more details, see
5019 : : Chiapolino, A., Saurel, R., & Nkonga, B. (2017). Sharpening diffuse
5020 : : interfaces with compressible fluids on unstructured meshes. Journal of
5021 : : Computational Physics, 340, 389-417.)"; }
5022 : : struct expect {
5023 : : static std::string description() { return "string"; }
5024 : : };
5025 : : };
5026 : : using underwater_ex =
5027 : : keyword< underwater_ex_info, TAOCPP_PEGTL_STRING("underwater_ex") >;
5028 : :
5029 : : struct problem_info {
5030 : : using code = Code< t >;
5031 : : static std::string name() { return "Test problem"; }
5032 : : static std::string shortDescription() { return
5033 : : "Specify problem configuration for a partial differential equation solver";
5034 : : }
5035 : : static std::string longDescription() { return
5036 : : R"(This keyword is used to specify the problem configuration for a partial
5037 : : differential equation solver in the input file.)";
5038 : : }
5039 : : struct expect {
5040 : : static std::string description() { return "string"; }
5041 : : static std::string choices() {
5042 : : return '\'' + user_defined::string() + "\' | \'"
5043 : : + shear_diff::string() + "\' | \'"
5044 : : + slot_cyl::string() + "\' | \'"
5045 : : + gauss_hump::string() + "\' | \'"
5046 : : + cyl_advect::string() + "\' | \'"
5047 : : + cyl_vortex::string() + "\' | \'"
5048 : : + vortical_flow::string() + "\' | \'"
5049 : : + nl_energy_growth::string() + "\' | \'"
5050 : : + rayleigh_taylor::string() + "\' | \'"
5051 : : + taylor_green::string() + "\' | \'"
5052 : : + sod_shocktube::string() + "\' | \'"
5053 : : + rotated_sod_shocktube::string() + "\' | \'"
5054 : : + interface_advection::string() + "\' | \'"
5055 : : + gauss_hump_compflow::string() + '\'';
5056 : : }
5057 : : };
5058 : : };
5059 : : using problem = keyword< problem_info, TAOCPP_PEGTL_STRING("problem") >;
5060 : :
5061 : : struct navierstokes_info {
5062 : : using code = Code< N >;
5063 : : static std::string name() { return "Navier-Stokes"; }
5064 : : static std::string shortDescription() { return "Specify the Navier-Stokes "
5065 : : "(viscous) compressible flow physics configuration"; }
5066 : : static std::string longDescription() { return
5067 : : R"(This keyword is used to select the Navier-Stokes (viscous) compressible
5068 : : flow physics configuration. Example: "compflow physics navierstokes end")";
5069 : : }
5070 : : struct expect {
5071 : : static std::string description() { return "string"; }
5072 : : };
5073 : : };
5074 : : using navierstokes =
5075 : : keyword< navierstokes_info, TAOCPP_PEGTL_STRING("navierstokes") >;
5076 : :
5077 : : struct euler_info {
5078 : : using code = Code< E >;
5079 : : static std::string name() { return "Euler"; }
5080 : : static std::string shortDescription() { return "Specify the Euler (inviscid) "
5081 : : "compressible flow physics configuration"; }
5082 : : static std::string longDescription() { return
5083 : : R"(This keyword is used to select the Euler (inviscid) compressible
5084 : : flow physics configuration. Example: "compflow physics euler end")";
5085 : : }
5086 : : struct expect {
5087 : : static std::string description() { return "string"; }
5088 : : };
5089 : : };
5090 : : using euler = keyword< euler_info, TAOCPP_PEGTL_STRING("euler") >;
5091 : :
5092 : : struct veleq_info {
5093 : : using code = Code< V >;
5094 : : static std::string name() { return "Velocity equilibrium"; }
5095 : : static std::string shortDescription() { return "Specify the multi-material "
5096 : : " compressible flow with velocity equilibrium as physics configuration"; }
5097 : : static std::string longDescription() { return
5098 : : R"(This keyword is used to select a compressible flow algorithm as physics
5099 : : configuration designed for multiple materials assuming velocity equailibrium
5100 : : (single velocity). Example: "multimat physics veleq end")";
5101 : : }
5102 : : struct expect {
5103 : : static std::string description() { return "string"; }
5104 : : };
5105 : : };
5106 : : using veleq = keyword< veleq_info, TAOCPP_PEGTL_STRING("veleq") >;
5107 : :
5108 : : struct advection_info {
5109 : : using code = Code< A >;
5110 : : static std::string name() { return "Advection"; }
5111 : : static std::string shortDescription() { return
5112 : : "Specify the advection physics configuration for a PDE "; }
5113 : : static std::string longDescription() { return
5114 : : R"(This keyword is used to select the advection physics configuration for a
5115 : : PDE. Example: "transport physics advection end")";
5116 : : }
5117 : : struct expect {
5118 : : static std::string description() { return "string"; }
5119 : : };
5120 : : };
5121 : : using advection = keyword< advection_info, TAOCPP_PEGTL_STRING("advection") >;
5122 : :
5123 : : struct advdiff_info {
5124 : : using code = Code< D >;
5125 : : static std::string name() { return "Advection + diffusion"; }
5126 : : static std::string shortDescription() { return
5127 : : "Specify the advection + diffusion physics configuration for a PDE "; }
5128 : : static std::string longDescription() { return
5129 : : R"(This keyword is used to select the advection +diffusion physics
5130 : : configuration for a PDE. Example: "transport physics advdiff end")";
5131 : : }
5132 : : struct expect {
5133 : : static std::string description() { return "string"; }
5134 : : };
5135 : : };
5136 : : using advdiff = keyword< advdiff_info, TAOCPP_PEGTL_STRING("advdiff") >;
5137 : :
5138 : : struct physics_info {
5139 : : using code = Code< p >;
5140 : : static std::string name() { return "Physics configuration"; }
5141 : : static std::string shortDescription() { return
5142 : : "Specify the physics configuration for a system of PDEs"; }
5143 : : static std::string longDescription() { return
5144 : : R"(This keyword is used to select the physics configuration for a particular
5145 : : PDE system. Example: "physics navierstokes", which selects the Navier-Stokes
5146 : : equations for solving viscous compressible flow, given within the
5147 : : compflow ... end block. Valid options depend on the given block the keyword
5148 : : is used.)"; }
5149 : : struct expect {
5150 : : static std::string description() { return "string"; }
5151 : : static std::string choices() {
5152 : : return '\'' + advection::string() + "\' | \'"
5153 : : + advdiff::string() + "\' | \'"
5154 : : + navierstokes::string() + "\' | \'"
5155 : : + euler::string() + '\'';
5156 : : }
5157 : : };
5158 : : };
5159 : : using physics = keyword< physics_info, TAOCPP_PEGTL_STRING("physics") >;
5160 : :
5161 : : struct pde_diffusivity_info {
5162 : : static std::string name() { return "diffusivity"; }
5163 : : static std::string shortDescription() { return
5164 : : R"(Set PDE parameter(s) diffusivity)"; }
5165 : : static std::string longDescription() { return
5166 : : R"(This keyword is used to specify a vector of real numbers used to
5167 : : parameterize a system of partial differential equations. Example:
5168 : : "diffusivity 5.0 2.0 3.0 end". The length of the vector depends on the
5169 : : particular type of PDE system and is controlled by the preceding keyword
5170 : : 'ncomp'.)"; }
5171 : : struct expect {
5172 : : using type = tk::real;
5173 : : static std::string description() { return "real(s)"; }
5174 : : };
5175 : : };
5176 : : using pde_diffusivity =
5177 : : keyword< pde_diffusivity_info, TAOCPP_PEGTL_STRING("diffusivity") >;
5178 : :
5179 : : struct pde_lambda_info {
5180 : : static std::string name() { return "lambda"; }
5181 : : static std::string shortDescription() { return
5182 : : R"(Set PDE parameter(s) lambda)"; }
5183 : : static std::string longDescription() { return
5184 : : R"(This keyword is used to specify a vector of real numbers used to
5185 : : parameterize a system of partial differential equations. Example:
5186 : : "lambda 5.0 2.0 3.0 end". The length of the vector depends on the particular
5187 : : type of PDE system and is controlled by the preceding keyword 'ncomp'.)"; }
5188 : : struct expect {
5189 : : using type = tk::real;
5190 : : static std::string description() { return "real(s)"; }
5191 : : };
5192 : : };
5193 : : using pde_lambda = keyword< pde_lambda_info, TAOCPP_PEGTL_STRING("lambda") >;
5194 : :
5195 : : struct pde_u0_info {
5196 : : static std::string name() { return "u0"; }
5197 : : static std::string shortDescription() { return
5198 : : R"(Set PDE parameter(s) u0)"; }
5199 : : static std::string longDescription() { return
5200 : : R"(This keyword is used to specify a vector of real numbers used to
5201 : : parameterize a system of partial differential equations. Example:
5202 : : "u0 5.0 2.0 3.0 end". The length of the vector depends on the particular
5203 : : type of PDE system and is controlled by the preceding keyword 'ncomp'.)"; }
5204 : : struct expect {
5205 : : using type = tk::real;
5206 : : static std::string description() { return "real(s)"; }
5207 : : };
5208 : : };
5209 : : using pde_u0 = keyword< pde_u0_info, TAOCPP_PEGTL_STRING("u0") >;
5210 : :
5211 : : struct pde_alpha_info {
5212 : : static std::string name() { return "alpha"; }
5213 : : static std::string shortDescription() { return
5214 : : R"(Set PDE parameter(s) alpha)"; }
5215 : : static std::string longDescription() { return
5216 : : R"(This keyword is used to specify a real number used to
5217 : : parameterize a system of partial differential equations. Example:
5218 : : "alpha 5.0".)"; }
5219 : : struct expect {
5220 : : using type = tk::real;
5221 : : static std::string description() { return "real"; }
5222 : : };
5223 : : };
5224 : : using pde_alpha = keyword< pde_alpha_info, TAOCPP_PEGTL_STRING("alpha") >;
5225 : :
5226 : : struct pde_beta_info {
5227 : : static std::string name() { return "beta"; }
5228 : : static std::string shortDescription() { return
5229 : : R"(Set PDE parameter(s) beta)"; }
5230 : : static std::string longDescription() { return
5231 : : R"(This keyword is used to specify a real number used to
5232 : : parameterize a system of partial differential equations. Example:
5233 : : "beta 5.0".)"; }
5234 : : struct expect {
5235 : : using type = tk::real;
5236 : : static std::string description() { return "real"; }
5237 : : };
5238 : : };
5239 : : using pde_beta = keyword< pde_beta_info, TAOCPP_PEGTL_STRING("beta") >;
5240 : :
5241 : : struct pde_p0_info {
5242 : : static std::string name() { return "p0"; }
5243 : : static std::string shortDescription() { return
5244 : : R"(Set PDE parameter(s) p0)"; }
5245 : : static std::string longDescription() { return
5246 : : R"(This keyword is used to specify a real number used to
5247 : : parameterize a system of partial differential equations. Example:
5248 : : "p0 10.0".)"; }
5249 : : struct expect {
5250 : : using type = tk::real;
5251 : : static std::string description() { return "real"; }
5252 : : };
5253 : : };
5254 : : using pde_p0 = keyword< pde_p0_info, TAOCPP_PEGTL_STRING("p0") >;
5255 : :
5256 : : // nonlinear energy parameters here
5257 : : struct pde_betax_info {
5258 : : static std::string name() { return "betax"; }
5259 : : static std::string shortDescription() { return
5260 : : R"(Set PDE parameter(s) betax)"; }
5261 : : static std::string longDescription() { return
5262 : : R"(This keyword is used to specify a real number used to
5263 : : parameterize a system of partial differential equations. Example:
5264 : : "betax 1.0".)"; }
5265 : : struct expect {
5266 : : using type = tk::real;
5267 : : static std::string description() { return "real"; }
5268 : : };
5269 : : };
5270 : : using pde_betax = keyword< pde_betax_info, TAOCPP_PEGTL_STRING("betax") >;
5271 : :
5272 : : struct pde_betay_info {
5273 : : static std::string name() { return "betay"; }
5274 : : static std::string shortDescription() { return
5275 : : R"(Set PDE parameter(s) betay)"; }
5276 : : static std::string longDescription() { return
5277 : : R"(This keyword is used to specify a real number used to
5278 : : parameterize a system of partial differential equations. Example:
5279 : : "betay 0.75".)"; }
5280 : : struct expect {
5281 : : using type = tk::real;
5282 : : static std::string description() { return "real"; }
5283 : : };
5284 : : };
5285 : : using pde_betay = keyword< pde_betay_info, TAOCPP_PEGTL_STRING("betay") >;
5286 : :
5287 : : struct pde_betaz_info {
5288 : : static std::string name() { return "betaz"; }
5289 : : static std::string shortDescription() { return
5290 : : R"(Set PDE parameter(s) betaz)"; }
5291 : : static std::string longDescription() { return
5292 : : R"(This keyword is used to specify a real number used to
5293 : : parameterize a system of partial differential equations. Example:
5294 : : "betaz 0.5".)"; }
5295 : : struct expect {
5296 : : using type = tk::real;
5297 : : static std::string description() { return "real"; }
5298 : : };
5299 : : };
5300 : : using pde_betaz = keyword< pde_betaz_info, TAOCPP_PEGTL_STRING("betaz") >;
5301 : :
5302 : : struct pde_ce_info {
5303 : : static std::string name() { return "ce"; }
5304 : : static std::string shortDescription() { return
5305 : : R"(Set PDE parameter(s) ce)"; }
5306 : : static std::string longDescription() { return
5307 : : R"(This keyword is used to specify a real number used to parameterize the
5308 : : Euler equations solving the manufactured solution test case "non-linear
5309 : : energy growth". Example: "ce -1.0". For more information on the test case see
5310 : : Waltz, et. al, "Manufactured solutions for the three-dimensional Euler
5311 : : equations with relevance to Inertial Confinement Fusion", Journal of
5312 : : Computational Physics 267 (2014) 196-209.)"; }
5313 : : struct expect {
5314 : : using type = tk::real;
5315 : : static std::string description() { return "real"; }
5316 : : };
5317 : : };
5318 : : using pde_ce = keyword< pde_ce_info, TAOCPP_PEGTL_STRING("ce") >;
5319 : :
5320 : : struct pde_kappa_info {
5321 : : static std::string name() { return "kappa"; }
5322 : : static std::string shortDescription() { return
5323 : : R"(Set PDE parameter(s) kappa)"; }
5324 : : static std::string longDescription() { return
5325 : : R"(This keyword is used to specify a real number used to
5326 : : parameterize a system of partial differential equations. Example:
5327 : : "kappa 0.8")"; }
5328 : : struct expect {
5329 : : using type = tk::real;
5330 : : static std::string description() { return "real"; }
5331 : : };
5332 : : };
5333 : : using pde_kappa = keyword< pde_kappa_info, TAOCPP_PEGTL_STRING("kappa") >;
5334 : :
5335 : : struct pde_r0_info {
5336 : : static std::string name() { return "r0"; }
5337 : : static std::string shortDescription() { return
5338 : : R"(Set PDE parameter(s) r0)"; }
5339 : : static std::string longDescription() { return
5340 : : R"(This keyword is used to specify a real number used to parameterize the
5341 : : Euler equations solving the manufactured solution test case "non-linear
5342 : : energy growth". Example: "r0 2.0". For more information on the test case see
5343 : : Waltz, et. al, "Manufactured solutions for the three-dimensional Euler
5344 : : equations with relevance to Inertial Confinement Fusion", Journal of
5345 : : Computational Physics 267 (2014) 196-209.)"; }
5346 : : struct expect {
5347 : : using type = tk::real;
5348 : : static std::string description() { return "real"; }
5349 : : };
5350 : : };
5351 : : using pde_r0 = keyword< pde_r0_info, TAOCPP_PEGTL_STRING("r0") >;
5352 : :
5353 : : struct ctau_info {
5354 : : static std::string name() { return "ctau"; }
5355 : : static std::string shortDescription() { return
5356 : : R"(Set FCT mass diffusion coefficient, ctau)"; }
5357 : : static std::string longDescription() { return
5358 : : R"(This keyword is used to set the mass diffusion coefficient used in
5359 : : flux-corrected transport, used for integrating transport equations. Example:
5360 : : "ctau 1.0".)"; }
5361 : : struct expect {
5362 : : using type = tk::real;
5363 : : static constexpr type lower = 0.0;
5364 : : static constexpr type upper = 1.0;
5365 : : static std::string description() { return "real"; }
5366 : : static std::string choices() {
5367 : : return "real between [" + std::to_string(lower) + "..." +
5368 : : std::to_string(upper) + "]";
5369 : : }
5370 : : };
5371 : : };
5372 : : using ctau = keyword< ctau_info, TAOCPP_PEGTL_STRING("ctau") >;
5373 : :
5374 : : struct fcteps_info {
5375 : : static std::string name() { return "Small number for FCT"; }
5376 : : static std::string shortDescription() { return
5377 : : R"(A number that is considered small enough for FCT)"; }
5378 : : static std::string longDescription() { return
5379 : : R"(This keyword is used to set the epsilon (a small number) below which FCT
5380 : : quantities are considered small enough to be treated as zero. Setting this
5381 : : number to be somewhat larger than the machine zero, e.g., 1.0e-15, helps
5382 : : ignoring some noise that otherwise could contaminate the solution.)"; }
5383 : : struct expect {
5384 : : using type = tk::real;
5385 : : static constexpr type lower = 0.0;
5386 : : static constexpr type upper = 1.0;
5387 : : static std::string description() { return "real"; }
5388 : : static std::string choices() {
5389 : : return "real between [" + std::to_string(lower) + "..." +
5390 : : std::to_string(upper) + "]";
5391 : : }
5392 : : };
5393 : : };
5394 : : using fcteps = keyword< fcteps_info, TAOCPP_PEGTL_STRING("fcteps") >;
5395 : :
5396 : : struct cweight_info {
5397 : : static std::string name() { return "cweight"; }
5398 : : static std::string shortDescription() { return
5399 : : R"(Set value for central linear weight used by WENO, cweight)"; }
5400 : : static std::string longDescription() { return
5401 : : R"(This keyword is used to set the central linear weight used for the
5402 : : central stencil in the Weighted Essentially Non-Oscillatory (WENO) limiter
5403 : : for discontinuous Galerkin (DG) methods. Example:
5404 : : "cweight 10.0".)"; }
5405 : : struct expect {
5406 : : using type = tk::real;
5407 : : static constexpr type lower = 1.0;
5408 : : static constexpr type upper = 1000.0;
5409 : : static std::string description() { return "real"; }
5410 : : static std::string choices() {
5411 : : return "real between [" + std::to_string(lower) + "..." +
5412 : : std::to_string(upper) + "]";
5413 : : }
5414 : : };
5415 : : };
5416 : : using cweight = keyword< cweight_info, TAOCPP_PEGTL_STRING("cweight") >;
5417 : :
5418 : : struct sideset_info {
5419 : : static std::string name() { return "sideset"; }
5420 : : static std::string shortDescription() { return
5421 : : "Specify configuration for setting BC on a side set";
5422 : : }
5423 : : static std::string longDescription() { return
5424 : : R"(This keyword is used to specify boundary conditions on a side set for a
5425 : : solving partial differential equation.)";
5426 : : }
5427 : : struct expect {
5428 : : using type = std::string;
5429 : : static std::string description() { return "strings"; }
5430 : : };
5431 : : };
5432 : : using sideset = keyword< sideset_info, TAOCPP_PEGTL_STRING("sideset") >;
5433 : :
5434 : : struct fn_info {
5435 : : static std::string name() { return "User-defined function"; }
5436 : : static std::string shortDescription() { return
5437 : : "Specify a discrete user-defined function"; }
5438 : : static std::string longDescription() { return
5439 : : R"(This keyword is used to specify a user-defined function with discrete
5440 : : points, listed between a fn ... end block.)"; }
5441 : : struct expect {
5442 : : using type = tk::real;
5443 : : static std::string description() { return "real(s)"; }
5444 : : };
5445 : : };
5446 : : using fn = keyword< fn_info, TAOCPP_PEGTL_STRING("fn") >;
5447 : :
5448 : : struct bc_dirichlet_info {
5449 : : static std::string name() { return "Dirichlet boundary condition"; }
5450 : : static std::string shortDescription() { return
5451 : : "Start configuration block describing Dirichlet boundary conditions"; }
5452 : : static std::string longDescription() { return
5453 : : R"(This keyword is used to introduce an bc_dirichlet ... end block, used to
5454 : : specify the configuration for setting Dirichlet boundary conditions (BC) for
5455 : : a partial differential equation. This keyword is used to list multiple side
5456 : : sets on which a prescribed Dirichlet BC is then applied. Such prescribed BCs
5457 : : at each point in space and time are evaluated using a built-in function,
5458 : : e.g., using the method of manufactured solutions.
5459 : : Keywords allowed in a bc_dirichlet ... end block: )" + std::string("\'")
5460 : : + sideset::string() + "\'. "
5461 : : + R"(For an example bc_dirichlet ... end block, see
5462 : : doc/html/inicter_example_shear.html.)";
5463 : : }
5464 : : };
5465 : : using bc_dirichlet =
5466 : : keyword< bc_dirichlet_info, TAOCPP_PEGTL_STRING("bc_dirichlet") >;
5467 : :
5468 : : struct bc_sym_info {
5469 : : static std::string name() { return "Symmetry boundary condition"; }
5470 : : static std::string shortDescription() { return
5471 : : "Start configuration block describing symmetry boundary conditions"; }
5472 : : static std::string longDescription() { return
5473 : : R"(This keyword is used to introduce an bc_sym ... end block, used to
5474 : : specify the configuration for setting symmetry boundary conditions for a
5475 : : partial differential equation. Keywords allowed in a bc_sym ... end
5476 : : block: )" + std::string("\'")
5477 : : + sideset::string() + "\'. "
5478 : : + R"(For an example bc_sym ... end block, see
5479 : : doc/html/inicter_example_gausshump.html.)";
5480 : : }
5481 : : };
5482 : : using bc_sym =
5483 : : keyword< bc_sym_info, TAOCPP_PEGTL_STRING("bc_sym") >;
5484 : :
5485 : : struct point_info {
5486 : : static std::string name() { return "point"; }
5487 : : static std::string shortDescription() { return "Specify a point"; }
5488 : : static std::string longDescription() { return
5489 : : R"(This keyword is used to specify a point, used, e.g., in specifying a
5490 : : point in 3D space for setting a stagnation (velocity vector = 0). Example
5491 : : specification: 'point 0.0 0.1 0.2 end')";
5492 : : }
5493 : : struct expect {
5494 : : using type = tk::real;
5495 : : static std::string description() { return "3 reals"; }
5496 : : };
5497 : : };
5498 : : using point = keyword< point_info, TAOCPP_PEGTL_STRING("point") >;
5499 : :
5500 : : struct radius_info {
5501 : : static std::string name() { return "radius"; }
5502 : : static std::string shortDescription() { return "Specify a radius"; }
5503 : : static std::string longDescription() { return
5504 : : R"(This keyword is used to specify a radius, used, e.g., in specifying a
5505 : : point in 3D space for setting a stagnation (velocity vector = 0). Example
5506 : : specification: 'radius 1.0e-5')";
5507 : : }
5508 : : struct expect {
5509 : : using type = tk::real;
5510 : : static constexpr type lower = 0.0;
5511 : : static std::string description() { return "real"; }
5512 : : };
5513 : : };
5514 : : using radius = keyword< radius_info, TAOCPP_PEGTL_STRING("radius") >;
5515 : :
5516 : : struct sponge_info {
5517 : : static std::string name() { return "Sponge boundary"; }
5518 : : static std::string shortDescription() { return
5519 : : "Start configuration block describing a sponge boundary"; }
5520 : : static std::string longDescription() { return
5521 : : R"(This keyword is used to introduce an sponge ... end block, used to
5522 : : specify the configuration for applying sponge parameters on boundaries.
5523 : : Keywords allowed in a sponge ... end block: )" + std::string("\'")
5524 : : + sideset::string() + "\', \'"
5525 : : + velocity::string() + "\', \'"
5526 : : + pressure::string() + "\'.";
5527 : : }
5528 : : };
5529 : : using sponge = keyword< sponge_info, TAOCPP_PEGTL_STRING("sponge") >;
5530 : :
5531 : : struct bc_stag_info {
5532 : : static std::string name() { return "Stagnation boundary condition"; }
5533 : : static std::string shortDescription() { return
5534 : : "Start configuration block describing stagnation boundary conditions"; }
5535 : : static std::string longDescription() { return
5536 : : R"(This keyword is used to introduce an bc_stag ... end block, used to
5537 : : specify the configuration for setting stagnation boundary conditions for a
5538 : : partial differential equation. Keywords allowed in a bc_stag ... end
5539 : : block: )" + std::string("\'")
5540 : : + point::string() + "\', \'"
5541 : : + radius::string() + "\'.";
5542 : : }
5543 : : };
5544 : : using bc_stag = keyword< bc_stag_info, TAOCPP_PEGTL_STRING("bc_stag") >;
5545 : :
5546 : : struct bc_skip_info {
5547 : : static std::string name() { return "Skip boundary condition"; }
5548 : : static std::string shortDescription() { return
5549 : : "Start configuration block describing skip boundary conditions"; }
5550 : : static std::string longDescription() { return
5551 : : R"(This keyword is used to introduce an bc_skip ... end block, used to
5552 : : specify the configuration for setting 'skip' boundary conditions for a
5553 : : partial differential equation. If a mesh point falls into a skip region,
5554 : : configured by a point and a radius, any application of boundary conditions
5555 : : on those points will be skipped. Keywords allowed in a bc_skip ... end
5556 : : block: )" + std::string("\'")
5557 : : + point::string() + "\', \'"
5558 : : + radius::string() + "\'. ";
5559 : : }
5560 : : };
5561 : : using bc_skip = keyword< bc_skip_info, TAOCPP_PEGTL_STRING("bc_skip") >;
5562 : :
5563 : : struct bc_inlet_info {
5564 : : static std::string name() { return "Inlet boundary condition"; }
5565 : : static std::string shortDescription() { return
5566 : : "Start configuration block describing inlet boundary conditions"; }
5567 : : static std::string longDescription() { return
5568 : : R"(This keyword is used to introduce an bc_inlet ... end block, used to
5569 : : specify the configuration for setting inlet boundary conditions for a
5570 : : partial differential equation. Keywords allowed in a bc_inlet ... end
5571 : : block: )" + std::string("\'")
5572 : : + sideset::string() + "\'. "
5573 : : + R"(For an example bc_inlet ... end block, see
5574 : : doc/html/inicter_example_gausshump.html.)";
5575 : : }
5576 : : };
5577 : : using bc_inlet =
5578 : : keyword< bc_inlet_info, TAOCPP_PEGTL_STRING("bc_inlet") >;
5579 : :
5580 : : struct bc_outlet_info {
5581 : : static std::string name() { return "Inlet boundary condition"; }
5582 : : static std::string shortDescription() { return
5583 : : "Start configuration block describing outlet boundary conditions"; }
5584 : : static std::string longDescription() { return
5585 : : R"(This keyword is used to introduce an bc_outlet ... end block, used to
5586 : : specify the configuration for setting outlet boundary conditions for a
5587 : : partial differential equation. Keywords allowed in a bc_outlet ... end
5588 : : block: )" + std::string("\'")
5589 : : + sideset::string() + "\'. "
5590 : : + R"(For an example bc_outlet ... end block, see
5591 : : doc/html/inicter_example_gausshump.html.)";
5592 : : }
5593 : : };
5594 : : using bc_outlet =
5595 : : keyword< bc_outlet_info, TAOCPP_PEGTL_STRING("bc_outlet") >;
5596 : :
5597 : : struct bc_farfield_info {
5598 : : static std::string name() { return "Farfield boundary condition"; }
5599 : : static std::string shortDescription() { return
5600 : : "Start configuration block describing farfield boundary conditions"; }
5601 : : static std::string longDescription() { return
5602 : : R"(This keyword is used to introduce a bc_farfield ... end block, used
5603 : : to specify the configuration for setting farfield boundary conditions
5604 : : for the compressible flow equations. Keywords allowed in a bc_farfield
5605 : : ... end block: )" + std::string("\'")
5606 : : + density::string() + "\', \'"
5607 : : + pressure::string() + "\', \'"
5608 : : + velocity::string() + "\', \'"
5609 : : + sideset::string() + "\'. ";
5610 : : }
5611 : : };
5612 : : using bc_farfield =
5613 : : keyword< bc_farfield_info, TAOCPP_PEGTL_STRING("bc_farfield") >;
5614 : :
5615 : : struct bc_extrapolate_info {
5616 : : static std::string name() { return "Extrapolation boundary condition"; }
5617 : : static std::string shortDescription() { return
5618 : : "Start configuration block describing Extrapolation boundary conditions"; }
5619 : : static std::string longDescription() { return
5620 : : R"(This keyword is used to introduce a bc_extrapolate ... end block, used to
5621 : : specify the configuration for setting extrapolation boundary conditions for a
5622 : : partial differential equation. Keywords allowed in a bc_extrapolate ... end
5623 : : block: )" + std::string("\'")
5624 : : + sideset::string() + "\'. "
5625 : : + R"(For an example bc_extrapolate ... end block, see
5626 : : doc/html/inciter_example_gausshump.html.)";
5627 : : }
5628 : : };
5629 : : using bc_extrapolate =
5630 : : keyword< bc_extrapolate_info, TAOCPP_PEGTL_STRING("bc_extrapolate") >;
5631 : :
5632 : : struct bc_timedep_info {
5633 : : static std::string name() { return "Time dependent boundary condition"; }
5634 : : static std::string shortDescription() { return
5635 : : "Start configuration block describing time dependent boundary conditions"; }
5636 : : static std::string longDescription() { return
5637 : : R"(This keyword is used to introduce a bc_timedep ... end block, used to
5638 : : specify the configuration of time dependent boundary conditions for a
5639 : : partial differential equation. A discrete function in time t in the form of
5640 : : a table with 6 columns (t, pressure(t), density(t), vx(t), vy(t), vz(t)) is
5641 : : expected inside a fn ... end block, specified within the bc_timedep ... end
5642 : : block. Multiple such bc_timedep blocks can be specified for different
5643 : : time dependent BCs on different groups of side sets. Keywords allowed in a
5644 : : bc_timedep ... end block: )"
5645 : : + std::string("\'") + sideset::string() + "\', "
5646 : : + std::string("\'") + fn::string() + "\'. "
5647 : : + R"(For an example bc_timedep ... end block, see
5648 : : tests/regression/inciter/compflow/Euler/TimedepBC/timedep_bc.q.)";
5649 : : }
5650 : : };
5651 : : using bc_timedep =
5652 : : keyword< bc_timedep_info, TAOCPP_PEGTL_STRING("bc_timedep") >;
5653 : :
5654 : : struct id_info {
5655 : : static std::string name() { return "id"; }
5656 : : static std::string shortDescription() { return "ID"; }
5657 : : static std::string longDescription() { return
5658 : : R"(This keyword is used to specify an ID, a positive integer.)";
5659 : : }
5660 : : struct expect {
5661 : : using type = uint64_t;
5662 : : static constexpr type lower = 1;
5663 : : static std::string description() { return "uint"; }
5664 : : };
5665 : : };
5666 : : using id = keyword< id_info, TAOCPP_PEGTL_STRING("id") >;
5667 : :
5668 : : struct prelax_info {
5669 : : static std::string name() { return "Pressure relaxation"; }
5670 : : static std::string shortDescription() { return
5671 : : "Turn multi-material finite pressure relaxation on/off"; }
5672 : : static std::string longDescription() { return
5673 : : R"(This keyword is used to turn finite pressure relaxation between multiple
5674 : : materials on/off. It is used only for the multi-material solver, and has
5675 : : no effect when used for the other PDE types.)";
5676 : : }
5677 : : struct expect {
5678 : : using type = int;
5679 : : static std::string description() { return "string"; }
5680 : : static std::string choices() { return "1 | 0"; }
5681 : : };
5682 : : };
5683 : : using prelax = keyword< prelax_info, TAOCPP_PEGTL_STRING("prelax") >;
5684 : :
5685 : : struct prelax_timescale_info {
5686 : : static std::string name() { return "Pressure relaxation time-scale"; }
5687 : : static std::string shortDescription() { return
5688 : : "Time-scale for multi-material finite pressure relaxation"; }
5689 : : static std::string longDescription() { return
5690 : : R"(This keyword is used to specify the time-scale at which finite pressure
5691 : : relaxation between multiple materials occurs. The default value of 1.0
5692 : : corresponds to a relaxation time of the order of time required for a
5693 : : sound wave to pass through a computational element. It is used only for
5694 : : multimat, and has no effect for the other PDE types.)";
5695 : : }
5696 : : struct expect {
5697 : : using type = tk::real;
5698 : : static constexpr type lower = 0.001;
5699 : : static std::string description() { return "real"; }
5700 : : };
5701 : : };
5702 : : using prelax_timescale = keyword< prelax_timescale_info,
5703 : : TAOCPP_PEGTL_STRING("prelax_timescale") >;
5704 : :
5705 : : struct intsharp_info {
5706 : : static std::string name() { return "Interface sharpening"; }
5707 : : static std::string shortDescription() { return
5708 : : "Turn multi-material interface sharpening on/off"; }
5709 : : static std::string longDescription() { return
5710 : : R"(This keyword is used to turn interface sharpening on/off. It uses the
5711 : : multi-material THINC interface reconstruction.
5712 : : Ref. Pandare A. K., Waltz J., & Bakosi J. (2021) Multi-Material
5713 : : Hydrodynamics with Algebraic Sharp Interface Capturing. Computers &
5714 : : Fluids, doi: https://doi.org/10.1016/j.compfluid.2020.104804. It is used
5715 : : for the multi-material and the transport solver, and has no effect when
5716 : : used for the other PDE types.)";
5717 : : }
5718 : : struct expect {
5719 : : using type = int;
5720 : : static std::string description() { return "string"; }
5721 : : static std::string choices() { return "1 | 0"; }
5722 : : };
5723 : : };
5724 : : using intsharp = keyword< intsharp_info, TAOCPP_PEGTL_STRING("intsharp") >;
5725 : :
5726 : : struct intsharp_param_info {
5727 : : static std::string name() { return "Interface sharpening parameter"; }
5728 : : static std::string shortDescription() { return
5729 : : "Parameter for multi-material interface sharpening"; }
5730 : : static std::string longDescription() { return
5731 : : R"(This keyword is used to specify the parameter for the interface
5732 : : sharpening. This parameter affects how many cells the material interfaces
5733 : : span, after the use of sharpening. It is used for multimat and transport,
5734 : : and has no effect for the other PDE types.)";
5735 : : }
5736 : : struct expect {
5737 : : using type = tk::real;
5738 : : static constexpr type lower = 0.1;
5739 : : static std::string description() { return "real"; }
5740 : : };
5741 : : };
5742 : : using intsharp_param = keyword< intsharp_param_info,
5743 : : TAOCPP_PEGTL_STRING("intsharp_param") >;
5744 : :
5745 : : struct mat_gamma_info {
5746 : : static std::string name() { return "gamma"; }
5747 : : static std::string shortDescription() { return "ratio of specific heats"; }
5748 : : static std::string longDescription() { return
5749 : : R"(This keyword is used to specify the material property, ratio of specific
5750 : : heats.)";
5751 : : }
5752 : : struct expect {
5753 : : using type = tk::real;
5754 : : static constexpr type lower = 0.0;
5755 : : static std::string description() { return "real"; }
5756 : : };
5757 : : };
5758 : : using mat_gamma = keyword< mat_gamma_info, TAOCPP_PEGTL_STRING("gamma") >;
5759 : :
5760 : : struct mat_pstiff_info {
5761 : : static std::string name() { return "pstiff"; }
5762 : : static std::string shortDescription() { return "EoS stiffness parameter"; }
5763 : : static std::string longDescription() { return
5764 : : R"(This keyword is used to specify the material property, stiffness
5765 : : parameter in the stiffened gas equation of state.)";
5766 : : }
5767 : : struct expect {
5768 : : using type = tk::real;
5769 : : static constexpr type lower = 0.0;
5770 : : static std::string description() { return "real"; }
5771 : : };
5772 : : };
5773 : : using mat_pstiff = keyword< mat_pstiff_info, TAOCPP_PEGTL_STRING("pstiff") >;
5774 : :
5775 : : struct mat_mu_info {
5776 : : static std::string name() { return "mu"; }
5777 : : static std::string shortDescription() { return "dynamic viscosity"; }
5778 : : static std::string longDescription() { return
5779 : : R"(This keyword is used to specify the material property, dynamic
5780 : : viscosity.)";
5781 : : }
5782 : : struct expect {
5783 : : using type = tk::real;
5784 : : static constexpr type lower = 0.0;
5785 : : static std::string description() { return "real"; }
5786 : : };
5787 : : };
5788 : : using mat_mu = keyword< mat_mu_info, TAOCPP_PEGTL_STRING("mu") >;
5789 : :
5790 : : struct mat_cv_info {
5791 : : static std::string name() { return "cv"; }
5792 : : static std::string shortDescription() {
5793 : : return "specific heat at constant volume"; }
5794 : : static std::string longDescription() { return
5795 : : R"(This keyword is used to specify the material property, specific heat at
5796 : : constant volume.)";
5797 : : }
5798 : : struct expect {
5799 : : using type = tk::real;
5800 : : static constexpr type lower = 0.0;
5801 : : static std::string description() { return "real"; }
5802 : : };
5803 : : };
5804 : : using mat_cv = keyword< mat_cv_info, TAOCPP_PEGTL_STRING("cv") >;
5805 : :
5806 : : struct mat_k_info {
5807 : : static std::string name() { return "k"; }
5808 : : static std::string shortDescription() { return "heat conductivity"; }
5809 : : static std::string longDescription() { return
5810 : : R"(This keyword is used to specify the material property, heat
5811 : : conductivity.)";
5812 : : }
5813 : : struct expect {
5814 : : using type = tk::real;
5815 : : static constexpr type lower = 0.0;
5816 : : static std::string description() { return "real"; }
5817 : : };
5818 : : };
5819 : : using mat_k = keyword< mat_k_info, TAOCPP_PEGTL_STRING("k") >;
5820 : :
5821 : : struct stiffenedgas_info {
5822 : : static std::string name() { return "Stiffened gas"; }
5823 : : static std::string shortDescription() { return
5824 : : "Select the stiffened gas equation of state"; }
5825 : : static std::string longDescription() { return
5826 : : R"(This keyword is used to select the stiffened gas equation of state.)"; }
5827 : : };
5828 : : using stiffenedgas =
5829 : : keyword< stiffenedgas_info, TAOCPP_PEGTL_STRING("stiffenedgas") >;
5830 : :
5831 : : struct jwl_info {
5832 : : static std::string name() { return "JWL"; }
5833 : : static std::string shortDescription() { return
5834 : : "Select the JWL equation of state"; }
5835 : : static std::string longDescription() { return
5836 : : R"(This keyword is used to select the Jones, Wilkins, Lee equation of
5837 : : state.)"; }
5838 : : };
5839 : : using jwl = keyword< jwl_info, TAOCPP_PEGTL_STRING("jwl") >;
5840 : :
5841 : : struct eos_info {
5842 : : static std::string name() { return "Equation of state"; }
5843 : : static std::string shortDescription() { return
5844 : : "Select equation of state (type)"; }
5845 : : static std::string longDescription() { return
5846 : : R"(This keyword is used to select an equation of state for a material.)"; }
5847 : : struct expect {
5848 : : static std::string description() { return "string"; }
5849 : : static std::string choices() {
5850 : : return '\'' + stiffenedgas::string() + "\' | \'"
5851 : : + jwl::string() + '\'';
5852 : : }
5853 : : };
5854 : : };
5855 : : using eos = keyword< eos_info, TAOCPP_PEGTL_STRING("eos") >;
5856 : :
5857 : : struct material_info {
5858 : : static std::string name() { return "Material properties block"; }
5859 : : static std::string shortDescription() { return
5860 : : "Start configuration block for material properties"; }
5861 : : static std::string longDescription() { return
5862 : : R"(This keyword is used to introduce a material ... end block, used to
5863 : : specify material properties. Keywords allowed in a material ... end
5864 : : block: )" + std::string("\'")
5865 : : + id::string()+ "\', \'"
5866 : : + eos::string()+ "\', \'"
5867 : : + mat_gamma::string()+ "\', \'"
5868 : : + mat_pstiff::string()+ "\', \'"
5869 : : + mat_mu::string()+ "\', \'"
5870 : : + mat_cv::string()+ "\', \'"
5871 : : + mat_k::string() + "\'. "
5872 : : + R"(For an example material ... end block, see
5873 : : doc/html/inicter_example_compflow.html.)";
5874 : : }
5875 : : };
5876 : : using material = keyword< material_info, TAOCPP_PEGTL_STRING("material") >;
5877 : :
5878 : : struct transport_info {
5879 : : static std::string name() { return "Transport"; }
5880 : : static std::string shortDescription() { return
5881 : : "Start configuration block for an transport equation"; }
5882 : : static std::string longDescription() { return
5883 : : R"(This keyword is used to introduce an transport ... end block, used to
5884 : : specify the configuration for a transport equation type. Keywords allowed
5885 : : in an transport ... end block: )" + std::string("\'")
5886 : : + depvar::string() + "\', \'"
5887 : : + ncomp::string() + "\', \'"
5888 : : + problem::string() + "\', \'"
5889 : : + physics::string() + "\', \'"
5890 : : + pde_diffusivity::string() + "\', \'"
5891 : : + pde_lambda::string() + "\', \'"
5892 : : + bc_dirichlet::string() + "\', \'"
5893 : : + bc_sym::string() + "\', \'"
5894 : : + bc_inlet::string() + "\', \'"
5895 : : + bc_outlet::string() + "\', \'"
5896 : : + pde_u0::string() + "\'. "
5897 : : + intsharp::string() + "\', \'"
5898 : : + intsharp_param::string() + "\', \'"
5899 : : + R"(For an example transport ... end block, see
5900 : : doc/html/inicter_example_transport.html.)";
5901 : : }
5902 : : };
5903 : : using transport = keyword< transport_info, TAOCPP_PEGTL_STRING("transport") >;
5904 : :
5905 : : struct compflow_info {
5906 : : static std::string name() { return "Compressible single-material flow"; }
5907 : : static std::string shortDescription() { return
5908 : : "Start configuration block for the compressible flow equations"; }
5909 : : static std::string longDescription() { return
5910 : : R"(This keyword is used to introduce the compflow ... end block, used to
5911 : : specify the configuration for a system of partial differential equations,
5912 : : governing compressible fluid flow. Keywords allowed in an compflow ... end
5913 : : block: )" + std::string("\'")
5914 : : + depvar::string()+ "\', \'"
5915 : : + physics::string() + "\', \'"
5916 : : + problem::string() + "\', \'"
5917 : : + material::string() + "\', \'"
5918 : : + npar::string() + "\', \'"
5919 : : + pde_alpha::string() + "\', \'"
5920 : : + pde_p0::string() + "\', \'"
5921 : : + pde_betax::string() + "\', \'"
5922 : : + pde_betay::string() + "\', \'"
5923 : : + pde_betaz::string() + "\', \'"
5924 : : + pde_beta::string() + "\', \'"
5925 : : + pde_r0::string() + "\', \'"
5926 : : + pde_ce::string() + "\', \'"
5927 : : + pde_kappa::string() + "\', \'"
5928 : : + bc_dirichlet::string() + "\', \'"
5929 : : + bc_sym::string() + "\', \'"
5930 : : + bc_inlet::string() + "\', \'"
5931 : : + bc_outlet::string() + "\', \'"
5932 : : + bc_farfield::string() + "\', \'"
5933 : : + bc_extrapolate::string() + "\'."
5934 : : + bc_timedep::string() + "\'."
5935 : : + R"(For an example compflow ... end block, see
5936 : : doc/html/inicter_example_compflow.html.)";
5937 : : }
5938 : : };
5939 : : using compflow = keyword< compflow_info, TAOCPP_PEGTL_STRING("compflow") >;
5940 : :
5941 : : struct multimat_info {
5942 : : static std::string name() { return "Compressible multi-material flow"; }
5943 : : static std::string shortDescription() { return "Start configuration block "
5944 : : "for the multi-material compressible flow equations"; }
5945 : : static std::string longDescription() { return
5946 : : R"(This keyword is used to introduce the multimat ... end block,
5947 : : used to specify the configuration for a system of partial differential
5948 : : equations, governing multi-material compressible fluid flow. Keywords
5949 : : allowed in a multimat ... end block: )" + std::string("\'")
5950 : : + depvar::string()+ "\', \'"
5951 : : + physics::string() + "\', \'"
5952 : : + problem::string() + "\', \'"
5953 : : + material::string() + "\', \'"
5954 : : + nmat::string() + "\', \'"
5955 : : + prelax::string() + "\', \'"
5956 : : + prelax_timescale::string() + "\', \'"
5957 : : + intsharp::string() + "\', \'"
5958 : : + intsharp_param::string() + "\', \'"
5959 : : + pde_alpha::string() + "\', \'"
5960 : : + pde_p0::string() + "\', \'"
5961 : : + pde_betax::string() + "\', \'"
5962 : : + pde_betay::string() + "\', \'"
5963 : : + pde_betaz::string() + "\', \'"
5964 : : + pde_beta::string() + "\', \'"
5965 : : + pde_r0::string() + "\', \'"
5966 : : + pde_ce::string() + "\', \'"
5967 : : + pde_kappa::string() + "\', \'"
5968 : : + bc_dirichlet::string() + "\', \'"
5969 : : + bc_sym::string() + "\', \'"
5970 : : + bc_inlet::string() + "\', \'"
5971 : : + bc_outlet::string() + "\', \'"
5972 : : + bc_extrapolate::string() + "\'."
5973 : : + R"(For an example multimat ... end block, see
5974 : : doc/html/inicter_example_multimat.html.)";
5975 : : }
5976 : : };
5977 : : using multimat = keyword< multimat_info, TAOCPP_PEGTL_STRING("multimat") >;
5978 : :
5979 : : struct rcb_info {
5980 : : static std::string name() { return "recursive coordinate bisection"; }
5981 : : static std::string shortDescription() { return
5982 : : "Select recursive coordinate bisection mesh partitioner"; }
5983 : : static std::string longDescription() { return
5984 : : R"(This keyword is used to select the recursive coordinate bisection (RCB)
5985 : : mesh partitioner. RCB is a geometry-based partitioner used to distribute an
5986 : : input mesh among processing elements. See
5987 : : Control/Options/PartitioningAlgorithm.hpp for other valid options.)"; }
5988 : : };
5989 : : using rcb = keyword< rcb_info, TAOCPP_PEGTL_STRING("rcb") >;
5990 : :
5991 : : struct rib_info {
5992 : : static std::string name() { return "recursive inertial bisection"; }
5993 : : static std::string shortDescription() { return
5994 : : "Select recursive inertial bisection mesh partitioner"; }
5995 : : static std::string longDescription() { return
5996 : : R"(This keyword is used to select the recursive inertial bisection (RIB)
5997 : : mesh partitioner. RIB is a geometry-based partitioner used to distribute an
5998 : : input mesh among processing elements. See
5999 : : Control/Options/PartitioningAlgorithm.hpp for other valid options.)"; }
6000 : : };
6001 : : using rib = keyword< rib_info, TAOCPP_PEGTL_STRING("rib") >;
6002 : :
6003 : : struct hsfc_info {
6004 : : static std::string name() { return "Hilbert space filling curve"; }
6005 : : static std::string shortDescription() { return
6006 : : "Select Hilbert Space Filling Curve (HSFC) mesh partitioner"; }
6007 : : static std::string longDescription() { return
6008 : : R"(This keyword is used to select the Hilbert Space Filling Curve (HSFC)
6009 : : mesh partitioner. HSFC is a geometry-based partitioner used to distribute an
6010 : : input mesh among processing elements. See
6011 : : Control/Options/PartitioningAlgorithm.hpp for other valid options.)"; }
6012 : : };
6013 : : using hsfc = keyword< hsfc_info, TAOCPP_PEGTL_STRING("hsfc") >;
6014 : :
6015 : : struct mj_info {
6016 : : static std::string name() { return "multi-jagged"; }
6017 : : static std::string shortDescription() { return
6018 : : "Select multi-jagged (MJ) mesh partitioner"; }
6019 : : static std::string longDescription() { return
6020 : : R"(This keyword is used to select the multi-jagged (MJ) mesh partitioner.
6021 : : MJ is a geometry-based partitioner used to distribute an input mesh among
6022 : : processing elements. See
6023 : : Control/Options/PartitioningAlgorithm.hpp for other valid options.)"; }
6024 : : };
6025 : : using mj = keyword< mj_info, TAOCPP_PEGTL_STRING("mj") >;
6026 : :
6027 : : struct phg_info {
6028 : : static std::string name() { return "hypergraph"; }
6029 : : static std::string shortDescription() { return
6030 : : "Select parallel hypergraph mesh partitioner"; }
6031 : : static std::string longDescription() { return
6032 : : R"(This keyword is used to select the parallel hypergraph (PHG)
6033 : : mesh partitioner. PHG is a graph-based partitioner used to distribute an
6034 : : input mesh among processing elements. See
6035 : : Control/Options/PartitioningAlgorithm.hpp for other valid options.)"; }
6036 : : };
6037 : : using phg = keyword< phg_info, TAOCPP_PEGTL_STRING("phg") >;
6038 : :
6039 : : struct algorithm_info {
6040 : : static std::string name() { return "algorithm"; }
6041 : : static std::string shortDescription() { return
6042 : : "Select mesh partitioning algorithm"; }
6043 : : static std::string longDescription() { return
6044 : : R"(This keyword is used to select a mesh partitioning algorithm. See
6045 : : Control/Options/PartitioningAlgorithm.hpp for valid options.)"; }
6046 : : struct expect {
6047 : : static std::string description() { return "string"; }
6048 : : static std::string choices() {
6049 : : return '\'' + rcb::string() + "\' | \'"
6050 : : + rib::string() + "\' | \'"
6051 : : + hsfc::string() + "\' | \'"
6052 : : + mj::string() + "\' | \'"
6053 : : + phg::string() + '\'';
6054 : : }
6055 : : };
6056 : : };
6057 : : using algorithm = keyword< algorithm_info, TAOCPP_PEGTL_STRING("algorithm") >;
6058 : :
6059 : : struct partitioning_info {
6060 : : static std::string name() { return "partitioning"; }
6061 : : static std::string shortDescription() { return
6062 : : "Start configuration block for mesh partitioning"; }
6063 : : static std::string longDescription() { return
6064 : : R"(This keyword is used to introduce a partitioning ... end block, used to
6065 : : specify the configuration for mesh partitioning. Keywords allowed
6066 : : in a partitioning ... end block: )" + std::string("\'")
6067 : : + algorithm::string() + "\'.";
6068 : : }
6069 : : };
6070 : : using partitioning = keyword< partitioning_info, TAOCPP_PEGTL_STRING("partitioning") >;
6071 : :
6072 : : struct move_info {
6073 : : static std::string name() { return "move"; }
6074 : : static std::string shortDescription() { return
6075 : : "Start configuration block configuring surface movement"; }
6076 : : static std::string longDescription() { return
6077 : : R"(This keyword is used to introduce a move ... end block, used to
6078 : : configure surface movement for ALE simulations. Keywords allowed
6079 : : in a move ... end block: )" + std::string("\'")
6080 : : + sideset::string() + "\'.";
6081 : : }
6082 : : };
6083 : : using move = keyword< move_info, TAOCPP_PEGTL_STRING("move") >;
6084 : :
6085 : : struct amr_uniform_info {
6086 : : using code = Code< u >;
6087 : : static std::string name() { return "uniform refine"; }
6088 : : static std::string shortDescription() { return
6089 : : "Select uniform initial mesh refinement"; }
6090 : : static std::string longDescription() { return
6091 : : R"(This keyword is used to select uniform initial mesh refinement.)"; }
6092 : : };
6093 : : using amr_uniform = keyword< amr_uniform_info, TAOCPP_PEGTL_STRING("uniform") >;
6094 : :
6095 : : struct amr_uniform_derefine_info {
6096 : : using code = Code< d >;
6097 : : static std::string name() { return "uniform derefine"; }
6098 : : static std::string shortDescription() { return
6099 : : "Select uniform initial mesh de-refinement"; }
6100 : : static std::string longDescription() { return
6101 : : R"(This keyword is used to select uniform initial mesh de-refinement.)"; }
6102 : : };
6103 : : using amr_uniform_derefine =
6104 : : keyword< amr_uniform_derefine_info, TAOCPP_PEGTL_STRING("uniform_derefine") >;
6105 : :
6106 : : struct amr_initial_conditions_info {
6107 : : using code = Code< i >;
6108 : : static std::string name() { return "initial conditions"; }
6109 : : static std::string shortDescription() { return
6110 : : "Select initial-conditions-based initial mesh refinement"; }
6111 : : static std::string longDescription() { return
6112 : : R"(This keyword is used to select initial-conditions-based initial mesh
6113 : : refinement.)"; }
6114 : : };
6115 : : using amr_initial_conditions =
6116 : : keyword< amr_initial_conditions_info, TAOCPP_PEGTL_STRING("ic") >;
6117 : :
6118 : : struct amr_edgelist_info {
6119 : : using code = Code< e >;
6120 : : static std::string name() { return "edge list"; }
6121 : : static std::string shortDescription() { return
6122 : : "Configure edge-node pairs for initial refinement"; }
6123 : : static std::string longDescription() { return
6124 : : R"(This keyword can be used to configure a list of edges that are explicitly
6125 : : tagged for initial refinement during setup in inciter. The keyword
6126 : : introduces an edgelist ... end block within an amr ... end block and must
6127 : : contain a list of integer pairs, i.e., the number of ids must be even,
6128 : : denoting the end-points of the nodes (=edge) which should be tagged for
6129 : : refinement.)"; }
6130 : : struct expect {
6131 : : using type = std::size_t;
6132 : : static constexpr type lower = 0;
6133 : : static std::string description() { return "two ints"; }
6134 : : };
6135 : : };
6136 : : using amr_edgelist =
6137 : : keyword< amr_edgelist_info, TAOCPP_PEGTL_STRING("edgelist") >;
6138 : :
6139 : : struct amr_coords_info {
6140 : : using code = Code< c >;
6141 : : static std::string name() { return "coordinates"; }
6142 : : static std::string shortDescription() { return
6143 : : "Configure initial refinement using coordinate planes"; }
6144 : : static std::string longDescription() { return
6145 : : R"(This keyword can be used to configure entire volumes on a given side of a
6146 : : plane in 3D space. The keyword introduces an coords ... end block within
6147 : : an amr ... end block and must contain the either or multiple of the
6148 : : following keywords: x- <real>, x+ <real>, y- <real>, y+ <real>, z- <real>,
6149 : : z+ <real>. All edges of the input mesh will be tagged for refinement whose
6150 : : end-points lie less than (-) or larger than (+) the real number given.
6151 : : Example: 'x- 0.5' refines all edges whose end-point coordinates are less
6152 : : than 0.5. Multiple specifications are understood by combining with a logical
6153 : : AND. That is: 'x- 0.5 y+ 0.3' refines all edges whose end-point x
6154 : : coordinates are less than 0.5 AND y coordinates are larger than 0.3.)"; }
6155 : : };
6156 : : using amr_coords =
6157 : : keyword< amr_coords_info, TAOCPP_PEGTL_STRING("coords") >;
6158 : :
6159 : : struct amr_initial_info {
6160 : : static std::string name() { return "Initial refinement typelist"; }
6161 : : static std::string shortDescription() { return
6162 : : "Configure initial mesh refinement (before time stepping)"; }
6163 : : static std::string longDescription() { return
6164 : : R"(This keyword is used to add to a list of initial mesh refinement types
6165 : : that happens before t = 0. Example: initial uniform initial ic inital
6166 : : uniform, which yiedls an initial uniform refinement, followed by a
6167 : : refinement based on the numerical error computed based on the initial
6168 : : conditions, followed by another step of unfirom refinement.)"; }
6169 : : struct expect {
6170 : : static std::string description() { return "string"; }
6171 : : static std::string choices() {
6172 : : return '\'' + amr_uniform::string() + "\' | \'"
6173 : : + amr_uniform_derefine::string() + "\' | \'"
6174 : : + amr_initial_conditions::string() + "\' | \'"
6175 : : + amr_edgelist::string() + "\' | \'"
6176 : : + amr_coords::string() + '\'';
6177 : : }
6178 : : };
6179 : : };
6180 : : using amr_initial = keyword< amr_initial_info, TAOCPP_PEGTL_STRING("initial") >;
6181 : :
6182 : : struct amr_refvar_info {
6183 : : static std::string name() { return "refinement variable(s)"; }
6184 : : static std::string shortDescription() { return
6185 : : "Configure dependent variables used for adaptive mesh refinement"; }
6186 : : static std::string longDescription() { return
6187 : : R"(This keyword is used to configured a list of dependent variables that
6188 : : trigger adaptive mesh refinement based on estimating their numerical error.
6189 : : These refinement variables are used for both initial (i.e., before time
6190 : : stepping) mesh refinement as well as during time stepping. Only previously
6191 : : (i.e., earlier in the input file) selected dependent variables can be
6192 : : configured as refinement variables. Dependent variables are required to be
6193 : : defined in all equation system configuration blocks, e.g., transport ...
6194 : : end, by using the 'depvar' keyword. Example: transport depvar c end amr
6195 : : refvar c end end. Selecting a particular scalar component in a system is
6196 : : done by appending the equation number to the refvar: Example: transport
6197 : : depvar q ncomp 3 end amr refvar q1 q2 end end, which configures two
6198 : : refinement variables: the first and third scalar component of the previously
6199 : : configured transport equation system.)"; }
6200 : : struct expect {
6201 : : static std::string description() { return "strings"; }
6202 : : };
6203 : : };
6204 : : using amr_refvar = keyword< amr_refvar_info, TAOCPP_PEGTL_STRING("refvar") >;
6205 : :
6206 : : struct amr_xminus_info {
6207 : : static std::string name() { return "initial refinement: x-"; }
6208 : : static std::string shortDescription() { return "Configure initial refinement "
6209 : : "for coordinates lower than an x-normal plane"; }
6210 : : static std::string longDescription() { return
6211 : : R"(This keyword can be used to configure a mesh refinement volume for edges
6212 : : whose end-points are less than the x coordinate of a plane perpendicular to
6213 : : coordinate x in 3D space. The keyword must be used in a coords ... end
6214 : : block within an amr ... end block with syntax 'x- <real>'. All edges of the
6215 : : input mesh will be tagged for refinement whose end-points lie less than (-)
6216 : : the real number given. Example: 'x- 0.5' refines all edges whose end-point
6217 : : coordinates are less than 0.5.)"; }
6218 : : struct expect {
6219 : : using type = tk::real;
6220 : : static std::string description() { return "real"; }
6221 : : };
6222 : : };
6223 : : using amr_xminus =
6224 : : keyword< amr_xminus_info, TAOCPP_PEGTL_STRING("x-") >;
6225 : :
6226 : : struct amr_xplus_info {
6227 : : static std::string name() { return "initial refinement: x+"; }
6228 : : static std::string shortDescription() { return "Configure initial refinement "
6229 : : "for coordinates larger than an x-normal plane"; }
6230 : : static std::string longDescription() { return
6231 : : R"(This keyword can be used to configure a mesh refinement volume for edges
6232 : : whose end-points are larger than the x coordinate of a plane perpendicular
6233 : : to coordinate x in 3D space. The keyword must be used in a coords ... end
6234 : : block within an amr ... end block with syntax 'x+ <real>'. All edges of the
6235 : : input mesh will be tagged for refinement whose end-points lie larger than
6236 : : (+) the real number given. Example: 'x+ 0.5' refines all edges whose
6237 : : end-point coordinates are larger than 0.5.)"; }
6238 : : struct expect {
6239 : : using type = tk::real;
6240 : : static std::string description() { return "real"; }
6241 : : };
6242 : : };
6243 : : using amr_xplus =
6244 : : keyword< amr_xplus_info, TAOCPP_PEGTL_STRING("x+") >;
6245 : :
6246 : : struct amr_yminus_info {
6247 : : static std::string name() { return "initial refinement: y-"; }
6248 : : static std::string shortDescription() { return "Configure initial refinement "
6249 : : "for coordinates lower than an y-normal plane"; }
6250 : : static std::string longDescription() { return
6251 : : R"(This keyword can be used to configure a mesh refinement volume for edges
6252 : : whose end-points are less than the y coordinate of a plane perpendicular to
6253 : : coordinate y in 3D space. The keyword must be used in a coords ... end
6254 : : block within an amr ... end block with syntax 'y- <real>'. All edges of the
6255 : : input mesh will be tagged for refinement whose end-points lie less than (-)
6256 : : the real number given. Example: 'y- 0.5' refines all edges whose end-point
6257 : : coordinates are less than 0.5.)"; }
6258 : : struct expect {
6259 : : using type = tk::real;
6260 : : static std::string description() { return "real"; }
6261 : : };
6262 : : };
6263 : : using amr_yminus =
6264 : : keyword< amr_yminus_info, TAOCPP_PEGTL_STRING("y-") >;
6265 : :
6266 : : struct amr_yplus_info {
6267 : : static std::string name() { return "initial refinement: y+"; }
6268 : : static std::string shortDescription() { return "Configure initial refinement "
6269 : : "for coordinates larger than an y-normal plane"; }
6270 : : static std::string longDescription() { return
6271 : : R"(This keyword can be used to configure a mesh refinement volume for edges
6272 : : whose end-points are larger than the y coordinate of a plane perpendicular
6273 : : to coordinate y in 3D space. The keyword must be used in a coords ... end
6274 : : block within an amr ... end block with syntax 'y+ <real>'. All edges of the
6275 : : input mesh will be tagged for refinement whose end-points lie larger than
6276 : : (+) the real number given. Example: 'y+ 0.5' refines all edges whose
6277 : : end-point coordinates are larger than 0.5.)"; }
6278 : : struct expect {
6279 : : using type = tk::real;
6280 : : static std::string description() { return "real"; }
6281 : : };
6282 : : };
6283 : : using amr_yplus =
6284 : : keyword< amr_yplus_info, TAOCPP_PEGTL_STRING("y+") >;
6285 : :
6286 : : struct amr_zminus_info {
6287 : : static std::string name() { return "initial refinement: z-"; }
6288 : : static std::string shortDescription() { return "Configure initial refinement "
6289 : : "for coordinates lower than an z-normal plane"; }
6290 : : static std::string longDescription() { return
6291 : : R"(This keyword can be used to configure a mesh refinement volume for edges
6292 : : whose end-points are less than the z coordinate of a plane perpendicular to
6293 : : coordinate z in 3D space. The keyword must be used in a coords ... end
6294 : : block within an amr ... end block with syntax 'z- <real>'. All edges of the
6295 : : input mesh will be tagged for refinement whose end-points lie less than (-)
6296 : : the real number given. Example: 'z- 0.5' refines all edges whose end-point
6297 : : coordinates are less than 0.5.)"; }
6298 : : struct expect {
6299 : : using type = tk::real;
6300 : : static std::string description() { return "real"; }
6301 : : };
6302 : : };
6303 : : using amr_zminus =
6304 : : keyword< amr_zminus_info, TAOCPP_PEGTL_STRING("z-") >;
6305 : :
6306 : : struct amr_zplus_info {
6307 : : static std::string name() { return "initial refinement: z+"; }
6308 : : static std::string shortDescription() { return "Configure initial refinement "
6309 : : "for coordinates larger than an z-normal plane"; }
6310 : : static std::string longDescription() { return
6311 : : R"(This keyword can be used to configure a mesh refinement volume for edges
6312 : : whose end-points are larger than the z coordinate of a plane perpendicular
6313 : : to coordinate z in 3D space. The keyword must be used in a coords ... end
6314 : : block within an amr ... end block with syntax 'z+ <real>'. All edges of the
6315 : : input mesh will be tagged for refinement whose end-points lie larger than
6316 : : (+) the real number given. Example: 'z+ 0.5' refines all edges whose
6317 : : end-point coordinates are larger than 0.5.)"; }
6318 : : struct expect {
6319 : : using type = tk::real;
6320 : : static std::string description() { return "real"; }
6321 : : };
6322 : : };
6323 : : using amr_zplus =
6324 : : keyword< amr_zplus_info, TAOCPP_PEGTL_STRING("z+") >;
6325 : :
6326 : : struct amr_jump_info {
6327 : : static std::string name() { return "jump"; }
6328 : : static std::string shortDescription() { return
6329 : : "Error estimation based on the jump in the solution normalized by solution";
6330 : : }
6331 : : static std::string longDescription() { return
6332 : : R"(This keyword is used to select the jump-based error indicator for
6333 : : solution-adaptive mesh refinement. The error is estimated by computing the
6334 : : magnitude of the jump in the solution value normalized by the solution
6335 : : value.)"; }
6336 : : };
6337 : : using amr_jump =
6338 : : keyword< amr_jump_info, TAOCPP_PEGTL_STRING("jump") >;
6339 : :
6340 : : struct amr_hessian_info {
6341 : : static std::string name() { return "Hessian"; }
6342 : : static std::string shortDescription() { return
6343 : : "Error estimation based on the Hessian normalized by solution value"; }
6344 : : static std::string longDescription() { return
6345 : : R"(This keyword is used to select the Hessian-based error indicator for
6346 : : solution-adaptive mesh refinement. The error is estimated by computing the
6347 : : Hessian (2nd derivative matrix) of the solution normalized by sum of the
6348 : : absolute values of the gradients at edges-end points.)"; }
6349 : : };
6350 : : using amr_hessian = keyword< amr_hessian_info, TAOCPP_PEGTL_STRING("hessian") >;
6351 : :
6352 : : struct amr_error_info {
6353 : : static std::string name() { return "Error estimator"; }
6354 : : static std::string shortDescription() { return
6355 : : "Configure the error type for solution-adaptive mesh refinement"; }
6356 : : static std::string longDescription() { return
6357 : : R"(This keyword is used to select the algorithm used to estimate the error
6358 : : for solution-adaptive mesh refinement.)"; }
6359 : : struct expect {
6360 : : static std::string description() { return "string"; }
6361 : : static std::string choices() {
6362 : : return '\'' + amr_jump::string() + "\' | \'"
6363 : : + amr_hessian::string() + '\'';
6364 : : }
6365 : : };
6366 : : };
6367 : : using amr_error = keyword< amr_error_info, TAOCPP_PEGTL_STRING("error") >;
6368 : :
6369 : : struct amr_t0ref_info {
6370 : : static std::string name() { return "Mesh refinement at t<0"; }
6371 : : static std::string shortDescription() { return
6372 : : "Enable mesh refinement at t<0"; }
6373 : : static std::string longDescription() { return
6374 : : R"(This keyword is used to enable initial mesh refinement, which can be
6375 : : configured to perform multiple levels of mesh refinement based on various
6376 : : refinement criteria and configuration settings.)";
6377 : : }
6378 : : struct expect {
6379 : : using type = bool;
6380 : : static std::string choices() { return "true | false"; }
6381 : : static std::string description() { return "string"; }
6382 : : };
6383 : : };
6384 : : using amr_t0ref = keyword< amr_t0ref_info, TAOCPP_PEGTL_STRING("t0ref") >;
6385 : :
6386 : : struct amr_dtref_info {
6387 : : static std::string name() { return "Mesh refinement at t>0"; }
6388 : : static std::string shortDescription() { return
6389 : : "Enable mesh refinement at t>0"; }
6390 : : static std::string longDescription() { return
6391 : : R"(This keyword is used to enable soution-adaptive mesh refinement during "
6392 : : "time stepping.)";
6393 : : }
6394 : : struct expect {
6395 : : using type = bool;
6396 : : static std::string choices() { return "true | false"; }
6397 : : static std::string description() { return "string"; }
6398 : : };
6399 : : };
6400 : : using amr_dtref = keyword< amr_dtref_info, TAOCPP_PEGTL_STRING("dtref") >;
6401 : :
6402 : : struct amr_dtref_uniform_info {
6403 : : static std::string name() { return "Uniform-only mesh refinement at t>0"; }
6404 : : static std::string shortDescription() { return
6405 : : "Enable mesh refinement at t>0 but only perform uniform refinement"; }
6406 : : static std::string longDescription() { return R"(This keyword is used to force
6407 : : uniform-only soution-adaptive mesh refinement during time stepping.)";
6408 : : }
6409 : : struct expect {
6410 : : using type = bool;
6411 : : static std::string choices() { return "true | false"; }
6412 : : static std::string description() { return "string"; }
6413 : : };
6414 : : };
6415 : : using amr_dtref_uniform =
6416 : : keyword< amr_dtref_uniform_info, TAOCPP_PEGTL_STRING("dtref_uniform") >;
6417 : :
6418 : : struct amr_dtfreq_info {
6419 : : static std::string name() { return "Mesh refinement frequency"; }
6420 : : static std::string shortDescription() { return
6421 : : "Set mesh refinement frequency during time stepping"; }
6422 : : static std::string longDescription() { return
6423 : : R"(This keyword is used to configure the frequency of mesh refinement
6424 : : during time stepping. The default is 3, which means that mesh refinement
6425 : : will be performed every 3rd time step.)";
6426 : : }
6427 : : struct expect {
6428 : : using type = std::size_t;
6429 : : static constexpr type lower = 1;
6430 : : static constexpr type upper = std::numeric_limits< type >::max();
6431 : : static std::string description() { return "int"; }
6432 : : static std::string choices() {
6433 : : return "integer between [" + std::to_string(lower) + "..." +
6434 : : std::to_string(upper) + "] (both inclusive)";
6435 : : }
6436 : : };
6437 : : };
6438 : : using amr_dtfreq = keyword< amr_dtfreq_info, TAOCPP_PEGTL_STRING("dtfreq") >;
6439 : :
6440 : : struct amr_tolref_info {
6441 : : static std::string name() { return "refine tolerance"; }
6442 : : static std::string shortDescription() { return "Configure refine tolerance"; }
6443 : : static std::string longDescription() { return
6444 : : R"(This keyword is used to set the tolerance used to tag an edge for
6445 : : refinement if the relative error exceeds this value.)"; }
6446 : : struct expect {
6447 : : using type = tk::real;
6448 : : static constexpr type lower = 0.0;
6449 : : static constexpr type upper = 1.0;
6450 : : static std::string description() { return "real"; }
6451 : : static std::string choices() {
6452 : : return "integer between [" + std::to_string(lower) + "..." +
6453 : : std::to_string(upper) + "] (both inclusive)";
6454 : : }
6455 : : };
6456 : : };
6457 : : using amr_tolref =
6458 : : keyword< amr_tolref_info, TAOCPP_PEGTL_STRING("tol_refine") >;
6459 : :
6460 : : struct amr_tolderef_info {
6461 : : static std::string name() { return "derefine tolerance"; }
6462 : : static std::string shortDescription() {
6463 : : return "Configure derefine tolerance"; }
6464 : : static std::string longDescription() { return
6465 : : R"(This keyword is used to set the tolerance used to tag an edge for
6466 : : derefinement if the relative error is below this value.)"; }
6467 : : struct expect {
6468 : : using type = tk::real;
6469 : : static constexpr type lower = 0.0;
6470 : : static constexpr type upper = 1.0;
6471 : : static std::string description() { return "real"; }
6472 : : static std::string choices() {
6473 : : return "integer between [" + std::to_string(lower) + "..." +
6474 : : std::to_string(upper) + "] (both inclusive)";
6475 : : }
6476 : : };
6477 : : };
6478 : : using amr_tolderef =
6479 : : keyword< amr_tolderef_info, TAOCPP_PEGTL_STRING("tol_derefine") >;
6480 : :
6481 : : struct amr_info {
6482 : : static std::string name() { return "AMR"; }
6483 : : static std::string shortDescription() { return
6484 : : "Start configuration block configuring adaptive mesh refinement"; }
6485 : : static std::string longDescription() { return
6486 : : R"(This keyword is used to introduce the amr ... end block, used to
6487 : : configure adaptive mesh refinement. Keywords allowed
6488 : : in this block: )" + std::string("\'")
6489 : : + amr_t0ref::string() + "\' | \'"
6490 : : + amr_dtref::string() + "\' | \'"
6491 : : + amr_dtref_uniform::string() + "\' | \'"
6492 : : + amr_dtfreq::string() + "\' | \'"
6493 : : + amr_initial::string() + "\' | \'"
6494 : : + amr_refvar::string() + "\' | \'"
6495 : : + amr_tolref::string() + "\' | \'"
6496 : : + amr_tolderef::string() + "\' | \'"
6497 : : + amr_error::string() + "\' | \'"
6498 : : + amr_coords::string() + "\' | \'"
6499 : : + amr_edgelist::string() + "\'.";
6500 : : }
6501 : : };
6502 : : using amr = keyword< amr_info, TAOCPP_PEGTL_STRING("amr") >;
6503 : :
6504 : : struct pref_spectral_decay_info {
6505 : : static std::string name() { return "spectral decay"; }
6506 : : static std::string shortDescription() { return "Select the spectral-decay"
6507 : : " indicator for p-adaptive DG scheme"; }
6508 : : static std::string longDescription() { return
6509 : : R"(This keyword is used to select the spectral-decay indicator used for
6510 : : p-adaptive discontinuous Galerkin (DG) discretization used in inciter.
6511 : : See Control/Inciter/Options/PrefIndicator.hpp for other valid options.)"; }
6512 : : };
6513 : : using pref_spectral_decay = keyword< pref_spectral_decay_info,
6514 : : TAOCPP_PEGTL_STRING("spectral_decay") >;
6515 : :
6516 : : struct pref_non_conformity_info {
6517 : : static std::string name() { return "non-conformity"; }
6518 : : static std::string shortDescription() { return "Select the non-conformity"
6519 : : " indicator for p-adaptive DG scheme"; }
6520 : : static std::string longDescription() { return
6521 : : R"(This keyword is used to select the non-conformity indicator used for
6522 : : p-adaptive discontinuous Galerkin (DG) discretization used in inciter.
6523 : : See Control/Inciter/Options/PrefIndicator.hpp for other valid options.)"; }
6524 : : };
6525 : : using pref_non_conformity = keyword< pref_non_conformity_info,
6526 : : TAOCPP_PEGTL_STRING("non_conformity") >;
6527 : :
6528 : : struct pref_indicator_info {
6529 : : static std::string name() { return "the choice of adaptive indicator"; }
6530 : : static std::string shortDescription() { return "Configure the specific "
6531 : : " adaptive indicator for p-adaptive DG scheme"; }
6532 : : static std::string longDescription() { return
6533 : : R"(This keyword can be used to configure a specific type of adaptive
6534 : : indicator for p-adaptive refinement of the DG scheme. The keyword must
6535 : : be used in pref ... end block. Example specification: 'indicator 1'.)"; }
6536 : : struct expect {
6537 : : static std::string description() { return "string"; }
6538 : : static std::string choices() {
6539 : : return '\'' + pref_spectral_decay::string() + "\' | \'"
6540 : : + pref_non_conformity::string() + '\'';
6541 : : }
6542 : : };
6543 : : };
6544 : : using pref_indicator =
6545 : : keyword< pref_indicator_info, TAOCPP_PEGTL_STRING("indicator") >;
6546 : :
6547 : : struct pref_ndofmax_info {
6548 : : static std::string name() { return "Maximum ndof for p-refinement"; }
6549 : : static std::string shortDescription() { return "Configure the maximum "
6550 : : "number of degree of freedom for p-adaptive DG scheme"; }
6551 : : static std::string longDescription() { return
6552 : : R"(This keyword can be used to configure a maximum number of degree of
6553 : : freedom for p-adaptive refinement of the DG scheme. The keyword must
6554 : : be used in pref ... end block. Example specification: 'ndofmax 10'.)"; }
6555 : : struct expect {
6556 : : using type = std::size_t;
6557 : : static constexpr type lower = 4;
6558 : : static constexpr type upper = 10;
6559 : : static std::string description() { return "int"; }
6560 : : static std::string choices() {
6561 : : return "int either 4 or 10";
6562 : : }
6563 : : };
6564 : : };
6565 : : using pref_ndofmax =
6566 : : keyword< pref_ndofmax_info, TAOCPP_PEGTL_STRING("ndofmax") >;
6567 : :
6568 : : struct pref_tolref_info {
6569 : : static std::string name() { return "Tolerance for p-refinement"; }
6570 : : static std::string shortDescription() { return "Configure the tolerance for "
6571 : : "p-refinement for the p-adaptive DG scheme"; }
6572 : : static std::string longDescription() { return
6573 : : R"(This keyword can be used to configure a tolerance for p-adaptive
6574 : : refinement for the DG scheme. The keyword must be used in pref ... end
6575 : : block. All elements with a refinement indicator larger than this tolerance
6576 : : will be p-refined. Example specification: 'tolref 0.1'.)"; }
6577 : : struct expect {
6578 : : using type = tk::real;
6579 : : static constexpr type lower = 0.0;
6580 : : static constexpr type upper = 1.0;
6581 : : static std::string description() { return "real"; }
6582 : : static std::string choices() {
6583 : : return "real between [" + std::to_string(lower) + "..." +
6584 : : std::to_string(upper) + "] (both inclusive)";
6585 : : }
6586 : : };
6587 : : };
6588 : : using pref_tolref = keyword< pref_tolref_info, TAOCPP_PEGTL_STRING("tolref") >;
6589 : :
6590 : : struct pref_info {
6591 : : static std::string name() { return "pref"; }
6592 : : static std::string shortDescription() { return
6593 : : "Start configuration block configuring p-adaptive refinement"; }
6594 : : static std::string longDescription() { return
6595 : : R"(This keyword is used to introduce the pref ... end block, used to
6596 : : configure p-adaptive refinement. Keywords allowed
6597 : : in this block: )" + std::string("\'")
6598 : : + pref_indicator::string() + "\' | \'"
6599 : : + pref_ndofmax::string() + "\' | \'"
6600 : : + pref_tolref::string() + "\' | \'";
6601 : : }
6602 : : };
6603 : : using pref = keyword< pref_info, TAOCPP_PEGTL_STRING("pref") >;
6604 : :
6605 : : struct diagcg_info {
6606 : : static std::string name() { return "CG+LW"; }
6607 : : static std::string shortDescription() { return "Select continuous Galerkin "
6608 : : "+ Lax Wendroff with a lumped-mass matrix LHS"; }
6609 : : static std::string longDescription() { return
6610 : : R"(This keyword is used to select the lumped-mass matrix continuous Galerkin
6611 : : (CG) finite element spatial discretiztaion used in inciter. CG is combined
6612 : : with a Lax-Wendroff scheme for time discretization and flux-corrected
6613 : : transport (FCT) for treating discontinuous solutions. This option selects
6614 : : the scheme that stores the left-hand side matrix lumped, i.e., only the
6615 : : diagonal elements stored and thus does not require a linear solver. See
6616 : : Control/Inciter/Options/Scheme.hpp for other valid options.)"; }
6617 : : };
6618 : : using diagcg = keyword< diagcg_info, TAOCPP_PEGTL_STRING("diagcg") >;
6619 : :
6620 : : struct alecg_info {
6621 : : static std::string name() { return "ALECG+RK"; }
6622 : : static std::string shortDescription() { return "Select continuous Galerkin "
6623 : : "with ALE + Runge-Kutta"; }
6624 : : static std::string longDescription() { return
6625 : : R"(This keyword is used to select the continuous Galerkin finite element
6626 : : scheme in the arbitrary Lagrangian-Eulerian (ALE) reference frame combined
6627 : : with Runge-Kutta (RK) time stepping. See Control/Inciter/Options/Scheme.hpp
6628 : : for other valid options.)"; }
6629 : : };
6630 : : using alecg = keyword< alecg_info, TAOCPP_PEGTL_STRING("alecg") >;
6631 : :
6632 : : struct dg_info {
6633 : : static std::string name() { return "DG(P0)+RK"; }
6634 : : static std::string shortDescription() { return
6635 : : "Select 1st-order discontinuous Galerkin discretization + Runge-Kutta"; }
6636 : : static std::string longDescription() { return
6637 : : R"(This keyword is used to select the first-order accurate discontinuous
6638 : : Galerkin, DG(P0), spatial discretiztaion used in Inciter. As this is first
6639 : : order accurate, it is intended for testing and debugging purposes only.
6640 : : Selecting this spatial discretization also selects the Runge-Kutta scheme
6641 : : for time discretization. See Control/Inciter/Options/Scheme.hpp for other
6642 : : valid options.)"; }
6643 : : };
6644 : : using dg = keyword< dg_info, TAOCPP_PEGTL_STRING("dg") >;
6645 : :
6646 : : struct p0p1_info {
6647 : : static std::string name() { return "P0P1+RK"; }
6648 : : static std::string shortDescription() { return
6649 : : "Select 2nd-order finite volume discretization + Runge-Kutta"; }
6650 : : static std::string longDescription() { return
6651 : : R"(This keyword is used to select the second-order accurate finite volume,
6652 : : P0P1, spatial discretiztaion used in Inciter. This method uses a
6653 : : least-squares procedure to reconstruct the second-order solution from the
6654 : : first-order one. Selecting this spatial discretization also selects the
6655 : : Runge-Kutta scheme for time discretization.
6656 : : See Control/Inciter/Options/Scheme.hpp for other valid options.)"; }
6657 : : };
6658 : : using p0p1 = keyword< p0p1_info, TAOCPP_PEGTL_STRING("p0p1") >;
6659 : :
6660 : : struct dgp1_info {
6661 : : static std::string name() { return "DG(P1)+RK"; }
6662 : : static std::string shortDescription() { return
6663 : : "Select 2nd-order discontinuous Galerkin discretization + Runge-Kutta"; }
6664 : : static std::string longDescription() { return
6665 : : R"(This keyword is used to select the second-order accurate discontinuous
6666 : : Galerkin, DG(P1), spatial discretiztaion used in Inciter. Selecting this
6667 : : spatial discretization also selects the Runge-Kutta scheme for time
6668 : : discretization. See Control/Inciter/Options/Scheme.hpp for other
6669 : : valid options.)"; }
6670 : : };
6671 : : using dgp1 = keyword< dgp1_info, TAOCPP_PEGTL_STRING("dgp1") >;
6672 : :
6673 : : struct dgp2_info {
6674 : : static std::string name() { return "DG(P2)+RK"; }
6675 : : static std::string shortDescription() { return
6676 : : "Select 3nd-order discontinuous Galerkin discretization + Runge-Kutta"; }
6677 : : static std::string longDescription() { return
6678 : : R"(This keyword is used to select the third-order accurate discontinuous
6679 : : Galerkin, DG(P2), spatial discretiztaion used in Inciter. Selecting this
6680 : : spatial discretization also selects the Runge-Kutta scheme for time
6681 : : discretization. See Control/Inciter/Options/Scheme.hpp for other
6682 : : valid options.)"; }
6683 : : };
6684 : : using dgp2 = keyword< dgp2_info, TAOCPP_PEGTL_STRING("dgp2") >;
6685 : :
6686 : : struct pdg_info {
6687 : : static std::string name() { return "pDG+RK"; }
6688 : : static std::string shortDescription() { return
6689 : : "Select adaptive discontinuous Galerkin discretization + Runge-Kutta"; }
6690 : : static std::string longDescription() { return
6691 : : R"(This keyword is used to select the adaptive discontinuous Galerkin
6692 : : spatial discretizaion used in Inciter. Selecting this spatial
6693 : : discretization also selects the Runge-Kutta scheme for time
6694 : : discretization. See Control/Inciter/Options/Scheme.hpp for other valid
6695 : : options.)"; }
6696 : : };
6697 : : using pdg = keyword< pdg_info, TAOCPP_PEGTL_STRING("pdg") >;
6698 : :
6699 : : struct fv_info {
6700 : : static std::string name() { return "FV"; }
6701 : : static std::string shortDescription() { return
6702 : : "Select 2nd-order finite volume discretization"; }
6703 : : static std::string longDescription() { return
6704 : : R"(This keyword is used to select the second-order accurate finite volume,
6705 : : P0P1, spatial discretiztaion used in Inciter. This method uses a
6706 : : least-squares procedure to reconstruct the second-order solution from the
6707 : : first-order one. See Control/Inciter/Options/Scheme.hpp for other valid
6708 : : options.)"; }
6709 : : };
6710 : : using fv = keyword< fv_info, TAOCPP_PEGTL_STRING("fv") >;
6711 : :
6712 : : struct scheme_info {
6713 : : static std::string name() { return "Discretization scheme"; }
6714 : : static std::string shortDescription() { return
6715 : : "Select discretization scheme"; }
6716 : : static std::string longDescription() { return
6717 : : R"(This keyword is used to select a spatial discretization scheme,
6718 : : necessarily connected to the teporal discretization scheme. See
6719 : : Control/Inciter/Options/Scheme.hpp for valid options.)"; }
6720 : : struct expect {
6721 : : static std::string description() { return "string"; }
6722 : : static std::string choices() {
6723 : : return '\'' + diagcg::string() + "\' | \'"
6724 : : + dg::string() + '\'';
6725 : : }
6726 : : };
6727 : : };
6728 : : using scheme = keyword< scheme_info, TAOCPP_PEGTL_STRING("scheme") >;
6729 : :
6730 : : struct laxfriedrichs_info {
6731 : : static std::string name() { return "Lax-Friedrichs"; }
6732 : : static std::string shortDescription() { return
6733 : : "Select Lax-Friedrichs flux function"; }
6734 : : static std::string longDescription() { return
6735 : : R"(This keyword is used to select the Lax-Friedrichs flux function used for
6736 : : discontinuous Galerkin (DG) spatial discretization used in inciter. See
6737 : : Control/Inciter/Options/Flux.hpp for other valid options.)"; }
6738 : : };
6739 : : using laxfriedrichs =
6740 : : keyword< laxfriedrichs_info, TAOCPP_PEGTL_STRING("laxfriedrichs") >;
6741 : :
6742 : : struct hllc_info {
6743 : : static std::string name() { return "HLLC"; }
6744 : : static std::string shortDescription() { return
6745 : : "Select the Harten-Lax-van Leer-Contact (HLLC) flux function"; }
6746 : : static std::string longDescription() { return
6747 : : R"(This keyword is used to select the Harten-Lax-van Leer-Contact flux
6748 : : function used for discontinuous Galerkin (DG) spatial discretization
6749 : : used in inciter. See Control/Inciter/Options/Flux.hpp for other valid
6750 : : options.)"; }
6751 : : };
6752 : : using hllc = keyword< hllc_info, TAOCPP_PEGTL_STRING("hllc") >;
6753 : :
6754 : : struct upwind_info {
6755 : : static std::string name() { return "Upwind"; }
6756 : : static std::string shortDescription() { return
6757 : : "Select the upwind flux function"; }
6758 : : static std::string longDescription() { return
6759 : : R"(This keyword is used to select the upwind flux
6760 : : function used for discontinuous Galerkin (DG) spatial discretization
6761 : : used in inciter. It is really only useful for scalar transport, it is thus
6762 : : not selectable for anything else, and for scalar transport it is the
6763 : : hardcoded flux type. See Control/Inciter/Options/Flux.hpp for other valid
6764 : : options.)"; }
6765 : : };
6766 : : using upwind = keyword< upwind_info, TAOCPP_PEGTL_STRING("upwind") >;
6767 : :
6768 : : struct ausm_info {
6769 : : static std::string name() { return "AUSM"; }
6770 : : static std::string shortDescription() { return
6771 : : "Select the Advection Upstream Splitting Method (AUSM) flux function"; }
6772 : : static std::string longDescription() { return
6773 : : R"(This keyword is used to select the AUSM flux
6774 : : function used for discontinuous Galerkin (DG) spatial discretization
6775 : : used in inciter. It is only used for for multi-material hydro, it is thus
6776 : : not selectable for anything else, and for multi-material hydro it is the
6777 : : hardcoded flux type.)"; }
6778 : : };
6779 : : using ausm = keyword< ausm_info, TAOCPP_PEGTL_STRING("ausm") >;
6780 : :
6781 : : struct hll_info {
6782 : : static std::string name() { return "HLL"; }
6783 : : static std::string shortDescription() { return
6784 : : "Select the Harten-Lax-vanLeer (HLL) flux function"; }
6785 : : static std::string longDescription() { return
6786 : : R"(This keyword is used to select the HLL flux
6787 : : function used for discontinuous Galerkin (DG) spatial discretization
6788 : : used in inciter. It is only used for for multi-material hydro, it is thus
6789 : : not selectable for anything else, and for multi-material hydro it is the
6790 : : hardcoded flux type.)"; }
6791 : : };
6792 : : using hll = keyword< hll_info, TAOCPP_PEGTL_STRING("hll") >;
6793 : :
6794 : : struct flux_info {
6795 : : static std::string name() { return "Flux function"; }
6796 : : static std::string shortDescription() { return
6797 : : "Select flux function"; }
6798 : : static std::string longDescription() { return
6799 : : R"(This keyword is used to select a flux function, used for
6800 : : discontinuous Galerkin (DG) spatial discretization used in inciter. See
6801 : : Control/Inciter/Options/Flux.hpp for valid options.)"; }
6802 : : struct expect {
6803 : : static std::string description() { return "string"; }
6804 : : static std::string choices() {
6805 : : return '\'' + laxfriedrichs::string() + "\' | \'"
6806 : : + hllc::string() + "\' | \'"
6807 : : + upwind::string() + "\' | \'"
6808 : : + ausm::string() + "\' | \'"
6809 : : + hll::string() + '\'';
6810 : : }
6811 : : };
6812 : : };
6813 : : using flux = keyword< flux_info, TAOCPP_PEGTL_STRING("flux") >;
6814 : :
6815 : : struct none_info {
6816 : : static std::string name() { return "none"; }
6817 : : static std::string shortDescription() { return "Select none option"; }
6818 : : static std::string longDescription() { return
6819 : : R"(This keyword is used to select the 'none' option from a list of
6820 : : configuration options.)"; }
6821 : : };
6822 : : using none = keyword< none_info, TAOCPP_PEGTL_STRING("none") >;
6823 : :
6824 : : struct sine_info {
6825 : : static std::string name() { return "sine"; }
6826 : : static std::string shortDescription() { return
6827 : : "Prescribe sinusoidal mesh velocity for ALE"; }
6828 : : static std::string longDescription() { return
6829 : : R"(This keyword is used to prescribe a sinusoidal mesh velocity
6830 : : for Arbitrary-Lagrangian-Eulerian (ALE) mesh motion.)"; }
6831 : : };
6832 : : using sine = keyword< sine_info, TAOCPP_PEGTL_STRING("sine") >;
6833 : :
6834 : : struct fluid_info {
6835 : : static std::string name() { return "fluid"; }
6836 : : static std::string shortDescription() { return
6837 : : "Select the fluid velocity for ALE"; }
6838 : : static std::string longDescription() { return
6839 : : R"(This keyword is used to select the 'fluid' velocity as the mesh velocity
6840 : : for Arbitrary-Lagrangian-Eulerian (ALE) mesh motion.)"; }
6841 : : };
6842 : : using fluid = keyword< fluid_info, TAOCPP_PEGTL_STRING("fluid") >;
6843 : :
6844 : : struct laplace_info {
6845 : : static std::string name() { return "Laplace"; }
6846 : : static std::string shortDescription() { return
6847 : : "Select the Laplace mesh velocity smoother for ALE"; }
6848 : : static std::string longDescription() { return
6849 : : R"(This keyword is used to select the 'Laplace' mesh velocity smoother for
6850 : : Arbitrary-Lagrangian-Eulerian (ALE) mesh motion.)"; }
6851 : : };
6852 : : using laplace = keyword< laplace_info, TAOCPP_PEGTL_STRING("laplace") >;
6853 : :
6854 : : struct helmholtz_info {
6855 : : static std::string name() { return "Helmholtz"; }
6856 : : static std::string shortDescription() { return
6857 : : "Select the Helmholtz velocity for ALE"; }
6858 : : static std::string longDescription() { return
6859 : : R"(This keyword is used to select the a velocity, computed from the
6860 : : Helmholtz-decomposition as the mesh velocity for
6861 : : Arbitrary-Lagrangian-Eulerian (ALE) mesh motion. See J. Bakosi, J. Waltz,
6862 : : N. Morgan, Improved ALE mesh velocities for complex flows, Int. J. Numer.
6863 : : Meth. Fl., 1-10, 2017, https://doi.org/10.1002/fld.4403.)"; }
6864 : : };
6865 : : using helmholtz = keyword< helmholtz_info, TAOCPP_PEGTL_STRING("helmholtz") >;
6866 : :
6867 : : struct meshvelocity_info {
6868 : : static std::string name() { return "Mesh velocity"; }
6869 : : static std::string shortDescription() { return
6870 : : "Select mesh velocity"; }
6871 : : static std::string longDescription() { return
6872 : : R"(This keyword is used to select a mesh velocity option, used for
6873 : : Arbitrary-Lagrangian-Eulerian (ALE) mesh motion.)"; }
6874 : : struct expect {
6875 : : static std::string description() { return "string"; }
6876 : : static std::string choices() {
6877 : : return '\'' + sine::string() + "\' | \'"
6878 : : + fluid::string() + "\' | \'"
6879 : : + user_defined::string() + '\'';
6880 : : }
6881 : : };
6882 : : };
6883 : : using meshvelocity =
6884 : : keyword< meshvelocity_info, TAOCPP_PEGTL_STRING("mesh_velocity") >;
6885 : :
6886 : : struct smoother_info {
6887 : : static std::string name() { return "Smoother"; }
6888 : : static std::string shortDescription() { return
6889 : : "Select mesh velocity smoother"; }
6890 : : static std::string longDescription() { return
6891 : : R"(This keyword is used to select a mesh velocity smoother option, used for
6892 : : Arbitrary-Lagrangian-Eulerian (ALE) mesh motion.)"; }
6893 : : struct expect {
6894 : : static std::string description() { return "string"; }
6895 : : static std::string choices() {
6896 : : return '\'' + none::string() + "\' | \'"
6897 : : + laplace::string() + "\' | \'"
6898 : : + helmholtz::string() + '\'';
6899 : : }
6900 : : };
6901 : : };
6902 : : using smoother =
6903 : : keyword< smoother_info, TAOCPP_PEGTL_STRING("smoother") >;
6904 : :
6905 : : struct fntype_info {
6906 : : static std::string name() { return "User-defined function type"; }
6907 : : static std::string shortDescription() { return
6908 : : "Select how a user-defined function is interpreted"; }
6909 : : static std::string longDescription() { return
6910 : : R"(This keyword is used to select how a user-defined function should be
6911 : : interpreted.)"; }
6912 : : struct expect {
6913 : : static std::string description() { return "string"; }
6914 : : };
6915 : : };
6916 : : using fntype =
6917 : : keyword< fntype_info, TAOCPP_PEGTL_STRING("fntype") >;
6918 : :
6919 : : struct mesh_motion_info {
6920 : : static std::string name() {
6921 : : return "Mesh velocity dimensions allowed to change in ALE"; }
6922 : : static std::string shortDescription() { return "Specify a list of scalar "
6923 : : "dimension indices that are allowed to move in ALE calculations"; }
6924 : : static std::string longDescription() { return
6925 : : R"(This keyword is used to specify a list of integers (0, 1, or 2) whose
6926 : : coordinate directions corresponding to x, y, or z are allowed to move with
6927 : : the mesh velocity in ALE calculations. Example: 'mesh_motion 0 1 end', which
6928 : : means disallow mesh motion in the z coordinate direction, useful for 2D
6929 : : problems in x-y.)";
6930 : : }
6931 : : struct expect {
6932 : : using type = std::size_t;
6933 : : static std::string description() { return "integers"; }
6934 : : };
6935 : : };
6936 : : using mesh_motion =
6937 : : keyword< mesh_motion_info, TAOCPP_PEGTL_STRING("mesh_motion") >;
6938 : :
6939 : : struct meshforce_info {
6940 : : static std::string name() { return "Mesh force"; }
6941 : : static std::string shortDescription() { return
6942 : : R"(Set ALE mesh force model parameter(s))"; }
6943 : : static std::string longDescription() { return
6944 : : R"(This keyword is used to specify a vector of real numbers used to
6945 : : parameterize a mesh force model for ALE. Example: "mesh_force 1.0 2.0 3.0
6946 : : 4.0 end". The length of the vector must exactly 4. Everything else is an
6947 : : error.)"; }
6948 : : struct expect {
6949 : : using type = tk::real;
6950 : : static std::string description() { return "real(s)"; }
6951 : : };
6952 : : };
6953 : : using meshforce = keyword< meshforce_info, TAOCPP_PEGTL_STRING("mesh_force") >;
6954 : :
6955 : : struct ale_info {
6956 : : static std::string name() { return "ALE"; }
6957 : : static std::string shortDescription() { return "Start configuration block "
6958 : : "configuring ALE"; }
6959 : : static std::string longDescription() { return
6960 : : R"(This keyword is used to introduce the ale ... end block, used to
6961 : : configure arbitrary Lagrangian-Eulerian (ALE) mesh movement. Keywords
6962 : : allowed in this block: )" + std::string("\'")
6963 : : + vortmult::string() + "\' | \'"
6964 : : + meshvel_maxit::string() + "\' | \'"
6965 : : + meshvel_tolerance::string() + "\' | \'"
6966 : : + bc_dirichlet::string() + "\' | \'"
6967 : : + bc_sym::string() + "\' | \'"
6968 : : + meshforce::string() + "\' | \'"
6969 : : + meshvelocity::string() + "\'.";
6970 : : }
6971 : : };
6972 : : using ale = keyword< ale_info, TAOCPP_PEGTL_STRING("ale") >;
6973 : :
6974 : : struct filename_info {
6975 : : static std::string name() { return "filename"; }
6976 : : static std::string shortDescription() { return "Set filename"; }
6977 : : static std::string longDescription() { return
6978 : : R"(Set filename, e.g., mesh filename for solver coupling.)";
6979 : : }
6980 : : struct expect {
6981 : : using type = std::string;
6982 : : static std::string description() { return "string"; }
6983 : : };
6984 : : };
6985 : : using filename = keyword< filename_info, TAOCPP_PEGTL_STRING("filename") >;
6986 : :
6987 : : struct location_info {
6988 : : static std::string name() { return "location"; }
6989 : : static std::string shortDescription() { return "Configure location"; }
6990 : : static std::string longDescription() { return
6991 : : R"(Configure location of a mesh relative to another, e.g., for solver
6992 : : coupling.)";
6993 : : }
6994 : : struct expect {
6995 : : using type = tk::real;
6996 : : static std::string description() { return "real(s)"; }
6997 : : };
6998 : : };
6999 : : using location = keyword< location_info, TAOCPP_PEGTL_STRING("location") >;
7000 : :
7001 : : struct orientation_info {
7002 : : static std::string name() { return "orientation"; }
7003 : : static std::string shortDescription() { return "Configure orientation"; }
7004 : : static std::string longDescription() { return
7005 : : R"(Configure orientation of a mesh relative to another, e.g., for solver
7006 : : coupling.)";
7007 : : }
7008 : : struct expect {
7009 : : using type = tk::real;
7010 : : static std::string description() { return "real(s)"; }
7011 : : };
7012 : : };
7013 : : using orientation =
7014 : : keyword< orientation_info, TAOCPP_PEGTL_STRING("orientation") >;
7015 : :
7016 : : struct mesh_info {
7017 : : static std::string name() { return "Mesh specification block"; }
7018 : : static std::string shortDescription() { return
7019 : : "Start configuration block assigning a mesh to a solver"; }
7020 : : static std::string longDescription() { return
7021 : : R"(This keyword is used to introduce a mesh ... end block, used to
7022 : : assign and configure a mesh to a solver.)";
7023 : : }
7024 : : };
7025 : : using mesh = keyword< mesh_info, TAOCPP_PEGTL_STRING("mesh") >;
7026 : :
7027 : : struct reference_info {
7028 : : static std::string name() { return "Mesh transformation"; }
7029 : : static std::string shortDescription() { return
7030 : : "Specify mesh transformation relative to a mesh of another solver"; }
7031 : : static std::string longDescription() { return
7032 : : R"(This keyword is used to specify a solver, given with a dependent
7033 : : variable, configured upstream in the input file, whose mesh is used as a
7034 : : reference to which the mesh being configured is transformed relative
7035 : : to.)";
7036 : : }
7037 : : struct expect {
7038 : : using type = char;
7039 : : static std::string description() { return "character"; }
7040 : : };
7041 : : };
7042 : : using reference = keyword< reference_info, TAOCPP_PEGTL_STRING("reference") >;
7043 : :
7044 : : struct couple_info {
7045 : : static std::string name() { return "Couple solvers"; }
7046 : : static std::string shortDescription() { return
7047 : : "Specify coupling of solvers on different meshes"; }
7048 : : static std::string longDescription() { return
7049 : : R"(This keyword is used to introduce a couple ... end block, used to
7050 : : specify coupling of solvers operating on different meshes.)";
7051 : : }
7052 : : };
7053 : : using couple = keyword< couple_info, TAOCPP_PEGTL_STRING("couple") >;
7054 : :
7055 : : struct nolimiter_info {
7056 : : static std::string name() { return "No limiter"; }
7057 : : static std::string shortDescription() { return
7058 : : "No limiter used"; }
7059 : : static std::string longDescription() { return
7060 : : R"(This keyword is used for discontinuous Galerkin (DG) spatial
7061 : : discretization without any limiter in inciter. See
7062 : : Control/Inciter/Options/Limiter.hpp for other valid options.)"; }
7063 : : };
7064 : : using nolimiter =
7065 : : keyword< nolimiter_info, TAOCPP_PEGTL_STRING("nolimiter") >;
7066 : :
7067 : : struct wenop1_info {
7068 : : static std::string name() { return "WENOP1"; }
7069 : : static std::string shortDescription() { return
7070 : : "Select the Weighted Essentially Non-Oscillatory (WENO) limiter for DGP1"; }
7071 : : static std::string longDescription() { return
7072 : : R"(This keyword is used to select the Weighted Essentially Non-Oscillatory
7073 : : limiter used for discontinuous Galerkin (DG) P1 spatial discretization
7074 : : used in inciter. See Control/Inciter/Options/Limiter.hpp for other valid
7075 : : options.)"; }
7076 : : };
7077 : : using wenop1 = keyword< wenop1_info, TAOCPP_PEGTL_STRING("wenop1") >;
7078 : :
7079 : : struct superbeep1_info {
7080 : : static std::string name() { return "SUPERBEEP1"; }
7081 : : static std::string shortDescription() { return
7082 : : "Select the Superbee limiter for DGP1"; }
7083 : : static std::string longDescription() { return
7084 : : R"(This keyword is used to select the Superbee limiter used for
7085 : : discontinuous Galerkin (DG) P1 spatial discretization used in inciter.
7086 : : See Control/Inciter/Options/Limiter.hpp for other valid options.)"; }
7087 : : };
7088 : : using superbeep1 = keyword< superbeep1_info, TAOCPP_PEGTL_STRING("superbeep1") >;
7089 : :
7090 : : struct vertexbasedp1_info {
7091 : : static std::string name() { return "VERTEXBASEDP1"; }
7092 : : static std::string shortDescription() { return
7093 : : "Select the vertex-based limiter for DGP1"; }
7094 : : static std::string longDescription() { return
7095 : : R"(This keyword is used to select the vertex-based limiter used for
7096 : : discontinuous Galerkin (DG) P1 spatial discretization used in inciter.
7097 : : Ref. Kuzmin, D. (2010). A vertex-based hierarchical slope limiter for
7098 : : p-adaptive discontinuous Galerkin methods. Journal of computational and
7099 : : applied mathematics, 233(12), 3077-3085.
7100 : : See Control/Inciter/Options/Limiter.hpp for other valid options.)"; }
7101 : : };
7102 : : using vertexbasedp1 = keyword< vertexbasedp1_info, TAOCPP_PEGTL_STRING("vertexbasedp1") >;
7103 : :
7104 : : struct limiter_info {
7105 : : static std::string name() { return "Limiter function"; }
7106 : : static std::string shortDescription() { return
7107 : : "Select limiter function"; }
7108 : : static std::string longDescription() { return
7109 : : R"(This keyword is used to select a limiter function, used for
7110 : : discontinuous Galerkin (DG) spatial discretization used in inciter. See
7111 : : Control/Inciter/Options/Limiter.hpp for valid options.)"; }
7112 : : struct expect {
7113 : : static std::string description() { return "string"; }
7114 : : static std::string choices() {
7115 : : return '\'' + nolimiter::string() + "\' | \'"
7116 : : + wenop1::string() + "\' | \'"
7117 : : + superbeep1::string() + "\' | \'"
7118 : : + vertexbasedp1::string() + '\'';
7119 : : }
7120 : : };
7121 : : };
7122 : : using limiter = keyword< limiter_info, TAOCPP_PEGTL_STRING("limiter") >;
7123 : :
7124 : : struct fct_info {
7125 : : static std::string name() { return "Flux-corrected transport"; }
7126 : : static std::string shortDescription() { return
7127 : : "Turn flux-corrected transport on/off"; }
7128 : : static std::string longDescription() { return
7129 : : R"(This keyword can be used to turn on/off flux-corrected transport (FCT).
7130 : : Note that FCT is only used in conjunction with continuous Galerkin finite
7131 : : element discretization, configured by scheme diagcg and it has no
7132 : : effect when the discontinuous Galerkin (DG) scheme is used, configured by
7133 : : 'scheme dg'. Also note that even if FCT is turned off, it is still
7134 : : performed, only its result is not applied.)"; }
7135 : : struct expect {
7136 : : using type = bool;
7137 : : static std::string description() { return "string"; }
7138 : : static std::string choices() { return "true | false"; }
7139 : : };
7140 : : };
7141 : : using fct = keyword< fct_info, TAOCPP_PEGTL_STRING("fct") >;
7142 : :
7143 : : struct fctclip_info {
7144 : : static std::string name() { return "Clipping Flux-corrected transport"; }
7145 : : static std::string shortDescription() { return
7146 : : "Turn on clipping flux-corrected transport on/off"; }
7147 : : static std::string longDescription() { return
7148 : : R"(This keyword can be used to turn on/off the clipping limiter used for
7149 : : flux-corrected transport (FCT). The clipping limiter only looks at the
7150 : : current low order solution to determine the allowed solution minima and
7151 : : maxima, instead of the minimum and maximum of the low order solution and
7152 : : the previous solution.)"; }
7153 : : struct expect {
7154 : : using type = bool;
7155 : : static std::string description() { return "string"; }
7156 : : static std::string choices() { return "true | false"; }
7157 : : };
7158 : : };
7159 : : using fctclip = keyword< fctclip_info, TAOCPP_PEGTL_STRING("fctclip") >;
7160 : :
7161 : : struct sysfct_info {
7162 : : static std::string name() { return "Flux-corrected transport for systems"; }
7163 : : static std::string shortDescription() { return
7164 : : "Turn on system nature of flux-corrected transport"; }
7165 : : static std::string longDescription() { return
7166 : : R"(This keyword can be used to enable a system-nature for flux-corrected
7167 : : transport (FCT). Note that FCT is only used in conjunction with continuous
7168 : : Galerkin finite element discretization, configured by scheme diagcg and it
7169 : : has no effect when the discontinuous Galerkin (DG) scheme is used,
7170 : : configured by 'scheme dg'. Enabling the system-nature for FCT will choose
7171 : : the limiter coefficients for a system of equations, e.g., compressible flow,
7172 : : in way that takes the system-nature of the equations into account. An
7173 : : example is assinging the minimum of the limit coefficient to all variables
7174 : : limited in a computational cell, e.g., density, momentum, and specitic total
7175 : : energy. This yields better, more monotonic, results.)"; }
7176 : : struct expect {
7177 : : using type = bool;
7178 : : static std::string description() { return "string"; }
7179 : : static std::string choices() { return "true | false"; }
7180 : : };
7181 : : };
7182 : : using sysfct = keyword< sysfct_info, TAOCPP_PEGTL_STRING("sysfct") >;
7183 : :
7184 : : struct sysfctvar_info {
7185 : : static std::string name() { return "Variables considered for system FCT"; }
7186 : : static std::string shortDescription() { return
7187 : : "Specify a list of scalar component indices that considered for system FCT";
7188 : : }
7189 : : static std::string longDescription() { return
7190 : : R"(This keyword is used to specify a list of integers that are considered
7191 : : for computing the system-nature of flux-corrected transport. Example:
7192 : : 'sysfctvar 0 1 2 3 end', which means ignoring the energy (by not listing 4)
7193 : : when computing the coupled limit coefficient for a system of mass, momentum,
7194 : : and energy for single-material compressible flow.)";
7195 : : }
7196 : : struct expect {
7197 : : using type = std::size_t;
7198 : : static std::string description() { return "integers"; }
7199 : : };
7200 : : };
7201 : : using sysfctvar = keyword< sysfctvar_info, TAOCPP_PEGTL_STRING("sysfctvar") >;
7202 : :
7203 : : ////////// NOT YET FULLY DOCUMENTED //////////
7204 : :
7205 : : struct mix_iem_info {
7206 : : static std::string name() { return "IEM"; }
7207 : : static std::string shortDescription() { return
7208 : : "Interaction by exchange with the mean"; }
7209 : : static std::string longDescription() { return
7210 : : R"(Material mix model, 'mix_iem', is short for interaction by exchange with
7211 : : the mean (IEM). It is a relaxation-type material mix model intended
7212 : : shear-driven flows.)";
7213 : : }
7214 : : };
7215 : : using mix_iem = keyword<mix_iem_info, TAOCPP_PEGTL_STRING("mix_iem") >;
7216 : :
7217 : : struct mix_iecm_info {
7218 : : static std::string name() { return "IECM"; }
7219 : : static std::string shortDescription()
7220 : : { return "Interaction by exchange with the conditional mean"; }
7221 : : static std::string longDescription() { return
7222 : : R"(Material mix model, 'mix_iecm', is short for interaction by exchange with
7223 : : the conditional mean (IECM). It is a relaxation-type material mix model
7224 : : intended shear-driven flows.)";
7225 : : }
7226 : : };
7227 : : using mix_iecm = keyword<mix_iecm_info, TAOCPP_PEGTL_STRING("mix_iecm") >;
7228 : :
7229 : : struct mix_dir_info {
7230 : : static std::string name() { return "Dirichlet"; }
7231 : : static std::string shortDescription() { return "Dirichlet"; }
7232 : : static std::string longDescription() { return
7233 : : R"(Material mix model, 'mix_dir', is short for Dirichlet. It is a material
7234 : : mix model that explicitly satisfies the unit-sum requirement for all
7235 : : statistical samples.)";
7236 : : }
7237 : : };
7238 : : using mix_dir = keyword<mix_dir_info, TAOCPP_PEGTL_STRING("mix_dir") >;
7239 : :
7240 : : struct mix_gendir_info {
7241 : : static std::string name() { return "Generalized Dirichlet"; }
7242 : : static std::string shortDescription() { return "Generalized Dirichlet"; }
7243 : : static std::string longDescription() { return
7244 : : R"(Material mix model, 'mix_gendir', is short for Lochner's generalized
7245 : : Dirichlet. It is a material mix model that explicitly satisfies the
7246 : : unit-sum requirement for all statistical samples.)";
7247 : : }
7248 : : };
7249 : : using mix_gendir = keyword<mix_gendir_info, TAOCPP_PEGTL_STRING("mix_gendir") >;
7250 : :
7251 : : struct hommix_info {
7252 : : static std::string name() { return "HomMix"; }
7253 : : static std::string shortDescription()
7254 : : { return "Homogeneous material mixing"; }
7255 : : static std::string longDescription() { return
7256 : : R"(Physics option, 'hommix', is short for homogeneous material mixing. It is
7257 : : the simplest physics option that can be used to research, develop, and
7258 : : test material mixing models independent, i.e., decoupled from other
7259 : : equations. Only a set of scalar equations are advanced which can be
7260 : : coupled to each other. The keyword 'hommix' introduces the hommix ... end
7261 : : block, selecting and describing the parameters of the mixing model(s).
7262 : : The common physics keywords are recognized.)";
7263 : : }
7264 : : };
7265 : : using hommix = keyword<hommix_info, TAOCPP_PEGTL_STRING("hommix") >;
7266 : :
7267 : : struct homhydro_info {
7268 : : static std::string name() { return "HomHydro"; }
7269 : : static std::string shortDescription() { return "Homogeneous hydrodynamics"; }
7270 : : static std::string longDescription() { return
7271 : : R"(Physics option, 'homhydro', is short for homogeneous hydrodynamics. It is
7272 : : the simplest physics option that can be used to research, develop, and
7273 : : test hydrodynamics models independent of, i.e., decoupled from other
7274 : : equations. Only a set of momentum equations are advanced whose components
7275 : : can be coupled to each other. The keyword 'homhydro' introduces the
7276 : : homhydro ... end block, selecting and describing the parameters of the
7277 : : hydrodynamics model(s). The common physics keywords are recognized.)";
7278 : : }
7279 : : };
7280 : : using homhydro = keyword<homhydro_info, TAOCPP_PEGTL_STRING("homhydro") >;
7281 : :
7282 : : struct homrt_info {
7283 : : static std::string name() { return "HomRT"; }
7284 : : static std::string shortDescription()
7285 : : { return "Homogeneous Rayleigh-Taylor"; }
7286 : : static std::string longDescription() { return
7287 : : R"(Physics option, 'homrt', is short for homogeneous Rayleigh-Taylor. It is
7288 : : the simplest physics option that can be used to research, develop, and
7289 : : test hydrodynamics models for variable-density hydrodynamics and coupled
7290 : : material mixing, independent, i.e., decoupled from other equations. Only
7291 : : a set of mass and momentum conservation equations are advanced whose
7292 : : components can be coupled to each other. The keyword 'homrt' introduces
7293 : : the homrt ... end block, selecting and describing the parameters of the
7294 : : mass and hydrodynamics model(s). The common physics keywords are
7295 : : recognized.)";
7296 : : }
7297 : : };
7298 : : using homrt = keyword<homrt_info, TAOCPP_PEGTL_STRING("homrt") >;
7299 : :
7300 : : struct spinsflow_info {
7301 : : static std::string name() { return "SPINSFlow"; }
7302 : : static std::string shortDescription() { return
7303 : : "Standalone-particle incompressible Navier-Stokes flow";
7304 : : }
7305 : : static std::string longDescription() { return
7306 : : R"(Physics option, 'spinsflow', is short for standalone-particle
7307 : : incompressible Navier-Stokes flow. It is a physics option intended for
7308 : : inhomogeneous constant-density flow. The transport equations solved are
7309 : : the momentum and optionally, energy, and a set of scalars. The
7310 : : divergence-constraint is enforced by solving a Poisson equation and
7311 : : projection scheme. The keyword 'spinsflow' introduces the spinsflow ...
7312 : : end block, selecting and describing the parameters of the above transport
7313 : : equations and their models. The common physics keywords are recognized.)";
7314 : : }
7315 : : };
7316 : : using spinsflow = keyword<spinsflow_info, TAOCPP_PEGTL_STRING("spinsflow") >;
7317 : :
7318 : : // This will go away once all the keywords below are documented
7319 : : struct undefined_info {
7320 : : static std::string name() { return "undef"; }
7321 : : static std::string shortDescription() { return "undefined"; }
7322 : : static std::string longDescription() { return "Undefined."; }
7323 : : };
7324 : :
7325 : : } // kw::
7326 : :
7327 : : #endif // Keywords_h
|
