Quinoa all test code coverage report
Current view: top level - Control/Inciter/InputDeck - InputDeck.hpp (source / functions) Hit Total Coverage
Commit: -128-NOTFOUND Lines: 257 257 100.0 %
Date: 2024-11-27 16:40:44 Functions: 2 2 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 2183 4848 45.0 %

           Branch data     Line data    Source code
       1                 :            : // *****************************************************************************
       2                 :            : /*!
       3                 :            :   \file      src/Control/Inciter/InputDeck/InputDeck.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     Inciter's new input deck definition
       9                 :            :   \details   This file defines the heterogeneous struct that is used for storing
      10                 :            :      the data from user input during the control file parsing of the
      11                 :            :      computational shock hydrodynamics tool, Inciter.
      12                 :            : */
      13                 :            : // *****************************************************************************
      14                 :            : #ifndef InputDeck_h
      15                 :            : #define InputDeck_h
      16                 :            : 
      17                 :            : #include <getopt.h>
      18                 :            : #include "Types.hpp"
      19                 :            : #include "TaggedTuple.hpp"
      20                 :            : #include "Inciter/CmdLine/CmdLine.hpp"
      21                 :            : #include "Transfer.hpp"
      22                 :            : #include "Inciter/OutVar.hpp"
      23                 :            : #include "Inciter/Options/PDE.hpp"
      24                 :            : #include "Inciter/Options/Problem.hpp"
      25                 :            : #include "Inciter/Options/Scheme.hpp"
      26                 :            : #include "Inciter/Options/Limiter.hpp"
      27                 :            : #include "Inciter/Options/Flux.hpp"
      28                 :            : #include "Inciter/Options/Initiate.hpp"
      29                 :            : #include "Inciter/Options/AMRInitial.hpp"
      30                 :            : #include "Inciter/Options/AMRError.hpp"
      31                 :            : #include "Inciter/Options/PrefIndicator.hpp"
      32                 :            : #include "Inciter/Options/MeshVelocity.hpp"
      33                 :            : #include "Inciter/Options/MeshVelocitySmoother.hpp"
      34                 :            : #include "Inciter/Options/Material.hpp"
      35                 :            : #include "Options/PartitioningAlgorithm.hpp"
      36                 :            : #include "Options/TxtFloatFormat.hpp"
      37                 :            : #include "Options/FieldFile.hpp"
      38                 :            : #include "Options/Error.hpp"
      39                 :            : #include "Options/UserTable.hpp"
      40                 :            : 
      41                 :            : namespace inciter {
      42                 :            : 
      43                 :            : namespace ctr {
      44                 :            : 
      45                 :            : using ncomp_t = std::size_t;
      46                 :            : 
      47                 :            : using bclist = tk::TaggedTuple< brigand::list<
      48                 :            :   tag::dirichlet,   std::vector< std::size_t >,
      49                 :            :   tag::symmetry,    std::vector< std::size_t >,
      50                 :            :   tag::inlet,       std::vector< std::size_t >,
      51                 :            :   tag::outlet,      std::vector< std::size_t >,
      52                 :            :   tag::farfield,    std::vector< std::size_t >,
      53                 :            :   tag::extrapolate, std::vector< std::size_t >,
      54                 :            :   tag::noslipwall,  std::vector< std::size_t >
      55                 :            : > >;
      56                 :            : 
      57                 :            : // Transport
      58                 :            : using transportList = tk::TaggedTuple< brigand::list<
      59                 :            :     tag::physics,        PhysicsType,
      60                 :            :     tag::ncomp,          std::size_t,
      61                 :            :     tag::intsharp,       int,
      62                 :            :     tag::intsharp_param, tk::real,
      63                 :            :     tag::problem,        ProblemType,
      64                 :            :     tag::diffusivity,    std::vector< tk::real >,
      65                 :            :     tag::lambda,         std::vector< tk::real >,
      66                 :            :     tag::u0,             std::vector< tk::real >
      67                 :            : > >;
      68                 :            : 
      69                 :            : // CompFlow
      70                 :            : using compflowList = tk::TaggedTuple< brigand::list<
      71                 :            :     tag::physics, PhysicsType,
      72                 :            :     tag::problem, ProblemType,
      73                 :            :     tag::alpha,   tk::real,
      74                 :            :     tag::beta,    tk::real,
      75                 :            :     tag::betax,   tk::real,
      76                 :            :     tag::betay,   tk::real,
      77                 :            :     tag::betaz,   tk::real,
      78                 :            :     tag::r0,      tk::real,
      79                 :            :     tag::p0,      tk::real,
      80                 :            :     tag::ce,      tk::real,
      81                 :            :     tag::kappa,   tk::real
      82                 :            : > >;
      83                 :            : 
      84                 :            : // MultiMat
      85                 :            : using multimatList = tk::TaggedTuple< brigand::list<
      86                 :            :   tag::physics,          PhysicsType,
      87                 :            :   tag::nmat,             std::size_t,
      88                 :            :   tag::prelax,           uint64_t,
      89                 :            :   tag::prelax_timescale, tk::real,
      90                 :            :   tag::intsharp,         int,
      91                 :            :   tag::intsharp_param,   tk::real,
      92                 :            :   tag::rho0constraint,   uint64_t,
      93                 :            :   tag::dt_sos_massavg,   int,
      94                 :            :   tag::problem,          ProblemType,
      95                 :            :   tag::viscous,          bool
      96                 :            : > >;
      97                 :            : 
      98                 :            : // MultiSpecies
      99                 :            : using multispeciesList = tk::TaggedTuple< brigand::list<
     100                 :            :   tag::physics,          PhysicsType,
     101                 :            :   tag::nspec,            std::size_t,
     102                 :            :   tag::problem,          ProblemType,
     103                 :            :   tag::viscous,          bool
     104                 :            : > >;
     105                 :            : 
     106                 :            : // Material/EOS object
     107                 :            : using materialList = tk::TaggedTuple< brigand::list<
     108                 :            :   tag::eos,          MaterialType,
     109                 :            :   tag::id,           std::vector< uint64_t >,
     110                 :            :   tag::gamma,        std::vector< tk::real >,
     111                 :            :   tag::pstiff,       std::vector< tk::real >,
     112                 :            :   tag::w_gru,        std::vector< tk::real >,
     113                 :            :   tag::A_jwl,        std::vector< tk::real >,
     114                 :            :   tag::B_jwl,        std::vector< tk::real >,
     115                 :            :   tag::C_jwl,        std::vector< tk::real >,
     116                 :            :   tag::R1_jwl,       std::vector< tk::real >,
     117                 :            :   tag::R2_jwl,       std::vector< tk::real >,
     118                 :            :   tag::rho0_jwl,     std::vector< tk::real >,
     119                 :            :   tag::de_jwl,       std::vector< tk::real >,
     120                 :            :   tag::rhor_jwl,     std::vector< tk::real >,
     121                 :            :   tag::Tr_jwl,       std::vector< tk::real >,
     122                 :            :   tag::Pr_jwl,       std::vector< tk::real >,
     123                 :            :   tag::mu,           std::vector< tk::real >,
     124                 :            :   tag::yield_stress, std::vector< tk::real >,
     125                 :            :   tag::cv,           std::vector< tk::real >,
     126                 :            :   tag::k,            std::vector< tk::real >
     127                 :            : > >;
     128                 :            : 
     129                 :            : // Boundary conditions block
     130                 :            : using bcList = tk::TaggedTuple< brigand::list<
     131                 :            :   tag::mesh,           std::vector< std::size_t >,
     132                 :            :   tag::dirichlet,      std::vector< std::size_t >,
     133                 :            :   tag::symmetry,       std::vector< std::size_t >,
     134                 :            :   tag::inlet,          std::vector< std::size_t >,
     135                 :            :   tag::outlet,         std::vector< std::size_t >,
     136                 :            :   tag::farfield,       std::vector< std::size_t >,
     137                 :            :   tag::extrapolate,    std::vector< std::size_t >,
     138                 :            :   tag::noslipwall,     std::vector< std::size_t >,
     139                 :            :   tag::stag_point,     std::vector< tk::real >,
     140                 :            :   tag::radius,         tk::real,
     141                 :            :   tag::velocity,       std::vector< tk::real >,
     142                 :            :   tag::pressure,       tk::real,
     143                 :            :   tag::density,        tk::real,
     144                 :            :   tag::temperature,    tk::real,
     145                 :            :   tag::mass_fractions, std::vector< tk::real >,
     146                 :            :   tag::materialid,     std::size_t,
     147                 :            :   tag::timedep,        std::vector<
     148                 :            :     tk::TaggedTuple< brigand::list<
     149                 :            :       tag::sideset,    std::vector< uint64_t >,
     150                 :            :       tag::fn,         std::vector< tk::real >
     151                 :            :     > >
     152                 :            :   >
     153                 :            : > >;
     154                 :            : 
     155                 :            : // IC box
     156                 :            : using boxList = tk::TaggedTuple< brigand::list<
     157                 :            :   tag::materialid,     std::size_t,
     158                 :            :   tag::volume,         tk::real,
     159                 :            :   tag::mass,           tk::real,
     160                 :            :   tag::density,        tk::real,
     161                 :            :   tag::velocity,       std::vector< tk::real >,
     162                 :            :   tag::pressure,       tk::real,
     163                 :            :   tag::energy,         tk::real,
     164                 :            :   tag::energy_content, tk::real,
     165                 :            :   tag::temperature,    tk::real,
     166                 :            :   tag::mass_fractions, std::vector< tk::real >,
     167                 :            :   tag::xmin,           tk::real,
     168                 :            :   tag::xmax,           tk::real,
     169                 :            :   tag::ymin,           tk::real,
     170                 :            :   tag::ymax,           tk::real,
     171                 :            :   tag::zmin,           tk::real,
     172                 :            :   tag::zmax,           tk::real,
     173                 :            :   tag::orientation,    std::vector< tk::real >,
     174                 :            :   tag::initiate,       inciter::ctr::InitiateType,
     175                 :            :   tag::point,          std::vector< tk::real >,
     176                 :            :   tag::init_time,      tk::real,
     177                 :            :   tag::front_width,    tk::real,
     178                 :            :   tag::front_speed,    tk::real
     179                 :            : > >;
     180                 :            : 
     181                 :            : // IC meshblock
     182                 :            : using meshblockList = tk::TaggedTuple< brigand::list<
     183                 :            :   tag::blockid,        std::uint64_t,
     184                 :            :   tag::materialid,     std::size_t,
     185                 :            :   tag::volume,         tk::real,
     186                 :            :   tag::mass,           tk::real,
     187                 :            :   tag::density,        tk::real,
     188                 :            :   tag::velocity,       std::vector< tk::real >,
     189                 :            :   tag::pressure,       tk::real,
     190                 :            :   tag::energy,         tk::real,
     191                 :            :   tag::energy_content, tk::real,
     192                 :            :   tag::temperature,    tk::real,
     193                 :            :   tag::mass_fractions, std::vector< tk::real >,
     194                 :            :   tag::initiate,       inciter::ctr::InitiateType,
     195                 :            :   tag::point,          std::vector< tk::real >,
     196                 :            :   tag::init_time,      tk::real,
     197                 :            :   tag::front_width,    tk::real,
     198                 :            :   tag::front_speed,    tk::real
     199                 :            : > >;
     200                 :            : 
     201                 :            : // Initial conditions (ic) block
     202                 :            : using icList = tk::TaggedTuple< brigand::list<
     203                 :            :   tag::materialid,     std::size_t,
     204                 :            :   tag::pressure,       tk::real,
     205                 :            :   tag::temperature,    tk::real,
     206                 :            :   tag::mass_fractions, std::vector< tk::real >,
     207                 :            :   tag::density,        tk::real,
     208                 :            :   tag::energy,         tk::real,
     209                 :            :   tag::velocity,       std::vector< tk::real >,
     210                 :            :   tag::box,            std::vector< boxList >,
     211                 :            :   tag::meshblock,      std::vector< meshblockList >
     212                 :            : > >;
     213                 :            : 
     214                 :            : // Overset mesh block
     215                 :            : using meshList = tk::TaggedTuple< brigand::list<
     216                 :            :   tag::filename,    std::string,
     217                 :            :   tag::location,    std::vector< tk::real >,
     218                 :            :   tag::orientation, std::vector< tk::real >,
     219                 :            :   tag::velocity,    std::vector< tk::real >
     220                 :            : > >;
     221                 :            : 
     222                 :            : // Field output block
     223                 :            : using fieldOutputList = tk::TaggedTuple< brigand::list<
     224                 :            :   tag::interval, uint32_t,
     225                 :            :   tag::time_interval, tk::real,
     226                 :            :   tag::time_range,    std::vector< tk::real >,
     227                 :            :   tag::refined,       bool,
     228                 :            :   tag::filetype,      tk::ctr::FieldFileType,
     229                 :            :   tag::sideset,       std::vector< uint64_t >,
     230                 :            :   tag::outvar,        std::vector< OutVar >,
     231                 :            :   tag::elemalias,     std::vector< std::string >,  // only for error checking
     232                 :            :   tag::elemvar,       std::vector< std::string >,  // only for error checking
     233                 :            :   tag::nodealias,     std::vector< std::string >,  // only for error checking
     234                 :            :   tag::nodevar,       std::vector< std::string >   // only for error checking
     235                 :            : > >;
     236                 :            : 
     237                 :            : // Diagnostics block
     238                 :            : using diagnosticsList = tk::TaggedTuple< brigand::list<
     239                 :            :   tag::interval, uint32_t,
     240                 :            :   tag::error,         tk::ctr::ErrorType,
     241                 :            :   tag::format,        tk::ctr::TxtFloatFormatType,
     242                 :            :   tag::precision,     std::streamsize
     243                 :            : > >;
     244                 :            : 
     245                 :            : // History output block
     246                 :            : using historyOutputList = tk::TaggedTuple< brigand::list<
     247                 :            :   tag::interval, uint32_t,
     248                 :            :   tag::time_interval, tk::real,
     249                 :            :   tag::time_range,    std::vector< tk::real >,
     250                 :            :   tag::format,        tk::ctr::TxtFloatFormatType,
     251                 :            :   tag::precision,     std::streamsize,
     252                 :            :   tag::point,         std::vector<
     253                 :            :     tk::TaggedTuple< brigand::list<
     254                 :            :       tag::id,    std::string,
     255                 :            :       tag::coord, std::vector< tk::real >
     256                 :            :     > >
     257                 :            :   >
     258                 :            : > >;
     259                 :            : 
     260                 :            : using ConfigMembers = brigand::list<
     261                 :            : 
     262                 :            :   tag::title, std::string,
     263                 :            : 
     264                 :            :   // Command line parameters
     265                 :            :   tag::cmd, CmdLine,
     266                 :            : 
     267                 :            :   // time stepping options
     268                 :            :   tag::nstep,            uint64_t,
     269                 :            :   tag::term,             tk::real,
     270                 :            :   tag::t0,               tk::real,
     271                 :            :   tag::dt,               tk::real,
     272                 :            :   tag::cfl,              tk::real,
     273                 :            :   tag::ttyi,             uint32_t,
     274                 :            :   tag::imex_runge_kutta, uint32_t,
     275                 :            :   tag::imex_maxiter,     uint32_t,
     276                 :            :   tag::imex_reltol,      tk::real,
     277                 :            :   tag::imex_abstol,      tk::real,
     278                 :            : 
     279                 :            :   // steady-state solver options
     280                 :            :   tag::steady_state, bool,
     281                 :            :   tag::residual,     tk::real,
     282                 :            :   tag::rescomp,      uint32_t,
     283                 :            : 
     284                 :            :   // mesh partitioning and reordering/sorting choices
     285                 :            :   tag::partitioning,     tk::ctr::PartitioningAlgorithmType,
     286                 :            :   tag::pelocal_reorder,  bool,
     287                 :            :   tag::operator_reorder, bool,
     288                 :            : 
     289                 :            :   // discretization scheme choices
     290                 :            :   tag::scheme,      SchemeType,
     291                 :            :   tag::ndof,        std::size_t,
     292                 :            :   tag::rdof,        std::size_t,
     293                 :            :   tag::flux,        FluxType,
     294                 :            :   tag::lowspeed_kp, tk::real,
     295                 :            : 
     296                 :            :   // limiter options
     297                 :            :   tag::limiter,              LimiterType,
     298                 :            :   tag::cweight,              tk::real,
     299                 :            :   tag::shock_detector_coeff, tk::real,
     300                 :            :   tag::accuracy_test,        bool,
     301                 :            :   tag::limsol_projection,    bool,
     302                 :            : 
     303                 :            :   // PDE options
     304                 :            :   tag::ncomp,        std::size_t,
     305                 :            :   tag::pde,          PDEType,
     306                 :            :   tag::transport,    transportList,
     307                 :            :   tag::compflow,     compflowList,
     308                 :            :   tag::multimat,     multimatList,
     309                 :            :   tag::multispecies, multispeciesList,
     310                 :            : 
     311                 :            :   // Dependent variable name
     312                 :            :   tag::depvar, std::vector< char >,
     313                 :            : 
     314                 :            :   tag::sys, std::map< std::size_t, std::size_t >,
     315                 :            : 
     316                 :            :   tag::material, std::vector< materialList >,
     317                 :            : 
     318                 :            :   tag::matidxmap, tk::TaggedTuple< brigand::list<
     319                 :            :     tag::eosidx, std::vector< std::size_t >,
     320                 :            :     tag::matidx, std::vector< std::size_t >,
     321                 :            :     tag::solidx, std::vector< std::size_t >
     322                 :            :   > >,
     323                 :            : 
     324                 :            :   // Conditions
     325                 :            :   tag::bc, std::vector< bcList >,
     326                 :            :   tag::ic, icList,
     327                 :            :   tag::mesh, std::vector< meshList >,
     328                 :            :   tag::transfer, std::vector< Transfer >,
     329                 :            : 
     330                 :            :   // ALE block
     331                 :            :   // ---------------------------------------------------------------------------
     332                 :            :   tag::ale, tk::TaggedTuple< brigand::list<
     333                 :            :     tag::ale,           bool,
     334                 :            :     tag::smoother,      MeshVelocitySmootherType,
     335                 :            :     tag::mesh_velocity, MeshVelocityType,
     336                 :            :     tag::mesh_motion,   std::vector< std::size_t >,
     337                 :            :     tag::meshforce,     std::vector< tk::real >,
     338                 :            :     tag::dvcfl,         tk::real,
     339                 :            :     tag::vortmult,      tk::real,
     340                 :            :     tag::maxit,         std::size_t,
     341                 :            :     tag::tolerance,     tk::real,
     342                 :            :     tag::dirichlet,     std::vector< std::size_t >,
     343                 :            :     tag::symmetry,      std::vector< std::size_t >,
     344                 :            :     tag::move,          std::vector<
     345                 :            :       tk::TaggedTuple< brigand::list<
     346                 :            :         tag::sideset, std::vector< uint64_t >,
     347                 :            :         tag::fntype,  tk::ctr::UserTableType,
     348                 :            :         tag::fn,      std::vector< tk::real >
     349                 :            :       > >
     350                 :            :     >
     351                 :            :   > >,
     352                 :            : 
     353                 :            :   // p-refinement block
     354                 :            :   // ---------------------------------------------------------------------------
     355                 :            :   tag::pref, tk::TaggedTuple< brigand::list<
     356                 :            :     tag::pref,      bool,
     357                 :            :     tag::indicator, PrefIndicatorType,
     358                 :            :     tag::ndofmax,   std::size_t,
     359                 :            :     tag::tolref,    tk::real
     360                 :            :   > >,
     361                 :            : 
     362                 :            :   // AMR block
     363                 :            :   // ---------------------------------------------------------------------------
     364                 :            :   tag::amr, tk::TaggedTuple< brigand::list<
     365                 :            :     tag::amr,           bool,
     366                 :            :     tag::t0ref,         bool,
     367                 :            :     tag::dtref,         bool,
     368                 :            :     tag::dtref_uniform, bool,
     369                 :            :     tag::dtfreq,        std::size_t,
     370                 :            :     tag::maxlevels,     std::size_t,
     371                 :            :     tag::initial,       std::vector< AMRInitialType >,
     372                 :            :     tag::edgelist,      std::vector< std::size_t >,
     373                 :            :     tag::coords,        tk::TaggedTuple< brigand::list<
     374                 :            :       tag::xminus, tk::real,
     375                 :            :       tag::xplus,  tk::real,
     376                 :            :       tag::yminus, tk::real,
     377                 :            :       tag::yplus,  tk::real,
     378                 :            :       tag::zminus, tk::real,
     379                 :            :       tag::zplus,  tk::real
     380                 :            :     > >,
     381                 :            :     tag::error,         AMRErrorType,
     382                 :            :     tag::refvar,        std::vector< char >,
     383                 :            :     tag::tol_refine,    tk::real,
     384                 :            :     tag::tol_derefine,  tk::real
     385                 :            :   > >,
     386                 :            : 
     387                 :            :   // Output options
     388                 :            :   tag::field_output,   fieldOutputList,
     389                 :            :   tag::diagnostics,    diagnosticsList,
     390                 :            :   tag::history_output, historyOutputList
     391                 :            : >;
     392                 :            : 
     393                 :            : // Class storing the Config params
     394                 :        189 : class InputDeck : public tk::TaggedTuple< ConfigMembers > {
     395                 :            : 
     396                 :            :   public:
     397                 :            :     //! Set of tags to ignore when printing this InputDeck
     398                 :            :     using ignore = CmdLine::ignore;
     399                 :            : 
     400                 :            :     //! \brief Constructor: set defaults
     401                 :            :     //! \param[in] cl Previously parsed and store command line
     402                 :            :     //! \details Anything not set here is initialized by the compiler using the
     403                 :            :     //!   default constructor for the corresponding type.
     404                 :       1333 :     explicit InputDeck( const CmdLine& cl = {} ) {
     405                 :            :       // Set previously parsed command line
     406                 :            :       get< tag::cmd >() = cl;
     407                 :            :       // Default time stepping params
     408                 :       1333 :       get< tag::dt >() = 0.0;
     409                 :       1333 :       get< tag::cfl >() = 0.0;
     410                 :            :       // Default AMR settings
     411                 :            :       auto rmax =
     412                 :            :         std::numeric_limits< tk::real >::max() / 100;
     413                 :       1333 :       get< tag::amr, tag::coords, tag::xminus >() = rmax;
     414                 :       1333 :       get< tag::amr, tag::coords, tag::xplus >() = -rmax;
     415                 :       1333 :       get< tag::amr, tag::coords, tag::yminus >() = rmax;
     416                 :       1333 :       get< tag::amr, tag::coords, tag::yplus >() = -rmax;
     417                 :       1333 :       get< tag::amr, tag::coords, tag::zminus >() = rmax;
     418         [ +  - ]:       1333 :       get< tag::amr, tag::coords, tag::zplus >() = -rmax;
     419                 :            : 
     420                 :            :       // -----------------------------------------------------------------------
     421                 :            :       /*
     422                 :            :                                   Keyword vector
     423                 :            :          The following code generates a vector of keywords, for the sole purpose
     424                 :            :          of documentation and user-help (accessible via the --helpctr and
     425                 :            :          --helpkw cmdline arguments. If entries for a keyword are not added to
     426                 :            :          this vector, help will not be output for it. The entries follow the
     427                 :            :          function signature of the tk::entry_t constructor (defined in
     428                 :            :          Base/Types.hpp).
     429                 :            :       */
     430                 :            :       // -----------------------------------------------------------------------
     431                 :            :       std::set< tk::entry_t > keywords;
     432                 :            : 
     433                 :            :       keywords.insert({"inciter",
     434                 :            :         "Start configuration block for inciter",
     435                 :            :         R"(This keyword is used to select inciter. Inciter, is a continuum-realm
     436                 :            :         shock hydrodynamics tool, solving a system of PDEs. The entire control
     437 [ +  - ][ +  - ]:       5332 :         file must be enclosed within the inciter block)", "block-title"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     438                 :            : 
     439                 :            :       keywords.insert({"title", "Title", R"(The title may be specified in
     440 [ +  - ][ +  - ]:       3999 :         the input file. It is optional.)", "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ -  + ]
         [ -  + ][ -  - ]
     441                 :            : 
     442                 :            :       // -----------------------------------------------------------------------
     443                 :            :       // time stepping options
     444                 :            :       // -----------------------------------------------------------------------
     445                 :            : 
     446                 :            :       keywords.insert({"nstep", "Set number of time steps to take",
     447                 :            :         R"(This keyword is used to specify the number of time steps to take in a
     448                 :            :         simulation. The number of time steps are used in conjunction with the
     449                 :            :         maximmum time specified by keyword 'term': the simulation stops whichever
     450                 :            :         is reached first. Both 'nstep' and 'term' can be left unspecified, in
     451 [ +  - ][ +  - ]:       5332 :         which case their default values are used. See also 'term'.)", "uint"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     452                 :            : 
     453                 :            :       keywords.insert({"term", "Set maximum physical time to simulate",
     454                 :            :         R"(This keyword is used to specify the termination time in a simulation.
     455                 :            :         The termination time and number of time steps, specified by 'nstep', are
     456                 :            :         used in conjunction to determine when to stop a simulation: whichever is
     457                 :            :         reached first. Both 'nstep' and 'term' can be left unspecified, in which
     458 [ +  - ][ +  - ]:       5332 :         case their default values are used. See also 'nstep'.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     459                 :            : 
     460                 :            :       keywords.insert({"t0", "Set starting non-dimensional time",
     461                 :            :         R"(This keyword is used to specify the starting time in a simulation.)",
     462 [ +  - ][ +  - ]:       5332 :         "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     463                 :            : 
     464                 :            :       keywords.insert({"dt", "Select constant time step size",
     465                 :            :         R"(This keyword is used to specify the time step size that used as a
     466                 :            :         constant during simulation. Setting 'cfl' and 'dt' are mutually
     467 [ +  - ][ +  - ]:       5332 :         exclusive. If both 'cfl' and 'dt' are set, 'dt' wins.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     468                 :            : 
     469                 :            :       keywords.insert({"cfl",
     470                 :            :       "Set the Courant-Friedrichs-Lewy (CFL) coefficient",
     471                 :            :       R"(This keyword is used to specify the CFL coefficient for
     472                 :            :       variable-time-step-size simulations. Setting 'cfl' and 'dt' are mutually
     473 [ +  - ][ +  - ]:       5332 :       exclusive. If both 'cfl' and 'dt' are set, 'dt' wins.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     474                 :            : 
     475                 :            :       keywords.insert({"ttyi", "Set screen output interval",
     476                 :            :         R"(This keyword is used to specify the interval in time steps for screen
     477 [ +  - ][ +  - ]:       5332 :         output during a simulation.)", "uint"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     478                 :            : 
     479                 :            :       keywords.insert({"imex_runge_kutta",
     480                 :            :         "Toggle use of IMplicit-EXplicit Runge-Kutta scheme",
     481                 :            :         R"(This keywords is used to turn IMEX integrator on/off for solid materials
     482                 :            :         in a multimat run. Plastic terms are integrated implicitly in time. This
     483                 :            :         flag will activate an Implicit-Explicit Runge-Kutta scheme to replace the
     484                 :            :         explicit one that is usually used. Scheme taken from Cavaglieri, D., &
     485                 :            :         Bewley, T. (2015). Low-storage implicit/explicit Runge–Kutta schemes for
     486                 :            :         the simulation of stiff high-dimensional ODE systems. Journal of
     487 [ +  - ][ +  - ]:       5332 :         Computational Physics, 286, 172-193.)", "uint 0/1"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ +  - ][ -  - ]
     488                 :            : 
     489                 :            :       keywords.insert({"imex_maxiter",
     490                 :            :         "Set maximum number of iterations for non-linear solver with IMEX-RK scheme",
     491                 :            :         R"(This keywords is used to specify the maximum number of iterations that
     492                 :            :         the non-linear solver uses to obtain the implicit unknowns within the
     493 [ +  - ][ +  - ]:       5332 :         Implicit-Explicit Runge-Kutta scheme.)", "uint"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     494                 :            : 
     495                 :            :       keywords.insert({"imex_reltol",
     496                 :            :         "Set relative tolerance for non-linear solver with IMEX-RK scheme",
     497                 :            :         R"(This keywords is used to specify the relative tolerance that
     498                 :            :         the non-linear solver uses to obtain the implicit unknowns within the
     499 [ +  - ][ +  - ]:       5332 :         Implicit-Explicit Runge-Kutta scheme.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     500                 :            : 
     501                 :            :       keywords.insert({"imex_abstol",
     502                 :            :         "Set absolute tolerance for non-linear solver with IMEX-RK scheme",
     503                 :            :         R"(This keywords is used to specify the absolute tolerance that
     504                 :            :         the non-linear solver uses to obtain the implicit unknowns within the
     505 [ +  - ][ +  - ]:       5332 :         Implicit-Explicit Runge-Kutta scheme.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     506                 :            : 
     507                 :            :       // -----------------------------------------------------------------------
     508                 :            :       // steady-state solver options
     509                 :            :       // -----------------------------------------------------------------------
     510                 :            : 
     511                 :            :       keywords.insert({"steady_state", "March to steady state",
     512                 :            :         R"(This keyword is used indicate that local time stepping should be used
     513 [ +  - ][ +  - ]:       5332 :         to march towards a stationary solution.)", "bool"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     514                 :            : 
     515                 :            :       keywords.insert({"residual",
     516                 :            :         "Set the convergence criterion for the residual to reach",
     517                 :            :         R"(This keyword is used to specify a convergence criterion for the local
     518                 :            :         time stepping marching to steady state, below which the simulation is
     519 [ +  - ][ +  - ]:       5332 :         considered converged.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     520                 :            : 
     521                 :            :       keywords.insert({"rescomp",
     522                 :            :         "Equation system component index for convergence",
     523                 :            :         R"(This keyword is used to specify a single integer that is used to denote
     524                 :            :         the equation component index in the complete system of equations
     525                 :            :         configured, to use for the convergence criterion for local
     526 [ +  - ][ +  - ]:       5332 :         time stepping marching towards steady state.)", "uint"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     527                 :            : 
     528                 :            :       // -----------------------------------------------------------------------
     529                 :            :       // mesh partitioning and reordering/sorting choices
     530                 :            :       // -----------------------------------------------------------------------
     531                 :            : 
     532                 :            :       keywords.insert({"partitioning",
     533                 :            :         "Select mesh partitioning algorithm",
     534                 :            :         R"(This keyword is used to select a mesh partitioning algorithm. See
     535                 :            :         Control/Options/PartitioningAlgorithm.hpp for valid options.)",
     536 [ +  - ][ +  - ]:       5332 :         "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     537                 :            : 
     538                 :            :       keywords.insert({"rcb",
     539                 :            :         "Select recursive coordinate bisection mesh partitioner",
     540                 :            :         R"(This keyword is used to select the recursive coordinate bisection (RCB)
     541                 :            :         mesh partitioner. RCB is a geometry-based partitioner used to distribute
     542                 :            :         an input mesh among processing elements. See
     543 [ +  - ][ +  - ]:       5332 :         Control/Options/PartitioningAlgorithm.hpp for other valid options.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     544                 :            : 
     545                 :            :       keywords.insert({"rib",
     546                 :            :         "Select recursive inertial bisection mesh partitioner",
     547                 :            :         R"(This keyword is used to select the recursive inertial bisection (RIB)
     548                 :            :         mesh partitioner. RIB is a geometry-based partitioner used to distribute
     549                 :            :         an input mesh among processing elements. See
     550 [ +  - ][ +  - ]:       5332 :         Control/Options/PartitioningAlgorithm.hpp for other valid options.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     551                 :            : 
     552                 :            :       keywords.insert({"hsfc",
     553                 :            :         "Select Hilbert Space Filling Curve (HSFC) mesh partitioner",
     554                 :            :         R"(This keyword is used to select the Hilbert Space Filling Curve (HSFC)
     555                 :            :         mesh partitioner. HSFC is a geometry-based partitioner used to distribute
     556                 :            :         an input mesh among processing elements. See
     557 [ +  - ][ +  - ]:       5332 :         Control/Options/PartitioningAlgorithm.hpp for other valid options.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     558                 :            : 
     559                 :            :       keywords.insert({"phg",
     560                 :            :         "Select parallel hypergraph mesh partitioner",
     561                 :            :         R"(This keyword is used to select the parallel hypergraph (PHG)
     562                 :            :         mesh partitioner. PHG is a graph-based partitioner used to distribute an
     563                 :            :         input mesh among processing elements. See
     564 [ +  - ][ +  - ]:       5332 :         Control/Options/PartitioningAlgorithm.hpp for other valid options.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     565                 :            : 
     566                 :            :       keywords.insert({"mj",
     567                 :            :         "Select multi-jagged (MJ) mesh partitioner",
     568                 :            :         R"(This keyword is used to select the multi-jagged (MJ) mesh partitioner.
     569                 :            :         MJ is a geometry-based partitioner used to distribute an input mesh among
     570                 :            :         processing elements. See
     571 [ +  - ][ +  - ]:       5332 :         Control/Options/PartitioningAlgorithm.hpp for other valid options.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     572                 :            : 
     573                 :            :       keywords.insert({"pelocal_reorder",
     574                 :            :         "PE-local reorder",
     575                 :            :         R"(This keyword is used in inciter as a keyword in the inciter...end block
     576                 :            :         as "pelocal_reorder true" (or false) to do (or not do) a global
     577                 :            :         distributed mesh reordering across all PEs that yields an approximately
     578                 :            :         continuous mesh node ID order as mesh partitions are assigned to PEs after
     579 [ +  - ][ +  - ]:       5332 :         mesh partitioning. This reordering is optional.)", "bool"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     580                 :            : 
     581                 :            :       keywords.insert({"operator_reorder",
     582                 :            :         "Operator-access reorder",
     583                 :            :         R"(This keyword is used in inciter as a keyword in the inciter...end block
     584                 :            :         as "operator_reorder on" (or off) to do (or not do) a local mesh node
     585                 :            :         reordering based on the PDE operator access pattern. This reordering is
     586 [ +  - ][ +  - ]:       5332 :         optional.)", "bool"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ +  - ][ -  - ]
     587                 :            : 
     588                 :            :       // -----------------------------------------------------------------------
     589                 :            :       // discretization scheme choices
     590                 :            :       // -----------------------------------------------------------------------
     591                 :            : 
     592                 :            :       keywords.insert({"scheme", "Select discretization scheme",
     593                 :            :         R"(This keyword is used to select a spatial discretization scheme,
     594                 :            :         necessarily connected to the temporal discretization scheme. See
     595 [ +  - ][ +  - ]:       5332 :         Control/Inciter/Options/Scheme.hpp for valid options.)", "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     596                 :            : 
     597                 :            :       keywords.insert({"alecg",
     598                 :            :         "Select continuous Galerkin with ALE + Runge-Kutta",
     599                 :            :         R"(This keyword is used to select the continuous Galerkin finite element
     600                 :            :         scheme in the arbitrary Lagrangian-Eulerian (ALE) reference frame combined
     601                 :            :         with Runge-Kutta (RK) time stepping.
     602 [ +  - ][ +  - ]:       5332 :         See Control/Inciter/Options/Scheme.hpp for other valid options.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     603                 :            : 
     604                 :            :       keywords.insert({"oversetfe",
     605                 :            :         "Select continuous Galerkin finite element with overset meshes + "
     606                 :            :         "Runge-Kutta",
     607                 :            :         R"(This keyword is used to select the continuous Galerkin finite element
     608                 :            :         scheme with Runge-Kutta (RK) time stepping, combined with overset grids.
     609 [ +  - ][ +  - ]:       5332 :         See Control/Inciter/Options/Scheme.hpp for other valid options.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     610                 :            : 
     611                 :            :       keywords.insert({"dg",
     612                 :            :         "Select 1st-order discontinuous Galerkin discretization + Runge-Kutta",
     613                 :            :         R"(This keyword is used to select the first-order accurate discontinuous
     614                 :            :         Galerkin, DG(P0), spatial discretiztaion used in Inciter. As this is first
     615                 :            :         order accurate, it is intended for testing and debugging purposes only.
     616                 :            :         Selecting this spatial discretization also selects the Runge-Kutta scheme
     617                 :            :         for time discretization. See Control/Inciter/Options/Scheme.hpp for other
     618 [ +  - ][ +  - ]:       5332 :         valid options.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     619                 :            : 
     620                 :            :       keywords.insert({"p0p1",
     621                 :            :         "Select 2nd-order finite volume discretization + Runge-Kutta",
     622                 :            :         R"(This keyword is used to select the second-order accurate finite volume,
     623                 :            :         P0P1, spatial discretiztaion used in Inciter. This method uses a
     624                 :            :         least-squares procedure to reconstruct the second-order solution from the
     625                 :            :         first-order one. Selecting this spatial discretization also selects the
     626                 :            :         Runge-Kutta scheme for time discretization.
     627 [ +  - ][ +  - ]:       5332 :         See Control/Inciter/Options/Scheme.hpp for other valid options.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     628                 :            : 
     629                 :            :       keywords.insert({"dgp1",
     630                 :            :         "Select 2nd-order discontinuous Galerkin discretization + Runge-Kutta",
     631                 :            :         R"(This keyword is used to select the second-order accurate discontinuous
     632                 :            :         Galerkin, DG(P1), spatial discretiztaion used in Inciter. Selecting this
     633                 :            :         spatial discretization also selects the Runge-Kutta scheme for time
     634                 :            :         discretization. See Control/Inciter/Options/Scheme.hpp for other
     635 [ +  - ][ +  - ]:       5332 :         valid options.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     636                 :            : 
     637                 :            :       keywords.insert({"dgp2",
     638                 :            :         "Select 3nd-order discontinuous Galerkin discretization + Runge-Kutta",
     639                 :            :         R"(This keyword is used to select the third-order accurate discontinuous
     640                 :            :         Galerkin, DG(P2), spatial discretiztaion used in Inciter. Selecting this
     641                 :            :         spatial discretization also selects the Runge-Kutta scheme for time
     642                 :            :         discretization. See Control/Inciter/Options/Scheme.hpp for other
     643 [ +  - ][ +  - ]:       5332 :         valid options.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     644                 :            : 
     645                 :            :       keywords.insert({"pdg",
     646                 :            :         "Select p-adaptive discontinuous Galerkin discretization + Runge-Kutta",
     647                 :            :         R"(This keyword is used to select the polynomial adaptive discontinuous
     648                 :            :         Galerkin spatial discretizaion used in Inciter. Selecting this spatial
     649                 :            :         discretization also selects the Runge-Kutta scheme for time
     650                 :            :         discretization. See Control/Inciter/Options/Scheme.hpp for other valid
     651 [ +  - ][ +  - ]:       5332 :         options.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     652                 :            : 
     653                 :            :       keywords.insert({"fv",
     654                 :            :         "Select 2nd-order finite volume discretization + Runge-Kutta",
     655                 :            :         R"(This keyword is used to select the second-order accurate finite volume,
     656                 :            :         P0P1, spatial discretiztaion used in Inciter. This method uses a
     657                 :            :         least-squares procedure to reconstruct the second-order solution from the
     658                 :            :         first-order one. See Control/Inciter/Options/Scheme.hpp for other valid
     659 [ +  - ][ +  - ]:       5332 :         options.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     660                 :            : 
     661                 :            :       keywords.insert({"ndof", "Number of evolved solution DOFs",
     662 [ +  - ][ +  - ]:       5332 :         R"(The number of solution DOFs that are evolved.)", "uint"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     663                 :            : 
     664                 :            :       keywords.insert({"rdof", "Total number of solution DOFs",
     665                 :            :         R"(The total number of solution DOFs, including the reconstructed and the
     666 [ +  - ][ +  - ]:       5332 :         evolved ones.)", "uint"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     667                 :            : 
     668                 :            :       // -----------------------------------------------------------------------
     669                 :            :       // limiter options
     670                 :            :       // -----------------------------------------------------------------------
     671                 :            : 
     672                 :            :       keywords.insert({"limiter", "Select limiter function",
     673                 :            :         R"(This keyword is used to select a limiter function, used for
     674                 :            :         discontinuous Galerkin (DG) spatial discretization used in inciter. See
     675 [ +  - ][ +  - ]:       5332 :         Control/Inciter/Options/Limiter.hpp for valid options.)", "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     676                 :            : 
     677                 :            :       keywords.insert({"nolimiter", "No limiter used",
     678                 :            :         R"(This keyword is used for discontinuous Galerkin (DG) spatial
     679                 :            :         discretization without any limiter in inciter. See
     680 [ +  - ][ +  - ]:       3999 :         Control/Inciter/Options/Limiter.hpp for other valid options.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ -  + ]
         [ -  + ][ -  - ]
     681                 :            : 
     682                 :            :       keywords.insert({"wenop1",
     683                 :            :         "Select the Weighted Essentially Non-Oscillatory (WENO) limiter for DGP1",
     684                 :            :         R"(This keyword is used to select the Weighted Essentially Non-Oscillatory
     685                 :            :         limiter used for discontinuous Galerkin (DG) P1 spatial discretization
     686                 :            :         used in inciter. See Control/Inciter/Options/Limiter.hpp for other valid
     687 [ +  - ][ +  - ]:       5332 :         options.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     688                 :            : 
     689                 :            :       keywords.insert({"cweight",
     690                 :            :         "Set value for central linear weight used by WENO, cweight",
     691                 :            :         R"(This keyword is used to set the central linear weight used for the
     692                 :            :         central stencil in the Weighted Essentially Non-Oscillatory (WENO) limiter
     693 [ +  - ][ +  - ]:       5332 :         for discontinuous Galerkin (DG) methods.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     694                 :            : 
     695                 :            :       keywords.insert({"superbeep1",
     696                 :            :         "Select the Superbee limiter for DGP1",
     697                 :            :         R"(This keyword is used to select the Superbee limiter used for
     698                 :            :         discontinuous Galerkin (DG) P1 spatial discretization used in inciter.
     699 [ +  - ][ +  - ]:       5332 :         See Control/Inciter/Options/Limiter.hpp for other valid options.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     700                 :            : 
     701                 :            :       keywords.insert({"shock_detector_coeff",
     702                 :            :         "Configure the coefficient used in shock indicator",
     703                 :            :         R"(This keyword can be used to configure the coefficient used in the
     704 [ +  - ][ +  - ]:       5332 :         threshold calculation for the shock indicator.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ +  - ][ -  - ]
     705                 :            : 
     706                 :            :       keywords.insert({"vertexbasedp1",
     707                 :            :         "Select the vertex-based limiter for DGP1",
     708                 :            :         R"(This keyword is used to select the vertex-based limiter used for
     709                 :            :         discontinuous Galerkin (DG) P1 spatial discretization used in inciter.
     710                 :            :         Ref. Kuzmin, D. (2010). A vertex-based hierarchical slope limiter for
     711                 :            :         p-adaptive discontinuous Galerkin methods. Journal of computational and
     712                 :            :         applied mathematics, 233(12), 3077-3085.
     713 [ +  - ][ +  - ]:       5332 :         See Control/Inciter/Options/Limiter.hpp for other valid options.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     714                 :            : 
     715                 :            :       keywords.insert({"accuracy_test", "Toggle accuracy test setup",
     716                 :            :         R"(This keyword is used to specify if the current setup is for an
     717                 :            :         order-of-accuracy testing, used for discontinuous Galerkin (DG) spatial
     718                 :            :         discretization in inciter. This deactivates certain robustness corrections
     719                 :            :         which might impact order-of-accuracy. Only intended for simple test
     720 [ +  - ][ +  - ]:       5332 :         problems and not for real problems.)", "bool"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     721                 :            : 
     722                 :            :       keywords.insert({"limsol_projection",
     723                 :            :         "Toggle limited solution projection",
     724                 :            :         R"(This keyword is used to specify limited solution projection.
     725                 :            :         This is used for discontinuous Galerkin (DG) spatial discretization in
     726                 :            :         inciter, for multi-material hydrodynamics. This uses a projection to
     727                 :            :         obtain bulk momentum and material energies from the limited primitive
     728                 :            :         quantities. This step is essential to obtain closure-law obeying limited
     729                 :            :         quantities. See Pandare et al. (2023). On the Design of Stable,
     730                 :            :         Consistent, and Conservative High-Order Methods for Multi-Material
     731 [ +  - ][ +  - ]:       5332 :         Hydrodynamics. J Comp Phys (490).)", "bool"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ +  - ][ -  - ]
     732                 :            : 
     733                 :            :       // -----------------------------------------------------------------------
     734                 :            :       // flux options
     735                 :            :       // -----------------------------------------------------------------------
     736                 :            : 
     737                 :            :       keywords.insert({"flux", "Select flux function",
     738                 :            :         R"(This keyword is used to select a flux function, used for
     739                 :            :         discontinuous Galerkin (DG) spatial discretization used in inciter. See
     740 [ +  - ][ +  - ]:       5332 :         Control/Inciter/Options/Flux.hpp for valid options.)", "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     741                 :            : 
     742                 :            :       keywords.insert({"laxfriedrichs",
     743                 :            :         "Select Lax-Friedrichs flux function",
     744                 :            :         R"(This keyword is used to select the Lax-Friedrichs flux function used
     745                 :            :         for discontinuous Galerkin (DG) spatial discretization used in inciter.
     746 [ +  - ][ +  - ]:       5332 :         See Control/Inciter/Options/Flux.hpp for other valid options.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     747                 :            : 
     748                 :            :       keywords.insert({"hllc",
     749                 :            :         "Select the Harten-Lax-van Leer-Contact (HLLC) flux function",
     750                 :            :         R"(This keyword is used to select the Harten-Lax-van Leer-Contact flux
     751                 :            :         function used for discontinuous Galerkin (DG) spatial discretization
     752                 :            :         used in inciter. See Control/Inciter/Options/Flux.hpp for other valid
     753 [ +  - ][ +  - ]:       5332 :         options.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     754                 :            : 
     755                 :            :       keywords.insert({"upwind", "Select the upwind flux function",
     756                 :            :         R"(This keyword is used to select the upwind flux
     757                 :            :         function used for discontinuous Galerkin (DG) spatial discretization
     758                 :            :         used in inciter. It is only usable for scalar transport.
     759 [ +  - ][ +  - ]:       5332 :         See Control/Inciter/Options/Flux.hpp for other valid options.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     760                 :            : 
     761                 :            :       keywords.insert({"ausm",
     762                 :            :         "Select the Advection Upstream Splitting Method (AUSM) flux function",
     763                 :            :         R"(This keyword is used to select the AUSM flux
     764                 :            :         function used for discontinuous Galerkin (DG) spatial discretization
     765                 :            :         used in inciter. It is only set up for for multi-material hydro, and
     766 [ +  - ][ +  - ]:       5332 :         not selectable for anything else.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     767                 :            : 
     768                 :            :       keywords.insert({"ldfss",
     769                 :            :         "Select the Low Diffusion Flux Splitting Scheme (LDFSS)",
     770                 :            :         R"(This keyword is used to select the LDFSS flux
     771                 :            :         function used for discontinuous Galerkin (DG) spatial discretization
     772                 :            :         used in inciter. It is only set up for for multi-material hydro, and
     773 [ +  - ][ +  - ]:       5332 :         not selectable for anything else.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     774                 :            : 
     775                 :            :       keywords.insert({"lowspeed_kp",
     776                 :            :         "Select the low-speed coefficient K_p in the AUSM+up flux function",
     777                 :            :         R"(This keyword is used to select the low-speed coefficient K_p in the
     778                 :            :         AUSM+up flux function used for the DG or FV spatial discretization for
     779                 :            :         multi-material hydro, and not used for anything else. The default
     780                 :            :         value is 0, and recommended value for low speed flows (Mach < 0.1) is
     781 [ +  - ][ +  - ]:       5332 :         1.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     782                 :            : 
     783                 :            :       keywords.insert({"hll",
     784                 :            :         "Select the Harten-Lax-vanLeer (HLL) flux function",
     785                 :            :         R"(This keyword is used to select the HLL flux
     786                 :            :         function used for discontinuous Galerkin (DG) spatial discretization
     787                 :            :         used in inciter. It is only set up for for multi-material hydro, and
     788 [ +  - ][ +  - ]:       5332 :         not selectable for anything else.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     789                 :            : 
     790                 :            :       // -----------------------------------------------------------------------
     791                 :            :       // PDE keywords
     792                 :            :       // -----------------------------------------------------------------------
     793                 :            : 
     794                 :            :       keywords.insert({"problem",
     795                 :            :         "Specify problem configuration for partial differential equation solver",
     796                 :            :         R"(This keyword is used to specify the problem configuration for the
     797 [ +  - ][ +  - ]:       5332 :         partial differential equation solver.)", "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     798                 :            : 
     799                 :            :       keywords.insert({"transport",
     800                 :            :         "Start configuration block for an transport equation",
     801                 :            :         R"(This keyword is used to introduce a transport block, used to
     802                 :            :         specify the configuration for a transport equation type.)",
     803 [ +  - ][ +  - ]:       5332 :         "block-title"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     804                 :            : 
     805                 :            :       keywords.insert({"ncomp",
     806                 :            :         "Set number of scalar components for a system of transport equations",
     807                 :            :         R"(This keyword is used to specify the number of scalar
     808 [ +  - ][ +  - ]:       5332 :         components of transport (linear advection) equations.)", "uint"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     809                 :            : 
     810                 :            :       keywords.insert({"compflow",
     811                 :            :         "Start configuration block for the compressible flow equations",
     812                 :            :         R"(This keyword is used to introduce the compflow block, used to
     813                 :            :         specify the configuration for a system of partial differential equations,
     814 [ +  - ][ +  - ]:       5332 :         governing single material compressible fluid flow.)", "block-title"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     815                 :            : 
     816                 :            :       keywords.insert({"multimat",
     817                 :            :         "Start configuration block for the compressible multi-material equations",
     818                 :            :         R"(This keyword is used to introduce the multimat block,
     819                 :            :         used to specify the configuration for a system of partial differential
     820                 :            :         equations, governing compressible multi-material hydrodynamics assuming
     821 [ +  - ][ +  - ]:       5332 :         velocity equilibrium (single velocity).)", "block-title"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     822                 :            : 
     823                 :            :       keywords.insert({"multispecies",
     824                 :            :         "Start configuration block for the compressible multi-species equations",
     825                 :            :         R"(This keyword is used to introduce the multispecies block,
     826                 :            :         used to specify the configuration for a system of partial differential
     827                 :            :         equations, governing compressible multi-species fluid dynamics.)",
     828 [ +  - ][ +  - ]:       5332 :         "block-title"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     829                 :            : 
     830                 :            :       keywords.insert({"nmat",
     831                 :            :         "Set number of materials for the multi-material system",
     832                 :            :         R"(This keyword is used to specify the number of materials for
     833 [ +  - ][ +  - ]:       5332 :         multi-material flow, see also the keyword 'multimat'.)", "uint"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     834                 :            : 
     835                 :            :       keywords.insert({"nspec",
     836                 :            :         "Set number of species for the multi-species system",
     837                 :            :         R"(This keyword is used to specify the number of species for
     838 [ +  - ][ +  - ]:       5332 :         multi-species flow, see also the keyword 'multispecies'.)", "uint"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     839                 :            : 
     840                 :            :       keywords.insert({"prelax",
     841                 :            :         "Toggle multi-material finite pressure relaxation",
     842                 :            :         R"(This keyword is used to turn finite pressure relaxation between
     843                 :            :         multiple materials on/off. It is used only for the multi-material solver,
     844 [ +  - ][ +  - ]:       5332 :         and has no effect when used for the other PDE types.)", "uint 0/1"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     845                 :            : 
     846                 :            :       keywords.insert({"prelax_timescale",
     847                 :            :         "Time-scale for multi-material finite pressure relaxation",
     848                 :            :         R"(This keyword is used to specify the time-scale at which finite pressure
     849                 :            :         relaxation between multiple materials occurs. The default value of 0.25
     850                 :            :         corresponds to a relaxation time that is 4 times the time required for a
     851                 :            :         sound wave to pass through a computational element. It is used only for
     852 [ +  - ][ +  - ]:       5332 :         multimat, and has no effect for the other PDE types.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ +  - ][ -  - ]
     853                 :            : 
     854                 :            :       keywords.insert({"intsharp",
     855                 :            :         "Toggle multi-material interface sharpening",
     856                 :            :         R"(This keyword is used to turn interface sharpening on/off. It uses the
     857                 :            :         multi-material THINC interface reconstruction.
     858                 :            :         Ref. Pandare A. K., Waltz J., & Bakosi J. (2021) Multi-Material
     859                 :            :         Hydrodynamics with Algebraic Sharp Interface Capturing. Computers &
     860                 :            :         Fluids, doi: https://doi.org/10.1016/j.compfluid.2020.104804. It is used
     861                 :            :         for the multi-material and the transport solver, and has no effect when
     862 [ +  - ][ +  - ]:       5332 :         used for the other PDE types.)", "uint 0/1"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     863                 :            : 
     864                 :            :       keywords.insert({"intsharp_param",
     865                 :            :         "Parameter for multi-material interface sharpening",
     866                 :            :         R"(This keyword is used to specify the parameter for the interface
     867                 :            :         sharpening. This parameter affects how many cells the material interfaces
     868                 :            :         span, after the use of sharpening. It is used for multimat and transport,
     869 [ +  - ][ +  - ]:       5332 :         and has no effect for the other PDE types.)", "real" });
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     870                 :            : 
     871                 :            :       keywords.insert({"rho0constraint",
     872                 :            :         "Toggle the density constraint correction",
     873                 :            :         R"(This keyword is used to toggle the density constraint in solid
     874                 :            :         dynamics on/off. It is used only for the multi-material solver in the
     875 [ +  - ][ +  - ]:       5332 :         presence of solids. The default is 1 (on).)", "uint 0/1"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     876                 :            : 
     877                 :            :       keywords.insert({"dt_sos_massavg",
     878                 :            :         "Toggle method for calculating speed of sound used for time step in a cell",
     879                 :            :         R"(This keyword is used to specify the method to calculate the speed of
     880                 :            :         sound in a cell used for the time step. If set to 1, the speed of sound
     881                 :            :         will be calculated using the mass average, rather than the maximum value
     882                 :            :         across materials. It is used for multimat, and has no effect for the
     883 [ +  - ][ +  - ]:       5332 :         other PDE types.)", "uint 0/1" });
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     884                 :            : 
     885                 :            :       // Dependent variable name
     886                 :            :       keywords.insert({"depvar",
     887                 :            :         "Select dependent variable name for PDE.",
     888 [ +  - ][ +  - ]:       5332 :         R"(Select dependent variable name for PDE.)", "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     889                 :            : 
     890                 :            :       // -----------------------------------------------------------------------
     891                 :            :       // physics choices
     892                 :            :       // -----------------------------------------------------------------------
     893                 :            : 
     894                 :            :       keywords.insert({"physics",
     895                 :            :         "Specify the physics configuration for a system of PDEs",
     896                 :            :         R"(This keyword is used to select the physics configuration for a
     897                 :            :         particular PDE system. Valid options depend on the system of PDEs in
     898 [ +  - ][ +  - ]:       5332 :         which the keyword is used.)", "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     899                 :            : 
     900                 :            :       keywords.insert({"advection",
     901                 :            :         "Specify the advection physics",
     902                 :            :         R"(This keyword is used to select the advection physics for the transport
     903 [ +  - ][ +  - ]:       5332 :         PDE system. Only usable for 'transport'.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     904                 :            : 
     905                 :            :       keywords.insert({"advdiff",
     906                 :            :         "Specify the advection + diffusion physics",
     907                 :            :         R"(This keyword is used to select the advection + diffusion physics
     908 [ +  - ][ +  - ]:       5332 :         for transport PDEs. Only usable for 'transport'.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     909                 :            : 
     910                 :            :       keywords.insert({"euler",
     911                 :            :         "Specify the Euler (inviscid) compressible flow physics",
     912                 :            :         R"(This keyword is used to select the Euler (inviscid) compressible
     913 [ +  - ][ +  - ]:       5332 :         flow physics configuration. Usable for 'compflow' and 'multimat')"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     914                 :            : 
     915                 :            :       keywords.insert({"energy_pill",
     916                 :            :         "Specify the energy pill physics",
     917                 :            :         R"(This keyword is used to select an energy pill initialization as physics
     918                 :            :         configuration for multiple material compressible flow. Parameters for the
     919                 :            :         linearly traveling front are required to be specified when energy_pill is
     920                 :            :         selected. See 'linear' for more details. Currently setup only for
     921 [ +  - ][ +  - ]:       5332 :         'multimat')"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     922                 :            : 
     923                 :            :       // -----------------------------------------------------------------------
     924                 :            :       // material/eos object
     925                 :            :       // -----------------------------------------------------------------------
     926                 :            : 
     927                 :            :       keywords.insert({"material",
     928                 :            :         "Start configuration block for material (eos) properties",
     929                 :            :         R"(This keyword is used to introduce a material block, used to
     930 [ +  - ][ +  - ]:       6665 :         specify material properties.)", "vector block-title"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     931                 :            : 
     932                 :            :       keywords.insert({"id", "ID",
     933                 :            :         R"(This keyword is used to specify an ID, a positive integer. Usage is
     934                 :            :         context specific, i.e. what block it is specified in. E.g. Inside the
     935                 :            :         material block, it is used to specify a block consisting of IDs of
     936 [ +  - ][ +  - ]:       3999 :         materials of that EOS type)", "vector of uints"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ -  + ]
         [ -  + ][ -  - ]
     937                 :            : 
     938                 :            :       keywords.insert({"eos", "Select equation of state (type)",
     939                 :            :         R"(This keyword is used to select an equation of state for a material.)",
     940 [ +  - ][ +  - ]:       5332 :         "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     941                 :            : 
     942                 :            :       keywords.insert({"gamma", "ratio of specific heats",
     943                 :            :         R"(This keyword is used to specify the material property, ratio of
     944 [ +  - ][ +  - ]:       5332 :         specific heats.)", "vector of reals"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     945                 :            : 
     946                 :            :       keywords.insert({"pstiff", "EoS stiffness parameter",
     947                 :            :         R"(This keyword is used to specify the material property, stiffness
     948 [ +  - ][ +  - ]:       5332 :         parameter in the stiffened gas equation of state.)", "vector of reals"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     949                 :            : 
     950                 :            :       keywords.insert({"w_gru", "Grueneisen coefficient",
     951                 :            :         R"(This keyword is used to specify the material property, Gruneisen
     952                 :            :         coefficient for the Jones-Wilkins-Lee equation of state.)",
     953 [ +  - ][ +  - ]:       5332 :         "vector of reals"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     954                 :            : 
     955                 :            :       keywords.insert({"A_jwl", "JWL EoS A parameter",
     956                 :            :         R"(This keyword is used to specify the material property A (units: Pa)
     957 [ +  - ][ +  - ]:       5332 :         for the Jones-Wilkins-Lee equation of state.)", "vector of reals"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     958                 :            : 
     959                 :            :       keywords.insert({"B_jwl", "JWL EoS B parameter",
     960                 :            :         R"(This keyword is used to specify the material property B (units: Pa)
     961 [ +  - ][ +  - ]:       5332 :         for the Jones-Wilkins-Lee equation of state.)", "vector of reals"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     962                 :            : 
     963                 :            :       keywords.insert({"C_jwl", "JWL EoS C parameter",
     964                 :            :         R"(This keyword is used to specify the material property C (units: Pa)
     965 [ +  - ][ +  - ]:       5332 :         for the Jones-Wilkins-Lee equation of state.)", "vector of reals"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     966                 :            : 
     967                 :            :       keywords.insert({"R1_jwl", "JWL EoS R1 parameter",
     968                 :            :         R"(This keyword is used to specify the material property R1 for the
     969 [ +  - ][ +  - ]:       5332 :         Jones-Wilkins-Lee equation of state.)", "vector of reals"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     970                 :            : 
     971                 :            :       keywords.insert({"R2_jwl", "JWL EoS R2 parameter",
     972                 :            :         R"(This keyword is used to specify the material property R2 for the
     973 [ +  - ][ +  - ]:       5332 :         Jones-Wilkins-Lee equation of state.)", "vector of reals"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     974                 :            : 
     975                 :            :       keywords.insert({"rho0_jwl", "JWL EoS rho0 parameter",
     976                 :            :         R"(This keyword is used to specify the material property rho0, which is
     977                 :            :         the density of initial state (units: kg/m3) for the Jones-Wilkins-Lee
     978 [ +  - ][ +  - ]:       5332 :         equation of state.)", "vector of reals"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     979                 :            : 
     980                 :            :       keywords.insert({"de_jwl", "JWL EoS de parameter",
     981                 :            :         R"(This keyword is used to specify the material property de, which is the
     982                 :            :         heat of detonation for products; and for reactants, it is chosen such that
     983                 :            :         the ambient internal energy (e0) is 0 (units: J/kg). Used for the
     984 [ +  - ][ +  - ]:       5332 :         Jones-Wilkins-Lee equation of state.)", "vector of reals"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     985                 :            : 
     986                 :            :       keywords.insert({"rhor_jwl", "JWL EoS rhor parameter",
     987                 :            :         R"(This keyword is used to specify the material property rhor, which is
     988                 :            :         the density of reference state (units: kg/m3) for the Jones-Wilkins-Lee
     989 [ +  - ][ +  - ]:       5332 :         equation of state.)", "vector of reals"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     990                 :            : 
     991                 :            :       keywords.insert({"Tr_jwl", "JWL EoS Tr parameter",
     992                 :            :         R"(This keyword is used to specify the material property Tr, which is the
     993                 :            :         temperature of reference state (units: K) for the Jones-Wilkins-Lee
     994 [ +  - ][ +  - ]:       5332 :         equation of state.)", "vector of reals"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
     995                 :            : 
     996                 :            :       keywords.insert({"Pr_jwl", "JWL EoS er parameter",
     997                 :            :         R"(This keyword is used to specify the material property Pr, which is the
     998                 :            :         pressure at the reference state (units: Pa) for the Jones-Wilkins-Lee
     999                 :            :         equation of state. It is used to calculate the reference temperature for
    1000 [ +  - ][ +  - ]:       5332 :         the EoS.)", "vector of reals"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1001                 :            : 
    1002                 :            :       keywords.insert({"mu", "shear modulus/dynamic viscosity",
    1003                 :            :         R"(This keyword is used to specify the material property, shear modulus
    1004 [ +  - ][ +  - ]:       5332 :         for solids, or dynamic viscosity for fluids.)", "vector of reals"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1005                 :            : 
    1006                 :            :       keywords.insert({"yield_stress", "Yield stress of solid material",
    1007                 :            :         R"(This keyword is used to specify the material property yield stress,
    1008                 :            :         which indicates the stress (units: Pa) after which the material begins
    1009 [ +  - ][ +  - ]:       5332 :         plastic flow.)", "vector of reals"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1010                 :            : 
    1011                 :            :       keywords.insert({"cv", "specific heat at constant volume",
    1012                 :            :         R"(This keyword is used to specify the material property, specific heat at
    1013 [ +  - ][ +  - ]:       5332 :         constant volume.)", "vector of reals"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1014                 :            : 
    1015                 :            :       keywords.insert({"k", "heat conductivity",
    1016                 :            :         R"(This keyword is used to specify the material property, heat
    1017 [ +  - ][ +  - ]:       5332 :         conductivity.)", "vector of reals"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1018                 :            : 
    1019                 :            :       keywords.insert({"stiffenedgas",
    1020                 :            :         "Select the stiffened gas equation of state",
    1021 [ +  - ][ +  - ]:       5332 :         R"(This keyword is used to select the stiffened gas equation of state.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1022                 :            : 
    1023                 :            :       keywords.insert({"jwl", "Select the JWL equation of state",
    1024                 :            :         R"(This keyword is used to select the Jones, Wilkins, Lee equation of
    1025 [ +  - ][ +  - ]:       5332 :         state.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1026                 :            : 
    1027                 :            :       keywords.insert({"smallshearsolid",
    1028                 :            :         "Select the SMALLSHEARSOLID equation of state",
    1029                 :            :         R"(This keyword is used to select the small shear strain equation of state
    1030                 :            :         for solids. This EOS uses a small-shear approximation for the elastic
    1031                 :            :         contribution, and a stiffened gas EOS for the hydrodynamic contribution of
    1032                 :            :         the internal energy See Plohr, J. N., & Plohr, B. J. (2005). Linearized
    1033                 :            :         analysis of Richtmyer–Meshkov flow for elastic materials. Journal of Fluid
    1034 [ +  - ][ +  - ]:       5332 :         Mechanics, 537, 55-89 for further details.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1035                 :            : 
    1036                 :            :       keywords.insert({"godunovromenski_aluminum",
    1037                 :            :         "Select the GODUNOVROMENSKIALUMINUM equation of state",
    1038                 :            :         R"(This keyword is used to select the Godunov-Romenski equation of
    1039                 :            :         state for solids and a hydro EoS for aluminum. These function were
    1040                 :            :         taken from Barton, Philip T. "An interface-capturing Godunov method
    1041                 :            :         for the simulation of compressible solid-fluid problems." Journal
    1042 [ +  - ][ +  - ]:       5332 :         of Computational Physics 390 (2019): 25-50.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ +  - ][ -  - ]
    1043                 :            : 
    1044                 :            :       keywords.insert({"matidxmap",
    1045                 :            :       "AUTO-GENERATED Material index map for EOS",
    1046                 :            :       R"(The following AUTO-GENERATED data structure is used to index into the
    1047                 :            :       correct material vector entry. This is done using the following three maps:
    1048                 :            :       1. eosidx: This vector provides the eos-index (value) in the
    1049                 :            :       vector<tag::material> for the given user-spec material id (index).
    1050                 :            :       2. matidx: This vector provides the material-index (value) inside the
    1051                 :            :       vector<tag::material>[eosidx] block for the given user-specified
    1052                 :            :       material id (index).
    1053                 :            :       3. solidx: This vector provides the solid-index (value) assigned to
    1054 [ +  - ][ +  - ]:       5332 :       the given user-specified material id (index). It is 0 for fluids.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1055                 :            : 
    1056                 :            :       // -----------------------------------------------------------------------
    1057                 :            :       // output object
    1058                 :            :       // -----------------------------------------------------------------------
    1059                 :            : 
    1060                 :            :       keywords.insert({"field_output",
    1061                 :            :         "Start of field_output input block",
    1062                 :            :         R"(This keyword is used to start a block in the input file containing the
    1063 [ +  - ][ +  - ]:       5332 :         list and settings of requested field output.)", "block-title"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1064                 :            : 
    1065                 :            :       keywords.insert({"interval",
    1066                 :            :         "Set interval (in units of iteration count)",
    1067                 :            :         R"(This keyword is used to specify an interval in units of iteration count
    1068                 :            :         (i.e., number of time steps). This must be used within a relevant
    1069 [ +  - ][ +  - ]:       5332 :         block.)", "uint"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1070                 :            : 
    1071                 :            :       keywords.insert({"time_interval",
    1072                 :            :         "Set interval (in units of physics time)",
    1073                 :            :         R"(This keyword is used to specify an interval in units of physics time.
    1074 [ +  - ][ +  - ]:       5332 :         This must be used within a relevant block.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1075                 :            : 
    1076                 :            :       keywords.insert({"time_range",
    1077                 :            :         "Configure physics time range for output (in units of physics time)",
    1078                 :            :         R"(This keyword is used to configure field-, or history-output, specifying
    1079                 :            :         a start time, a stop time, and an output frequency in physics time units.
    1080                 :            :         Example: 'time_range = {0.2, 0.3, 0.001}', which specifies that from t=0.2 to
    1081                 :            :         t=0.3 output should happen at physics time units of dt=0.001. This must be
    1082 [ +  - ][ +  - ]:       6665 :         used within a relevant block.)", "vector of 3 reals"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1083                 :            : 
    1084                 :            :       keywords.insert({"refined", "Toggle refined field output on/off",
    1085                 :            :         R"(This keyword can be used to turn on/off refined field output, which
    1086                 :            :         refines the mesh and evaluates the solution on the refined mesh for saving
    1087 [ +  - ][ +  - ]:       5332 :         the solution.)", "bool"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1088                 :            : 
    1089                 :            :       keywords.insert({"filetype", "Select output file type",
    1090                 :            :         R"(This keyword is used to specify the output file type of
    1091 [ +  - ][ +  - ]:       5332 :         mesh-based field output in a field_output block.)", "string" });
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1092                 :            : 
    1093                 :            :       keywords.insert({"elemvar",
    1094                 :            :         "Specify list of elem-centered variables for output",
    1095                 :            :         R"(This keyword is used to specify elem-centered variables for output to
    1096 [ +  - ][ +  - ]:       6665 :         file. It is used in field_output blocks.)", "vector of string"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1097                 :            : 
    1098                 :            :       keywords.insert({"nodevar",
    1099                 :            :         "Specify list of node-centered variables for output",
    1100                 :            :         R"(This keyword is used to specify node-centered variables for output to
    1101 [ +  - ][ +  - ]:       6665 :         file. It is used in field_output blocks.)", "vector of string"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1102                 :            : 
    1103                 :            :       keywords.insert({"sideset",
    1104                 :            :         "Specify list of side sets",
    1105                 :            :         R"(This keyword is used to specify side sets. Usage is context specific,
    1106                 :            :         i.e. depends on what block it is specified in. Eg. in the field_output
    1107                 :            :         block it specifies the sidesets on which field output is desired.)",
    1108 [ +  - ][ +  - ]:       5332 :         "vector of uints"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1109                 :            : 
    1110                 :            :       keywords.insert({"diagnostics",
    1111                 :            :         "Specify the diagnostics block",
    1112                 :            :         R"(This keyword is used to introduce the dagnostics block, used to
    1113 [ +  - ][ +  - ]:       5332 :         configure diagnostics output.)", "block-title"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1114                 :            : 
    1115                 :            :       keywords.insert({"interval",
    1116                 :            :         "Set interval (in units of iteration count)",
    1117                 :            :         R"(This keyword is used to specify an interval in units of iteration count
    1118                 :            :         (i.e., number of time steps). Usage is context specific, and this must
    1119 [ +  - ][ +  - ]:       5332 :         be used within a relevant block.)", "uint"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1120                 :            : 
    1121                 :            :       keywords.insert({"error", "Select an error type",
    1122                 :            :         R"(This keyword is used to select the error type. Used either in the
    1123                 :            :         diagnostics block to specify error norm, or in the AMR block to specify
    1124 [ +  - ][ +  - ]:       5332 :         the error for solution-adaptive mesh refinement.)", "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1125                 :            : 
    1126                 :            :       keywords.insert({"format",
    1127                 :            :         "Specify the ASCII floating-point output format",
    1128                 :            :         R"(This keyword is used to select the
    1129                 :            :         floating-point output format for ASCII floating-point number output.
    1130                 :            :         Valid options are 'default', 'fixed', and 'scientific'. For more info on
    1131                 :            :         these various formats, see
    1132 [ +  - ][ +  - ]:       5332 :         http://en.cppreference.com/w/cpp/io/manip/fixed.)", "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1133                 :            : 
    1134                 :            :       keywords.insert({"precision",
    1135                 :            :         "Precision in digits for ASCII floating-point output",
    1136                 :            :         R"(This keyword is used to select
    1137                 :            :         the precision in digits for ASCII floating-point real number output.
    1138                 :            :         Example: "precision=10", which selects ten digits for floating-point
    1139                 :            :         output, e.g., 3.141592654. The number of digits must be larger than zero
    1140                 :            :         and lower than the maximum representable digits for the given
    1141                 :            :         floating-point type. For more info on setting the precision in C++, see
    1142                 :            :         http://en.cppreference.com/w/cpp/io/manip/setprecision, and
    1143 [ +  - ][ +  - ]:       5332 :         http://en.cppreference.com/w/cpp/types/numeric_limits/digits10)", "uint"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1144                 :            : 
    1145                 :            :       keywords.insert({"history_output",
    1146                 :            :         "Start of history_output input block",
    1147                 :            :         R"(This keyword is used to start a block in the input file containing the
    1148 [ +  - ][ +  - ]:       5332 :         descriptions and settings of requested history output.)", "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1149                 :            : 
    1150                 :            :       keywords.insert({"point",
    1151                 :            :         "Start configuration block for history point, or a single point in IC blocks",
    1152                 :            :         R"(This keyword is used to either introduce a vector block used to
    1153                 :            :         specify probes for history output, or in the IC/BC block to specify
    1154                 :            :         a single point. When used in history output, it takes sub-entries of
    1155                 :            :         'id' and 'coord'. When used in IC/BC, directly takes three reals as
    1156 [ +  - ][ +  - ]:       6665 :         coordinates.)", "vector block-title"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1157                 :            : 
    1158                 :            :       keywords.insert({"coord", "Specify point coordinates",
    1159                 :            :         R"(This keyword is used to specify coordinates of the history-point.)",
    1160 [ +  - ][ +  - ]:       5332 :         "3 reals"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1161                 :            : 
    1162                 :            :       keywords.insert({"exodusii", "Select ExodusII output",
    1163                 :            :         R"(This keyword is used to select the
    1164                 :            :         ExodusII output file type readable by, e.g., ParaView of either a requested
    1165                 :            :         probability density function (PDF) within a pdfs ... end block or for
    1166                 :            :         mesh-based field output in a field_output ... end block. Example:
    1167                 :            :         "filetype exodusii", which selects ExodusII file output. For more info on
    1168 [ +  - ][ +  - ]:       5332 :         ExodusII, see http://sourceforge.net/projects/exodusii.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1169                 :            : 
    1170                 :            :       keywords.insert({"density", "Request/specify density",
    1171                 :            :         R"(This keyword is used to request/specify the density. Usage is
    1172                 :            :         context specific. When specifed as 'elemvar' or 'nodevar' inside
    1173                 :            :         field_output, requests density as an output quantity. Otherwise,
    1174 [ +  - ][ +  - ]:       5332 :         specifies density at IC/BC.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1175                 :            : 
    1176                 :            :       keywords.insert({"x-momentum",
    1177                 :            :         "Request x-momentum",
    1178                 :            :         R"(This keyword is used to request the fluid x-momentum as an output
    1179 [ +  - ][ +  - ]:       5332 :         variable.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1180                 :            : 
    1181                 :            :       keywords.insert({"y-momentum",
    1182                 :            :         "Request y-momentum",
    1183                 :            :         R"(This keyword is used to request the fluid y-momentum as an output
    1184 [ +  - ][ +  - ]:       5332 :         variable.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1185                 :            : 
    1186                 :            :       keywords.insert({"z-momentum",
    1187                 :            :         "Request z-momentum",
    1188                 :            :         R"(This keyword is used to request the fluid z-momentum as an output
    1189 [ +  - ][ +  - ]:       5332 :         variable.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1190                 :            : 
    1191                 :            :       keywords.insert({
    1192                 :            :         "specific_total_energy", "Request specific total energy",
    1193                 :            :         R"(This keyword is used to request the specific total energy as an output
    1194 [ +  - ][ +  - ]:       5332 :         variable.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ +  - ][ -  - ]
    1195                 :            : 
    1196                 :            :       keywords.insert({
    1197                 :            :         "volumetric_total_energy", "Request total volumetric energy",
    1198                 :            :         R"(This keyword is used to request the volumetric total energy as an output
    1199 [ +  - ][ +  - ]:       5332 :         variable.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ +  - ][ -  - ]
    1200                 :            : 
    1201                 :            :       keywords.insert({"x-velocity",
    1202                 :            :         "Request x-velocity",
    1203                 :            :         R"(This keyword is used to request the fluid x-velocity as an output
    1204 [ +  - ][ +  - ]:       5332 :         variable.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1205                 :            : 
    1206                 :            :       keywords.insert({"y-velocity",
    1207                 :            :         "Request y-velocity",
    1208                 :            :         R"(This keyword is used to request the fluid y-velocity as an output
    1209 [ +  - ][ +  - ]:       5332 :         variable.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1210                 :            : 
    1211                 :            :       keywords.insert({"z-velocity",
    1212                 :            :         "Request z-velocity",
    1213                 :            :         R"(This keyword is used to request the fluid z-velocity as an output
    1214 [ +  - ][ +  - ]:       5332 :         variable.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1215                 :            : 
    1216                 :            :       keywords.insert({"pressure", "Request/specify pressure",
    1217                 :            :         R"(This keyword is used to request/specify the pressure. Usage is
    1218                 :            :         context specific. When specifed as 'elemvar' or 'nodevar' inside
    1219                 :            :         field_output, requests pressure as an output quantity. Otherwise,
    1220 [ +  - ][ +  - ]:       5332 :         specifies pressure at IC/BC.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1221                 :            : 
    1222                 :            :       keywords.insert({"material_indicator",
    1223                 :            :         "Request material_indicator",
    1224                 :            :         R"(This keyword is used to request the material indicator function as an
    1225 [ +  - ][ +  - ]:       5332 :         output variable.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ +  - ][ -  - ]
    1226                 :            : 
    1227                 :            :       keywords.insert({"analytic",
    1228                 :            :         "Request analytic solution",
    1229                 :            :         R"(This keyword is used to request the analytic solution (if exist) as an
    1230 [ +  - ][ +  - ]:       5332 :         output variable.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1231                 :            : 
    1232                 :            :       keywords.insert({"l2", "Select the L2 norm",
    1233 [ +  - ][ +  - ]:       5332 :         R"(This keyword is used to enable computing the L2 norm.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1234                 :            : 
    1235                 :            :       keywords.insert({"linf", "Select the L_{infinity} norm",
    1236 [ +  - ][ +  - ]:       5332 :         R"(This keyword is used to enable computing the L-infinity norm.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1237                 :            : 
    1238                 :            :       keywords.insert({"default",
    1239                 :            :         "Select the default ASCII floating-point output",
    1240                 :            :         R"(This keyword is used to select the
    1241                 :            :         'default' floating-point output format for ASCII floating-point real
    1242                 :            :         number output. For more info on these various formats, see
    1243 [ +  - ][ +  - ]:       5332 :         http://en.cppreference.com/w/cpp/io/manip/fixed.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1244                 :            : 
    1245                 :            :       keywords.insert({"fixed",
    1246                 :            :         "Select the fixed ASCII floating-point output",
    1247                 :            :         R"(This keyword is used to select the
    1248                 :            :         'fixed' floating-point output format for ASCII floating-point real
    1249                 :            :         number output. For more info on these various formats, see
    1250 [ +  - ][ +  - ]:       5332 :         http://en.cppreference.com/w/cpp/io/manip/fixed.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1251                 :            : 
    1252                 :            :       keywords.insert({"scientific",
    1253                 :            :         "Select the scientific ASCII floating-point output",
    1254                 :            :         R"(This keyword is used to select the
    1255                 :            :         'scientific' floating-point output format for ASCII floating-point real
    1256                 :            :         number output. For more info on these various formats, see
    1257 [ +  - ][ +  - ]:       5332 :         http://en.cppreference.com/w/cpp/io/manip/fixed.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1258                 :            : 
    1259                 :            :       // -----------------------------------------------------------------------
    1260                 :            :       // ALE options
    1261                 :            :       // -----------------------------------------------------------------------
    1262                 :            : 
    1263                 :            :       keywords.insert({"ale", "Start block configuring ALE",
    1264                 :            :         R"(This keyword is used to introduce the ale block, used to
    1265                 :            :         configure arbitrary Lagrangian-Eulerian (ALE) mesh movement.)",
    1266 [ +  - ][ +  - ]:       5332 :         "block-title"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1267                 :            : 
    1268                 :            :       keywords.insert({"smoother", "Select mesh velocity smoother",
    1269                 :            :         R"(This keyword is used to select a mesh velocity smoother option, used
    1270                 :            :         for Arbitrary-Lagrangian-Eulerian (ALE) mesh motion. Valid options are
    1271 [ +  - ][ +  - ]:       5332 :         'laplace', 'helmholtz', and 'none')", "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1272                 :            : 
    1273                 :            :       keywords.insert({"mesh_velocity", "Select mesh velocity",
    1274                 :            :         R"(This keyword is used to select a mesh velocity option, used for
    1275                 :            :         Arbitrary-Lagrangian-Eulerian (ALE) mesh motion. Valid options are
    1276 [ +  - ][ +  - ]:       5332 :         'sine', 'fluid', and 'user_defined".)", "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1277                 :            : 
    1278                 :            :       keywords.insert({"mesh_motion",
    1279                 :            :         "List of dimension indices that are allowed to move in ALE calculations",
    1280                 :            :         R"(This keyword is used to specify a list of integers (0, 1, or 2) whose
    1281                 :            :         coordinate directions corresponding to x, y, or z are allowed to move with
    1282                 :            :         the mesh velocity in ALE calculations. Useful for 1D/2D problems.)",
    1283 [ +  - ][ +  - ]:       5332 :         "vector of uints"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1284                 :            : 
    1285                 :            :       keywords.insert({"meshforce", "Set ALE mesh force model parameter(s)",
    1286                 :            :         R"(This keyword is used to specify a vector of real numbers used to
    1287                 :            :         parameterize a mesh force model for ALE. The length of the vector must
    1288 [ +  - ][ +  - ]:       6665 :         exactly be 4.)", "vector of 4 reals"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1289                 :            : 
    1290                 :            :       keywords.insert({"dvcfl",
    1291                 :            :         "Set the volume-change Courant-Friedrichs-Lewy (CFL) coefficient",
    1292                 :            :         R"(This keyword is used to specify the volume-change (dV/dt) CFL coefficient
    1293                 :            :         for variable-time-step-size simulations due to volume change in time in
    1294                 :            :         arbitrary-Lagrangian-Eulerian (ALE) calculations. Setting 'dvcfl' only has
    1295                 :            :         effect in ALE calculations and used together with 'cfl'. See also J. Waltz,
    1296                 :            :         N.R. Morgan, T.R. Canfield, M.R.J. Charest, L.D. Risinger, J.G. Wohlbier, A
    1297                 :            :         three-dimensional finite element arbitrary Lagrangian–Eulerian method for
    1298                 :            :         shock hydrodynamics on unstructured grids, Computers & Fluids, 92: 172-187,
    1299 [ +  - ][ +  - ]:       5332 :         2014.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1300                 :            : 
    1301                 :            :       keywords.insert({"vortmult",
    1302                 :            :         "Configure vorticity multiplier for ALE mesh velocity",
    1303                 :            :         R"(This keyword is used to configure the multiplier for the vorticity term
    1304                 :            :         in the mesh velocity smoother (mesh_velocity=fluid) or for the potential
    1305                 :            :         gradient for the Helmholtz mesh velocity (mesh_velocity=helmholtz) for ALE
    1306                 :            :         mesh motion. For 'fluid' this is coefficient c2 in Eq.(36) of Waltz,
    1307                 :            :         Morgan, Canfield, Charest, Risinger, Wohlbier, A three-dimensional finite
    1308                 :            :         element arbitrary Lagrangian–Eulerian method for shock hydrodynamics on
    1309                 :            :         unstructured grids, Computers & Fluids, 2014, and for 'helmholtz', this
    1310                 :            :         is coefficient a1 in Eq.(23) of Bakosi, Waltz, Morgan, Improved ALE mesh
    1311                 :            :         velocities for complex flows, International Journal for Numerical Methods
    1312 [ +  - ][ +  - ]:       5332 :         in Fluids, 2017. )", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1313                 :            : 
    1314                 :            :       keywords.insert({"maxit",
    1315                 :            :         "Set the max number of iterations for the ALE mesh velocity linear solve",
    1316                 :            :         R"(This keyword is used to specify the maximum number of linear solver
    1317                 :            :         iterations taken to converge the mesh velocity linear solve in
    1318                 :            :         arbitrary-Lagrangian-Eulerian (ALE) calculations. See also J. Waltz,
    1319                 :            :         N.R. Morgan, T.R. Canfield, M.R.J. Charest, L.D. Risinger, J.G. Wohlbier, A
    1320                 :            :         three-dimensional finite element arbitrary Lagrangian–Eulerian method for
    1321                 :            :         shock hydrodynamics on unstructured grids, Computers & Fluids, 92: 172-187,
    1322 [ +  - ][ +  - ]:       5332 :         2014.)", "uint"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1323                 :            : 
    1324                 :            :       keywords.insert({"tolerance",
    1325                 :            :         "Set the tolerance for the ALE mesh velocity linear solve",
    1326                 :            :         R"(This keyword is used to specify the tolerance to converge the mesh
    1327                 :            :         velocity linear solve for in
    1328                 :            :         arbitrary-Lagrangian-Eulerian (ALE) calculations. See also J. Waltz,
    1329                 :            :         N.R. Morgan, T.R. Canfield, M.R.J. Charest, L.D. Risinger, J.G. Wohlbier, A
    1330                 :            :         three-dimensional finite element arbitrary Lagrangian–Eulerian method for
    1331                 :            :         shock hydrodynamics on unstructured grids, Computers & Fluids, 92: 172-187,
    1332 [ +  - ][ +  - ]:       5332 :         2014.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1333                 :            : 
    1334                 :            :       keywords.insert({"move",
    1335                 :            :         "Start configuration block configuring surface movement in ALE",
    1336                 :            :         R"(This keyword is used to introduce a move block, used to
    1337 [ +  - ][ +  - ]:       6665 :         configure surface movement for ALE simulations.)", "vector block-title"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1338                 :            : 
    1339                 :            :       keywords.insert({"fntype",
    1340                 :            :         "Select how a user-defined function is interpreted",
    1341                 :            :         R"(This keyword is used to select how a user-defined function should be
    1342 [ +  - ][ +  - ]:       5332 :         interpreted.)", "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1343                 :            : 
    1344                 :            :       keywords.insert({"fn", "Specify a discrete user-defined function",
    1345                 :            :         R"(This keyword is used to specify a user-defined function block with
    1346                 :            :         discrete points, listed inside the fn block. Used in ale mesh motion and
    1347 [ +  - ][ +  - ]:       5332 :         time-dependent BC specification)", "reals" });
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1348                 :            : 
    1349                 :            :       keywords.insert({"laplace",
    1350                 :            :         "Select the Laplace mesh velocity smoother for ALE",
    1351                 :            :         R"(This keyword is used to select the 'Laplace' mesh velocity smoother
    1352 [ +  - ][ +  - ]:       5332 :         for Arbitrary-Lagrangian-Eulerian (ALE) mesh motion.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1353                 :            : 
    1354                 :            :       keywords.insert({"helmholtz",
    1355                 :            :         "Select the Helmholtz velocity for ALE",
    1356                 :            :         R"(This keyword is used to select the a velocity, computed from the
    1357                 :            :         Helmholtz-decomposition as the mesh velocity for
    1358                 :            :         Arbitrary-Lagrangian-Eulerian (ALE) mesh motion. See J. Bakosi, J. Waltz,
    1359                 :            :         N. Morgan, Improved ALE mesh velocities for complex flows, Int. J. Numer.
    1360 [ +  - ][ +  - ]:       5332 :         Meth. Fl., 1-10, 2017, https://doi.org/10.1002/fld.4403.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1361                 :            : 
    1362                 :            :       keywords.insert({"none", "Select none option",
    1363                 :            :         R"(This keyword is used to select the 'none' option from a list of
    1364 [ +  - ][ +  - ]:       5332 :         configuration options.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1365                 :            : 
    1366                 :            :       keywords.insert({"sine",
    1367                 :            :         "Prescribe sinusoidal mesh velocity for ALE",
    1368                 :            :         R"(This keyword is used to prescribe a sinusoidal mesh velocity
    1369 [ +  - ][ +  - ]:       5332 :         for Arbitrary-Lagrangian-Eulerian (ALE) mesh motion.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1370                 :            : 
    1371                 :            :       keywords.insert({"fluid", "Select the fluid velocity for ALE",
    1372                 :            :         R"(This keyword is used to select the 'fluid' velocity as the mesh velocity
    1373 [ +  - ][ +  - ]:       5332 :         for Arbitrary-Lagrangian-Eulerian (ALE) mesh motion.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1374                 :            : 
    1375                 :            :       // -----------------------------------------------------------------------
    1376                 :            :       // h/p adaptation objects
    1377                 :            :       // -----------------------------------------------------------------------
    1378                 :            : 
    1379                 :            :       keywords.insert({"amr",
    1380                 :            :         "Start configuration block configuring adaptive mesh refinement",
    1381                 :            :         R"(This keyword is used to introduce the amr block, used to
    1382 [ +  - ][ +  - ]:       5332 :         configure adaptive mesh refinement.)", "block-title"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1383                 :            : 
    1384                 :            :       keywords.insert({"t0ref", "Enable mesh refinement at t<0",
    1385                 :            :         R"(This keyword is used to enable initial mesh refinement, which can be
    1386                 :            :         configured to perform multiple levels of mesh refinement based on various
    1387 [ +  - ][ +  - ]:       5332 :         refinement criteria and configuration settings.)", "bool"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1388                 :            : 
    1389                 :            :       keywords.insert({"dtref", "Enable mesh refinement at t>0",
    1390                 :            :         R"(This keyword is used to enable solution-adaptive mesh refinement during
    1391 [ +  - ][ +  - ]:       5332 :         time stepping.)", "bool"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1392                 :            : 
    1393                 :            :       keywords.insert({"dtref_uniform",
    1394                 :            :         "Enable mesh refinement at t>0 but only perform uniform refinement",
    1395                 :            :         R"(This keyword is used to force uniform-only solution-adaptive mesh
    1396 [ +  - ][ +  - ]:       5332 :         refinement during time stepping.)", "bool"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1397                 :            : 
    1398                 :            :       keywords.insert({"dtfreq",
    1399                 :            :         "Set mesh refinement frequency during time stepping",
    1400                 :            :         R"(This keyword is used to configure the frequency of mesh refinement
    1401 [ +  - ][ +  - ]:       5332 :         during time stepping.)", "uint"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1402                 :            : 
    1403                 :            :       keywords.insert({"maxlevels",
    1404                 :            :         "Set maximum allowed mesh refinement levels",
    1405                 :            :         R"(This keyword is used to configure the maximum allowed mesh refinement
    1406 [ +  - ][ +  - ]:       5332 :         levels.)", "uint"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1407                 :            : 
    1408                 :            :       keywords.insert({"initial",
    1409                 :            :         "Configure initial mesh refinement (before time stepping)",
    1410                 :            :         R"(This keyword is used to add to a list of initial mesh refinement types
    1411                 :            :         that happens before t = 0. Allowed options are 'uniform',
    1412                 :            :         'uniform_derefine', 'initial_conditions', 'coords', 'edgelist')",
    1413 [ +  - ][ +  - ]:       6665 :         "vector of strings"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1414                 :            : 
    1415                 :            :       keywords.insert({"coords",
    1416                 :            :         "Configure initial refinement using coordinate planes",
    1417                 :            :         R"(This keyword can be used to configure entire volumes on a given side of
    1418                 :            :         a plane in 3D space. The keyword introduces an coords block within
    1419                 :            :         an amr block. All edges of the input mesh will be tagged for refinement
    1420                 :            :         whose end-points lie within the given ranges.
    1421                 :            :         Example: 'xminus 0.5' refines all edges whose end-point coordinates are
    1422                 :            :         less than 0.5. Multiple specifications are understood by combining with
    1423                 :            :         a logical AND. That is: 'xminus 0.5 yplus 0.3' refines all edges whose
    1424                 :            :         end-point x coordinates are less than 0.5 AND y coordinates are larger than
    1425 [ +  - ][ +  - ]:       5332 :         0.3.)", "block-title"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1426                 :            : 
    1427                 :            :       keywords.insert({"xminus",
    1428                 :            :         "Configure initial refinement for coordinates lower than an x-normal plane",
    1429                 :            :         R"(This keyword can be used to configure a mesh refinement volume for edges
    1430                 :            :         whose end-points are less than the x coordinate of a plane perpendicular
    1431                 :            :         to coordinate x in 3D space. The keyword must be used in a coords-block
    1432                 :            :         within an amr-block with syntax 'xminus <real>'. All edges of the
    1433                 :            :         input mesh will be tagged for refinement whose end-points lie less than (-)
    1434                 :            :         the real number given. Example: 'xminus 0.5' refines all edges whose end-point
    1435 [ +  - ][ +  - ]:       5332 :         x-coordinates are less than 0.5.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1436                 :            : 
    1437                 :            :       keywords.insert({"xplus",
    1438                 :            :         "Configure initial refinement for coordinates larger than an x-normal plane",
    1439                 :            :         R"(This keyword can be used to configure a mesh refinement volume for edges
    1440                 :            :         whose end-points are larger than the x coordinate of a plane perpendicular
    1441                 :            :         to coordinate x in 3D space. The keyword must be used in a coords-block
    1442                 :            :         within an amr-block with syntax 'xplus <real>'. All edges of the
    1443                 :            :         input mesh will be tagged for refinement whose end-points lie larger than
    1444                 :            :         (+) the real number given. Example: 'xplus 0.5' refines all edges whose
    1445 [ +  - ][ +  - ]:       5332 :         end-point coordinates are larger than 0.5.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1446                 :            : 
    1447                 :            :       keywords.insert({"yminus",
    1448                 :            :         "Configure initial refinement for coordinates lower than an y-normal plane",
    1449                 :            :         R"(This keyword can be used to configure a mesh refinement volume for edges
    1450                 :            :         whose end-points are less than the y coordinate of a plane perpendicular
    1451                 :            :         to coordinate y in 3D space. The keyword must be used in a coords-block
    1452                 :            :         within an amr-block with syntax 'yminus <real>'. All edges of the
    1453                 :            :         input mesh will be tagged for refinement whose end-points lie less than (-)
    1454                 :            :         the real number given. Example: 'yminus 0.5' refines all edges whose end-point
    1455 [ +  - ][ +  - ]:       5332 :         coordinates are less than 0.5.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1456                 :            : 
    1457                 :            :       keywords.insert({"yplus",
    1458                 :            :         "Configure initial refinement for coordinates larger than an y-normal plane",
    1459                 :            :         R"(This keyword can be used to configure a mesh refinement volume for edges
    1460                 :            :         whose end-points are larger than the y coordinate of a plane perpendicular
    1461                 :            :         to coordinate y in 3D space. The keyword must be used in a coords-block
    1462                 :            :         within an amr-block with syntax 'yplus <real>'. All edges of the
    1463                 :            :         input mesh will be tagged for refinement whose end-points lie larger than
    1464                 :            :         (+) the real number given. Example: 'yplus 0.5' refines all edges whose
    1465 [ +  - ][ +  - ]:       5332 :         end-point coordinates are larger than 0.5.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1466                 :            : 
    1467                 :            :       keywords.insert({"zminus",
    1468                 :            :         "Configure initial refinement for coordinates lower than an z-normal plane",
    1469                 :            :         R"(This keyword can be used to configure a mesh refinement volume for edges
    1470                 :            :         whose end-points are less than the z coordinate of a plane perpendicular
    1471                 :            :         to coordinate z in 3D space. The keyword must be used in a coords-block
    1472                 :            :         within an amr-block with syntax 'zminus <real>'. All edges of the
    1473                 :            :         input mesh will be tagged for refinement whose end-points lie less than (-)
    1474                 :            :         the real number given. Example: 'zminus 0.5' refines all edges whose end-point
    1475 [ +  - ][ +  - ]:       5332 :         coordinates are less than 0.5.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1476                 :            : 
    1477                 :            :       keywords.insert({"zplus",
    1478                 :            :         "Configure initial refinement for coordinates larger than an z-normal plane",
    1479                 :            :         R"(This keyword can be used to configure a mesh refinement volume for edges
    1480                 :            :         whose end-points are larger than the z coordinate of a plane perpendicular
    1481                 :            :         to coordinate z in 3D space. The keyword must be used in a coords-block
    1482                 :            :         within an amr-block with syntax 'zplus <real>'. All edges of the
    1483                 :            :         input mesh will be tagged for refinement whose end-points lie larger than
    1484                 :            :         (+) the real number given. Example: 'zplus 0.5' refines all edges whose
    1485 [ +  - ][ +  - ]:       5332 :         end-point coordinates are larger than 0.5.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1486                 :            : 
    1487                 :            :       keywords.insert({"edgelist",
    1488                 :            :         "Configure edge-node pairs for initial refinement",
    1489                 :            :         R"(This keyword can be used to configure a list of edges that are explicitly
    1490                 :            :         tagged for initial refinement during setup in inciter. The keyword
    1491                 :            :         introduces an edgelist block within an amr block and must
    1492                 :            :         contain a list of integer pairs, i.e., the number of ids must be even,
    1493                 :            :         denoting the end-points of the nodes (=edge) which should be tagged for
    1494 [ +  - ][ +  - ]:       5332 :         refinement.)", "vector of uints"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1495                 :            : 
    1496                 :            :       keywords.insert({"error",
    1497                 :            :         "Configure the error type for solution-adaptive mesh refinement",
    1498                 :            :         R"(This keyword is used to select the algorithm used to estimate the error
    1499                 :            :         for solution-adaptive mesh refinement. Available options are 'jump' and
    1500 [ +  - ][ +  - ]:       5332 :         'hessian')", "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1501                 :            : 
    1502                 :            :       keywords.insert({"refvar",
    1503                 :            :         "Configure dependent variables used for adaptive mesh refinement",
    1504                 :            :         R"(This keyword is used to configured a list of dependent variables that
    1505                 :            :         trigger adaptive mesh refinement based on estimating their numerical error.
    1506                 :            :         These refinement variables are used for both initial (i.e., before time
    1507                 :            :         stepping) mesh refinement as well as during time stepping. Only previously
    1508                 :            :         (i.e., earlier in the input file) selected dependent variables can be
    1509                 :            :         configured as refinement variables. Dependent variables are required to be
    1510                 :            :         defined in all equation system configuration blocks, e.g., transport ...
    1511                 :            :         end, by using the 'depvar' keyword. Example: transport depvar c end amr
    1512                 :            :         refvar c end end. Selecting a particular scalar component in a system is
    1513                 :            :         done by appending the equation number to the refvar: Example: transport
    1514                 :            :         depvar q ncomp 3 end amr refvar q1 q2 end end, which configures two
    1515                 :            :         refinement variables: the first and third scalar component of the previously
    1516 [ +  - ][ +  - ]:       5332 :         configured transport equation system.)", "vector of char"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1517                 :            : 
    1518                 :            :       keywords.insert({"tol_refine", "Configure refine tolerance",
    1519                 :            :         R"(This keyword is used to set the tolerance used to tag an edge for
    1520 [ +  - ][ +  - ]:       5332 :         refinement if the relative error exceeds this value.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1521                 :            : 
    1522                 :            :       keywords.insert({"tol_derefine",
    1523                 :            :         "Configure derefine tolerance",
    1524                 :            :         R"(This keyword is used to set the tolerance used to tag an edge for
    1525 [ +  - ][ +  - ]:       5332 :         derefinement if the relative error is below this value.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1526                 :            : 
    1527                 :            :       keywords.insert({"uniform",
    1528                 :            :         "Select uniform initial mesh refinement",
    1529                 :            :         R"(This keyword is used to select uniform initial mesh refinement.)",
    1530 [ +  - ][ +  - ]:       5332 :         "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1531                 :            : 
    1532                 :            :       keywords.insert({"uniform_derefine",
    1533                 :            :         "Select uniform initial mesh de-refinement",
    1534                 :            :         R"(This keyword is used to select uniform initial mesh de-refinement.)",
    1535 [ +  - ][ +  - ]:       5332 :         "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ +  - ][ -  - ]
    1536                 :            : 
    1537                 :            :       keywords.insert({"initial_conditions",
    1538                 :            :         "Select initial-conditions-based initial mesh refinement",
    1539                 :            :         R"(This keyword is used to select initial-conditions-based initial mesh
    1540 [ +  - ][ +  - ]:       5332 :         refinement.)", "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ +  - ][ -  - ]
    1541                 :            : 
    1542                 :            :       keywords.insert({"jump",
    1543                 :            :         "Error estimation based on the solution jump normalized by solution value",
    1544                 :            :         R"(This keyword is used to select the jump-based error indicator for
    1545                 :            :         solution-adaptive mesh refinement. The error is estimated by computing the
    1546                 :            :         magnitude of the jump in the solution value normalized by the solution
    1547 [ +  - ][ +  - ]:       5332 :         value.)", "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1548                 :            : 
    1549                 :            :       keywords.insert({"hessian",
    1550                 :            :         "Error estimation based on the Hessian normalized by solution value",
    1551                 :            :         R"(This keyword is used to select the Hessian-based error indicator for
    1552                 :            :         solution-adaptive mesh refinement. The error is estimated by computing the
    1553                 :            :         Hessian (2nd derivative matrix) of the solution normalized by sum of the
    1554 [ +  - ][ +  - ]:       5332 :         absolute values of the gradients at edges-end points.)", "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1555                 :            : 
    1556                 :            :       keywords.insert({"pref",
    1557                 :            :         "Start configuration block configuring p-adaptive refinement",
    1558                 :            :         R"(This keyword is used to introduce the pref block, to
    1559 [ +  - ][ +  - ]:       5332 :         configure p-adaptive refinement)", "block-title"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1560                 :            : 
    1561                 :            :       keywords.insert({"indicator",
    1562                 :            :         "Configure the specific adaptive indicator for p-adaptive DG scheme",
    1563                 :            :         R"(This keyword can be used to configure a specific type of adaptive
    1564                 :            :         indicator for p-adaptive refinement  of the DG scheme. The keyword must
    1565                 :            :         be used in a pref block. Available options are 'pref_spectral_decay' and
    1566 [ +  - ][ +  - ]:       5332 :         'pref_non_conformity'.)", "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1567                 :            : 
    1568                 :            :       keywords.insert({"ndofmax",
    1569                 :            :         "Configure the maximum number of degree of freedom for p-adaptive DG",
    1570                 :            :         R"(This keyword can be used to configure a maximum number of degree of
    1571                 :            :         freedom for p-adaptive refinement  of the DG scheme. The keyword must
    1572 [ +  - ][ +  - ]:       6665 :         be used in a pref block.)", "uint either 4 or 10"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1573                 :            : 
    1574                 :            :       keywords.insert({"tolref",
    1575                 :            :         "Configure the tolerance for p-refinement for p-adaptive DG",
    1576                 :            :         R"(This keyword can be used to configure a tolerance for p-adaptive
    1577                 :            :         refinement  for the DG scheme. The keyword must be used in a pref
    1578                 :            :         block. All elements with a refinement indicator larger than this
    1579 [ +  - ][ +  - ]:       6665 :         tolerance will be p-refined.)", "real between 0 and 1"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1580                 :            : 
    1581                 :            :       keywords.insert({"spectral_decay",
    1582                 :            :         "Select the spectral-decay indicator for p-adaptive DG scheme",
    1583                 :            :         R"(This keyword is used to select the spectral-decay indicator used for
    1584                 :            :         p-adaptive discontinuous Galerkin (DG) discretization used in inciter.
    1585                 :            :         See Control/Inciter/Options/PrefIndicator.hpp for other valid options.)",
    1586 [ +  - ][ +  - ]:       5332 :         "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1587                 :            : 
    1588                 :            :       keywords.insert({"non_conformity",
    1589                 :            :         "Select the non-conformity indicator for p-adaptive DG scheme",
    1590                 :            :         R"(This keyword is used to select the non-conformity indicator used for
    1591                 :            :         p-adaptive discontinuous Galerkin (DG) discretization used in inciter.
    1592                 :            :         See Control/Inciter/Options/PrefIndicator.hpp for other valid options.)",
    1593 [ +  - ][ +  - ]:       5332 :         "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1594                 :            : 
    1595                 :            :       // -----------------------------------------------------------------------
    1596                 :            :       // boundary condition options
    1597                 :            :       // -----------------------------------------------------------------------
    1598                 :            : 
    1599                 :            :       keywords.insert({"bc",
    1600                 :            :         "Start configuration block for boundary conditions",
    1601                 :            :         R"(This keyword is used to introduce the bc block, used for
    1602                 :            :         boundary conditions. This is a vector block, where each vector entry
    1603 [ +  - ][ +  - ]:       6665 :         specifies BCs for a particular mesh)", "vector block-title"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1604                 :            : 
    1605                 :            :       keywords.insert({"mesh",
    1606                 :            :         "List meshes on which the following BCs apply",
    1607                 :            :         R"(This keyword is used to list multiple meshes on which the boundary
    1608                 :            :         conditions listed in this particular bc-block apply.)",
    1609 [ +  - ][ +  - ]:       5332 :         "vector of uints"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1610                 :            : 
    1611                 :            :       keywords.insert({"dirichlet",
    1612                 :            :         "List sidesets with Dirichlet boundary conditions",
    1613                 :            :         R"(This keyword is used to list Dirichlet sidesets.
    1614                 :            :         This keyword is used to list multiple sidesets on
    1615                 :            :         which a prescribed Dirichlet BC is then applied. Such prescribed BCs
    1616                 :            :         at each point in space and time are evaluated using a built-in function,
    1617 [ +  - ][ +  - ]:       6665 :         e.g., using the method of manufactured solutions.)", "vector of uint(s)"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1618                 :            : 
    1619                 :            :       keywords.insert({"symmetry",
    1620                 :            :         "List sidesets with symmetry boundary conditions",
    1621                 :            :         R"(This keyword is used to list (multiple) symmetry BC sidesets.)",
    1622 [ +  - ][ +  - ]:       6665 :         "vector of uint(s)"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1623                 :            : 
    1624                 :            :       keywords.insert({"inlet",
    1625                 :            :         "List sidesets with inlet boundary conditions",
    1626                 :            :         R"(This keyword is used to list (multiple) inlet BC sidesets.)",
    1627 [ +  - ][ +  - ]:       6665 :         "vector of uint(s)"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1628                 :            : 
    1629                 :            :       keywords.insert({"outlet",
    1630                 :            :         "List sidesets with outlet boundary conditions",
    1631                 :            :         R"(This keyword is used to list (multiple) outlet BC sidesets.)",
    1632 [ +  - ][ +  - ]:       6665 :         "vector of uint(s)"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1633                 :            : 
    1634                 :            :       keywords.insert({"farfield",
    1635                 :            :         "List sidesets with farfield boundary conditions",
    1636                 :            :         R"(This keyword is used to list (multiple) farfield BC sidesets.
    1637                 :            :         Keywords allowed in a bc_farfield block are 'density', 'velocity',
    1638 [ +  - ][ +  - ]:       6665 :         'pressure')", "vector of uint(s)"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1639                 :            : 
    1640                 :            :       keywords.insert({"extrapolate",
    1641                 :            :         "List sidesets with Extrapolation boundary conditions",
    1642                 :            :         R"(This keyword is used to list (multiple) extrapolate BC sidesets.)",
    1643 [ +  - ][ +  - ]:       6665 :         "vector of uint(s)"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1644                 :            : 
    1645                 :            :       keywords.insert({"noslipwall",
    1646                 :            :         "List sidesets with no-slip wall boundary conditions",
    1647                 :            :         R"(This keyword is used to list (multiple) no-slip wall BC sidesets.)",
    1648 [ +  - ][ +  - ]:       6665 :         "vector of uint(s)"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1649                 :            : 
    1650                 :            :       keywords.insert({"stag",
    1651                 :            :         "List sidesets with stagnation boundary conditions",
    1652                 :            :         R"(This keyword is used to list (multiple) stagnation BC sidesets.)",
    1653 [ +  - ][ +  - ]:       6665 :         "vector of uint(s)"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1654                 :            : 
    1655                 :            :       keywords.insert({"timedep",
    1656                 :            :         "Start configuration block describing time dependent boundary conditions",
    1657                 :            :         R"(This keyword is used to introduce a bc_timedep block, used to
    1658                 :            :         specify the configuration of time dependent boundary conditions for a
    1659                 :            :         partial differential equation. A discrete function in time t in the form
    1660                 :            :         of a table with 6 columns (t, pressure(t), density(t), vx(t), vy(t), vz(t))
    1661                 :            :         is expected inside a fn ... end block, specified within the bc_timedep
    1662                 :            :         block. Multiple such bc_timedep blocks can be specified for different
    1663 [ +  - ][ +  - ]:       5332 :         time dependent BCs on different groups of side sets.)", "block-title"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1664                 :            : 
    1665                 :            :       keywords.insert({"radius", "Specify a radius",
    1666                 :            :         R"(This keyword is used to specify a radius, used, e.g., in specifying a
    1667                 :            :         point in 3D space for setting a stagnation (velocity vector = 0).)",
    1668 [ +  - ][ +  - ]:       5332 :         "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1669                 :            : 
    1670                 :            :       keywords.insert({"velocity", "Specify velocity",
    1671                 :            :         R"(This keyword is used to configure a velocity vector used in a
    1672                 :            :         context-specific way, e.g., for boundary or initial conditions, or
    1673 [ +  - ][ +  - ]:       6665 :         specifying overset mesh velocity.)", "vector of 3 reals"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1674                 :            : 
    1675                 :            :       // -----------------------------------------------------------------------
    1676                 :            :       // IC object
    1677                 :            :       // -----------------------------------------------------------------------
    1678                 :            : 
    1679                 :            :       keywords.insert({"ic",
    1680                 :            :         "Introduce an ic block used to configure initial conditions",
    1681                 :            :         R"(This keyword is used to introduce an ic block used to set initial
    1682 [ +  - ][ +  - ]:       5332 :         conditions.)", "block-title"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1683                 :            : 
    1684                 :            :       keywords.insert({"materialid", "Specify material id",
    1685                 :            :         R"(This keyword is used to configure the material id within an IC box,
    1686                 :            :         IC mesh-block, farfield BC, or in the background as a part of the
    1687 [ +  - ][ +  - ]:       5332 :         initialization.)", "uint"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1688                 :            : 
    1689                 :            :       keywords.insert({"temperature", "Specify temperature",
    1690                 :            :         R"(This keyword is used to configure temperature, used for, e.g.,
    1691 [ +  - ][ +  - ]:       5332 :         boundary or initial conditions.)" , "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1692                 :            : 
    1693                 :            :       keywords.insert({"mass_fractions", "Specify species mass fractions",
    1694                 :            :         R"(This keyword is used to configure species mass fractions, used for,
    1695 [ +  - ][ +  - ]:       5332 :         e.g., boundary or initial conditions.)" , "vector of reals"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1696                 :            : 
    1697                 :            :       keywords.insert({"box",
    1698                 :            :         "Introduce a box block used to assign initial conditions",
    1699                 :            :         R"(This keyword is used to introduce a IC box block used to assign
    1700                 :            :         initial conditions within a box given by spatial coordinates.)",
    1701 [ +  - ][ +  - ]:       6665 :         "vector block-title"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1702                 :            : 
    1703                 :            :       keywords.insert({"meshblock",
    1704                 :            :         "Introduce a meshblock block used to assign initial conditions",
    1705                 :            :         R"(This keyword is used to introduce a IC meshblock block used to
    1706                 :            :         assign initial conditions within a mesh block specified in the mesh file.)",
    1707 [ +  - ][ +  - ]:       6665 :         "vector block-title"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1708                 :            : 
    1709                 :            :       keywords.insert({"blockid", "Specify mesh block id",
    1710                 :            :         R"(This keyword is used to configure the mesh block id within the
    1711                 :            :         meshblock-block as a part of the initialization. It is strongly
    1712                 :            :         recommended to use contiguous block ids in mesh file starting from 1.)",
    1713 [ +  - ][ +  - ]:       5332 :         "uint"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1714                 :            : 
    1715                 :            :       keywords.insert({"volume", "Specify volume",
    1716                 :            :         R"(This keyword is used to configure the volume of a meshblock.)",
    1717 [ +  - ][ +  - ]:       3999 :         "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ -  + ]
         [ -  + ][ -  - ]
    1718                 :            : 
    1719                 :            :       keywords.insert({"mass", "Specify mass",
    1720                 :            :         R"(This keyword is used to configure the mass within a box/meshblock.)",
    1721 [ +  - ][ +  - ]:       3999 :         "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ -  + ]
         [ -  + ][ -  - ]
    1722                 :            : 
    1723                 :            :       keywords.insert({"energy", "Specify energy per unit mass",
    1724                 :            :         R"(This keyword is used to configure energy per unit mass, used for, e.g.,
    1725 [ +  - ][ +  - ]:       5332 :         boundary or initial conditions.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1726                 :            : 
    1727                 :            :       keywords.insert({"energy_content", "Specify energy per unit volume",
    1728                 :            :         R"(This keyword is used to configure energy per unit volume, used for
    1729 [ +  - ][ +  - ]:       5332 :         initial conditions.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1730                 :            : 
    1731                 :            :       keywords.insert({"xmin", "Minimum x coordinate",
    1732                 :            :         R"(This keyword used to configure a minimum x coordinate to specify
    1733 [ +  - ][ +  - ]:       5332 :         a box.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1734                 :            : 
    1735                 :            :       keywords.insert({"xmax", "Maximum x coordinate",
    1736                 :            :         R"(This keyword used to configure a maximum x coordinate to specify
    1737 [ +  - ][ +  - ]:       5332 :         a box.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1738                 :            : 
    1739                 :            :       keywords.insert({"ymin", "Minimum y coordinate",
    1740                 :            :         R"(This keyword used to configure a minimum y coordinate to specify
    1741 [ +  - ][ +  - ]:       5332 :         a box.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1742                 :            : 
    1743                 :            :       keywords.insert({"ymax", "Maximum y coordinate",
    1744                 :            :         R"(This keyword used to configure a maximum y coordinate to specify
    1745 [ +  - ][ +  - ]:       5332 :         a box.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1746                 :            : 
    1747                 :            :       keywords.insert({"zmin", "Minimum z coordinate",
    1748                 :            :         R"(This keyword used to configure a minimum z coordinate to specify
    1749 [ +  - ][ +  - ]:       5332 :         a box.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1750                 :            : 
    1751                 :            :       keywords.insert({"zmax", "Maximum z coordinate",
    1752                 :            :         R"(This keyword used to configure a maximum z coordinate to specify
    1753 [ +  - ][ +  - ]:       5332 :         a box.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1754                 :            : 
    1755                 :            :       keywords.insert({"orientation", "Configure orientation",
    1756                 :            :         R"(Configure orientation of an IC box for rotation about centroid of box.)",
    1757 [ +  - ][ +  - ]:       6665 :         "vector of 3 reals"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1758                 :            : 
    1759                 :            :       keywords.insert({"initiate", "Initiation type",
    1760                 :            :         R"(This keyword is used to select an initiation type to configure how
    1761                 :            :         values are assigned for a box/meshblock initialization. This can be used
    1762                 :            :         to specify, how the values are assigned to mesh nodes within a box. Uses:
    1763                 :            :         (1) impulse: assign the full values at t=0 for all points in a box,
    1764                 :            :         (2) linear: use a linear function in time and space, configured with an
    1765                 :            :         initiation point in space, a constant velocity of the growing spherical
    1766                 :            :         front in time (and space) linearly, and width of the front and assigns
    1767                 :            :         values to mesh points falling within the growing spherical shell inside
    1768 [ +  - ][ +  - ]:       3999 :         a configured box.)", "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ -  + ]
         [ -  + ][ -  - ]
    1769                 :            : 
    1770                 :            :       keywords.insert({"init_time","Specify the initialization time",
    1771                 :            :         R"(This keyword is used to specify the time at which the propagating front
    1772                 :            :         is initialized for a mesh block or box IC, with 'initiate linear' type.
    1773                 :            :         Delays in initializing separate mesh blocks or boxes can be achieved using
    1774 [ +  - ][ +  - ]:       5332 :         different initialization times.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1775                 :            : 
    1776                 :            :       keywords.insert({"front_width", "Specify a front width",
    1777                 :            :         R"(This keyword is used to specify the width of the propagating front for
    1778                 :            :         a mesh block or box IC, with 'initiate linear' type. The suggested value
    1779                 :            :         of the front width is about 4-5 times the mesh size inside the mesh block
    1780 [ +  - ][ +  - ]:       5332 :         or box.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1781                 :            : 
    1782                 :            :       keywords.insert({"front_speed", "Specify a front speed",
    1783                 :            :         R"(This keyword is used to specify the speed at which a front propagates
    1784 [ +  - ][ +  - ]:       5332 :         for a mesh block or box IC, with 'initiate linear' type.)", "real"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1785                 :            : 
    1786                 :            :       keywords.insert({"impulse",
    1787                 :            :         "Select the impulse initiation type, for a box/meshblock IC",
    1788                 :            :         R"(This keyword can be used to select the 'impulse' initiation/assignment
    1789                 :            :         type for box initial conditions. It simply assigns the prescribed values
    1790 [ +  - ][ +  - ]:       5332 :         to all mesh points within a configured box at t=0.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1791                 :            : 
    1792                 :            :       keywords.insert({"linear",
    1793                 :            :         "Select the linear initiation type, for a box/meshblock IC",
    1794                 :            :         R"(This keyword is be used to specify the 'linear' initiation parameters
    1795                 :            :         for a particular box or meshblock, as a part of the 'energy_pill'
    1796                 :            :         initialization. Linear initiation uses a linear function in time and space,
    1797                 :            :         configured with an initiation point in space, a constant velocity of the
    1798                 :            :         growing spherical front in time (and space) linearly, and width of the front
    1799                 :            :         and assigns values to mesh points falling within the growing spherical shell
    1800                 :            :         inside a configured box or meshblock. The following keywords are required
    1801                 :            :         in the box/meshblock block if 'linear' is used: 'init_time',
    1802 [ +  - ][ +  - ]:       5332 :         'front_width', 'front_speed')"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1803                 :            : 
    1804                 :            :       // -----------------------------------------------------------------------
    1805                 :            :       // Overset mesh object
    1806                 :            :       // -----------------------------------------------------------------------
    1807                 :            : 
    1808                 :            :       keywords.insert({"mesh",
    1809                 :            :         "Start configuration block assigning a mesh to a solver",
    1810                 :            :         R"(This keyword is used to introduce a mesh block, used to
    1811 [ +  - ][ +  - ]:       6665 :         assign and configure a mesh to a solver.)", "vector block-title"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1812                 :            : 
    1813                 :            :       keywords.insert({"filename", "Set filename",
    1814 [ +  - ][ +  - ]:       3999 :         R"(Set filename, e.g., mesh filename for solver coupling.)", "string"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ -  + ]
         [ -  + ][ -  - ]
    1815                 :            : 
    1816                 :            :       keywords.insert({"location", "Configure location",
    1817                 :            :         R"(Configure location of a mesh relative to another.)",
    1818 [ +  - ][ +  - ]:       6665 :         "vector of 3 reals"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1819                 :            : 
    1820                 :            :       keywords.insert({"orientation", "Configure orientation",
    1821                 :            :         R"(Configure orientation of a mesh relative to another.)",
    1822 [ +  - ][ +  - ]:       6665 :         "vector of 3 reals"});
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1823                 :            : 
    1824                 :            :       // -----------------------------------------------------------------------
    1825                 :            :       // pre-configured problems
    1826                 :            :       // -----------------------------------------------------------------------
    1827                 :            : 
    1828                 :            :       keywords.insert({"user_defined",
    1829                 :            :         "Select user-defined specification for a problem",
    1830                 :            :         R"(This keyword is used to select the user-defined specification for an
    1831                 :            :         option. This could be a 'problem' to be solved by a partial differential
    1832                 :            :         equation, but can also be a 'user-defined' mesh velocity specification for
    1833 [ +  - ][ +  - ]:       5332 :         ALE mesh motion.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1834                 :            : 
    1835                 :            :       keywords.insert({"shear_diff",
    1836                 :            :         "Select the shear + diffusion test problem ",
    1837                 :            :         R"(This keyword is used to select the shear diffusion test problem. The
    1838                 :            :         initial and boundary conditions are specified to set up the test problem
    1839                 :            :         suitable to exercise and test the advection and diffusion terms of the
    1840 [ +  - ][ +  - ]:       5332 :         scalar transport equation.)" });
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1841                 :            : 
    1842                 :            :       keywords.insert({"slot_cyl",
    1843                 :            :         "Select Zalesak's slotted cylinder test problem",
    1844                 :            :         R"(This keyword is used to select Zalesak's slotted cylinder test
    1845                 :            :         problem. The initial and boundary conditions are specified to set up the
    1846                 :            :         test problem suitable to exercise and test the advection and diffusion
    1847 [ +  - ][ +  - ]:       5332 :         terms of the scalar transport equation.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1848                 :            : 
    1849                 :            :       keywords.insert({"gauss_hump",
    1850                 :            :         "Select advection of 2D Gaussian hump test problem",
    1851                 :            :         R"(This keyword is used to select the advection of 2D Gaussian hump test
    1852                 :            :         problem. The initial and boundary conditions are specified to set up the
    1853                 :            :         test problem suitable to exercise and test the advection
    1854 [ +  - ][ +  - ]:       5332 :         terms of the scalar transport equation.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1855                 :            : 
    1856                 :            :       keywords.insert({"cyl_advect",
    1857                 :            :         "Select advection of cylinder test problem",
    1858                 :            :         R"(This keyword is used to select the advection of cylinder test
    1859                 :            :         problem. The initial and boundary conditions are specified to set up the
    1860                 :            :         test problem suitable to exercise and test the advection
    1861 [ +  - ][ +  - ]:       5332 :         terms of the scalar transport equation.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1862                 :            : 
    1863                 :            :       keywords.insert({"cyl_vortex",
    1864                 :            :         "Select deformation of cylinder in a vortex test problem",
    1865                 :            :         R"(This keyword is used to select the test problem which deforms a cylinder
    1866                 :            :         in a vortical velocity field. The initial and boundary conditions are
    1867                 :            :         specified to set up the test problem suitable to exercise and test the
    1868 [ +  - ][ +  - ]:       5332 :         advection terms of the scalar transport equation.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1869                 :            : 
    1870                 :            :       keywords.insert({"vortical_flow",
    1871                 :            :         "Select the vortical flow test problem ",
    1872                 :            :         R"(This keyword is used to select the vortical flow test problem. The
    1873                 :            :         purpose of this test problem is to test velocity errors generated by spatial
    1874                 :            :         operators in the presence of 3D vorticity and in particluar the
    1875                 :            :         superposition of planar and vortical flows, analogous to voritcity
    1876                 :            :         stretching. For more details, see Waltz,
    1877                 :            :         et. al, "Manufactured solutions for the three-dimensional Euler equations
    1878                 :            :         with relevance to Inertial Confinement Fusion", Journal of Computational
    1879 [ +  - ][ +  - ]:       5332 :         Physics 267 (2014) 196-209.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1880                 :            : 
    1881                 :            :       keywords.insert({"nl_energy_growth",
    1882                 :            :         "Select the nonlinear energy growth test problem",
    1883                 :            :         R"(This keyword is used to select the nonlinear energy growth test problem.
    1884                 :            :         The purpose of this test problem is to test nonlinear, time dependent energy
    1885                 :            :         growth and the subsequent development of pressure gradients due to coupling
    1886                 :            :         between the internal energy and the equation of state. For more details,
    1887                 :            :         see Waltz, et. al, "Manufactured
    1888                 :            :         solutions for the three-dimensional Euler equations with relevance to
    1889                 :            :         Inertial Confinement Fusion", Journal of Computational Physics 267 (2014)
    1890 [ +  - ][ +  - ]:       5332 :         196-209.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ +  - ][ -  - ]
    1891                 :            : 
    1892                 :            :       keywords.insert({"rayleigh_taylor",
    1893                 :            :         "Select the Rayleigh-Taylor test problem ",
    1894                 :            :         R"(This keyword is used to select the Rayleigh-Taylor unstable configuration
    1895                 :            :         test problem. The purpose of this test problem is to assess time dependent
    1896                 :            :         fluid motion in the presence of Rayleigh-Taylor unstable conditions, i.e.
    1897                 :            :         opposing density and pressure gradients.
    1898                 :            :         For more details, see Waltz, et. al, "Manufactured solutions for the
    1899                 :            :         three-dimensional Euler equations with relevance to Inertial Confinement
    1900 [ +  - ][ +  - ]:       5332 :         Fusion", Journal of Computational Physics 267 (2014) 196-209.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1901                 :            : 
    1902                 :            :       keywords.insert({"taylor_green",
    1903                 :            :         "Select the Taylor-Green test problem ",
    1904                 :            :         R"(This keyword is used to select the Taylor-Green vortex test problem. The
    1905                 :            :         purpose of this problem is to test time accuracy and the correctness of the
    1906                 :            :         discretization of the viscous term in the Navier-Stokes equation. For more
    1907                 :            :         details on the flow, see G.I. Taylor, A.E.
    1908                 :            :         Green, "Mechanism of the Production of Small Eddies from Large Ones", Proc.
    1909                 :            :         R. Soc. Lond. A 1937 158 499-521; DOI: 10.1098/rspa.1937.0036. Published 3
    1910 [ +  - ][ +  - ]:       5332 :         February 1937.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1911                 :            : 
    1912                 :            :       keywords.insert({"sod_shocktube",
    1913                 :            :         "Select the Sod shock-tube test problem ",
    1914                 :            :         R"(This keyword is used to select the Sod shock-tube test problem. The
    1915                 :            :         purpose of this test problem is to test the correctness of the
    1916                 :            :         approximate Riemann solver and its shock and interface capturing
    1917                 :            :         capabilities. For more details, see
    1918                 :            :         G. A. Sod, "A Survey of Several Finite Difference Methods for Systems of
    1919                 :            :         Nonlinear Hyperbolic Conservation Laws", J. Comput. Phys., 27 (1978)
    1920 [ +  - ][ +  - ]:       5332 :         1–31.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1921                 :            : 
    1922                 :            :       keywords.insert({"rotated_sod_shocktube",
    1923                 :            :         "Select the rotated Sod shock-tube test problem ",
    1924                 :            :         R"(This keyword is used to select the rotated Sod shock-tube test problem.
    1925                 :            :         This the same as Sod shocktube but the geometry is rotated about X, Y, Z
    1926                 :            :         each by 45 degrees (in that order) so that none of the domain boundary align
    1927                 :            :         with any of the coordinate directions. The purpose of this test problem is
    1928                 :            :         to test the correctness of the approximate Riemann solver and its shock and
    1929                 :            :         interface capturing capabilities in an arbitrarily oriented geometry.
    1930                 :            :         For more details on the Sod
    1931                 :            :         problem, see G. A. Sod, "A Survey of Several Finite Difference Methods for
    1932                 :            :         Systems of Nonlinear Hyperbolic Conservation Laws", J. Comput. Phys., 27
    1933 [ +  - ][ +  - ]:       5332 :         (1978) 1–31.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ +  - ][ -  - ]
    1934                 :            : 
    1935                 :            :       keywords.insert({"shedding_flow",
    1936                 :            :         "Select the Shedding flow test problem ",
    1937                 :            :         R"(This keyword is used to select the Shedding flow test problem. It
    1938                 :            :         describe a quasi-2D inviscid flow over a triangular wedge in tetrahedron
    1939                 :            :         grid. The purpose of this test problem is to test the capability of DG
    1940                 :            :         scheme for retaining the shape of vortices and also different error
    1941                 :            :         indicator behavior for this external flow problem when p-adaptive DG scheme
    1942 [ +  - ][ +  - ]:       5332 :         is applied.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1943                 :            : 
    1944                 :            :       keywords.insert({"sedov_blastwave",
    1945                 :            :         "Select the Sedov blast-wave test problem ",
    1946                 :            :         R"(This keyword is used to select the Sedov blast-wave test problem. The
    1947                 :            :         purpose of this test problem is to test the correctness of the
    1948                 :            :         approximate Riemann solver and its strong shock and interface capturing
    1949 [ +  - ][ +  - ]:       5332 :         capabilities.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1950                 :            : 
    1951                 :            :       keywords.insert({"interface_advection",
    1952                 :            :         "Select the interface advection test problem ",
    1953                 :            :         R"(This keyword is used to select the interface advection test problem.
    1954                 :            :         The purpose of this test problem is to test the well-balancedness of the
    1955                 :            :         multi-material discretization and its interface capturing
    1956 [ +  - ][ +  - ]:       5332 :         capabilities.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ +  - ][ -  - ]
    1957                 :            : 
    1958                 :            :       keywords.insert({"gauss_hump_compflow",
    1959                 :            :         "Select advection of 2D Gaussian hump test problem",
    1960                 :            :         R"(This keyword is used to select the advection of 2D Gaussian hump test
    1961                 :            :         problem. The initial and boundary conditions are specified to set up the
    1962                 :            :         test problem suitable to exercise and test the advection terms of the
    1963                 :            :         Euler equations. The baseline of the density distribution in this testcase
    1964                 :            :         is 1 instead of 0 in gauss_hump_transport which enables it to be the
    1965 [ +  - ][ +  - ]:       5332 :         regression testcase for p-adaptive DG scheme.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ +  - ][ -  - ]
    1966                 :            : 
    1967                 :            :       keywords.insert({"waterair_shocktube",
    1968                 :            :         "Select the water-air shock-tube test problem ",
    1969                 :            :         R"(This keyword is used to select the Water-air shock-tube test problem.
    1970                 :            :         The purpose of this test problem is to test the correctness of the
    1971                 :            :         multi-material pressure relaxation procedure and its interface capturing
    1972                 :            :         capabilities. For more details, see
    1973                 :            :         Chiapolino, A., Saurel, R., & Nkonga, B. (2017). Sharpening diffuse
    1974                 :            :         interfaces with compressible fluids on unstructured meshes. Journal of
    1975 [ +  - ][ +  - ]:       5332 :         Computational Physics, 340, 389-417.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ +  - ][ -  - ]
    1976                 :            : 
    1977                 :            :       keywords.insert({"shock_hebubble",
    1978                 :            :         "Select the shock He-bubble test problem ",
    1979                 :            :         R"(This keyword is used to select the shock He-bubble test problem. The
    1980                 :            :         purpose of this test problem is to test the correctness of the
    1981                 :            :         multi-material algorithm and its shock-interface interaction
    1982                 :            :         capabilities. For more details, see
    1983                 :            :         Quirk, J. J., & Karni, S. (1996). On the dynamics of a shock–bubble
    1984 [ +  - ][ +  - ]:       5332 :         interaction. Journal of Fluid Mechanics, 318, 129-163.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1985                 :            : 
    1986                 :            :       keywords.insert({"underwater_ex",
    1987                 :            :         "Select the underwater explosion test problem ",
    1988                 :            :         R"(This keyword is used to select the underwater explosion test problem.
    1989                 :            :         The purpose of this test problem is to test the correctness of the
    1990                 :            :         multi-material algorithm and its interface capturing capabilities in the
    1991                 :            :         presence of strong shocks and large deformations.
    1992                 :            :         For more details, see
    1993                 :            :         Chiapolino, A., Saurel, R., & Nkonga, B. (2017). Sharpening diffuse
    1994                 :            :         interfaces with compressible fluids on unstructured meshes. Journal of
    1995 [ +  - ][ +  - ]:       5332 :         Computational Physics, 340, 389-417.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    1996                 :            : 
    1997                 :            :       keywords.insert({"shockdensity_wave",
    1998                 :            :         "Select the shock-density wave test problem ",
    1999                 :            :         R"(This keyword is used to select the shock-density wave test problem.
    2000                 :            :         THe purpose of this test problem is to assess the accuracy of high order
    2001                 :            :         method in predicting the interaction of a density wave with a shock front.
    2002                 :            :         For more details, see Yu, L., Matthias
    2003                 :            :         I. (2014). Discontinuous Galerkin method for multicomponent chemically
    2004                 :            :         reacting flows and combustion. Journal of Computational Physics, 270,
    2005 [ +  - ][ +  - ]:       5332 :         105-137.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ +  - ][ -  - ]
    2006                 :            : 
    2007                 :            :       keywords.insert({"equilinterface_advect",
    2008                 :            :         "Select the advection of equilibrium interface problem ",
    2009                 :            :         R"(This keyword is used to select the advection of equilibrium interface
    2010                 :            :         problem. This is a manufactured problem with source terms with nonlinear
    2011                 :            :         solutions near the material interface. Source terms are used to ensure
    2012 [ +  - ][ +  - ]:       5332 :         that the conservation laws are satisfied by the manufactured solution.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ +  - ][ -  - ]
    2013                 :            : 
    2014                 :            :       keywords.insert({"sinewave_packet",
    2015                 :            :         "Select the advection of sinewave packet problem ",
    2016                 :            :         R"(This keyword is used to select the advection of sinewave packet
    2017 [ +  - ][ +  - ]:       5332 :         problem.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ -  + ][ -  - ]
    2018                 :            : 
    2019                 :            :       keywords.insert({"richtmyer_meshkov",
    2020                 :            :         "Select the Richtmyer-Meshkov instability problem ",
    2021                 :            :         R"(This keyword is used to select the Richtmyer-Meshkov instability
    2022 [ +  - ][ +  - ]:       6665 :         problem. In this problem, a shock hits a perturbed material interface.)"});
         [ +  - ][ +  - ]
         [ +  - ][ -  + ]
         [ +  - ][ +  - ]
         [ +  - ][ -  - ]
    2023                 :            : 
    2024                 :            :       // -----------------------------------------------------------------------
    2025                 :            : 
    2026                 :            :       // Initialize help: fill own keywords
    2027                 :            :       tk::ctr::Info ctrinfoFill(get< tag::cmd, tag::ctrinfo >());
    2028         [ +  + ]:     318587 :       for (const auto& i : keywords) {
    2029         [ +  - ]:     317254 :         ctrinfoFill.fill(i);
    2030                 :            :       }
    2031                 :       1333 :     }
    2032                 :            : 
    2033                 :            :     //! Query scheme centering
    2034                 :            :     //! \return Scheme centering
    2035                 :        189 :     tk::Centering centering() const
    2036         [ +  - ]:        378 :     { return ctr::Scheme().centering( get< tag::scheme >() ); }
    2037                 :            : 
    2038                 :            :     /** @name Pack/Unpack: Serialize InputDeck object for Charm++ */
    2039                 :            :     ///@{
    2040                 :            :     //! \brief Pack/Unpack serialize member function
    2041                 :            :     //! \param[in,out] p Charm++'s PUP::er serializer object reference
    2042                 :            :     void pup( PUP::er& p ) { tk::TaggedTuple< ConfigMembers >::pup(p); }
    2043                 :            :     //! \brief Pack/Unpack serialize operator|
    2044                 :            :     //! \param[in,out] p Charm++'s PUP::er serializer object reference
    2045                 :            :     //! \param[in,out] c InputDeck object reference
    2046                 :            :     friend void operator|( PUP::er& p, InputDeck& c ) { c.pup(p); }
    2047                 :            :     //@}
    2048                 :            : 
    2049                 :            : };
    2050                 :            : 
    2051                 :            : } // ctr::
    2052                 :            : } // inciter::
    2053                 :            : 
    2054                 :            : #endif // InputDeck_h

Generated by: LCOV version 1.14