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 "QuinoaBuildConfig.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 [ + - ]: 2317 : static std::string shortDescription() { return "Set analysis title"; }
168 : 2317 : static std::string longDescription() { return
169 [ + - ]: 2317 : 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 [ + - ]: 2317 : 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 [ + - ]: 2317 : static std::string shortDescription() { return "End of an input block"; }
184 : 2317 : static std::string longDescription() { return
185 [ + - ]: 2317 : 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 : 4986 : static std::string shortDescription() { return
194 [ + - ]: 4986 : R"(Display one-liner help on all command-line arguments)"; }
195 : 4986 : static std::string longDescription() { return
196 [ + - ]: 4986 : 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 : 4945 : static std::string shortDescription() { return
209 [ + - ]: 4945 : "Display one-liner help on all control file keywords"; }
210 : 4945 : static std::string longDescription() { return
211 [ + - ]: 4945 : 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 : 4986 : static std::string shortDescription() { return
221 [ + - ]: 4986 : "Display verbose help on a single keyword"; }
222 : 4986 : static std::string longDescription() { return
223 [ + - ]: 4986 : 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 [ + - ]: 4986 : 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 : 752 : static std::string shortDescription() { return
238 [ + - ]: 752 : "Set random number generator seed"; }
239 : 752 : static std::string longDescription() { return
240 [ + - ]: 752 : 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 [ + - ]: 752 : 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 : : static std::string name() { return "MKL MCG311"; }
252 : : static std::string shortDescription() { return
253 : : "Select Intel MKL MCG31 RNG"; }
254 : : static std::string longDescription() { return
255 : : 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 : : static std::string name() { return "MKL R250"; }
264 : : static std::string shortDescription() { return
265 : : "Select Intel MKL R250 RNG"; }
266 : : static std::string longDescription() { return
267 : : 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 : : static std::string name() { return "MKL MRG32K3A"; }
276 : : static std::string shortDescription() { return
277 : : "Select Intel MKL MRG32K3A RNG"; }
278 : : static std::string longDescription() { return
279 : : 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 : : static std::string name() { return "MKL MCG59"; }
289 : : static std::string shortDescription() { return
290 : : "Select Intel MKL MCG59 RNG"; }
291 : : static std::string longDescription() { return
292 : : 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 : : static std::string name() { return "MKL WH"; }
302 : : static std::string shortDescription() { return
303 : : "Select Intel MKL WH RNG"; }
304 : : static std::string longDescription() { return
305 : : 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 : : static std::string name() { return "MKL MT19937"; }
314 : : static std::string shortDescription() { return
315 : : "Select Intel MKL MT19937 RNG"; }
316 : : static std::string longDescription() { return
317 : : 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 : : static std::string name() { return "MKL MT2203"; }
327 : : static std::string shortDescription() { return
328 : : "Select Intel MKL MT2203 RNG"; }
329 : : static std::string longDescription() { return
330 : : 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 : : static std::string name() { return "MKL SFMT19937"; }
339 : : static std::string shortDescription() { return
340 : : "Select Intel MKL SFMT19937 RNG"; }
341 : : static std::string longDescription() { return
342 : : 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 : : static std::string name() { return "MKL SOBOL"; }
352 : : static std::string shortDescription() { return
353 : : "Select Intel MKL SOBOL RNG"; }
354 : : static std::string longDescription() { return
355 : : 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 : : static std::string name() { return "MKL NIEDERR"; }
365 : : static std::string shortDescription() { return
366 : : "Select Intel MKL NIEDERR RNG"; }
367 : : static std::string longDescription() { return
368 : : 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 : : static std::string name() { return "MKL NONDETERM"; }
417 : : static std::string shortDescription() { return
418 : : "Select Intel MKL NONDETERM RNG"; }
419 : : static std::string longDescription() { return
420 : : 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 : : static std::string name() { return "standard"; }
429 : : static std::string shortDescription() { return
430 : : "Select the standard algorithm for uniform RNG"; }
431 : : static std::string longDescription() { return
432 : : 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 : : static std::string name() { return "accurate"; }
441 : : static std::string shortDescription() { return
442 : : "Select the accurate algorithm for uniform RNG"; }
443 : : static std::string longDescription() { return
444 : : 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 : : static std::string shortDescription() { return
454 : : "Select an Intel MKL uniform RNG method"; }
455 : : static std::string longDescription() { return
456 : : 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 : : static std::string description() { return "string"; }
462 : : static std::string choices() {
463 : : return '\'' + standard::string() + "\' | \'"
464 : : + 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 : : static std::string name() { return "Box-Muller"; }
473 : : static std::string shortDescription() { return
474 : : "Select the Box-Muller algorithm for sampling a Gaussian"; }
475 : : static std::string longDescription() { return
476 : : 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 : : static std::string name() { return "Box-Muller 2"; }
486 : : static std::string shortDescription() { return
487 : : "Select the Box-Muller 2 algorithm for sampling a Gaussian"; }
488 : : static std::string longDescription() { return
489 : : 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 : : static std::string name() { return "ICDF"; }
498 : : static std::string shortDescription() { return
499 : : R"(Use inverse cumulative distribution function for sampling a Gaussian)"; }
500 : : static std::string longDescription() { return
501 : : 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 : : static std::string shortDescription() { return
511 : : "Select an Intel MKL Gaussian RNG method"; }
512 : : static std::string longDescription() { return
513 : : 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 : : static std::string description() { return "string"; }
519 : : static std::string choices() {
520 : : return '\'' + boxmuller::string() + "\' | \'"
521 : : + boxmuller2::string() + "\' | \'"
522 : : + 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 : : static std::string shortDescription() { return
532 : : "Select an Intel MKL multi-variate Gaussian RNG method"; }
533 : : static std::string longDescription() { return
534 : : 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 : : static std::string description() { return "string"; }
541 : : static std::string choices() {
542 : : return '\'' + boxmuller::string() + "\' | \'"
543 : : + boxmuller2::string() + "\' | \'"
544 : : + 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 : : static std::string name() { return "CJA"; }
553 : 752 : static std::string shortDescription() { return
554 [ + - ]: 752 : "Select the Cheng, Johnk, Atkinson algorithm for sampling a beta"; }
555 : 752 : static std::string longDescription() { return
556 [ + - ]: 752 : 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 : : static std::string name() { return "CJA accurate"; }
565 : 752 : static std::string shortDescription() { return
566 [ + - ]: 752 : "Select the accurate Cheng, Johnk, Atkinson algorithm for sampling a beta"; }
567 : 752 : static std::string longDescription() { return
568 [ + - ]: 752 : 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 : : static std::string shortDescription() { return
579 : : "Select an Intel MKL beta RNG method"; }
580 : : static std::string longDescription() { return
581 : : 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 : : static std::string description() { return "string"; }
587 : : static std::string choices() {
588 : : return '\'' + cja::string() + "\' | \'"
589 : : + 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 : : static std::string name() { return "GNORM"; }
598 : 752 : static std::string shortDescription() { return
599 [ + - ]: 752 : "Select the GNORM (see MKL doc) algorithm for sampling a gamma"; }
600 : 752 : static std::string longDescription() { return
601 [ + - ]: 752 : 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 : : static std::string name() { return "GNORM accurate"; }
610 : 752 : static std::string shortDescription() { return
611 [ + - ]: 752 : "Select the accurate GNORM (see MKL doc) algorithm for sampling a gamma"; }
612 : 752 : static std::string longDescription() { return
613 [ + - ]: 752 : 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 : 752 : static std::string shortDescription() { return
624 [ + - ]: 752 : "Select an Intel MKL gamma RNG method"; }
625 : 752 : static std::string longDescription() { return
626 [ + - ]: 752 : 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 [ + - ]: 752 : static std::string description() { return "string"; }
632 : 752 : static std::string choices() {
633 [ + - ][ + - ]: 1504 : return '\'' + gnorm::string() + "\' | \'"
[ + - ]
634 [ + - ][ + - ]: 3008 : + 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 [ + - ]: 1762 : static std::string name() { return "RNGSSE GM19"; }
643 : 752 : static std::string shortDescription() { return
644 [ + - ]: 752 : "Select RNGSSE GM19 RNG"; }
645 : 752 : static std::string longDescription() { return
646 [ + - ]: 752 : 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 [ + - ]: 1762 : static std::string name() { return "RNGSSE GM29"; }
658 : 752 : static std::string shortDescription() { return
659 [ + - ]: 752 : "Select RNGSSE GM29 RNG"; }
660 : 752 : static std::string longDescription() { return
661 [ + - ]: 752 : 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 [ + - ]: 1762 : static std::string name() { return "RNGSSE GM31"; }
673 : 752 : static std::string shortDescription() { return
674 [ + - ]: 752 : "Select RNGSSE GM31 RNG"; }
675 : 752 : static std::string longDescription() { return
676 [ + - ]: 752 : 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 [ + - ]: 1762 : static std::string name() { return "RNGSSE GM55"; }
688 : 752 : static std::string shortDescription() { return
689 [ + - ]: 752 : "Select RNGSSE GM55 RNG"; }
690 : 752 : static std::string longDescription() { return
691 [ + - ]: 752 : 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 [ + - ]: 1762 : static std::string name() { return "RNGSSE GM61"; }
703 : 752 : static std::string shortDescription() { return
704 [ + - ]: 752 : "Select RNGSSE GM61 RNG"; }
705 : 752 : static std::string longDescription() { return
706 [ + - ]: 752 : 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 [ + - ]: 1762 : static std::string name() { return "RNGSSE GQ58.1"; }
718 : 752 : static std::string shortDescription() { return
719 [ + - ]: 752 : "Select RNGSSE GQ58.1 RNG"; }
720 : 752 : static std::string longDescription() { return
721 [ + - ]: 752 : 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 [ + - ]: 1762 : static std::string name() { return "RNGSSE GQ58.3"; }
733 : 752 : static std::string shortDescription() { return
734 [ + - ]: 752 : "Select RNGSSE GQ58.3 RNG"; }
735 : 752 : static std::string longDescription() { return
736 [ + - ]: 752 : 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 [ + - ]: 1762 : static std::string name() { return "RNGSSE GQ58.4"; }
748 : 752 : static std::string shortDescription() { return
749 [ + - ]: 752 : "Select RNGSSE GQ58.4 RNG"; }
750 : 752 : static std::string longDescription() { return
751 [ + - ]: 752 : 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 [ + - ]: 1762 : static std::string name() { return "RNGSSE MT19937"; }
763 : 752 : static std::string shortDescription() { return
764 [ + - ]: 752 : "Select RNGSSE MT19937 RNG"; }
765 : 752 : static std::string longDescription() { return
766 [ + - ]: 752 : 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 [ + - ]: 1762 : static std::string name() { return "RNGSSE LSFR113"; }
776 : 752 : static std::string shortDescription() { return
777 [ + - ]: 752 : "Select RNGSSE LFSR113 RNG"; }
778 : 752 : static std::string longDescription() { return
779 [ + - ]: 752 : 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 [ + - ]: 1762 : static std::string name() { return "RNGSSE MRG32K3A"; }
789 : 752 : static std::string shortDescription() { return
790 [ + - ]: 752 : "Select RNGSSE MRG32K3A RNG"; }
791 : 752 : static std::string longDescription() { return
792 [ + - ]: 752 : 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 [ + - ]: 3 : 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 [ + - ]: 3 : 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 [ + - ]: 3 : 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 : 752 : static std::string shortDescription() { return
843 [ + - ]: 752 : "Specify the RNGSSE RNG sequence length"; }
844 : 752 : static std::string longDescription() { return
845 [ + - ]: 752 : 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 [ + - ]: 752 : static std::string description() { return "string"; }
852 : 752 : static std::string choices() {
853 [ + - ][ + - ]: 1504 : return '\'' + seq_short::string() + "\' | \'"
[ + - ]
854 [ + - ][ + - ]: 3008 : + seq_med::string() + "\' | \'"
[ + - ]
855 [ + - ][ + - ]: 3008 : + seq_long::string() + '\'';
856 : : }
857 : : };
858 : : };
859 : : using seqlen = keyword< seqlen_info, TAOCPP_PEGTL_STRING("seqlen") >;
860 : :
861 : : struct r123_threefry_info {
862 [ + - ]: 1762 : static std::string name() { return "Random123 ThreeFry"; }
863 : 752 : static std::string shortDescription() { return
864 [ + - ]: 752 : "Select Random123 ThreeFry RNG"; }
865 : 752 : static std::string longDescription() { return
866 [ + - ]: 752 : 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 [ + - ]: 1762 : static std::string name() { return "Random123 Philox"; }
877 : 752 : static std::string shortDescription() { return
878 [ + - ]: 752 : "Select Random123 Philox RNG"; }
879 : 752 : static std::string longDescription() { return
880 [ + - ]: 752 : 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 : 572 : static std::string shortDescription() { return
892 [ + - ]: 572 : "Start of probability density function (PDF) input block"; }
893 : 572 : static std::string longDescription() { return
894 [ + - ]: 572 : 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 [ + - ]: 26 : static std::string name() { return "txt"; }
908 : 572 : static std::string shortDescription() { return
909 [ + - ]: 572 : "Select ASCII output for outputing PDFs"; }
910 : 572 : static std::string longDescription() { return
911 [ + - ]: 572 : 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 [ + - ]: 26 : static std::string name() { return "gmshtxt"; }
922 : 572 : static std::string shortDescription() { return
923 [ + - ]: 572 : "Select Gmsh ASCII output for outputing PDFs"; }
924 : 572 : static std::string longDescription() { return
925 [ + - ]: 572 : 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 [ + - ]: 26 : static std::string name() { return "gmshbin"; }
937 : 572 : static std::string shortDescription() { return
938 [ + - ]: 572 : "Select Gmsh binary output for outputing PDFs"; }
939 : 572 : static std::string longDescription() { return
940 [ + - ]: 572 : 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 [ + - ]: 32 : static std::string name() { return "exo"; }
952 : 2137 : static std::string shortDescription() { return
953 [ + - ]: 2137 : "Select ExodusII output"; }
954 : 2137 : static std::string longDescription() { return
955 [ + - ]: 2137 : 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 : 1565 : static std::string shortDescription() { return
968 [ + - ]: 1565 : "Select Root output"; }
969 : 1565 : static std::string longDescription() { return
970 [ + - ]: 1565 : 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 : 2137 : static std::string shortDescription() { return
981 [ + - ]: 2137 : "Select output file type"; }
982 : 2137 : static std::string longDescription() { return
983 [ + - ]: 2137 : 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 [ + - ]: 2137 : static std::string description() { return "string"; }
992 : 2137 : static std::string choices() {
993 [ + - ][ + - ]: 4274 : return '\'' + txt::string() + "\' | \'"
[ + - ]
994 [ + - ][ + - ]: 8548 : + gmshtxt::string() + "\' | \'"
[ + - ]
995 [ + - ][ + - ]: 8548 : + gmshbin::string() + "\' | \'"
[ + - ]
996 [ + - ][ + - ]: 8548 : + root::string() + "\' | \'"
[ + - ]
997 [ + - ][ + - ]: 8548 : + exodusii::string() + '\'';
998 : : }
999 : : };
1000 : :
1001 : : };
1002 : : using filetype = keyword< filetype_info, TAOCPP_PEGTL_STRING("filetype") >;
1003 : :
1004 : : struct overwrite_info {
1005 [ + - ]: 26 : static std::string name() { return "overwrite"; }
1006 : 572 : static std::string shortDescription() { return
1007 [ + - ]: 572 : "Select PDF output policy overwrite"; }
1008 : 572 : static std::string longDescription() { return
1009 [ + - ]: 572 : 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 [ + - ]: 26 : static std::string name() { return "multiple"; }
1022 : 572 : static std::string shortDescription() { return
1023 [ + - ]: 572 : "Select PDF output policy multiple"; }
1024 : 572 : static std::string longDescription() { return
1025 [ + - ]: 572 : 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 [ + - ]: 26 : static std::string name() { return "evolution"; }
1038 : 572 : static std::string shortDescription() { return
1039 [ + - ]: 572 : "Select PDF output policy evolution"; }
1040 : 572 : static std::string longDescription() { return
1041 [ + - ]: 572 : 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 : 572 : static std::string shortDescription() { return
1057 [ + - ]: 572 : "Select PDF output file policy"; }
1058 : 572 : static std::string longDescription() { return
1059 [ + - ]: 572 : 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 [ + - ]: 572 : static std::string description() { return "string"; }
1068 : 572 : static std::string choices() {
1069 [ + - ][ + - ]: 1144 : return '\'' + overwrite::string() + "\' | \'"
[ + - ]
1070 [ + - ][ + - ]: 2288 : + multiple::string() + "\' | \'"
[ + - ]
1071 [ + - ][ + - ]: 2288 : + evolution::string() + '\'';
1072 : : }
1073 : : };
1074 : : };
1075 : : using pdf_policy = keyword< policy_info, TAOCPP_PEGTL_STRING("policy") >;
1076 : :
1077 : : struct txt_float_default_info {
1078 [ + - ]: 242 : static std::string name() { return "default"; }
1079 : 2137 : static std::string shortDescription() { return
1080 [ + - ]: 2137 : "Select the default ASCII floating-point output"; }
1081 : 2137 : static std::string longDescription() { return
1082 [ + - ]: 2137 : 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 [ + - ]: 242 : static std::string name() { return "scientific"; }
1095 : 2137 : static std::string shortDescription() { return
1096 [ + - ]: 2137 : "Select the scientific ASCII floating-point output"; }
1097 : 2137 : static std::string longDescription() { return
1098 [ + - ]: 2137 : 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 [ + - ]: 242 : static std::string name() { return "fixed"; }
1111 : 2137 : static std::string shortDescription() { return
1112 [ + - ]: 2137 : "Select the fixed ASCII floating-point output"; }
1113 : 2137 : static std::string longDescription() { return
1114 [ + - ]: 2137 : 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 : 2137 : static std::string shortDescription() { return
1127 [ + - ]: 2137 : "Specify the ASCII floating-point output format"; }
1128 : 2137 : static std::string longDescription() { return
1129 [ + - ]: 2137 : 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 [ + - ]: 2137 : static std::string description() { return "string"; }
1137 : 2137 : static std::string choices() {
1138 [ + - ][ + - ]: 4274 : return '\'' + txt_float_default::string() + "\' | \'"
[ + - ]
1139 [ + - ][ + - ]: 8548 : + txt_float_scientific::string() + "\' | \'"
[ + - ]
1140 [ + - ][ + - ]: 8548 : + 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 : 2137 : static std::string shortDescription() { return
1150 [ + - ]: 2137 : R"(Precision in digits for ASCII floating-point output)"; }
1151 : 2137 : static std::string longDescription() { return
1152 [ + - ]: 2137 : 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 [ + - ]: 2137 : static std::string description() { return "int"; }
1166 : 2137 : static std::string choices() {
1167 [ + - ][ + - ]: 4274 : return "integer between [" + std::to_string(lower) + "..." +
[ + - ][ + - ]
1168 [ + - ]: 6411 : 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 [ + - ]: 26 : static std::string name() { return "elem"; }
1176 : 2137 : static std::string shortDescription() { return
1177 [ + - ]: 2137 : "Specify elem-centering for output"; }
1178 : 2137 : static std::string longDescription() { return
1179 [ + - ]: 2137 : 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 [ + - ]: 26 : static std::string name() { return "node"; }
1192 : 2137 : static std::string shortDescription() { return
1193 [ + - ]: 2137 : "Specify node-centering for output"; }
1194 : 2137 : static std::string longDescription() { return
1195 [ + - ]: 2137 : 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 : 572 : static std::string shortDescription() { return
1209 [ + - ]: 572 : "Specify data-centering for PDF output"; }
1210 : 572 : static std::string longDescription() { return
1211 [ + - ]: 572 : 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 [ + - ]: 572 : static std::string description() { return "string"; }
1220 : 572 : static std::string choices() {
1221 [ + - ][ + - ]: 1144 : return '\'' + elem::string() + "\' | \'"
[ + - ]
1222 [ + - ][ + - ]: 2288 : + node::string() + '\'';
1223 : : }
1224 : : };
1225 : : };
1226 : : using pdf_centering = keyword< centering_info, TAOCPP_PEGTL_STRING("centering") >;
1227 : :
1228 : : struct raw_info {
1229 [ + - ]: 180 : static std::string name() { return "raw"; }
1230 : 572 : static std::string shortDescription() { return
1231 [ + - ]: 572 : "Select the raw initialization policy"; }
1232 : 572 : static std::string longDescription() { return
1233 [ + - ]: 572 : R"(This keyword is used to select the raw
1234 : : initialization policy. The initialization policy is used to specify how
1235 : : the initial conditions are set at t = 0 before time-integration.
1236 : : Example: "init raw", which selects raw initialization policy, which
1237 : : leaves the memory uninitialized. Note that this option may behave
1238 : : differently depending on the particular equation or physical model. See the
1239 : : the init policies in DiffEq/InitPolicy.hpp for valid options.)"; }
1240 : : };
1241 : : using raw = keyword< raw_info, TAOCPP_PEGTL_STRING("raw") >;
1242 : :
1243 : : struct zero_info {
1244 [ + - ]: 180 : static std::string name() { return "zero"; }
1245 : 572 : static std::string shortDescription() { return
1246 [ + - ]: 572 : "Select the zero initialization policy"; }
1247 : 572 : static std::string longDescription() { return
1248 [ + - ]: 572 : R"(This keyword is used to select the zero
1249 : : initialization policy. The initialization policy is used to specify how
1250 : : the initial conditions are set at t = 0 before time-integration.
1251 : : Example: "init zero", which selects zero initialization policy, which
1252 : : puts zeros in memory. Note that this option may behave differently
1253 : : depending on the particular equation or physical model. See the init
1254 : : policies in DiffEq/InitPolicy.hpp for valid options.)"; }
1255 : : };
1256 : : using zero = keyword< zero_info, TAOCPP_PEGTL_STRING("zero") >;
1257 : :
1258 : : struct jointdelta_info {
1259 [ + - ]: 180 : static std::string name() { return "delta"; }
1260 : 572 : static std::string shortDescription() { return
1261 [ + - ]: 572 : "Select the joint delta initialization policy"; }
1262 : 572 : static std::string longDescription() { return
1263 [ + - ]: 572 : R"(This keyword is used to select the joint delta initialization policy.
1264 : : The initialization policy is used to specify how the initial conditions are
1265 : : set at t = 0 before time-integration. Example: "init zero", which selects
1266 : : zero initialization policy, which puts zeros in memory. Note that this
1267 : : option may behave differently depending on the particular equation or
1268 : : physical model. For an example, see tk::InitPolicies in
1269 : : DiffEq/InitPolicy.hpp for valid options.) The joint delta initialization
1270 : : policy can be used to prescribe delta-spikes on the sample space with given
1271 : : heights, i.e., probabilities. Example: "init jointdelta" - select delta
1272 : : init-policy, "delta spike 0.1 0.3 0.8 0.7 end end" - prescribe two
1273 : : delta-spikes at sample space positions 0.1 and 0.8 with spike heights 0.3
1274 : : and 0.7, respectively. Note that the sum of the heights must add up to
1275 : : unity. See also the help on keyword spike.)"; }
1276 : : };
1277 : : using jointdelta = keyword< jointdelta_info, TAOCPP_PEGTL_STRING("jointdelta") >;
1278 : :
1279 : : struct jointgaussian_info {
1280 [ + - ]: 180 : static std::string name() { return "Gaussian"; }
1281 : 572 : static std::string shortDescription() { return
1282 [ + - ]: 572 : "Select the joint Gaussian initialization policy"; }
1283 : 572 : static std::string longDescription() { return
1284 [ + - ]: 572 : R"(This keyword is used to select the joint Gaussian initialization policy.
1285 : : The initialization policy is used to specify how the initial conditions are
1286 : : set at t = 0 before time-integration. Example: "init zero", which selects
1287 : : zero initialization policy, which puts zeros in memory. Note that this
1288 : : option may behave differently depending on the particular equation or
1289 : : physical model. For an example, see tk::InitPolicies in
1290 : : DiffEq/InitPolicy.hpp for valid options.) The joint Gaussian initialization
1291 : : policy can be used to prescribe a joint Gaussian (joint Gaussian) on the
1292 : : sample space with given variances. Example: "init jointgaussian" - select
1293 : : (joint) Gaussian init-policy, "gaussian 0.1 0.3 0.8 0.7 end" - prescribe two
1294 : : Gaussians with mean 0.1 and variance 0.3, and with mean 0.8 and 0.7,
1295 : : respectively. Note that the means can be any real number while the
1296 : : variances must be positive. No correlations between the Gaussians (as the
1297 : : initial conditions) are supported.)"; }
1298 : : };
1299 : : using jointgaussian =
1300 : : keyword< jointgaussian_info, TAOCPP_PEGTL_STRING("jointgaussian") >;
1301 : :
1302 : : struct jointcorrgaussian_info {
1303 [ + - ]: 180 : static std::string name() { return "correlated Gaussian"; }
1304 : 572 : static std::string shortDescription() { return
1305 [ + - ]: 572 : "Select the joint correlated Gaussian initialization policy"; }
1306 : 572 : static std::string longDescription() { return
1307 [ + - ]: 572 : R"(This keyword is used to select the joint correlated Gaussian
1308 : : initialization policy. The initialization policy is used to specify how the
1309 : : initial conditions are
1310 : : set at t = 0 before time-integration. Example: "init zero", which selects
1311 : : zero initialization policy, which puts zeros in memory. Note that this
1312 : : option may behave differently depending on the particular equation or
1313 : : physical model. For an example, see tk::InitPolicies in
1314 : : DiffEq/InitPolicy.hpp for valid options.) The joint correlated Gaussian
1315 : : initialization policy can be used to prescribe a joint correlated Gaussian
1316 : : on the sample space with a given covariance matrix. Example:
1317 : : "init jointcorrgaussian
1318 : : icjointgaussian
1319 : : mean 0.0 0.5 1.0 end
1320 : : cov
1321 : : 4.0 2.5 1.1
1322 : : 32.0 5.6
1323 : : 23.0
1324 : : end
1325 : : end")"; }
1326 : : };
1327 : : using jointcorrgaussian =
1328 : : keyword< jointcorrgaussian_info, TAOCPP_PEGTL_STRING("jointcorrgaussian") >;
1329 : :
1330 : : struct jointbeta_info {
1331 [ + - ]: 180 : static std::string name() { return "beta"; }
1332 : 572 : static std::string shortDescription() { return
1333 [ + - ]: 572 : "Select the joint beta initialization policy"; }
1334 : 572 : static std::string longDescription() { return
1335 [ + - ]: 572 : R"(This keyword is used to select the joint beta initialization policy.
1336 : : The initialization policy is used to specify how the initial conditions are
1337 : : set at t = 0 before time-integration. Example: "init zero", which selects
1338 : : zero initialization policy, which puts zeros in memory. Note that this
1339 : : option may behave differently depending on the particular equation or
1340 : : physical model. For an example, see tk::InitPolicies in
1341 : : DiffEq/InitPolicy.hpp for valid options.) The joint beta initialization
1342 : : policy can be used to prescribe a multi-dimensional sample space where the
1343 : : samples are generated from a joint beta distribution with independent
1344 : : marginal univariate beta distributions.)";
1345 : : }
1346 : : };
1347 : : using jointbeta = keyword< jointbeta_info, TAOCPP_PEGTL_STRING("jointbeta") >;
1348 : :
1349 : : struct jointgamma_info {
1350 [ + - ]: 180 : static std::string name() { return "gamma"; }
1351 : 572 : static std::string shortDescription() { return
1352 [ + - ]: 572 : "Select the joint gamma initialization policy"; }
1353 : 572 : static std::string longDescription() { return
1354 [ + - ]: 572 : R"(This keyword is used to select the joint gamma initialization policy.
1355 : : The initialization policy is used to specify how the initial conditions are
1356 : : set at t = 0 before time-integration. Example: "init zero", which selects
1357 : : zero initialization policy, which puts zeros in memory. Note that this
1358 : : option may behave differently depending on the particular equation or
1359 : : physical model. For an example, see tk::InitPolicies in
1360 : : DiffEq/InitPolicy.hpp for valid options.) The joint gamma initialization
1361 : : policy can be used to prescribe a joint gamma distribution on the
1362 : : sample space with given shape and scale parameters. Example: "init
1363 : : jointgamma" - select the (joint) gamma init-policy, "gammapdf 0.1 0.3
1364 : : end" - prescribe a gamma distribution with shape 0.1 and scale 0.3
1365 : : parameters, respectively. Note that both shape and scale
1366 : : must be positive. Multiple independent gamma PDFs can be specified and the
1367 : : they will be used for the different scalar components configured for the
1368 : : equation. No correlations between the gamma distributions (as the
1369 : : initial conditions) are supported.)"; }
1370 : : };
1371 : : using jointgamma =
1372 : : keyword< jointgamma_info, TAOCPP_PEGTL_STRING("jointgamma") >;
1373 : :
1374 : : struct jointdirichlet_info {
1375 [ + - ]: 180 : static std::string name() { return "Dirichlet"; }
1376 : 572 : static std::string shortDescription() { return
1377 [ + - ]: 572 : "Select the Dirichlet initialization policy"; }
1378 : 572 : static std::string longDescription() { return
1379 [ + - ]: 572 : R"(This keyword is used to select the Dirichlet initialization policy.
1380 : : The initialization policy is used to specify how the initial conditions are
1381 : : set at t = 0 before time-integration. Example: "init zero", which selects
1382 : : zero initialization policy, which puts zeros in memory. Note that this
1383 : : option may behave differently depending on the particular equation or
1384 : : physical model. For an example, see tk::InitPolicies in
1385 : : DiffEq/InitPolicy.hpp for valid options.) The Dirichlet initialization
1386 : : policy can be used to prescribe a Dirichlet distribution on the
1387 : : sample space with given shape parameters. Example: "init
1388 : : jointdirichlet" - select the Dirichlet init-policy, "dirichletpdf 0.1 0.3
1389 : : 0.2 end" - prescribe a Dirichlet distribution with shape parameters 0.1,
1390 : : 0.3, and 0.2. All shape parameters must be positive.)"; }
1391 : : };
1392 : : using jointdirichlet =
1393 : : keyword< jointdirichlet_info, TAOCPP_PEGTL_STRING("jointdirichlet") >;
1394 : :
1395 : : struct init_info {
1396 : : static std::string name() { return "initialization policy"; }
1397 : 572 : static std::string shortDescription() { return
1398 [ + - ]: 572 : "Select initialization policy"; }
1399 : 572 : static std::string longDescription() { return
1400 [ + - ]: 572 : R"(This keyword is used to select an
1401 : : initialization policy. This is used to specify how the initial conditions
1402 : : are set at t = 0 before time-integration. Example: "init raw", which
1403 : : selects raw initialization policy, which leaves the memory uninitialized.
1404 : : Note that this option may behave differently depending on the particular
1405 : : equation or physical model. See the init policies in
1406 : : DiffEq/InitPolicy.hpp for valid options.)"; }
1407 : : struct expect {
1408 [ + - ]: 572 : static std::string description() { return "string"; }
1409 : 572 : static std::string choices() {
1410 [ + - ][ + - ]: 1144 : return '\'' + raw::string() + "\' | \'"
[ + - ]
1411 [ + - ][ + - ]: 2288 : + zero::string() + "\' | \'"
[ + - ]
1412 [ + - ][ + - ]: 2288 : + jointdelta::string() + "\' | \'"
[ + - ]
1413 [ + - ][ + - ]: 2288 : + jointbeta::string() + "\' | \'"
[ + - ]
1414 [ + - ][ + - ]: 2288 : + jointgaussian::string() + "\' | \'"
[ + - ]
1415 [ + - ][ + - ]: 2288 : + jointcorrgaussian::string() + "\' | \'"
[ + - ]
1416 [ + - ][ + - ]: 2288 : + jointgamma::string() + '\'';
1417 : : }
1418 : : };
1419 : : };
1420 : : using init = keyword< init_info, TAOCPP_PEGTL_STRING("init") >;
1421 : :
1422 : : struct constcoeff_info {
1423 [ + - ]: 172 : static std::string name() { return "constant coefficients"; }
1424 : 572 : static std::string shortDescription() { return
1425 [ + - ]: 572 : "Select constant coefficients policy"; }
1426 : 572 : static std::string longDescription() { return
1427 [ + - ]: 572 : R"(This keyword is used to select the 'constant coefficients' coefficients
1428 : : policy. A coefficients policy is used to specify how the coefficients are
1429 : : set at each time step during time-integration. Example: "coeff
1430 : : const_coeff", which selects 'constant coefficients' coefficients policy,
1431 : : which sets constant coefficients before t = 0 and leaves the coefficients
1432 : : unchanged during time integration. Note that this option may behave
1433 : : differently depending on the particular equation or physical model.)"; }
1434 : : };
1435 : : using constcoeff =
1436 : : keyword< constcoeff_info, TAOCPP_PEGTL_STRING("const_coeff") >;
1437 : :
1438 : : struct decay_info {
1439 [ + - ]: 172 : static std::string name() { return "decay"; }
1440 : 572 : static std::string shortDescription() { return
1441 [ + - ]: 572 : "Select decay coefficients policy"; }
1442 : 572 : static std::string longDescription() { return
1443 [ + - ]: 572 : R"(This keyword is used to select the decay coefficients policy. This policy
1444 : : (or model) is used to constrain a beta stochastic differential equation so
1445 : : that its variance, <y^2>, always decays. A coefficients policy, in general,
1446 : : is used to specify how the coefficients are set at each time step during
1447 : : time-integration. Example: "coeff const", which selects constant
1448 : : coefficients policy, which sets constant coefficients before t = 0 and
1449 : : leaves the coefficients unchanged during time integration. Note that this
1450 : : option may behave differently depending on the particular equation or
1451 : : physical model.)"; }
1452 : : };
1453 : : using decay = keyword< decay_info, TAOCPP_PEGTL_STRING("decay") >;
1454 : :
1455 : : struct homogeneous_info {
1456 [ + - ]: 172 : static std::string name() { return "homogeneous"; }
1457 : 572 : static std::string shortDescription() { return
1458 [ + - ]: 572 : "Select homogeneous coefficients policy"; }
1459 : 572 : static std::string longDescription() { return
1460 [ + - ]: 572 : R"(This keyword is used to select the homogeneous coefficients policy.
1461 : : This policy (or model) is used to constrain a Dirichlet stochastic
1462 : : differential equation so that its mean density stays constant.
1463 : : A coefficients policy, in general, is used to specify how the
1464 : : coefficients are set at each time step during time-integration. Example:
1465 : : "coeff const", which selects constant coefficients policy, which sets
1466 : : constant coefficients before t = 0 and leaves the coefficients unchanged
1467 : : during time integration. Note that this option may behave differently
1468 : : depending on the particular equation or physical model.)"; }
1469 : : };
1470 : : using homogeneous =
1471 : : keyword< homogeneous_info, TAOCPP_PEGTL_STRING("homogeneous") >;
1472 : :
1473 : : struct homdecay_info {
1474 [ + - ]: 172 : static std::string name() { return "homogeneous decay"; }
1475 : 572 : static std::string shortDescription() { return
1476 [ + - ]: 572 : "Select homogeneous decay coefficients policy"; }
1477 : 572 : static std::string longDescription() { return
1478 [ + - ]: 572 : R"(This keyword is used to select the homogeneous decay coefficients policy.
1479 : : This policy (or model) is used to constrain a beta stochastic differential
1480 : : equation so that its variance, <y^2>, always decays and its mean, <R> =
1481 : : rho2/(1+r<RY>/<R>), where Y = <Y> + y, does not change in time. Note that
1482 : : R = rho2/(1+rY). This policy is similar to 'montecarlo_homdecay', but
1483 : : computes the SDE coefficient S in a different but statistically equivalent
1484 : : way. While 'homdecay' only requires the estimation of statistics, <R>,
1485 : : <r^2>, and <r^3>, 'montecarlo_homdecay' requires <R^2>, <YR^2>, and
1486 : : <Y(1-Y)R^3>. A coefficients policy, in general, is used to specify how the
1487 : : coefficients are set at each time step during time-integration. Example:
1488 : : "coeff const", which selects constant coefficients policy, which sets
1489 : : constant coefficients before t = 0 and leaves the coefficients unchanged
1490 : : during time integration. Note that this option may behave differently
1491 : : depending on the particular equation or physical model.)"; }
1492 : : };
1493 : : using homdecay = keyword< homdecay_info, TAOCPP_PEGTL_STRING("homdecay") >;
1494 : :
1495 : : struct montecarlo_homdecay_info {
1496 [ + - ]: 172 : static std::string name() { return "Monte Carlo homogeneous decay"; }
1497 : 572 : static std::string shortDescription() { return
1498 [ + - ]: 572 : "Select Monte Carlo homogeneous decay coefficients policy"; }
1499 : 572 : static std::string longDescription() { return
1500 [ + - ]: 572 : R"(This keyword is used to select the Monte Carlo homogeneous decay
1501 : : coefficients policy. This policy (or model) is used to constrain a beta
1502 : : stochastic differential equation (SDE) so that its variance, <y^2>, always
1503 : : decays and its mean, <R> = rho2/(1+r<RY>/<R>), where Y = <Y> + y, does not
1504 : : change in time. Note that R = rho2/(1+rY). This policy is similar to
1505 : : 'homdecay', but computes the the SDE coefficient S in a different but
1506 : : statistically equivalent way. While 'homdecay' only requires the estimation
1507 : : of statistics, <R>, <r^2>, and <r^3>, 'montecarlo_homdecay' requires <R^2>,
1508 : : <YR^2>, and <Y(1-Y)R^3>. A coefficients policy, in general, is used to
1509 : : specify how the coefficients are set at each time step during
1510 : : time-integration. Example: "coeff const", which selects constant
1511 : : coefficients policy, which sets constant coefficients before t = 0 and
1512 : : leaves the coefficients unchanged during time integration. Note that this
1513 : : option may behave differently depending on the particular equation or
1514 : : physical model.)"; }
1515 : : };
1516 : : using montecarlo_homdecay =
1517 : : keyword< montecarlo_homdecay_info, TAOCPP_PEGTL_STRING("montecarlo_homdecay") >;
1518 : :
1519 : : struct hydrotimescale_info {
1520 [ + - ]: 172 : static std::string name() { return "hydro-timescale"; }
1521 : 572 : static std::string shortDescription() { return
1522 [ + - ]: 572 : "Select hydro-timescale coefficients policy"; }
1523 : 572 : static std::string longDescription() { return
1524 [ + - ]: 572 : R"(This keyword is used to select the hydrodynamics-timescale
1525 : : coefficients policy. This policy (or model) is used to constrain a
1526 : : beta stochastic differential equation (SDE) so that its variance, <y^2>,
1527 : : always decays and its mean, <R> = rho2/(1+r<RY>/<R>), where Y = <Y> + y,
1528 : : does not change in time. Note that R = rho2/(1+rY). This policy is similar
1529 : : to 'homdecay' as well as 'montecarlo_homdecay', but instead of simply
1530 : : constraining b' and kappa' to ensure decay in the evolution of <y^2>, b' and
1531 : : kappa' are specified as functions of an externally-specified hydrodynamics
1532 : : time scale, as a function of time. This policy is more similar to 'homdecay'
1533 : : than to 'montecarlo_homdecay' in that only requires the estimation
1534 : : of statistics, <R>, <r^2>, and <r^3>. A coefficients policy, in general, is
1535 : : used to specify how the coefficients are set at each time step during
1536 : : time-integration. Example: "coeff const", which selects constant
1537 : : coefficients policy, which sets constant coefficients before t = 0 and
1538 : : leaves the coefficients unchanged during time integration. Note that this
1539 : : option may behave differently depending on the particular equation or
1540 : : physical model.)"; }
1541 : : };
1542 : : using hydrotimescale =
1543 : : keyword< hydrotimescale_info, TAOCPP_PEGTL_STRING("hydrotimescale") >;
1544 : :
1545 : : struct const_shear_info {
1546 [ + - ]: 172 : static std::string name() { return "prescribed constant shear"; }
1547 : 572 : static std::string shortDescription() { return
1548 [ + - ]: 572 : "Select constant shear coefficients policy"; }
1549 : 572 : static std::string longDescription() { return
1550 [ + - ]: 572 : R"(This keyword is used to select the prescribed constant shear
1551 : : coefficients policy, used to compute a homogeneous free shear flow using the
1552 : : Langevin model. This policy (or model) prescribes a constant mean shear in
1553 : : the y direction and computes the dissipation of turbulent kinetic energy
1554 : : specifically for this flow. The flow is a fully developed homogeneous
1555 : : turbulent shear flow with a uniform mean velocity gradient in one direction
1556 : : (y) and the mean flow is in predominantly in the x direction. The flow is
1557 : : considered to be far from solid boundaries. See Pope, S.B. (2000). Turbulent
1558 : : flows (Cambridge: Cambridge University Press).)"; }
1559 : : };
1560 : : using const_shear =
1561 : : keyword< const_shear_info, TAOCPP_PEGTL_STRING("const_shear") >;
1562 : :
1563 : : struct stationary_info {
1564 [ + - ]: 172 : static std::string name() { return "stationary"; }
1565 : 572 : static std::string shortDescription() { return
1566 [ + - ]: 572 : "Select the stationary coefficients policy"; }
1567 : 572 : static std::string longDescription() { return
1568 [ + - ]: 572 : R"(This keyword is used to select the stationary coefficients
1569 : : policy. This policy will keep a stochastic differential equation at a
1570 : : constant statistically stationary state.)";
1571 : : }
1572 : : };
1573 : : using stationary =
1574 : : keyword< stationary_info, TAOCPP_PEGTL_STRING("stationary") >;
1575 : :
1576 : : struct inst_velocity_info {
1577 [ + - ]: 172 : static std::string name() { return "instantaneous velocity"; }
1578 : 572 : static std::string shortDescription() { return
1579 [ + - ]: 572 : "Select the instantaneous velocity coefficients policy"; }
1580 : 572 : static std::string longDescription() { return
1581 [ + - ]: 572 : R"(This keyword is used to select the instantaneous velocity coefficients
1582 : : policy. This is used to prescribe a coupling for instantaneous velocity to
1583 : : some other differential equation, e.g., to update Lagrangian particle
1584 : : position or to couple a mix model to velocity.)"; }
1585 : : };
1586 : : using inst_velocity =
1587 : : keyword< inst_velocity_info, TAOCPP_PEGTL_STRING("inst_velocity") >;
1588 : :
1589 : : struct coeff_info {
1590 : : static std::string name() { return "coefficients policy"; }
1591 : 572 : static std::string shortDescription() { return
1592 [ + - ]: 572 : "Select the coefficients policy"; }
1593 : 572 : static std::string longDescription() { return
1594 [ + - ]: 572 : R"(This keyword is used to select a
1595 : : coefficients policy. This is used to specify how the coefficients are set
1596 : : at each time step during time-integration. Example: "coeff const",
1597 : : which selects constant coefficients policy, which sets constant
1598 : : coefficients before t = 0 and leaves the coefficients unchanged during
1599 : : time integration. Note that this option may behave differently depending
1600 : : on the particular equation or physical model.)"; }
1601 : : struct expect {
1602 [ + - ]: 572 : static std::string description() { return "string"; }
1603 : 572 : static std::string choices() {
1604 [ + - ]: 572 : return '\'' +
1605 [ + - ][ + - ]: 1716 : kw::constcoeff::string() + "\' | \'" +
[ + - ]
1606 [ + - ][ + - ]: 2288 : kw::decay::string() + "\' | \'" +
[ + - ]
1607 [ + - ][ + - ]: 2288 : kw::homogeneous::string() + "\' | \'" +
[ + - ]
1608 [ + - ][ + - ]: 2288 : kw::homdecay::string() + "\' | \'" +
[ + - ]
1609 [ + - ][ + - ]: 2288 : kw::montecarlo_homdecay::string() + "\' | \'" +
[ + - ]
1610 [ + - ][ + - ]: 2288 : kw::hydrotimescale::string() + "\' | \'" +
[ + - ]
1611 [ + - ][ + - ]: 2288 : kw::const_shear::string() + "\' | \'" +
[ + - ]
1612 [ + - ][ + - ]: 2288 : kw::stationary::string() + "\' | \'" +
[ + - ]
1613 [ + - ]: 1716 : kw::inst_velocity::string() + '\'';
1614 : : }
1615 : : };
1616 : : };
1617 : : using coeff = keyword< coeff_info, TAOCPP_PEGTL_STRING("coeff") >;
1618 : :
1619 : : struct walker_info {
1620 : : static std::string name() { return "walker"; }
1621 : 572 : static std::string shortDescription() { return
1622 [ + - ]: 572 : "Start configuration block of the random walker"; }
1623 : 572 : static std::string longDescription() { return
1624 [ + - ]: 572 : R"(This keyword is used to select the walker. Walker, is a random walker,
1625 : : that allows temporal integration of a system of ordinary or stochastic
1626 : : differential equations (SDEs) of various types and the collection of
1627 : : arbitrary coupled statistics and probability density functions. Walker is
1628 : : intended as a general mathematical tool to analyze the behavior of SDEs
1629 : : and its statistics.)";
1630 : : }
1631 : : };
1632 : : using walker = keyword< walker_info, TAOCPP_PEGTL_STRING("walker") >;
1633 : :
1634 : : struct npar_info {
1635 : : static std::string name() { return "npar"; }
1636 : 2137 : static std::string shortDescription() { return
1637 [ + - ]: 2137 : "Set total number of particles"; }
1638 : 2137 : static std::string longDescription() { return
1639 [ + - ]: 2137 : R"(This keyword is used to specify the total number of particles in a
1640 : : simulation.)";
1641 : : }
1642 : : struct expect {
1643 : : using type = uint64_t;
1644 : : static constexpr type lower = 1;
1645 [ + - ]: 2137 : static std::string description() { return "uint"; }
1646 : : };
1647 : : };
1648 : : using npar = keyword< npar_info, TAOCPP_PEGTL_STRING("npar") >;
1649 : :
1650 : : struct nstep_info {
1651 : : static std::string name() { return "nstep"; }
1652 : 2137 : static std::string shortDescription() { return
1653 [ + - ]: 2137 : "Set number of time steps to take"; }
1654 : 2137 : static std::string longDescription() { return
1655 [ + - ]: 2137 : R"(This keyword is used to specify the number of time steps to take in a
1656 : : simulation. The number of time steps are used in conjunction with the
1657 : : maximmum time specified by keyword 'term': the simulation stops whichever is
1658 : : reached first. Both 'nstep' and 'term' can be left unspecified, in which
1659 : : case their default values are used. See also 'term'.)";
1660 : : }
1661 : : struct expect {
1662 : : using type = uint64_t;
1663 : : static constexpr type lower = 1;
1664 [ + - ]: 2137 : static std::string description() { return "uint"; }
1665 : : };
1666 : : };
1667 : : using nstep = keyword< nstep_info, TAOCPP_PEGTL_STRING("nstep") >;
1668 : :
1669 : : struct term_info {
1670 : : static std::string name() { return "term"; }
1671 : 2137 : static std::string shortDescription() { return
1672 [ + - ]: 2137 : "Set maximum non-dimensional time to simulate"; }
1673 : 2137 : static std::string longDescription() { return
1674 [ + - ]: 2137 : R"(This keyword is used to specify the termination time in a simulation. The
1675 : : termination time and number of time steps, specified by 'nstep', are used in
1676 : : conjunction to determine when to stop a simulation: whichever is
1677 : : reached first. Both 'nstep' and 'term' can be left unspecified, in which
1678 : : case their default values are used. See also 'nstep'.)";
1679 : : }
1680 : : struct expect {
1681 : : using type = tk::real;
1682 : : static constexpr type lower = 0.0;
1683 [ + - ]: 2137 : static std::string description() { return "real"; }
1684 : : };
1685 : : };
1686 : : using term = keyword< term_info, TAOCPP_PEGTL_STRING("term") >;
1687 : :
1688 : : struct t0_info {
1689 : : static std::string name() { return "t0"; }
1690 : 1565 : static std::string shortDescription() { return
1691 [ + - ]: 1565 : "Set starting non-dimensional time"; }
1692 : 1565 : static std::string longDescription() { return
1693 [ + - ]: 1565 : R"(This keyword is used to specify the starting time in a simulation.)";
1694 : : }
1695 : : struct expect {
1696 : : using type = tk::real;
1697 : : static constexpr type lower = 0.0;
1698 [ + - ]: 1565 : static std::string description() { return "real"; }
1699 : : };
1700 : : };
1701 : : using t0 = keyword< t0_info, TAOCPP_PEGTL_STRING("t0") >;
1702 : :
1703 : : struct dt_info {
1704 : : static std::string name() { return "dt"; }
1705 : 2137 : static std::string shortDescription() { return
1706 [ + - ]: 2137 : "Select constant time step size"; }
1707 : 2137 : static std::string longDescription() { return
1708 [ + - ]: 2137 : R"(This keyword is used to specify the time step size that used as a
1709 : : constant during simulation. Setting 'cfl' and 'dt' are mutually
1710 : : exclusive. If both 'cfl' and 'dt' are set, 'dt' wins.)";
1711 : : }
1712 : : struct expect {
1713 : : using type = tk::real;
1714 : : static constexpr type lower = 0.0;
1715 [ + - ]: 2137 : static std::string description() { return "real"; }
1716 : : };
1717 : : };
1718 : : using dt = keyword< dt_info, TAOCPP_PEGTL_STRING("dt") >;
1719 : :
1720 : : struct cfl_info {
1721 : : static std::string name() { return "CFL"; }
1722 : 1565 : static std::string shortDescription() { return
1723 [ + - ]: 1565 : "Set the Courant-Friedrichs-Lewy (CFL) coefficient"; }
1724 : 1565 : static std::string longDescription() { return
1725 [ + - ]: 1565 : R"(This keyword is used to specify the CFL coefficient for
1726 : : variable-time-step-size simulations. Setting 'cfl' and 'dt' are mutually
1727 : : exclusive. If both 'cfl' and 'dt' are set, 'dt' wins.)";
1728 : : }
1729 : : struct expect {
1730 : : using type = tk::real;
1731 : : static constexpr type lower = 0.0;
1732 [ + - ]: 1565 : static std::string description() { return "real"; }
1733 : : };
1734 : : };
1735 : : using cfl = keyword< cfl_info, TAOCPP_PEGTL_STRING("cfl") >;
1736 : :
1737 : : struct dvcfl_info {
1738 : : static std::string name() { return "dvCFL"; }
1739 : 1565 : static std::string shortDescription() { return
1740 [ + - ]: 1565 : "Set the volume-change Courant-Friedrichs-Lewy (CFL) coefficient"; }
1741 : 1565 : static std::string longDescription() { return
1742 [ + - ]: 1565 : R"(This keyword is used to specify the volume-change (dV/dt) CFL coefficient
1743 : : for variable-time-step-size simulations due to volume change in time in
1744 : : arbitrary-Lagrangian-Eulerian (ALE) calculations. Setting 'dvcfl' only has
1745 : : effect in ALE calculations and used together with 'cfl'. See also J. Waltz,
1746 : : N.R. Morgan, T.R. Canfield, M.R.J. Charest, L.D. Risinger, J.G. Wohlbier, A
1747 : : three-dimensional finite element arbitrary Lagrangian–Eulerian method for
1748 : : shock hydrodynamics on unstructured grids, Computers & Fluids, 92: 172-187,
1749 : : 2014.)";
1750 : : }
1751 : : struct expect {
1752 : : using type = tk::real;
1753 : : static constexpr type lower = 0.01;
1754 [ + - ]: 1565 : static std::string description() { return "real"; }
1755 : : };
1756 : : };
1757 : : using dvcfl = keyword< dvcfl_info, TAOCPP_PEGTL_STRING("dvcfl") >;
1758 : :
1759 : : struct vortmult_info {
1760 : : static std::string name() { return "vortmult"; }
1761 : 1565 : static std::string shortDescription() { return
1762 [ + - ]: 1565 : "Configure vorticity multiplier for ALE mesh velocity"; }
1763 : 1565 : static std::string longDescription() { return
1764 [ + - ]: 1565 : R"(This keyword is used to configure the multiplier for the vorticity term
1765 : : in the mesh velocity smoother (mesh_velocity=fluid) or for the potential
1766 : : gradient for the Helmholtz mesh velocity (mesh_velocity=helmholtz) for ALE
1767 : : mesh motion. For 'fluid' this is coefficient c2 in Eq.(36) of Waltz,
1768 : : Morgan, Canfield, Charest, Risinger, Wohlbier, A three-dimensional finite
1769 : : element arbitrary Lagrangian–Eulerian method for shock hydrodynamics on
1770 : : unstructured grids, Computers & Fluids, 2014, and for 'helmholtz', this is
1771 : : coefficient a1 in Eq.(23) of Bakosi, Waltz, Morgan, Improved ALE mesh
1772 : : velocities for complex flows, International Journal for Numerical Methods
1773 : : in Fluids, 2017. )";
1774 : : }
1775 : : struct expect {
1776 : : using type = tk::real;
1777 : : static constexpr type lower = 0.0;
1778 : : static constexpr type upper = 1.0;
1779 [ + - ]: 1565 : static std::string description() { return "real"; }
1780 : : };
1781 : : };
1782 : : using vortmult = keyword< vortmult_info, TAOCPP_PEGTL_STRING("vortmult") >;
1783 : :
1784 : : struct meshvel_maxit_info {
1785 : : static std::string name() {
1786 : : return "mesh velocity linear solve max number of iterations"; }
1787 : 1565 : static std::string shortDescription() { return
1788 : : "Set the max number of iterations for the mesh velocity linear solve "
1789 [ + - ]: 1565 : "for ALE"; }
1790 : 1565 : static std::string longDescription() { return
1791 [ + - ]: 1565 : R"(This keyword is used to specify the maximum number of linear solver
1792 : : iterations taken to converge the mesh velocity linear solve in
1793 : : arbitrary-Lagrangian-Eulerian (ALE) calculations. See also J. Waltz,
1794 : : N.R. Morgan, T.R. Canfield, M.R.J. Charest, L.D. Risinger, J.G. Wohlbier, A
1795 : : three-dimensional finite element arbitrary Lagrangian–Eulerian method for
1796 : : shock hydrodynamics on unstructured grids, Computers & Fluids, 92: 172-187,
1797 : : 2014.)";
1798 : : }
1799 : : struct expect {
1800 : : using type = std::size_t;
1801 [ + - ]: 1565 : static std::string description() { return "int"; }
1802 : : };
1803 : : };
1804 : : using meshvel_maxit =
1805 : : keyword< meshvel_maxit_info, TAOCPP_PEGTL_STRING("maxit") >;
1806 : :
1807 : : struct meshvel_tolerance_info {
1808 : : static std::string name() {
1809 : : return "mesh velocity linear solve tolerance "; }
1810 : 1565 : static std::string shortDescription() { return
1811 [ + - ]: 1565 : "Set the tolerance for the mesh velocity linear solve for ALE"; }
1812 : 1565 : static std::string longDescription() { return
1813 [ + - ]: 1565 : R"(This keyword is used to specify the tolerance to converge the mesh
1814 : : velocity linear solve for in
1815 : : arbitrary-Lagrangian-Eulerian (ALE) calculations. See also J. Waltz,
1816 : : N.R. Morgan, T.R. Canfield, M.R.J. Charest, L.D. Risinger, J.G. Wohlbier, A
1817 : : three-dimensional finite element arbitrary Lagrangian–Eulerian method for
1818 : : shock hydrodynamics on unstructured grids, Computers & Fluids, 92: 172-187,
1819 : : 2014.)";
1820 : : }
1821 : : struct expect {
1822 : : using type = tk::real;
1823 [ + - ]: 1565 : static std::string description() { return "real"; }
1824 : : };
1825 : : };
1826 : : using meshvel_tolerance =
1827 : : keyword< meshvel_tolerance_info, TAOCPP_PEGTL_STRING("tolerance") >;
1828 : :
1829 : : struct ncomp_info {
1830 : : static std::string name() { return "ncomp"; }
1831 : 2137 : static std::string shortDescription() { return
1832 [ + - ]: 2137 : "Set number of scalar components for a system of differential equations"; }
1833 : 2137 : static std::string longDescription() { return
1834 [ + - ]: 2137 : R"(This keyword is used to specify the number of scalar
1835 : : components of a vector. 'ncomp' means "number of components". It is also
1836 : : used for specifying the number of scalar components of a transporter scalar
1837 : : (see also the keywords 'transport').)";
1838 : : }
1839 : : struct expect {
1840 : : using type = std::size_t;
1841 : : static constexpr type lower = 1;
1842 [ + - ]: 2137 : static std::string description() { return "uint"; }
1843 : : };
1844 : : };
1845 : : using ncomp = keyword< ncomp_info, TAOCPP_PEGTL_STRING("ncomp") >;
1846 : :
1847 : : struct nmat_info {
1848 : : static std::string name() { return "nmat"; }
1849 : 1565 : static std::string shortDescription() { return
1850 [ + - ]: 1565 : "Set number of materials for a system of differential equations"; }
1851 : 1565 : static std::string longDescription() { return
1852 [ + - ]: 1565 : R"(This keyword is used to specify the number of materials, e.g., for
1853 : : multi-material flow, see also the keyword 'multimat' and 'veleq'.)";
1854 : : }
1855 : : struct expect {
1856 : : using type = std::size_t;
1857 : : static constexpr type lower = 1;
1858 [ + - ]: 1565 : static std::string description() { return "uint"; }
1859 : : };
1860 : : };
1861 : : using nmat = keyword< nmat_info, TAOCPP_PEGTL_STRING("nmat") >;
1862 : :
1863 : : struct ttyi_info {
1864 : : static std::string name() { return "ttyi"; }
1865 : 2137 : static std::string shortDescription() { return
1866 [ + - ]: 2137 : "Set screen output interval"; }
1867 : 2137 : static std::string longDescription() { return
1868 [ + - ]: 2137 : R"(This keyword is used to specify the interval in time steps for screen
1869 : : output during a simulation.)";
1870 : : }
1871 : : struct expect {
1872 : : using type = uint32_t;
1873 : : static constexpr type lower = 0;
1874 [ + - ]: 2137 : static std::string description() { return "uint"; }
1875 : : };
1876 : : };
1877 : : using ttyi = keyword< ttyi_info, TAOCPP_PEGTL_STRING("ttyi") >;
1878 : :
1879 : : struct pari_info {
1880 : : static std::string name() { return "pari"; }
1881 : 572 : static std::string shortDescription() { return
1882 [ + - ]: 572 : "Set particles output interval"; }
1883 : 572 : static std::string longDescription() { return
1884 [ + - ]: 572 : R"(This keyword is used to specify the interval in time steps for particles
1885 : : output during a simulation.)";
1886 : : }
1887 : : struct expect {
1888 : : using type = uint32_t;
1889 : : static constexpr type lower = 1;
1890 [ + - ]: 572 : static std::string description() { return "uint"; }
1891 : : };
1892 : : };
1893 : : using pari = keyword< pari_info, TAOCPP_PEGTL_STRING("pari") >;
1894 : :
1895 : : struct interval_iter_info {
1896 : : static std::string name() { return "interval"; }
1897 : 2137 : static std::string shortDescription() { return
1898 [ + - ]: 2137 : "Set interval (in units of iteration count)"; }
1899 : 2137 : static std::string longDescription() { return
1900 [ + - ]: 2137 : R"(This keyword is used to specify an interval in units of iteration count
1901 : : (i.e., number of time steps). This must be used within a relevant block.)";
1902 : : }
1903 : : struct expect {
1904 : : using type = uint32_t;
1905 : : static constexpr type lower = 0;
1906 [ + - ]: 2137 : static std::string description() { return "uint"; }
1907 : : };
1908 : : };
1909 : : using interval_iter =
1910 : : keyword< interval_iter_info, TAOCPP_PEGTL_STRING("interval") >;
1911 : :
1912 : : struct interval_time_info {
1913 : : static std::string name() { return "time_interval"; }
1914 : 1565 : static std::string shortDescription() { return
1915 [ + - ]: 1565 : "Set interval (in units of physics time)"; }
1916 : 1565 : static std::string longDescription() { return
1917 [ + - ]: 1565 : R"(This keyword is used to specify an interval in units of physics time.
1918 : : This must be used within a relevant block.)";
1919 : : }
1920 : : struct expect {
1921 : : using type = tk::real;
1922 : : static constexpr type lower = std::numeric_limits< tk::real >::epsilon();
1923 [ + - ]: 1565 : static std::string description() { return "real"; }
1924 : : };
1925 : : };
1926 : : using interval_time =
1927 : : keyword< interval_time_info, TAOCPP_PEGTL_STRING("time_interval") >;
1928 : :
1929 : : struct time_range_info {
1930 : : static std::string name() { return "time_range"; }
1931 : 1565 : static std::string shortDescription() { return
1932 [ + - ]: 1565 : "Configure physics time range for output (in units of physics time)"; }
1933 : 1565 : static std::string longDescription() { return
1934 [ + - ]: 1565 : R"(This keyword is used to configure field-, or history-output, specifying
1935 : : a start time, a stop time, and an output frequency in physics time units.
1936 : : Example: 'time_range 0.2 0.3 0.001 end', which specifies that from t=0.2 to
1937 : : t=0.3 output should happen at physics time units of dt=0.001. This must be
1938 : : used within a relevant block.)";
1939 : : }
1940 : : struct expect {
1941 : : using type = tk::real;
1942 [ + - ]: 1565 : static std::string description() { return "3 reals"; }
1943 : : };
1944 : : };
1945 : : using time_range =
1946 : : keyword< time_range_info, TAOCPP_PEGTL_STRING("time_range") >;
1947 : :
1948 : : struct statistics_info {
1949 : : static std::string name() { return "statistics"; }
1950 : 572 : static std::string shortDescription() { return
1951 [ + - ]: 572 : "Start of statistics input block"; }
1952 : 572 : static std::string longDescription() { return
1953 [ + - ]: 572 : R"(This keyword is used to start a block in the input file containing the
1954 : : descriptions and settings of requested output for statistical moments.
1955 : : Example: "statistics <Y> <yy> end", which requests the first two moments of
1956 : : the flutcutating variable 'Y'. For more info on the structure of the
1957 : : statistics ... end block, see doc/pages/statistics_output.dox.)";
1958 : : }
1959 : : };
1960 : : using statistics = keyword< statistics_info, TAOCPP_PEGTL_STRING("statistics") >;
1961 : :
1962 : : struct history_output_info {
1963 : : static std::string name() { return "history_output"; }
1964 : 1565 : static std::string shortDescription() { return
1965 [ + - ]: 1565 : "Start of history_output input block"; }
1966 : 1565 : static std::string longDescription() { return
1967 [ + - ]: 1565 : R"(This keyword is used to start a block in the input file containing the
1968 : : descriptions and settings of requested history output.)";
1969 : : }
1970 : : };
1971 : : using history_output =
1972 : : keyword< history_output_info, TAOCPP_PEGTL_STRING("history_output") >;
1973 : :
1974 : : struct field_output_info {
1975 : : static std::string name() { return "field_output"; }
1976 : 1565 : static std::string shortDescription() { return
1977 [ + - ]: 1565 : "Start of field_output input block"; }
1978 : 1565 : static std::string longDescription() { return
1979 [ + - ]: 1565 : R"(This keyword is used to start a block in the input file containing the
1980 : : list and settings of requested field output.)";
1981 : : }
1982 : : };
1983 : : using field_output =
1984 : : keyword< field_output_info, TAOCPP_PEGTL_STRING("field_output") >;
1985 : :
1986 : : struct outvar_density_info {
1987 : : static std::string name() { return "density"; }
1988 [ + - ]: 1565 : static std::string shortDescription() { return "Request density"; }
1989 : 1565 : static std::string longDescription() { return
1990 [ + - ]: 1565 : R"(This keyword is used to request the fluid density as an output
1991 : : variable.)";
1992 : : }
1993 : : };
1994 : : using outvar_density =
1995 : : keyword< outvar_density_info, TAOCPP_PEGTL_STRING("density") >;
1996 : :
1997 : : struct outvar_xmomentum_info {
1998 : : static std::string name() { return "x-momentum"; }
1999 [ + - ]: 1565 : static std::string shortDescription() { return "Request x-momentum"; }
2000 : 1565 : static std::string longDescription() { return
2001 [ + - ]: 1565 : R"(This keyword is used to request the fluid x-momentum as an output
2002 : : variable.)";
2003 : : }
2004 : : };
2005 : : using outvar_xmomentum =
2006 : : keyword< outvar_xmomentum_info, TAOCPP_PEGTL_STRING("x-momentum") >;
2007 : :
2008 : : struct outvar_ymomentum_info {
2009 : : static std::string name() { return "y-momentum"; }
2010 [ + - ]: 1565 : static std::string shortDescription() { return "Request y-momentum"; }
2011 : 1565 : static std::string longDescription() { return
2012 [ + - ]: 1565 : R"(This keyword is used to request the fluid y-momentum as an output
2013 : : variable.)";
2014 : : }
2015 : : };
2016 : : using outvar_ymomentum =
2017 : : keyword< outvar_ymomentum_info, TAOCPP_PEGTL_STRING("y-momentum") >;
2018 : :
2019 : : struct outvar_zmomentum_info {
2020 : : static std::string name() { return "z-momentum"; }
2021 [ + - ]: 1565 : static std::string shortDescription() { return "Request z-momentum"; }
2022 : 1565 : static std::string longDescription() { return
2023 [ + - ]: 1565 : R"(This keyword is used to request the fluid z-momentum as an output
2024 : : variable.)";
2025 : : }
2026 : : };
2027 : : using outvar_zmomentum =
2028 : : keyword< outvar_zmomentum_info, TAOCPP_PEGTL_STRING("z-momentum") >;
2029 : :
2030 : : struct outvar_specific_total_energy_info {
2031 : : static std::string name() { return "specific_total_energy"; }
2032 : 1565 : static std::string shortDescription() {
2033 [ + - ]: 1565 : return "Request total specific energy"; }
2034 : 1565 : static std::string longDescription() { return
2035 [ + - ]: 1565 : R"(This keyword is used to request the specific total energy as an output
2036 : : variable.)";
2037 : : }
2038 : : };
2039 : : using outvar_specific_total_energy =
2040 : : keyword< outvar_specific_total_energy_info,
2041 : : TAOCPP_PEGTL_STRING("specific_total_energy") >;
2042 : :
2043 : : struct outvar_volumetric_total_energy_info {
2044 : : static std::string name() { return "volumetric_total_energy"; }
2045 : 1565 : static std::string shortDescription() {
2046 [ + - ]: 1565 : return "Request total volumetric energy"; }
2047 : 1565 : static std::string longDescription() { return
2048 [ + - ]: 1565 : R"(This keyword is used to request the volumetric total energy as an output
2049 : : variable.)";
2050 : : }
2051 : : };
2052 : : using outvar_volumetric_total_energy =
2053 : : keyword< outvar_volumetric_total_energy_info,
2054 : : TAOCPP_PEGTL_STRING("volumetric_total_energy") >;
2055 : :
2056 : : struct outvar_xvelocity_info {
2057 : : static std::string name() { return "x-velocity"; }
2058 [ + - ]: 1565 : static std::string shortDescription() { return "Request x-velocity"; }
2059 : 1565 : static std::string longDescription() { return
2060 [ + - ]: 1565 : R"(This keyword is used to request the fluid x-velocity as an output
2061 : : variable.)";
2062 : : }
2063 : : };
2064 : : using outvar_xvelocity =
2065 : : keyword< outvar_xvelocity_info, TAOCPP_PEGTL_STRING("x-velocity") >;
2066 : :
2067 : : struct outvar_yvelocity_info {
2068 : : static std::string name() { return "y-velocity"; }
2069 [ + - ]: 1565 : static std::string shortDescription() { return "Request y-velocity"; }
2070 : 1565 : static std::string longDescription() { return
2071 [ + - ]: 1565 : R"(This keyword is used to request the fluid y-velocity as an output
2072 : : variable.)";
2073 : : }
2074 : : };
2075 : : using outvar_yvelocity =
2076 : : keyword< outvar_yvelocity_info, TAOCPP_PEGTL_STRING("y-velocity") >;
2077 : :
2078 : : struct outvar_zvelocity_info {
2079 : : static std::string name() { return "z-velocity"; }
2080 [ + - ]: 1565 : static std::string shortDescription() { return "Request z-velocity"; }
2081 : 1565 : static std::string longDescription() { return
2082 [ + - ]: 1565 : R"(This keyword is used to request the fluid z-velocity as an output
2083 : : variable.)";
2084 : : }
2085 : : };
2086 : : using outvar_zvelocity =
2087 : : keyword< outvar_zvelocity_info, TAOCPP_PEGTL_STRING("z-velocity") >;
2088 : :
2089 : : struct outvar_pressure_info {
2090 : : static std::string name() { return "pressure"; }
2091 [ + - ]: 1565 : static std::string shortDescription() { return "Request pressure"; }
2092 : 1565 : static std::string longDescription() { return
2093 [ + - ]: 1565 : R"(This keyword is used to request the fluid pressure as an output
2094 : : variable.)";
2095 : : }
2096 : : };
2097 : : using outvar_pressure =
2098 : : keyword< outvar_pressure_info, TAOCPP_PEGTL_STRING("pressure") >;
2099 : :
2100 : : struct outvar_material_indicator_info {
2101 : : static std::string name() { return "material_indicator"; }
2102 [ + - ]: 1565 : static std::string shortDescription() { return "Request material_indicator"; }
2103 : 1565 : static std::string longDescription() { return
2104 [ + - ]: 1565 : R"(This keyword is used to request the material indicator function as an
2105 : : output variable.)";
2106 : : }
2107 : : };
2108 : : using outvar_material_indicator =
2109 : : keyword< outvar_material_indicator_info,
2110 : : TAOCPP_PEGTL_STRING("material_indicator") >;
2111 : :
2112 : : struct outvar_analytic_info {
2113 : : static std::string name() { return "analytic"; }
2114 [ + - ]: 1565 : static std::string shortDescription() { return "Request analytic solution"; }
2115 : 1565 : static std::string longDescription() { return
2116 [ + - ]: 1565 : R"(This keyword is used to request the analytic solution (if exist) as an
2117 : : output variable.)";
2118 : : }
2119 : : };
2120 : : using outvar_analytic =
2121 : : keyword< outvar_analytic_info, TAOCPP_PEGTL_STRING("analytic") >;
2122 : :
2123 : : struct outvar_info {
2124 : : static std::string name() { return "outvar"; }
2125 : 1565 : static std::string shortDescription() { return
2126 [ + - ]: 1565 : "Start of var ... end input block"; }
2127 : 1565 : static std::string longDescription() { return
2128 : : R"(This keyword is used to start a block in the input file containing a
2129 : : list of physics variables for output. The following keywords are allowed
2130 : : in an var ... end block:)"
2131 [ + - ][ + - ]: 3130 : + std::string("\'")
2132 [ + - ][ + - ]: 6260 : + outvar_density::string()+ "\', \'"
[ + - ]
2133 [ + - ][ + - ]: 6260 : + outvar_xmomentum::string()+ "\', \'"
[ + - ]
2134 [ + - ][ + - ]: 6260 : + outvar_ymomentum::string()+ "\', \'"
[ + - ]
2135 [ + - ][ + - ]: 6260 : + outvar_zmomentum::string()+ "\', \'"
[ + - ]
2136 [ + - ][ + - ]: 6260 : + outvar_specific_total_energy::string() + "\', \'"
[ + - ]
2137 [ + - ][ + - ]: 6260 : + outvar_volumetric_total_energy::string() + "\', \'"
[ + - ]
2138 [ + - ][ + - ]: 6260 : + outvar_xvelocity::string() + "\', \'"
[ + - ]
2139 [ + - ][ + - ]: 6260 : + outvar_yvelocity::string() + "\', \'"
[ + - ]
2140 [ + - ][ + - ]: 6260 : + outvar_zvelocity::string() + "\', \'"
[ + - ]
2141 [ + - ][ + - ]: 6260 : + outvar_pressure::string() + "\', \'"
[ + - ]
2142 [ + - ][ + - ]: 6260 : + outvar_material_indicator::string() + "\', \'"
[ + - ]
2143 [ + - ][ + - ]: 6260 : + outvar_analytic::string() + "\'.";
2144 : : }
2145 : : };
2146 : : using outvar = keyword< outvar_info, TAOCPP_PEGTL_STRING("var") >;
2147 : :
2148 : : struct rngs_info {
2149 : : static std::string name() { return "rngs"; }
2150 : 572 : static std::string shortDescription() { return
2151 [ + - ]: 572 : "Start of a random number generators description input block"; }
2152 : 572 : static std::string longDescription() { return
2153 [ + - ]: 572 : R"(This keyword is used to start a block in the input file containing the
2154 : : descriptions and settings of requested random number generators.
2155 : : Example: "rngs mkl_mcg59 seed 2134 uniform_method accurate end end" which
2156 : : enables the MCG59 generator from MKL using the seed 2134. For more info on
2157 : : the structure of the rngs ... end block, see
2158 : : doc/pages/rngs_input.dox.)";
2159 : : }
2160 : : };
2161 : : using rngs = keyword< rngs_info, TAOCPP_PEGTL_STRING("rngs") >;
2162 : :
2163 : : struct rng_info {
2164 : : static std::string name() { return "rng"; }
2165 : 572 : static std::string shortDescription() { return
2166 [ + - ]: 572 : "Select random number generator (RNG) from pool of enabled RNGs"; }
2167 : 572 : static std::string longDescription() { return
2168 [ + - ]: 572 : R"(This keyword is used to select a particular random number generator (RNG)
2169 : : from a pre-selected set of (enabled and configured) pool of RNGs. The pool
2170 : : is specified by the 'rngs ... end' block and it must precede the selection
2171 : : of an RNG.)";
2172 : : }
2173 : : struct expect {
2174 [ + - ]: 572 : static std::string description() { return "string"; }
2175 : 572 : static std::string choices() {
2176 [ + - ][ + - ]: 1144 : return '\'' + r123_threefry::string() + "\' | \'"
[ + - ]
2177 [ + - ][ + - ]: 2288 : + r123_philox::string()
2178 : : #ifdef HAS_RNGSSE2
2179 [ + - ]: 1144 : + "\' | \'"
2180 [ + - ][ + - ]: 2288 : + rngsse_gm19::string() + "\' | \'"
[ + - ]
2181 [ + - ][ + - ]: 2288 : + rngsse_gm29::string() + "\' | \'"
[ + - ]
2182 [ + - ][ + - ]: 2288 : + rngsse_gm31::string() + "\' | \'"
[ + - ]
2183 [ + - ][ + - ]: 2288 : + rngsse_gm55::string() + "\' | \'"
[ + - ]
2184 [ + - ][ + - ]: 2288 : + rngsse_gm61::string() + "\' | \'"
[ + - ]
2185 [ + - ][ + - ]: 2288 : + rngsse_gq581::string() + "\' | \'"
[ + - ]
2186 [ + - ][ + - ]: 2288 : + rngsse_gq583::string() + "\' | \'"
[ + - ]
2187 [ + - ][ + - ]: 2288 : + rngsse_gq584::string() + "\' | \'"
[ + - ]
2188 [ + - ][ + - ]: 2288 : + rngsse_mt19937::string() + "\' | \'"
[ + - ]
2189 [ + - ][ + - ]: 2288 : + rngsse_lfsr113::string() + "\' | \'"
[ + - ]
2190 [ + - ]: 2288 : + rngsse_mrg32k3a::string()
2191 : : #endif
2192 : : #ifdef HAS_MKL
2193 : : + "\' | \'"
2194 : : + mkl_mcg31::string() + "\' | \'"
2195 : : + mkl_r250::string() + "\' | \'"
2196 : : + mkl_mrg32k3a::string() + "\' | \'"
2197 : : + mkl_mcg59::string() + "\' | \'"
2198 : : + mkl_wh::string() + "\' | \'"
2199 : : + mkl_mt19937::string() + "\' | \'"
2200 : : + mkl_mt2203::string() + "\' | \'"
2201 : : + mkl_sfmt19937::string() + "\' | \'"
2202 : : + mkl_sobol::string() + "\' | \'"
2203 : : + mkl_niederr::string() + "\' | \'"
2204 : : + mkl_iabstract::string() + "\' | \'"
2205 : : + mkl_dabstract::string() + "\' | \'"
2206 : : + mkl_sabstract::string() + "\' | \'"
2207 : : + mkl_nondeterm::string() + "\' "
2208 : : #else
2209 [ + - ]: 1144 : + "\' "
2210 : : #endif
2211 : : + "Remember: the RNG must be listed in the pool before it can be "
2212 [ + - ]: 1144 : "selected via this keyword!";
2213 : : }
2214 : : };
2215 : : };
2216 : : using rng = keyword< rng_info, TAOCPP_PEGTL_STRING("rng") >;
2217 : :
2218 : : struct sde_omega_info {
2219 : : static std::string name() { return "omega"; }
2220 : 572 : static std::string shortDescription() { return
2221 [ + - ]: 572 : R"(Set SDE parameter(s) omega)"; }
2222 : 572 : static std::string longDescription() { return
2223 [ + - ]: 572 : R"(This keyword is used to specify a vector of real numbers used to
2224 : : parameterize a system of stochastic differential equations. Example:
2225 : : "omega 5.0 2.0 3.0 end". The length of the vector depends on the particular
2226 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
2227 : : struct expect {
2228 : : using type = tk::real;
2229 [ + - ]: 572 : static std::string description() { return "real(s)"; }
2230 : : };
2231 : : };
2232 : : using sde_omega = keyword< sde_omega_info, TAOCPP_PEGTL_STRING("omega") >;
2233 : :
2234 : : struct sde_c0_info {
2235 : : static std::string name() { return "C0"; }
2236 : 572 : static std::string shortDescription() { return
2237 [ + - ]: 572 : R"(Set Langevin SDE parameter C0)"; }
2238 : 572 : static std::string longDescription() { return
2239 [ + - ]: 572 : R"(This keyword is used to specify a real number used to parameterize the
2240 : : Langevin model for the fluctuating velocity in homogeneous variable-density
2241 : : turbulence. Example: "C0 2.1".)"; }
2242 : : struct expect {
2243 : : using type = tk::real;
2244 [ + - ]: 572 : static std::string description() { return "real"; }
2245 : : };
2246 : : };
2247 : : using sde_c0 = keyword< sde_c0_info, TAOCPP_PEGTL_STRING("C0") >;
2248 : :
2249 : : struct gravity_info {
2250 : : static std::string name() { return "gravity"; }
2251 : 572 : static std::string shortDescription() { return
2252 [ + - ]: 572 : R"(Set Langevin SDE parameter gravity)"; }
2253 : 572 : static std::string longDescription() { return
2254 [ + - ]: 572 : R"(This keyword is used to specify a vector of 3 real numbers used to
2255 : : parameterize the Langevin model for the fluctuating velocity in homogeneous
2256 : : variable-density turbulence, prescribing a gravy body force in the three
2257 : : coordinate directions, x, y, z. Example: "gravity 0.0 0.2 1.0 end".)"; }
2258 : : struct expect {
2259 : : using type = tk::real;
2260 [ + - ]: 572 : static std::string description() { return "3 reals"; }
2261 : : };
2262 : : };
2263 : : using gravity = keyword< gravity_info, TAOCPP_PEGTL_STRING("gravity") >;
2264 : :
2265 : : struct sde_c3_info {
2266 : : static std::string name() { return "C3"; }
2267 : 572 : static std::string shortDescription() { return
2268 [ + - ]: 572 : R"(Set gamma (dissipation) SDE parameter C3)"; }
2269 : 572 : static std::string longDescription() { return
2270 [ + - ]: 572 : R"(This keyword is used to specify a real number used to parameterize the
2271 : : gamma distribution dissipation (turbulence frequency) model for particles
2272 : : Example: "C3 1.0".)"; }
2273 : : struct expect {
2274 : : using type = tk::real;
2275 : : static constexpr type lower = 0.0;
2276 [ + - ]: 572 : static std::string description() { return "real"; }
2277 : : };
2278 : : };
2279 : : using sde_c3 = keyword< sde_c3_info, TAOCPP_PEGTL_STRING("C3") >;
2280 : :
2281 : : struct sde_c4_info {
2282 : : static std::string name() { return "C4"; }
2283 : 572 : static std::string shortDescription() { return
2284 [ + - ]: 572 : R"(Set gamma (dissipation) SDE parameter C4)"; }
2285 : 572 : static std::string longDescription() { return
2286 [ + - ]: 572 : R"(This keyword is used to specify a real number used to parameterize the
2287 : : gamma distribution dissipation (turbulence frequency) model for particles
2288 : : Example: "C4 0.25".)"; }
2289 : : struct expect {
2290 : : using type = tk::real;
2291 : : static constexpr type lower = 0.0;
2292 [ + - ]: 572 : static std::string description() { return "real"; }
2293 : : };
2294 : : };
2295 : : using sde_c4 = keyword< sde_c4_info, TAOCPP_PEGTL_STRING("C4") >;
2296 : :
2297 : : struct sde_com1_info {
2298 : : static std::string name() { return "COM1"; }
2299 : 572 : static std::string shortDescription() { return
2300 [ + - ]: 572 : R"(Set gamma (dissipation) SDE parameter COM1)"; }
2301 : 572 : static std::string longDescription() { return
2302 [ + - ]: 572 : R"(This keyword is used to specify a real number used to parameterize the
2303 : : gamma distribution dissipation (turbulence frequency) model for particles
2304 : : Example: "COM1 0.44".)"; }
2305 : : struct expect {
2306 : : using type = tk::real;
2307 : : static constexpr type lower = 0.0;
2308 [ + - ]: 572 : static std::string description() { return "real"; }
2309 : : };
2310 : : };
2311 : : using sde_com1 = keyword< sde_com1_info, TAOCPP_PEGTL_STRING("COM1") >;
2312 : :
2313 : : struct sde_com2_info {
2314 : : static std::string name() { return "COM2"; }
2315 : 572 : static std::string shortDescription() { return
2316 [ + - ]: 572 : R"(Set gamma (dissipation) SDE parameter COM2)"; }
2317 : 572 : static std::string longDescription() { return
2318 [ + - ]: 572 : R"(This keyword is used to specify a real number used to parameterize the
2319 : : gamma distribution dissipation (turbulence frequency) model for particles
2320 : : Example: "COM2 0.9".)"; }
2321 : : struct expect {
2322 : : using type = tk::real;
2323 : : static constexpr type lower = 0.0;
2324 [ + - ]: 572 : static std::string description() { return "real"; }
2325 : : };
2326 : : };
2327 : : using sde_com2 = keyword< sde_com2_info, TAOCPP_PEGTL_STRING("COM2") >;
2328 : :
2329 : : struct sde_b_info {
2330 : : static std::string name() { return "b"; }
2331 : 572 : static std::string shortDescription() { return
2332 [ + - ]: 572 : R"(Set SDE parameter(s) b)"; }
2333 : 572 : static std::string longDescription() { return
2334 [ + - ]: 572 : R"(This keyword is used to specify a vector of real numbers used to
2335 : : parameterize a system of stochastic differential equations. Example:
2336 : : "b 5.0 2.0 3.0 end". The length of the vector depends on the particular
2337 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
2338 : : struct expect {
2339 : : using type = tk::real;
2340 [ + - ]: 572 : static std::string description() { return "real(s)"; }
2341 : : };
2342 : : };
2343 : : using sde_b = keyword< sde_b_info, TAOCPP_PEGTL_STRING("b") >;
2344 : :
2345 : : struct sde_S_info {
2346 : : static std::string name() { return "S"; }
2347 : 572 : static std::string shortDescription() { return
2348 [ + - ]: 572 : R"(Set SDE parameter(s) S)"; }
2349 : 572 : static std::string longDescription() { return
2350 [ + - ]: 572 : R"(This keyword is used to specify a vector of real numbers used to
2351 : : parameterize a system of stochastic differential equations. Example:
2352 : : "S 5.0 2.0 3.0 end". The length of the vector depends on the particular
2353 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
2354 : : struct expect {
2355 : : using type = tk::real;
2356 [ + - ]: 572 : static std::string description() { return "real(s)"; }
2357 : : };
2358 : : };
2359 : : using sde_S = keyword< sde_S_info, TAOCPP_PEGTL_STRING("S") >;
2360 : :
2361 : : struct sde_kappa_info {
2362 : : static std::string name() { return "kappa"; }
2363 : 572 : static std::string shortDescription() { return
2364 [ + - ]: 572 : R"(Set SDE parameter(s) kappa)"; }
2365 : 572 : static std::string longDescription() { return
2366 [ + - ]: 572 : R"(This keyword is used to specify a vector of real numbers used to
2367 : : parameterize a system of stochastic differential equations. Example:
2368 : : "kappa 5.0 2.0 3.0 end". The length of the vector depends on the particular
2369 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
2370 : : struct expect {
2371 : : using type = tk::real;
2372 [ + - ]: 572 : static std::string description() { return "real(s)"; }
2373 : : };
2374 : : };
2375 : : using sde_kappa = keyword< sde_kappa_info, TAOCPP_PEGTL_STRING("kappa") >;
2376 : :
2377 : : struct sde_bprime_info {
2378 : : static std::string name() { return "bprime"; }
2379 : 572 : static std::string shortDescription() { return
2380 [ + - ]: 572 : R"(Set SDE parameter(s) bprime)"; }
2381 : 572 : static std::string longDescription() { return
2382 [ + - ]: 572 : R"(This keyword is used to specify a vector of real numbers used to
2383 : : parameterize a system of stochastic differential equations. Example:
2384 : : "bprime 5.0 2.0 3.0 end". The length of the vector depends on the particular
2385 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
2386 : : struct expect {
2387 : : using type = sde_b_info::expect::type;
2388 [ + - ]: 572 : static std::string description() { return "real(s)"; }
2389 : : };
2390 : : };
2391 : : using sde_bprime = keyword< sde_bprime_info, TAOCPP_PEGTL_STRING("bprime") >;
2392 : :
2393 : : struct sde_kappaprime_info {
2394 : : static std::string name() { return "kappaprime"; }
2395 : 572 : static std::string shortDescription() { return
2396 [ + - ]: 572 : R"(Set SDE parameter(s) kappaprime)"; }
2397 : 572 : static std::string longDescription() { return
2398 [ + - ]: 572 : R"(This keyword is used to specify a vector of real numbers used to
2399 : : parameterize a system of stochastic differential equations. Example:
2400 : : "kappaprime 5.0 2.0 3.0 end". The length of the vector depends on the
2401 : : particular type of SDE system and is controlled by the preceding keyword
2402 : : 'ncomp'.)"; }
2403 : : struct expect {
2404 : : using type = sde_kappa_info::expect::type;
2405 [ + - ]: 572 : static std::string description() { return "real(s)"; }
2406 : : };
2407 : : };
2408 : : using sde_kappaprime = keyword< sde_kappaprime_info, TAOCPP_PEGTL_STRING("kappaprime") >;
2409 : :
2410 : : struct sde_c_info {
2411 : : static std::string name() { return "c"; }
2412 : 572 : static std::string shortDescription() { return
2413 [ + - ]: 572 : R"(Set SDE parameter(s) c)"; }
2414 : 572 : static std::string longDescription() { return
2415 [ + - ]: 572 : R"(This keyword is used to specify a vector of real numbers used to
2416 : : parameterize a system of stochastic differential equations. Example:
2417 : : "c 5.0 2.0 3.0 end". The length of the vector depends on the particular type
2418 : : of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
2419 : : struct expect {
2420 : : using type = tk::real;
2421 [ + - ]: 572 : static std::string description() { return "real(s)"; }
2422 : : };
2423 : : };
2424 : : using sde_c = keyword< sde_c_info, TAOCPP_PEGTL_STRING("c") >;
2425 : :
2426 : : struct sde_sigmasq_info {
2427 : : static std::string name() { return "sigmasq"; }
2428 : 572 : static std::string shortDescription() { return
2429 [ + - ]: 572 : R"(Set SDE parameter(s) sigmasq)"; }
2430 : 572 : static std::string longDescription() { return
2431 [ + - ]: 572 : R"(This keyword is used to specify a vector of real numbers used to
2432 : : parameterize a system of stochastic differential equations. Example:
2433 : : "sigmasq
2434 : : 4.0 2.5 1.1
2435 : : 32.0 5.6
2436 : : 23.0
2437 : : end"
2438 : : The length of the vector depends on the
2439 : : particular type of SDE system and is controlled by the preceding keyword
2440 : : 'ncomp'.)"; }
2441 : : struct expect {
2442 : : using type = tk::real;
2443 [ + - ]: 572 : static std::string description() { return "real(s)"; }
2444 : : };
2445 : : };
2446 : : using sde_sigmasq = keyword< sde_sigmasq_info, TAOCPP_PEGTL_STRING("sigmasq") >;
2447 : :
2448 : : struct sde_cov_info {
2449 : : static std::string name() { return "cov"; }
2450 : 572 : static std::string shortDescription() { return
2451 [ + - ]: 572 : R"(Set SDE parameter(s) cov)"; }
2452 : 572 : static std::string longDescription() { return
2453 [ + - ]: 572 : R"(This keyword is used to specify a vector of real numbers used to
2454 : : parameterize a system of stochastic differential equations. Example:
2455 : : "cov
2456 : : 4.0 2.5 1.1
2457 : : 32.0 5.6
2458 : : 23.0
2459 : : end"
2460 : : The length of the vector depends on the
2461 : : particular type of SDE system and is controlled by the preceding keyword
2462 : : 'ncomp'.)"; }
2463 : : struct expect {
2464 : : using type = tk::real;
2465 [ + - ]: 572 : static std::string description() { return "real(s)"; }
2466 : : };
2467 : : };
2468 : : using sde_cov = keyword< sde_cov_info, TAOCPP_PEGTL_STRING("cov") >;
2469 : :
2470 : : struct sde_theta_info {
2471 : : static std::string name() { return "theta"; }
2472 : 572 : static std::string shortDescription() { return
2473 [ + - ]: 572 : R"(Set SDE parameter(s) theta)"; }
2474 : 572 : static std::string longDescription() { return
2475 [ + - ]: 572 : R"(This keyword is used to specify a vector of real numbers used to
2476 : : parameterize a system of stochastic differential equations. Example:
2477 : : "theta 5.0 2.0 3.0 end". The length of the vector depends on the particular
2478 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
2479 : : struct expect {
2480 : : using type = tk::real;
2481 [ + - ]: 572 : static std::string description() { return "real(s)"; }
2482 : : };
2483 : : };
2484 : : using sde_theta = keyword< sde_theta_info, TAOCPP_PEGTL_STRING("theta") >;
2485 : :
2486 : : struct sde_mu_info {
2487 : : static std::string name() { return "mu"; }
2488 : 572 : static std::string shortDescription() { return
2489 [ + - ]: 572 : R"(Set SDE parameter(s) mu)"; }
2490 : 572 : static std::string longDescription() { return
2491 [ + - ]: 572 : R"(This keyword is used to specify a vector of real numbers used to
2492 : : parameterize a system of stochastic differential equations. Example:
2493 : : "mu 5.0 2.0 3.0 end". The length of the vector depends on the particular
2494 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
2495 : : struct expect {
2496 : : using type = tk::real;
2497 [ + - ]: 572 : static std::string description() { return "real(s)"; }
2498 : : };
2499 : : };
2500 : : using sde_mu = keyword< sde_mu_info, TAOCPP_PEGTL_STRING("mu") >;
2501 : :
2502 : : struct sde_mean_info {
2503 : : static std::string name() { return "mean"; }
2504 : 572 : static std::string shortDescription() { return
2505 [ + - ]: 572 : R"(Set SDE parameter(s) mean)"; }
2506 : 572 : static std::string longDescription() { return
2507 [ + - ]: 572 : R"(This keyword is used to specify a vector of real numbers used to
2508 : : parameterize a system of stochastic differential equations. Example:
2509 : : "mean 5.0 2.0 3.0 end". The length of the vector depends on the particular
2510 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
2511 : : struct expect {
2512 : : using type = tk::real;
2513 [ + - ]: 572 : static std::string description() { return "real(s)"; }
2514 : : };
2515 : : };
2516 : : using sde_mean = keyword< sde_mean_info, TAOCPP_PEGTL_STRING("mean") >;
2517 : :
2518 : : struct sde_T_info {
2519 : : static std::string name() { return "T"; }
2520 : 572 : static std::string shortDescription() { return
2521 [ + - ]: 572 : R"(Set SDE parameter(s) T)"; }
2522 : 572 : static std::string longDescription() { return
2523 [ + - ]: 572 : R"(This keyword is used to specify a vector of real numbers used to
2524 : : parameterize a system of stochastic differential equations. Example:
2525 : : "T 5.0 2.0 3.0 end". The length of the vector depends on the particular
2526 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
2527 : : struct expect {
2528 : : using type = tk::real;
2529 [ + - ]: 572 : static std::string description() { return "real(s)"; }
2530 : : };
2531 : : };
2532 : : using sde_T = keyword< sde_T_info, TAOCPP_PEGTL_STRING("T") >;
2533 : :
2534 : : struct sde_lambda_info {
2535 : : static std::string name() { return "lambda"; }
2536 : 572 : static std::string shortDescription() { return
2537 [ + - ]: 572 : R"(Set SDE parameter(s) lambda)"; }
2538 : 572 : static std::string longDescription() { return
2539 [ + - ]: 572 : R"(This keyword is used to specify a vector of real numbers used to
2540 : : parameterize a system of stochastic differential equations. Example:
2541 : : "lambda 5.0 2.0 3.0 end". The length of the vector depends on the particular
2542 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
2543 : : struct expect {
2544 : : using type = tk::real;
2545 [ + - ]: 572 : static std::string description() { return "real(s)"; }
2546 : : };
2547 : : };
2548 : : using sde_lambda = keyword< sde_lambda_info, TAOCPP_PEGTL_STRING("lambda") >;
2549 : :
2550 : : struct spike_info {
2551 : : static std::string name() { return "spike"; }
2552 : 572 : static std::string shortDescription() { return
2553 [ + - ]: 572 : R"(Configure a delta spike)"; }
2554 : 572 : static std::string longDescription() { return
2555 [ + - ]: 572 : R"(This keyword is used to specify the configuration of delta spikes for,
2556 : : the delta initialization policy. The configuration is given by an even set
2557 : : of real numbers inside a spike...end block. Example: "spike 0.1 1.0 end",
2558 : : which specifies a delta spike at sample space position 0.1 with relative
2559 : : height 1.0. The height must be between [0.0...1.0] inclusive and specifies a
2560 : : relative probability. See also the help on keyword icdelta.)"; }
2561 : : struct expect {
2562 : : using type = tk::real;
2563 [ + - ]: 572 : static std::string description() { return "even reals"; }
2564 : : };
2565 : : };
2566 : : using spike = keyword< spike_info, TAOCPP_PEGTL_STRING("spike") >;
2567 : :
2568 : : struct icdelta_info {
2569 : : static std::string name() { return "icdelta"; }
2570 : 572 : static std::string shortDescription() { return
2571 [ + - ]: 572 : R"(Introduce a icdelta...end block used to configure delta spikes)"; }
2572 : 572 : static std::string longDescription() { return
2573 [ + - ]: 572 : R"(This keyword is used to introduce a icdelta...end block in which delta
2574 : : spikes are configured for the delta initialization policy. Example:
2575 : : "init jointdelta" - select joint delta init-policy,"icdelta spike 0.1 0.3
2576 : : 0.9 0.7 end end" - prescribe a univariate distribution that consists of two
2577 : : delta-spikes at sample space positions 0.1 and 0.9 with spike heights 0.3
2578 : : and 0.7, respectively. Note that the sum of the heights must add up to
2579 : : unity. See also the help on keyword jointdelta and spike.)"; }
2580 : : };
2581 : : using icdelta = keyword< icdelta_info, TAOCPP_PEGTL_STRING("icdelta") >;
2582 : :
2583 : : struct betapdf_info {
2584 : : static std::string name() { return "betapdf"; }
2585 : 572 : static std::string shortDescription() { return
2586 [ + - ]: 572 : R"(Configure a beta distribution)"; }
2587 : 572 : static std::string longDescription() { return
2588 [ + - ]: 572 : R"(This keyword is used to specify the configuration of beta distributions
2589 : : for the beta initialization policy. The configuration is given by four
2590 : : real numbers inside a betapdf...end block. Example: "betapdf 0.2 0.3 0.0 1.0
2591 : : end", which specifies a univariate beta distribution with shape parameters
2592 : : 0.2 and 0.3, displacement 0.0, and scale 1.0. See also the help on keyword
2593 : : icbeta.)"; }
2594 : : struct expect {
2595 : : using type = tk::real;
2596 [ + - ]: 572 : static std::string description() { return "4 reals"; }
2597 : : };
2598 : : };
2599 : : using betapdf = keyword< betapdf_info, TAOCPP_PEGTL_STRING("betapdf") >;
2600 : :
2601 : : struct gaussian_info {
2602 : : static std::string name() { return "Gaussian"; }
2603 : 572 : static std::string shortDescription() { return
2604 [ + - ]: 572 : R"(Configure a Gaussian distribution)"; }
2605 : 572 : static std::string longDescription() { return
2606 [ + - ]: 572 : R"(This keyword is used to specify the configuration of Gaussian
2607 : : distributions for the jointgaussian initialization policy. The configuration
2608 : : is given by two real numbers inside a gaussian...end block. Example:
2609 : : "gaussian 0.2 0.3 end", which specifies a Gaussian distribution with 0.2
2610 : : mean and 0.3 variance. See also the help on keyword icgaussian.)"; }
2611 : : struct expect {
2612 : : using type = tk::real;
2613 [ + - ]: 572 : static std::string description() { return "2 reals"; }
2614 : : };
2615 : : };
2616 : : using gaussian = keyword< gaussian_info, TAOCPP_PEGTL_STRING("gaussian") >;
2617 : :
2618 : : struct icbeta_info {
2619 : : static std::string name() { return "icbeta"; }
2620 : 572 : static std::string shortDescription() { return
2621 [ + - ]: 572 : R"(Introduce an icbeta...end block used to configure beta distributions)"; }
2622 : 572 : static std::string longDescription() { return
2623 [ + - ]: 572 : R"(This keyword is used to introduce an icbeta...end block in which beta
2624 : : distributions are configured for the beta initialization policy. Example:
2625 : : "init jointbeta" - select beta init-policy,"icbeta betapdf 0.2 0.3 0.0 1.0
2626 : : end end" - prescribe a univariate beta distribution with shape parameters
2627 : : 0.2 and 0.3, displacement 0.0, and scale 1.0. See also the help on keyword
2628 : : jointbeta and betapdf.)"; }
2629 : : };
2630 : : using icbeta = keyword< icbeta_info, TAOCPP_PEGTL_STRING("icbeta") >;
2631 : :
2632 : : struct icgaussian_info {
2633 : : static std::string name() { return "icgaussian"; }
2634 : 572 : static std::string shortDescription() {
2635 [ + - ]: 572 : return R"(Configure a joint uncorrelated Gaussian as initial condition)"; }
2636 : 572 : static std::string longDescription() { return
2637 [ + - ]: 572 : R"(This keyword is used to introduce an icgaussian...end block in which
2638 : : Gaussian distributions are configured for the jointgaussian initialization
2639 : : policy. Example: "init jointgaussian" - select jointgaussian
2640 : : init-policy,"icgaussian gaussian 0.2 0.3 end end" - prescribes a univariate
2641 : : Gaussian distribution with 0.2 mean and 0.3 variance. See also the help on
2642 : : keyword jointgaussian and gaussian.)"; }
2643 : : };
2644 : : using icgaussian = keyword< icgaussian_info, TAOCPP_PEGTL_STRING("icgaussian") >;
2645 : :
2646 : : struct icjointgaussian_info {
2647 : : static std::string name() { return "icjointgaussian"; }
2648 : 572 : static std::string shortDescription() {
2649 [ + - ]: 572 : return R"(Configure an joint correlated Gaussian as initial condition)"; }
2650 : 572 : static std::string longDescription() { return
2651 [ + - ]: 572 : R"(This keyword is used to introduce an icjointgaussian...end block in which
2652 : : a multi-variate joint Gaussian distribution is configured for the
2653 : : jointgaussian initialization policy. Example: "init jointgaussian" - select
2654 : : jointgaussian init-policy, "
2655 : : icjointgaussian
2656 : : mean 0.0 0.5 1.0 end
2657 : : cov
2658 : : 4.0 2.5 1.1
2659 : : 32.0 5.6
2660 : : 23.0
2661 : : end
2662 : : end" - prescribes a tri-variate joint Gaussian distribution with means
2663 : : 0.0, 0.5 and 1.0, and a covariance matrix which must be symmetric positive
2664 : : definite. See also the help on keyword jointgaussian and gaussian.)"; }
2665 : : };
2666 : : using icjointgaussian =
2667 : : keyword< icjointgaussian_info, TAOCPP_PEGTL_STRING("icjointgaussian") >;
2668 : :
2669 : : struct gammapdf_info {
2670 : : static std::string name() { return "gammapdf"; }
2671 : 572 : static std::string shortDescription() { return
2672 [ + - ]: 572 : R"(Configure a gamma distribution)"; }
2673 : 572 : static std::string longDescription() { return
2674 [ + - ]: 572 : R"(This keyword is used to specify the configuration of gamma distributions
2675 : : for the gamma initialization policy. The configuration is given by two
2676 : : real numbers inside a gammapdf...end block. Example: "gammapdf 0.2 0.3
2677 : : end", which specifies a univariate gamma distribution with shape and scale
2678 : : parameters 0.2 and 0.3, respectively. See also the help on keyword
2679 : : icgamma.)"; }
2680 : : struct expect {
2681 : : using type = tk::real;
2682 [ + - ]: 572 : static std::string description() { return "2 reals"; }
2683 : : };
2684 : : };
2685 : : using gammapdf = keyword< gammapdf_info, TAOCPP_PEGTL_STRING("gammapdf") >;
2686 : :
2687 : : struct icgamma_info {
2688 : : static std::string name() { return "icgamma"; }
2689 : 572 : static std::string shortDescription() { return
2690 [ + - ]: 572 : R"(Configure a gamma distribution as initial condition)"; }
2691 : 572 : static std::string longDescription() { return
2692 [ + - ]: 572 : R"(This keyword is used to introduce an icgamma...end block in which gamma
2693 : : distributions are configured for the gamma initialization policy. Example:
2694 : : "init jointgamma" - select gamma init-policy,"icgamma gammapdf 0.2 0.3
2695 : : end end" - prescribe a univariate gamma distribution with shape and scale
2696 : : parameters 0.2 and 0.3, respectively. See also the help on keyword
2697 : : jointgamma and gammapdf.)"; }
2698 : : };
2699 : : using icgamma = keyword< icgamma_info, TAOCPP_PEGTL_STRING("icgamma") >;
2700 : :
2701 : : struct dirichletpdf_info {
2702 : : static std::string name() { return "dirichletpdf"; }
2703 : 572 : static std::string shortDescription() { return
2704 [ + - ]: 572 : R"(Configure a Dirichlet distribution)"; }
2705 : 572 : static std::string longDescription() { return
2706 [ + - ]: 572 : R"(This keyword is used to specify the configuration of a Dirichlet
2707 : : distribution for the Dirichlet initialization policy. The configuration is
2708 : : given by a vector of positive real numbers inside a dirichletpdf...end
2709 : : block. Example: "dirichletpdf 0.1 0.3 0.2 end" - prescribe a Dirichlet
2710 : : distribution with shape parameters 0.1, 0.3, and 0.2. See also the help on
2711 : : keyword icdirichlet.)"; }
2712 : : struct expect {
2713 : : using type = tk::real;
2714 [ + - ]: 572 : static std::string description() { return "reals"; }
2715 : : };
2716 : : };
2717 : : using dirichletpdf =
2718 : : keyword< dirichletpdf_info, TAOCPP_PEGTL_STRING("dirichletpdf") >;
2719 : :
2720 : : struct icdirichlet_info {
2721 : : static std::string name() { return "icdirichlet"; }
2722 : 572 : static std::string shortDescription() { return
2723 [ + - ]: 572 : R"(Configure a Dirichlet PDF as initial condition)"; }
2724 : 572 : static std::string longDescription() { return
2725 [ + - ]: 572 : R"(This keyword is used to introduce an icdirichlet...end block in which a
2726 : : Dirichlet distribution is configured for the Dirichlet initialization
2727 : : policy)"; }
2728 : : };
2729 : : using icdirichlet =
2730 : : keyword< icdirichlet_info, TAOCPP_PEGTL_STRING("icdirichlet") >;
2731 : :
2732 : : struct velocity_info {
2733 [ + - ]: 176 : static std::string name() { return "velocity"; }
2734 [ + - ]: 2137 : static std::string shortDescription() { return "Specify velocity"; }
2735 : 2137 : static std::string longDescription() { return
2736 [ + - ]: 2137 : R"(This keyword is used to configure a velocity vector, used for, e.g.,
2737 : : boundary or initial conditions or as a keyword that selects velocity in some
2738 : : other context-specific way, e.g., 'velocity' as opposed to 'position'.)";
2739 : : }
2740 : : struct expect {
2741 : : using type = tk::real;
2742 [ + - ]: 2137 : static std::string description() { return "real(s)"; }
2743 : : };
2744 : : };
2745 : : using velocity = keyword< velocity_info, TAOCPP_PEGTL_STRING("velocity") >;
2746 : :
2747 : : struct acceleration_info {
2748 [ + - ]: 4 : static std::string name() { return "acceleration"; }
2749 [ + - ]: 1565 : static std::string shortDescription() { return "Specify acceleration"; }
2750 : 1565 : static std::string longDescription() { return
2751 [ + - ]: 1565 : R"(This keyword is used as a keyword that selects acceleration in some
2752 : : other context-specific way, e.g., as opposed to 'velocity' or 'position'.)";
2753 : : }
2754 : : };
2755 : : using acceleration =
2756 : : keyword< acceleration_info, TAOCPP_PEGTL_STRING("acceleration") >;
2757 : :
2758 : : struct materialid_info {
2759 : : static std::string name() { return "materialid"; }
2760 [ + - ]: 1565 : static std::string shortDescription() { return "Specify material id"; }
2761 : 1565 : static std::string longDescription() { return
2762 [ + - ]: 1565 : R"(This keyword is used to configure the material id within a box as a part
2763 : : of the initialization.)";
2764 : : }
2765 : : struct expect {
2766 : : using type = std::size_t;
2767 : : static constexpr type lower = 1;
2768 [ + - ]: 1565 : static std::string description() { return "uint"; }
2769 : : };
2770 : : };
2771 : : using materialid = keyword< materialid_info,
2772 : : TAOCPP_PEGTL_STRING("materialid") >;
2773 : :
2774 : : struct mass_info {
2775 : : static std::string name() { return "mass"; }
2776 [ + - ]: 1565 : static std::string shortDescription() { return "Specify mass"; }
2777 : 1565 : static std::string longDescription() { return
2778 [ + - ]: 1565 : R"(This keyword is used to configure the mass
2779 : : and associated volume within a box.)";
2780 : : }
2781 : : struct expect {
2782 : : using type = tk::real;
2783 [ + - ]: 1565 : static std::string description() { return "real"; }
2784 : : };
2785 : : };
2786 : : using mass = keyword< mass_info, TAOCPP_PEGTL_STRING("mass") >;
2787 : :
2788 : : struct density_info {
2789 : : static std::string name() { return "density"; }
2790 [ + - ]: 1565 : static std::string shortDescription() { return "Specify density"; }
2791 : 1565 : static std::string longDescription() { return
2792 [ + - ]: 1565 : R"(This keyword is used to configure a density, used for, e.g., boundary or
2793 : : initial conditions.)";
2794 : : }
2795 : : struct expect {
2796 : : using type = tk::real;
2797 [ + - ]: 1565 : static std::string description() { return "real"; }
2798 : : };
2799 : : };
2800 : : using density = keyword< density_info, TAOCPP_PEGTL_STRING("density") >;
2801 : :
2802 : : struct pressure_info {
2803 : : static std::string name() { return "pressure"; }
2804 [ + - ]: 1565 : static std::string shortDescription() { return "Specify pressure"; }
2805 : 1565 : static std::string longDescription() { return
2806 [ + - ]: 1565 : R"(This keyword is used to configure a pressure, used for, e.g., boundary or
2807 : : initial conditions or as a keyword that selects pressure in some other
2808 : : context-specific way.)";
2809 : : }
2810 : : struct expect {
2811 : : using type = tk::real;
2812 [ + - ]: 1565 : static std::string description() { return "real"; }
2813 : : };
2814 : : };
2815 : : using pressure = keyword< pressure_info, TAOCPP_PEGTL_STRING("pressure") >;
2816 : :
2817 : : struct energy_info {
2818 : : static std::string name() { return "energy"; }
2819 : 1565 : static std::string shortDescription() { return
2820 [ + - ]: 1565 : "Specify energy per unit mass"; }
2821 : 1565 : static std::string longDescription() { return
2822 [ + - ]: 1565 : R"(This keyword is used to configure energy per unit mass, used for, e.g.,
2823 : : boundary or initial conditions.)"; }
2824 : : struct expect {
2825 : : using type = tk::real;
2826 [ + - ]: 1565 : static std::string description() { return "real"; }
2827 : : };
2828 : : };
2829 : : using energy = keyword< energy_info, TAOCPP_PEGTL_STRING("energy") >;
2830 : :
2831 : : struct energy_content_info {
2832 : : static std::string name() { return "energy_content"; }
2833 : 1565 : static std::string shortDescription() { return
2834 [ + - ]: 1565 : "Specify energy per unit volume";
2835 : : }
2836 : 1565 : static std::string longDescription() { return
2837 [ + - ]: 1565 : R"(This keyword is used to configure energy per unit volume, used for, e.g.,
2838 : : boundary or initial conditions.)"; }
2839 : : struct expect {
2840 : : using type = tk::real;
2841 [ + - ]: 1565 : static std::string description() { return "real"; }
2842 : : };
2843 : : };
2844 : : using energy_content =
2845 : : keyword< energy_content_info, TAOCPP_PEGTL_STRING("energy_content") >;
2846 : :
2847 : : struct temperature_info {
2848 : : static std::string name() { return "temperature"; }
2849 [ + - ]: 1565 : static std::string shortDescription() { return "Specify temperature"; }
2850 : 1565 : static std::string longDescription() { return
2851 [ + - ]: 1565 : R"(This keyword is used to configure temperature, used for, e.g.,
2852 : : boundary or initial conditions.)"; }
2853 : : struct expect {
2854 : : using type = tk::real;
2855 [ + - ]: 1565 : static std::string description() { return "real"; }
2856 : : };
2857 : : };
2858 : : using temperature =
2859 : : keyword< temperature_info, TAOCPP_PEGTL_STRING("temperature") >;
2860 : :
2861 : : struct lua_info {
2862 : : static std::string name() { return "lua"; }
2863 : 1565 : static std::string shortDescription() { return
2864 [ + - ]: 1565 : R"(Introduce a lua ... end block to inject lua code in control files)"; }
2865 : 1565 : static std::string longDescription() { return
2866 [ + - ]: 1565 : R"(This keyword is used to introduce a lua ... end block which can be used
2867 : : to inject arbitrary Lua code into control files. For more info on the lua
2868 : : language, see https://www.lua.org.)"; }
2869 : : };
2870 : : using lua = keyword< lua_info, TAOCPP_PEGTL_STRING("lua") >;
2871 : :
2872 : : struct xmin_info {
2873 : : static std::string name() { return "xmin"; }
2874 [ + - ]: 1565 : static std::string shortDescription() { return "Minimum x coordinate"; }
2875 : 1565 : static std::string longDescription() { return
2876 [ + - ]: 1565 : R"(This keyword used to configure a minimum x coordinate, e.g., to specify
2877 : : a box.)"; }
2878 : : struct expect {
2879 : : using type = tk::real;
2880 [ + - ]: 1565 : static std::string description() { return "real"; }
2881 : : };
2882 : : };
2883 : : using xmin = keyword< xmin_info, TAOCPP_PEGTL_STRING("xmin") >;
2884 : :
2885 : : struct xmax_info {
2886 : : static std::string name() { return "xmax"; }
2887 [ + - ]: 1565 : static std::string shortDescription() { return "Maximum x coordinate"; }
2888 : 1565 : static std::string longDescription() { return
2889 [ + - ]: 1565 : R"(This keyword used to configure a maximum x coordinate, e.g., to specify
2890 : : a box.)"; }
2891 : : struct expect {
2892 : : using type = tk::real;
2893 [ + - ]: 1565 : static std::string description() { return "real"; }
2894 : : };
2895 : : };
2896 : : using xmax = keyword< xmax_info, TAOCPP_PEGTL_STRING("xmax") >;
2897 : :
2898 : : struct ymin_info {
2899 : : static std::string name() { return "ymin"; }
2900 [ + - ]: 1565 : static std::string shortDescription() { return "Minimum y coordinate"; }
2901 : 1565 : static std::string longDescription() { return
2902 [ + - ]: 1565 : R"(This keyword used to configure a minimum y coordinate, e.g., to specify
2903 : : a box.)"; }
2904 : : struct expect {
2905 : : using type = tk::real;
2906 [ + - ]: 1565 : static std::string description() { return "real"; }
2907 : : };
2908 : : };
2909 : : using ymin = keyword< ymin_info, TAOCPP_PEGTL_STRING("ymin") >;
2910 : :
2911 : : struct ymax_info {
2912 : : static std::string name() { return "ymax"; }
2913 [ + - ]: 1565 : static std::string shortDescription() { return "Maximum y coordinate"; }
2914 : 1565 : static std::string longDescription() { return
2915 [ + - ]: 1565 : R"(This keyword used to configure a maximum y coordinate, e.g., to specify
2916 : : a box.)"; }
2917 : : struct expect {
2918 : : using type = tk::real;
2919 [ + - ]: 1565 : static std::string description() { return "real"; }
2920 : : };
2921 : : };
2922 : : using ymax = keyword< ymax_info, TAOCPP_PEGTL_STRING("ymax") >;
2923 : :
2924 : : struct zmin_info {
2925 : : static std::string name() { return "zmin"; }
2926 [ + - ]: 1565 : static std::string shortDescription() { return "Minimum z coordinate"; }
2927 : 1565 : static std::string longDescription() { return
2928 [ + - ]: 1565 : R"(This keyword used to configure a minimum z coordinate, e.g., to specify
2929 : : a box.)"; }
2930 : : struct expect {
2931 : : using type = tk::real;
2932 [ + - ]: 1565 : static std::string description() { return "real"; }
2933 : : };
2934 : : };
2935 : : using zmin = keyword< zmin_info, TAOCPP_PEGTL_STRING("zmin") >;
2936 : :
2937 : : struct zmax_info {
2938 : : static std::string name() { return "zmax"; }
2939 [ + - ]: 1565 : static std::string shortDescription() { return "Maximum z coordinate"; }
2940 : 1565 : static std::string longDescription() { return
2941 [ + - ]: 1565 : R"(This keyword used to configure a maximum z coordinate, e.g., to specify
2942 : : a box.)"; }
2943 : : struct expect {
2944 : : using type = tk::real;
2945 [ + - ]: 1565 : static std::string description() { return "real"; }
2946 : : };
2947 : : };
2948 : : using zmax = keyword< zmax_info, TAOCPP_PEGTL_STRING("zmax") >;
2949 : :
2950 : : struct impulse_info {
2951 [ + - ]: 4 : static std::string name() { return "impulse"; }
2952 : 1565 : static std::string shortDescription() { return
2953 [ + - ]: 1565 : "Select the impulse initiation type, e.g., for a box IC"; }
2954 : 1565 : static std::string longDescription() { return
2955 [ + - ]: 1565 : R"(This keyword can be used to select the 'impulse' initiation/assignment
2956 : : type for box initial conditions. It simply assigns the prescribed values to
2957 : : mesh points within a configured box at t=0.)"; }
2958 : : };
2959 : : using impulse = keyword< impulse_info, TAOCPP_PEGTL_STRING("impulse") >;
2960 : :
2961 : : struct linear_info {
2962 [ + - ]: 4 : static std::string name() { return "linear"; }
2963 : 1565 : static std::string shortDescription() { return
2964 [ + - ]: 1565 : "Select the linear initiation type, e.g., for a box IC"; }
2965 : 1565 : static std::string longDescription() { return
2966 [ + - ]: 1565 : R"(This keyword can be used to select the 'linear' initiation/assignment
2967 : : type for box initial conditions. Linear initiation uses a linear function
2968 : : in time and space, configured with an initiation point in space, an initial
2969 : : radius around the point, and a constant velocity that grows a sphere in time
2970 : : (and space) linearly and assigns values to mesh points falling within a
2971 : : growing sphere within a configured box.)"; }
2972 : : };
2973 : : using linear = keyword< linear_info, TAOCPP_PEGTL_STRING("linear") >;
2974 : :
2975 : : struct initiate_info {
2976 [ + - ]: 4 : static std::string name() { return "initiate type"; }
2977 [ + - ]: 1565 : static std::string shortDescription() { return "Initiation/assignemt type"; }
2978 : 1565 : static std::string longDescription() { return
2979 [ + - ]: 1565 : R"(This keyword is used to select an initiation type to configure how
2980 : : values are assigned, e.g., for a box initial condition. This can be used to
2981 : : specify, how the values are assigned to mesh nodes within a box. Examples:
2982 : : (1) impulse: assign the full values at t=0 for all points in a box,
2983 : : (2) linear: use a linear function in time and space, configured with an
2984 : : initiation point in space, an initial radius around the point, and a
2985 : : velocity that grows a sphere in time (and space) linearly and assigns values
2986 : : to mesh points falling within a growing sphere within a configured box.)"; }
2987 : : struct expect {
2988 [ + - ]: 1565 : static std::string description() { return "string"; }
2989 : 1565 : static std::string choices() {
2990 [ + - ][ + - ]: 3130 : return '\'' + impulse::string() + "\' | \'"
[ + - ]
2991 [ + - ][ + - ]: 6260 : + linear::string() + '\'';
2992 : : }
2993 : : };
2994 : : };
2995 : : using initiate = keyword< initiate_info, TAOCPP_PEGTL_STRING("initiate") >;
2996 : :
2997 : : struct box_info {
2998 : : static std::string name() { return "box"; }
2999 : 1565 : static std::string shortDescription() { return
3000 [ + - ]: 1565 : R"(Introduce a box ... end block used to assign initial conditions)"; }
3001 : 1565 : static std::string longDescription() { return
3002 : : R"(This keyword is used to introduce a box ... end block used to assign
3003 : : initial conditions within a box given by spatial coordinates. Example:
3004 : : box x- 0.5 x+ 1.5 y- -0.5 y+ 0.5 z- -0.5 z+ 0.5 density 1.2 end pressure
3005 : : 1.4 end end", which specifies a box with extends within which the density
3006 : : will be set to 1.2 and the pressure to be 1.4. Besides the box dimensions,
3007 : : the following physics keywords are allowed in a box ... end block:)"
3008 [ + - ][ + - ]: 3130 : + std::string("\'")
3009 [ + - ][ + - ]: 6260 : + materialid::string()+ "\', \'"
[ + - ]
3010 [ + - ][ + - ]: 6260 : + mass::string()+ "\', \'"
[ + - ]
3011 [ + - ][ + - ]: 6260 : + density::string()+ "\', \'"
[ + - ]
3012 [ + - ][ + - ]: 6260 : + velocity::string() + "\', \'"
[ + - ]
3013 [ + - ][ + - ]: 6260 : + energy::string() + "\', \'"
[ + - ]
3014 [ + - ][ + - ]: 6260 : + energy_content::string() + "\', \'"
[ + - ]
3015 [ + - ][ + - ]: 6260 : + temperature::string() + "\', \'"
[ + - ]
3016 [ + - ][ + - ]: 6260 : + pressure::string() + "\'."; }
3017 : : };
3018 : : using box = keyword< box_info, TAOCPP_PEGTL_STRING("box") >;
3019 : :
3020 : : struct ic_info {
3021 : : static std::string name() { return "ic"; }
3022 : 1565 : static std::string shortDescription() { return
3023 [ + - ]: 1565 : R"(Introduce an ic...end block used to configure initial conditions)"; }
3024 : 1565 : static std::string longDescription() { return
3025 : : R"(This keyword is used to introduce an ic...end block used to set initial
3026 [ + - ][ + - ]: 3130 : conditions. Keywords allowed in a ic ... end block: )" + std::string("\'")
3027 [ + - ][ + - ]: 6260 : + materialid::string()+ "\', \'"
[ + - ]
3028 [ + - ][ + - ]: 6260 : + mass::string()+ "\', \'"
[ + - ]
3029 [ + - ][ + - ]: 6260 : + density::string()+ "\', \'"
[ + - ]
3030 [ + - ][ + - ]: 6260 : + velocity::string() + "\', \'"
[ + - ]
3031 [ + - ][ + - ]: 6260 : + pressure::string() + "\', \'"
[ + - ]
3032 [ + - ][ + - ]: 6260 : + energy::string() + "\', \'"
[ + - ]
3033 [ + - ][ + - ]: 6260 : + temperature::string() + "\', \'"
[ + - ]
3034 [ + - ][ + - ]: 6260 : + box::string() + "\'.";
3035 : : }
3036 : : };
3037 : : using ic = keyword< ic_info, TAOCPP_PEGTL_STRING("ic") >;
3038 : :
3039 : : struct depvar_info {
3040 : : static std::string name() { return "depvar"; }
3041 : 2137 : static std::string shortDescription() { return
3042 [ + - ]: 2137 : "Select dependent variable (in a relevant block)"; }
3043 : 2137 : static std::string longDescription() { return
3044 [ + - ]: 2137 : R"(Dependent variable, e.g, in differential equations.)"; }
3045 : : struct expect {
3046 : : using type = char;
3047 [ + - ]: 2137 : static std::string description() { return "character"; }
3048 : : };
3049 : : };
3050 : : using depvar = keyword< depvar_info, TAOCPP_PEGTL_STRING("depvar") >;
3051 : :
3052 : : struct sde_rho2_info {
3053 : : static std::string name() { return "rho2"; }
3054 : 572 : static std::string shortDescription() { return
3055 [ + - ]: 572 : R"(Set SDE parameter(s) rho2)"; }
3056 : 572 : static std::string longDescription() { return
3057 [ + - ]: 572 : R"(This keyword is used to specify a vector of real numbers used to
3058 : : parameterize a system of stochastic differential equations. Example:
3059 : : "rho2 5.0 2.0 3.0 end". The length of the vector depends on the particular
3060 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
3061 : : struct expect {
3062 : : using type = tk::real;
3063 [ + - ]: 572 : static std::string description() { return "real(s)"; }
3064 : : };
3065 : : };
3066 : : using sde_rho2 = keyword< sde_rho2_info, TAOCPP_PEGTL_STRING("rho2") >;
3067 : :
3068 : : struct sde_rho_info {
3069 : : static std::string name() { return "rho"; }
3070 : 572 : static std::string shortDescription() { return
3071 [ + - ]: 572 : R"(Set SDE parameter(s) rho)"; }
3072 : 572 : static std::string longDescription() { return
3073 [ + - ]: 572 : R"(This keyword is used to specify a vector of real numbers used to
3074 : : parameterize a system of stochastic differential equations. Example:
3075 : : "rho 5.0 2.0 3.0 end". The length of the vector depends on the particular
3076 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
3077 : : struct expect {
3078 : : using type = tk::real;
3079 [ + - ]: 572 : static std::string description() { return "real(s)"; }
3080 : : };
3081 : : };
3082 : : using sde_rho = keyword< sde_rho_info, TAOCPP_PEGTL_STRING("rho") >;
3083 : :
3084 : : struct mean_gradient_info {
3085 : : static std::string name() { return "Prescribed mean gradient"; }
3086 : 572 : static std::string shortDescription() { return
3087 [ + - ]: 572 : R"(Set prescribed mean gradient)"; }
3088 : 572 : static std::string longDescription() { return
3089 [ + - ]: 572 : R"(This keyword is used to specify a vector of real numbers used to
3090 : : parameterize a system of stochastic differential equations. Example:
3091 : : "mean_gradient 1.0 1.0 0.0 end". One use of a mean gradient vector is to
3092 : : specify a prescribed mean scalar gradient in 3 spatial directions for a
3093 : : scalar transprot equation.)"; }
3094 : : struct expect {
3095 : : using type = tk::real;
3096 [ + - ]: 572 : static std::string description() { return "real(s)"; }
3097 : : };
3098 : : };
3099 : : using mean_gradient = keyword< mean_gradient_info,
3100 : : TAOCPP_PEGTL_STRING("mean_gradient") >;
3101 : :
3102 : : struct sde_rcomma_info {
3103 : : static std::string name() { return "rcomma"; }
3104 : 572 : static std::string shortDescription() { return
3105 [ + - ]: 572 : R"(Set SDE parameter(s) rcomma)"; }
3106 : 572 : static std::string longDescription() { return
3107 [ + - ]: 572 : R"(This keyword is used to specify a vector of real numbers used to
3108 : : parameterize a system of stochastic differential equations. Example:
3109 : : "rcomma 5.0 2.0 3.0 end". The length of the vector depends on the particular
3110 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
3111 : : struct expect {
3112 : : using type = tk::real;
3113 [ + - ]: 572 : static std::string description() { return "real(s)"; }
3114 : : };
3115 : : };
3116 : : using sde_rcomma = keyword< sde_rcomma_info, TAOCPP_PEGTL_STRING("rcomma") >;
3117 : :
3118 : : struct sde_r_info {
3119 : : static std::string name() { return "r"; }
3120 : 572 : static std::string shortDescription() { return
3121 [ + - ]: 572 : R"(Set SDE parameter(s) r)"; }
3122 : 572 : static std::string longDescription() { return
3123 [ + - ]: 572 : R"(This keyword is used to specify a vector of real numbers used to
3124 : : parameterize a system of stochastic differential equations. Example:
3125 : : "r 5.0 2.0 3.0 end". The length of the vector depends on the particular
3126 : : type of SDE system and is controlled by the preceding keyword 'ncomp'.)"; }
3127 : : struct expect {
3128 : : using type = tk::real;
3129 [ + - ]: 572 : static std::string description() { return "real(s)"; }
3130 : : };
3131 : : };
3132 : : using sde_r = keyword< sde_r_info, TAOCPP_PEGTL_STRING("r") >;
3133 : :
3134 : : struct dirichlet_info {
3135 [ + - ]: 172 : static std::string name() { return "Dirichlet"; }
3136 : 572 : static std::string shortDescription() { return
3137 [ + - ]: 572 : "Start configuration block for the Dirichlet SDE"; }
3138 : 572 : static std::string longDescription() { return
3139 : : R"(This keyword is used to introduce a dirichlet ... end block, used to
3140 : : specify the configuration of a system of stochastic differential
3141 : : equations (SDEs), whose invariant is the Dirichlet distribution. For more
3142 : : details on the Dirichlet SDE, see https://doi.org/10.1155/2013/842981.
3143 [ + - ][ + - ]: 1144 : Keywords allowed in a dirichlet ... end block: )" + std::string("\'")
3144 [ + - ][ + - ]: 2288 : + depvar::string()+ "\', \'"
[ + - ]
3145 [ + - ][ + - ]: 2288 : + ncomp::string() + "\', \'"
[ + - ]
3146 [ + - ][ + - ]: 2288 : + rng::string() + "\', \'"
[ + - ]
3147 [ + - ][ + - ]: 2288 : + init::string() + "\', \'"
[ + - ]
3148 [ + - ][ + - ]: 2288 : + coeff::string() + "\', \'"
[ + - ]
3149 [ + - ][ + - ]: 2288 : + sde_b::string() + "\', \'"
[ + - ]
3150 [ + - ][ + - ]: 2288 : + sde_S::string() + "\', \'"
[ + - ]
3151 [ + - ][ + - ]: 2288 : + sde_kappa::string() + "\'. "
3152 [ + - ]: 1144 : + R"(For an example dirichlet ... end block, see
3153 : : doc/html/walker_example_dirichlet.html.)";
3154 : : }
3155 : : };
3156 : : using dirichlet = keyword< dirichlet_info, TAOCPP_PEGTL_STRING("dirichlet") >;
3157 : :
3158 : : struct mixdirichlet_info {
3159 [ + - ]: 172 : static std::string name() { return "MixDirichlet"; }
3160 : 572 : static std::string shortDescription() { return
3161 [ + - ]: 572 : "Start configuration block for the Mixture Dirichlet SDE"; }
3162 : 572 : static std::string longDescription() { return
3163 : : R"(This keyword is used to introduce a mixdirichlet ... end block, used to
3164 : : specify the configuration of a system of stochastic differential
3165 : : equations (SDEs), whose invariant is the Dirichlet distribution constrained
3166 : : to model multi-material mixing in turbulent flows. For more
3167 : : details on the Dirichlet SDE, see https://doi.org/10.1155/2013/842981.
3168 [ + - ][ + - ]: 1144 : Keywords allowed in a mixdirichlet ... end block: )" + std::string("\'")
3169 [ + - ][ + - ]: 2288 : + depvar::string()+ "\', \'"
[ + - ]
3170 [ + - ][ + - ]: 2288 : + ncomp::string() + "\', \'"
[ + - ]
3171 [ + - ][ + - ]: 2288 : + rng::string() + "\', \'"
[ + - ]
3172 [ + - ][ + - ]: 2288 : + init::string() + "\', \'"
[ + - ]
3173 [ + - ][ + - ]: 2288 : + coeff::string() + "\', \'"
[ + - ]
3174 [ + - ][ + - ]: 2288 : + sde_b::string() + "\', \'"
[ + - ]
3175 [ + - ][ + - ]: 2288 : + sde_S::string() + "\', \'"
[ + - ]
3176 [ + - ][ + - ]: 2288 : + sde_kappa::string() + "\', \'"
[ + - ]
3177 [ + - ][ + - ]: 2288 : + sde_rho2::string() + "\', \'"
[ + - ]
3178 [ + - ][ + - ]: 2288 : + sde_r::string() + "\'. "
3179 [ + - ]: 1144 : + R"(For an example mixdirichlet ... end block, see
3180 : : doc/html/walker_example_mixdirichlet.html.)";
3181 : : }
3182 : : };
3183 : : using mixdirichlet =
3184 : : keyword< mixdirichlet_info, TAOCPP_PEGTL_STRING("mixdirichlet") >;
3185 : :
3186 : : struct gendir_info {
3187 [ + - ]: 172 : static std::string name() { return "Generalized Dirichlet"; }
3188 : 572 : static std::string shortDescription() { return
3189 [ + - ]: 572 : "Start configuration block for the generalized Dirichlet SDE"; }
3190 : 572 : static std::string longDescription() { return
3191 : : R"(This keyword is used to introduce a gendir ... end
3192 : : block, used to specify the configuration of a system of stochastic
3193 : : differential equations (SDEs), whose invariant is Lochner's generalized
3194 : : Dirichlet distribution. For more details on the generalized Dirichlet
3195 : : SDE, see https://doi.org/10.1063/1.4822416. Keywords allowed in a gendir
3196 [ + - ][ + - ]: 1144 : ... end block: )" + std::string("\'")
3197 [ + - ][ + - ]: 2288 : + depvar::string()+ "\', \'"
[ + - ]
3198 [ + - ][ + - ]: 2288 : + ncomp::string() + "\', \'"
[ + - ]
3199 [ + - ][ + - ]: 2288 : + rng::string() + "\', \'"
[ + - ]
3200 [ + - ][ + - ]: 2288 : + init::string() + "\', \'"
[ + - ]
3201 [ + - ][ + - ]: 2288 : + coeff::string() + "\', \'"
[ + - ]
3202 [ + - ][ + - ]: 2288 : + sde_b::string() + "\', \'"
[ + - ]
3203 [ + - ][ + - ]: 2288 : + sde_S::string() + "\', \'"
[ + - ]
3204 [ + - ][ + - ]: 2288 : + sde_c::string() + "\', \'"
[ + - ]
3205 [ + - ][ + - ]: 2288 : + sde_kappa::string() + "\'. "
3206 [ + - ]: 1144 : + R"(For an example gendir... end block, see
3207 : : doc/html/walker_example_gendir.html.)";
3208 : : }
3209 : : };
3210 : : using gendir = keyword< gendir_info, TAOCPP_PEGTL_STRING("gendir") >;
3211 : :
3212 : : struct wrightfisher_info {
3213 [ + - ]: 172 : static std::string name() { return "Wright-Fisher"; }
3214 : 572 : static std::string shortDescription() { return
3215 [ + - ]: 572 : "Start configuration block for the Wright-Fisher SDE"; }
3216 : 572 : static std::string longDescription() { return
3217 : : R"(This keyword is used to introduce a wright_fisher ... end block, used
3218 : : to specify the configuration of a system of stochastic differential
3219 : : equations (SDEs), whose invariant is the Dirichlet distribution. For more
3220 : : details on the Wright-Fisher SDE, see
3221 : : http://www.sciencedirect.com/science/article/pii/S0040580912001013.
3222 [ + - ][ + - ]: 1144 : Keywords allowed in a wright-fisher... end block: )" + std::string("\'")
3223 [ + - ][ + - ]: 2288 : + depvar::string()+ "\', \'"
[ + - ]
3224 [ + - ][ + - ]: 2288 : + ncomp::string() + "\', \'"
[ + - ]
3225 [ + - ][ + - ]: 2288 : + rng::string() + "\', \'"
[ + - ]
3226 [ + - ][ + - ]: 2288 : + init::string() + "\', \'"
[ + - ]
3227 [ + - ][ + - ]: 2288 : + coeff::string() + "\', \'"
[ + - ]
3228 [ + - ][ + - ]: 2288 : + sde_omega::string() + "\'. "
3229 [ + - ]: 1144 : + R"(For an example wright-fisher ... end block, see
3230 : : doc/html/walker_example_wf.html.)";
3231 : : }
3232 : : };
3233 : : using wrightfisher =
3234 : : keyword< wrightfisher_info, TAOCPP_PEGTL_STRING("wright-fisher") >;
3235 : :
3236 : : struct skewnormal_info {
3237 [ + - ]: 172 : static std::string name() { return "Skew-Normal"; }
3238 : 572 : static std::string shortDescription() { return
3239 [ + - ]: 572 : "Start configuration block for the Skew-normal SDE"; }
3240 : 572 : static std::string longDescription() { return
3241 : : R"(This keyword is used to introduce a skew-normal ... end block, used
3242 : : to specify the configuration of a system of stochastic differential
3243 : : equations (SDEs), whose invariant is the joint skew-normal distribution.
3244 : : For more details on the skew-normal distribution, see
3245 : : http://www.jstor.org/stable/2337278. Keywords allowed in an skew-normal ...
3246 [ + - ][ + - ]: 1144 : end block: )" + std::string("\'")
3247 [ + - ][ + - ]: 2288 : + depvar::string()+ "\', \'"
[ + - ]
3248 [ + - ][ + - ]: 2288 : + ncomp::string() + "\', \'"
[ + - ]
3249 [ + - ][ + - ]: 2288 : + rng::string() + "\', \'"
[ + - ]
3250 [ + - ][ + - ]: 2288 : + init::string() + "\', \'"
[ + - ]
3251 [ + - ][ + - ]: 2288 : + coeff::string() + "\', \'"
[ + - ]
3252 [ + - ][ + - ]: 2288 : + sde_sigmasq::string() + "\', \'"
[ + - ]
3253 [ + - ][ + - ]: 2288 : + sde_T::string() + "\', \'"
[ + - ]
3254 [ + - ][ + - ]: 2288 : + sde_lambda::string() + "\'. "
3255 [ + - ]: 1144 : + R"(For an example skew-normal... end block, see
3256 : : doc/html/walker_example_skewnormal.html.)";
3257 : : }
3258 : : };
3259 : : using skewnormal = keyword< skewnormal_info, TAOCPP_PEGTL_STRING("skew-normal") >;
3260 : :
3261 : : struct beta_info {
3262 [ + - ]: 172 : static std::string name() { return "Beta"; }
3263 : 572 : static std::string shortDescription() { return
3264 [ + - ]: 572 : "Introduce the beta SDE input block"; }
3265 : 572 : static std::string longDescription() { return
3266 : : R"(This keyword is used to introduce a beta ... end block, used to specify
3267 : : the configuration of a system of stochastic differential equations (SDEs),
3268 : : with linear drift and quadratic diagonal diffusion, whose invariant is the
3269 : : joint beta distribution. For more details on the beta SDE, see
3270 : : https://doi.org/10.1080/14685248.2010.510843 and src/DiffEq/Beta/Beta.hpp.
3271 [ + - ][ + - ]: 1144 : Keywords allowed in a beta ... end block: )" + std::string("\'")
3272 [ + - ][ + - ]: 2288 : + depvar::string()+ "\', \'"
[ + - ]
3273 [ + - ][ + - ]: 2288 : + ncomp::string() + "\', \'"
[ + - ]
3274 [ + - ][ + - ]: 2288 : + rng::string() + "\', \'"
[ + - ]
3275 [ + - ][ + - ]: 2288 : + init::string() + "\', \'"
[ + - ]
3276 [ + - ][ + - ]: 2288 : + coeff::string() + "\', \'"
[ + - ]
3277 [ + - ][ + - ]: 2288 : + sde_b::string() + "\', \'"
[ + - ]
3278 [ + - ][ + - ]: 2288 : + sde_S::string() + "\', \'"
[ + - ]
3279 [ + - ][ + - ]: 2288 : + sde_kappa::string() + "\'. "
3280 [ + - ]: 1144 : + R"(For an example beta ... end block, see
3281 : : doc/html/walker_example_beta.html.)";
3282 : : }
3283 : : };
3284 : : using beta = keyword< beta_info, TAOCPP_PEGTL_STRING("beta") >;
3285 : :
3286 : : struct numfracbeta_info {
3287 [ + - ]: 172 : static std::string name() { return "Number-fraction beta"; }
3288 : 572 : static std::string shortDescription() { return
3289 [ + - ]: 572 : "Introduce the numfracbeta SDE input block"; }
3290 : 572 : static std::string longDescription() { return
3291 : : R"(This keyword is used to introduce a numfracbeta ... end block, used to
3292 : : specify the configuration of a system of number-fraction beta SDEs, a system
3293 : : of stochastic differential equations (SDEs), in which, in addition to the
3294 : : dependent variable, computed with linear drift and quadratic diagonal
3295 : : diffusion (whose invariant is joint beta), two additional variables are
3296 : : computed. In other words, this is a beta SDE but there are two additional
3297 : : stochastic variables computed based on the beta SDE. If X is governed by the
3298 : : beta SDE, then the number-fraction beta SDE additionally governs rho(X) and
3299 : : V(X), where both rho and V are random variables, computed by rho(X) = rho2
3300 : : ( 1 - r' X ), and V(X) = 1 / [ rho2 ( 1 - r'X ) ]. For more details on the
3301 : : beta SDE, see https://doi.org/10.1080/14685248.2010.510843 and
3302 : : src/DiffEq/Beta/Beta.hpp. Keywords allowed in a numfracbeta ... end block: )"
3303 [ + - ][ + - ]: 1144 : + std::string("\'")
3304 [ + - ][ + - ]: 2288 : + depvar::string()+ "\', \'"
[ + - ]
3305 [ + - ][ + - ]: 2288 : + ncomp::string() + "\', \'"
[ + - ]
3306 [ + - ][ + - ]: 2288 : + rng::string() + "\', \'"
[ + - ]
3307 [ + - ][ + - ]: 2288 : + init::string() + "\', \'"
[ + - ]
3308 [ + - ][ + - ]: 2288 : + coeff::string() + "\', \'"
[ + - ]
3309 [ + - ][ + - ]: 2288 : + sde_b::string() + "\', \'"
[ + - ]
3310 [ + - ][ + - ]: 2288 : + sde_S::string() + "\', \'"
[ + - ]
3311 [ + - ][ + - ]: 2288 : + sde_kappa::string() + "\', \'"
[ + - ]
3312 [ + - ][ + - ]: 2288 : + sde_rho2::string() + "\', \'"
[ + - ]
3313 [ + - ][ + - ]: 2288 : + sde_rcomma::string() + "\'. "
3314 [ + - ]: 1144 : + R"(For an example numfracbeta ... end block, see
3315 : : doc/html/walker_example_numfracbeta.html.)";
3316 : : }
3317 : : };
3318 : : using numfracbeta = keyword< numfracbeta_info, TAOCPP_PEGTL_STRING("numfracbeta") >;
3319 : :
3320 : : struct massfracbeta_info {
3321 [ + - ]: 172 : static std::string name() { return "Mass-fraction beta"; }
3322 : 572 : static std::string shortDescription() { return
3323 [ + - ]: 572 : "Introduce the massfracbeta SDE input block"; }
3324 : 572 : static std::string longDescription() { return
3325 : : R"(This keyword is used to introduce a massfracbeta ... end block, used to
3326 : : specify the configuration of a system of number-fraction beta SDEs, a system
3327 : : of stochastic differential equations (SDEs), in which, in addition to the
3328 : : dependent variable, computed with linear drift and quadratic diagonal
3329 : : diffusion (whose invariant is joint beta), two additional variables are
3330 : : computed. In other words, this is a beta SDE but there are two additional
3331 : : stochastic variables computed based on the beta SDE. If Y is governed by the
3332 : : beta SDE, then the mass-fraction beta SDE additionally governs rho(Y) and
3333 : : V(Y), where both rho and V are random variables, computed by rho(Y) = rho2 /
3334 : : ( 1 + r Y ), and V(Y) = ( 1 + r Y ) / rho2. For more details on the beta
3335 : : SDE, see
3336 : : https://doi.org/10.1080/14685248.2010.510843 and src/DiffEq/Beta/Beta.hpp.
3337 : : Keywords allowed in a massfracbeta ... end block: )"
3338 [ + - ][ + - ]: 1144 : + std::string("\'")
3339 [ + - ][ + - ]: 2288 : + depvar::string()+ "\', \'"
[ + - ]
3340 [ + - ][ + - ]: 2288 : + ncomp::string() + "\', \'"
[ + - ]
3341 [ + - ][ + - ]: 2288 : + rng::string() + "\', \'"
[ + - ]
3342 [ + - ][ + - ]: 2288 : + init::string() + "\', \'"
[ + - ]
3343 [ + - ][ + - ]: 2288 : + coeff::string() + "\', \'"
[ + - ]
3344 [ + - ][ + - ]: 2288 : + sde_b::string() + "\', \'"
[ + - ]
3345 [ + - ][ + - ]: 2288 : + sde_S::string() + "\', \'"
[ + - ]
3346 [ + - ][ + - ]: 2288 : + sde_kappa::string() + "\', \'"
[ + - ]
3347 [ + - ][ + - ]: 2288 : + sde_rho2::string() + "\', \'"
[ + - ]
3348 [ + - ][ + - ]: 2288 : + sde_r::string() + "\'. "
3349 [ + - ]: 1144 : + R"(For an example massfracbeta ... end block, see
3350 : : doc/html/walker_example_massfracbeta.html.)";
3351 : : }
3352 : : };
3353 : : using massfracbeta = keyword< massfracbeta_info, TAOCPP_PEGTL_STRING("massfracbeta") >;
3354 : :
3355 : : struct mixnumfracbeta_info {
3356 [ + - ]: 172 : static std::string name() { return "Mix number-fraction beta"; }
3357 : 572 : static std::string shortDescription() { return
3358 [ + - ]: 572 : "Introduce the mixnumfracbeta SDE input block"; }
3359 : 572 : static std::string longDescription() { return
3360 : : R"(This keyword is used to introduce a mixnumfracbeta ... end block, used
3361 : : to specify the configuration of a system of mix number-fraction beta SDEs, a
3362 : : system of stochastic differential equations (SDEs), whose solution is the
3363 : : joint beta distribution and in which the usual beta SDE parameters b and
3364 : : kappa are specified via functions that constrain the beta SDE to be
3365 : : consistent with the turbulent mixing process. The mix number-fraction beta
3366 : : SDE is similar to the number-fraction beta SDE, only the process is made
3367 : : consistent with the no-mix and fully mixed limits via the specification of
3368 : : the SDE coefficients b and kappa. As in the number-fraction beta SDE, X is
3369 : : governed by the beta SDE and two additional stochastic variables are
3370 : : computed. However, in the mix number-fraction beta SDE the parameters b and
3371 : : kappa are given by b = Theta * b' and kappa = kappa' * <x^2>, where Theta =
3372 : : 1 - <x^2> / [ <X> ( 1 - <X> ], the fluctuation about the mean, <X>, is
3373 : : defined as usual: x = X - <X>, and b' and kappa' are user-specified
3374 : : constants. Similar to the number-fraction beta SDE, there two additional
3375 : : random variables computed besides, X, and they are rho(X) and V(X). For more
3376 : : detail on the number-fraction beta SDE, see the help on keyword
3377 : : 'numfracbeta'. For more details on the beta SDE, see
3378 : : https://doi.org/10.1080/14685248.2010.510843 and src/DiffEq/Beta/Beta.h.
3379 : : Keywords allowed in a mixnumfracbeta ... end block: )"
3380 [ + - ][ + - ]: 1144 : + std::string("\'")
3381 [ + - ][ + - ]: 2288 : + depvar::string()+ "\', \'"
[ + - ]
3382 [ + - ][ + - ]: 2288 : + ncomp::string() + "\', \'"
[ + - ]
3383 [ + - ][ + - ]: 2288 : + rng::string() + "\', \'"
[ + - ]
3384 [ + - ][ + - ]: 2288 : + init::string() + "\', \'"
[ + - ]
3385 [ + - ][ + - ]: 2288 : + coeff::string() + "\', \'"
[ + - ]
3386 [ + - ][ + - ]: 2288 : + sde_bprime::string() + "\', \'"
[ + - ]
3387 [ + - ][ + - ]: 2288 : + sde_S::string() + "\', \'"
[ + - ]
3388 [ + - ][ + - ]: 2288 : + sde_kappaprime::string() + "\', \'"
[ + - ]
3389 [ + - ][ + - ]: 2288 : + sde_rho2::string() + "\', \'"
[ + - ]
3390 [ + - ][ + - ]: 2288 : + sde_rcomma::string() + "\'. "
3391 [ + - ]: 1144 : + R"(For an example mixnumfracbeta ... end block, see
3392 : : doc/html/walker_example_mixnumfracbeta.html.)";
3393 : : }
3394 : : };
3395 : : using mixnumfracbeta =
3396 : : keyword< mixnumfracbeta_info, TAOCPP_PEGTL_STRING("mixnumfracbeta") >;
3397 : :
3398 : : struct eq_A005H_info {
3399 [ + - ]: 31 : static std::string name() { return "eq_A005H"; }
3400 : 572 : static std::string shortDescription() { return "Select inverse equilibrium "
3401 [ + - ]: 572 : "hydro time scale from DNS of HRT, A=0.05, IC:light<<heavy"; }
3402 : 572 : static std::string longDescription() { return
3403 [ + - ]: 572 : R"(Inverse equilibrium hydrodynamics time scale from DNS of homogeneous
3404 : : Rayleigh-Taylor instability, tau_eq, A = 0.05, IC: light << heavy.)"; }
3405 : : };
3406 : : using eq_A005H = keyword< eq_A005H_info, TAOCPP_PEGTL_STRING("eq_A005H") >;
3407 : :
3408 : : struct eq_A005S_info {
3409 [ + - ]: 31 : static std::string name() { return "eq_A005S"; }
3410 : 572 : static std::string shortDescription() { return "Select inverse equilibrium "
3411 [ + - ]: 572 : "hydro time scale from DNS of HRT, A=0.05, IC:light=heavy"; }
3412 : 572 : static std::string longDescription() { return
3413 [ + - ]: 572 : R"(Inverse equilibrium hydrodynamics time scale from DNS of homogeneous
3414 : : Rayleigh-Taylor instability, tau_eq, A = 0.05, IC: light = heavy.)"; }
3415 : : };
3416 : : using eq_A005S = keyword< eq_A005S_info, TAOCPP_PEGTL_STRING("eq_A005S") >;
3417 : :
3418 : : struct eq_A005L_info {
3419 [ + - ]: 31 : static std::string name() { return "eq_A005L"; }
3420 : 572 : static std::string shortDescription() { return "Select inverse equilibrium "
3421 [ + - ]: 572 : "hydro time scale from DNS of HRT, A=0.05, IC:light>>heavy"; }
3422 : 572 : static std::string longDescription() { return
3423 [ + - ]: 572 : R"(Inverse equilibrium hydrodynamics time scale from DNS of homogeneous
3424 : : Rayleigh-Taylor instability, tau_eq, A = 0.05, IC: light >> heavy.)"; }
3425 : : };
3426 : : using eq_A005L = keyword< eq_A005L_info, TAOCPP_PEGTL_STRING("eq_A005L") >;
3427 : :
3428 : : struct eq_A05H_info {
3429 [ + - ]: 31 : static std::string name() { return "eq_A05H"; }
3430 : 572 : static std::string shortDescription() { return "Select inverse equilibrium "
3431 [ + - ]: 572 : "hydro time scale from DNS of HRT, A=0.5, IC:light<<heavy"; }
3432 : 572 : static std::string longDescription() { return
3433 [ + - ]: 572 : R"(Inverse equilibrium hydrodynamics time scale from DNS of homogeneous
3434 : : Rayleigh-Taylor instability, tau_eq, A = 0.5, IC: light << heavy.)"; }
3435 : : };
3436 : : using eq_A05H = keyword< eq_A05H_info, TAOCPP_PEGTL_STRING("eq_A05H") >;
3437 : :
3438 : : struct eq_A05S_info {
3439 [ + - ]: 31 : static std::string name() { return "eq_A05S"; }
3440 : 572 : static std::string shortDescription() { return "Select inverse equilibrium "
3441 [ + - ]: 572 : "hydro time scale from DNS of HRT, A=0.5, IC:light=heavy"; }
3442 : 572 : static std::string longDescription() { return
3443 [ + - ]: 572 : R"(Inverse equilibrium hydrodynamics time scale from DNS of homogeneous
3444 : : Rayleigh-Taylor instability, tau_eq, A = 0.5, IC: light = heavy.)"; }
3445 : : };
3446 : : using eq_A05S = keyword< eq_A05S_info, TAOCPP_PEGTL_STRING("eq_A05S") >;
3447 : :
3448 : : struct eq_A05L_info {
3449 [ + - ]: 31 : static std::string name() { return "eq_A05L"; }
3450 : 572 : static std::string shortDescription() { return "Select inverse equilibrium "
3451 [ + - ]: 572 : "hydro time scale from DNS of HRT, A=0.5, IC:light>>heavy"; }
3452 : 572 : static std::string longDescription() { return
3453 [ + - ]: 572 : R"(Inverse equilibrium hydrodynamics time scale from DNS of homogeneous
3454 : : Rayleigh-Taylor instability, tau_eq, A = 0.5, IC: light >> heavy.)"; }
3455 : : };
3456 : : using eq_A05L = keyword< eq_A05L_info, TAOCPP_PEGTL_STRING("eq_A05L") >;
3457 : :
3458 : : struct eq_A075H_info {
3459 [ + - ]: 31 : static std::string name() { return "eq_A075H"; }
3460 : 572 : static std::string shortDescription() { return "Select inverse equilibrium "
3461 [ + - ]: 572 : "hydro time scale from DNS of HRT, A=0.75, IC:light<<heavy"; }
3462 : 572 : static std::string longDescription() { return
3463 [ + - ]: 572 : R"(Inverse equilibrium hydrodynamics time scale from DNS of homogeneous
3464 : : Rayleigh-Taylor instability, tau_eq, A = 0.75, IC: light << heavy.)"; }
3465 : : };
3466 : : using eq_A075H = keyword< eq_A075H_info, TAOCPP_PEGTL_STRING("eq_A075H") >;
3467 : :
3468 : : struct eq_A075S_info {
3469 [ + - ]: 31 : static std::string name() { return "eq_A075S"; }
3470 : 572 : static std::string shortDescription() { return "Select inverse equilibrium "
3471 [ + - ]: 572 : "hydro time scale from DNS of HRT, A=0.75, IC:light=heavy"; }
3472 : 572 : static std::string longDescription() { return
3473 [ + - ]: 572 : R"(Inverse equilibrium hydrodynamics time scale from DNS of homogeneous
3474 : : Rayleigh-Taylor instability, tau_eq, A = 0.75, IC: light = heavy.)"; }
3475 : : };
3476 : : using eq_A075S = keyword< eq_A075S_info, TAOCPP_PEGTL_STRING("eq_A075S") >;
3477 : :
3478 : : struct eq_A075L_info {
3479 [ + - ]: 31 : static std::string name() { return "eq_A075L"; }
3480 : 572 : static std::string shortDescription() { return "Select inverse equilibrium "
3481 [ + - ]: 572 : "hydro time scale from DNS of HRT, A=0.75, IC:light>>heavy"; }
3482 : 572 : static std::string longDescription() { return
3483 [ + - ]: 572 : R"(Inverse equilibrium hydrodynamics time scale from DNS of homogeneous
3484 : : Rayleigh-Taylor instability, tau_eq, A = 0.75, IC: light >> heavy.)"; }
3485 : : };
3486 : : using eq_A075L = keyword< eq_A075L_info, TAOCPP_PEGTL_STRING("eq_A075L") >;
3487 : :
3488 : : struct hydrotimescales_info {
3489 : : static std::string name() { return "hydrotimescales"; }
3490 : 572 : static std::string shortDescription() { return
3491 [ + - ]: 572 : R"(Set MixMassFractionBeta SDE parameter(s) hydrotimescales)"; }
3492 : 572 : static std::string longDescription() { return
3493 : : R"(This keyword is used to specify a vector of strings used to parameterize
3494 : : the system of stochastic differential equations, configured in a
3495 : : mixmassfracbeta ... end block. Within the mixmassfracbeta ... end block the
3496 : : coefficients policy must be set to 'hydrotimescale' in order for the
3497 : : hydrotimescales ... end block to be in effect. The 'hydrotimescales'
3498 : : keyword is then used to specify a list of strings, each specifying which
3499 : : inverse time scale should be used for the particular component integrated.
3500 : : Available time scales are defined in src/DiffEq/HydroTimescales.hpp.
3501 : : Example: "hydrotimescales eq_A05S eq_A05H eq_A05L eq_A05S eq_A05S end",
3502 : : which configures five inverse hydrodynamics time scales associated to 5
3503 : : components, i.e., 5 scalar stochastic differential equations, integrated,
3504 : : specified and configured within the given mixmassfracbeta ... end block. The
3505 : : length of the hydrotimescales vector depends on the number of scalar
3506 : : components and is controlled by the preceding keyword 'ncomp'. For
3507 : : mixmassfracbeta, ncomp is the actual number of scalar components * 4, since
3508 : : mixmassfractionbeta always computes 4 additional derived stochastic
3509 : : variables (in a diagnostic) fashion. See also MixMassFractionBeta::derived()
3510 : : in src/DiffEq/Beta/MixMassFractionBeta.hpp. Keywords allowed in a
3511 [ + - ][ + - ]: 1144 : hydrotimescales ... end block: )" + std::string("\'")
3512 [ + - ][ + - ]: 2288 : + eq_A005H::string() + "\', \'"
[ + - ]
3513 [ + - ][ + - ]: 2288 : + eq_A005S::string() + "\', \'"
[ + - ]
3514 [ + - ][ + - ]: 2288 : + eq_A005L::string() + "\', \'"
[ + - ]
3515 [ + - ][ + - ]: 2288 : + eq_A05H::string() + "\', \'"
[ + - ]
3516 [ + - ][ + - ]: 2288 : + eq_A05S::string() + "\', \'"
[ + - ]
3517 [ + - ][ + - ]: 2288 : + eq_A05L::string() + "\', \'"
[ + - ]
3518 [ + - ][ + - ]: 2288 : + eq_A075H::string() + "\', \'"
[ + - ]
3519 [ + - ][ + - ]: 2288 : + eq_A075S::string() + "\', \'"
[ + - ]
3520 [ + - ][ + - ]: 2288 : + eq_A075L::string() + "\'. "
3521 [ + - ]: 1144 : + R"(For an example hydrotimescales ... end block, see
3522 : : doc/html/walker_example_mixmassfracbeta.html.)"; }
3523 : : struct expect {
3524 : : using type = std::string;
3525 [ + - ]: 572 : static std::string description() { return "string(s)"; }
3526 : : };
3527 : : };
3528 : : using hydrotimescales =
3529 : : keyword< hydrotimescales_info, TAOCPP_PEGTL_STRING("hydrotimescales") >;
3530 : :
3531 : : struct prod_A005H_info {
3532 [ + - ]: 31 : static std::string name() { return "prod_A005H"; }
3533 : 572 : static std::string shortDescription() { return "Select production divided by "
3534 [ + - ]: 572 : "dissipation rate from DNS of HRT, A=0.05, IC:light<<heavy"; }
3535 : 572 : static std::string longDescription() { return
3536 [ + - ]: 572 : R"(Production divided by dissipation rate from DNS of homogeneous
3537 : : Rayleigh-Taylor instability, P/e, A = 0.05, IC: light << heavy.)"; }
3538 : : };
3539 : : using prod_A005H = keyword< prod_A005H_info, TAOCPP_PEGTL_STRING("prod_A005H") >;
3540 : :
3541 : : struct prod_A005S_info {
3542 [ + - ]: 31 : static std::string name() { return "prod_A005S"; }
3543 : 572 : static std::string shortDescription() { return "Select production divided by "
3544 [ + - ]: 572 : "dissipation rate from DNS of HRT, A=0.05, IC:light=heavy"; }
3545 : 572 : static std::string longDescription() { return
3546 [ + - ]: 572 : R"(Production divided by dissipation rate from DNS of homogeneous
3547 : : Rayleigh-Taylor instability, P/e, A = 0.05, IC: light = heavy.)"; }
3548 : : };
3549 : : using prod_A005S = keyword< prod_A005S_info, TAOCPP_PEGTL_STRING("prod_A005S") >;
3550 : :
3551 : : struct prod_A005L_info {
3552 [ + - ]: 31 : static std::string name() { return "prod_A005L"; }
3553 : 572 : static std::string shortDescription() { return "Select production divided by "
3554 [ + - ]: 572 : "dissipation rate from DNS of HRT, A=0.05, IC:light>>heavy"; }
3555 : 572 : static std::string longDescription() { return
3556 [ + - ]: 572 : R"(Production divided by dissipation rate from DNS of homogeneous
3557 : : Rayleigh-Taylor instability, P/e, A = 0.05, IC: light >> heavy.)"; }
3558 : : };
3559 : : using prod_A005L = keyword< prod_A005L_info, TAOCPP_PEGTL_STRING("prod_A005L") >;
3560 : :
3561 : : struct prod_A05H_info {
3562 [ + - ]: 31 : static std::string name() { return "prod_A05H"; }
3563 : 572 : static std::string shortDescription() { return "Select production divided by "
3564 [ + - ]: 572 : "dissipation rate from DNS of HRT, A=0.5, IC:light<<heavy"; }
3565 : 572 : static std::string longDescription() { return
3566 [ + - ]: 572 : R"(Production divided by dissipation rate from DNS of homogeneous
3567 : : Rayleigh-Taylor instability, P/e, A = 0.5, IC: light << heavy.)"; }
3568 : : };
3569 : : using prod_A05H = keyword< prod_A05H_info, TAOCPP_PEGTL_STRING("prod_A05H") >;
3570 : :
3571 : : struct prod_A05S_info {
3572 [ + - ]: 31 : static std::string name() { return "prod_A05S"; }
3573 : 572 : static std::string shortDescription() { return "Select production divided by "
3574 [ + - ]: 572 : "dissipation rate from DNS of HRT, A=0.5, IC:light=heavy"; }
3575 : 572 : static std::string longDescription() { return
3576 [ + - ]: 572 : R"(Production divided by dissipation rate from DNS of homogeneous
3577 : : Rayleigh-Taylor instability, P/e, A = 0.5, IC: light = heavy.)"; }
3578 : : };
3579 : : using prod_A05S = keyword< prod_A05S_info, TAOCPP_PEGTL_STRING("prod_A05S") >;
3580 : :
3581 : : struct prod_A05L_info {
3582 [ + - ]: 31 : static std::string name() { return "prod_A05L"; }
3583 : 572 : static std::string shortDescription() { return "Select production divided by "
3584 [ + - ]: 572 : "dissipation rate from DNS of HRT, A=0.5, IC:light>>heavy"; }
3585 : 572 : static std::string longDescription() { return
3586 [ + - ]: 572 : R"(Production divided by dissipation rate from DNS of homogeneous
3587 : : Rayleigh-Taylor instability, P/e, A = 0.5, IC: light >> heavy.)"; }
3588 : : };
3589 : : using prod_A05L = keyword< prod_A05L_info, TAOCPP_PEGTL_STRING("prod_A05L") >;
3590 : :
3591 : : struct prod_A075H_info {
3592 [ + - ]: 31 : static std::string name() { return "prod_A075H"; }
3593 : 572 : static std::string shortDescription() { return "Select production divided by "
3594 [ + - ]: 572 : "dissipation rate from DNS of HRT, A=0.75, IC:light<<heavy"; }
3595 : 572 : static std::string longDescription() { return
3596 [ + - ]: 572 : R"(Production divided by dissipation rate from DNS of homogeneous
3597 : : Rayleigh-Taylor instability, P/e, A = 0.75, IC: light << heavy.)"; }
3598 : : };
3599 : : using prod_A075H = keyword< prod_A075H_info, TAOCPP_PEGTL_STRING("prod_A075H") >;
3600 : :
3601 : : struct prod_A075S_info {
3602 [ + - ]: 31 : static std::string name() { return "prod_A075S"; }
3603 : 572 : static std::string shortDescription() { return "Select production divided by "
3604 [ + - ]: 572 : "dissipation rate from DNS of HRT, A=0.75, IC:light=heavy"; }
3605 : 572 : static std::string longDescription() { return
3606 [ + - ]: 572 : R"(Production divided by dissipation rate from DNS of homogeneous
3607 : : Rayleigh-Taylor instability, P/e, A = 0.75, IC: light = heavy.)"; }
3608 : : };
3609 : : using prod_A075S = keyword< prod_A075S_info, TAOCPP_PEGTL_STRING("prod_A075S") >;
3610 : :
3611 : : struct prod_A075L_info {
3612 [ + - ]: 31 : static std::string name() { return "prod_A075L"; }
3613 : 572 : static std::string shortDescription() { return "Select production divided by "
3614 [ + - ]: 572 : "dissipation rate from DNS of HRT, A=0.75, IC:light>>heavy"; }
3615 : 572 : static std::string longDescription() { return
3616 [ + - ]: 572 : R"(Production divided by dissipation rate from DNS of homogeneous
3617 : : Rayleigh-Taylor instability, P/e, A = 0.75, IC: light >> heavy.)"; }
3618 : : };
3619 : : using prod_A075L = keyword< prod_A075L_info, TAOCPP_PEGTL_STRING("prod_A075L") >;
3620 : :
3621 : : struct hydroproductions_info {
3622 : : static std::string name() { return "P/eps"; }
3623 : 572 : static std::string shortDescription() { return
3624 [ + - ]: 572 : R"(Set MixMassFractionBeta SDE parameter(s) productions)"; }
3625 : 572 : static std::string longDescription() { return
3626 : : R"(This keyword is used to specify a vector of strings used to parameterize
3627 : : the system of stochastic differential equations, configured in a
3628 : : mixmassfracbeta ... end block. Within the mixmassfracbeta ... end block the
3629 : : coefficients policy must be set to 'hydrotimescale' in order for the
3630 : : hydroproductions ... end block to be in effect. The 'hydroproductions'
3631 : : keyword is then used to specify a list of strings, each specifying which
3632 : : turbulent kinetic energy production dividied by the dissipation rate (P/eps)
3633 : : data (from direct numerical simulations) should be used for the particular
3634 : : component integrated. Available P/eps data are defined in
3635 : : src/DiffEq/HydroProductions.hpp. Example: "productions prod_A05S prod_A05H
3636 : : prod_A05L prod_A05S prod_A05S end", which
3637 : : configures five P/eps data sets associated to 5 components, i.e., 5 scalar
3638 : : stochastic differential equations, integrated, specified and configured
3639 : : within the given mixmassfracbeta ... end block. The length of the
3640 : : hydroproductions vector depends on the number of scalar components and is
3641 : : controlled by the preceding keyword 'ncomp'. For mixmassfracbeta, ncomp is
3642 : : the actual number of scalar components * 4, since mixmassfractionbeta always
3643 : : computes 4 additional derived stochastic variables (in a diagnostic)
3644 : : fashion. See also MixMassFractionBeta::derived() in
3645 : : src/DiffEq/MixMassFractionBeta.hpp. Keywords allowed in a hydroproductions
3646 [ + - ][ + - ]: 1144 : ... end block: )" + std::string("\'")
3647 [ + - ][ + - ]: 2288 : + prod_A005H::string() + "\', \'"
[ + - ]
3648 [ + - ][ + - ]: 2288 : + prod_A005S::string() + "\', \'"
[ + - ]
3649 [ + - ][ + - ]: 2288 : + prod_A005L::string() + "\', \'"
[ + - ]
3650 [ + - ][ + - ]: 2288 : + prod_A05H::string() + "\', \'"
[ + - ]
3651 [ + - ][ + - ]: 2288 : + prod_A05S::string() + "\', \'"
[ + - ]
3652 [ + - ][ + - ]: 2288 : + prod_A05L::string() + "\', \'"
[ + - ]
3653 [ + - ][ + - ]: 2288 : + prod_A075H::string() + "\', \'"
[ + - ]
3654 [ + - ][ + - ]: 2288 : + prod_A075S::string() + "\', \'"
[ + - ]
3655 [ + - ][ + - ]: 2288 : + prod_A075L::string() + "\'. "
3656 [ + - ]: 1144 : + R"(For an example hydroproductions ... end block, see
3657 : : doc/html/walker_example_mixmassfracbeta.html.)"; }
3658 : : struct expect {
3659 : : using type = std::string;
3660 [ + - ]: 572 : static std::string description() { return "string(s)"; }
3661 : : };
3662 : : };
3663 : : using hydroproductions =
3664 : : keyword< hydroproductions_info, TAOCPP_PEGTL_STRING("hydroproductions") >;
3665 : :
3666 : : struct mixmassfracbeta_info {
3667 [ + - ]: 172 : static std::string name() { return "Mix mass-fraction beta"; }
3668 : 572 : static std::string shortDescription() { return
3669 [ + - ]: 572 : "Introduce the mixmassfracbeta SDE input block"; }
3670 : 572 : static std::string longDescription() { return
3671 : : R"(This keyword is used in multiple ways: (1) To introduce a mixmassfracbeta
3672 : : ... end block, used to specify the configuration of a system of mix
3673 : : mass-fraction beta SDEs, a system of stochastic differential equations
3674 : : (SDEs), whose solution is the joint beta distribution and in which the usual
3675 : : beta SDE parameters b and kappa are specified via functions that constrain
3676 : : the beta SDE to be consistent with the turbulent mixing process. The mix
3677 : : mass-fraction beta SDE is similar to the mass-fraction beta SDE, only the
3678 : : process is made consistent with the no-mix and fully mixed limits via the
3679 : : specification of the SDE coefficients b and kappa. As in the mass-fraction
3680 : : beta SDE, Y is governed by the beta SDE and two additional stochastic
3681 : : variables are computed. However, in the mix mass-fraction beta SDE the
3682 : : parameters b and kappa are given by b = Theta * b' and kappa = kappa' *
3683 : : <y^2>, where Theta = 1 - <y^2> / [ <Y> ( 1 - <Y> ], the fluctuation about
3684 : : the mean, <Y>, is defined as usual: y = Y - <Y>, and b' and kappa' are
3685 : : user-specified constants. Similar to the mass-fraction beta SDE, there two
3686 : : additional random variables computed besides, Y, and they are rho(Y) and
3687 : : V(Y). For more detail on the mass-fraction beta SDE, see the help on keyword
3688 : : 'massfracbeta'. For more details on the beta SDE, see
3689 : : https://doi.org/10.1080/14685248.2010.510843 and src/DiffEq/Beta/Beta.hpp.
3690 : : Keywords allowed in a mixmassfracbeta ... end block: )"
3691 [ + - ][ + - ]: 1144 : + std::string("\'")
3692 [ + - ][ + - ]: 2288 : + depvar::string()+ "\', \'"
[ + - ]
3693 [ + - ][ + - ]: 2288 : + ncomp::string() + "\', \'"
[ + - ]
3694 [ + - ][ + - ]: 2288 : + rng::string() + "\', \'"
[ + - ]
3695 [ + - ][ + - ]: 2288 : + init::string() + "\', \'"
[ + - ]
3696 [ + - ][ + - ]: 2288 : + coeff::string() + "\', \'"
[ + - ]
3697 [ + - ][ + - ]: 2288 : + sde_bprime::string() + "\', \'"
[ + - ]
3698 [ + - ][ + - ]: 2288 : + sde_S::string() + "\', \'"
[ + - ]
3699 [ + - ][ + - ]: 2288 : + sde_kappaprime::string() + "\', \'"
[ + - ]
3700 [ + - ][ + - ]: 2288 : + sde_rho2::string() + "\', \'"
[ + - ]
3701 [ + - ][ + - ]: 2288 : + hydrotimescales::string() + "\', \'"
[ + - ]
3702 [ + - ][ + - ]: 2288 : + hydroproductions::string() + "\', \'"
[ + - ]
3703 [ + - ][ + - ]: 1144 : + "velocity" + "\', \'"
3704 [ + - ][ + - ]: 1144 : + "dissipation" + "\', \'"
3705 [ + - ][ + - ]: 2288 : + sde_r::string() + "\'. "
3706 [ + - ]: 1144 : + R"(For an example mixmassfracbeta ... end block, see
3707 : : doc/html/walker_example_mixmassfracbeta.html. (2) To specify a dependent
3708 : : variable (by a character) used to couple a differential equation system, in
3709 : : which the 'mixmassfracbeta' keyword appears) to another labeled by a
3710 : : 'depvar'.)";
3711 : : }
3712 : : };
3713 : : using mixmassfracbeta =
3714 : : keyword< mixmassfracbeta_info, TAOCPP_PEGTL_STRING("mixmassfracbeta") >;
3715 : :
3716 : : struct fullvar_info {
3717 [ + - ]: 31 : static std::string name() { return "full variable"; }
3718 : 572 : static std::string shortDescription() { return
3719 [ + - ]: 572 : "Select full variable (as the dependent variable) to solve for"; }
3720 : 572 : static std::string longDescription() { return
3721 [ + - ]: 572 : R"(This keyword is used to select the full random (instantaneous) variable
3722 : : as what quantity to solve for, i.e., use as the dependent variable, in,
3723 : : e.g., a position or velocity model for a stochastic particle. This
3724 : : configures how statistics must be interpreted.)"; }
3725 : : struct expect {
3726 [ + - ]: 572 : static std::string description() { return "string"; }
3727 : : };
3728 : : };
3729 : : using fullvar = keyword< fullvar_info, TAOCPP_PEGTL_STRING("fullvar") >;
3730 : :
3731 : : struct fluctuation_info {
3732 [ + - ]: 31 : static std::string name() { return "fluctuation"; }
3733 : 572 : static std::string shortDescription() { return
3734 [ + - ]: 572 : "Select fluctuation (as the dependent variable) to solve for"; }
3735 : 572 : static std::string longDescription() { return
3736 [ + - ]: 572 : R"(This keyword is used to select the fluctuation of a random variable as
3737 : : what quantity to solve for, i.e., use as the dependent variable, e.g., in a
3738 : : position or velocity model for a stochastic particle. This configures how
3739 : : statistics must be interpreted.)"; }
3740 : : struct expect {
3741 [ + - ]: 572 : static std::string description() { return "string"; }
3742 : : };
3743 : : };
3744 : : using fluctuation =
3745 : : keyword< fluctuation_info, TAOCPP_PEGTL_STRING("fluctuation") >;
3746 : :
3747 : : struct product_info {
3748 [ + - ]: 31 : static std::string name() { return "product"; }
3749 : 572 : static std::string shortDescription() { return
3750 [ + - ]: 572 : "Select product (as the dependent variable) to solve for"; }
3751 : 572 : static std::string longDescription() { return
3752 [ + - ]: 572 : R"(This keyword is used to select the product of multiple random variables
3753 : : as what quantity to solve for, i.e., use as the dependent variable, e.g., in
3754 : : a velocity model, solve for the product of the full density and the full
3755 : : velocity, i.e., the full momentum, for a stochastic particle. This
3756 : : configures how statistics must be interpreted.)"; }
3757 : : struct expect {
3758 [ + - ]: 572 : static std::string description() { return "string"; }
3759 : : };
3760 : : };
3761 : : using product =
3762 : : keyword< product_info, TAOCPP_PEGTL_STRING("product") >;
3763 : :
3764 : : struct fluctuating_momentum_info {
3765 [ + - ]: 31 : static std::string name() { return "fluctuating momentum"; }
3766 : 572 : static std::string shortDescription() { return
3767 [ + - ]: 572 : "Select fluctuating moment (as the dependent variable) to solve for"; }
3768 : 572 : static std::string longDescription() { return
3769 [ + - ]: 572 : R"(This keyword is used to select fluctuating moment as the dependent
3770 : : variable. This is a very specific quantity and used in conjunction with the
3771 : : Langevin equation for the velocity/momentum. The dependent variable is
3772 : : phi_i^* = rho^* u_i - <rho^* u_i^*>, where the star superscript means a full
3773 : : (i.e., not only a fluctuation about some mean) random variable, u_i is the
3774 : : fluctuating velocity, u_i = u^*_i - <u_i^*>, and angle brackets denote the
3775 : : ensemble average. This also configures how statistics must be
3776 : : interpreted.)"; }
3777 : : struct expect {
3778 [ + - ]: 572 : static std::string description() { return "string"; }
3779 : : };
3780 : : };
3781 : : using fluctuating_momentum = keyword< fluctuating_momentum_info,
3782 : : TAOCPP_PEGTL_STRING("fluctuating_momentum") >;
3783 : :
3784 : : struct solve_info {
3785 : : static std::string name() { return "solve for"; }
3786 : 572 : static std::string shortDescription() { return
3787 [ + - ]: 572 : "Select dependent variable to solve for"; }
3788 : 572 : static std::string longDescription() { return
3789 [ + - ]: 572 : R"(This keyword is used to select an the quantity (the dependent variable)
3790 : : to solve for in walker's position and/or velocity model. This configures how
3791 : : statistics must be interpreted.)"; }
3792 : : struct expect {
3793 [ + - ]: 572 : static std::string description() { return "string"; }
3794 : 572 : static std::string choices() {
3795 [ + - ][ + - ]: 1144 : return '\'' + fullvar::string() + "\' | \'"
[ + - ]
3796 [ + - ][ + - ]: 2288 : + fluctuation::string() + "\' | \'"
[ + - ]
3797 [ + - ][ + - ]: 2288 : + product::string() + "\' | \'"
[ + - ]
3798 [ + - ][ + - ]: 2288 : + fluctuating_momentum::string() + '\'';
3799 : : }
3800 : : };
3801 : : };
3802 : : using solve = keyword< solve_info, TAOCPP_PEGTL_STRING("solve") >;
3803 : :
3804 : : struct slm_info {
3805 [ + - ]: 10 : static std::string name() { return "slm"; }
3806 : 572 : static std::string shortDescription() { return
3807 [ + - ]: 572 : "Select the simplified Langevin model (SLM) for the velocity PDF model"; }
3808 : 572 : static std::string longDescription() { return
3809 [ + - ]: 572 : R"(This keyword is used to select the simplified Langevin model (SLM) for
3810 : : the Lagrangian velocity in turbulent flows.)"; }
3811 : : struct expect {
3812 [ + - ]: 572 : static std::string description() { return "string"; }
3813 : : };
3814 : : };
3815 : : using slm = keyword< slm_info, TAOCPP_PEGTL_STRING("slm") >;
3816 : :
3817 : : struct glm_info {
3818 [ + - ]: 10 : static std::string name() { return "glm"; }
3819 : 572 : static std::string shortDescription() { return
3820 [ + - ]: 572 : "Select the generalized Langevin model for the velocity PDF model"; }
3821 : 572 : static std::string longDescription() { return
3822 [ + - ]: 572 : R"(This keyword is used to select the generalized Langevin model for the
3823 : : Lagrangian velocity in turbulent flows.)"; }
3824 : : struct expect {
3825 [ + - ]: 572 : static std::string description() { return "string"; }
3826 : : };
3827 : : };
3828 : : using glm = keyword< glm_info, TAOCPP_PEGTL_STRING("glm") >;
3829 : :
3830 : : struct variant_info {
3831 : : static std::string name() { return "variant"; }
3832 : 572 : static std::string shortDescription() { return
3833 [ + - ]: 572 : "Select velocity PDF model variant"; }
3834 : 572 : static std::string longDescription() { return
3835 [ + - ]: 572 : R"(This keyword is used to select the velocity PDF model variant.)"; }
3836 : : struct expect {
3837 [ + - ]: 572 : static std::string description() { return "string"; }
3838 : 572 : static std::string choices() {
3839 [ + - ][ + - ]: 1144 : return '\'' + slm::string() + "\' | \'"
[ + - ]
3840 [ + - ][ + - ]: 2288 : + glm::string() + '\'';
3841 : : }
3842 : : };
3843 : : };
3844 : : using variant = keyword< variant_info, TAOCPP_PEGTL_STRING("variant") >;
3845 : :
3846 : : struct light_info {
3847 [ + - ]: 16 : static std::string name() { return "light"; }
3848 : 572 : static std::string shortDescription() { return
3849 [ + - ]: 572 : "Select the light-fluid normalization for the mixture Dirichlet SDE"; }
3850 : 572 : static std::string longDescription() { return
3851 [ + - ]: 572 : R"(This keyword is used to select the light-fluid normalization for the
3852 : : mixture Dirichlet PDF/SDE model for multi-material mixing in turbulent
3853 : : flows.)"; }
3854 : : struct expect {
3855 [ + - ]: 572 : static std::string description() { return "string"; }
3856 : : };
3857 : : };
3858 : : using light = keyword< light_info, TAOCPP_PEGTL_STRING("light") >;
3859 : :
3860 : : struct heavy_info {
3861 [ + - ]: 16 : static std::string name() { return "heavy"; }
3862 : 572 : static std::string shortDescription() { return
3863 [ + - ]: 572 : "Select the heavy-fluid normalization for the mixture Dirichlet SDE"; }
3864 : 572 : static std::string longDescription() { return
3865 [ + - ]: 572 : R"(This keyword is used to select the heavy-fluid normalization for the
3866 : : mixture Dirichlet PDF/SDE model for multi-material mixing in turbulent
3867 : : flows.)"; }
3868 : : struct expect {
3869 [ + - ]: 572 : static std::string description() { return "string"; }
3870 : : };
3871 : : };
3872 : : using heavy = keyword< heavy_info, TAOCPP_PEGTL_STRING("heavy") >;
3873 : :
3874 : : struct normalization_info {
3875 : : static std::string name() { return "normalization"; }
3876 : 572 : static std::string shortDescription() { return
3877 [ + - ]: 572 : "Select mixture Dirichlet PDF model normalization type"; }
3878 : 572 : static std::string longDescription() { return
3879 [ + - ]: 572 : R"(This keyword is used to select the mixture Dirichlet PDF model
3880 : : normalization type.)"; }
3881 : : struct expect {
3882 [ + - ]: 572 : static std::string description() { return "string"; }
3883 : 572 : static std::string choices() {
3884 [ + - ][ + - ]: 1144 : return '\'' + light::string() + "\' | \'"
[ + - ]
3885 [ + - ][ + - ]: 2288 : + heavy::string() + '\'';
3886 : : }
3887 : : };
3888 : : };
3889 : : using normalization =
3890 : : keyword< normalization_info, TAOCPP_PEGTL_STRING("normalization") >;
3891 : :
3892 : : struct position_info {
3893 [ + - ]: 176 : static std::string name() { return "position"; }
3894 : 2137 : static std::string shortDescription() { return
3895 [ + - ]: 2137 : "Introduce the (particle) position equation input block or coupling"; }
3896 : 2137 : static std::string longDescription() { return
3897 : : R"(This keyword is used to introduce a position ...
3898 : : end block, used to specify the configuration of a system of deterministic or
3899 : : stochastic differential equations, governing particle positions usually in
3900 : : conjunction with velocity model, e.g, the Langevin, model. Note that the
3901 : : random number generator r123_philox is automatically put on the list as a
3902 : : selected RNG if no RNG is selected. Keywords allowed in a position ... end
3903 [ + - ]: 2137 : block: )" +
3904 [ + - ]: 4274 : std::string("\'")
3905 [ + - ][ + - ]: 8548 : + depvar::string()+ "\', \'"
[ + - ]
3906 [ + - ][ + - ]: 8548 : + rng::string() + "\', \'"
[ + - ]
3907 [ + - ][ + - ]: 8548 : + init::string() + "\', \'"
[ + - ]
3908 [ + - ][ + - ]: 8548 : + coeff::string() + "\', \'"
3909 [ + - ][ + - ]: 4274 : + "velocity" + "\', \'"
3910 [ + - ]: 4274 : + R"(For an example position ... end block, see
3911 : : doc/html/walker_example_position.html. (2) To specify a dependent
3912 : : variable (by a character) used to couple a differential equation system, in
3913 : : which the 'position' keyword appears) to another labeled by a 'depvar'.
3914 : : Note that this keyword can also be used as a keyword that selects position
3915 : : in some other context-specific way, e.g., 'position' as opposed to
3916 : : 'velocity'.)";
3917 : : }
3918 : : };
3919 : : using position = keyword< position_info, TAOCPP_PEGTL_STRING("position") >;
3920 : :
3921 : : struct dissipation_info {
3922 [ + - ]: 172 : static std::string name() { return "dissipation"; }
3923 : 572 : static std::string shortDescription() { return
3924 [ + - ]: 572 : "Introduce the (particle) dissipation equation input block or coupling"; }
3925 : 572 : static std::string longDescription() { return
3926 : : R"(This keyword is used to introduce a dissipation
3927 : : ... end block, used to specify the configuration of a system of
3928 : : deterministic or stochastic differential equations, governing a particle
3929 : : quantity that models the dissipation rate of turbulent kinetic energy, used
3930 : : to coupled to particle velocity model, e.g, the Langevin, model. Note that
3931 : : the random number generator r123_philox is automatically put on the list as
3932 : : a selected RNG if no RNG is selected. Keywords allowed in a dissipation ...
3933 [ + - ]: 572 : end block: )" +
3934 [ + - ]: 1144 : std::string("\'")
3935 [ + - ][ + - ]: 2288 : + depvar::string()+ "\', \'"
[ + - ]
3936 [ + - ][ + - ]: 2288 : + rng::string() + "\', \'"
[ + - ]
3937 [ + - ][ + - ]: 2288 : + init::string() + "\', \'"
[ + - ]
3938 [ + - ][ + - ]: 2288 : + coeff::string() + "\', \'"
3939 [ + - ][ + - ]: 1144 : + "velocity" + "\', \'"
3940 [ + - ]: 1144 : + R"(For an example dissipation ... end block, see
3941 : : doc/html/walker_example_dissipation.html. (2) To specify a dependent
3942 : : variable (by a character) used to couple a differential equation system, in
3943 : : which the 'dissipation' keyword appears) to another labeled by a 'depvar'.)";
3944 : : }
3945 : : };
3946 : : using dissipation =
3947 : : keyword< dissipation_info, TAOCPP_PEGTL_STRING("dissipation") >;
3948 : :
3949 : : struct velocitysde_info {
3950 : : static std::string name() { return "velocity"; }
3951 : 572 : static std::string shortDescription() { return
3952 [ + - ]: 572 : "Introduce the velocity equation input block or coupling"; }
3953 : 572 : static std::string longDescription() { return
3954 : : R"(This keyword is used to introduce a velocity ...
3955 : : end block, used to specify the configuration of a system of stochastic
3956 : : differential equations (SDEs), governed by the Langevin model for the
3957 : : fluctuating velocity in homogeneous variable-density turbulence. For more
3958 : : details on this Langevin model, see
3959 : : https://doi.org/10.1080/14685248.2011.554419 and
3960 : : src/DiffEq/Velocity/Velocity.hpp. Keywords allowed in a velocity ... end
3961 [ + - ]: 572 : block: )" +
3962 [ + - ]: 1144 : std::string("\'")
3963 [ + - ][ + - ]: 2288 : + depvar::string()+ "\', \'"
[ + - ]
3964 [ + - ][ + - ]: 2288 : + rng::string() + "\', \'"
[ + - ]
3965 [ + - ][ + - ]: 2288 : + init::string() + "\', \'"
[ + - ]
3966 [ + - ][ + - ]: 2288 : + coeff::string() + "\', \'"
[ + - ]
3967 [ + - ][ + - ]: 2288 : + hydrotimescales::string() + "\', \'"
[ + - ]
3968 [ + - ][ + - ]: 2288 : + hydroproductions::string() + "\', \'"
[ + - ]
3969 [ + - ][ + - ]: 2288 : + sde_c0::string() + "\'. "
[ + - ]
3970 [ + - ][ + - ]: 2288 : + position::string() + "\', \'"
[ + - ]
3971 [ + - ][ + - ]: 2288 : + dissipation::string() + "\', \'"
[ + - ]
3972 [ + - ][ + - ]: 2288 : + mixmassfracbeta::string() + "\', \'"
3973 [ + - ]: 1144 : + R"(For an example velocity ... end block, see
3974 : : doc/html/walker_example_velocity.html. (2) To specify a dependent
3975 : : variable (by a character) used to couple a differential equation system, in
3976 : : which the 'velocity' keyword appears) to another labeled by a 'depvar'.)";
3977 : : }
3978 : : };
3979 : : using velocitysde = keyword< velocitysde_info, TAOCPP_PEGTL_STRING("velocity") >;
3980 : :
3981 : : struct gamma_info {
3982 [ + - ]: 172 : static std::string name() { return "Gamma"; }
3983 : 572 : static std::string shortDescription() { return
3984 [ + - ]: 572 : "Introduce the gamma SDE input block"; }
3985 : 572 : static std::string longDescription() { return
3986 [ + - ]: 572 : R"(This keyword is used to introduce the gamma ... end block, used to
3987 : : specify the configuration of a system of stochastic differential equations
3988 : : (SDEs), with linear drift and linear diagonal diffusion, whose invariant
3989 : : is the joint gamma distribution.)";
3990 : : }
3991 : : };
3992 : : using gamma = keyword< gamma_info, TAOCPP_PEGTL_STRING("gamma") >;
3993 : :
3994 : : struct ornstein_uhlenbeck_info {
3995 [ + - ]: 172 : static std::string name() { return "Ornstein-Uhlenbeck"; }
3996 : 572 : static std::string shortDescription() { return
3997 [ + - ]: 572 : "Introduce the Ornstein-Uhlenbeck SDE input block"; }
3998 : 572 : static std::string longDescription() { return
3999 : : R"(This keyword is used to introduce an ornstein-uhlenbeck ... end block,
4000 : : used to specify the configuration of a system of stochastic differential
4001 : : equations (SDEs), with linear drift and constant diffusion, whose
4002 : : invariant is the joint normal distribution. Keywords allowed in an
4003 [ + - ][ + - ]: 1144 : ornstein-uhlenbeck ... end block: )" + std::string("\'")
4004 [ + - ][ + - ]: 2288 : + depvar::string()+ "\', \'"
[ + - ]
4005 [ + - ][ + - ]: 2288 : + ncomp::string() + "\', \'"
[ + - ]
4006 [ + - ][ + - ]: 2288 : + rng::string() + "\', \'"
[ + - ]
4007 [ + - ][ + - ]: 2288 : + init::string() + "\', \'"
[ + - ]
4008 [ + - ][ + - ]: 2288 : + coeff::string() + "\', \'"
[ + - ]
4009 [ + - ][ + - ]: 2288 : + sde_sigmasq::string() + "\', \'"
[ + - ]
4010 [ + - ][ + - ]: 2288 : + sde_theta::string() + "\', \'"
[ + - ]
4011 [ + - ][ + - ]: 2288 : + sde_mu::string() + "\'. "
4012 [ + - ]: 1144 : + R"(For an example ornstein-uhlenbeck ... end block, see
4013 : : doc/html/walker_example_ou.html.)";
4014 : : }
4015 : : };
4016 : : using ornstein_uhlenbeck =
4017 : : keyword< ornstein_uhlenbeck_info, TAOCPP_PEGTL_STRING("ornstein-uhlenbeck") >;
4018 : :
4019 : : struct diag_ou_info {
4020 [ + - ]: 172 : static std::string name() { return "Diagonal Ornstein-Uhlenbeck"; }
4021 : 572 : static std::string shortDescription() { return
4022 [ + - ]: 572 : "Introduce the diagonal Ornstein-Uhlenbeck SDE input block"; }
4023 : 572 : static std::string longDescription() { return
4024 : : R"(This keyword is used to introduce a diag_ou ... end
4025 : : block, where 'diag_ou' stands for diagonal Ornstein-Uhlenbeck' and is used
4026 : : to specify the configuration of a system of stochastic differential
4027 : : equations (SDEs), with linear drift and constant diagonal diffusion, whose
4028 : : invariant is the joint normal distribution. Keywords
4029 [ + - ][ + - ]: 1144 : allowed in a diagou ... end block: )" + std::string("\'")
4030 [ + - ][ + - ]: 2288 : + depvar::string()+ "\', \'"
[ + - ]
4031 [ + - ][ + - ]: 2288 : + ncomp::string() + "\', \'"
[ + - ]
4032 [ + - ][ + - ]: 2288 : + rng::string() + "\', \'"
[ + - ]
4033 [ + - ][ + - ]: 2288 : + init::string() + "\', \'"
[ + - ]
4034 [ + - ][ + - ]: 2288 : + coeff::string() + "\', \'"
[ + - ]
4035 [ + - ][ + - ]: 2288 : + sde_sigmasq::string() + "\', \'"
[ + - ]
4036 [ + - ][ + - ]: 2288 : + sde_theta::string() + "\', \'"
[ + - ]
4037 [ + - ][ + - ]: 2288 : + sde_mu::string() + "\'. "
4038 [ + - ]: 1144 : + R"(For an example diagou ... end block, see
4039 : : doc/html/walker_example_diagou.html.)";
4040 : : }
4041 : : };
4042 : : using diag_ou = keyword< diag_ou_info, TAOCPP_PEGTL_STRING("diag_ou") >;
4043 : :
4044 : : struct control_info {
4045 : : static std::string name() { return "control"; }
4046 : 4945 : static std::string shortDescription()
4047 [ + - ]: 4945 : { return "Specify the control file name [REQUIRED]"; }
4048 : 4945 : static std::string longDescription() { return
4049 [ + - ]: 4945 : R"(This keyword is used to specify the name of the control file from which
4050 : : detailed user input is parsed.)";
4051 : : }
4052 : : using alias = Alias< c >;
4053 : : struct expect {
4054 : : using type = std::string;
4055 [ + - ]: 4945 : static std::string description() { return "string"; }
4056 : : };
4057 : : };
4058 : : using control = keyword< control_info, TAOCPP_PEGTL_STRING("control") >;
4059 : :
4060 : : struct smallcrush_info {
4061 [ + - ]: 17 : static std::string name() { return "SmallCrush"; }
4062 : 180 : static std::string shortDescription() {
4063 [ + - ]: 180 : return "Select RNG battery SmallCrush"; }
4064 : 180 : static std::string longDescription() { return
4065 [ + - ]: 180 : R"(This keyword is used to introduce the description of the random number
4066 : : generator test suite, i.e., battery, 'SmallCrush'. SmallCrush is a
4067 : : battery of relatively small number, O(10), of tests, defined in TestU01,
4068 : : a library for the empirical testing of random number generators. For more "
4069 : : info, see http://www.iro.umontreal.ca/~simardr/testu01/tu01.html.)";
4070 : : }
4071 : : };
4072 : : using smallcrush = keyword< smallcrush_info, TAOCPP_PEGTL_STRING("smallcrush") >;
4073 : :
4074 : : struct crush_info {
4075 [ + - ]: 17 : static std::string name() { return "Crush"; }
4076 : 180 : static std::string shortDescription() { return
4077 [ + - ]: 180 : "Select RNG battery Crush"; }
4078 : 180 : static std::string longDescription() { return
4079 [ + - ]: 180 : R"(This keyword is used to introduce the description of the random number
4080 : : generator test suite, i.e., battery, 'Crush'. Crush is a suite of
4081 : : stringent statistical tests, O(100), defined in TestU01, a library for
4082 : : the empirical testing of random number generators. For more info, see
4083 : : http://www.iro.umontreal.ca/~simardr/testu01/tu01.html.)";
4084 : : }
4085 : : };
4086 : : using crush = keyword< crush_info, TAOCPP_PEGTL_STRING("crush") >;
4087 : :
4088 : : struct bigcrush_info {
4089 [ + - ]: 17 : static std::string name() { return "BigCrush"; }
4090 : 180 : static std::string shortDescription() { return
4091 [ + - ]: 180 : "Select RNG battery BigCrush"; }
4092 : 180 : static std::string longDescription() { return
4093 [ + - ]: 180 : R"(This keyword is used to introduce the description of the random number
4094 : : generator test suite, i.e., battery, 'BigCrush'. BigCrush is a
4095 : : suite of very stringent statistical tests, O(100), defined in TestU01, a
4096 : : library for the empirical testing of random number generators. For more
4097 : : info, see http://www.iro.umontreal.ca/~simardr/testu01/tu01.html.)";
4098 : : }
4099 : : };
4100 : : using bigcrush = keyword< bigcrush_info, TAOCPP_PEGTL_STRING("bigcrush") >;
4101 : :
4102 : : struct verbose_info {
4103 : : static std::string name() { return "verbose"; }
4104 : 4986 : static std::string shortDescription() { return
4105 [ + - ]: 4986 : "Select verbose screen output"; }
4106 : 4986 : static std::string longDescription() { return
4107 [ + - ]: 4986 : R"(This keyword is used to select verbose screen-output as opposed to the
4108 : : default quiet output. With quiet output only the most important messages
4109 : : are echoed to screen.)";
4110 : : }
4111 : : using alias = Alias< v >;
4112 : : };
4113 : : using verbose = keyword< verbose_info, TAOCPP_PEGTL_STRING("verbose") >;
4114 : :
4115 : : struct charestate_info {
4116 : : static std::string name() { return "charestate"; }
4117 : 4986 : static std::string shortDescription() { return
4118 [ + - ]: 4986 : "Enable verbose chare state screen output"; }
4119 : 4986 : static std::string longDescription() { return
4120 [ + - ]: 4986 : R"(This keyword is used to enable verbose Charm++ chare state collection and
4121 : : screen output. The chare state is displayed after a run is finished and the
4122 : : data collected is grouped by chare id (thisIndex), and within groups data
4123 : : is ordered by the time-stamp when a given chare member function is
4124 : : called. See src/Base/ChareState.hpp for details on what is collected. Note
4125 : : that to collect chare state, the given chare must be instrumented. Note that
4126 : : if quescence detection is enabled,
4127 : : chare state collection is also automatically enabled, but the chare state is
4128 : : only output if quiescence is detected (which also triggers an error).)";
4129 : : }
4130 : : using alias = Alias< S >;
4131 : : };
4132 : : using charestate = keyword< charestate_info, TAOCPP_PEGTL_STRING("state") >;
4133 : :
4134 : : struct benchmark_info {
4135 : : static std::string name() { return "benchmark"; }
4136 [ + - ]: 3363 : static std::string shortDescription() { return "Select benchmark mode"; }
4137 : 3363 : static std::string longDescription() { return
4138 [ + - ]: 3363 : R"(This keyword is used to select benchmark mode. In benchmark mode no large
4139 : : file output is performed, overriding the configuration in the control
4140 : : file.)";
4141 : : }
4142 : : using alias = Alias< b >;
4143 : : };
4144 : :
4145 : : using benchmark = keyword< benchmark_info, TAOCPP_PEGTL_STRING("benchmark") >;
4146 : :
4147 : : struct nonblocking_info {
4148 : : static std::string name() { return "nonblocking"; }
4149 : 3363 : static std::string shortDescription()
4150 [ + - ]: 3363 : { return "Select non-blocking migration"; }
4151 : 3363 : static std::string longDescription() { return
4152 [ + - ]: 3363 : R"(This keyword is used to select non-blocking, instead of the default
4153 : : blocking, migration. WARNING: This feature is experimental, not well
4154 : : tested, and may not always work as expected.)";
4155 : : }
4156 : : using alias = Alias< n >;
4157 : : };
4158 : :
4159 : : using nonblocking =
4160 : : keyword< nonblocking_info, TAOCPP_PEGTL_STRING("nonblocking") >;
4161 : :
4162 : : struct lbfreq_info {
4163 : : static std::string name() { return "Load balancing frequency"; }
4164 : 3363 : static std::string shortDescription()
4165 [ + - ]: 3363 : { return "Set load-balancing frequency during time stepping"; }
4166 : 3363 : static std::string longDescription() { return
4167 [ + - ]: 3363 : R"(This keyword is used to set the frequency of load-balancing during
4168 : : time stepping. The default is 1, which means that load balancing is
4169 : : initiated every time step. Note, however, that this does not necessarily
4170 : : mean that load balancing will be performed by the runtime system every
4171 : : time step, only that the Charm++ load-balancer is initiated. For more
4172 : : information, see the Charm++ manual.)";
4173 : : }
4174 : : using alias = Alias< l >;
4175 : : struct expect {
4176 : : using type = std::size_t;
4177 : : static constexpr type lower = 1;
4178 : : static constexpr type upper = std::numeric_limits< type >::max()-1;
4179 [ + - ]: 3363 : static std::string description() { return "int"; }
4180 : 3363 : static std::string choices() {
4181 [ + - ][ + - ]: 6726 : return "integer between [" + std::to_string(lower) + "..." +
[ + - ][ + - ]
4182 [ + - ]: 10089 : std::to_string(upper) + "] (both inclusive)";
4183 : : }
4184 : : };
4185 : : };
4186 : : using lbfreq = keyword< lbfreq_info, TAOCPP_PEGTL_STRING("lbfreq") >;
4187 : :
4188 : : struct rsfreq_info {
4189 : : static std::string name() { return "Checkpoint/restart frequency"; }
4190 : 3363 : static std::string shortDescription()
4191 [ + - ]: 3363 : { return "Set checkpoint/restart frequency during time stepping"; }
4192 : 3363 : static std::string longDescription() { return
4193 [ + - ]: 3363 : R"(This keyword is used to set the frequency of dumping checkpoint/restart
4194 : : files during time stepping. The default is 1000, which means that
4195 : : checkpoint/restart files are dumped at every 1000th time step.)";
4196 : : }
4197 : : using alias = Alias< r >;
4198 : : struct expect {
4199 : : using type = std::size_t;
4200 : : static constexpr type lower = 1;
4201 : : static constexpr type upper = std::numeric_limits< type >::max()-1;
4202 [ + - ]: 3363 : static std::string description() { return "int"; }
4203 : 3363 : static std::string choices() {
4204 [ + - ][ + - ]: 6726 : return "integer between [" + std::to_string(lower) + "..." +
[ + - ][ + - ]
4205 [ + - ]: 10089 : std::to_string(upper) + "] (both inclusive)";
4206 : : }
4207 : : };
4208 : : };
4209 : : using rsfreq = keyword< rsfreq_info, TAOCPP_PEGTL_STRING("rsfreq") >;
4210 : :
4211 : : struct feedback_info {
4212 : : static std::string name() { return "feedback"; }
4213 [ + - ]: 3363 : static std::string shortDescription() { return "Enable on-screen feedback"; }
4214 : 3363 : static std::string longDescription() { return
4215 [ + - ]: 3363 : R"(This keyword is used to enable more detailed on-screen feedback on
4216 : : particular tasks and sub-tasks as they happen. This is useful for large
4217 : : problems and debugging.)";
4218 : : }
4219 : : using alias = Alias< f >;
4220 : : };
4221 : : using feedback = keyword< feedback_info, TAOCPP_PEGTL_STRING("feedback") >;
4222 : :
4223 : : struct version_info {
4224 : : static std::string name() { return "Show version"; }
4225 [ + - ]: 4986 : static std::string shortDescription() { return "Show version information"; }
4226 : 4986 : static std::string longDescription() { return
4227 [ + - ]: 4986 : R"(This keyword is used to display version information for the
4228 : : executable/tool on the standard output and exit successfully.)";
4229 : : }
4230 : : using alias = Alias< V >;
4231 : : };
4232 : : using version = keyword< version_info, TAOCPP_PEGTL_STRING("version") >;
4233 : :
4234 : : struct license_info {
4235 : : static std::string name() { return "Show license"; }
4236 [ + - ]: 4986 : static std::string shortDescription() { return "Show license information"; }
4237 : 4986 : static std::string longDescription() { return
4238 [ + - ]: 4986 : R"(This keyword is used to display license information for the
4239 : : executable/tool on the standard output and exit successfully.)";
4240 : : }
4241 : : using alias = Alias< L >;
4242 : : };
4243 : : using license = keyword< license_info, TAOCPP_PEGTL_STRING("license") >;
4244 : :
4245 : : struct trace_info {
4246 : : static std::string name() { return "trace"; }
4247 : 4986 : static std::string shortDescription()
4248 [ + - ]: 4986 : { return "Disable call and stack trace"; }
4249 [ + - ]: 4986 : static std::string longDescription() { return R"(This keyword can be used to
4250 : : disable the on-screen call trace and stack trace after an exception is
4251 : : thrown. Trace output is on by default and in some cases, the call and
4252 : : stack trace can be huge and not very helpful, hence this command line
4253 : : option.)"; }
4254 : : using alias = Alias< t >;
4255 : : };
4256 : : using trace = keyword< trace_info, TAOCPP_PEGTL_STRING("trace") >;
4257 : :
4258 : : struct quiescence_info {
4259 : : static std::string name() { return "quiescence"; }
4260 : 4986 : static std::string shortDescription()
4261 [ + - ]: 4986 : { return "Enable quiescence detection"; }
4262 : 4986 : static std::string longDescription() { return
4263 [ + - ]: 4986 : R"(This keyword is used to enable the quiescence detection feature of
4264 : : Charm++, used to catch logic errors in the asynchronous control flow,
4265 : : resulting in deadlocks. This is useful for automated testing and
4266 : : debugging and does have some overhead, so it is off by default.)";
4267 : : }
4268 : : using alias = Alias< q >;
4269 : : };
4270 : : using quiescence =
4271 : : keyword< quiescence_info, TAOCPP_PEGTL_STRING("quiescence") >;
4272 : :
4273 : : struct virtualization_info {
4274 : : static std::string name() { return "virtualization"; }
4275 : 4581 : static std::string shortDescription() { return
4276 [ + - ]: 4581 : R"(Set degree of virtualization)"; }
4277 : 4581 : static std::string longDescription() { return
4278 [ + - ]: 4581 : R"(This option is used to set the degree of virtualization
4279 : : (over-decomposition). The virtualization parameter is a real number
4280 : : between 0.0 and 1.0, inclusive, which controls the degree of
4281 : : virtualization or over-decomposition. Independent of the value of
4282 : : virtualization the work is approximately evenly distributed among the
4283 : : available processing elements. For zero virtualization (no
4284 : : over-decomposition), the work is simply decomposed into
4285 : : total_work/numPEs, which yields the smallest number of Charm++ chares and
4286 : : the largest chunks of work units. The other extreme is unity
4287 : : virtualization, which decomposes the total work into the smallest size
4288 : : work units possible, yielding the largest number of Charm++ chares.
4289 : : Obviously, the optimum will be between 0.0 and 1.0, depending on the
4290 : : problem.)";
4291 : : }
4292 : : using alias = Alias< u >;
4293 : : struct expect {
4294 : : using type = tk::real;
4295 : : static constexpr type lower = 0.0;
4296 : : static constexpr type upper = 1.0;
4297 [ + - ]: 4581 : static std::string description() { return "real"; }
4298 : 4581 : static std::string choices() {
4299 [ + - ][ + - ]: 9162 : return "real between [" + std::to_string(lower) + "..." +
[ + - ][ + - ]
4300 [ + - ]: 13743 : std::to_string(upper) + "] (both inclusive)";
4301 : : }
4302 : : };
4303 : : };
4304 : : using virtualization =
4305 : : keyword< virtualization_info, TAOCPP_PEGTL_STRING("virtualization") >;
4306 : :
4307 : : struct pdf_info {
4308 : : static std::string name() { return "pdf"; }
4309 : 1218 : static std::string shortDescription() { return
4310 [ + - ]: 1218 : "Specify the name of the PDF output file"; }
4311 : 1218 : static std::string longDescription() { return
4312 [ + - ]: 1218 : R"(This keyword is used to specify the name of the output file in which to
4313 : : store probability density functions (PDFs) during a simulation.)";
4314 : : }
4315 : : using alias = Alias< p >;
4316 : : struct expect {
4317 : : using type = std::string;
4318 [ + - ]: 1218 : static std::string description() { return "string"; }
4319 : : };
4320 : : };
4321 : : using pdf = keyword< pdf_info, TAOCPP_PEGTL_STRING("pdf") >;
4322 : :
4323 : : struct stat_info {
4324 : : static std::string name() { return "stat"; }
4325 : 1218 : static std::string shortDescription() { return
4326 [ + - ]: 1218 : "Specify the name of the statistical moments output file"; }
4327 : 1218 : static std::string longDescription() { return
4328 [ + - ]: 1218 : R"(This keyword is used to specify the name of the output file in which to
4329 : : store statistical moments during a simulation.)";
4330 : : }
4331 : : using alias = Alias< s >;
4332 : : struct expect {
4333 : : using type = std::string;
4334 [ + - ]: 1218 : static std::string description() { return "string"; }
4335 : : };
4336 : : };
4337 : : using stat = keyword< stat_info, TAOCPP_PEGTL_STRING("stat") >;
4338 : :
4339 : : struct particles_info {
4340 : : static std::string name() { return "particles"; }
4341 : 1218 : static std::string shortDescription() { return
4342 [ + - ]: 1218 : "Specify the name of the particles position output file"; }
4343 : 1218 : static std::string longDescription() { return
4344 [ + - ]: 1218 : R"(This keyword is used to specify the name of the output file in which to
4345 : : store particles positions during a simulation.)";
4346 : : }
4347 : : using alias = Alias< x >;
4348 : : struct expect {
4349 : : using type = std::string;
4350 [ + - ]: 1218 : static std::string description() { return "string"; }
4351 : : };
4352 : : };
4353 : : using particles = keyword< particles_info, TAOCPP_PEGTL_STRING("particles") >;
4354 : :
4355 : : struct input_info {
4356 : : static std::string name() { return "input"; }
4357 [ + - ]: 3399 : static std::string shortDescription() { return "Specify the input file"; }
4358 : 3399 : static std::string longDescription() { return
4359 [ + - ]: 3399 : R"(This option is used to define the name of input file.)";
4360 : : }
4361 : : using alias = Alias< i >;
4362 : : struct expect {
4363 : : using type = std::string;
4364 [ + - ]: 3399 : static std::string description() { return "string"; }
4365 : : };
4366 : : };
4367 : : using input = keyword< input_info, TAOCPP_PEGTL_STRING("input") >;
4368 : :
4369 : : struct output_info {
4370 : : static std::string name() { return "output"; }
4371 [ + - ]: 3399 : static std::string shortDescription() { return "Specify the output file"; }
4372 : 3399 : static std::string longDescription() { return
4373 [ + - ]: 3399 : R"(This option is used to define the output file name. In MeshConv, this is
4374 : : used to specify the output mesh file name. In Inciter this is used to
4375 : : specify the output base filename. The base filename is appended by
4376 : : ".e-s.<meshid>.<numchares>.<chareid>", where 'e-s' probably stands for
4377 : : ExodusII sequence (the output file format), <meshid> counts the number of
4378 : : new meshes (this is incremented whenever the mesh is new compared to the
4379 : : previous iteration, due to, e.g., mesh refinement), <numchares> is the total
4380 : : number of mesh partitions, and <chareid> is the work unit (or mesh
4381 : : partition) id.)";
4382 : : }
4383 : : using alias = Alias< o >;
4384 : : struct expect {
4385 : : using type = std::string;
4386 [ + - ]: 3399 : static std::string description() { return "string"; }
4387 : : };
4388 : : };
4389 : : using output = keyword< output_info, TAOCPP_PEGTL_STRING("output") >;
4390 : :
4391 : : struct refined_info {
4392 : : static std::string name() { return "Refined field output"; }
4393 : 1565 : static std::string shortDescription() { return
4394 [ + - ]: 1565 : "Turn refined field output on/off"; }
4395 : 1565 : static std::string longDescription() { return
4396 [ + - ]: 1565 : R"(This keyword can be used to turn on/off refined field output, which
4397 : : refines the mesh and evaluates the solution on the refined mesh for saving
4398 : : the solution.)"; }
4399 : : struct expect {
4400 : : using type = bool;
4401 [ + - ]: 1565 : static std::string description() { return "string"; }
4402 [ + - ]: 1565 : static std::string choices() { return "true | false"; }
4403 : : };
4404 : : };
4405 : : using refined =keyword< refined_info, TAOCPP_PEGTL_STRING("refined") >;
4406 : :
4407 : : struct screen_info {
4408 : : static std::string name() { return "screen"; }
4409 : 4986 : static std::string shortDescription() {
4410 [ + - ]: 4986 : return "Specify the screen output file"; }
4411 : 4986 : static std::string longDescription() { return
4412 [ + - ]: 4986 : R"(This option is used to set the screen output file name. The default is
4413 : : "<executable>_screen.log".)";
4414 : : }
4415 : : using alias = Alias< O >;
4416 : : struct expect {
4417 : : using type = std::string;
4418 [ + - ]: 4986 : static std::string description() { return "string"; }
4419 : : };
4420 : : };
4421 : : using screen = keyword< screen_info, TAOCPP_PEGTL_STRING("screen") >;
4422 : :
4423 : : struct restart_info {
4424 : : static std::string name() { return "checkpoint/restart directory name"; }
4425 : 3363 : static std::string shortDescription()
4426 [ + - ]: 3363 : { return "Specify the directory for restart files"; }
4427 : 3363 : static std::string longDescription() { return
4428 [ + - ]: 3363 : R"(This option is used to specify the directory name in which to save
4429 : : checkpoint/restart files.)";
4430 : : }
4431 : : using alias = Alias< R >;
4432 : : struct expect {
4433 : : using type = std::string;
4434 [ + - ]: 3363 : static std::string description() { return "string"; }
4435 : : };
4436 : : };
4437 : : using restart = keyword< restart_info, TAOCPP_PEGTL_STRING("restart") >;
4438 : :
4439 : : struct l2_info {
4440 [ + - ]: 381 : static std::string name() { return "L2"; }
4441 [ + - ]: 1565 : static std::string shortDescription() { return "Select the L2 norm"; }
4442 : 1565 : static std::string longDescription() { return
4443 [ + - ]: 1565 : R"(This keyword is used to enable computing the L2 norm. Example:
4444 : : "diagnostics error l2 end'.")"; }
4445 : : struct expect {
4446 [ + - ]: 1565 : static std::string description() { return "string"; }
4447 : : };
4448 : : };
4449 : : using l2 = keyword< l2_info, TAOCPP_PEGTL_STRING("l2") >;
4450 : :
4451 : : struct linf_info {
4452 [ + - ]: 381 : static std::string name() { return "Linf"; }
4453 : 1565 : static std::string shortDescription() { return
4454 [ + - ]: 1565 : "Select the L_{infinity} norm"; }
4455 : 1565 : static std::string longDescription() { return
4456 [ + - ]: 1565 : R"(This keyword is used to enable computing the L-infinity norm. Example:
4457 : : "diagnostics error linf end'.")"; }
4458 : : struct expect {
4459 [ + - ]: 1565 : static std::string description() { return "string"; }
4460 : : };
4461 : : };
4462 : : using linf = keyword< linf_info, TAOCPP_PEGTL_STRING("linf") >;
4463 : :
4464 : : struct error_info {
4465 : : static std::string name() { return "error"; }
4466 [ + - ]: 1565 : static std::string shortDescription() { return "Select an error norm"; }
4467 : 1565 : static std::string longDescription() { return
4468 [ + - ]: 1565 : R"(This keyword is used to select, i.e., turn on, the estimation of an
4469 : : error norm. The keyword is used in a 'diagnostics ... end' block. Example:
4470 : : "diagnostics error l2 end", which configures computation of the L2 norm.)";
4471 : : }
4472 : : struct expect {
4473 [ + - ]: 1565 : static std::string description() { return "string"; }
4474 : 1565 : static std::string choices() {
4475 [ + - ][ + - ]: 3130 : return '\'' + l2::string() + "\' | \'"
[ + - ]
4476 [ + - ][ + - ]: 6260 : + linf::string() + '\'';
4477 : : }
4478 : : };
4479 : : };
4480 : : using error = keyword< error_info, TAOCPP_PEGTL_STRING("error") >;
4481 : :
4482 : : struct diagnostics_cmd_info {
4483 : : static std::string name() { return "diagnostics"; }
4484 : 3363 : static std::string shortDescription()
4485 [ + - ]: 3363 : { return "Specify the diagnostics file name"; }
4486 : 3363 : static std::string longDescription() { return
4487 [ + - ]: 3363 : R"(This option is used to define the diagnostics file name.)";
4488 : : }
4489 : : using alias = Alias< d >;
4490 : : struct expect {
4491 : : using type = std::string;
4492 [ + - ]: 3363 : static std::string description() { return "string"; }
4493 : : };
4494 : : };
4495 : : using diagnostics_cmd =
4496 : : keyword< diagnostics_cmd_info, TAOCPP_PEGTL_STRING("diagnostics") >;
4497 : :
4498 : : struct diagnostics_info {
4499 : : static std::string name() { return "diagnostics"; }
4500 : 1565 : static std::string shortDescription()
4501 [ + - ]: 1565 : { return "Specify the diagnostics file name"; }
4502 : 1565 : static std::string longDescription() { return
4503 : : R"(This keyword is used to introduce the dagnostics ... end block, used to
4504 : : configure diagnostics output. Keywords allowed in this block: )"
4505 [ + - ][ + - ]: 3130 : + std::string("\'")
4506 [ + - ][ + - ]: 6260 : + interval_iter::string() + "\' | \'"
[ + - ]
4507 [ + - ][ + - ]: 6260 : + txt_float_format::string() + "\' | \'"
[ + - ]
4508 [ + - ][ + - ]: 6260 : + error::string() + "\' | \'"
[ + - ]
4509 [ + - ][ + - ]: 6260 : + precision::string() + "\'.";
4510 : : }
4511 : : };
4512 : : using diagnostics =
4513 : : keyword< diagnostics_info, TAOCPP_PEGTL_STRING("diagnostics") >;
4514 : :
4515 : : struct reorder_cmd_info {
4516 : : static std::string name() { return "reorder"; }
4517 [ + - ]: 36 : static std::string shortDescription() { return "Reorder mesh nodes"; }
4518 : 36 : static std::string longDescription() { return
4519 [ + - ]: 36 : R"(This keyword is used as a command line argument to instruct the mesh
4520 : : converter to not only convert but also reorder the mesh nodes using the
4521 : : advancing front technique. Reordering is optional in meshconv and
4522 : : inciter.)";
4523 : : }
4524 : : using alias = Alias< r >;
4525 : : struct expect {
4526 : : using type = bool;
4527 [ + - ]: 36 : static std::string description() { return "string"; }
4528 : : };
4529 : : };
4530 : : using reorder_cmd = keyword< reorder_cmd_info, TAOCPP_PEGTL_STRING("reorder") >;
4531 : :
4532 : : struct pelocal_reorder_info {
4533 : : static std::string name() { return "PE-local reorder"; }
4534 [ + - ]: 1565 : static std::string shortDescription() { return "PE-local reorder"; }
4535 : 1565 : static std::string longDescription() { return
4536 [ + - ]: 1565 : R"(This keyword is used in inciter as a keyword in the inciter...end block
4537 : : as "pelocal_reorder true" (or false) to do (or not do) a global distributed
4538 : : mesh reordering across all PEs that yields an approximately continous mesh
4539 : : node ID order as mesh partitions are assigned to PEs after mesh
4540 : : partitioning. This reordering is optional.)";
4541 : : }
4542 : : struct expect {
4543 : : using type = bool;
4544 [ + - ]: 1565 : static std::string choices() { return "true | false"; }
4545 [ + - ]: 1565 : static std::string description() { return "string"; }
4546 : : };
4547 : : };
4548 : : using pelocal_reorder =
4549 : : keyword< pelocal_reorder_info, TAOCPP_PEGTL_STRING("pelocal_reorder") >;
4550 : :
4551 : : struct operator_reorder_info {
4552 : : static std::string name() { return "operator_reorder"; }
4553 [ + - ]: 1565 : static std::string shortDescription() { return "Operator-access reorder"; }
4554 : 1565 : static std::string longDescription() { return
4555 [ + - ]: 1565 : R"(This keyword is used in inciter as a keyword in the inciter...end block
4556 : : as "operator_reorder on" (or off) to do (or not do) a local mesh node
4557 : : reordering based on the PDE operator access pattern. This reordering is
4558 : : optional.)";
4559 : : }
4560 : : struct expect {
4561 : : using type = bool;
4562 [ + - ]: 1565 : static std::string choices() { return "true | false"; }
4563 [ + - ]: 1565 : static std::string description() { return "string"; }
4564 : : };
4565 : : };
4566 : : using operator_reorder =
4567 : : keyword< operator_reorder_info, TAOCPP_PEGTL_STRING("operator_reorder") >;
4568 : :
4569 : : struct steady_state_info {
4570 : : static std::string name() { return "steady_state"; }
4571 [ + - ]: 1565 : static std::string shortDescription() { return "March to steady state"; }
4572 : 1565 : static std::string longDescription() { return
4573 [ + - ]: 1565 : R"(This keyword is used indicate that local time stepping should be used
4574 : : towards a stationary solution.)"; }
4575 : : struct expect {
4576 : : using type = bool;
4577 [ + - ]: 1565 : static std::string choices() { return "true | false"; }
4578 [ + - ]: 1565 : static std::string description() { return "string"; }
4579 : : };
4580 : : };
4581 : : using steady_state =
4582 : : keyword< steady_state_info, TAOCPP_PEGTL_STRING("steady_state") >;
4583 : :
4584 : : struct residual_info {
4585 : : static std::string name() { return "residual"; }
4586 : 1565 : static std::string shortDescription() { return
4587 [ + - ]: 1565 : "Set the convergence criterion for the residual to reach"; }
4588 : 1565 : static std::string longDescription() { return
4589 [ + - ]: 1565 : R"(This keyword is used to specify a convergence criterion for, e.g., local
4590 : : time stepping marching to steady state, below which the simulation is
4591 : : considered converged.)"; }
4592 : : struct expect {
4593 : : using type = tk::real;
4594 : : static constexpr type lower = 1.0e-14;
4595 [ + - ]: 1565 : static std::string description() { return "real"; }
4596 : : };
4597 : : };
4598 : : using residual = keyword< residual_info, TAOCPP_PEGTL_STRING("residual") >;
4599 : :
4600 : : struct rescomp_info {
4601 : : static std::string name() { return "rescomp"; }
4602 : 1565 : static std::string shortDescription() { return
4603 [ + - ]: 1565 : "Equation system component index for convergence"; }
4604 : 1565 : static std::string longDescription() { return
4605 [ + - ]: 1565 : R"(This keyword is used to specify a single integer that is used to denote
4606 : : the equation component index in the complete system of equation systems
4607 : : configured in an input file to use for the convergence criterion for local
4608 : : time stepping marching towards steady state.)";
4609 : : }
4610 : : struct expect {
4611 : : using type = uint32_t;
4612 : : static constexpr type lower = 1;
4613 [ + - ]: 1565 : static std::string description() { return "uint"; }
4614 : : };
4615 : : };
4616 : : using rescomp = keyword< rescomp_info, TAOCPP_PEGTL_STRING("rescomp") >;
4617 : :
4618 : : struct group_info {
4619 : : static std::string name() { return "group"; }
4620 : 5 : static std::string shortDescription() { return
4621 [ + - ]: 5 : "Select test group(s) to run"; }
4622 : 5 : static std::string longDescription() { return
4623 [ + - ]: 5 : R"(This option can be used to select one or more test groups to run by
4624 : : specifying the full or a partial name of a test group. All tests of a
4625 : : selected group will be executed. If this option is not given, all test
4626 : : groups are executed by default. Examples: '--group make_list' - run only
4627 : : the 'make_list' test group, '--group Parser' - run the test groups that have
4628 : : the string 'Parser' in their name, e.g., groups 'Control/FileParser' and
4629 : : 'Control/StringParser'.)";
4630 : : }
4631 : : using alias = Alias< g >;
4632 : : struct expect {
4633 : : using type = std::string;
4634 [ + - ]: 5 : static std::string description() { return "string"; }
4635 : : };
4636 : : };
4637 : : using group = keyword< group_info, TAOCPP_PEGTL_STRING("group") >;
4638 : :
4639 : : struct inciter_info {
4640 : : static std::string name() { return "inciter"; }
4641 : 1565 : static std::string shortDescription() { return
4642 [ + - ]: 1565 : "Start configuration block for inciter"; }
4643 : 1565 : static std::string longDescription() { return
4644 [ + - ]: 1565 : R"(This keyword is used to select inciter. Inciter, is a continuum-realm
4645 : : shock hydrodynamics tool, solving a PDE.)";
4646 : : }
4647 : : };
4648 : : using inciter = keyword< inciter_info, TAOCPP_PEGTL_STRING("inciter") >;
4649 : :
4650 : : struct user_defined_info {
4651 [ + - ]: 481 : static std::string name() { return "User-defined"; }
4652 : 1565 : static std::string shortDescription() { return
4653 [ + - ]: 1565 : "Select user-defined specification for a problem"; }
4654 : 1565 : static std::string longDescription() { return
4655 [ + - ]: 1565 : R"(This keyword is used to select the user-defined specification for an
4656 : : option. This could be a 'problem' to be solved by a partial differential
4657 : : equation, but can also be a 'user-defined' mesh velocity specification for
4658 : : ALE mesh motion.)"; }
4659 : : struct expect {
4660 [ + - ]: 1565 : static std::string description() { return "string"; }
4661 : : };
4662 : : };
4663 : :
4664 : : using user_defined =
4665 : : keyword< user_defined_info, TAOCPP_PEGTL_STRING("user_defined") >;
4666 : :
4667 : : struct shear_diff_info {
4668 [ + - ]: 461 : static std::string name() { return "Shear-diffusion"; }
4669 : 1565 : static std::string shortDescription() { return
4670 [ + - ]: 1565 : "Select the shear + diffusion test problem "; }
4671 : 1565 : static std::string longDescription() { return
4672 [ + - ]: 1565 : R"(This keyword is used to select the shear diffusion test problem. The
4673 : : initial and boundary conditions are specified to set up the test problem
4674 : : suitable to exercise and test the advection and diffusion terms of the
4675 : : scalar transport equation. Example: "problem shear_diff".)"; }
4676 : : struct expect {
4677 [ + - ]: 1565 : static std::string description() { return "string"; }
4678 : : };
4679 : : };
4680 : : using shear_diff = keyword< shear_diff_info, TAOCPP_PEGTL_STRING("shear_diff") >;
4681 : :
4682 : : struct slot_cyl_info {
4683 [ + - ]: 461 : static std::string name() { return "Zalesak's slotted cylinder"; }
4684 : 1565 : static std::string shortDescription() { return
4685 [ + - ]: 1565 : "Select Zalesak's slotted cylinder test problem"; }
4686 : 1565 : static std::string longDescription() { return
4687 [ + - ]: 1565 : R"(This keyword is used to select the Zalesak's slotted cylinder test
4688 : : problem. The initial and boundary conditions are specified to set up the
4689 : : test problem suitable to exercise and test the advection and diffusion
4690 : : terms of the scalar transport equation. Example: "problem slot_cyl".)"; }
4691 : : struct expect {
4692 [ + - ]: 1565 : static std::string description() { return "string"; }
4693 : : };
4694 : : };
4695 : : using slot_cyl = keyword< slot_cyl_info, TAOCPP_PEGTL_STRING("slot_cyl") >;
4696 : :
4697 : : struct gauss_hump_info {
4698 [ + - ]: 461 : static std::string name() { return "Advection of 2D Gaussian hump"; }
4699 : 1565 : static std::string shortDescription() { return
4700 [ + - ]: 1565 : "Select advection of 2D Gaussian hump test problem"; }
4701 : 1565 : static std::string longDescription() { return
4702 [ + - ]: 1565 : R"(This keyword is used to select the advection of 2D Gaussian hump test
4703 : : problem. The initial and boundary conditions are specified to set up the
4704 : : test problem suitable to exercise and test the advection
4705 : : terms of the scalar transport equation. Example: "problem gauss_hump".)"; }
4706 : : struct expect {
4707 [ + - ]: 1565 : static std::string description() { return "string"; }
4708 : : };
4709 : : };
4710 : : using gauss_hump = keyword< gauss_hump_info, TAOCPP_PEGTL_STRING("gauss_hump") >;
4711 : :
4712 : : struct cyl_advect_info {
4713 [ + - ]: 461 : static std::string name() { return "Advection of cylinder"; }
4714 : 1565 : static std::string shortDescription() { return
4715 [ + - ]: 1565 : "Select advection of cylinder test problem"; }
4716 : 1565 : static std::string longDescription() { return
4717 [ + - ]: 1565 : R"(This keyword is used to select the advection of cylinder test
4718 : : problem. The initial and boundary conditions are specified to set up the
4719 : : test problem suitable to exercise and test the advection
4720 : : terms of the scalar transport equation. Example: "problem cyl_advect".)"; }
4721 : : struct expect {
4722 [ + - ]: 1565 : static std::string description() { return "string"; }
4723 : : };
4724 : : };
4725 : : using cyl_advect = keyword< cyl_advect_info, TAOCPP_PEGTL_STRING("cyl_advect") >;
4726 : :
4727 : : struct cyl_vortex_info {
4728 [ + - ]: 461 : static std::string name() { return "Deformation of cylinder in a vortex"; }
4729 : 1565 : static std::string shortDescription() { return
4730 [ + - ]: 1565 : "Select deformation of cylinder in a vortex test problem"; }
4731 : 1565 : static std::string longDescription() { return
4732 [ + - ]: 1565 : R"(This keyword is used to select the test problem which deforms a cylinder
4733 : : in a vortical velocity field. The initial and boundary conditions are
4734 : : specified to set up the test problem suitable to exercise and test the
4735 : : advection terms of the scalar transport equation.
4736 : : Example: "problem cyl_vortex".)"; }
4737 : : struct expect {
4738 [ + - ]: 1565 : static std::string description() { return "string"; }
4739 : : };
4740 : : };
4741 : : using cyl_vortex = keyword< cyl_vortex_info, TAOCPP_PEGTL_STRING("cyl_vortex") >;
4742 : :
4743 : : struct vortical_flow_info {
4744 [ + - ]: 461 : static std::string name() { return "Vortical flow"; }
4745 : 1565 : static std::string shortDescription() { return
4746 [ + - ]: 1565 : "Select the vortical flow test problem "; }
4747 : 1565 : static std::string longDescription() { return
4748 [ + - ]: 1565 : R"(This keyword is used to select the vortical flow test problem. The
4749 : : purpose of this test problem is to test velocity errors generated by spatial
4750 : : operators in the presence of 3D vorticity and in particluar the
4751 : : superposition of planar and vortical flows, analogous to voritcity
4752 : : stretching. Example: "problem vortical_flow. For more details, see Waltz,
4753 : : et. al, "Manufactured solutions for the three-dimensional Euler equations
4754 : : with relevance to Inertial Confinement Fusion", Journal of Computational
4755 : : Physics 267 (2014) 196-209.)"; }
4756 : : struct expect {
4757 [ + - ]: 1565 : static std::string description() { return "string"; }
4758 : : };
4759 : : };
4760 : : using vortical_flow =
4761 : : keyword< vortical_flow_info, TAOCPP_PEGTL_STRING("vortical_flow") >;
4762 : :
4763 : : struct nl_energy_growth_info {
4764 [ + - ]: 461 : static std::string name() { return "Nonlinear energy growth"; }
4765 : 1565 : static std::string shortDescription() { return
4766 [ + - ]: 1565 : "Select the nonlinear energy growth test problem ";}
4767 : 1565 : static std::string longDescription() { return
4768 [ + - ]: 1565 : R"(This keyword is used to select the nonlinear energy growth test problem.
4769 : : The purpose of this test problem is to test nonlinear, time dependent energy
4770 : : growth and the subsequent development of pressure gradients due to coupling
4771 : : between the internal energy and the equation of state. Example: "problem
4772 : : nl_energy_growth". For more details, see Waltz, et. al, "Manufactured
4773 : : solutions for the three-dimensional Euler equations with relevance to
4774 : : Inertial Confinement Fusion", Journal of Computational Physics 267 (2014)
4775 : : 196-209.)"; }
4776 : : struct expect {
4777 [ + - ]: 1565 : static std::string description() { return "string"; }
4778 : : };
4779 : : };
4780 : : using nl_energy_growth =
4781 : : keyword< nl_energy_growth_info, TAOCPP_PEGTL_STRING("nl_energy_growth") >;
4782 : :
4783 : : struct rayleigh_taylor_info {
4784 [ + - ]: 461 : static std::string name() { return "Rayleigh-Taylor"; }
4785 : 1565 : static std::string shortDescription() { return
4786 [ + - ]: 1565 : "Select the Rayleigh-Taylor test problem "; }
4787 : 1565 : static std::string longDescription() { return
4788 [ + - ]: 1565 : R"(This keyword is used to select the Rayleigh-Taylor unstable configuration
4789 : : test problem. The purpose of this test problem is to assess time dependent
4790 : : fluid motion in the presence of Rayleigh-Taylor unstable conditions, i.e.
4791 : : opposing density and pressure gradients. Example: "problem rayleigh_taylor".
4792 : : For more details, see Waltz, et. al, "Manufactured solutions for the
4793 : : three-dimensional Euler equations with relevance to Inertial Confinement
4794 : : Fusion", Journal of Computational Physics 267 (2014) 196-209.)"; }
4795 : : struct expect {
4796 [ + - ]: 1565 : static std::string description() { return "string"; }
4797 : : };
4798 : : };
4799 : : using rayleigh_taylor =
4800 : : keyword< rayleigh_taylor_info, TAOCPP_PEGTL_STRING("rayleigh_taylor") >;
4801 : :
4802 : : struct taylor_green_info {
4803 [ + - ]: 461 : static std::string name() { return "Taylor-Green"; }
4804 : 1565 : static std::string shortDescription() { return
4805 [ + - ]: 1565 : "Select the Taylor-Green test problem "; }
4806 : 1565 : static std::string longDescription() { return
4807 [ + - ]: 1565 : R"(This keyword is used to select the Taylor-Green vortex test problem. The
4808 : : purpose of this problem is to test time accuracy and the correctness of the
4809 : : discretization of the viscous term in the Navier-Stokes equation. Example:
4810 : : "problem taylor_green". For more details on the flow, see G.I. Taylor, A.E.
4811 : : Green, "Mechanism of the Production of Small Eddies from Large Ones", Proc.
4812 : : R. Soc. Lond. A 1937 158 499-521; DOI: 10.1098/rspa.1937.0036. Published 3
4813 : : February 1937.)"; }
4814 : : struct expect {
4815 [ + - ]: 1565 : static std::string description() { return "string"; }
4816 : : };
4817 : : };
4818 : : using taylor_green =
4819 : : keyword< taylor_green_info, TAOCPP_PEGTL_STRING("taylor_green") >;
4820 : :
4821 : : struct shedding_flow_info {
4822 [ + - ]: 461 : static std::string name() { return "Shedding flow over triangular wedge"; }
4823 : 1565 : static std::string shortDescription() { return
4824 [ + - ]: 1565 : "Select the Shedding flow test problem "; }
4825 : 1565 : static std::string longDescription() { return
4826 [ + - ]: 1565 : R"(This keyword is used to select the Shedding flow test problem. It
4827 : : describe a quasi-2D inviscid flow over a triangular wedge in tetrahedron
4828 : : grid. The purpose of this test problem is to test the capability of DG
4829 : : scheme for retaining the shape of vortices and also different error
4830 : : indicator behavior for this external flow problem when p-adaptive DG scheme
4831 : : is applied. Example: "problem shedding_flow".)"; }
4832 : : struct expect {
4833 [ + - ]: 1565 : static std::string description() { return "string"; }
4834 : : };
4835 : : };
4836 : : using shedding_flow =
4837 : : keyword< shedding_flow_info, TAOCPP_PEGTL_STRING("shedding_flow") >;
4838 : :
4839 : : struct sod_shocktube_info {
4840 [ + - ]: 461 : static std::string name() { return "Sod shock-tube"; }
4841 : 1565 : static std::string shortDescription() { return
4842 [ + - ]: 1565 : "Select the Sod shock-tube test problem "; }
4843 : 1565 : static std::string longDescription() { return
4844 [ + - ]: 1565 : R"(This keyword is used to select the Sod shock-tube test problem. The
4845 : : purpose of this test problem is to test the correctness of the
4846 : : approximate Riemann solver and its shock and interface capturing
4847 : : capabilities. Example: "problem sod_shocktube". For more details, see
4848 : : G. A. Sod, "A Survey of Several Finite Difference Methods for Systems of
4849 : : Nonlinear Hyperbolic Conservation Laws", J. Comput. Phys., 27 (1978)
4850 : : 1–31.)"; }
4851 : : struct expect {
4852 [ + - ]: 1565 : static std::string description() { return "string"; }
4853 : : };
4854 : : };
4855 : : using sod_shocktube =
4856 : : keyword< sod_shocktube_info, TAOCPP_PEGTL_STRING("sod_shocktube") >;
4857 : :
4858 : : struct sod_rotated_shocktube_info {
4859 [ + - ]: 461 : static std::string name() { return "Rotated Sod shock-tube"; }
4860 : 1565 : static std::string shortDescription() { return
4861 [ + - ]: 1565 : "Select the rotated Sod shock-tube test problem "; }
4862 : 1565 : static std::string longDescription() { return
4863 [ + - ]: 1565 : R"(This keyword is used to select the rotated Sod shock-tube test problem.
4864 : : This the same as Sod shocktube but the geometry is rotated about X, Y, Z
4865 : : each by 45 degrees (in that order) so that none of the domain boundary align
4866 : : with any of the coordinate directions. The purpose of this test problem is
4867 : : to test the correctness of the approximate Riemann solver and its shock and
4868 : : interface capturing capabilities in an arbitrarily oriented geometry.
4869 : : Example: "problem rotated_sod_shocktube". For more details on the Sod
4870 : : problem, see G. A. Sod, "A Survey of Several Finite Difference Methods for
4871 : : Systems of Nonlinear Hyperbolic Conservation Laws", J. Comput. Phys., 27
4872 : : (1978) 1–31.)"; }
4873 : : struct expect {
4874 [ + - ]: 1565 : static std::string description() { return "string"; }
4875 : : };
4876 : : };
4877 : : using rotated_sod_shocktube =
4878 : : keyword< sod_rotated_shocktube_info,
4879 : : TAOCPP_PEGTL_STRING("rotated_sod_shocktube") >;
4880 : :
4881 : : struct sedov_blastwave_info {
4882 [ + - ]: 461 : static std::string name() { return "Sedov blast-wave"; }
4883 : 1565 : static std::string shortDescription() { return
4884 [ + - ]: 1565 : "Select the Sedov blast-wave test problem "; }
4885 : 1565 : static std::string longDescription() { return
4886 [ + - ]: 1565 : R"(This keyword is used to select the Sedov blast-wave test problem. The
4887 : : purpose of this test problem is to test the correctness of the
4888 : : approximate Riemann solver and its strong shock and interface capturing
4889 : : capabilities. Example: "problem sedov_blastwave".)"; }
4890 : : struct expect {
4891 [ + - ]: 1565 : static std::string description() { return "string"; }
4892 : : };
4893 : : };
4894 : : using sedov_blastwave =
4895 : : keyword< sedov_blastwave_info, TAOCPP_PEGTL_STRING("sedov_blastwave") >;
4896 : :
4897 : : struct interface_advection_info {
4898 [ + - ]: 461 : static std::string name() { return "Interface advection"; }
4899 : 1565 : static std::string shortDescription() { return
4900 [ + - ]: 1565 : "Select the interface advection test problem "; }
4901 : 1565 : static std::string longDescription() { return
4902 [ + - ]: 1565 : R"(This keyword is used to select the interface advection test problem. The
4903 : : purpose of this test problem is to test the well-balancedness of the
4904 : : multi-material discretization and its interface capturing
4905 : : capabilities. Example: "problem interface_advection".)"; }
4906 : : struct expect {
4907 [ + - ]: 1565 : static std::string description() { return "string"; }
4908 : : };
4909 : : };
4910 : : using interface_advection =
4911 : : keyword< interface_advection_info,
4912 : : TAOCPP_PEGTL_STRING("interface_advection") >;
4913 : :
4914 : : struct gauss_hump_compflow_info {
4915 : 461 : static std::string name()
4916 [ + - ]: 461 : { return "Advection of 2D Gaussian hump for Euler equations"; }
4917 : 1565 : static std::string shortDescription()
4918 [ + - ]: 1565 : { return "Select advection of 2D Gaussian hump test problem"; }
4919 : 1565 : static std::string longDescription() { return
4920 [ + - ]: 1565 : R"(This keyword is used to select the advection of 2D Gaussian hump test
4921 : : problem. The initial and boundary conditions are specified to set up the
4922 : : test problem suitable to exercise and test the advection terms of the
4923 : : Euler equations. The baseline of the density distribution in this testcase
4924 : : is 1 instead of 0 in gauss_hump_transport which enables it to be the
4925 : : regression testcase for p-adaptive DG scheme. Example: "problem
4926 : : gauss_hump_compflow".)"; }
4927 : : struct expect {
4928 [ + - ]: 1565 : static std::string description() { return "string"; }
4929 : : };
4930 : : };
4931 : : using gauss_hump_compflow = keyword< gauss_hump_compflow_info,
4932 : : TAOCPP_PEGTL_STRING("gauss_hump_compflow") >;
4933 : :
4934 : : struct waterair_shocktube_info {
4935 [ + - ]: 461 : static std::string name() { return "Water-air shock-tube"; }
4936 : 1565 : static std::string shortDescription() { return
4937 [ + - ]: 1565 : "Select the water-air shock-tube test problem "; }
4938 : 1565 : static std::string longDescription() { return
4939 [ + - ]: 1565 : R"(This keyword is used to select the Water-air shock-tube test problem. The
4940 : : purpose of this test problem is to test the correctness of the
4941 : : multi-material pressure relaxation procedure and its interface capturing
4942 : : capabilities. Example: "problem waterair_shocktube". For more details, see
4943 : : Chiapolino, A., Saurel, R., & Nkonga, B. (2017). Sharpening diffuse
4944 : : interfaces with compressible fluids on unstructured meshes. Journal of
4945 : : Computational Physics, 340, 389-417.)"; }
4946 : : struct expect {
4947 [ + - ]: 1565 : static std::string description() { return "string"; }
4948 : : };
4949 : : };
4950 : : using waterair_shocktube =
4951 : : keyword< waterair_shocktube_info, TAOCPP_PEGTL_STRING("waterair_shocktube") >;
4952 : :
4953 : : struct shock_hebubble_info {
4954 [ + - ]: 461 : static std::string name() { return "Shock He-bubble problem"; }
4955 : 1565 : static std::string shortDescription() { return
4956 [ + - ]: 1565 : "Select the shock He-bubble test problem "; }
4957 : 1565 : static std::string longDescription() { return
4958 [ + - ]: 1565 : R"(This keyword is used to select the shock He-bubble test problem. The
4959 : : purpose of this test problem is to test the correctness of the
4960 : : multi-material algorithm and its shock-interface interaction
4961 : : capabilities. Example: "problem shock_hebubble". For more details, see
4962 : : Quirk, J. J., & Karni, S. (1996). On the dynamics of a shock–bubble
4963 : : interaction. Journal of Fluid Mechanics, 318, 129-163.)"; }
4964 : : struct expect {
4965 [ + - ]: 1565 : static std::string description() { return "string"; }
4966 : : };
4967 : : };
4968 : : using shock_hebubble =
4969 : : keyword< shock_hebubble_info, TAOCPP_PEGTL_STRING("shock_hebubble") >;
4970 : :
4971 : : struct underwater_ex_info {
4972 [ + - ]: 461 : static std::string name() { return "Underwater explosion problem"; }
4973 : 1565 : static std::string shortDescription() { return
4974 [ + - ]: 1565 : "Select the underwater explosion test problem "; }
4975 : 1565 : static std::string longDescription() { return
4976 [ + - ]: 1565 : R"(This keyword is used to select the underwater explosion test problem. The
4977 : : purpose of this test problem is to test the correctness of the
4978 : : multi-material algorithm and its interface capturing capabilities in the
4979 : : presence of strong shocks and large deformations.
4980 : : Example: "problem underwater_ex". For more details, see
4981 : : Chiapolino, A., Saurel, R., & Nkonga, B. (2017). Sharpening diffuse
4982 : : interfaces with compressible fluids on unstructured meshes. Journal of
4983 : : Computational Physics, 340, 389-417.)"; }
4984 : : struct expect {
4985 [ + - ]: 1565 : static std::string description() { return "string"; }
4986 : : };
4987 : : };
4988 : : using underwater_ex =
4989 : : keyword< underwater_ex_info, TAOCPP_PEGTL_STRING("underwater_ex") >;
4990 : :
4991 : : struct problem_info {
4992 [ + - ]: 461 : static std::string name() { return "Test problem"; }
4993 : 1565 : static std::string shortDescription() { return
4994 [ + - ]: 1565 : "Specify problem configuration for a partial differential equation solver";
4995 : : }
4996 : 1565 : static std::string longDescription() { return
4997 [ + - ]: 1565 : R"(This keyword is used to specify the problem configuration for a partial
4998 : : differential equation solver in the input file.)";
4999 : : }
5000 : : struct expect {
5001 [ + - ]: 1565 : static std::string description() { return "string"; }
5002 : 1565 : static std::string choices() {
5003 [ + - ][ + - ]: 3130 : return '\'' + user_defined::string() + "\' | \'"
[ + - ]
5004 [ + - ][ + - ]: 6260 : + shear_diff::string() + "\' | \'"
[ + - ]
5005 [ + - ][ + - ]: 6260 : + slot_cyl::string() + "\' | \'"
[ + - ]
5006 [ + - ][ + - ]: 6260 : + gauss_hump::string() + "\' | \'"
[ + - ]
5007 [ + - ][ + - ]: 6260 : + cyl_advect::string() + "\' | \'"
[ + - ]
5008 [ + - ][ + - ]: 6260 : + cyl_vortex::string() + "\' | \'"
[ + - ]
5009 [ + - ][ + - ]: 6260 : + vortical_flow::string() + "\' | \'"
[ + - ]
5010 [ + - ][ + - ]: 6260 : + nl_energy_growth::string() + "\' | \'"
[ + - ]
5011 [ + - ][ + - ]: 6260 : + rayleigh_taylor::string() + "\' | \'"
[ + - ]
5012 [ + - ][ + - ]: 6260 : + taylor_green::string() + "\' | \'"
[ + - ]
5013 [ + - ][ + - ]: 6260 : + sod_shocktube::string() + "\' | \'"
[ + - ]
5014 [ + - ][ + - ]: 6260 : + rotated_sod_shocktube::string() + "\' | \'"
[ + - ]
5015 [ + - ][ + - ]: 6260 : + interface_advection::string() + "\' | \'"
[ + - ]
5016 [ + - ][ + - ]: 6260 : + gauss_hump_compflow::string() + '\'';
5017 : : }
5018 : : };
5019 : : };
5020 : : using problem = keyword< problem_info, TAOCPP_PEGTL_STRING("problem") >;
5021 : :
5022 : : struct navierstokes_info {
5023 [ + - ]: 340 : static std::string name() { return "Navier-Stokes"; }
5024 : 1565 : static std::string shortDescription() { return "Specify the Navier-Stokes "
5025 [ + - ]: 1565 : "(viscous) compressible flow physics configuration"; }
5026 : 1565 : static std::string longDescription() { return
5027 [ + - ]: 1565 : R"(This keyword is used to select the Navier-Stokes (viscous) compressible
5028 : : flow physics configuration. Example: "compflow physics navierstokes end")";
5029 : : }
5030 : : struct expect {
5031 [ + - ]: 1565 : static std::string description() { return "string"; }
5032 : : };
5033 : : };
5034 : : using navierstokes =
5035 : : keyword< navierstokes_info, TAOCPP_PEGTL_STRING("navierstokes") >;
5036 : :
5037 : : struct euler_info {
5038 [ + - ]: 340 : static std::string name() { return "Euler"; }
5039 : 1565 : static std::string shortDescription() { return "Specify the Euler (inviscid) "
5040 [ + - ]: 1565 : "compressible flow physics configuration"; }
5041 : 1565 : static std::string longDescription() { return
5042 [ + - ]: 1565 : R"(This keyword is used to select the Euler (inviscid) compressible
5043 : : flow physics configuration. Example: "compflow physics euler end")";
5044 : : }
5045 : : struct expect {
5046 [ + - ]: 1565 : static std::string description() { return "string"; }
5047 : : };
5048 : : };
5049 : : using euler = keyword< euler_info, TAOCPP_PEGTL_STRING("euler") >;
5050 : :
5051 : : struct veleq_info {
5052 [ + - ]: 340 : static std::string name() { return "Velocity equilibrium"; }
5053 : 1565 : static std::string shortDescription() { return "Specify the multi-material "
5054 [ + - ]: 1565 : " compressible flow with velocity equilibrium as physics configuration"; }
5055 : 1565 : static std::string longDescription() { return
5056 [ + - ]: 1565 : R"(This keyword is used to select a compressible flow algorithm as physics
5057 : : configuration designed for multiple materials assuming velocity equailibrium
5058 : : (single velocity). Example: "multimat physics veleq end")";
5059 : : }
5060 : : struct expect {
5061 [ + - ]: 1565 : static std::string description() { return "string"; }
5062 : : };
5063 : : };
5064 : : using veleq = keyword< veleq_info, TAOCPP_PEGTL_STRING("veleq") >;
5065 : :
5066 : : struct advection_info {
5067 [ + - ]: 340 : static std::string name() { return "Advection"; }
5068 : 1565 : static std::string shortDescription() { return
5069 [ + - ]: 1565 : "Specify the advection physics configuration for a PDE "; }
5070 : 1565 : static std::string longDescription() { return
5071 [ + - ]: 1565 : R"(This keyword is used to select the advection physics configuration for a
5072 : : PDE. Example: "transport physics advection end")";
5073 : : }
5074 : : struct expect {
5075 [ + - ]: 1565 : static std::string description() { return "string"; }
5076 : : };
5077 : : };
5078 : : using advection = keyword< advection_info, TAOCPP_PEGTL_STRING("advection") >;
5079 : :
5080 : : struct advdiff_info {
5081 [ + - ]: 340 : static std::string name() { return "Advection + diffusion"; }
5082 : 1565 : static std::string shortDescription() { return
5083 [ + - ]: 1565 : "Specify the advection + diffusion physics configuration for a PDE "; }
5084 : 1565 : static std::string longDescription() { return
5085 [ + - ]: 1565 : R"(This keyword is used to select the advection +diffusion physics
5086 : : configuration for a PDE. Example: "transport physics advdiff end")";
5087 : : }
5088 : : struct expect {
5089 [ + - ]: 1565 : static std::string description() { return "string"; }
5090 : : };
5091 : : };
5092 : : using advdiff = keyword< advdiff_info, TAOCPP_PEGTL_STRING("advdiff") >;
5093 : :
5094 : : struct physics_info {
5095 [ + - ]: 340 : static std::string name() { return "Physics configuration"; }
5096 : 1565 : static std::string shortDescription() { return
5097 [ + - ]: 1565 : "Specify the physics configuration for a system of PDEs"; }
5098 : 1565 : static std::string longDescription() { return
5099 [ + - ]: 1565 : R"(This keyword is used to select the physics configuration for a particular
5100 : : PDE system. Example: "physics navierstokes", which selects the Navier-Stokes
5101 : : equations for solving viscous compressible flow, given within the
5102 : : compflow ... end block. Valid options depend on the given block the keyword
5103 : : is used.)"; }
5104 : : struct expect {
5105 [ + - ]: 1565 : static std::string description() { return "string"; }
5106 : 1565 : static std::string choices() {
5107 [ + - ][ + - ]: 3130 : return '\'' + advection::string() + "\' | \'"
[ + - ]
5108 [ + - ][ + - ]: 6260 : + advdiff::string() + "\' | \'"
[ + - ]
5109 [ + - ][ + - ]: 6260 : + navierstokes::string() + "\' | \'"
[ + - ]
5110 [ + - ][ + - ]: 6260 : + euler::string() + '\'';
5111 : : }
5112 : : };
5113 : : };
5114 : : using physics = keyword< physics_info, TAOCPP_PEGTL_STRING("physics") >;
5115 : :
5116 : : struct pde_diffusivity_info {
5117 : : static std::string name() { return "diffusivity"; }
5118 : 1565 : static std::string shortDescription() { return
5119 [ + - ]: 1565 : R"(Set PDE parameter(s) diffusivity)"; }
5120 : 1565 : static std::string longDescription() { return
5121 [ + - ]: 1565 : R"(This keyword is used to specify a vector of real numbers used to
5122 : : parameterize a system of partial differential equations. Example:
5123 : : "diffusivity 5.0 2.0 3.0 end". The length of the vector depends on the
5124 : : particular type of PDE system and is controlled by the preceding keyword
5125 : : 'ncomp'.)"; }
5126 : : struct expect {
5127 : : using type = tk::real;
5128 [ + - ]: 1565 : static std::string description() { return "real(s)"; }
5129 : : };
5130 : : };
5131 : : using pde_diffusivity =
5132 : : keyword< pde_diffusivity_info, TAOCPP_PEGTL_STRING("diffusivity") >;
5133 : :
5134 : : struct pde_lambda_info {
5135 : : static std::string name() { return "lambda"; }
5136 : 1565 : static std::string shortDescription() { return
5137 [ + - ]: 1565 : R"(Set PDE parameter(s) lambda)"; }
5138 : 1565 : static std::string longDescription() { return
5139 [ + - ]: 1565 : R"(This keyword is used to specify a vector of real numbers used to
5140 : : parameterize a system of partial differential equations. Example:
5141 : : "lambda 5.0 2.0 3.0 end". The length of the vector depends on the particular
5142 : : type of PDE system and is controlled by the preceding keyword 'ncomp'.)"; }
5143 : : struct expect {
5144 : : using type = tk::real;
5145 [ + - ]: 1565 : static std::string description() { return "real(s)"; }
5146 : : };
5147 : : };
5148 : : using pde_lambda = keyword< pde_lambda_info, TAOCPP_PEGTL_STRING("lambda") >;
5149 : :
5150 : : struct pde_u0_info {
5151 : : static std::string name() { return "u0"; }
5152 : 1565 : static std::string shortDescription() { return
5153 [ + - ]: 1565 : R"(Set PDE parameter(s) u0)"; }
5154 : 1565 : static std::string longDescription() { return
5155 [ + - ]: 1565 : R"(This keyword is used to specify a vector of real numbers used to
5156 : : parameterize a system of partial differential equations. Example:
5157 : : "u0 5.0 2.0 3.0 end". The length of the vector depends on the particular
5158 : : type of PDE system and is controlled by the preceding keyword 'ncomp'.)"; }
5159 : : struct expect {
5160 : : using type = tk::real;
5161 [ + - ]: 1565 : static std::string description() { return "real(s)"; }
5162 : : };
5163 : : };
5164 : : using pde_u0 = keyword< pde_u0_info, TAOCPP_PEGTL_STRING("u0") >;
5165 : :
5166 : : struct pde_alpha_info {
5167 : : static std::string name() { return "alpha"; }
5168 : 1565 : static std::string shortDescription() { return
5169 [ + - ]: 1565 : R"(Set PDE parameter(s) alpha)"; }
5170 : 1565 : static std::string longDescription() { return
5171 [ + - ]: 1565 : R"(This keyword is used to specify a real number used to
5172 : : parameterize a system of partial differential equations. Example:
5173 : : "alpha 5.0".)"; }
5174 : : struct expect {
5175 : : using type = tk::real;
5176 [ + - ]: 1565 : static std::string description() { return "real"; }
5177 : : };
5178 : : };
5179 : : using pde_alpha = keyword< pde_alpha_info, TAOCPP_PEGTL_STRING("alpha") >;
5180 : :
5181 : : struct pde_beta_info {
5182 : : static std::string name() { return "beta"; }
5183 : 1565 : static std::string shortDescription() { return
5184 [ + - ]: 1565 : R"(Set PDE parameter(s) beta)"; }
5185 : 1565 : static std::string longDescription() { return
5186 [ + - ]: 1565 : R"(This keyword is used to specify a real number used to
5187 : : parameterize a system of partial differential equations. Example:
5188 : : "beta 5.0".)"; }
5189 : : struct expect {
5190 : : using type = tk::real;
5191 [ + - ]: 1565 : static std::string description() { return "real"; }
5192 : : };
5193 : : };
5194 : : using pde_beta = keyword< pde_beta_info, TAOCPP_PEGTL_STRING("beta") >;
5195 : :
5196 : : struct pde_p0_info {
5197 : : static std::string name() { return "p0"; }
5198 : 1565 : static std::string shortDescription() { return
5199 [ + - ]: 1565 : R"(Set PDE parameter(s) p0)"; }
5200 : 1565 : static std::string longDescription() { return
5201 [ + - ]: 1565 : R"(This keyword is used to specify a real number used to
5202 : : parameterize a system of partial differential equations. Example:
5203 : : "p0 10.0".)"; }
5204 : : struct expect {
5205 : : using type = tk::real;
5206 [ + - ]: 1565 : static std::string description() { return "real"; }
5207 : : };
5208 : : };
5209 : : using pde_p0 = keyword< pde_p0_info, TAOCPP_PEGTL_STRING("p0") >;
5210 : :
5211 : : // nonlinear energy parameters here
5212 : : struct pde_betax_info {
5213 : : static std::string name() { return "betax"; }
5214 : 1565 : static std::string shortDescription() { return
5215 [ + - ]: 1565 : R"(Set PDE parameter(s) betax)"; }
5216 : 1565 : static std::string longDescription() { return
5217 [ + - ]: 1565 : R"(This keyword is used to specify a real number used to
5218 : : parameterize a system of partial differential equations. Example:
5219 : : "betax 1.0".)"; }
5220 : : struct expect {
5221 : : using type = tk::real;
5222 [ + - ]: 1565 : static std::string description() { return "real"; }
5223 : : };
5224 : : };
5225 : : using pde_betax = keyword< pde_betax_info, TAOCPP_PEGTL_STRING("betax") >;
5226 : :
5227 : : struct pde_betay_info {
5228 : : static std::string name() { return "betay"; }
5229 : 1565 : static std::string shortDescription() { return
5230 [ + - ]: 1565 : R"(Set PDE parameter(s) betay)"; }
5231 : 1565 : static std::string longDescription() { return
5232 [ + - ]: 1565 : R"(This keyword is used to specify a real number used to
5233 : : parameterize a system of partial differential equations. Example:
5234 : : "betay 0.75".)"; }
5235 : : struct expect {
5236 : : using type = tk::real;
5237 [ + - ]: 1565 : static std::string description() { return "real"; }
5238 : : };
5239 : : };
5240 : : using pde_betay = keyword< pde_betay_info, TAOCPP_PEGTL_STRING("betay") >;
5241 : :
5242 : : struct pde_betaz_info {
5243 : : static std::string name() { return "betaz"; }
5244 : 1565 : static std::string shortDescription() { return
5245 [ + - ]: 1565 : R"(Set PDE parameter(s) betaz)"; }
5246 : 1565 : static std::string longDescription() { return
5247 [ + - ]: 1565 : R"(This keyword is used to specify a real number used to
5248 : : parameterize a system of partial differential equations. Example:
5249 : : "betaz 0.5".)"; }
5250 : : struct expect {
5251 : : using type = tk::real;
5252 [ + - ]: 1565 : static std::string description() { return "real"; }
5253 : : };
5254 : : };
5255 : : using pde_betaz = keyword< pde_betaz_info, TAOCPP_PEGTL_STRING("betaz") >;
5256 : :
5257 : : struct pde_ce_info {
5258 : : static std::string name() { return "ce"; }
5259 : 1565 : static std::string shortDescription() { return
5260 [ + - ]: 1565 : R"(Set PDE parameter(s) ce)"; }
5261 : 1565 : static std::string longDescription() { return
5262 [ + - ]: 1565 : R"(This keyword is used to specify a real number used to parameterize the
5263 : : Euler equations solving the manufactured solution test case "non-linear
5264 : : energy growth". Example: "ce -1.0". For more information on the test case see
5265 : : Waltz, et. al, "Manufactured solutions for the three-dimensional Euler
5266 : : equations with relevance to Inertial Confinement Fusion", Journal of
5267 : : Computational Physics 267 (2014) 196-209.)"; }
5268 : : struct expect {
5269 : : using type = tk::real;
5270 [ + - ]: 1565 : static std::string description() { return "real"; }
5271 : : };
5272 : : };
5273 : : using pde_ce = keyword< pde_ce_info, TAOCPP_PEGTL_STRING("ce") >;
5274 : :
5275 : : struct pde_kappa_info {
5276 : : static std::string name() { return "kappa"; }
5277 : 1565 : static std::string shortDescription() { return
5278 [ + - ]: 1565 : R"(Set PDE parameter(s) kappa)"; }
5279 : 1565 : static std::string longDescription() { return
5280 [ + - ]: 1565 : R"(This keyword is used to specify a real number used to
5281 : : parameterize a system of partial differential equations. Example:
5282 : : "kappa 0.8")"; }
5283 : : struct expect {
5284 : : using type = tk::real;
5285 [ + - ]: 1565 : static std::string description() { return "real"; }
5286 : : };
5287 : : };
5288 : : using pde_kappa = keyword< pde_kappa_info, TAOCPP_PEGTL_STRING("kappa") >;
5289 : :
5290 : : struct pde_r0_info {
5291 : : static std::string name() { return "r0"; }
5292 : 1565 : static std::string shortDescription() { return
5293 [ + - ]: 1565 : R"(Set PDE parameter(s) r0)"; }
5294 : 1565 : static std::string longDescription() { return
5295 [ + - ]: 1565 : R"(This keyword is used to specify a real number used to parameterize the
5296 : : Euler equations solving the manufactured solution test case "non-linear
5297 : : energy growth". Example: "r0 2.0". For more information on the test case see
5298 : : Waltz, et. al, "Manufactured solutions for the three-dimensional Euler
5299 : : equations with relevance to Inertial Confinement Fusion", Journal of
5300 : : Computational Physics 267 (2014) 196-209.)"; }
5301 : : struct expect {
5302 : : using type = tk::real;
5303 [ + - ]: 1565 : static std::string description() { return "real"; }
5304 : : };
5305 : : };
5306 : : using pde_r0 = keyword< pde_r0_info, TAOCPP_PEGTL_STRING("r0") >;
5307 : :
5308 : : struct ctau_info {
5309 : : static std::string name() { return "ctau"; }
5310 : 1565 : static std::string shortDescription() { return
5311 [ + - ]: 1565 : R"(Set FCT mass diffusion coefficient, ctau)"; }
5312 : 1565 : static std::string longDescription() { return
5313 [ + - ]: 1565 : R"(This keyword is used to set the mass diffusion coefficient used in
5314 : : flux-corrected transport, used for integrating transport equations. Example:
5315 : : "ctau 1.0".)"; }
5316 : : struct expect {
5317 : : using type = tk::real;
5318 : : static constexpr type lower = 0.0;
5319 : : static constexpr type upper = 1.0;
5320 [ + - ]: 1565 : static std::string description() { return "real"; }
5321 : 1565 : static std::string choices() {
5322 [ + - ][ + - ]: 3130 : return "real between [" + std::to_string(lower) + "..." +
[ + - ][ + - ]
5323 [ + - ]: 4695 : std::to_string(upper) + "]";
5324 : : }
5325 : : };
5326 : : };
5327 : : using ctau = keyword< ctau_info, TAOCPP_PEGTL_STRING("ctau") >;
5328 : :
5329 : : struct fcteps_info {
5330 : : static std::string name() { return "Small number for FCT"; }
5331 : 1565 : static std::string shortDescription() { return
5332 [ + - ]: 1565 : R"(A number that is considered small enough for FCT)"; }
5333 : 1565 : static std::string longDescription() { return
5334 [ + - ]: 1565 : R"(This keyword is used to set the epsilon (a small number) below which FCT
5335 : : quantities are considered small enough to be treated as zero. Setting this
5336 : : number to be somewhat larger than the machine zero, e.g., 1.0e-15, helps
5337 : : ignoring some noise that otherwise could contaminate the solution.)"; }
5338 : : struct expect {
5339 : : using type = tk::real;
5340 : : static constexpr type lower = 0.0;
5341 : : static constexpr type upper = 1.0;
5342 [ + - ]: 1565 : static std::string description() { return "real"; }
5343 : 1565 : static std::string choices() {
5344 [ + - ][ + - ]: 3130 : return "real between [" + std::to_string(lower) + "..." +
[ + - ][ + - ]
5345 [ + - ]: 4695 : std::to_string(upper) + "]";
5346 : : }
5347 : : };
5348 : : };
5349 : : using fcteps = keyword< fcteps_info, TAOCPP_PEGTL_STRING("fcteps") >;
5350 : :
5351 : : struct cweight_info {
5352 : : static std::string name() { return "cweight"; }
5353 : 1565 : static std::string shortDescription() { return
5354 [ + - ]: 1565 : R"(Set value for central linear weight used by WENO, cweight)"; }
5355 : 1565 : static std::string longDescription() { return
5356 [ + - ]: 1565 : R"(This keyword is used to set the central linear weight used for the
5357 : : central stencil in the Weighted Essentially Non-Oscillatory (WENO) limiter
5358 : : for discontinuous Galerkin (DG) methods. Example:
5359 : : "cweight 10.0".)"; }
5360 : : struct expect {
5361 : : using type = tk::real;
5362 : : static constexpr type lower = 1.0;
5363 : : static constexpr type upper = 1000.0;
5364 [ + - ]: 1565 : static std::string description() { return "real"; }
5365 : 1565 : static std::string choices() {
5366 [ + - ][ + - ]: 3130 : return "real between [" + std::to_string(lower) + "..." +
[ + - ][ + - ]
5367 [ + - ]: 4695 : std::to_string(upper) + "]";
5368 : : }
5369 : : };
5370 : : };
5371 : : using cweight = keyword< cweight_info, TAOCPP_PEGTL_STRING("cweight") >;
5372 : :
5373 : : struct sideset_info {
5374 : : static std::string name() { return "sideset"; }
5375 : 1565 : static std::string shortDescription() { return
5376 [ + - ]: 1565 : "Specify configuration for setting BC on a side set";
5377 : : }
5378 : 1565 : static std::string longDescription() { return
5379 [ + - ]: 1565 : R"(This keyword is used to specify boundary conditions on a side set for a
5380 : : solving partial differential equation.)";
5381 : : }
5382 : : struct expect {
5383 : : using type = std::string;
5384 [ + - ]: 1565 : static std::string description() { return "strings"; }
5385 : : };
5386 : : };
5387 : : using sideset = keyword< sideset_info, TAOCPP_PEGTL_STRING("sideset") >;
5388 : :
5389 : : struct fn_info {
5390 : : static std::string name() { return "User-defined function"; }
5391 : 1565 : static std::string shortDescription() { return
5392 [ + - ]: 1565 : "Specify a discrete user-defined function"; }
5393 : 1565 : static std::string longDescription() { return
5394 [ + - ]: 1565 : R"(This keyword is used to specify a user-defined function with discrete
5395 : : points, listed between a fn ... end block.)"; }
5396 : : struct expect {
5397 : : using type = tk::real;
5398 [ + - ]: 1565 : static std::string description() { return "real(s)"; }
5399 : : };
5400 : : };
5401 : : using fn = keyword< fn_info, TAOCPP_PEGTL_STRING("fn") >;
5402 : :
5403 : : struct bc_dirichlet_info {
5404 : : static std::string name() { return "Dirichlet boundary condition"; }
5405 : 1565 : static std::string shortDescription() { return
5406 [ + - ]: 1565 : "Start configuration block describing Dirichlet boundary conditions"; }
5407 : 1565 : static std::string longDescription() { return
5408 : : R"(This keyword is used to introduce an bc_dirichlet ... end block, used to
5409 : : specify the configuration for setting Dirichlet boundary conditions (BC) for
5410 : : a partial differential equation. This keyword is used to list multiple side
5411 : : sets on which a prescribed Dirichlet BC is then applied. Such prescribed BCs
5412 : : at each point in space and time are evaluated using a built-in function,
5413 : : e.g., using the method of manufactured solutions.
5414 [ + - ][ + - ]: 3130 : Keywords allowed in a bc_dirichlet ... end block: )" + std::string("\'")
5415 [ + - ][ + - ]: 6260 : + sideset::string() + "\'. "
5416 [ + - ]: 3130 : + R"(For an example bc_dirichlet ... end block, see
5417 : : doc/html/inicter_example_shear.html.)";
5418 : : }
5419 : : };
5420 : : using bc_dirichlet =
5421 : : keyword< bc_dirichlet_info, TAOCPP_PEGTL_STRING("bc_dirichlet") >;
5422 : :
5423 : : struct bc_sym_info {
5424 : : static std::string name() { return "Symmetry boundary condition"; }
5425 : 1565 : static std::string shortDescription() { return
5426 [ + - ]: 1565 : "Start configuration block describing symmetry boundary conditions"; }
5427 : 1565 : static std::string longDescription() { return
5428 : : R"(This keyword is used to introduce an bc_sym ... end block, used to
5429 : : specify the configuration for setting symmetry boundary conditions for a
5430 : : partial differential equation. Keywords allowed in a bc_sym ... end
5431 [ + - ][ + - ]: 3130 : block: )" + std::string("\'")
5432 [ + - ][ + - ]: 6260 : + sideset::string() + "\'. "
5433 [ + - ]: 3130 : + R"(For an example bc_sym ... end block, see
5434 : : doc/html/inicter_example_gausshump.html.)";
5435 : : }
5436 : : };
5437 : : using bc_sym =
5438 : : keyword< bc_sym_info, TAOCPP_PEGTL_STRING("bc_sym") >;
5439 : :
5440 : : struct point_info {
5441 : : static std::string name() { return "point"; }
5442 [ + - ]: 1565 : static std::string shortDescription() { return "Specify a point"; }
5443 : 1565 : static std::string longDescription() { return
5444 [ + - ]: 1565 : R"(This keyword is used to specify a point, used, e.g., in specifying a
5445 : : point in 3D space for setting a stagnation (velocity vector = 0). Example
5446 : : specification: 'point 0.0 0.1 0.2 end')";
5447 : : }
5448 : : struct expect {
5449 : : using type = tk::real;
5450 [ + - ]: 1565 : static std::string description() { return "3 reals"; }
5451 : : };
5452 : : };
5453 : : using point = keyword< point_info, TAOCPP_PEGTL_STRING("point") >;
5454 : :
5455 : : struct radius_info {
5456 : : static std::string name() { return "radius"; }
5457 [ + - ]: 1565 : static std::string shortDescription() { return "Specify a radius"; }
5458 : 1565 : static std::string longDescription() { return
5459 [ + - ]: 1565 : R"(This keyword is used to specify a radius, used, e.g., in specifying a
5460 : : point in 3D space for setting a stagnation (velocity vector = 0). Example
5461 : : specification: 'radius 1.0e-5')";
5462 : : }
5463 : : struct expect {
5464 : : using type = tk::real;
5465 : : static constexpr type lower = 0.0;
5466 [ + - ]: 1565 : static std::string description() { return "real"; }
5467 : : };
5468 : : };
5469 : : using radius = keyword< radius_info, TAOCPP_PEGTL_STRING("radius") >;
5470 : :
5471 : : struct sponge_info {
5472 : : static std::string name() { return "Sponge boundary"; }
5473 : 1565 : static std::string shortDescription() { return
5474 [ + - ]: 1565 : "Start configuration block describing a sponge boundary"; }
5475 : 1565 : static std::string longDescription() { return
5476 : : R"(This keyword is used to introduce an sponge ... end block, used to
5477 : : specify the configuration for applying sponge parameters on boundaries.
5478 [ + - ][ + - ]: 3130 : Keywords allowed in a sponge ... end block: )" + std::string("\'")
5479 [ + - ][ + - ]: 6260 : + sideset::string() + "\', \'"
[ + - ]
5480 [ + - ][ + - ]: 6260 : + velocity::string() + "\', \'"
[ + - ]
5481 [ + - ][ + - ]: 6260 : + pressure::string() + "\'.";
5482 : : }
5483 : : };
5484 : : using sponge = keyword< sponge_info, TAOCPP_PEGTL_STRING("sponge") >;
5485 : :
5486 : : struct bc_stag_info {
5487 : : static std::string name() { return "Stagnation boundary condition"; }
5488 : 1565 : static std::string shortDescription() { return
5489 [ + - ]: 1565 : "Start configuration block describing stagnation boundary conditions"; }
5490 : 1565 : static std::string longDescription() { return
5491 : : R"(This keyword is used to introduce an bc_stag ... end block, used to
5492 : : specify the configuration for setting stagnation boundary conditions for a
5493 : : partial differential equation. Keywords allowed in a bc_stag ... end
5494 [ + - ][ + - ]: 3130 : block: )" + std::string("\'")
5495 [ + - ][ + - ]: 6260 : + point::string() + "\', \'"
[ + - ]
5496 [ + - ][ + - ]: 6260 : + radius::string() + "\'.";
5497 : : }
5498 : : };
5499 : : using bc_stag = keyword< bc_stag_info, TAOCPP_PEGTL_STRING("bc_stag") >;
5500 : :
5501 : : struct bc_skip_info {
5502 : : static std::string name() { return "Skip boundary condition"; }
5503 : 1565 : static std::string shortDescription() { return
5504 [ + - ]: 1565 : "Start configuration block describing skip boundary conditions"; }
5505 : 1565 : static std::string longDescription() { return
5506 : : R"(This keyword is used to introduce an bc_skip ... end block, used to
5507 : : specify the configuration for setting 'skip' boundary conditions for a
5508 : : partial differential equation. If a mesh point falls into a skip region,
5509 : : configured by a point and a radius, any application of boundary conditions
5510 : : on those points will be skipped. Keywords allowed in a bc_skip ... end
5511 [ + - ][ + - ]: 3130 : block: )" + std::string("\'")
5512 [ + - ][ + - ]: 6260 : + point::string() + "\', \'"
[ + - ]
5513 [ + - ][ + - ]: 6260 : + radius::string() + "\'. ";
5514 : : }
5515 : : };
5516 : : using bc_skip = keyword< bc_skip_info, TAOCPP_PEGTL_STRING("bc_skip") >;
5517 : :
5518 : : struct bc_inlet_info {
5519 : : static std::string name() { return "Inlet boundary condition"; }
5520 : 1565 : static std::string shortDescription() { return
5521 [ + - ]: 1565 : "Start configuration block describing inlet boundary conditions"; }
5522 : 1565 : static std::string longDescription() { return
5523 : : R"(This keyword is used to introduce an bc_inlet ... end block, used to
5524 : : specify the configuration for setting inlet boundary conditions for a
5525 : : partial differential equation. Keywords allowed in a bc_inlet ... end
5526 [ + - ][ + - ]: 3130 : block: )" + std::string("\'")
5527 [ + - ][ + - ]: 6260 : + sideset::string() + "\'. "
5528 [ + - ]: 3130 : + R"(For an example bc_inlet ... end block, see
5529 : : doc/html/inicter_example_gausshump.html.)";
5530 : : }
5531 : : };
5532 : : using bc_inlet =
5533 : : keyword< bc_inlet_info, TAOCPP_PEGTL_STRING("bc_inlet") >;
5534 : :
5535 : : struct bc_outlet_info {
5536 : : static std::string name() { return "Inlet boundary condition"; }
5537 : 1565 : static std::string shortDescription() { return
5538 [ + - ]: 1565 : "Start configuration block describing outlet boundary conditions"; }
5539 : 1565 : static std::string longDescription() { return
5540 : : R"(This keyword is used to introduce an bc_outlet ... end block, used to
5541 : : specify the configuration for setting outlet boundary conditions for a
5542 : : partial differential equation. Keywords allowed in a bc_outlet ... end
5543 [ + - ][ + - ]: 3130 : block: )" + std::string("\'")
5544 [ + - ][ + - ]: 6260 : + sideset::string() + "\'. "
5545 [ + - ]: 3130 : + R"(For an example bc_outlet ... end block, see
5546 : : doc/html/inicter_example_gausshump.html.)";
5547 : : }
5548 : : };
5549 : : using bc_outlet =
5550 : : keyword< bc_outlet_info, TAOCPP_PEGTL_STRING("bc_outlet") >;
5551 : :
5552 : : struct bc_farfield_info {
5553 : : static std::string name() { return "Farfield boundary condition"; }
5554 : 1565 : static std::string shortDescription() { return
5555 [ + - ]: 1565 : "Start configuration block describing farfield boundary conditions"; }
5556 : 1565 : static std::string longDescription() { return
5557 : : R"(This keyword is used to introduce a bc_farfield ... end block, used
5558 : : to specify the configuration for setting farfield boundary conditions
5559 : : for the compressible flow equations. Keywords allowed in a bc_farfield
5560 [ + - ][ + - ]: 3130 : ... end block: )" + std::string("\'")
5561 [ + - ][ + - ]: 6260 : + density::string() + "\', \'"
[ + - ]
5562 [ + - ][ + - ]: 6260 : + pressure::string() + "\', \'"
[ + - ]
5563 [ + - ][ + - ]: 6260 : + velocity::string() + "\', \'"
[ + - ]
5564 [ + - ][ + - ]: 6260 : + sideset::string() + "\'. ";
5565 : : }
5566 : : };
5567 : : using bc_farfield =
5568 : : keyword< bc_farfield_info, TAOCPP_PEGTL_STRING("bc_farfield") >;
5569 : :
5570 : : struct bc_extrapolate_info {
5571 : : static std::string name() { return "Extrapolation boundary condition"; }
5572 : 1565 : static std::string shortDescription() { return
5573 [ + - ]: 1565 : "Start configuration block describing Extrapolation boundary conditions"; }
5574 : 1565 : static std::string longDescription() { return
5575 : : R"(This keyword is used to introduce a bc_extrapolate ... end block, used to
5576 : : specify the configuration for setting extrapolation boundary conditions for a
5577 : : partial differential equation. Keywords allowed in a bc_extrapolate ... end
5578 [ + - ][ + - ]: 3130 : block: )" + std::string("\'")
5579 [ + - ][ + - ]: 6260 : + sideset::string() + "\'. "
5580 [ + - ]: 3130 : + R"(For an example bc_extrapolate ... end block, see
5581 : : doc/html/inciter_example_gausshump.html.)";
5582 : : }
5583 : : };
5584 : : using bc_extrapolate =
5585 : : keyword< bc_extrapolate_info, TAOCPP_PEGTL_STRING("bc_extrapolate") >;
5586 : :
5587 : : struct bc_timedep_info {
5588 : : static std::string name() { return "Time dependent boundary condition"; }
5589 : 1565 : static std::string shortDescription() { return
5590 [ + - ]: 1565 : "Start configuration block describing time dependent boundary conditions"; }
5591 : 1565 : static std::string longDescription() { return
5592 : : R"(This keyword is used to introduce a bc_timedep ... end block, used to
5593 : : specify the configuration of time dependent boundary conditions for a
5594 : : partial differential equation. A discrete function in time t in the form of
5595 : : a table with 6 columns (t, pressure(t), density(t), vx(t), vy(t), vz(t)) is
5596 : : expected inside a fn ... end block, specified within the bc_timedep ... end
5597 : : block. Multiple such bc_timedep blocks can be specified for different
5598 : : time dependent BCs on different groups of side sets. Keywords allowed in a
5599 : : bc_timedep ... end block: )"
5600 [ + - ][ + - ]: 3130 : + std::string("\'") + sideset::string() + "\', "
[ + - ][ + - ]
[ + - ]
5601 [ + - ][ + - ]: 6260 : + std::string("\'") + fn::string() + "\'. "
[ + - ][ + - ]
5602 [ + - ]: 3130 : + R"(For an example bc_timedep ... end block, see
5603 : : tests/regression/inciter/compflow/Euler/TimedepBC/timedep_bc.q.)";
5604 : : }
5605 : : };
5606 : : using bc_timedep =
5607 : : keyword< bc_timedep_info, TAOCPP_PEGTL_STRING("bc_timedep") >;
5608 : :
5609 : : struct id_info {
5610 : : static std::string name() { return "id"; }
5611 [ + - ]: 1565 : static std::string shortDescription() { return "ID"; }
5612 : 1565 : static std::string longDescription() { return
5613 [ + - ]: 1565 : R"(This keyword is used to specify an ID, a positive integer.)";
5614 : : }
5615 : : struct expect {
5616 : : using type = uint64_t;
5617 : : static constexpr type lower = 1;
5618 [ + - ]: 1565 : static std::string description() { return "uint"; }
5619 : : };
5620 : : };
5621 : : using id = keyword< id_info, TAOCPP_PEGTL_STRING("id") >;
5622 : :
5623 : : struct prelax_info {
5624 : : static std::string name() { return "Pressure relaxation"; }
5625 : 1565 : static std::string shortDescription() { return
5626 [ + - ]: 1565 : "Turn multi-material finite pressure relaxation on/off"; }
5627 : 1565 : static std::string longDescription() { return
5628 [ + - ]: 1565 : R"(This keyword is used to turn finite pressure relaxation between multiple
5629 : : materials on/off. It is used only for the multi-material solver, and has
5630 : : no effect when used for the other PDE types.)";
5631 : : }
5632 : : struct expect {
5633 : : using type = int;
5634 [ + - ]: 1565 : static std::string description() { return "string"; }
5635 [ + - ]: 1565 : static std::string choices() { return "1 | 0"; }
5636 : : };
5637 : : };
5638 : : using prelax = keyword< prelax_info, TAOCPP_PEGTL_STRING("prelax") >;
5639 : :
5640 : : struct prelax_timescale_info {
5641 : : static std::string name() { return "Pressure relaxation time-scale"; }
5642 : 1565 : static std::string shortDescription() { return
5643 [ + - ]: 1565 : "Time-scale for multi-material finite pressure relaxation"; }
5644 : 1565 : static std::string longDescription() { return
5645 [ + - ]: 1565 : R"(This keyword is used to specify the time-scale at which finite pressure
5646 : : relaxation between multiple materials occurs. The default value of 1.0
5647 : : corresponds to a relaxation time of the order of time required for a
5648 : : sound wave to pass through a computational element. It is used only for
5649 : : multimat, and has no effect for the other PDE types.)";
5650 : : }
5651 : : struct expect {
5652 : : using type = tk::real;
5653 : : static constexpr type lower = 0.001;
5654 [ + - ]: 1565 : static std::string description() { return "real"; }
5655 : : };
5656 : : };
5657 : : using prelax_timescale = keyword< prelax_timescale_info,
5658 : : TAOCPP_PEGTL_STRING("prelax_timescale") >;
5659 : :
5660 : : struct intsharp_info {
5661 : : static std::string name() { return "Interface sharpening"; }
5662 : 1565 : static std::string shortDescription() { return
5663 [ + - ]: 1565 : "Turn multi-material interface sharpening on/off"; }
5664 : 1565 : static std::string longDescription() { return
5665 [ + - ]: 1565 : R"(This keyword is used to turn interface sharpening on/off. It uses the
5666 : : multi-material THINC interface reconstruction.
5667 : : Ref. Pandare A. K., Waltz J., & Bakosi J. (2021) Multi-Material
5668 : : Hydrodynamics with Algebraic Sharp Interface Capturing. Computers &
5669 : : Fluids, doi: https://doi.org/10.1016/j.compfluid.2020.104804. It is used
5670 : : for the multi-material and the transport solver, and has no effect when
5671 : : used for the other PDE types.)";
5672 : : }
5673 : : struct expect {
5674 : : using type = int;
5675 [ + - ]: 1565 : static std::string description() { return "string"; }
5676 [ + - ]: 1565 : static std::string choices() { return "1 | 0"; }
5677 : : };
5678 : : };
5679 : : using intsharp = keyword< intsharp_info, TAOCPP_PEGTL_STRING("intsharp") >;
5680 : :
5681 : : struct intsharp_param_info {
5682 : : static std::string name() { return "Interface sharpening parameter"; }
5683 : 1565 : static std::string shortDescription() { return
5684 [ + - ]: 1565 : "Parameter for multi-material interface sharpening"; }
5685 : 1565 : static std::string longDescription() { return
5686 [ + - ]: 1565 : R"(This keyword is used to specify the parameter for the interface
5687 : : sharpening. This parameter affects how many cells the material interfaces
5688 : : span, after the use of sharpening. It is used for multimat and transport,
5689 : : and has no effect for the other PDE types.)";
5690 : : }
5691 : : struct expect {
5692 : : using type = tk::real;
5693 : : static constexpr type lower = 0.1;
5694 [ + - ]: 1565 : static std::string description() { return "real"; }
5695 : : };
5696 : : };
5697 : : using intsharp_param = keyword< intsharp_param_info,
5698 : : TAOCPP_PEGTL_STRING("intsharp_param") >;
5699 : :
5700 : : struct mat_gamma_info {
5701 : : static std::string name() { return "gamma"; }
5702 [ + - ]: 1565 : static std::string shortDescription() { return "ratio of specific heats"; }
5703 : 1565 : static std::string longDescription() { return
5704 [ + - ]: 1565 : R"(This keyword is used to specify the material property, ratio of specific
5705 : : heats.)";
5706 : : }
5707 : : struct expect {
5708 : : using type = tk::real;
5709 : : static constexpr type lower = 0.0;
5710 [ + - ]: 1565 : static std::string description() { return "real"; }
5711 : : };
5712 : : };
5713 : : using mat_gamma = keyword< mat_gamma_info, TAOCPP_PEGTL_STRING("gamma") >;
5714 : :
5715 : : struct mat_pstiff_info {
5716 : : static std::string name() { return "pstiff"; }
5717 [ + - ]: 1565 : static std::string shortDescription() { return "EoS stiffness parameter"; }
5718 : 1565 : static std::string longDescription() { return
5719 [ + - ]: 1565 : R"(This keyword is used to specify the material property, stiffness
5720 : : parameter in the stiffened gas equation of state.)";
5721 : : }
5722 : : struct expect {
5723 : : using type = tk::real;
5724 : : static constexpr type lower = 0.0;
5725 [ + - ]: 1565 : static std::string description() { return "real"; }
5726 : : };
5727 : : };
5728 : : using mat_pstiff = keyword< mat_pstiff_info, TAOCPP_PEGTL_STRING("pstiff") >;
5729 : :
5730 : : struct mat_mu_info {
5731 : : static std::string name() { return "mu"; }
5732 [ + - ]: 1565 : static std::string shortDescription() { return "dynamic viscosity"; }
5733 : 1565 : static std::string longDescription() { return
5734 [ + - ]: 1565 : R"(This keyword is used to specify the material property, dynamic
5735 : : viscosity.)";
5736 : : }
5737 : : struct expect {
5738 : : using type = tk::real;
5739 : : static constexpr type lower = 0.0;
5740 [ + - ]: 1565 : static std::string description() { return "real"; }
5741 : : };
5742 : : };
5743 : : using mat_mu = keyword< mat_mu_info, TAOCPP_PEGTL_STRING("mu") >;
5744 : :
5745 : : struct mat_cv_info {
5746 : : static std::string name() { return "cv"; }
5747 : 1565 : static std::string shortDescription() {
5748 [ + - ]: 1565 : return "specific heat at constant volume"; }
5749 : 1565 : static std::string longDescription() { return
5750 [ + - ]: 1565 : R"(This keyword is used to specify the material property, specific heat at
5751 : : constant volume.)";
5752 : : }
5753 : : struct expect {
5754 : : using type = tk::real;
5755 : : static constexpr type lower = 0.0;
5756 [ + - ]: 1565 : static std::string description() { return "real"; }
5757 : : };
5758 : : };
5759 : : using mat_cv = keyword< mat_cv_info, TAOCPP_PEGTL_STRING("cv") >;
5760 : :
5761 : : struct mat_k_info {
5762 : : static std::string name() { return "k"; }
5763 [ + - ]: 1565 : static std::string shortDescription() { return "heat conductivity"; }
5764 : 1565 : static std::string longDescription() { return
5765 [ + - ]: 1565 : R"(This keyword is used to specify the material property, heat
5766 : : conductivity.)";
5767 : : }
5768 : : struct expect {
5769 : : using type = tk::real;
5770 : : static constexpr type lower = 0.0;
5771 [ + - ]: 1565 : static std::string description() { return "real"; }
5772 : : };
5773 : : };
5774 : : using mat_k = keyword< mat_k_info, TAOCPP_PEGTL_STRING("k") >;
5775 : :
5776 : : struct stiffenedgas_info {
5777 [ + - ]: 107 : static std::string name() { return "Stiffened gas"; }
5778 : 1565 : static std::string shortDescription() { return
5779 [ + - ]: 1565 : "Select the stiffened gas equation of state"; }
5780 : 1565 : static std::string longDescription() { return
5781 [ + - ]: 1565 : R"(This keyword is used to select the stiffened gas equation of state.)"; }
5782 : : };
5783 : : using stiffenedgas =
5784 : : keyword< stiffenedgas_info, TAOCPP_PEGTL_STRING("stiffenedgas") >;
5785 : :
5786 : : struct jwl_info {
5787 [ + - ]: 107 : static std::string name() { return "JWL"; }
5788 : 1565 : static std::string shortDescription() { return
5789 [ + - ]: 1565 : "Select the JWL equation of state"; }
5790 : 1565 : static std::string longDescription() { return
5791 [ + - ]: 1565 : R"(This keyword is used to select the Jones, Wilkins, Lee equation of
5792 : : state.)"; }
5793 : : };
5794 : : using jwl = keyword< jwl_info, TAOCPP_PEGTL_STRING("jwl") >;
5795 : :
5796 : : struct eos_info {
5797 : : static std::string name() { return "Equation of state"; }
5798 : 1565 : static std::string shortDescription() { return
5799 [ + - ]: 1565 : "Select equation of state (type)"; }
5800 : 1565 : static std::string longDescription() { return
5801 [ + - ]: 1565 : R"(This keyword is used to select an equation of state for a material.)"; }
5802 : : struct expect {
5803 [ + - ]: 1565 : static std::string description() { return "string"; }
5804 : 1565 : static std::string choices() {
5805 [ + - ][ + - ]: 3130 : return '\'' + stiffenedgas::string() + "\' | \'"
[ + - ]
5806 [ + - ][ + - ]: 6260 : + jwl::string() + '\'';
5807 : : }
5808 : : };
5809 : : };
5810 : : using eos = keyword< eos_info, TAOCPP_PEGTL_STRING("eos") >;
5811 : :
5812 : : struct material_info {
5813 : : static std::string name() { return "Material properties block"; }
5814 : 1565 : static std::string shortDescription() { return
5815 [ + - ]: 1565 : "Start configuration block for material properties"; }
5816 : 1565 : static std::string longDescription() { return
5817 : : R"(This keyword is used to introduce a material ... end block, used to
5818 : : specify material properties. Keywords allowed in a material ... end
5819 [ + - ][ + - ]: 3130 : block: )" + std::string("\'")
5820 [ + - ][ + - ]: 6260 : + id::string()+ "\', \'"
[ + - ]
5821 [ + - ][ + - ]: 6260 : + eos::string()+ "\', \'"
[ + - ]
5822 [ + - ][ + - ]: 6260 : + mat_gamma::string()+ "\', \'"
[ + - ]
5823 [ + - ][ + - ]: 6260 : + mat_pstiff::string()+ "\', \'"
[ + - ]
5824 [ + - ][ + - ]: 6260 : + mat_mu::string()+ "\', \'"
[ + - ]
5825 [ + - ][ + - ]: 6260 : + mat_cv::string()+ "\', \'"
[ + - ]
5826 [ + - ][ + - ]: 6260 : + mat_k::string() + "\'. "
5827 [ + - ]: 3130 : + R"(For an example material ... end block, see
5828 : : doc/html/inicter_example_compflow.html.)";
5829 : : }
5830 : : };
5831 : : using material = keyword< material_info, TAOCPP_PEGTL_STRING("material") >;
5832 : :
5833 : : struct transport_info {
5834 [ + - ]: 466 : static std::string name() { return "Transport"; }
5835 : 1565 : static std::string shortDescription() { return
5836 [ + - ]: 1565 : "Start configuration block for an transport equation"; }
5837 : 1565 : static std::string longDescription() { return
5838 : : R"(This keyword is used to introduce an transport ... end block, used to
5839 : : specify the configuration for a transport equation type. Keywords allowed
5840 [ + - ][ + - ]: 3130 : in an transport ... end block: )" + std::string("\'")
5841 [ + - ][ + - ]: 6260 : + depvar::string() + "\', \'"
[ + - ]
5842 [ + - ][ + - ]: 6260 : + ncomp::string() + "\', \'"
[ + - ]
5843 [ + - ][ + - ]: 6260 : + problem::string() + "\', \'"
[ + - ]
5844 [ + - ][ + - ]: 6260 : + physics::string() + "\', \'"
[ + - ]
5845 [ + - ][ + - ]: 6260 : + pde_diffusivity::string() + "\', \'"
[ + - ]
5846 [ + - ][ + - ]: 6260 : + pde_lambda::string() + "\', \'"
[ + - ]
5847 [ + - ][ + - ]: 6260 : + bc_dirichlet::string() + "\', \'"
[ + - ]
5848 [ + - ][ + - ]: 6260 : + bc_sym::string() + "\', \'"
[ + - ]
5849 [ + - ][ + - ]: 6260 : + bc_inlet::string() + "\', \'"
[ + - ]
5850 [ + - ][ + - ]: 6260 : + bc_outlet::string() + "\', \'"
[ + - ]
5851 [ + - ][ + - ]: 6260 : + pde_u0::string() + "\'. "
[ + - ]
5852 [ + - ][ + - ]: 6260 : + intsharp::string() + "\', \'"
[ + - ]
5853 [ + - ][ + - ]: 6260 : + intsharp_param::string() + "\', \'"
5854 [ + - ]: 3130 : + R"(For an example transport ... end block, see
5855 : : doc/html/inicter_example_transport.html.)";
5856 : : }
5857 : : };
5858 : : using transport = keyword< transport_info, TAOCPP_PEGTL_STRING("transport") >;
5859 : :
5860 : : struct compflow_info {
5861 [ + - ]: 466 : static std::string name() { return "Compressible single-material flow"; }
5862 : 1565 : static std::string shortDescription() { return
5863 [ + - ]: 1565 : "Start configuration block for the compressible flow equations"; }
5864 : 1565 : static std::string longDescription() { return
5865 : : R"(This keyword is used to introduce the compflow ... end block, used to
5866 : : specify the configuration for a system of partial differential equations,
5867 : : governing compressible fluid flow. Keywords allowed in an compflow ... end
5868 [ + - ][ + - ]: 3130 : block: )" + std::string("\'")
5869 [ + - ][ + - ]: 6260 : + depvar::string()+ "\', \'"
[ + - ]
5870 [ + - ][ + - ]: 6260 : + physics::string() + "\', \'"
[ + - ]
5871 [ + - ][ + - ]: 6260 : + problem::string() + "\', \'"
[ + - ]
5872 [ + - ][ + - ]: 6260 : + material::string() + "\', \'"
[ + - ]
5873 [ + - ][ + - ]: 6260 : + npar::string() + "\', \'"
[ + - ]
5874 [ + - ][ + - ]: 6260 : + pde_alpha::string() + "\', \'"
[ + - ]
5875 [ + - ][ + - ]: 6260 : + pde_p0::string() + "\', \'"
[ + - ]
5876 [ + - ][ + - ]: 6260 : + pde_betax::string() + "\', \'"
[ + - ]
5877 [ + - ][ + - ]: 6260 : + pde_betay::string() + "\', \'"
[ + - ]
5878 [ + - ][ + - ]: 6260 : + pde_betaz::string() + "\', \'"
[ + - ]
5879 [ + - ][ + - ]: 6260 : + pde_beta::string() + "\', \'"
[ + - ]
5880 [ + - ][ + - ]: 6260 : + pde_r0::string() + "\', \'"
[ + - ]
5881 [ + - ][ + - ]: 6260 : + pde_ce::string() + "\', \'"
[ + - ]
5882 [ + - ][ + - ]: 6260 : + pde_kappa::string() + "\', \'"
[ + - ]
5883 [ + - ][ + - ]: 6260 : + bc_dirichlet::string() + "\', \'"
[ + - ]
5884 [ + - ][ + - ]: 6260 : + bc_sym::string() + "\', \'"
[ + - ]
5885 [ + - ][ + - ]: 6260 : + bc_inlet::string() + "\', \'"
[ + - ]
5886 [ + - ][ + - ]: 6260 : + bc_outlet::string() + "\', \'"
[ + - ]
5887 [ + - ][ + - ]: 6260 : + bc_farfield::string() + "\', \'"
[ + - ]
5888 [ + - ][ + - ]: 6260 : + bc_extrapolate::string() + "\'."
[ + - ]
5889 [ + - ][ + - ]: 6260 : + bc_timedep::string() + "\'."
5890 [ + - ]: 3130 : + R"(For an example compflow ... end block, see
5891 : : doc/html/inicter_example_compflow.html.)";
5892 : : }
5893 : : };
5894 : : using compflow = keyword< compflow_info, TAOCPP_PEGTL_STRING("compflow") >;
5895 : :
5896 : : struct multimat_info {
5897 [ + - ]: 466 : static std::string name() { return "Compressible multi-material flow"; }
5898 : 1565 : static std::string shortDescription() { return "Start configuration block "
5899 [ + - ]: 1565 : "for the multi-material compressible flow equations"; }
5900 : 1565 : static std::string longDescription() { return
5901 : : R"(This keyword is used to introduce the multimat ... end block,
5902 : : used to specify the configuration for a system of partial differential
5903 : : equations, governing multi-material compressible fluid flow. Keywords
5904 [ + - ][ + - ]: 3130 : allowed in a multimat ... end block: )" + std::string("\'")
5905 [ + - ][ + - ]: 6260 : + depvar::string()+ "\', \'"
[ + - ]
5906 [ + - ][ + - ]: 6260 : + physics::string() + "\', \'"
[ + - ]
5907 [ + - ][ + - ]: 6260 : + problem::string() + "\', \'"
[ + - ]
5908 [ + - ][ + - ]: 6260 : + material::string() + "\', \'"
[ + - ]
5909 [ + - ][ + - ]: 6260 : + nmat::string() + "\', \'"
[ + - ]
5910 [ + - ][ + - ]: 6260 : + prelax::string() + "\', \'"
[ + - ]
5911 [ + - ][ + - ]: 6260 : + prelax_timescale::string() + "\', \'"
[ + - ]
5912 [ + - ][ + - ]: 6260 : + intsharp::string() + "\', \'"
[ + - ]
5913 [ + - ][ + - ]: 6260 : + intsharp_param::string() + "\', \'"
[ + - ]
5914 [ + - ][ + - ]: 6260 : + pde_alpha::string() + "\', \'"
[ + - ]
5915 [ + - ][ + - ]: 6260 : + pde_p0::string() + "\', \'"
[ + - ]
5916 [ + - ][ + - ]: 6260 : + pde_betax::string() + "\', \'"
[ + - ]
5917 [ + - ][ + - ]: 6260 : + pde_betay::string() + "\', \'"
[ + - ]
5918 [ + - ][ + - ]: 6260 : + pde_betaz::string() + "\', \'"
[ + - ]
5919 [ + - ][ + - ]: 6260 : + pde_beta::string() + "\', \'"
[ + - ]
5920 [ + - ][ + - ]: 6260 : + pde_r0::string() + "\', \'"
[ + - ]
5921 [ + - ][ + - ]: 6260 : + pde_ce::string() + "\', \'"
[ + - ]
5922 [ + - ][ + - ]: 6260 : + pde_kappa::string() + "\', \'"
[ + - ]
5923 [ + - ][ + - ]: 6260 : + bc_dirichlet::string() + "\', \'"
[ + - ]
5924 [ + - ][ + - ]: 6260 : + bc_sym::string() + "\', \'"
[ + - ]
5925 [ + - ][ + - ]: 6260 : + bc_inlet::string() + "\', \'"
[ + - ]
5926 [ + - ][ + - ]: 6260 : + bc_outlet::string() + "\', \'"
[ + - ]
5927 [ + - ][ + - ]: 6260 : + bc_extrapolate::string() + "\'."
5928 [ + - ]: 3130 : + R"(For an example multimat ... end block, see
5929 : : doc/html/inicter_example_multimat.html.)";
5930 : : }
5931 : : };
5932 : : using multimat = keyword< multimat_info, TAOCPP_PEGTL_STRING("multimat") >;
5933 : :
5934 : : struct rcb_info {
5935 [ + - ]: 1012 : static std::string name() { return "recursive coordinate bisection"; }
5936 : 1565 : static std::string shortDescription() { return
5937 [ + - ]: 1565 : "Select recursive coordinate bisection mesh partitioner"; }
5938 : 1565 : static std::string longDescription() { return
5939 [ + - ]: 1565 : R"(This keyword is used to select the recursive coordinate bisection (RCB)
5940 : : mesh partitioner. RCB is a geometry-based partitioner used to distribute an
5941 : : input mesh among processing elements. See
5942 : : Control/Options/PartitioningAlgorithm.hpp for other valid options.)"; }
5943 : : };
5944 : : using rcb = keyword< rcb_info, TAOCPP_PEGTL_STRING("rcb") >;
5945 : :
5946 : : struct rib_info {
5947 [ + - ]: 1012 : static std::string name() { return "recursive inertial bisection"; }
5948 : 1565 : static std::string shortDescription() { return
5949 [ + - ]: 1565 : "Select recursive inertial bisection mesh partitioner"; }
5950 : 1565 : static std::string longDescription() { return
5951 [ + - ]: 1565 : R"(This keyword is used to select the recursive inertial bisection (RIB)
5952 : : mesh partitioner. RIB is a geometry-based partitioner used to distribute an
5953 : : input mesh among processing elements. See
5954 : : Control/Options/PartitioningAlgorithm.hpp for other valid options.)"; }
5955 : : };
5956 : : using rib = keyword< rib_info, TAOCPP_PEGTL_STRING("rib") >;
5957 : :
5958 : : struct hsfc_info {
5959 [ + - ]: 1012 : static std::string name() { return "Hilbert space filling curve"; }
5960 : 1565 : static std::string shortDescription() { return
5961 [ + - ]: 1565 : "Select Hilbert Space Filling Curve (HSFC) mesh partitioner"; }
5962 : 1565 : static std::string longDescription() { return
5963 [ + - ]: 1565 : R"(This keyword is used to select the Hilbert Space Filling Curve (HSFC)
5964 : : mesh partitioner. HSFC is a geometry-based partitioner used to distribute an
5965 : : input mesh among processing elements. See
5966 : : Control/Options/PartitioningAlgorithm.hpp for other valid options.)"; }
5967 : : };
5968 : : using hsfc = keyword< hsfc_info, TAOCPP_PEGTL_STRING("hsfc") >;
5969 : :
5970 : : struct mj_info {
5971 [ + - ]: 1012 : static std::string name() { return "multi-jagged"; }
5972 : 1565 : static std::string shortDescription() { return
5973 [ + - ]: 1565 : "Select multi-jagged (MJ) mesh partitioner"; }
5974 : 1565 : static std::string longDescription() { return
5975 [ + - ]: 1565 : R"(This keyword is used to select the multi-jagged (MJ) mesh partitioner.
5976 : : MJ is a geometry-based partitioner used to distribute an input mesh among
5977 : : processing elements. See
5978 : : Control/Options/PartitioningAlgorithm.hpp for other valid options.)"; }
5979 : : };
5980 : : using mj = keyword< mj_info, TAOCPP_PEGTL_STRING("mj") >;
5981 : :
5982 : : struct phg_info {
5983 [ + - ]: 1012 : static std::string name() { return "hypergraph"; }
5984 : 1565 : static std::string shortDescription() { return
5985 [ + - ]: 1565 : "Select parallel hypergraph mesh partitioner"; }
5986 : 1565 : static std::string longDescription() { return
5987 [ + - ]: 1565 : R"(This keyword is used to select the parallel hypergraph (PHG)
5988 : : mesh partitioner. PHG is a graph-based partitioner used to distribute an
5989 : : input mesh among processing elements. See
5990 : : Control/Options/PartitioningAlgorithm.hpp for other valid options.)"; }
5991 : : };
5992 : : using phg = keyword< phg_info, TAOCPP_PEGTL_STRING("phg") >;
5993 : :
5994 : : struct algorithm_info {
5995 : : static std::string name() { return "algorithm"; }
5996 : 1565 : static std::string shortDescription() { return
5997 [ + - ]: 1565 : "Select mesh partitioning algorithm"; }
5998 : 1565 : static std::string longDescription() { return
5999 [ + - ]: 1565 : R"(This keyword is used to select a mesh partitioning algorithm. See
6000 : : Control/Options/PartitioningAlgorithm.hpp for valid options.)"; }
6001 : : struct expect {
6002 [ + - ]: 1565 : static std::string description() { return "string"; }
6003 : 1565 : static std::string choices() {
6004 [ + - ][ + - ]: 3130 : return '\'' + rcb::string() + "\' | \'"
[ + - ]
6005 [ + - ][ + - ]: 6260 : + rib::string() + "\' | \'"
[ + - ]
6006 [ + - ][ + - ]: 6260 : + hsfc::string() + "\' | \'"
[ + - ]
6007 [ + - ][ + - ]: 6260 : + mj::string() + "\' | \'"
[ + - ]
6008 [ + - ][ + - ]: 6260 : + phg::string() + '\'';
6009 : : }
6010 : : };
6011 : : };
6012 : : using algorithm = keyword< algorithm_info, TAOCPP_PEGTL_STRING("algorithm") >;
6013 : :
6014 : : struct partitioning_info {
6015 : : static std::string name() { return "partitioning"; }
6016 : 1565 : static std::string shortDescription() { return
6017 [ + - ]: 1565 : "Start configuration block for mesh partitioning"; }
6018 : 1565 : static std::string longDescription() { return
6019 : : R"(This keyword is used to introduce a partitioning ... end block, used to
6020 : : specify the configuration for mesh partitioning. Keywords allowed
6021 [ + - ][ + - ]: 3130 : in a partitioning ... end block: )" + std::string("\'")
6022 [ + - ][ + - ]: 6260 : + algorithm::string() + "\'.";
6023 : : }
6024 : : };
6025 : : using partitioning = keyword< partitioning_info, TAOCPP_PEGTL_STRING("partitioning") >;
6026 : :
6027 : : struct move_info {
6028 : : static std::string name() { return "move"; }
6029 : 1565 : static std::string shortDescription() { return
6030 [ + - ]: 1565 : "Start configuration block configuring surface movement"; }
6031 : 1565 : static std::string longDescription() { return
6032 : : R"(This keyword is used to introduce a move ... end block, used to
6033 : : configure surface movement for ALE simulations. Keywords allowed
6034 [ + - ][ + - ]: 3130 : in a move ... end block: )" + std::string("\'")
6035 [ + - ][ + - ]: 6260 : + sideset::string() + "\'.";
6036 : : }
6037 : : };
6038 : : using move = keyword< move_info, TAOCPP_PEGTL_STRING("move") >;
6039 : :
6040 : : struct amr_uniform_info {
6041 [ + - ]: 132 : static std::string name() { return "uniform refine"; }
6042 : 1565 : static std::string shortDescription() { return
6043 [ + - ]: 1565 : "Select uniform initial mesh refinement"; }
6044 : 1565 : static std::string longDescription() { return
6045 [ + - ]: 1565 : R"(This keyword is used to select uniform initial mesh refinement.)"; }
6046 : : };
6047 : : using amr_uniform = keyword< amr_uniform_info, TAOCPP_PEGTL_STRING("uniform") >;
6048 : :
6049 : : struct amr_uniform_derefine_info {
6050 [ + - ]: 132 : static std::string name() { return "uniform derefine"; }
6051 : 1565 : static std::string shortDescription() { return
6052 [ + - ]: 1565 : "Select uniform initial mesh de-refinement"; }
6053 : 1565 : static std::string longDescription() { return
6054 [ + - ]: 1565 : R"(This keyword is used to select uniform initial mesh de-refinement.)"; }
6055 : : };
6056 : : using amr_uniform_derefine =
6057 : : keyword< amr_uniform_derefine_info, TAOCPP_PEGTL_STRING("uniform_derefine") >;
6058 : :
6059 : : struct amr_initial_conditions_info {
6060 [ + - ]: 132 : static std::string name() { return "initial conditions"; }
6061 : 1565 : static std::string shortDescription() { return
6062 [ + - ]: 1565 : "Select initial-conditions-based initial mesh refinement"; }
6063 : 1565 : static std::string longDescription() { return
6064 [ + - ]: 1565 : R"(This keyword is used to select initial-conditions-based initial mesh
6065 : : refinement.)"; }
6066 : : };
6067 : : using amr_initial_conditions =
6068 : : keyword< amr_initial_conditions_info, TAOCPP_PEGTL_STRING("ic") >;
6069 : :
6070 : : struct amr_edgelist_info {
6071 [ + - ]: 132 : static std::string name() { return "edge list"; }
6072 : 1565 : static std::string shortDescription() { return
6073 [ + - ]: 1565 : "Configure edge-node pairs for initial refinement"; }
6074 : 1565 : static std::string longDescription() { return
6075 [ + - ]: 1565 : R"(This keyword can be used to configure a list of edges that are explicitly
6076 : : tagged for initial refinement during setup in inciter. The keyword
6077 : : introduces an edgelist ... end block within an amr ... end block and must
6078 : : contain a list of integer pairs, i.e., the number of ids must be even,
6079 : : denoting the end-points of the nodes (=edge) which should be tagged for
6080 : : refinement.)"; }
6081 : : struct expect {
6082 : : using type = std::size_t;
6083 : : static constexpr type lower = 0;
6084 [ + - ]: 1565 : static std::string description() { return "two ints"; }
6085 : : };
6086 : : };
6087 : : using amr_edgelist =
6088 : : keyword< amr_edgelist_info, TAOCPP_PEGTL_STRING("edgelist") >;
6089 : :
6090 : : struct amr_coords_info {
6091 [ + - ]: 132 : static std::string name() { return "coordinates"; }
6092 : 1565 : static std::string shortDescription() { return
6093 [ + - ]: 1565 : "Configure initial refinement using coordinate planes"; }
6094 : 1565 : static std::string longDescription() { return
6095 [ + - ]: 1565 : R"(This keyword can be used to configure entire volumes on a given side of a
6096 : : plane in 3D space. The keyword introduces an coords ... end block within
6097 : : an amr ... end block and must contain the either or multiple of the
6098 : : following keywords: x- <real>, x+ <real>, y- <real>, y+ <real>, z- <real>,
6099 : : z+ <real>. All edges of the input mesh will be tagged for refinement whose
6100 : : end-points lie less than (-) or larger than (+) the real number given.
6101 : : Example: 'x- 0.5' refines all edges whose end-point coordinates are less
6102 : : than 0.5. Multiple specifications are understood by combining with a logical
6103 : : AND. That is: 'x- 0.5 y+ 0.3' refines all edges whose end-point x
6104 : : coordinates are less than 0.5 AND y coordinates are larger than 0.3.)"; }
6105 : : };
6106 : : using amr_coords =
6107 : : keyword< amr_coords_info, TAOCPP_PEGTL_STRING("coords") >;
6108 : :
6109 : : struct amr_initial_info {
6110 [ + - ]: 132 : static std::string name() { return "Initial refinement typelist"; }
6111 : 1565 : static std::string shortDescription() { return
6112 [ + - ]: 1565 : "Configure initial mesh refinement (before time stepping)"; }
6113 : 1565 : static std::string longDescription() { return
6114 [ + - ]: 1565 : R"(This keyword is used to add to a list of initial mesh refinement types
6115 : : that happens before t = 0. Example: initial uniform initial ic inital
6116 : : uniform, which yiedls an initial uniform refinement, followed by a
6117 : : refinement based on the numerical error computed based on the initial
6118 : : conditions, followed by another step of unfirom refinement.)"; }
6119 : : struct expect {
6120 [ + - ]: 1565 : static std::string description() { return "string"; }
6121 : 1565 : static std::string choices() {
6122 [ + - ][ + - ]: 3130 : return '\'' + amr_uniform::string() + "\' | \'"
[ + - ]
6123 [ + - ][ + - ]: 6260 : + amr_uniform_derefine::string() + "\' | \'"
[ + - ]
6124 [ + - ][ + - ]: 6260 : + amr_initial_conditions::string() + "\' | \'"
[ + - ]
6125 [ + - ][ + - ]: 6260 : + amr_edgelist::string() + "\' | \'"
[ + - ]
6126 [ + - ][ + - ]: 6260 : + amr_coords::string() + '\'';
6127 : : }
6128 : : };
6129 : : };
6130 : : using amr_initial = keyword< amr_initial_info, TAOCPP_PEGTL_STRING("initial") >;
6131 : :
6132 : : struct amr_refvar_info {
6133 [ + - ]: 33 : static std::string name() { return "refinement variable(s)"; }
6134 : 1565 : static std::string shortDescription() { return
6135 [ + - ]: 1565 : "Configure dependent variables used for adaptive mesh refinement"; }
6136 : 1565 : static std::string longDescription() { return
6137 [ + - ]: 1565 : R"(This keyword is used to configured a list of dependent variables that
6138 : : trigger adaptive mesh refinement based on estimating their numerical error.
6139 : : These refinement variables are used for both initial (i.e., before time
6140 : : stepping) mesh refinement as well as during time stepping. Only previously
6141 : : (i.e., earlier in the input file) selected dependent variables can be
6142 : : configured as refinement variables. Dependent variables are required to be
6143 : : defined in all equation system configuration blocks, e.g., transport ...
6144 : : end, by using the 'depvar' keyword. Example: transport depvar c end amr
6145 : : refvar c end end. Selecting a particular scalar component in a system is
6146 : : done by appending the equation number to the refvar: Example: transport
6147 : : depvar q ncomp 3 end amr refvar q1 q2 end end, which configures two
6148 : : refinement variables: the first and third scalar component of the previously
6149 : : configured transport equation system.)"; }
6150 : : struct expect {
6151 [ + - ]: 1565 : static std::string description() { return "strings"; }
6152 : : };
6153 : : };
6154 : : using amr_refvar = keyword< amr_refvar_info, TAOCPP_PEGTL_STRING("refvar") >;
6155 : :
6156 : : struct amr_xminus_info {
6157 : : static std::string name() { return "initial refinement: x-"; }
6158 : 1565 : static std::string shortDescription() { return "Configure initial refinement "
6159 [ + - ]: 1565 : "for coordinates lower than an x-normal plane"; }
6160 : 1565 : static std::string longDescription() { return
6161 [ + - ]: 1565 : R"(This keyword can be used to configure a mesh refinement volume for edges
6162 : : whose end-points are less than the x coordinate of a plane perpendicular to
6163 : : coordinate x in 3D space. The keyword must be used in a coords ... end
6164 : : block within an amr ... end block with syntax 'x- <real>'. All edges of the
6165 : : input mesh will be tagged for refinement whose end-points lie less than (-)
6166 : : the real number given. Example: 'x- 0.5' refines all edges whose end-point
6167 : : coordinates are less than 0.5.)"; }
6168 : : struct expect {
6169 : : using type = tk::real;
6170 [ + - ]: 1565 : static std::string description() { return "real"; }
6171 : : };
6172 : : };
6173 : : using amr_xminus =
6174 : : keyword< amr_xminus_info, TAOCPP_PEGTL_STRING("x-") >;
6175 : :
6176 : : struct amr_xplus_info {
6177 : : static std::string name() { return "initial refinement: x+"; }
6178 : 1565 : static std::string shortDescription() { return "Configure initial refinement "
6179 [ + - ]: 1565 : "for coordinates larger than an x-normal plane"; }
6180 : 1565 : static std::string longDescription() { return
6181 [ + - ]: 1565 : R"(This keyword can be used to configure a mesh refinement volume for edges
6182 : : whose end-points are larger than the x coordinate of a plane perpendicular
6183 : : to coordinate x in 3D space. The keyword must be used in a coords ... end
6184 : : block within an amr ... end block with syntax 'x+ <real>'. All edges of the
6185 : : input mesh will be tagged for refinement whose end-points lie larger than
6186 : : (+) the real number given. Example: 'x+ 0.5' refines all edges whose
6187 : : end-point coordinates are larger than 0.5.)"; }
6188 : : struct expect {
6189 : : using type = tk::real;
6190 [ + - ]: 1565 : static std::string description() { return "real"; }
6191 : : };
6192 : : };
6193 : : using amr_xplus =
6194 : : keyword< amr_xplus_info, TAOCPP_PEGTL_STRING("x+") >;
6195 : :
6196 : : struct amr_yminus_info {
6197 : : static std::string name() { return "initial refinement: y-"; }
6198 : 1565 : static std::string shortDescription() { return "Configure initial refinement "
6199 [ + - ]: 1565 : "for coordinates lower than an y-normal plane"; }
6200 : 1565 : static std::string longDescription() { return
6201 [ + - ]: 1565 : R"(This keyword can be used to configure a mesh refinement volume for edges
6202 : : whose end-points are less than the y coordinate of a plane perpendicular to
6203 : : coordinate y in 3D space. The keyword must be used in a coords ... end
6204 : : block within an amr ... end block with syntax 'y- <real>'. All edges of the
6205 : : input mesh will be tagged for refinement whose end-points lie less than (-)
6206 : : the real number given. Example: 'y- 0.5' refines all edges whose end-point
6207 : : coordinates are less than 0.5.)"; }
6208 : : struct expect {
6209 : : using type = tk::real;
6210 [ + - ]: 1565 : static std::string description() { return "real"; }
6211 : : };
6212 : : };
6213 : : using amr_yminus =
6214 : : keyword< amr_yminus_info, TAOCPP_PEGTL_STRING("y-") >;
6215 : :
6216 : : struct amr_yplus_info {
6217 : : static std::string name() { return "initial refinement: y+"; }
6218 : 1565 : static std::string shortDescription() { return "Configure initial refinement "
6219 [ + - ]: 1565 : "for coordinates larger than an y-normal plane"; }
6220 : 1565 : static std::string longDescription() { return
6221 [ + - ]: 1565 : R"(This keyword can be used to configure a mesh refinement volume for edges
6222 : : whose end-points are larger than the y coordinate of a plane perpendicular
6223 : : to coordinate y in 3D space. The keyword must be used in a coords ... end
6224 : : block within an amr ... end block with syntax 'y+ <real>'. All edges of the
6225 : : input mesh will be tagged for refinement whose end-points lie larger than
6226 : : (+) the real number given. Example: 'y+ 0.5' refines all edges whose
6227 : : end-point coordinates are larger than 0.5.)"; }
6228 : : struct expect {
6229 : : using type = tk::real;
6230 [ + - ]: 1565 : static std::string description() { return "real"; }
6231 : : };
6232 : : };
6233 : : using amr_yplus =
6234 : : keyword< amr_yplus_info, TAOCPP_PEGTL_STRING("y+") >;
6235 : :
6236 : : struct amr_zminus_info {
6237 : : static std::string name() { return "initial refinement: z-"; }
6238 : 1565 : static std::string shortDescription() { return "Configure initial refinement "
6239 [ + - ]: 1565 : "for coordinates lower than an z-normal plane"; }
6240 : 1565 : static std::string longDescription() { return
6241 [ + - ]: 1565 : R"(This keyword can be used to configure a mesh refinement volume for edges
6242 : : whose end-points are less than the z coordinate of a plane perpendicular to
6243 : : coordinate z in 3D space. The keyword must be used in a coords ... end
6244 : : block within an amr ... end block with syntax 'z- <real>'. All edges of the
6245 : : input mesh will be tagged for refinement whose end-points lie less than (-)
6246 : : the real number given. Example: 'z- 0.5' refines all edges whose end-point
6247 : : coordinates are less than 0.5.)"; }
6248 : : struct expect {
6249 : : using type = tk::real;
6250 [ + - ]: 1565 : static std::string description() { return "real"; }
6251 : : };
6252 : : };
6253 : : using amr_zminus =
6254 : : keyword< amr_zminus_info, TAOCPP_PEGTL_STRING("z-") >;
6255 : :
6256 : : struct amr_zplus_info {
6257 : : static std::string name() { return "initial refinement: z+"; }
6258 : 1565 : static std::string shortDescription() { return "Configure initial refinement "
6259 [ + - ]: 1565 : "for coordinates larger than an z-normal plane"; }
6260 : 1565 : static std::string longDescription() { return
6261 [ + - ]: 1565 : R"(This keyword can be used to configure a mesh refinement volume for edges
6262 : : whose end-points are larger than the z coordinate of a plane perpendicular
6263 : : to coordinate z in 3D space. The keyword must be used in a coords ... end
6264 : : block within an amr ... end block with syntax 'z+ <real>'. All edges of the
6265 : : input mesh will be tagged for refinement whose end-points lie larger than
6266 : : (+) the real number given. Example: 'z+ 0.5' refines all edges whose
6267 : : end-point coordinates are larger than 0.5.)"; }
6268 : : struct expect {
6269 : : using type = tk::real;
6270 [ + - ]: 1565 : static std::string description() { return "real"; }
6271 : : };
6272 : : };
6273 : : using amr_zplus =
6274 : : keyword< amr_zplus_info, TAOCPP_PEGTL_STRING("z+") >;
6275 : :
6276 : : struct amr_jump_info {
6277 [ + - ]: 75 : static std::string name() { return "jump"; }
6278 : 1565 : static std::string shortDescription() { return
6279 [ + - ]: 1565 : "Error estimation based on the jump in the solution normalized by solution";
6280 : : }
6281 : 1565 : static std::string longDescription() { return
6282 [ + - ]: 1565 : R"(This keyword is used to select the jump-based error indicator for
6283 : : solution-adaptive mesh refinement. The error is estimated by computing the
6284 : : magnitude of the jump in the solution value normalized by the solution
6285 : : value.)"; }
6286 : : };
6287 : : using amr_jump =
6288 : : keyword< amr_jump_info, TAOCPP_PEGTL_STRING("jump") >;
6289 : :
6290 : : struct amr_hessian_info {
6291 [ + - ]: 75 : static std::string name() { return "Hessian"; }
6292 : 1565 : static std::string shortDescription() { return
6293 [ + - ]: 1565 : "Error estimation based on the Hessian normalized by solution value"; }
6294 : 1565 : static std::string longDescription() { return
6295 [ + - ]: 1565 : R"(This keyword is used to select the Hessian-based error indicator for
6296 : : solution-adaptive mesh refinement. The error is estimated by computing the
6297 : : Hessian (2nd derivative matrix) of the solution normalized by sum of the
6298 : : absolute values of the gradients at edges-end points.)"; }
6299 : : };
6300 : : using amr_hessian = keyword< amr_hessian_info, TAOCPP_PEGTL_STRING("hessian") >;
6301 : :
6302 : : struct amr_error_info {
6303 [ + - ]: 75 : static std::string name() { return "Error estimator"; }
6304 : 1565 : static std::string shortDescription() { return
6305 [ + - ]: 1565 : "Configure the error type for solution-adaptive mesh refinement"; }
6306 : 1565 : static std::string longDescription() { return
6307 [ + - ]: 1565 : R"(This keyword is used to select the algorithm used to estimate the error
6308 : : for solution-adaptive mesh refinement.)"; }
6309 : : struct expect {
6310 [ + - ]: 1565 : static std::string description() { return "string"; }
6311 : 1565 : static std::string choices() {
6312 [ + - ][ + - ]: 3130 : return '\'' + amr_jump::string() + "\' | \'"
[ + - ]
6313 [ + - ][ + - ]: 6260 : + amr_hessian::string() + '\'';
6314 : : }
6315 : : };
6316 : : };
6317 : : using amr_error = keyword< amr_error_info, TAOCPP_PEGTL_STRING("error") >;
6318 : :
6319 : : struct amr_t0ref_info {
6320 : : static std::string name() { return "Mesh refinement at t<0"; }
6321 : 1565 : static std::string shortDescription() { return
6322 [ + - ]: 1565 : "Enable mesh refinement at t<0"; }
6323 : 1565 : static std::string longDescription() { return
6324 [ + - ]: 1565 : R"(This keyword is used to enable initial mesh refinement, which can be
6325 : : configured to perform multiple levels of mesh refinement based on various
6326 : : refinement criteria and configuration settings.)";
6327 : : }
6328 : : struct expect {
6329 : : using type = bool;
6330 [ + - ]: 1565 : static std::string choices() { return "true | false"; }
6331 [ + - ]: 1565 : static std::string description() { return "string"; }
6332 : : };
6333 : : };
6334 : : using amr_t0ref = keyword< amr_t0ref_info, TAOCPP_PEGTL_STRING("t0ref") >;
6335 : :
6336 : : struct amr_dtref_info {
6337 : : static std::string name() { return "Mesh refinement at t>0"; }
6338 : 1565 : static std::string shortDescription() { return
6339 [ + - ]: 1565 : "Enable mesh refinement at t>0"; }
6340 : 1565 : static std::string longDescription() { return
6341 [ + - ]: 1565 : R"(This keyword is used to enable soution-adaptive mesh refinement during "
6342 : : "time stepping.)";
6343 : : }
6344 : : struct expect {
6345 : : using type = bool;
6346 [ + - ]: 1565 : static std::string choices() { return "true | false"; }
6347 [ + - ]: 1565 : static std::string description() { return "string"; }
6348 : : };
6349 : : };
6350 : : using amr_dtref = keyword< amr_dtref_info, TAOCPP_PEGTL_STRING("dtref") >;
6351 : :
6352 : : struct amr_dtref_uniform_info {
6353 : : static std::string name() { return "Uniform-only mesh refinement at t>0"; }
6354 : 1565 : static std::string shortDescription() { return
6355 [ + - ]: 1565 : "Enable mesh refinement at t>0 but only perform uniform refinement"; }
6356 [ + - ]: 1565 : static std::string longDescription() { return R"(This keyword is used to force
6357 : : uniform-only soution-adaptive mesh refinement during time stepping.)";
6358 : : }
6359 : : struct expect {
6360 : : using type = bool;
6361 [ + - ]: 1565 : static std::string choices() { return "true | false"; }
6362 [ + - ]: 1565 : static std::string description() { return "string"; }
6363 : : };
6364 : : };
6365 : : using amr_dtref_uniform =
6366 : : keyword< amr_dtref_uniform_info, TAOCPP_PEGTL_STRING("dtref_uniform") >;
6367 : :
6368 : : struct amr_dtfreq_info {
6369 : : static std::string name() { return "Mesh refinement frequency"; }
6370 : 1565 : static std::string shortDescription() { return
6371 [ + - ]: 1565 : "Set mesh refinement frequency during time stepping"; }
6372 : 1565 : static std::string longDescription() { return
6373 [ + - ]: 1565 : R"(This keyword is used to configure the frequency of mesh refinement
6374 : : during time stepping. The default is 3, which means that mesh refinement
6375 : : will be performed every 3rd time step.)";
6376 : : }
6377 : : struct expect {
6378 : : using type = std::size_t;
6379 : : static constexpr type lower = 1;
6380 : : static constexpr type upper = std::numeric_limits< type >::max();
6381 [ + - ]: 1565 : static std::string description() { return "int"; }
6382 : 1565 : static std::string choices() {
6383 [ + - ][ + - ]: 3130 : return "integer between [" + std::to_string(lower) + "..." +
[ + - ][ + - ]
6384 [ + - ]: 4695 : std::to_string(upper) + "] (both inclusive)";
6385 : : }
6386 : : };
6387 : : };
6388 : : using amr_dtfreq = keyword< amr_dtfreq_info, TAOCPP_PEGTL_STRING("dtfreq") >;
6389 : :
6390 : : struct amr_tolref_info {
6391 : : static std::string name() { return "refine tolerance"; }
6392 [ + - ]: 1565 : static std::string shortDescription() { return "Configure refine tolerance"; }
6393 : 1565 : static std::string longDescription() { return
6394 [ + - ]: 1565 : R"(This keyword is used to set the tolerance used to tag an edge for
6395 : : refinement if the relative error exceeds this value.)"; }
6396 : : struct expect {
6397 : : using type = tk::real;
6398 : : static constexpr type lower = 0.0;
6399 : : static constexpr type upper = 1.0;
6400 [ + - ]: 1565 : static std::string description() { return "real"; }
6401 : 1565 : static std::string choices() {
6402 [ + - ][ + - ]: 3130 : return "integer between [" + std::to_string(lower) + "..." +
[ + - ][ + - ]
6403 [ + - ]: 4695 : std::to_string(upper) + "] (both inclusive)";
6404 : : }
6405 : : };
6406 : : };
6407 : : using amr_tolref =
6408 : : keyword< amr_tolref_info, TAOCPP_PEGTL_STRING("tol_refine") >;
6409 : :
6410 : : struct amr_tolderef_info {
6411 : : static std::string name() { return "derefine tolerance"; }
6412 : 1565 : static std::string shortDescription() {
6413 [ + - ]: 1565 : return "Configure derefine tolerance"; }
6414 : 1565 : static std::string longDescription() { return
6415 [ + - ]: 1565 : R"(This keyword is used to set the tolerance used to tag an edge for
6416 : : derefinement if the relative error is below this value.)"; }
6417 : : struct expect {
6418 : : using type = tk::real;
6419 : : static constexpr type lower = 0.0;
6420 : : static constexpr type upper = 1.0;
6421 [ + - ]: 1565 : static std::string description() { return "real"; }
6422 : 1565 : static std::string choices() {
6423 [ + - ][ + - ]: 3130 : return "integer between [" + std::to_string(lower) + "..." +
[ + - ][ + - ]
6424 [ + - ]: 4695 : std::to_string(upper) + "] (both inclusive)";
6425 : : }
6426 : : };
6427 : : };
6428 : : using amr_tolderef =
6429 : : keyword< amr_tolderef_info, TAOCPP_PEGTL_STRING("tol_derefine") >;
6430 : :
6431 : : struct amr_info {
6432 : : static std::string name() { return "AMR"; }
6433 : 1565 : static std::string shortDescription() { return
6434 [ + - ]: 1565 : "Start configuration block configuring adaptive mesh refinement"; }
6435 : 1565 : static std::string longDescription() { return
6436 : : R"(This keyword is used to introduce the amr ... end block, used to
6437 : : configure adaptive mesh refinement. Keywords allowed
6438 [ + - ][ + - ]: 3130 : in this block: )" + std::string("\'")
6439 [ + - ][ + - ]: 6260 : + amr_t0ref::string() + "\' | \'"
[ + - ]
6440 [ + - ][ + - ]: 6260 : + amr_dtref::string() + "\' | \'"
[ + - ]
6441 [ + - ][ + - ]: 6260 : + amr_dtref_uniform::string() + "\' | \'"
[ + - ]
6442 [ + - ][ + - ]: 6260 : + amr_dtfreq::string() + "\' | \'"
[ + - ]
6443 [ + - ][ + - ]: 6260 : + amr_initial::string() + "\' | \'"
[ + - ]
6444 [ + - ][ + - ]: 6260 : + amr_refvar::string() + "\' | \'"
[ + - ]
6445 [ + - ][ + - ]: 6260 : + amr_tolref::string() + "\' | \'"
[ + - ]
6446 [ + - ][ + - ]: 6260 : + amr_tolderef::string() + "\' | \'"
[ + - ]
6447 [ + - ][ + - ]: 6260 : + amr_error::string() + "\' | \'"
[ + - ]
6448 [ + - ][ + - ]: 6260 : + amr_coords::string() + "\' | \'"
[ + - ]
6449 [ + - ][ + - ]: 6260 : + amr_edgelist::string() + "\'.";
6450 : : }
6451 : : };
6452 : : using amr = keyword< amr_info, TAOCPP_PEGTL_STRING("amr") >;
6453 : :
6454 : : struct pref_spectral_decay_info {
6455 [ + - ]: 12 : static std::string name() { return "spectral decay"; }
6456 : 1565 : static std::string shortDescription() { return "Select the spectral-decay"
6457 [ + - ]: 1565 : " indicator for p-adaptive DG scheme"; }
6458 : 1565 : static std::string longDescription() { return
6459 [ + - ]: 1565 : R"(This keyword is used to select the spectral-decay indicator used for
6460 : : p-adaptive discontinuous Galerkin (DG) discretization used in inciter.
6461 : : See Control/Inciter/Options/PrefIndicator.hpp for other valid options.)"; }
6462 : : };
6463 : : using pref_spectral_decay = keyword< pref_spectral_decay_info,
6464 : : TAOCPP_PEGTL_STRING("spectral_decay") >;
6465 : :
6466 : : struct pref_non_conformity_info {
6467 [ + - ]: 12 : static std::string name() { return "non-conformity"; }
6468 : 1565 : static std::string shortDescription() { return "Select the non-conformity"
6469 [ + - ]: 1565 : " indicator for p-adaptive DG scheme"; }
6470 : 1565 : static std::string longDescription() { return
6471 [ + - ]: 1565 : R"(This keyword is used to select the non-conformity indicator used for
6472 : : p-adaptive discontinuous Galerkin (DG) discretization used in inciter.
6473 : : See Control/Inciter/Options/PrefIndicator.hpp for other valid options.)"; }
6474 : : };
6475 : : using pref_non_conformity = keyword< pref_non_conformity_info,
6476 : : TAOCPP_PEGTL_STRING("non_conformity") >;
6477 : :
6478 : : struct pref_indicator_info {
6479 [ + - ]: 12 : static std::string name() { return "the choice of adaptive indicator"; }
6480 : 1565 : static std::string shortDescription() { return "Configure the specific "
6481 [ + - ]: 1565 : " adaptive indicator for p-adaptive DG scheme"; }
6482 : 1565 : static std::string longDescription() { return
6483 [ + - ]: 1565 : R"(This keyword can be used to configure a specific type of adaptive
6484 : : indicator for p-adaptive refinement of the DG scheme. The keyword must
6485 : : be used in pref ... end block. Example specification: 'indicator 1'.)"; }
6486 : : struct expect {
6487 [ + - ]: 1565 : static std::string description() { return "string"; }
6488 : 1565 : static std::string choices() {
6489 [ + - ][ + - ]: 3130 : return '\'' + pref_spectral_decay::string() + "\' | \'"
[ + - ]
6490 [ + - ][ + - ]: 6260 : + pref_non_conformity::string() + '\'';
6491 : : }
6492 : : };
6493 : : };
6494 : : using pref_indicator =
6495 : : keyword< pref_indicator_info, TAOCPP_PEGTL_STRING("indicator") >;
6496 : :
6497 : : struct pref_ndofmax_info {
6498 : : static std::string name() { return "Maximum ndof for p-refinement"; }
6499 : 1565 : static std::string shortDescription() { return "Configure the maximum "
6500 [ + - ]: 1565 : "number of degree of freedom for p-adaptive DG scheme"; }
6501 : 1565 : static std::string longDescription() { return
6502 [ + - ]: 1565 : R"(This keyword can be used to configure a maximum number of degree of
6503 : : freedom for p-adaptive refinement of the DG scheme. The keyword must
6504 : : be used in pref ... end block. Example specification: 'ndofmax 10'.)"; }
6505 : : struct expect {
6506 : : using type = std::size_t;
6507 : : static constexpr type lower = 4;
6508 : : static constexpr type upper = 10;
6509 [ + - ]: 1565 : static std::string description() { return "int"; }
6510 : 1565 : static std::string choices() {
6511 [ + - ]: 1565 : return "int either 4 or 10";
6512 : : }
6513 : : };
6514 : : };
6515 : : using pref_ndofmax =
6516 : : keyword< pref_ndofmax_info, TAOCPP_PEGTL_STRING("ndofmax") >;
6517 : :
6518 : : struct pref_tolref_info {
6519 : : static std::string name() { return "Tolerance for p-refinement"; }
6520 : 1565 : static std::string shortDescription() { return "Configure the tolerance for "
6521 [ + - ]: 1565 : "p-refinement for the p-adaptive DG scheme"; }
6522 : 1565 : static std::string longDescription() { return
6523 [ + - ]: 1565 : R"(This keyword can be used to configure a tolerance for p-adaptive
6524 : : refinement for the DG scheme. The keyword must be used in pref ... end
6525 : : block. All elements with a refinement indicator larger than this tolerance
6526 : : will be p-refined. Example specification: 'tolref 0.1'.)"; }
6527 : : struct expect {
6528 : : using type = tk::real;
6529 : : static constexpr type lower = 0.0;
6530 : : static constexpr type upper = 1.0;
6531 [ + - ]: 1565 : static std::string description() { return "real"; }
6532 : 1565 : static std::string choices() {
6533 [ + - ][ + - ]: 3130 : return "real between [" + std::to_string(lower) + "..." +
[ + - ][ + - ]
6534 [ + - ]: 4695 : std::to_string(upper) + "] (both inclusive)";
6535 : : }
6536 : : };
6537 : : };
6538 : : using pref_tolref = keyword< pref_tolref_info, TAOCPP_PEGTL_STRING("tolref") >;
6539 : :
6540 : : struct pref_info {
6541 : : static std::string name() { return "pref"; }
6542 : 1565 : static std::string shortDescription() { return
6543 [ + - ]: 1565 : "Start configuration block configuring p-adaptive refinement"; }
6544 : 1565 : static std::string longDescription() { return
6545 : : R"(This keyword is used to introduce the pref ... end block, used to
6546 : : configure p-adaptive refinement. Keywords allowed
6547 [ + - ][ + - ]: 3130 : in this block: )" + std::string("\'")
6548 [ + - ][ + - ]: 6260 : + pref_indicator::string() + "\' | \'"
[ + - ]
6549 [ + - ][ + - ]: 6260 : + pref_ndofmax::string() + "\' | \'"
[ + - ]
6550 [ + - ][ + - ]: 6260 : + pref_tolref::string() + "\' | \'";
6551 : : }
6552 : : };
6553 : : using pref = keyword< pref_info, TAOCPP_PEGTL_STRING("pref") >;
6554 : :
6555 : : struct diagcg_info {
6556 [ + - ]: 907672 : static std::string name() { return "CG+LW"; }
6557 : 1565 : static std::string shortDescription() { return "Select continuous Galerkin "
6558 [ + - ]: 1565 : "+ Lax Wendroff with a lumped-mass matrix LHS"; }
6559 : 1565 : static std::string longDescription() { return
6560 [ + - ]: 1565 : R"(This keyword is used to select the lumped-mass matrix continuous Galerkin
6561 : : (CG) finite element spatial discretiztaion used in inciter. CG is combined
6562 : : with a Lax-Wendroff scheme for time discretization and flux-corrected
6563 : : transport (FCT) for treating discontinuous solutions. This option selects
6564 : : the scheme that stores the left-hand side matrix lumped, i.e., only the
6565 : : diagonal elements stored and thus does not require a linear solver. See
6566 : : Control/Inciter/Options/Scheme.hpp for other valid options.)"; }
6567 : : };
6568 : : using diagcg = keyword< diagcg_info, TAOCPP_PEGTL_STRING("diagcg") >;
6569 : :
6570 : : struct alecg_info {
6571 [ + - ]: 907672 : static std::string name() { return "ALECG+RK"; }
6572 : 1565 : static std::string shortDescription() { return "Select continuous Galerkin "
6573 [ + - ]: 1565 : "with ALE + Runge-Kutta"; }
6574 : 1565 : static std::string longDescription() { return
6575 [ + - ]: 1565 : R"(This keyword is used to select the continuous Galerkin finite element
6576 : : scheme in the arbitrary Lagrangian-Eulerian (ALE) reference frame combined
6577 : : with Runge-Kutta (RK) time stepping. See Control/Inciter/Options/Scheme.hpp
6578 : : for other valid options.)"; }
6579 : : };
6580 : : using alecg = keyword< alecg_info, TAOCPP_PEGTL_STRING("alecg") >;
6581 : :
6582 : : struct dg_info {
6583 [ + - ]: 907672 : static std::string name() { return "DG(P0)+RK"; }
6584 : 1565 : static std::string shortDescription() { return
6585 [ + - ]: 1565 : "Select 1st-order discontinuous Galerkin discretization + Runge-Kutta"; }
6586 : 1565 : static std::string longDescription() { return
6587 [ + - ]: 1565 : R"(This keyword is used to select the first-order accurate discontinuous
6588 : : Galerkin, DG(P0), spatial discretiztaion used in Inciter. As this is first
6589 : : order accurate, it is intended for testing and debugging purposes only.
6590 : : Selecting this spatial discretization also selects the Runge-Kutta scheme
6591 : : for time discretization. See Control/Inciter/Options/Scheme.hpp for other
6592 : : valid options.)"; }
6593 : : };
6594 : : using dg = keyword< dg_info, TAOCPP_PEGTL_STRING("dg") >;
6595 : :
6596 : : struct p0p1_info {
6597 [ + - ]: 907672 : static std::string name() { return "P0P1+RK"; }
6598 : 1565 : static std::string shortDescription() { return
6599 [ + - ]: 1565 : "Select 2nd-order finite volume discretization + Runge-Kutta"; }
6600 : 1565 : static std::string longDescription() { return
6601 [ + - ]: 1565 : R"(This keyword is used to select the second-order accurate finite volume,
6602 : : P0P1, spatial discretiztaion used in Inciter. This method uses a
6603 : : least-squares procedure to reconstruct the second-order solution from the
6604 : : first-order one. Selecting this spatial discretization also selects the
6605 : : Runge-Kutta scheme for time discretization.
6606 : : See Control/Inciter/Options/Scheme.hpp for other valid options.)"; }
6607 : : };
6608 : : using p0p1 = keyword< p0p1_info, TAOCPP_PEGTL_STRING("p0p1") >;
6609 : :
6610 : : struct dgp1_info {
6611 [ + - ]: 907672 : static std::string name() { return "DG(P1)+RK"; }
6612 : 1565 : static std::string shortDescription() { return
6613 [ + - ]: 1565 : "Select 2nd-order discontinuous Galerkin discretization + Runge-Kutta"; }
6614 : 1565 : static std::string longDescription() { return
6615 [ + - ]: 1565 : R"(This keyword is used to select the second-order accurate discontinuous
6616 : : Galerkin, DG(P1), spatial discretiztaion used in Inciter. Selecting this
6617 : : spatial discretization also selects the Runge-Kutta scheme for time
6618 : : discretization. See Control/Inciter/Options/Scheme.hpp for other
6619 : : valid options.)"; }
6620 : : };
6621 : : using dgp1 = keyword< dgp1_info, TAOCPP_PEGTL_STRING("dgp1") >;
6622 : :
6623 : : struct dgp2_info {
6624 [ + - ]: 907672 : static std::string name() { return "DG(P2)+RK"; }
6625 : 1565 : static std::string shortDescription() { return
6626 [ + - ]: 1565 : "Select 3nd-order discontinuous Galerkin discretization + Runge-Kutta"; }
6627 : 1565 : static std::string longDescription() { return
6628 [ + - ]: 1565 : R"(This keyword is used to select the third-order accurate discontinuous
6629 : : Galerkin, DG(P2), spatial discretiztaion used in Inciter. Selecting this
6630 : : spatial discretization also selects the Runge-Kutta scheme for time
6631 : : discretization. See Control/Inciter/Options/Scheme.hpp for other
6632 : : valid options.)"; }
6633 : : };
6634 : : using dgp2 = keyword< dgp2_info, TAOCPP_PEGTL_STRING("dgp2") >;
6635 : :
6636 : : struct pdg_info {
6637 [ + - ]: 907672 : static std::string name() { return "pDG+RK"; }
6638 : 1565 : static std::string shortDescription() { return
6639 [ + - ]: 1565 : "Select adaptive discontinuous Galerkin discretization + Runge-Kutta"; }
6640 : 1565 : static std::string longDescription() { return
6641 [ + - ]: 1565 : R"(This keyword is used to select the adaptive discontinuous Galerkin
6642 : : spatial discretizaion used in Inciter. Selecting this spatial
6643 : : discretization also selects the Runge-Kutta scheme for time
6644 : : discretization. See Control/Inciter/Options/Scheme.hpp for other valid
6645 : : options.)"; }
6646 : : };
6647 : : using pdg = keyword< pdg_info, TAOCPP_PEGTL_STRING("pdg") >;
6648 : :
6649 : : struct scheme_info {
6650 [ + - ]: 907672 : static std::string name() { return "Discretization scheme"; }
6651 : 1565 : static std::string shortDescription() { return
6652 [ + - ]: 1565 : "Select discretization scheme"; }
6653 : 1565 : static std::string longDescription() { return
6654 [ + - ]: 1565 : R"(This keyword is used to select a spatial discretization scheme,
6655 : : necessarily connected to the teporal discretization scheme. See
6656 : : Control/Inciter/Options/Scheme.hpp for valid options.)"; }
6657 : : struct expect {
6658 [ + - ]: 1565 : static std::string description() { return "string"; }
6659 : 1565 : static std::string choices() {
6660 [ + - ][ + - ]: 3130 : return '\'' + diagcg::string() + "\' | \'"
[ + - ]
6661 [ + - ][ + - ]: 6260 : + dg::string() + '\'';
6662 : : }
6663 : : };
6664 : : };
6665 : : using scheme = keyword< scheme_info, TAOCPP_PEGTL_STRING("scheme") >;
6666 : :
6667 : : struct laxfriedrichs_info {
6668 [ + - ]: 49 : static std::string name() { return "Lax-Friedrichs"; }
6669 : 1565 : static std::string shortDescription() { return
6670 [ + - ]: 1565 : "Select Lax-Friedrichs flux function"; }
6671 : 1565 : static std::string longDescription() { return
6672 [ + - ]: 1565 : R"(This keyword is used to select the Lax-Friedrichs flux function used for
6673 : : discontinuous Galerkin (DG) spatial discretization used in inciter. See
6674 : : Control/Inciter/Options/Flux.hpp for other valid options.)"; }
6675 : : };
6676 : : using laxfriedrichs =
6677 : : keyword< laxfriedrichs_info, TAOCPP_PEGTL_STRING("laxfriedrichs") >;
6678 : :
6679 : : struct hllc_info {
6680 [ + - ]: 49 : static std::string name() { return "HLLC"; }
6681 : 1565 : static std::string shortDescription() { return
6682 [ + - ]: 1565 : "Select the Harten-Lax-van Leer-Contact (HLLC) flux function"; }
6683 : 1565 : static std::string longDescription() { return
6684 [ + - ]: 1565 : R"(This keyword is used to select the Harten-Lax-van Leer-Contact flux
6685 : : function used for discontinuous Galerkin (DG) spatial discretization
6686 : : used in inciter. See Control/Inciter/Options/Flux.hpp for other valid
6687 : : options.)"; }
6688 : : };
6689 : : using hllc = keyword< hllc_info, TAOCPP_PEGTL_STRING("hllc") >;
6690 : :
6691 : : struct upwind_info {
6692 [ + - ]: 49 : static std::string name() { return "Upwind"; }
6693 : 1565 : static std::string shortDescription() { return
6694 [ + - ]: 1565 : "Select the upwind flux function"; }
6695 : 1565 : static std::string longDescription() { return
6696 [ + - ]: 1565 : R"(This keyword is used to select the upwind flux
6697 : : function used for discontinuous Galerkin (DG) spatial discretization
6698 : : used in inciter. It is really only useful for scalar transport, it is thus
6699 : : not selectable for anything else, and for scalar transport it is the
6700 : : hardcoded flux type. See Control/Inciter/Options/Flux.hpp for other valid
6701 : : options.)"; }
6702 : : };
6703 : : using upwind = keyword< upwind_info, TAOCPP_PEGTL_STRING("upwind") >;
6704 : :
6705 : : struct ausm_info {
6706 [ + - ]: 49 : static std::string name() { return "AUSM"; }
6707 : 1565 : static std::string shortDescription() { return
6708 [ + - ]: 1565 : "Select the Advection Upstream Splitting Method (AUSM) flux function"; }
6709 : 1565 : static std::string longDescription() { return
6710 [ + - ]: 1565 : R"(This keyword is used to select the AUSM flux
6711 : : function used for discontinuous Galerkin (DG) spatial discretization
6712 : : used in inciter. It is only used for for multi-material hydro, it is thus
6713 : : not selectable for anything else, and for multi-material hydro it is the
6714 : : hardcoded flux type.)"; }
6715 : : };
6716 : : using ausm = keyword< ausm_info, TAOCPP_PEGTL_STRING("ausm") >;
6717 : :
6718 : : struct hll_info {
6719 [ + - ]: 49 : static std::string name() { return "HLL"; }
6720 : 1565 : static std::string shortDescription() { return
6721 [ + - ]: 1565 : "Select the Harten-Lax-vanLeer (HLL) flux function"; }
6722 : 1565 : static std::string longDescription() { return
6723 [ + - ]: 1565 : R"(This keyword is used to select the HLL flux
6724 : : function used for discontinuous Galerkin (DG) spatial discretization
6725 : : used in inciter. It is only used for for multi-material hydro, it is thus
6726 : : not selectable for anything else, and for multi-material hydro it is the
6727 : : hardcoded flux type.)"; }
6728 : : };
6729 : : using hll = keyword< hll_info, TAOCPP_PEGTL_STRING("hll") >;
6730 : :
6731 : : struct flux_info {
6732 [ + - ]: 156 : static std::string name() { return "Flux function"; }
6733 : 1565 : static std::string shortDescription() { return
6734 [ + - ]: 1565 : "Select flux function"; }
6735 : 1565 : static std::string longDescription() { return
6736 [ + - ]: 1565 : R"(This keyword is used to select a flux function, used for
6737 : : discontinuous Galerkin (DG) spatial discretization used in inciter. See
6738 : : Control/Inciter/Options/Flux.hpp for valid options.)"; }
6739 : : struct expect {
6740 [ + - ]: 1565 : static std::string description() { return "string"; }
6741 : 1565 : static std::string choices() {
6742 [ + - ][ + - ]: 3130 : return '\'' + laxfriedrichs::string() + "\' | \'"
[ + - ]
6743 [ + - ][ + - ]: 6260 : + hllc::string() + "\' | \'"
[ + - ]
6744 [ + - ][ + - ]: 6260 : + upwind::string() + "\' | \'"
[ + - ]
6745 [ + - ][ + - ]: 6260 : + ausm::string() + "\' | \'"
[ + - ]
6746 [ + - ][ + - ]: 6260 : + hll::string() + '\'';
6747 : : }
6748 : : };
6749 : : };
6750 : : using flux = keyword< flux_info, TAOCPP_PEGTL_STRING("flux") >;
6751 : :
6752 : : struct none_info {
6753 [ + - ]: 16 : static std::string name() { return "none"; }
6754 [ + - ]: 1565 : static std::string shortDescription() { return "Select none option"; }
6755 : 1565 : static std::string longDescription() { return
6756 [ + - ]: 1565 : R"(This keyword is used to select the 'none' option from a list of
6757 : : configuration options.)"; }
6758 : : };
6759 : : using none = keyword< none_info, TAOCPP_PEGTL_STRING("none") >;
6760 : :
6761 : : struct sine_info {
6762 [ + - ]: 20 : static std::string name() { return "sine"; }
6763 : 1565 : static std::string shortDescription() { return
6764 [ + - ]: 1565 : "Prescribe sinusoidal mesh velocity for ALE"; }
6765 : 1565 : static std::string longDescription() { return
6766 [ + - ]: 1565 : R"(This keyword is used to prescribe a sinusoidal mesh velocity
6767 : : for Arbitrary-Lagrangian-Eulerian (ALE) mesh motion.)"; }
6768 : : };
6769 : : using sine = keyword< sine_info, TAOCPP_PEGTL_STRING("sine") >;
6770 : :
6771 : : struct fluid_info {
6772 [ + - ]: 20 : static std::string name() { return "fluid"; }
6773 : 1565 : static std::string shortDescription() { return
6774 [ + - ]: 1565 : "Select the fluid velocity for ALE"; }
6775 : 1565 : static std::string longDescription() { return
6776 [ + - ]: 1565 : R"(This keyword is used to select the 'fluid' velocity as the mesh velocity
6777 : : for Arbitrary-Lagrangian-Eulerian (ALE) mesh motion.)"; }
6778 : : };
6779 : : using fluid = keyword< fluid_info, TAOCPP_PEGTL_STRING("fluid") >;
6780 : :
6781 : : struct laplace_info {
6782 [ + - ]: 16 : static std::string name() { return "Laplace"; }
6783 : 1565 : static std::string shortDescription() { return
6784 [ + - ]: 1565 : "Select the Laplace mesh velocity smoother for ALE"; }
6785 : 1565 : static std::string longDescription() { return
6786 [ + - ]: 1565 : R"(This keyword is used to select the 'Laplace' mesh velocity smoother for
6787 : : Arbitrary-Lagrangian-Eulerian (ALE) mesh motion.)"; }
6788 : : };
6789 : : using laplace = keyword< laplace_info, TAOCPP_PEGTL_STRING("laplace") >;
6790 : :
6791 : : struct helmholtz_info {
6792 [ + - ]: 16 : static std::string name() { return "Helmholtz"; }
6793 : 1565 : static std::string shortDescription() { return
6794 [ + - ]: 1565 : "Select the Helmholtz velocity for ALE"; }
6795 : 1565 : static std::string longDescription() { return
6796 [ + - ]: 1565 : R"(This keyword is used to select the a velocity, computed from the
6797 : : Helmholtz-decomposition as the mesh velocity for
6798 : : Arbitrary-Lagrangian-Eulerian (ALE) mesh motion. See J. Bakosi, J. Waltz,
6799 : : N. Morgan, Improved ALE mesh velocities for complex flows, Int. J. Numer.
6800 : : Meth. Fl., 1-10, 2017, https://doi.org/10.1002/fld.4403.)"; }
6801 : : };
6802 : : using helmholtz = keyword< helmholtz_info, TAOCPP_PEGTL_STRING("helmholtz") >;
6803 : :
6804 : : struct meshvelocity_info {
6805 [ + - ]: 20 : static std::string name() { return "Mesh velocity"; }
6806 : 1565 : static std::string shortDescription() { return
6807 [ + - ]: 1565 : "Select mesh velocity"; }
6808 : 1565 : static std::string longDescription() { return
6809 [ + - ]: 1565 : R"(This keyword is used to select a mesh velocity option, used for
6810 : : Arbitrary-Lagrangian-Eulerian (ALE) mesh motion.)"; }
6811 : : struct expect {
6812 [ + - ]: 1565 : static std::string description() { return "string"; }
6813 : 1565 : static std::string choices() {
6814 [ + - ][ + - ]: 3130 : return '\'' + sine::string() + "\' | \'"
[ + - ]
6815 [ + - ][ + - ]: 6260 : + fluid::string() + "\' | \'"
[ + - ]
6816 [ + - ][ + - ]: 6260 : + user_defined::string() + '\'';
6817 : : }
6818 : : };
6819 : : };
6820 : : using meshvelocity =
6821 : : keyword< meshvelocity_info, TAOCPP_PEGTL_STRING("mesh_velocity") >;
6822 : :
6823 : : struct smoother_info {
6824 [ + - ]: 16 : static std::string name() { return "Smoother"; }
6825 : 1565 : static std::string shortDescription() { return
6826 [ + - ]: 1565 : "Select mesh velocity smoother"; }
6827 : 1565 : static std::string longDescription() { return
6828 [ + - ]: 1565 : R"(This keyword is used to select a mesh velocity smoother option, used for
6829 : : Arbitrary-Lagrangian-Eulerian (ALE) mesh motion.)"; }
6830 : : struct expect {
6831 [ + - ]: 1565 : static std::string description() { return "string"; }
6832 : 1565 : static std::string choices() {
6833 [ + - ][ + - ]: 3130 : return '\'' + none::string() + "\' | \'"
[ + - ]
6834 [ + - ][ + - ]: 6260 : + laplace::string() + "\' | \'"
[ + - ]
6835 [ + - ][ + - ]: 6260 : + helmholtz::string() + '\'';
6836 : : }
6837 : : };
6838 : : };
6839 : : using smoother =
6840 : : keyword< smoother_info, TAOCPP_PEGTL_STRING("smoother") >;
6841 : :
6842 : : struct fntype_info {
6843 : : static std::string name() { return "User-defined function type"; }
6844 : 1565 : static std::string shortDescription() { return
6845 [ + - ]: 1565 : "Select how a user-defined function is interpreted"; }
6846 : 1565 : static std::string longDescription() { return
6847 [ + - ]: 1565 : R"(This keyword is used to select how a user-defined function should be
6848 : : interpreted.)"; }
6849 : : struct expect {
6850 [ + - ]: 1565 : static std::string description() { return "string"; }
6851 : : };
6852 : : };
6853 : : using fntype =
6854 : : keyword< fntype_info, TAOCPP_PEGTL_STRING("fntype") >;
6855 : :
6856 : : struct mesh_motion_info {
6857 : : static std::string name() {
6858 : : return "Mesh velocity dimensions allowed to change in ALE"; }
6859 : 1565 : static std::string shortDescription() { return "Specify a list of scalar "
6860 [ + - ]: 1565 : "dimension indices that are allowed to move in ALE calculations"; }
6861 : 1565 : static std::string longDescription() { return
6862 [ + - ]: 1565 : R"(This keyword is used to specify a list of integers (0, 1, or 2) whose
6863 : : coordinate directions corresponding to x, y, or z are allowed to move with
6864 : : the mesh velocity in ALE calculations. Example: 'mesh_motion 0 1 end', which
6865 : : means disallow mesh motion in the z coordinate direction, useful for 2D
6866 : : problems in x-y.)";
6867 : : }
6868 : : struct expect {
6869 : : using type = std::size_t;
6870 [ + - ]: 1565 : static std::string description() { return "integers"; }
6871 : : };
6872 : : };
6873 : : using mesh_motion =
6874 : : keyword< mesh_motion_info, TAOCPP_PEGTL_STRING("mesh_motion") >;
6875 : :
6876 : : struct meshforce_info {
6877 : : static std::string name() { return "Mesh force"; }
6878 : 1565 : static std::string shortDescription() { return
6879 [ + - ]: 1565 : R"(Set ALE mesh force model parameter(s))"; }
6880 : 1565 : static std::string longDescription() { return
6881 [ + - ]: 1565 : R"(This keyword is used to specify a vector of real numbers used to
6882 : : parameterize a mesh force model for ALE. Example: "mesh_force 1.0 2.0 3.0
6883 : : 4.0 end". The length of the vector must exactly 4. Everything else is an
6884 : : error.)"; }
6885 : : struct expect {
6886 : : using type = tk::real;
6887 [ + - ]: 1565 : static std::string description() { return "real(s)"; }
6888 : : };
6889 : : };
6890 : : using meshforce = keyword< meshforce_info, TAOCPP_PEGTL_STRING("mesh_force") >;
6891 : :
6892 : : struct ale_info {
6893 : : static std::string name() { return "ALE"; }
6894 : 1565 : static std::string shortDescription() { return "Start configuration block "
6895 [ + - ]: 1565 : "configuring ALE"; }
6896 : 1565 : static std::string longDescription() { return
6897 : : R"(This keyword is used to introduce the ale ... end block, used to
6898 : : configure arbitrary Lagrangian-Eulerian (ALE) mesh movement. Keywords
6899 [ + - ][ + - ]: 3130 : allowed in this block: )" + std::string("\'")
6900 [ + - ][ + - ]: 6260 : + vortmult::string() + "\' | \'"
[ + - ]
6901 [ + - ][ + - ]: 6260 : + meshvel_maxit::string() + "\' | \'"
[ + - ]
6902 [ + - ][ + - ]: 6260 : + meshvel_tolerance::string() + "\' | \'"
[ + - ]
6903 [ + - ][ + - ]: 6260 : + bc_dirichlet::string() + "\' | \'"
[ + - ]
6904 [ + - ][ + - ]: 6260 : + bc_sym::string() + "\' | \'"
[ + - ]
6905 [ + - ][ + - ]: 6260 : + meshforce::string() + "\' | \'"
[ + - ]
6906 [ + - ][ + - ]: 6260 : + meshvelocity::string() + "\'.";
6907 : : }
6908 : : };
6909 : : using ale = keyword< ale_info, TAOCPP_PEGTL_STRING("ale") >;
6910 : :
6911 : : struct filename_info {
6912 : : static std::string name() { return "filename"; }
6913 [ + - ]: 1565 : static std::string shortDescription() { return "Set filename"; }
6914 : 1565 : static std::string longDescription() { return
6915 [ + - ]: 1565 : R"(Set filename, e.g., mesh filename for solver coupling.)";
6916 : : }
6917 : : struct expect {
6918 : : using type = std::string;
6919 [ + - ]: 1565 : static std::string description() { return "string"; }
6920 : : };
6921 : : };
6922 : : using filename = keyword< filename_info, TAOCPP_PEGTL_STRING("filename") >;
6923 : :
6924 : : struct location_info {
6925 : : static std::string name() { return "location"; }
6926 [ + - ]: 1565 : static std::string shortDescription() { return "Configure location"; }
6927 : 1565 : static std::string longDescription() { return
6928 [ + - ]: 1565 : R"(Configure location of a mesh relative to another, e.g., for solver
6929 : : coupling.)";
6930 : : }
6931 : : struct expect {
6932 : : using type = tk::real;
6933 [ + - ]: 1565 : static std::string description() { return "real(s)"; }
6934 : : };
6935 : : };
6936 : : using location = keyword< location_info, TAOCPP_PEGTL_STRING("location") >;
6937 : :
6938 : : struct orientation_info {
6939 : : static std::string name() { return "orientation"; }
6940 [ + - ]: 1565 : static std::string shortDescription() { return "Configure orientation"; }
6941 : 1565 : static std::string longDescription() { return
6942 [ + - ]: 1565 : R"(Configure orientation of a mesh relative to another, e.g., for solver
6943 : : coupling.)";
6944 : : }
6945 : : struct expect {
6946 : : using type = tk::real;
6947 [ + - ]: 1565 : static std::string description() { return "real(s)"; }
6948 : : };
6949 : : };
6950 : : using orientation =
6951 : : keyword< orientation_info, TAOCPP_PEGTL_STRING("orientation") >;
6952 : :
6953 : : struct mesh_info {
6954 : : static std::string name() { return "Mesh specification block"; }
6955 : 1565 : static std::string shortDescription() { return
6956 [ + - ]: 1565 : "Start configuration block assigning a mesh to a solver"; }
6957 : 1565 : static std::string longDescription() { return
6958 [ + - ]: 1565 : R"(This keyword is used to introduce a mesh ... end block, used to
6959 : : assign and configure a mesh to a solver.)";
6960 : : }
6961 : : };
6962 : : using mesh = keyword< mesh_info, TAOCPP_PEGTL_STRING("mesh") >;
6963 : :
6964 : : struct reference_info {
6965 : : static std::string name() { return "Mesh transformation"; }
6966 : 1565 : static std::string shortDescription() { return
6967 [ + - ]: 1565 : "Specify mesh transformation relative to a mesh of another solver"; }
6968 : 1565 : static std::string longDescription() { return
6969 [ + - ]: 1565 : R"(This keyword is used to specify a solver, given with a dependent
6970 : : variable, configured upstream in the input file, whose mesh is used as a
6971 : : reference to which the mesh being configured is transformed relative
6972 : : to.)";
6973 : : }
6974 : : struct expect {
6975 : : using type = char;
6976 [ + - ]: 1565 : static std::string description() { return "character"; }
6977 : : };
6978 : : };
6979 : : using reference = keyword< reference_info, TAOCPP_PEGTL_STRING("reference") >;
6980 : :
6981 : : struct couple_info {
6982 : : static std::string name() { return "Couple solvers"; }
6983 : 1565 : static std::string shortDescription() { return
6984 [ + - ]: 1565 : "Specify coupling of solvers on different meshes"; }
6985 : 1565 : static std::string longDescription() { return
6986 [ + - ]: 1565 : R"(This keyword is used to introduce a couple ... end block, used to
6987 : : specify coupling of solvers operating on different meshes.)";
6988 : : }
6989 : : };
6990 : : using couple = keyword< couple_info, TAOCPP_PEGTL_STRING("couple") >;
6991 : :
6992 : : struct nolimiter_info {
6993 [ + - ]: 124 : static std::string name() { return "No limiter"; }
6994 : 1565 : static std::string shortDescription() { return
6995 [ + - ]: 1565 : "No limiter used"; }
6996 : 1565 : static std::string longDescription() { return
6997 [ + - ]: 1565 : R"(This keyword is used for discontinuous Galerkin (DG) spatial
6998 : : discretization without any limiter in inciter. See
6999 : : Control/Inciter/Options/Limiter.hpp for other valid options.)"; }
7000 : : };
7001 : : using nolimiter =
7002 : : keyword< nolimiter_info, TAOCPP_PEGTL_STRING("nolimiter") >;
7003 : :
7004 : : struct wenop1_info {
7005 [ + - ]: 124 : static std::string name() { return "WENOP1"; }
7006 : 1565 : static std::string shortDescription() { return
7007 [ + - ]: 1565 : "Select the Weighted Essentially Non-Oscillatory (WENO) limiter for DGP1"; }
7008 : 1565 : static std::string longDescription() { return
7009 [ + - ]: 1565 : R"(This keyword is used to select the Weighted Essentially Non-Oscillatory
7010 : : limiter used for discontinuous Galerkin (DG) P1 spatial discretization
7011 : : used in inciter. See Control/Inciter/Options/Limiter.hpp for other valid
7012 : : options.)"; }
7013 : : };
7014 : : using wenop1 = keyword< wenop1_info, TAOCPP_PEGTL_STRING("wenop1") >;
7015 : :
7016 : : struct superbeep1_info {
7017 [ + - ]: 124 : static std::string name() { return "SUPERBEEP1"; }
7018 : 1565 : static std::string shortDescription() { return
7019 [ + - ]: 1565 : "Select the Superbee limiter for DGP1"; }
7020 : 1565 : static std::string longDescription() { return
7021 [ + - ]: 1565 : R"(This keyword is used to select the Superbee limiter used for
7022 : : discontinuous Galerkin (DG) P1 spatial discretization used in inciter.
7023 : : See Control/Inciter/Options/Limiter.hpp for other valid options.)"; }
7024 : : };
7025 : : using superbeep1 = keyword< superbeep1_info, TAOCPP_PEGTL_STRING("superbeep1") >;
7026 : :
7027 : : struct vertexbasedp1_info {
7028 [ + - ]: 124 : static std::string name() { return "VERTEXBASEDP1"; }
7029 : 1565 : static std::string shortDescription() { return
7030 [ + - ]: 1565 : "Select the vertex-based limiter for DGP1"; }
7031 : 1565 : static std::string longDescription() { return
7032 [ + - ]: 1565 : R"(This keyword is used to select the vertex-based limiter used for
7033 : : discontinuous Galerkin (DG) P1 spatial discretization used in inciter.
7034 : : Ref. Kuzmin, D. (2010). A vertex-based hierarchical slope limiter for
7035 : : p-adaptive discontinuous Galerkin methods. Journal of computational and
7036 : : applied mathematics, 233(12), 3077-3085.
7037 : : See Control/Inciter/Options/Limiter.hpp for other valid options.)"; }
7038 : : };
7039 : : using vertexbasedp1 = keyword< vertexbasedp1_info, TAOCPP_PEGTL_STRING("vertexbasedp1") >;
7040 : :
7041 : : struct limiter_info {
7042 [ + - ]: 124 : static std::string name() { return "Limiter function"; }
7043 : 1565 : static std::string shortDescription() { return
7044 [ + - ]: 1565 : "Select limiter function"; }
7045 : 1565 : static std::string longDescription() { return
7046 [ + - ]: 1565 : R"(This keyword is used to select a limiter function, used for
7047 : : discontinuous Galerkin (DG) spatial discretization used in inciter. See
7048 : : Control/Inciter/Options/Limiter.hpp for valid options.)"; }
7049 : : struct expect {
7050 [ + - ]: 1565 : static std::string description() { return "string"; }
7051 : 1565 : static std::string choices() {
7052 [ + - ][ + - ]: 3130 : return '\'' + nolimiter::string() + "\' | \'"
[ + - ]
7053 [ + - ][ + - ]: 6260 : + wenop1::string() + "\' | \'"
[ + - ]
7054 [ + - ][ + - ]: 6260 : + superbeep1::string() + "\' | \'"
[ + - ]
7055 [ + - ][ + - ]: 6260 : + vertexbasedp1::string() + '\'';
7056 : : }
7057 : : };
7058 : : };
7059 : : using limiter = keyword< limiter_info, TAOCPP_PEGTL_STRING("limiter") >;
7060 : :
7061 : : struct fct_info {
7062 : : static std::string name() { return "Flux-corrected transport"; }
7063 : 1565 : static std::string shortDescription() { return
7064 [ + - ]: 1565 : "Turn flux-corrected transport on/off"; }
7065 : 1565 : static std::string longDescription() { return
7066 [ + - ]: 1565 : R"(This keyword can be used to turn on/off flux-corrected transport (FCT).
7067 : : Note that FCT is only used in conjunction with continuous Galerkin finite
7068 : : element discretization, configured by scheme diagcg and it has no
7069 : : effect when the discontinuous Galerkin (DG) scheme is used, configured by
7070 : : 'scheme dg'. Also note that even if FCT is turned off, it is still
7071 : : performed, only its result is not applied.)"; }
7072 : : struct expect {
7073 : : using type = bool;
7074 [ + - ]: 1565 : static std::string description() { return "string"; }
7075 [ + - ]: 1565 : static std::string choices() { return "true | false"; }
7076 : : };
7077 : : };
7078 : : using fct = keyword< fct_info, TAOCPP_PEGTL_STRING("fct") >;
7079 : :
7080 : : struct fctclip_info {
7081 : : static std::string name() { return "Clipping Flux-corrected transport"; }
7082 : 1565 : static std::string shortDescription() { return
7083 [ + - ]: 1565 : "Turn on clipping flux-corrected transport on/off"; }
7084 : 1565 : static std::string longDescription() { return
7085 [ + - ]: 1565 : R"(This keyword can be used to turn on/off the clipping limiter used for
7086 : : flux-corrected transport (FCT). The clipping limiter only looks at the
7087 : : current low order solution to determine the allowed solution minima and
7088 : : maxima, instead of the minimum and maximum of the low order solution and
7089 : : the previous solution.)"; }
7090 : : struct expect {
7091 : : using type = bool;
7092 [ + - ]: 1565 : static std::string description() { return "string"; }
7093 [ + - ]: 1565 : static std::string choices() { return "true | false"; }
7094 : : };
7095 : : };
7096 : : using fctclip = keyword< fctclip_info, TAOCPP_PEGTL_STRING("fctclip") >;
7097 : :
7098 : : struct sysfct_info {
7099 : : static std::string name() { return "Flux-corrected transport for systems"; }
7100 : 1565 : static std::string shortDescription() { return
7101 [ + - ]: 1565 : "Turn on system nature of flux-corrected transport"; }
7102 : 1565 : static std::string longDescription() { return
7103 [ + - ]: 1565 : R"(This keyword can be used to enable a system-nature for flux-corrected
7104 : : transport (FCT). Note that FCT is only used in conjunction with continuous
7105 : : Galerkin finite element discretization, configured by scheme diagcg and it
7106 : : has no effect when the discontinuous Galerkin (DG) scheme is used,
7107 : : configured by 'scheme dg'. Enabling the system-nature for FCT will choose
7108 : : the limiter coefficients for a system of equations, e.g., compressible flow,
7109 : : in way that takes the system-nature of the equations into account. An
7110 : : example is assinging the minimum of the limit coefficient to all variables
7111 : : limited in a computational cell, e.g., density, momentum, and specitic total
7112 : : energy. This yields better, more monotonic, results.)"; }
7113 : : struct expect {
7114 : : using type = bool;
7115 [ + - ]: 1565 : static std::string description() { return "string"; }
7116 [ + - ]: 1565 : static std::string choices() { return "true | false"; }
7117 : : };
7118 : : };
7119 : : using sysfct = keyword< sysfct_info, TAOCPP_PEGTL_STRING("sysfct") >;
7120 : :
7121 : : struct sysfctvar_info {
7122 : : static std::string name() { return "Variables considered for system FCT"; }
7123 : 1565 : static std::string shortDescription() { return
7124 [ + - ]: 1565 : "Specify a list of scalar component indices that considered for system FCT";
7125 : : }
7126 : 1565 : static std::string longDescription() { return
7127 [ + - ]: 1565 : R"(This keyword is used to specify a list of integers that are considered
7128 : : for computing the system-nature of flux-corrected transport. Example:
7129 : : 'sysfctvar 0 1 2 3 end', which means ignoring the energy (by not listing 4)
7130 : : when computing the coupled limit coefficient for a system of mass, momentum,
7131 : : and energy for single-material compressible flow.)";
7132 : : }
7133 : : struct expect {
7134 : : using type = std::size_t;
7135 [ + - ]: 1565 : static std::string description() { return "integers"; }
7136 : : };
7137 : : };
7138 : : using sysfctvar = keyword< sysfctvar_info, TAOCPP_PEGTL_STRING("sysfctvar") >;
7139 : :
7140 : : ////////// NOT YET FULLY DOCUMENTED //////////
7141 : :
7142 : : struct mix_iem_info {
7143 : : static std::string name() { return "IEM"; }
7144 : : static std::string shortDescription() { return
7145 : : "Interaction by exchange with the mean"; }
7146 : : static std::string longDescription() { return
7147 : : R"(Material mix model, 'mix_iem', is short for interaction by exchange with
7148 : : the mean (IEM). It is a relaxation-type material mix model intended
7149 : : shear-driven flows.)";
7150 : : }
7151 : : };
7152 : : using mix_iem = keyword<mix_iem_info, TAOCPP_PEGTL_STRING("mix_iem") >;
7153 : :
7154 : : struct mix_iecm_info {
7155 : : static std::string name() { return "IECM"; }
7156 : : static std::string shortDescription()
7157 : : { return "Interaction by exchange with the conditional mean"; }
7158 : : static std::string longDescription() { return
7159 : : R"(Material mix model, 'mix_iecm', is short for interaction by exchange with
7160 : : the conditional mean (IECM). It is a relaxation-type material mix model
7161 : : intended shear-driven flows.)";
7162 : : }
7163 : : };
7164 : : using mix_iecm = keyword<mix_iecm_info, TAOCPP_PEGTL_STRING("mix_iecm") >;
7165 : :
7166 : : struct mix_dir_info {
7167 : : static std::string name() { return "Dirichlet"; }
7168 : : static std::string shortDescription() { return "Dirichlet"; }
7169 : : static std::string longDescription() { return
7170 : : R"(Material mix model, 'mix_dir', is short for Dirichlet. It is a material
7171 : : mix model that explicitly satisfies the unit-sum requirement for all
7172 : : statistical samples.)";
7173 : : }
7174 : : };
7175 : : using mix_dir = keyword<mix_dir_info, TAOCPP_PEGTL_STRING("mix_dir") >;
7176 : :
7177 : : struct mix_gendir_info {
7178 : : static std::string name() { return "Generalized Dirichlet"; }
7179 : : static std::string shortDescription() { return "Generalized Dirichlet"; }
7180 : : static std::string longDescription() { return
7181 : : R"(Material mix model, 'mix_gendir', is short for Lochner's generalized
7182 : : Dirichlet. It is a material mix model that explicitly satisfies the
7183 : : unit-sum requirement for all statistical samples.)";
7184 : : }
7185 : : };
7186 : : using mix_gendir = keyword<mix_gendir_info, TAOCPP_PEGTL_STRING("mix_gendir") >;
7187 : :
7188 : : struct hommix_info {
7189 : : static std::string name() { return "HomMix"; }
7190 : : static std::string shortDescription()
7191 : : { return "Homogeneous material mixing"; }
7192 : : static std::string longDescription() { return
7193 : : R"(Physics option, 'hommix', is short for homogeneous material mixing. It is
7194 : : the simplest physics option that can be used to research, develop, and
7195 : : test material mixing models independent, i.e., decoupled from other
7196 : : equations. Only a set of scalar equations are advanced which can be
7197 : : coupled to each other. The keyword 'hommix' introduces the hommix ... end
7198 : : block, selecting and describing the parameters of the mixing model(s).
7199 : : The common physics keywords are recognized.)";
7200 : : }
7201 : : };
7202 : : using hommix = keyword<hommix_info, TAOCPP_PEGTL_STRING("hommix") >;
7203 : :
7204 : : struct homhydro_info {
7205 : : static std::string name() { return "HomHydro"; }
7206 : : static std::string shortDescription() { return "Homogeneous hydrodynamics"; }
7207 : : static std::string longDescription() { return
7208 : : R"(Physics option, 'homhydro', is short for homogeneous hydrodynamics. It is
7209 : : the simplest physics option that can be used to research, develop, and
7210 : : test hydrodynamics models independent of, i.e., decoupled from other
7211 : : equations. Only a set of momentum equations are advanced whose components
7212 : : can be coupled to each other. The keyword 'homhydro' introduces the
7213 : : homhydro ... end block, selecting and describing the parameters of the
7214 : : hydrodynamics model(s). The common physics keywords are recognized.)";
7215 : : }
7216 : : };
7217 : : using homhydro = keyword<homhydro_info, TAOCPP_PEGTL_STRING("homhydro") >;
7218 : :
7219 : : struct homrt_info {
7220 : : static std::string name() { return "HomRT"; }
7221 : : static std::string shortDescription()
7222 : : { return "Homogeneous Rayleigh-Taylor"; }
7223 : : static std::string longDescription() { return
7224 : : R"(Physics option, 'homrt', is short for homogeneous Rayleigh-Taylor. It is
7225 : : the simplest physics option that can be used to research, develop, and
7226 : : test hydrodynamics models for variable-density hydrodynamics and coupled
7227 : : material mixing, independent, i.e., decoupled from other equations. Only
7228 : : a set of mass and momentum conservation equations are advanced whose
7229 : : components can be coupled to each other. The keyword 'homrt' introduces
7230 : : the homrt ... end block, selecting and describing the parameters of the
7231 : : mass and hydrodynamics model(s). The common physics keywords are
7232 : : recognized.)";
7233 : : }
7234 : : };
7235 : : using homrt = keyword<homrt_info, TAOCPP_PEGTL_STRING("homrt") >;
7236 : :
7237 : : struct spinsflow_info {
7238 : : static std::string name() { return "SPINSFlow"; }
7239 : : static std::string shortDescription() { return
7240 : : "Standalone-particle incompressible Navier-Stokes flow";
7241 : : }
7242 : : static std::string longDescription() { return
7243 : : R"(Physics option, 'spinsflow', is short for standalone-particle
7244 : : incompressible Navier-Stokes flow. It is a physics option intended for
7245 : : inhomogeneous constant-density flow. The transport equations solved are
7246 : : the momentum and optionally, energy, and a set of scalars. The
7247 : : divergence-constraint is enforced by solving a Poisson equation and
7248 : : projection scheme. The keyword 'spinsflow' introduces the spinsflow ...
7249 : : end block, selecting and describing the parameters of the above transport
7250 : : equations and their models. The common physics keywords are recognized.)";
7251 : : }
7252 : : };
7253 : : using spinsflow = keyword<spinsflow_info, TAOCPP_PEGTL_STRING("spinsflow") >;
7254 : :
7255 : : // This will go away once all the keywords below are documented
7256 : : struct undefined_info {
7257 : : static std::string name() { return "undef"; }
7258 : : static std::string shortDescription() { return "undefined"; }
7259 : : static std::string longDescription() { return "Undefined."; }
7260 : : };
7261 : :
7262 : : } // kw::
7263 : :
7264 : : #endif // Keywords_h
|
