Branch data Line data Source code
1 : : // *****************************************************************************
2 : : /*!
3 : : \file src/Control/Inciter/InputDeck/LuaParser.cpp
4 : : \copyright 2019-2021 Triad National Security, LLC.
5 : : All rights reserved. See the LICENSE file for details.
6 : : \brief Inciter's lua input deck file parser
7 : : \details This file defines the input deck, i.e., control file, parser for
8 : : the computational shock hydrodynamics tool, Inciter.
9 : : */
10 : : // *****************************************************************************
11 : :
12 : : #include <ostream>
13 : : #include <type_traits>
14 : :
15 : : #include "QuinoaConfig.hpp"
16 : :
17 : : #include "NoWarning/pegtl.hpp"
18 : :
19 : : #include "Print.hpp"
20 : : #include "Exception.hpp"
21 : : #include "Inciter/InputDeck/InputDeck.hpp"
22 : : #include "Inciter/InputDeck/LuaParser.hpp"
23 : : #include "PDE/MultiMat/MultiMatIndexing.hpp"
24 : : #include "PDE/MultiSpecies/MultiSpeciesIndexing.hpp"
25 : :
26 : : namespace tk {
27 : : namespace grm {
28 : :
29 : : //! \brief Case-insensitive character comparison functor
30 : : struct CaseInsensitiveCharLess {
31 : : //! Function call operator
32 : : //! \param[in] lhs Left character of the comparitor operand
33 : : //! \param[in] rhs Right character of the comparitor operand
34 : : //! \return Boolean indicating the result of the comparison
35 : 6 : bool operator() ( char lhs, char rhs ) const {
36 : 6 : return std::tolower( lhs ) < std::tolower( rhs );
37 : : }
38 : : };
39 : :
40 : : //! \brief Parser-lifetime storage for dependent variables selected.
41 : : //! \details Used to track the dependent variable of differential equations
42 : : //! (i.e., models) assigned during parsing. It needs to be case insensitive
43 : : //! since we only care about whether the variable is selected or not and not
44 : : //! whether it denotes a full variable (upper case) or a fluctuation (lower
45 : : //! case). This is true for both inserting variables into the set as well as
46 : : //! at matching terms of products in parsing requested statistics.
47 : : static std::set< char, CaseInsensitiveCharLess > depvars;
48 : :
49 : : } // grm::
50 : : } // tk::
51 : :
52 : : using inciter::LuaParser;
53 : :
54 : 191 : LuaParser::LuaParser( const tk::Print& /*print*/,
55 : : const ctr::CmdLine& cmdline,
56 : 191 : ctr::InputDeck& inputdeck ) :
57 : 191 : m_filename( cmdline.get< tag::io, tag::control >() )
58 : : // *****************************************************************************
59 : : // Constructor
60 : : // //! \param[in] print Pretty printer
61 : : //! \param[in] cmdline Command line stack
62 : : //! \param[in,out] inputdeck Input deck stack where data is stored during
63 : : //! parsing
64 : : // *****************************************************************************
65 : : {
66 : : // Make sure there is a filename
67 [ - + ][ - - ]: 191 : Assert( !m_filename.empty(), "No filename specified" );
[ - - ][ - - ]
68 : :
69 : : // Local file stream handle
70 [ + - ]: 382 : std::ifstream q;
71 : :
72 : : // Check if file exists, throw exception if it does not
73 [ + - ]: 191 : q.open( m_filename, std::ifstream::in );
74 [ + - ][ - + ]: 191 : ErrChk( q.good(), "Failed to open file: " + m_filename );
[ - - ][ - - ]
[ - - ]
75 : :
76 : : // Attempt to read a character, throw if it fails
77 : : // It is curious that on some systems opening a directory instead of a file
78 : : // with the above ifstream::open() call does not set the failbit. Thus we get
79 : : // here fine, so we try to read a character from it. If it is a directory or
80 : : // an empty file the read will fail, so we throw. Read more at: http://
81 : : // stackoverflow.com/questions/9591036/
82 : : // ifstream-open-doesnt-set-error-bits-when-argument-is-a-directory.
83 [ + - ]: 191 : q.get();
84 [ + - ][ - + ]: 191 : ErrChk( q.good(), "Failed to read from file: " + m_filename );
[ - - ][ - - ]
[ - - ]
85 : :
86 : : // Close it
87 [ + - ]: 191 : q.close();
88 [ + - ][ - + ]: 191 : ErrChk( !q.fail(), "Failed to close file: " + m_filename );
[ - - ][ - - ]
[ - - ]
89 : :
90 : : // Create InputDeck (a tagged tuple) to store parsed input
91 [ + - ]: 382 : ctr::InputDeck ideck( cmdline );
92 : :
93 : : // Read lua file into sol object
94 [ + - ]: 382 : sol::state lua_deck;
95 [ + - ]: 191 : lua_deck.open_libraries(sol::lib::base);
96 [ + - ]: 191 : lua_deck.script_file(m_filename);
97 : :
98 : : // Store inputdeck parameters from sol object into tagged tuple
99 [ + - ][ + - ]: 191 : storeInputDeck(lua_deck["inciter"], ideck);
[ + - ]
100 : :
101 : 191 : inputdeck = std::move( ideck );
102 : 191 : }
103 : :
104 : : void
105 : 191 : LuaParser::storeInputDeck(
106 : : const sol::table& lua_ideck,
107 : : ctr::InputDeck& gideck )
108 : : // *****************************************************************************
109 : : // Store lua inputdeck in custom struct
110 : : //! \param[in] lua_ideck Lua inputdeck parsed by sol2
111 : : //! \param[in,out] gideck Inciter's inputdeck storage
112 : : // *****************************************************************************
113 : : {
114 : : // TODO: explore replacing storeIfSpecd() and storeOptIfSpecd with sol::get_or()
115 : :
116 [ + - ][ + - ]: 191 : storeIfSpecd< std::string >(
[ + - ]
117 : : lua_ideck, "title", gideck.get< tag::title >(), "No title");
118 : :
119 : : // time stepping options
120 : : // ---------------------------------------------------------------------------
121 [ + - ][ + - ]: 191 : storeIfSpecd< uint64_t >(
122 : : lua_ideck, "nstep", gideck.get< tag::nstep >(),
123 : : std::numeric_limits< uint64_t >::max());
124 [ + - ][ + - ]: 191 : storeIfSpecd< tk::real >(
125 : : lua_ideck, "term", gideck.get< tag::term >(),
126 : : std::numeric_limits< tk::real >::max());
127 [ + - ][ + - ]: 191 : storeIfSpecd< tk::real >(
128 : : lua_ideck, "t0", gideck.get< tag::t0 >(), 0.0);
129 [ + - ][ + - ]: 191 : storeIfSpecd< tk::real >(
130 : : lua_ideck, "dt", gideck.get< tag::dt >(), 0.0);
131 [ + - ][ + - ]: 191 : storeIfSpecd< tk::real >(
132 : : lua_ideck, "cfl", gideck.get< tag::cfl >(), 0.0);
133 [ + - ][ + - ]: 191 : storeIfSpecd< uint32_t >(
134 : : lua_ideck, "ttyi", gideck.get< tag::ttyi >(), 1);
135 [ + - ][ + - ]: 191 : storeIfSpecd< bool >(
136 : : lua_ideck, "steady_state", gideck.get< tag::steady_state >(), false);
137 [ + - ][ + - ]: 191 : storeIfSpecd< tk::real >(
138 : : lua_ideck, "residual", gideck.get< tag::residual >(), 1.0e-8);
139 [ + - ][ + - ]: 191 : storeIfSpecd< uint32_t >(
140 : : lua_ideck, "rescomp", gideck.get< tag::rescomp >(), 1);
141 [ + - ][ + - ]: 191 : storeIfSpecd< uint32_t >(
142 : : lua_ideck, "imex_runge_kutta", gideck.get< tag::imex_runge_kutta >(), 0);
143 [ + - ][ + - ]: 191 : storeIfSpecd< uint32_t >(
144 : : lua_ideck, "imex_maxiter", gideck.get< tag::imex_maxiter >(), 50);
145 [ + - ][ + - ]: 191 : storeIfSpecd< tk::real >(
146 : : lua_ideck, "imex_reltol", gideck.get< tag::imex_reltol >(), 1.0e-02);
147 [ + - ][ + - ]: 191 : storeIfSpecd< tk::real >(
148 : : lua_ideck, "imex_abstol", gideck.get< tag::imex_abstol >(), 1.0e-04);
149 : :
150 [ + + ][ - + ]: 191 : if (gideck.get< tag::dt >() < 1e-12 && gideck.get< tag::cfl >() < 1e-12)
[ - + ]
151 [ - - ][ - - ]: 0 : Throw("No time step calculation policy has been selected in the "
[ - - ]
152 : : "preceeding block. Use keyword 'dt' to set a constant or 'cfl' to set an "
153 : : "adaptive time step size calculation policy.");
154 : :
155 : : // partitioning/reordering options
156 : : // ---------------------------------------------------------------------------
157 : : storeOptIfSpecd< tk::ctr::PartitioningAlgorithmType,
158 [ + - ][ + - ]: 191 : tk::ctr::PartitioningAlgorithm >(
159 : : lua_ideck, "partitioning", gideck.get< tag::partitioning >(),
160 : : tk::ctr::PartitioningAlgorithmType::RCB);
161 [ + - ][ + - ]: 191 : storeIfSpecd< bool >(
162 : : lua_ideck, "pelocal_reorder", gideck.get< tag::pelocal_reorder >(),
163 : : false);
164 [ + - ][ + - ]: 191 : storeIfSpecd< bool >(
165 : : lua_ideck, "operator_reorder", gideck.get< tag::operator_reorder >(),
166 : : false);
167 : :
168 : : // discretization scheme options
169 : : // ---------------------------------------------------------------------------
170 : : using inciter::ctr::SchemeType;
171 [ + - ][ + - ]: 191 : storeOptIfSpecd< SchemeType, inciter::ctr::Scheme >(
172 : : lua_ideck, "scheme", gideck.get< tag::scheme >(), SchemeType::ALECG);
173 [ + - ][ + - ]: 191 : storeOptIfSpecd< inciter::ctr::LimiterType, inciter::ctr::Limiter >(
174 : : lua_ideck, "limiter", gideck.get< tag::limiter >(),
175 : : inciter::ctr::LimiterType::NOLIMITER);
176 [ + - ][ + - ]: 191 : storeIfSpecd< tk::real >(
177 : : lua_ideck, "cweight", gideck.get< tag::cweight >(), 1.0);
178 [ + - ][ + - ]: 191 : storeIfSpecd< tk::real >(
179 : : lua_ideck, "shock_detector_coeff",
180 : : gideck.get< tag::shock_detector_coeff >(), 1.0);
181 [ + - ][ + - ]: 191 : storeIfSpecd< bool >(
182 : : lua_ideck, "accuracy_test", gideck.get< tag::accuracy_test >(), false);
183 [ + - ][ + - ]: 191 : storeIfSpecd< bool >(
184 : : lua_ideck, "limsol_projection", gideck.get< tag::limsol_projection >(),
185 : : true);
186 [ + - ][ + - ]: 191 : storeIfSpecd< tk::real >(
187 : : lua_ideck, "lowspeed_kp", gideck.get< tag::lowspeed_kp >(), 0.0);
188 : :
189 : : // configure solutions DOFs
190 : 191 : auto scheme = gideck.get< tag::scheme >();
191 : 191 : auto& ndof = gideck.get< tag::ndof >();
192 : 191 : auto& rdof = gideck.get< tag::rdof >();
193 : 191 : ndof = rdof = 1;
194 [ + + ][ + + ]: 191 : if (scheme == SchemeType::P0P1 || scheme == SchemeType::FV) {
195 : 26 : ndof = 1; rdof = 4;
196 [ + + ]: 165 : } else if (scheme == SchemeType::DGP1) {
197 : 17 : ndof = rdof = 4;
198 [ + + ]: 148 : } else if (scheme == SchemeType::DGP2) {
199 : 8 : ndof = rdof = 10;
200 [ + + ]: 140 : } else if (scheme == SchemeType::PDG) {
201 : 12 : ndof = rdof = 10;
202 : 12 : gideck.get< tag::pref, tag::pref >() = true;
203 [ + + ][ + + ]: 128 : } else if (scheme != SchemeType::DG &&
204 [ - + ]: 21 : scheme != SchemeType::ALECG &&
205 : : scheme != SchemeType::OversetFE) {
206 [ - - ][ - - ]: 0 : Throw("Scheme type not configured in configure_scheme");
[ - - ]
207 : : }
208 : :
209 : : // PDE options
210 : : // ---------------------------------------------------------------------------
211 : :
212 : 191 : char depvar_cnt = 'a';
213 [ + - ]: 191 : gideck.get< tag::depvar >().resize(1);
214 : :
215 : : // check transport
216 [ + - ][ + - ]: 191 : if (lua_ideck["transport"].valid()) {
[ + + ]
217 : :
218 [ + - ][ + - ]: 92 : checkBlock< inciter::ctr::transportList::Keys >(lua_ideck["transport"],
[ + - ][ + - ]
219 : : "transport");
220 : :
221 : 92 : gideck.get< tag::pde >() = inciter::ctr::PDEType::TRANSPORT;
222 [ + - ][ + - ]: 92 : storeIfSpecd< std::size_t >(
[ + - ][ + - ]
223 : : lua_ideck["transport"], "ncomp",
224 : : gideck.get< tag::transport, tag::ncomp >(), 1);
225 [ + - ][ + - ]: 92 : storeIfSpecd< int >(
[ + - ][ + - ]
226 : : lua_ideck["transport"], "intsharp",
227 : : gideck.get< tag::transport, tag::intsharp >(), 0);
228 [ + - ][ + - ]: 92 : storeIfSpecd< tk::real >(
[ + - ][ + - ]
229 : : lua_ideck["transport"], "intsharp_param",
230 : : gideck.get< tag::transport, tag::intsharp_param >(), 1.8);
231 [ + - ][ + - ]: 92 : storeOptIfSpecd< inciter::ctr::ProblemType, inciter::ctr::Problem >(
[ + - ][ + - ]
232 : : lua_ideck["transport"], "problem",
233 : : gideck.get< tag::transport, tag::problem >(),
234 : : inciter::ctr::ProblemType::USER_DEFINED);
235 [ + - ][ + - ]: 92 : storeVecIfSpecd< tk::real >(
[ + - ][ + - ]
[ + - ]
236 : : lua_ideck["transport"], "diffusivity",
237 : : gideck.get< tag::transport, tag::diffusivity >(), {0.0, 0.0, 0.0});
238 [ + - ][ + - ]: 92 : storeVecIfSpecd< tk::real >(
[ + - ][ + - ]
[ + - ]
239 : : lua_ideck["transport"], "u0",
240 : : gideck.get< tag::transport, tag::u0 >(), {0.0, 0.0, 0.0});
241 [ + - ][ + - ]: 92 : storeVecIfSpecd< tk::real >(
[ + - ][ + - ]
[ + - ]
242 : : lua_ideck["transport"], "lambda",
243 : : gideck.get< tag::transport, tag::lambda >(), {0.0, 0.0, 0.0});
244 : 92 : gideck.get< tag::depvar >()[0] = 'c';
245 [ + - ][ + - ]: 92 : storeOptIfSpecd< inciter::ctr::FluxType, inciter::ctr::Flux >(
246 : : lua_ideck, "flux", gideck.get< tag::flux >(),
247 : : inciter::ctr::FluxType::UPWIND);
248 [ + - ][ + - ]: 92 : storeOptIfSpecd< inciter::ctr::PhysicsType, inciter::ctr::Physics >(
[ + - ][ + - ]
249 : : lua_ideck["transport"], "physics",
250 : : gideck.get< tag::transport, tag::physics >(),
251 : : inciter::ctr::PhysicsType::ADVECTION);
252 : :
253 : : // store number of equations in PDE system
254 : 92 : gideck.get< tag::ncomp >() =
255 : 92 : gideck.get< tag::transport, tag::ncomp >();
256 : : }
257 : :
258 : : // check compflow
259 [ + - ][ + - ]: 191 : if (lua_ideck["compflow"].valid()) {
[ + + ]
260 : :
261 [ + - ][ + - ]: 64 : checkBlock< inciter::ctr::compflowList::Keys >(lua_ideck["compflow"],
[ + - ][ + - ]
262 : : "compflow");
263 : :
264 : 64 : gideck.get< tag::pde >() = inciter::ctr::PDEType::COMPFLOW;
265 [ + - ][ + - ]: 64 : storeOptIfSpecd< inciter::ctr::ProblemType, inciter::ctr::Problem >(
[ + - ][ + - ]
266 : : lua_ideck["compflow"], "problem",
267 : : gideck.get< tag::compflow, tag::problem >(),
268 : : inciter::ctr::ProblemType::USER_DEFINED);
269 [ + - ][ + - ]: 64 : storeOptIfSpecd< inciter::ctr::PhysicsType, inciter::ctr::Physics >(
[ + - ][ + - ]
270 : : lua_ideck["compflow"], "physics",
271 : : gideck.get< tag::compflow, tag::physics >(),
272 : : inciter::ctr::PhysicsType::EULER);
273 : :
274 : : // problem parameters for MMS
275 [ + - ][ + - ]: 64 : storeIfSpecd< tk::real >(lua_ideck["compflow"], "alpha",
[ + - ][ + - ]
276 : : gideck.get< tag::compflow, tag::alpha >(), 0.0);
277 [ + - ][ + - ]: 64 : storeIfSpecd< tk::real >(lua_ideck["compflow"], "beta",
[ + - ][ + - ]
278 : : gideck.get< tag::compflow, tag::beta >(), 0.0);
279 [ + - ][ + - ]: 64 : storeIfSpecd< tk::real >(lua_ideck["compflow"], "betax",
[ + - ][ + - ]
280 : : gideck.get< tag::compflow, tag::betax >(), 0.0);
281 [ + - ][ + - ]: 64 : storeIfSpecd< tk::real >(lua_ideck["compflow"], "betay",
[ + - ][ + - ]
282 : : gideck.get< tag::compflow, tag::betay >(), 0.0);
283 [ + - ][ + - ]: 64 : storeIfSpecd< tk::real >(lua_ideck["compflow"], "betaz",
[ + - ][ + - ]
284 : : gideck.get< tag::compflow, tag::betaz >(), 0.0);
285 [ + - ][ + - ]: 64 : storeIfSpecd< tk::real >(lua_ideck["compflow"], "r0",
[ + - ][ + - ]
286 : : gideck.get< tag::compflow, tag::r0 >(), 0.0);
287 [ + - ][ + - ]: 64 : storeIfSpecd< tk::real >(lua_ideck["compflow"], "p0",
[ + - ][ + - ]
288 : : gideck.get< tag::compflow, tag::p0 >(), 0.0);
289 [ + - ][ + - ]: 64 : storeIfSpecd< tk::real >(lua_ideck["compflow"], "ce",
[ + - ][ + - ]
290 : : gideck.get< tag::compflow, tag::ce >(), 0.0);
291 [ + - ][ + - ]: 64 : storeIfSpecd< tk::real >(lua_ideck["compflow"], "kappa",
[ + - ][ + - ]
292 : : gideck.get< tag::compflow, tag::kappa >(), 0.0);
293 : :
294 : 64 : gideck.get< tag::depvar >()[0] = 'a';
295 [ + - ][ + - ]: 64 : storeOptIfSpecd< inciter::ctr::FluxType, inciter::ctr::Flux >(
296 : : lua_ideck, "flux", gideck.get< tag::flux >(),
297 : : inciter::ctr::FluxType::HLLC);
298 : :
299 : : // store number of equations in PDE system
300 : 64 : gideck.get< tag::ncomp >() = 5;
301 : : }
302 : :
303 : : // check multimat
304 [ + - ][ + - ]: 191 : if (lua_ideck["multimat"].valid()) {
[ + + ]
305 : :
306 [ + - ][ + - ]: 32 : checkBlock< inciter::ctr::multimatList::Keys >(lua_ideck["multimat"],
[ + - ][ + - ]
307 : : "multimat");
308 : :
309 : 32 : gideck.get< tag::pde >() = inciter::ctr::PDEType::MULTIMAT;
310 [ + - ][ + - ]: 32 : storeIfSpecd< std::size_t >(
[ + - ][ + - ]
311 : : lua_ideck["multimat"], "nmat",
312 : : gideck.get< tag::multimat, tag::nmat >(), 2);
313 [ + - ][ + - ]: 32 : storeIfSpecd< uint64_t >(
[ + - ][ + - ]
314 : : lua_ideck["multimat"], "prelax",
315 : : gideck.get< tag::multimat, tag::prelax >(), 1);
316 [ + - ][ + - ]: 32 : storeIfSpecd< tk::real >(
[ + - ][ + - ]
317 : : lua_ideck["multimat"], "prelax_timescale",
318 : : gideck.get< tag::multimat, tag::prelax_timescale >(), 0.25);
319 [ + - ][ + - ]: 32 : storeIfSpecd< int >(
[ + - ][ + - ]
320 : : lua_ideck["multimat"], "intsharp",
321 : : gideck.get< tag::multimat, tag::intsharp >(), 0);
322 [ + - ][ + - ]: 32 : storeIfSpecd< tk::real >(
[ + - ][ + - ]
323 : : lua_ideck["multimat"], "intsharp_param",
324 : : gideck.get< tag::multimat, tag::intsharp_param >(), 1.8);
325 [ + - ][ + - ]: 32 : storeIfSpecd< uint64_t >(
[ + - ][ + - ]
326 : : lua_ideck["multimat"], "rho0constraint",
327 : : gideck.get< tag::multimat, tag::rho0constraint >(), 1);
328 [ + - ][ + - ]: 32 : storeIfSpecd< int >(
[ + - ][ + - ]
329 : : lua_ideck["multimat"], "dt_sos_massavg",
330 : : gideck.get< tag::multimat, tag::dt_sos_massavg >(), 0);
331 [ + - ][ + - ]: 32 : storeOptIfSpecd< inciter::ctr::ProblemType, inciter::ctr::Problem >(
[ + - ][ + - ]
332 : : lua_ideck["multimat"], "problem",
333 : : gideck.get< tag::multimat, tag::problem >(),
334 : : inciter::ctr::ProblemType::USER_DEFINED);
335 [ + - ][ + - ]: 32 : storeOptIfSpecd< inciter::ctr::PhysicsType, inciter::ctr::Physics >(
[ + - ][ + - ]
336 : : lua_ideck["multimat"], "physics",
337 : : gideck.get< tag::multimat, tag::physics >(),
338 : : inciter::ctr::PhysicsType::EULER);
339 : 32 : gideck.get< tag::depvar >()[0] = 'a';
340 [ + - ][ + - ]: 32 : storeOptIfSpecd< inciter::ctr::FluxType, inciter::ctr::Flux >(
341 : : lua_ideck, "flux", gideck.get< tag::flux >(),
342 : : inciter::ctr::FluxType::AUSM);
343 : :
344 : : // number of equations in PDE system are determined based on materials
345 : : }
346 : :
347 : : // check multispecies
348 [ + - ][ + - ]: 191 : if (lua_ideck["multispecies"].valid()) {
[ + + ]
349 : :
350 [ + - ][ + - ]: 3 : checkBlock< inciter::ctr::multispeciesList::Keys >(lua_ideck["multispecies"],
[ + - ][ + - ]
351 : : "multispecies");
352 : :
353 : 3 : gideck.get< tag::pde >() = inciter::ctr::PDEType::MULTISPECIES;
354 [ + - ][ + - ]: 3 : storeIfSpecd< std::size_t >(
[ + - ][ + - ]
355 : : lua_ideck["multispecies"], "nspec",
356 : : gideck.get< tag::multispecies, tag::nspec >(), 1);
357 [ + - ][ + - ]: 3 : storeOptIfSpecd< inciter::ctr::ProblemType, inciter::ctr::Problem >(
[ + - ][ + - ]
358 : : lua_ideck["multispecies"], "problem",
359 : : gideck.get< tag::multispecies, tag::problem >(),
360 : : inciter::ctr::ProblemType::USER_DEFINED);
361 [ + - ][ + - ]: 3 : storeOptIfSpecd< inciter::ctr::PhysicsType, inciter::ctr::Physics >(
[ + - ][ + - ]
362 : : lua_ideck["multispecies"], "physics",
363 : : gideck.get< tag::multispecies, tag::physics >(),
364 : : inciter::ctr::PhysicsType::EULER);
365 : 3 : gideck.get< tag::depvar >()[0] = 'a';
366 [ + - ][ + - ]: 3 : storeOptIfSpecd< inciter::ctr::FluxType, inciter::ctr::Flux >(
367 : : lua_ideck, "flux", gideck.get< tag::flux >(),
368 : : inciter::ctr::FluxType::AUSM);
369 : :
370 : : // store number of equations in PDE system
371 : : // nspec: species mass conservation equations,
372 : : // 3: momentum equations,
373 : : // 1: total energy equation.
374 : 3 : gideck.get< tag::ncomp >() =
375 : 3 : gideck.get< tag::multispecies, tag::nspec >() + 3 + 1;
376 : : }
377 : :
378 : : // number of species, for future use
379 : 191 : std::size_t nspec(1);
380 [ + + ]: 191 : if (gideck.get< tag::pde >() == inciter::ctr::PDEType::MULTISPECIES)
381 : 3 : nspec = gideck.get< tag::multispecies, tag::nspec >();
382 : :
383 : : // add depvar to deck::depvars so it can be selected as outvar later
384 [ + - ]: 191 : tk::grm::depvars.insert( gideck.get< tag::depvar >()[0] );
385 : :
386 : : // Assemble material blocks
387 : : // ---------------------------------------------------------------------------
388 : :
389 : : // solid counters
390 : 191 : std::size_t tmat(0), imatcntr(0), mtypei(0), isolcntr(0);
391 : 191 : bool is_solid(false);
392 : 382 : std::set< std::size_t > matidset;
393 : :
394 : : // material vector
395 [ + - ][ + - ]: 191 : if (lua_ideck["material"].valid()) {
[ + + ]
396 : :
397 : : // size material map vectors
398 : 99 : std::size_t nmat(1);
399 [ + + ]: 99 : if (gideck.get< tag::pde >() == inciter::ctr::PDEType::MULTIMAT)
400 : 32 : nmat = gideck.get< tag::multimat, tag::nmat >();
401 [ + - ]: 99 : gideck.get< tag::matidxmap, tag::eosidx >().resize(nmat);
402 [ + - ]: 99 : gideck.get< tag::matidxmap, tag::matidx >().resize(nmat);
403 [ + - ]: 99 : gideck.get< tag::matidxmap, tag::solidx >().resize(nmat);
404 : :
405 : : // size material vector appropriately
406 : : // size of the material vector is the number of distinct types of materials
407 [ + - ][ + - ]: 198 : sol::table sol_mat = lua_ideck["material"];
408 [ + - ][ + - ]: 99 : gideck.get< tag::material >().resize(sol_mat.size());
409 : : // species vector size is one, since all species are only of one type for now
410 [ + - ]: 99 : gideck.get< tag::species >().resize(1);
411 : :
412 : : // store material properties
413 [ + + ]: 198 : for (std::size_t i=0; i<gideck.get< tag::material >().size(); ++i) {
414 : :
415 [ + - ][ + - ]: 99 : checkBlock< inciter::ctr::materialList::Keys >(sol_mat[i+1], "material");
[ + - ][ + - ]
416 : :
417 : 99 : auto& mati_deck = gideck.get< tag::material >()[i];
418 : : // eos
419 [ + - ][ + - ]: 297 : storeOptIfSpecd< inciter::ctr::MaterialType, inciter::ctr::Material >(
[ + - ]
420 [ + - ]: 198 : sol_mat[i+1], "eos", mati_deck.get< tag::eos >(),
421 : : inciter::ctr::MaterialType::STIFFENEDGAS);
422 : :
423 : : // material ids in this eos (default is for compflow i.e. single mat)
424 [ + - ][ + - ]: 297 : storeVecIfSpecd< uint64_t >(
[ + - ]
425 [ + - ]: 198 : sol_mat[i+1], "id", mati_deck.get< tag::id >(),
426 [ + - ]: 198 : std::vector< uint64_t >(1,1));
427 : :
428 : : // Track total number of materials in multiple material blocks (eos's)
429 : 99 : tmat += mati_deck.get< tag::id >().size();
430 : :
431 : : // Check for repeating user specified material ids
432 [ + + ]: 250 : for (auto midx : mati_deck.get< tag::id >()) {
433 [ + - ][ + - ]: 151 : if (!matidset.count(midx))
434 [ + - ]: 151 : matidset.insert(midx);
435 : : else
436 [ - - ][ - - ]: 0 : Throw("Repeating material id specified");
[ - - ]
437 : : }
438 : :
439 : 99 : std::size_t ntype = mati_deck.get< tag::id >().size();
440 : : // cv
441 [ + - ][ + - ]: 99 : if (!sol_mat[i+1]["cv"].valid())
[ + - ][ + + ]
442 [ + - ][ + - ]: 73 : sol_mat[i+1]["cv"] = std::vector< tk::real >(ntype, 717.5);
[ + - ][ + - ]
443 [ + - ][ + - ]: 99 : checkStoreMatProp(sol_mat[i+1], "cv", ntype, mati_deck.get< tag::cv >());
[ + - ][ + - ]
444 : :
445 : : // reset solid-marker
446 : 99 : is_solid = false;
447 : :
448 : : // Stiffened-gas materials
449 [ + + ]: 99 : if (mati_deck.get< tag::eos >() ==
450 : : inciter::ctr::MaterialType::STIFFENEDGAS) {
451 : : // gamma
452 [ + - ][ + - ]: 96 : checkStoreMatProp(sol_mat[i+1], "gamma", ntype,
[ + - ][ + - ]
453 : : mati_deck.get< tag::gamma >());
454 : :
455 : : // pstiff
456 [ + - ][ + - ]: 96 : if (!sol_mat[i+1]["pstiff"].valid())
[ + - ][ + + ]
457 [ + - ][ + - ]: 93 : sol_mat[i+1]["pstiff"] = std::vector< tk::real >(ntype, 0.0);
[ + - ][ + - ]
458 [ + - ][ + - ]: 96 : checkStoreMatProp(sol_mat[i+1], "pstiff", ntype,
[ + - ][ + - ]
459 : : mati_deck.get< tag::pstiff >());
460 : :
461 : : // mu (dynamic viscosity) and 'viscous' keyword
462 [ + - ][ + - ]: 96 : if (!sol_mat[i+1]["mu"].valid())
[ + - ][ + - ]
463 [ + - ][ + - ]: 96 : sol_mat[i+1]["mu"] = std::vector< tk::real >(ntype, 0.0);
[ + - ][ + - ]
464 : 0 : else gideck.get< tag::multimat, tag::viscous >() = true;
465 [ + - ][ + - ]: 96 : checkStoreMatProp(sol_mat[i+1], "mu", ntype, mati_deck.get< tag::mu >());
[ + - ][ + - ]
466 : : }
467 : : // Small-shear solid materials
468 [ - + ]: 3 : else if (mati_deck.get< tag::eos >() ==
469 : : inciter::ctr::MaterialType::SMALLSHEARSOLID) {
470 : : // gamma
471 [ - - ][ - - ]: 0 : checkStoreMatProp(sol_mat[i+1], "gamma", ntype,
[ - - ][ - - ]
472 : : mati_deck.get< tag::gamma >());
473 : :
474 : : // pstiff
475 [ - - ][ - - ]: 0 : if (!sol_mat[i+1]["pstiff"].valid())
[ - - ][ - - ]
476 [ - - ][ - - ]: 0 : sol_mat[i+1]["pstiff"] = std::vector< tk::real >(ntype, 0.0);
[ - - ][ - - ]
477 [ - - ][ - - ]: 0 : checkStoreMatProp(sol_mat[i+1], "pstiff", ntype,
[ - - ][ - - ]
478 : : mati_deck.get< tag::pstiff >());
479 : :
480 : : // mu
481 [ - - ][ - - ]: 0 : checkStoreMatProp(sol_mat[i+1], "mu", ntype,
[ - - ][ - - ]
482 : : mati_deck.get< tag::mu >());
483 : :
484 : : // yield_stress
485 [ - - ][ - - ]: 0 : if (!sol_mat[i+1]["yield_stress"].valid())
[ - - ][ - - ]
486 : 0 : sol_mat[i+1]["yield_stress"] =
487 [ - - ][ - - ]: 0 : std::vector< tk::real >(ntype, 300.0e+06);
[ - - ][ - - ]
488 [ - - ][ - - ]: 0 : checkStoreMatProp(sol_mat[i+1], "yield_stress", ntype,
[ - - ][ - - ]
489 : : mati_deck.get< tag::yield_stress >());
490 : :
491 : : // assign solid
492 : 0 : is_solid = true;
493 : : }
494 : : // Godunov-Romenski aluminum materials
495 [ - + ]: 3 : else if (mati_deck.get< tag::eos >() ==
496 : : inciter::ctr::MaterialType::GODUNOVROMENSKIALUMINUM) {
497 : : // gamma
498 [ - - ][ - - ]: 0 : checkStoreMatProp(sol_mat[i+1], "gamma", ntype,
[ - - ][ - - ]
499 : : mati_deck.get< tag::gamma >());
500 : :
501 : : // mu
502 [ - - ][ - - ]: 0 : checkStoreMatProp(sol_mat[i+1], "mu", ntype,
[ - - ][ - - ]
503 : : mati_deck.get< tag::mu >());
504 : :
505 : : // yield_stress
506 [ - - ][ - - ]: 0 : if (!sol_mat[i+1]["yield_stress"].valid())
[ - - ][ - - ]
507 : 0 : sol_mat[i+1]["yield_stress"] =
508 [ - - ][ - - ]: 0 : std::vector< tk::real >(ntype, 300.0e+06);
[ - - ][ - - ]
509 [ - - ][ - - ]: 0 : checkStoreMatProp(sol_mat[i+1], "yield_stress", ntype,
[ - - ][ - - ]
510 : : mati_deck.get< tag::yield_stress >());
511 : :
512 : : // assign solid
513 : 0 : is_solid = true;
514 : : }
515 : : // JWL materials
516 [ - + ]: 3 : else if (mati_deck.get< tag::eos >() == inciter::ctr::MaterialType::JWL) {
517 : : // w_gru
518 [ - - ][ - - ]: 0 : checkStoreMatProp(sol_mat[i+1], "w_gru", ntype,
[ - - ][ - - ]
519 : : mati_deck.get< tag::w_gru >());
520 : :
521 : : // a_jwl
522 [ - - ][ - - ]: 0 : checkStoreMatProp(sol_mat[i+1], "A_jwl", ntype,
[ - - ][ - - ]
523 : : mati_deck.get< tag::A_jwl >());
524 : :
525 : : // b_jwl
526 [ - - ][ - - ]: 0 : checkStoreMatProp(sol_mat[i+1], "B_jwl", ntype,
[ - - ][ - - ]
527 : : mati_deck.get< tag::B_jwl >());
528 : :
529 : : // R1_jwl
530 [ - - ][ - - ]: 0 : checkStoreMatProp(sol_mat[i+1], "R1_jwl", ntype,
[ - - ][ - - ]
531 : : mati_deck.get< tag::R1_jwl >());
532 : :
533 : : // R2_jwl
534 [ - - ][ - - ]: 0 : checkStoreMatProp(sol_mat[i+1], "R2_jwl", ntype,
[ - - ][ - - ]
535 : : mati_deck.get< tag::R2_jwl >());
536 : :
537 : : // rho0_jwl
538 [ - - ][ - - ]: 0 : checkStoreMatProp(sol_mat[i+1], "rho0_jwl", ntype,
[ - - ][ - - ]
539 : : mati_deck.get< tag::rho0_jwl >());
540 : :
541 : : // de_jwl
542 [ - - ][ - - ]: 0 : checkStoreMatProp(sol_mat[i+1], "de_jwl", ntype,
[ - - ][ - - ]
543 : : mati_deck.get< tag::de_jwl >());
544 : :
545 : : // Pr_jwl
546 [ - - ][ - - ]: 0 : checkStoreMatProp(sol_mat[i+1], "Pr_jwl", ntype,
[ - - ][ - - ]
547 : : mati_deck.get< tag::Pr_jwl >());
548 : :
549 : : // rhor_jwl
550 [ - - ][ - - ]: 0 : if (sol_mat[i+1]["rhor_jwl"].valid()) {
[ - - ][ - - ]
551 [ - - ][ - - ]: 0 : checkStoreMatProp(sol_mat[i+1], "rhor_jwl", ntype,
[ - - ][ - - ]
552 : : mati_deck.get< tag::rhor_jwl >());
553 : : }
554 : : // Tr_jwl
555 [ - - ][ - - ]: 0 : else if (sol_mat[i+1]["Tr_jwl"].valid()) {
[ - - ][ - - ]
556 [ - - ][ - - ]: 0 : checkStoreMatProp(sol_mat[i+1], "Tr_jwl", ntype,
[ - - ][ - - ]
557 : : mati_deck.get< tag::Tr_jwl >());
558 : : }
559 : : else
560 [ - - ][ - - ]: 0 : Throw("Either reference density or reference temperature must be "
[ - - ]
561 : : "specified for JWL equation of state (EOS).");
562 : : }
563 : : // Thermally-perfect gas materials
564 [ + - ]: 3 : else if (mati_deck.get< tag::eos >() ==
565 : : inciter::ctr::MaterialType::THERMALLYPERFECTGAS) {
566 : :
567 [ + - ][ + - ]: 3 : if (!lua_ideck["species"].valid())
[ - + ]
568 [ - - ][ - - ]: 0 : Throw("Species block must be specified for thermally perfect gas");
[ - - ]
569 [ + - ][ + - ]: 3 : sol::table sol_spc = lua_ideck["species"];
570 : :
571 : : // We have assumed that nmat == 1 always for multi species, and that
572 : : // all species are of a single type, so that the outer species vector
573 : : // is of size one
574 : 3 : auto& spci_deck = gideck.get< tag::species >()[0];
575 : :
576 : : // species ids (default is for single species)
577 [ + - ][ + - ]: 9 : storeVecIfSpecd< uint64_t >(
[ + - ]
578 [ + - ]: 6 : sol_spc[i+1], "id", spci_deck.get< tag::id >(),
579 [ + - ]: 6 : std::vector< uint64_t >(1,1));
580 : :
581 [ - + ][ - - ]: 3 : Assert(nspec == spci_deck.get< tag::id >().size(),
[ - - ][ - - ]
582 : : "Number of ids in species-block not equal to number of species");
583 : :
584 : : // gamma
585 [ + - ][ + - ]: 3 : checkStoreMatProp(sol_spc[i+1], "gamma", nspec,
[ + - ][ + - ]
586 : : spci_deck.get< tag::gamma >());
587 : : // R
588 [ + - ][ + - ]: 3 : checkStoreMatProp(sol_spc[i+1], "R", nspec,
[ + - ][ + - ]
589 : : spci_deck.get< tag::R >());
590 : : // cp_coeff
591 [ + - ][ + - ]: 3 : checkStoreMatPropVec(sol_spc[i+1], "cp_coeff", nspec, 8,
[ + - ][ + - ]
592 : : spci_deck.get< tag::cp_coeff >());
593 : : }
594 : :
595 : : // Generate mapping between material index and eos parameter index
596 : 99 : auto& eosmap = gideck.get< tag::matidxmap, tag::eosidx >();
597 : 99 : auto& idxmap = gideck.get< tag::matidxmap, tag::matidx >();
598 : 99 : auto& solidxmap = gideck.get< tag::matidxmap, tag::solidx >();
599 [ + + ]: 250 : for (auto midx : mati_deck.get< tag::id >()) {
600 : 151 : midx -= 1;
601 : 151 : eosmap[midx] = mtypei;
602 : 151 : idxmap[midx] = imatcntr;
603 [ - + ]: 151 : if (is_solid) {
604 : : // add to solid-counter
605 : 0 : ++isolcntr;
606 : 0 : solidxmap[midx] = isolcntr;
607 : : }
608 : 151 : ++imatcntr;
609 : : }
610 : : // end of materials for this eos, thus reset index counter
611 : 99 : imatcntr = 0;
612 : : // increment material-type/eos-type index counter
613 : 99 : ++mtypei;
614 : : }
615 : :
616 : : // Error checking on material ids
617 : : // -------------------------------------------------------------------------
618 : :
619 : : // Total number of materials
620 [ - + ]: 99 : if (tmat != nmat)
621 [ - - ][ - - ]: 0 : Throw("The total number of materials in all the material blocks (" +
[ - - ][ - - ]
[ - - ]
622 : : std::to_string(tmat) +
623 : : ") is not equal to the number of materials specified 'nmat'.");
624 : :
625 : : // Contiguous and 1-based material ids
626 [ - + ]: 99 : if (*matidset.begin() != 1)
627 [ - - ][ - - ]: 0 : Throw("Material ids specified in material blocks not one-based. "
[ - - ]
628 : : "Material ids must begin with one.");
629 : 99 : std::size_t icount(1);
630 [ + + ]: 250 : for (auto midx : matidset) {
631 [ - + ]: 151 : if (midx != icount)
632 [ - - ][ - - ]: 0 : Throw("Material ids specified in material blocks have a gap. "
[ - - ]
633 : : "Material ids must be contiguous.");
634 : 151 : ++icount;
635 : : }
636 : :
637 : : // Set up number of PDEs for multimat
638 [ + + ]: 99 : if (gideck.get< tag::pde >() == inciter::ctr::PDEType::MULTIMAT) {
639 : 32 : auto ntot = nmat + nmat + 3 + nmat;
640 : : // if solid EOS, add components
641 : 32 : const auto& solidx = gideck.get< tag::matidxmap, tag::solidx >();
642 [ + + ]: 116 : for (std::size_t i=0; i<solidx.size(); ++i) {
643 [ - + ]: 84 : if (solidx[i] > 0)
644 : 0 : ntot += 9;
645 : : }
646 : 32 : gideck.get< tag::ncomp >() = ntot;
647 : : }
648 : : }
649 : :
650 : : // Mesh specification block (for overset)
651 : : // ---------------------------------------------------------------------------
652 [ + - ][ + - ]: 191 : if (lua_ideck["mesh"].valid()) {
[ + + ]
653 [ + - ][ + - ]: 24 : const sol::table& lua_mesh = lua_ideck["mesh"];
654 : 12 : auto& mesh_deck = gideck.get< tag::mesh >();
655 [ + - ][ + - ]: 12 : mesh_deck.resize(lua_mesh.size());
656 : :
657 [ + + ]: 26 : for (std::size_t i=0; i<mesh_deck.size(); ++i) {
658 : :
659 [ + - ][ + - ]: 14 : checkBlock< inciter::ctr::meshList::Keys >(lua_mesh[i+1], "mesh");
[ + - ][ + - ]
660 : :
661 : : // filename
662 [ + - ][ + - ]: 28 : storeIfSpecd< std::string >(lua_mesh[i+1], "filename",
[ + - ][ + - ]
[ + - ]
663 : 14 : mesh_deck[i].get< tag::filename >(), "");
664 : :
665 : : // location
666 [ + - ][ + - ]: 28 : storeVecIfSpecd< tk::real >(lua_mesh[i+1], "location",
[ + - ][ + - ]
[ + - ]
667 : 14 : mesh_deck[i].get< tag::location >(), {0.0, 0.0, 0.0});
668 [ - + ]: 14 : if (mesh_deck[i].get< tag::location >().size() != 3)
669 [ - - ][ - - ]: 0 : Throw("Mesh location requires 3 coordinates.");
[ - - ]
670 : :
671 : : // orientation
672 [ + - ][ + - ]: 28 : storeVecIfSpecd< tk::real >(lua_mesh[i+1], "orientation",
[ + - ][ + - ]
[ + - ]
673 : 14 : mesh_deck[i].get< tag::orientation >(), {0.0, 0.0, 0.0});
674 [ - + ]: 14 : if (mesh_deck[i].get< tag::orientation >().size() != 3)
675 [ - - ][ - - ]: 0 : Throw("Mesh orientation requires 3 rotation angles.");
[ - - ]
676 : :
677 : : // velocity
678 [ + - ][ + - ]: 28 : storeVecIfSpecd< tk::real >(lua_mesh[i+1], "velocity",
[ + - ][ + - ]
[ + - ]
679 : 14 : mesh_deck[i].get< tag::velocity >(), {0.0, 0.0, 0.0});
680 [ - + ]: 14 : if (mesh_deck[i].get< tag::velocity >().size() != 3)
681 [ - - ][ - - ]: 0 : Throw("Mesh velocity requires 3 components.");
[ - - ]
682 : :
683 : : // Transfer object
684 [ + + ]: 14 : if (i > 0) {
685 [ + - ]: 2 : gideck.get< tag::transfer >().emplace_back( 0, i );
686 : :
687 : : // assign depvar
688 : 2 : ++depvar_cnt;
689 [ + - ]: 2 : gideck.get< tag::depvar >().push_back(depvar_cnt);
690 : :
691 : : // add depvar to deck::depvars so it can be selected as outvar later
692 [ + - ]: 2 : tk::grm::depvars.insert(depvar_cnt);
693 : : }
694 : : }
695 : : }
696 : : else {
697 : : // TODO: remove double-specification of defaults
698 : 179 : auto& mesh_deck = gideck.get< tag::mesh >();
699 [ + - ]: 179 : mesh_deck.resize(1);
700 : 179 : mesh_deck[0].get< tag::filename >() =
701 [ + - ]: 358 : gideck.get< tag::cmd, tag::io, tag::input >();
702 [ + - ]: 179 : mesh_deck[0].get< tag::location >() = {0.0, 0.0, 0.0};
703 [ + - ]: 179 : mesh_deck[0].get< tag::orientation >() = {0.0, 0.0, 0.0};
704 [ + - ]: 179 : mesh_deck[0].get< tag::velocity >() = {0.0, 0.0, 0.0};
705 : : }
706 : :
707 [ - + ][ - - ]: 191 : Assert(gideck.get< tag::mesh >().size() == gideck.get< tag::depvar >().size(),
[ - - ][ - - ]
708 : : "Number of depvar not equal to the number of meshes.");
709 : :
710 : : // Field output block
711 : : // ---------------------------------------------------------------------------
712 [ + - ][ + - ]: 191 : if (lua_ideck["field_output"].valid()) {
[ + - ]
713 : :
714 [ + - ][ + - ]: 191 : checkBlock< inciter::ctr::fieldOutputList::Keys >(lua_ideck["field_output"],
[ + - ][ + - ]
715 : : "field_output");
716 : :
717 : 191 : auto& fo_deck = gideck.get< tag::field_output >();
718 : :
719 : : // interval iteration
720 [ + - ][ + - ]: 191 : storeIfSpecd< uint32_t >(
[ + - ][ + - ]
721 : : lua_ideck["field_output"], "interval",
722 : : fo_deck.get< tag::interval >(),
723 : : std::numeric_limits< uint32_t >::max());
724 : :
725 : : // interval physical time
726 [ + - ][ + - ]: 191 : storeIfSpecd< tk::real >(
[ + - ][ + - ]
727 : : lua_ideck["field_output"], "time_interval",
728 : : fo_deck.get< tag::time_interval >(),
729 : : std::numeric_limits< tk::real >::max());
730 : :
731 : : // interval time range
732 [ + - ][ + - ]: 191 : storeVecIfSpecd< tk::real >(
[ + - ][ + - ]
733 : : lua_ideck["field_output"], "time_range",
734 : : fo_deck.get< tag::time_range >(), {});
735 : :
736 : : // refined mesh field output
737 [ + - ][ + - ]: 191 : storeIfSpecd< bool >(
[ + - ][ + - ]
738 : : lua_ideck["field_output"], "refined", fo_deck.get< tag::refined >(),
739 : : false);
740 : 191 : gideck.get< tag::cmd, tag::io, tag::refined >() = fo_deck.get< tag::refined >();
741 : :
742 : : // filetype
743 [ + - ][ + - ]: 191 : storeOptIfSpecd< tk::ctr::FieldFileType, tk::ctr::FieldFile >(
[ + - ][ + - ]
744 : : lua_ideck["field_output"], "filetype", fo_deck.get< tag::filetype >(),
745 : : tk::ctr::FieldFileType::EXODUSII);
746 : :
747 : : // sidesets for field output
748 [ + - ][ + - ]: 191 : storeVecIfSpecd< uint64_t >(
[ + - ][ + - ]
749 : : lua_ideck["field_output"], "sideset", fo_deck.get< tag::sideset >(), {});
750 : :
751 : : // Assign outvar
752 : 191 : auto& foutvar = fo_deck.get< tag::outvar >();
753 : 191 : std::size_t nevar(0), nnvar(0), tensorcompvar(0);
754 : 191 : std::size_t nmat(1);
755 [ + + ]: 191 : if (gideck.get< tag::pde >() == inciter::ctr::PDEType::MULTIMAT)
756 : 32 : nmat = gideck.get< tag::multimat, tag::nmat >();
757 : :
758 : : // elem aliases
759 : 382 : std::vector< std::string > elemalias;
760 [ + - ][ + - ]: 191 : if (lua_ideck["field_output"]["elemvar"].valid())
[ + - ][ + + ]
761 [ + - ][ + - ]: 86 : nevar = sol::table(lua_ideck["field_output"]["elemvar"]).size();
[ + - ][ + - ]
762 [ + - ][ + - ]: 191 : storeVecIfSpecd< std::string >(
[ + - ][ + - ]
763 : : lua_ideck["field_output"], "elemalias", elemalias,
764 [ + - ][ + - ]: 382 : std::vector< std::string >(nevar, ""));
765 : :
766 : : // node aliases
767 : 382 : std::vector< std::string > nodealias;
768 [ + - ][ + - ]: 191 : if (lua_ideck["field_output"]["nodevar"].valid())
[ + - ][ + + ]
769 [ + - ][ + - ]: 40 : nnvar = sol::table(lua_ideck["field_output"]["nodevar"]).size();
[ + - ][ + - ]
770 [ + - ][ + - ]: 191 : storeVecIfSpecd< std::string >(
[ + - ][ + - ]
771 : : lua_ideck["field_output"], "nodealias", nodealias,
772 [ + - ][ + - ]: 382 : std::vector< std::string >(nnvar, ""));
773 : :
774 : : // error check on aliases
775 [ - + ]: 191 : if (elemalias.size() != nevar)
776 [ - - ][ - - ]: 0 : Throw("elemalias should have the same size as elemvar.");
[ - - ]
777 [ - + ]: 191 : if (nodealias.size() != nnvar)
778 [ - - ][ - - ]: 0 : Throw("nodealias should have the same size as nodevar.");
[ - - ]
779 : :
780 : : // element variables
781 [ + - ][ + - ]: 191 : if (lua_ideck["field_output"]["elemvar"].valid()) {
[ + - ][ + + ]
782 [ + + ]: 486 : for (std::size_t i=0; i<nevar; ++i) {
783 [ + - ][ + - ]: 800 : std::string varname(lua_ideck["field_output"]["elemvar"][i+1]);
[ + - ][ + - ]
784 [ + - ]: 800 : std::string alias(elemalias[i]);
785 : : // add extra outvars for tensor components
786 [ - + ]: 400 : if (varname.find("_tensor") != std::string::npos) tensorcompvar += 8;
787 [ + - ]: 400 : addOutVar(varname, alias, gideck.get< tag::depvar >(), nmat,
788 : 400 : nspec, gideck.get< tag::pde >(), tk::Centering::ELEM, foutvar);
789 : : }
790 : : }
791 : :
792 : : // node variables
793 [ + - ][ + - ]: 191 : if (lua_ideck["field_output"]["nodevar"].valid()) {
[ + - ][ + + ]
794 [ + + ]: 263 : for (std::size_t i=0; i<nnvar; ++i) {
795 [ + - ][ + - ]: 446 : std::string varname(lua_ideck["field_output"]["nodevar"][i+1]);
[ + - ][ + - ]
796 [ + - ]: 446 : std::string alias(nodealias[i]);
797 : : // add extra outvars for tensor components
798 [ - + ]: 223 : if (varname.find("_tensor") != std::string::npos) tensorcompvar += 8;
799 [ + - ]: 223 : addOutVar(varname, alias, gideck.get< tag::depvar >(), nmat,
800 : 223 : nspec, gideck.get< tag::pde >(), tk::Centering::NODE, foutvar);
801 : : }
802 : : }
803 : :
804 [ - + ][ - - ]: 191 : Assert(foutvar.size() == (nevar + nnvar + tensorcompvar),
[ - - ][ - - ]
805 : : "Incorrectly sized outvar vector.");
806 : : }
807 : : else {
808 : : // TODO: remove double-specification of defaults
809 : 0 : auto& fo_deck = gideck.get< tag::field_output >();
810 : 0 : fo_deck.get< tag::interval >() =
811 : 0 : std::numeric_limits< uint32_t >::max();
812 : 0 : fo_deck.get< tag::time_interval >() =
813 : 0 : std::numeric_limits< tk::real >::max();
814 [ - - ]: 0 : fo_deck.get< tag::time_range >() = {};
815 : 0 : fo_deck.get< tag::refined >() = false;
816 : 0 : fo_deck.get< tag::filetype >() = tk::ctr::FieldFileType::EXODUSII;
817 [ - - ]: 0 : fo_deck.get< tag::sideset >() = {};
818 : : }
819 : :
820 : : // Diagnostics output block
821 : : // ---------------------------------------------------------------------------
822 [ + - ][ + - ]: 191 : if (lua_ideck["diagnostics"].valid()) {
[ + + ]
823 : :
824 [ + - ][ + - ]: 102 : checkBlock< inciter::ctr::diagnosticsList::Keys >(lua_ideck["diagnostics"],
[ + - ][ + - ]
825 : : "diagnostics");
826 : :
827 : 102 : auto& diag_deck = gideck.get< tag::diagnostics >();
828 : :
829 : : // interval iteration
830 [ + - ][ + - ]: 102 : storeIfSpecd< uint32_t >(
[ + - ][ + - ]
831 : : lua_ideck["diagnostics"], "interval",
832 : : diag_deck.get< tag::interval >(), 1);
833 : :
834 : : // error norm
835 [ + - ][ + - ]: 102 : storeOptIfSpecd< tk::ctr::ErrorType, tk::ctr::Error >(
[ + - ][ + - ]
836 : : lua_ideck["diagnostics"], "error", diag_deck.get< tag::error >(),
837 : : tk::ctr::ErrorType::L2);
838 : :
839 : : // float format
840 [ + - ][ + - ]: 102 : storeOptIfSpecd< tk::ctr::TxtFloatFormatType, tk::ctr::TxtFloatFormat >(
[ + - ][ + - ]
841 : : lua_ideck["diagnostics"], "format", diag_deck.get< tag::format >(),
842 : : tk::ctr::TxtFloatFormatType::DEFAULT);
843 : :
844 : : // precision
845 [ + - ][ + - ]: 102 : storeIfSpecd< std::streamsize >(
[ + - ][ + - ]
846 : : lua_ideck["diagnostics"], "precision",
847 : : diag_deck.get< tag::precision >(), std::cout.precision());
848 : : }
849 : : else {
850 : : // TODO: remove double-specification of defaults
851 : 89 : auto& diag_deck = gideck.get< tag::diagnostics >();
852 : 89 : diag_deck.get< tag::interval >() = 1;
853 : 89 : diag_deck.get< tag::error >() = tk::ctr::ErrorType::L2;
854 : 89 : diag_deck.get< tag::format >() = tk::ctr::TxtFloatFormatType::DEFAULT;
855 : 89 : diag_deck.get< tag::precision >() = std::cout.precision();
856 : : }
857 : :
858 : : // History output block
859 : : // ---------------------------------------------------------------------------
860 [ + - ][ + - ]: 191 : if (lua_ideck["history_output"].valid()) {
[ + + ]
861 : :
862 [ + - ][ + - ]: 5 : checkBlock< inciter::ctr::historyOutputList::Keys >(
[ + - ][ + - ]
863 : : lua_ideck["history_output"], "history_output");
864 : :
865 : 5 : auto& hist_deck = gideck.get< tag::history_output >();
866 : :
867 : : // interval iteration
868 [ + - ][ + - ]: 5 : storeIfSpecd< uint32_t >(
[ + - ][ + - ]
869 : : lua_ideck["history_output"], "interval",
870 : : hist_deck.get< tag::interval >(),
871 : : std::numeric_limits< uint32_t >::max());
872 : :
873 : : // interval time
874 [ + - ][ + - ]: 5 : storeIfSpecd< tk::real >(
[ + - ][ + - ]
875 : : lua_ideck["history_output"], "time_interval",
876 : : hist_deck.get< tag::time_interval >(),
877 : : std::numeric_limits< tk::real >::max());
878 : :
879 : : // interval time range
880 [ + - ][ + - ]: 5 : storeVecIfSpecd< tk::real >(
[ + - ][ + - ]
881 : : lua_ideck["history_output"], "time_range",
882 : : hist_deck.get< tag::time_range >(), {});
883 : :
884 : : // point probes
885 [ + - ][ + - ]: 5 : if (lua_ideck["history_output"]["point"].valid()) {
[ + - ][ + - ]
886 [ + - ][ + - ]: 10 : const sol::table& sol_pt = lua_ideck["history_output"]["point"];
[ + - ]
887 [ + - ][ + - ]: 5 : hist_deck.get< tag::point >().resize(sol_pt.size());
888 : :
889 [ + + ]: 14 : for (std::size_t i=0; i<hist_deck.get< tag::point >().size(); ++i) {
890 : 9 : auto& pti = hist_deck.get< tag::point >()[i];
891 [ + - ][ + - ]: 27 : storeIfSpecd< std::string >(
[ + - ][ + - ]
892 [ + - ]: 18 : sol_pt[i+1], "id", pti.get< tag::id >(), "p");
893 [ + - ][ + - ]: 27 : storeVecIfSpecd< tk::real >(
[ + - ]
894 [ + - ]: 18 : sol_pt[i+1], "coord", pti.get< tag::coord >(), {});
895 : : }
896 : : }
897 : :
898 : : // float format
899 [ + - ][ + - ]: 5 : storeOptIfSpecd< tk::ctr::TxtFloatFormatType, tk::ctr::TxtFloatFormat >(
[ + - ][ + - ]
900 : : lua_ideck["history_output"], "format", hist_deck.get< tag::format >(),
901 : : tk::ctr::TxtFloatFormatType::DEFAULT);
902 : :
903 : : // precision
904 [ + - ][ + - ]: 5 : storeIfSpecd< std::streamsize >(
[ + - ][ + - ]
905 : : lua_ideck["history_output"], "precision",
906 : : hist_deck.get< tag::precision >(), std::cout.precision());
907 : :
908 : : // error check point
909 [ + + ]: 14 : for (std::size_t i=0; i<hist_deck.get< tag::point >().size(); ++i) {
910 [ - + ]: 9 : if (hist_deck.get< tag::point >()[i].get< tag::coord >().size() != 3)
911 [ - - ][ - - ]: 0 : Throw("Three reals required for point coordinates in history_output.");
[ - - ]
912 : : }
913 : : }
914 : : else {
915 : : // TODO: remove double-specification of defaults
916 : 186 : auto& hist_deck = gideck.get< tag::history_output >();
917 : 186 : hist_deck.get< tag::interval >() =
918 : 186 : std::numeric_limits< uint32_t >::max();
919 : 186 : hist_deck.get< tag::time_interval >() =
920 : 186 : std::numeric_limits< tk::real >::max();
921 [ + - ]: 186 : hist_deck.get< tag::time_range >() = {};
922 : 186 : hist_deck.get< tag::precision >() = std::cout.precision();
923 [ + - ]: 186 : hist_deck.get< tag::point >().resize(0);
924 : : }
925 : :
926 : : // ALE block
927 : : // ---------------------------------------------------------------------------
928 : 191 : gideck.get< tag::ale, tag::ale >() = false;
929 [ + - ][ + - ]: 191 : if (lua_ideck["ale"].valid()) {
[ + + ]
930 : 10 : auto& ale_deck = gideck.get< tag::ale >();
931 : 10 : ale_deck.get< tag::ale >() = true;
932 : :
933 : : // Mesh velocity smoother
934 : : storeOptIfSpecd< inciter::ctr::MeshVelocitySmootherType,
935 [ + - ][ + - ]: 10 : inciter::ctr::MeshVelocitySmoother >(lua_ideck["ale"], "smoother",
[ + - ][ + - ]
936 : : ale_deck.get< tag::smoother >(), inciter::ctr::MeshVelocitySmootherType::NONE);
937 : :
938 : : // Mesh velocity
939 : : storeOptIfSpecd< inciter::ctr::MeshVelocityType,
940 [ + - ][ + - ]: 10 : inciter::ctr::MeshVelocity >(lua_ideck["ale"], "mesh_velocity",
[ + - ][ + - ]
941 : : ale_deck.get< tag::mesh_velocity >(), inciter::ctr::MeshVelocityType::SINE);
942 : :
943 : : // Mesh motion direction
944 [ + - ][ + - ]: 10 : storeVecIfSpecd< std::size_t >(lua_ideck["ale"], "mesh_motion",
[ + - ][ + - ]
[ + - ]
945 : : ale_deck.get< tag::mesh_motion >(), { 0, 1, 2 });
946 : :
947 : : // Mesh force
948 [ + - ][ + - ]: 10 : storeVecIfSpecd< tk::real >(lua_ideck["ale"], "meshforce",
[ + - ][ + - ]
[ + - ]
949 : : ale_deck.get< tag::meshforce >(), { 0, 0, 0, 0 });
950 : :
951 : : // Dirichlet
952 [ + - ][ + - ]: 10 : storeVecIfSpecd< std::size_t >(lua_ideck["ale"], "dirichlet",
[ + - ][ + - ]
953 : : ale_deck.get< tag::dirichlet >(), {});
954 : :
955 : : // Symmetry
956 [ + - ][ + - ]: 10 : storeVecIfSpecd< std::size_t >(lua_ideck["ale"], "symmetry",
[ + - ][ + - ]
957 : : ale_deck.get< tag::symmetry >(), {});
958 : :
959 : : // Move sidesets with user defined function
960 [ + - ][ + - ]: 10 : if (lua_ideck["ale"]["move"].valid()) {
[ + - ][ + + ]
961 [ + - ][ + - ]: 4 : const sol::table& sol_mv = lua_ideck["ale"]["move"];
[ + - ]
962 [ + - ][ + - ]: 2 : ale_deck.get< tag::move >().resize(sol_mv.size());
963 : :
964 [ + + ]: 4 : for (std::size_t i=0; i<ale_deck.get< tag::move >().size(); ++i) {
965 : 2 : auto& mvi = ale_deck.get< tag::move >()[i];
966 [ + - ][ + - ]: 6 : storeOptIfSpecd< tk::ctr::UserTableType, tk::ctr::UserTable >(
[ + - ]
967 [ + - ]: 4 : sol_mv[i+1], "fntype", mvi.get< tag::fntype >(),
968 : : tk::ctr::UserTableType::POSITION);
969 [ + - ][ + - ]: 6 : storeVecIfSpecd< uint64_t >(
[ + - ]
970 [ + - ]: 4 : sol_mv[i+1], "sideset", mvi.get< tag::sideset >(), {});
971 [ + - ][ + - ]: 6 : storeVecIfSpecd< tk::real >(
[ + - ]
972 [ + - ]: 4 : sol_mv[i+1], "fn", mvi.get< tag::fn >(), {});
973 : :
974 : : // error checking on user-def function
975 [ - + ]: 2 : if (mvi.get< tag::fn >().size() % 4 != 0)
976 [ - - ][ - - ]: 0 : Throw("Incomplete user-defined function for ALE sideset movement. An "
[ - - ]
977 : : "R->R^3 function is expected, the number of descrete entries must be "
978 : : "divisible by 4: one 'column' for the abscissa, and 3 for the "
979 : : "ordinate.");
980 : : }
981 : : }
982 : :
983 : : // dv-CFL
984 [ + - ][ + - ]: 10 : storeIfSpecd< tk::real >(lua_ideck["ale"], "dvcfl", ale_deck.get< tag::dvcfl >(),
[ + - ][ + - ]
985 : : 0.01);
986 : :
987 : : // Vorticity multiplier
988 [ + - ][ + - ]: 10 : storeIfSpecd< tk::real >(lua_ideck["ale"], "vortmult",
[ + - ][ + - ]
989 : : ale_deck.get< tag::vortmult >(), 0.0);
990 : :
991 : : // Mesh velocity max iterations
992 [ + - ][ + - ]: 10 : storeIfSpecd< std::size_t >(lua_ideck["ale"], "maxit",
[ + - ][ + - ]
993 : : ale_deck.get< tag::maxit >(), 5);
994 : :
995 : : // Mesh velocity max iterations
996 [ + - ][ + - ]: 10 : storeIfSpecd< tk::real >(lua_ideck["ale"], "tolerance",
[ + - ][ + - ]
997 : : ale_deck.get< tag::tolerance >(), 1e-2);
998 : : }
999 : :
1000 : : // AMR block
1001 : : // ---------------------------------------------------------------------------
1002 : 191 : gideck.get< tag::amr, tag::amr >() = false;
1003 : 191 : gideck.get< tag::amr, tag::maxlevels >() = 2; // this is needed for outref
1004 [ + - ][ + - ]: 191 : if (lua_ideck["amr"].valid()) {
[ + + ]
1005 : 20 : auto& amr_deck = gideck.get< tag::amr >();
1006 : 20 : amr_deck.get< tag::amr >() = true;
1007 : :
1008 : : // Initial refinement toggle
1009 [ + - ][ + - ]: 20 : storeIfSpecd< bool >(lua_ideck["amr"], "t0ref", amr_deck.get< tag::t0ref >(),
[ + - ][ + - ]
1010 : : false);
1011 : :
1012 : : // Mesh refinement during time-stepping toggle
1013 [ + - ][ + - ]: 20 : storeIfSpecd< bool >(lua_ideck["amr"], "dtref", amr_deck.get< tag::dtref >(),
[ + - ][ + - ]
1014 : : false);
1015 : :
1016 : : // Uniform mesh refinement during time-stepping toggle
1017 [ + - ][ + - ]: 20 : storeIfSpecd< bool >(lua_ideck["amr"], "dtref_uniform",
[ + - ][ + - ]
1018 : : amr_deck.get< tag::dtref_uniform >(), false);
1019 : :
1020 : : // Mesh refinement frequency during time-stepping toggle
1021 [ + - ][ + - ]: 20 : storeIfSpecd< std::size_t >(lua_ideck["amr"], "dtfreq",
[ + - ][ + - ]
1022 : : amr_deck.get< tag::dtfreq >(), 3);
1023 : :
1024 : : // Maximum AMR levels
1025 [ + - ][ + - ]: 20 : storeIfSpecd< std::size_t >(lua_ideck["amr"], "maxlevels",
[ + - ][ + - ]
1026 : : amr_deck.get< tag::maxlevels >(), 2);
1027 : :
1028 : : // Initial AMR steps
1029 [ + - ][ + - ]: 20 : storeOptVecIfSpecd< inciter::ctr::AMRInitialType, inciter::ctr::AMRInitial >(
[ + - ][ + - ]
1030 : : lua_ideck["amr"], "initial", amr_deck.get< tag::initial >(), {});
1031 : :
1032 : : // Initial AMR coordinate based
1033 [ + - ][ + - ]: 20 : if (lua_ideck["amr"]["coords"].valid()) {
[ + - ][ + + ]
1034 : 1 : auto rmax = std::numeric_limits< tk::real >::max() / 100;
1035 : :
1036 [ + - ][ + - ]: 1 : storeIfSpecd< tk::real >(lua_ideck["amr"]["coords"], "xminus",
[ + - ][ + - ]
[ + - ]
1037 : : amr_deck.get< tag::coords, tag::xminus >(), rmax);
1038 [ + - ][ + - ]: 1 : storeIfSpecd< tk::real >(lua_ideck["amr"]["coords"], "xplus",
[ + - ][ + - ]
[ + - ]
1039 : : amr_deck.get< tag::coords, tag::xplus >(), -rmax);
1040 : :
1041 [ + - ][ + - ]: 1 : storeIfSpecd< tk::real >(lua_ideck["amr"]["coords"], "yminus",
[ + - ][ + - ]
[ + - ]
1042 : : amr_deck.get< tag::coords, tag::yminus >(), rmax);
1043 [ + - ][ + - ]: 1 : storeIfSpecd< tk::real >(lua_ideck["amr"]["coords"], "yplus",
[ + - ][ + - ]
[ + - ]
1044 : : amr_deck.get< tag::coords, tag::yplus >(), -rmax);
1045 : :
1046 [ + - ][ + - ]: 1 : storeIfSpecd< tk::real >(lua_ideck["amr"]["coords"], "zminus",
[ + - ][ + - ]
[ + - ]
1047 : : amr_deck.get< tag::coords, tag::zminus >(), rmax);
1048 [ + - ][ + - ]: 1 : storeIfSpecd< tk::real >(lua_ideck["amr"]["coords"], "zplus",
[ + - ][ + - ]
[ + - ]
1049 : : amr_deck.get< tag::coords, tag::zplus >(), -rmax);
1050 : : }
1051 : :
1052 : : // Initial AMR edgelist based
1053 [ + - ][ + - ]: 20 : storeVecIfSpecd< std::size_t >(lua_ideck["amr"], "edgelist",
[ + - ][ + - ]
1054 : : amr_deck.get< tag::edgelist >(), {});
1055 [ - + ]: 20 : if (amr_deck.get< tag::edgelist >().size() % 2 != 0)
1056 [ - - ][ - - ]: 0 : Throw("The number of edge-nodes, marking edges as pairs of nodes, used "
[ - - ]
1057 : : "for explicit tagging of edges for initial mesh refineoment, is odd "
1058 : : "(it must be even).");
1059 : :
1060 : : // Error type for AMR
1061 [ + - ][ + - ]: 20 : storeOptIfSpecd< inciter::ctr::AMRErrorType, inciter::ctr::AMRError >(
[ + - ][ + - ]
1062 : : lua_ideck["amr"], "error", amr_deck.get< tag::error >(),
1063 : : inciter::ctr::AMRErrorType::JUMP);
1064 : :
1065 : : // Tolerances for refine/de-refine
1066 [ + - ][ + - ]: 20 : storeIfSpecd< tk::real >(lua_ideck["amr"], "tol_refine",
[ + - ][ + - ]
1067 : : amr_deck.get< tag::tol_refine >(), 0.2);
1068 [ + - ][ + - ]: 20 : storeIfSpecd< tk::real >(lua_ideck["amr"], "tol_derefine",
[ + - ][ + - ]
1069 : : amr_deck.get< tag::tol_derefine >(), 0.05);
1070 : : }
1071 : :
1072 : : // p-refinement block
1073 : : // ---------------------------------------------------------------------------
1074 : 191 : gideck.get< tag::pref, tag::pref >() = false;
1075 [ + - ][ + - ]: 191 : if (lua_ideck["pref"].valid()) {
[ + + ]
1076 : 12 : auto& pref_deck = gideck.get< tag::pref >();
1077 : 12 : pref_deck.get< tag::pref >() = true;
1078 : :
1079 : : // p-ref indicator type
1080 : : storeOptIfSpecd< inciter::ctr::PrefIndicatorType,
1081 [ + - ][ + - ]: 12 : inciter::ctr::PrefIndicator >(lua_ideck["pref"], "indicator",
[ + - ][ + - ]
1082 : : pref_deck.get< tag::indicator >(),
1083 : : inciter::ctr::PrefIndicatorType::SPECTRAL_DECAY);
1084 : :
1085 : : // p-ref max degrees-of-freedom per cell
1086 [ + - ][ + - ]: 12 : storeIfSpecd< std::size_t >(lua_ideck["pref"], "ndofmax",
[ + - ][ + - ]
1087 : : pref_deck.get< tag::ndofmax >(), 10);
1088 : :
1089 : : // p-ref tolerance
1090 [ + - ][ + - ]: 12 : storeIfSpecd< tk::real >(lua_ideck["pref"], "tolref",
[ + - ][ + - ]
1091 : : pref_deck.get< tag::tolref >(), 0.5);
1092 : :
1093 : : // error checking on the tolerance
1094 [ + - ][ - + ]: 12 : if (pref_deck.get< tag::tolref >() < 0.0 || pref_deck.get< tag::tolref >() > 1.0)
[ - + ]
1095 [ - - ][ - - ]: 0 : Throw("The p-refinement tolerance must be a real number "
[ - - ]
1096 : : "between 0.0 and 1.0, both inclusive.");
1097 : : }
1098 : :
1099 : : // Boundary conditions block
1100 : : // ---------------------------------------------------------------------------
1101 [ + - ][ + - ]: 191 : if (lua_ideck["bc"].valid()) {
[ + + ]
1102 : 282 : std::set< std::size_t > totalmesh;
1103 [ + - ][ + - ]: 282 : const sol::table& sol_bc = lua_ideck["bc"];
1104 : 141 : auto& bc_deck = gideck.get< tag::bc >();
1105 [ + - ][ + - ]: 141 : bc_deck.resize(sol_bc.size());
1106 : :
1107 [ + + ]: 284 : for (std::size_t i=0; i<bc_deck.size(); ++i) {
1108 : :
1109 [ + - ][ + - ]: 143 : checkBlock< inciter::ctr::bcList::Keys >(sol_bc[i+1], "bc");
[ + - ][ + - ]
1110 : :
1111 [ + - ][ + - ]: 286 : storeVecIfSpecd< std::size_t >(sol_bc[i+1], "mesh",
[ + - ][ + - ]
[ + - ]
1112 : 143 : bc_deck[i].get< tag::mesh >(), {1});
1113 : : // collect meshes for error checking
1114 [ + - ]: 143 : totalmesh.insert(bc_deck[i].get< tag::mesh >().begin(),
1115 : 143 : bc_deck[i].get< tag::mesh >().end());
1116 : :
1117 [ + - ][ + - ]: 286 : storeVecIfSpecd< uint64_t >(sol_bc[i+1], "dirichlet",
[ + - ][ + - ]
1118 : 143 : bc_deck[i].get< tag::dirichlet >(), {});
1119 : :
1120 [ + - ][ + - ]: 286 : storeVecIfSpecd< uint64_t >(sol_bc[i+1], "symmetry",
[ + - ][ + - ]
1121 : 143 : bc_deck[i].get< tag::symmetry >(), {});
1122 : :
1123 [ + - ][ + - ]: 286 : storeVecIfSpecd< uint64_t >(sol_bc[i+1], "inlet",
[ + - ][ + - ]
1124 : 143 : bc_deck[i].get< tag::inlet >(), {});
1125 : :
1126 [ + - ][ + - ]: 286 : storeVecIfSpecd< uint64_t >(sol_bc[i+1], "outlet",
[ + - ][ + - ]
1127 : 143 : bc_deck[i].get< tag::outlet >(), {});
1128 : :
1129 [ + - ][ + - ]: 286 : storeVecIfSpecd< uint64_t >(sol_bc[i+1], "farfield",
[ + - ][ + - ]
1130 : 143 : bc_deck[i].get< tag::farfield >(), {});
1131 : :
1132 [ + - ][ + - ]: 286 : storeVecIfSpecd< uint64_t >(sol_bc[i+1], "extrapolate",
[ + - ][ + - ]
1133 : 143 : bc_deck[i].get< tag::extrapolate >(), {});
1134 : :
1135 [ + - ][ + - ]: 286 : storeVecIfSpecd< uint64_t >(sol_bc[i+1], "noslipwall",
[ + - ][ + - ]
1136 : 143 : bc_deck[i].get< tag::noslipwall >(), {});
1137 : :
1138 : : // Time-dependent BC
1139 [ + - ][ + - ]: 143 : if (sol_bc[i+1]["timedep"].valid()) {
[ + - ][ + + ]
1140 [ + - ][ + - ]: 4 : const sol::table& sol_tdbc = sol_bc[i+1]["timedep"];
[ + - ]
1141 : 2 : auto& tdbc_deck = bc_deck[i].get< tag::timedep >();
1142 [ + - ][ + - ]: 2 : tdbc_deck.resize(sol_tdbc.size());
1143 : :
1144 [ + + ]: 4 : for (std::size_t j=0; j<tdbc_deck.size(); ++j) {
1145 [ + - ][ + - ]: 4 : storeVecIfSpecd< uint64_t >(sol_tdbc[j+1], "sideset",
[ + - ][ + - ]
1146 : 2 : tdbc_deck[j].get< tag::sideset >(), {});
1147 [ + - ][ + - ]: 4 : storeVecIfSpecd< tk::real >(sol_tdbc[j+1], "fn",
[ + - ][ + - ]
1148 : 2 : tdbc_deck[j].get< tag::fn >(), {});
1149 : :
1150 : : // error checking on user-def function
1151 [ - + ]: 2 : if (tdbc_deck[j].get< tag::fn >().size() % 6 != 0)
1152 [ - - ][ - - ]: 0 : Throw("Incomplete user-defined function for time-dependent BC. An "
[ - - ]
1153 : : "R->R^5 function is expected, the number of descrete entries must "
1154 : : "be divisible by 6: one 'column' for the abscissa, and 5 for the "
1155 : : "ordinate.");
1156 : : }
1157 : : }
1158 : :
1159 : : // Stagnation point
1160 [ + - ][ + - ]: 286 : storeVecIfSpecd< tk::real >(sol_bc[i+1], "stag_point",
[ + - ][ + - ]
1161 : 143 : bc_deck[i].get< tag::stag_point >(), {});
1162 [ + + ][ - + ]: 144 : if (!bc_deck[i].get< tag::stag_point >().empty() &&
1163 [ - + ]: 1 : bc_deck[i].get< tag::stag_point >().size() % 3 != 0)
1164 [ - - ][ - - ]: 0 : Throw("BC stagnation point requires 3 coordinate values for each "
[ - - ]
1165 : : "point. Thus, this vector must be divisible by 3.");
1166 : :
1167 : : // Stagnation radius
1168 [ + - ][ + - ]: 143 : storeIfSpecd< tk::real >(sol_bc[i+1], "radius",
[ + - ][ + - ]
1169 : 143 : bc_deck[i].get< tag::radius >(), 0.0);
1170 : :
1171 : : // Velocity for inlet/farfield
1172 [ + - ][ + - ]: 286 : storeVecIfSpecd< tk::real >(sol_bc[i+1], "velocity",
[ + - ][ + - ]
[ + - ]
1173 : 143 : bc_deck[i].get< tag::velocity >(), {0.0, 0.0, 0.0});
1174 [ - + ]: 143 : if (bc_deck[i].get< tag::velocity >().size() != 3)
1175 [ - - ][ - - ]: 0 : Throw("BC velocity requires 3 components.");
[ - - ]
1176 : :
1177 : : // Pressure for inlet/outlet/farfield
1178 [ + - ][ + - ]: 143 : storeIfSpecd< tk::real >(sol_bc[i+1], "pressure",
[ + - ][ + - ]
1179 : 143 : bc_deck[i].get< tag::pressure >(), 0.0);
1180 : :
1181 : : // Density for inlet/outlet/farfield
1182 [ + - ][ + - ]: 143 : storeIfSpecd< tk::real >(sol_bc[i+1], "density",
[ + - ][ + - ]
1183 : 143 : bc_deck[i].get< tag::density >(), 0.0);
1184 : :
1185 : : // Temperature for inlet/outlet/farfield
1186 [ + - ][ + - ]: 143 : storeIfSpecd< tk::real >(sol_bc[i+1], "temperature",
[ + - ][ + - ]
1187 : 143 : bc_deck[i].get< tag::temperature >(), 0.0);
1188 : :
1189 : : // Mass fractions for inlet/farfield
1190 [ + - ][ + - ]: 143 : storeVecIfSpecd< tk::real >(sol_bc[i+1], "mass_fractions",
[ + - ][ + - ]
1191 : 143 : bc_deck[i].get< tag::mass_fractions >(),
1192 [ + - ]: 286 : std::vector< tk::real >(nspec, 1.0/static_cast<tk::real>(nspec)));
1193 [ - + ]: 143 : if (bc_deck[i].get< tag::mass_fractions >().size() != nspec)
1194 [ - - ][ - - ]: 0 : Throw("BC mass fraction has incorrect number of species. "
[ - - ][ - - ]
1195 : : "Expected " + std::to_string(nspec));
1196 : :
1197 : : // Material-id for inlet/outlet/farfield
1198 [ + - ][ + - ]: 143 : storeIfSpecd< std::size_t >(sol_bc[i+1], "materialid",
[ + - ][ + - ]
1199 : 143 : bc_deck[i].get< tag::materialid >(), 1);
1200 : : }
1201 : :
1202 : : // error checking on number of meshes
1203 [ - + ]: 141 : if (totalmesh.size() != gideck.get< tag::mesh >().size())
1204 [ - - ][ - - ]: 0 : Throw("Total meshes (" + std::to_string(gideck.get< tag::mesh >().size()) +
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ]
1205 : : ") not equal to the meshes on which BC's are specified (" +
1206 : : std::to_string(totalmesh.size()));
1207 : :
1208 : : // error checking on mesh ids
1209 : 141 : std::size_t ic(1);
1210 [ + + ]: 284 : for (const auto& im : totalmesh) {
1211 [ - + ][ - - ]: 143 : if (im != ic) Throw("Non-contiguous mesh ids in BC-mesh");
[ - - ][ - - ]
1212 : 143 : ++ic;
1213 : : }
1214 : : }
1215 [ + + ][ + - ]: 68 : else if (gideck.get< tag::scheme >() == inciter::ctr::SchemeType::ALECG ||
1216 [ + - ]: 18 : gideck.get< tag::scheme >() == inciter::ctr::SchemeType::OversetFE)
1217 [ + - ]: 50 : gideck.get< tag::bc >().resize(1);
1218 : : // error checking for unspecified BC's
1219 : : else
1220 [ - - ][ - - ]: 0 : Throw("No boundary conditions specified in input file.");
[ - - ]
1221 : :
1222 : : // Initial condition block
1223 : : // ---------------------------------------------------------------------------
1224 [ + - ][ + - ]: 191 : if (lua_ideck["ic"].valid()) {
[ + + ]
1225 : 13 : auto& ic_deck = gideck.get< tag::ic >();
1226 : :
1227 [ + - ][ + - ]: 13 : checkBlock< inciter::ctr::icList::Keys >(lua_ideck["ic"], "ic");
[ + - ][ + - ]
1228 : :
1229 : : // background IC values
1230 [ + - ][ + - ]: 13 : storeIfSpecd< std::size_t >(lua_ideck["ic"], "materialid",
[ + - ][ + - ]
1231 : : ic_deck.get< tag::materialid >(), 1);
1232 : :
1233 [ + - ][ + - ]: 13 : storeIfSpecd< tk::real >(lua_ideck["ic"], "pressure",
[ + - ][ + - ]
1234 : : ic_deck.get< tag::pressure >(), 0.0);
1235 : :
1236 [ + - ][ + - ]: 13 : storeIfSpecd< tk::real >(lua_ideck["ic"], "temperature",
[ + - ][ + - ]
1237 : : ic_deck.get< tag::temperature >(), 0.0);
1238 : :
1239 [ + - ][ + - ]: 13 : storeVecIfSpecd< tk::real >(lua_ideck["ic"], "mass_fractions",
[ + - ][ + - ]
1240 : : ic_deck.get< tag::mass_fractions >(),
1241 [ + - ]: 26 : std::vector< tk::real >(nspec, 1.0/static_cast<tk::real>(nspec)));
1242 [ - + ]: 13 : if (ic_deck.get< tag::mass_fractions >().size() != nspec)
1243 [ - - ][ - - ]: 0 : Throw("IC mass fraction has incorrect number of species. "
[ - - ][ - - ]
1244 : : "Expected " + std::to_string(nspec));
1245 : :
1246 [ + - ][ + - ]: 13 : storeIfSpecd< tk::real >(lua_ideck["ic"], "density",
[ + - ][ + - ]
1247 : : ic_deck.get< tag::density >(), 0.0);
1248 : :
1249 [ + - ][ + - ]: 13 : storeIfSpecd< tk::real >(lua_ideck["ic"], "energy",
[ + - ][ + - ]
1250 : : ic_deck.get< tag::energy >(), 0.0);
1251 : :
1252 [ + - ][ + - ]: 13 : storeVecIfSpecd< tk::real >(lua_ideck["ic"], "velocity",
[ + - ][ + - ]
[ + - ]
1253 : : ic_deck.get< tag::velocity >(), {0.0, 0.0, 0.0});
1254 [ - + ]: 13 : if (ic_deck.get< tag::velocity >().size() != 3)
1255 [ - - ][ - - ]: 0 : Throw("Velocity in IC requires 3 components.");
[ - - ]
1256 : :
1257 : : // IC box
1258 [ + - ][ + - ]: 13 : if (lua_ideck["ic"]["box"].valid()) {
[ + - ][ + + ]
1259 [ + - ][ + - ]: 12 : const sol::table& lua_box = lua_ideck["ic"]["box"];
[ + - ]
1260 : 6 : auto& box_deck = ic_deck.get< tag::box >();
1261 [ + - ][ + - ]: 6 : box_deck.resize(lua_box.size());
1262 : :
1263 [ + + ]: 13 : for (std::size_t i=0; i<box_deck.size(); ++i) {
1264 : :
1265 [ + - ][ + - ]: 7 : checkBlock< inciter::ctr::boxList::Keys >(lua_box[i+1], "box");
[ + - ][ + - ]
1266 : :
1267 [ + - ][ + - ]: 7 : storeIfSpecd< std::size_t >(lua_box[i+1], "materialid",
[ + - ][ + - ]
1268 : 7 : box_deck[i].get< tag::materialid >(), 1);
1269 : :
1270 [ + - ][ + - ]: 7 : storeIfSpecd< tk::real >(lua_box[i+1], "volume",
[ + - ][ + - ]
1271 : 7 : box_deck[i].get< tag::volume >(), 0.0);
1272 : :
1273 [ + - ][ + - ]: 7 : storeIfSpecd< tk::real >(lua_box[i+1], "mass",
[ + - ][ + - ]
1274 : 7 : box_deck[i].get< tag::mass >(), 0.0);
1275 : :
1276 [ + - ][ + - ]: 7 : storeIfSpecd< tk::real >(lua_box[i+1], "density",
[ + - ][ + - ]
1277 : 7 : box_deck[i].get< tag::density >(), 0.0);
1278 : :
1279 [ + - ][ + - ]: 14 : storeVecIfSpecd< tk::real >(lua_box[i+1], "velocity",
[ + - ][ + - ]
[ + - ]
1280 : 7 : box_deck[i].get< tag::velocity >(), {0.0, 0.0, 0.0});
1281 [ - + ]: 7 : if (box_deck[i].get< tag::velocity >().size() != 3)
1282 [ - - ][ - - ]: 0 : Throw("Velocity in IC box requires 3 components.");
[ - - ]
1283 : :
1284 [ + - ][ + - ]: 7 : storeIfSpecd< tk::real >(lua_box[i+1], "pressure",
[ + - ][ + - ]
1285 : 7 : box_deck[i].get< tag::pressure >(), 0.0);
1286 : :
1287 [ + - ][ + - ]: 7 : storeIfSpecd< tk::real >(lua_box[i+1], "energy",
[ + - ][ + - ]
1288 : 7 : box_deck[i].get< tag::energy >(), 0.0);
1289 : :
1290 [ + - ][ + - ]: 7 : storeIfSpecd< tk::real >(lua_box[i+1], "energy_content",
[ + - ][ + - ]
1291 : 7 : box_deck[i].get< tag::energy_content >(), 0.0);
1292 : :
1293 [ + - ][ + - ]: 7 : storeIfSpecd< tk::real >(lua_box[i+1], "temperature",
[ + - ][ + - ]
1294 : 7 : box_deck[i].get< tag::temperature >(), 0.0);
1295 : :
1296 [ + - ][ + - ]: 7 : storeVecIfSpecd< tk::real >(lua_box[i+1], "mass_fractions",
[ + - ][ + - ]
1297 : 7 : box_deck[i].get< tag::mass_fractions >(),
1298 [ + - ]: 14 : std::vector< tk::real >(nspec, 1.0/static_cast<tk::real>(nspec)));
1299 [ - + ]: 7 : if (box_deck[i].get< tag::mass_fractions >().size() != nspec)
1300 [ - - ][ - - ]: 0 : Throw("IC box mass fraction has incorrect number of species. "
[ - - ][ - - ]
1301 : : "Expected " + std::to_string(nspec));
1302 : :
1303 [ + - ][ + - ]: 7 : storeIfSpecd< tk::real >(lua_box[i+1], "xmin",
[ + - ][ + - ]
1304 : 7 : box_deck[i].get< tag::xmin >(), 0.0);
1305 : :
1306 [ + - ][ + - ]: 7 : storeIfSpecd< tk::real >(lua_box[i+1], "xmax",
[ + - ][ + - ]
1307 : 7 : box_deck[i].get< tag::xmax >(), 0.0);
1308 : :
1309 [ + - ][ + - ]: 7 : storeIfSpecd< tk::real >(lua_box[i+1], "ymin",
[ + - ][ + - ]
1310 : 7 : box_deck[i].get< tag::ymin >(), 0.0);
1311 : :
1312 [ + - ][ + - ]: 7 : storeIfSpecd< tk::real >(lua_box[i+1], "ymax",
[ + - ][ + - ]
1313 : 7 : box_deck[i].get< tag::ymax >(), 0.0);
1314 : :
1315 [ + - ][ + - ]: 7 : storeIfSpecd< tk::real >(lua_box[i+1], "zmin",
[ + - ][ + - ]
1316 : 7 : box_deck[i].get< tag::zmin >(), 0.0);
1317 : :
1318 [ + - ][ + - ]: 7 : storeIfSpecd< tk::real >(lua_box[i+1], "zmax",
[ + - ][ + - ]
1319 : 7 : box_deck[i].get< tag::zmax >(), 0.0);
1320 : :
1321 [ + - ][ + - ]: 14 : storeVecIfSpecd< tk::real >(lua_box[i+1], "orientation",
[ + - ][ + - ]
[ + - ]
1322 : 7 : box_deck[i].get< tag::orientation >(), {0.0, 0.0, 0.0});
1323 [ - + ]: 7 : if (box_deck[i].get< tag::orientation >().size() != 3)
1324 [ - - ][ - - ]: 0 : Throw("Orientation in IC box requires 3 rotation angles.");
[ - - ]
1325 : :
1326 [ + - ][ + - ]: 21 : storeOptIfSpecd< inciter::ctr::InitiateType, inciter::ctr::Initiate >(
[ + - ]
1327 [ + - ]: 21 : lua_box[i+1], "initiate", box_deck[i].get< tag::initiate >(),
1328 : : inciter::ctr::InitiateType::IMPULSE);
1329 : :
1330 [ + - ][ + - ]: 14 : storeVecIfSpecd< tk::real >(lua_box[i+1], "point",
[ + - ][ + - ]
[ + - ]
1331 : 7 : box_deck[i].get< tag::point >(), {0.0, 0.0, 0.0});
1332 [ - + ]: 7 : if (box_deck[i].get< tag::point >().size() != 3)
1333 [ - - ][ - - ]: 0 : Throw("Point in IC box requires 3 coordinates.");
[ - - ]
1334 : :
1335 [ + - ][ + - ]: 7 : storeIfSpecd< tk::real >(lua_box[i+1], "init_time",
[ + - ][ + - ]
1336 : 7 : box_deck[i].get< tag::init_time >(), 0.0);
1337 : :
1338 [ + - ][ + - ]: 7 : storeIfSpecd< tk::real >(lua_box[i+1], "front_width",
[ + - ][ + - ]
1339 : 7 : box_deck[i].get< tag::front_width >(), 0.0);
1340 : :
1341 [ + - ][ + - ]: 7 : storeIfSpecd< tk::real >(lua_box[i+1], "front_speed",
[ + - ][ + - ]
1342 : 7 : box_deck[i].get< tag::front_speed >(), 0.0);
1343 : : }
1344 : : }
1345 : :
1346 : : // IC mesh-block
1347 [ + - ][ + - ]: 13 : if (lua_ideck["ic"]["meshblock"].valid()) {
[ + - ][ - + ]
1348 [ - - ][ - - ]: 0 : const sol::table& lua_meshblock = lua_ideck["ic"]["meshblock"];
[ - - ]
1349 : 0 : auto& mblk_deck = ic_deck.get< tag::meshblock >();
1350 [ - - ][ - - ]: 0 : mblk_deck.resize(lua_meshblock.size());
1351 : :
1352 [ - - ]: 0 : for (std::size_t i=0; i<mblk_deck.size(); ++i) {
1353 : :
1354 [ - - ][ - - ]: 0 : checkBlock< inciter::ctr::meshblockList::Keys >(lua_meshblock[i+1],
[ - - ][ - - ]
1355 : : "meshblock");
1356 : :
1357 [ - - ][ - - ]: 0 : storeIfSpecd< std::size_t >(lua_meshblock[i+1], "blockid",
[ - - ][ - - ]
1358 : 0 : mblk_deck[i].get< tag::blockid >(), 0);
1359 [ - - ]: 0 : if (mblk_deck[i].get< tag::blockid >() == 0)
1360 [ - - ][ - - ]: 0 : Throw("Each IC mesh block must specify the mesh block id.");
[ - - ]
1361 : :
1362 [ - - ][ - - ]: 0 : storeIfSpecd< std::size_t >(lua_meshblock[i+1], "materialid",
[ - - ][ - - ]
1363 : 0 : mblk_deck[i].get< tag::materialid >(), 1);
1364 : :
1365 [ - - ][ - - ]: 0 : storeIfSpecd< tk::real >(lua_meshblock[i+1], "energy_content",
[ - - ][ - - ]
1366 : 0 : mblk_deck[i].get< tag::energy_content >(), 0.0);
1367 : :
1368 [ - - ][ - - ]: 0 : storeIfSpecd< tk::real >(lua_meshblock[i+1], "volume",
[ - - ][ - - ]
1369 : 0 : mblk_deck[i].get< tag::volume >(), 0.0);
1370 [ - - ][ - - ]: 0 : if (mblk_deck[i].get< tag::energy_content >() > 0.0 &&
1371 [ - - ]: 0 : mblk_deck[i].get< tag::volume >() < 1e-12)
1372 [ - - ][ - - ]: 0 : Throw("Mesh block volume must be specified, if energy content is "
[ - - ]
1373 : : "used to initialize block");
1374 : :
1375 [ - - ][ - - ]: 0 : storeIfSpecd< tk::real >(lua_meshblock[i+1], "mass",
[ - - ][ - - ]
1376 : 0 : mblk_deck[i].get< tag::mass >(), 0.0);
1377 : :
1378 [ - - ][ - - ]: 0 : storeIfSpecd< tk::real >(lua_meshblock[i+1], "density",
[ - - ][ - - ]
1379 : 0 : mblk_deck[i].get< tag::density >(), 0.0);
1380 : :
1381 [ - - ][ - - ]: 0 : storeVecIfSpecd< tk::real >(lua_meshblock[i+1], "velocity",
[ - - ][ - - ]
[ - - ]
1382 : 0 : mblk_deck[i].get< tag::velocity >(), {0.0, 0.0, 0.0});
1383 [ - - ]: 0 : if (mblk_deck[i].get< tag::velocity >().size() != 3)
1384 [ - - ][ - - ]: 0 : Throw("Velocity in IC meshblock requires 3 components.");
[ - - ]
1385 : :
1386 [ - - ][ - - ]: 0 : storeIfSpecd< tk::real >(lua_meshblock[i+1], "pressure",
[ - - ][ - - ]
1387 : 0 : mblk_deck[i].get< tag::pressure >(), 0.0);
1388 : :
1389 [ - - ][ - - ]: 0 : storeIfSpecd< tk::real >(lua_meshblock[i+1], "energy",
[ - - ][ - - ]
1390 : 0 : mblk_deck[i].get< tag::energy >(), 0.0);
1391 : :
1392 [ - - ][ - - ]: 0 : storeIfSpecd< tk::real >(lua_meshblock[i+1], "temperature",
[ - - ][ - - ]
1393 : 0 : mblk_deck[i].get< tag::temperature >(), 0.0);
1394 : :
1395 [ - - ][ - - ]: 0 : storeVecIfSpecd< tk::real >(lua_meshblock[i+1], "mass_fractions",
[ - - ][ - - ]
1396 : 0 : mblk_deck[i].get< tag::mass_fractions >(),
1397 [ - - ]: 0 : std::vector< tk::real >(nspec, 1.0/static_cast<tk::real>(nspec)));
1398 [ - - ]: 0 : if (mblk_deck[i].get< tag::mass_fractions >().size() != nspec)
1399 [ - - ][ - - ]: 0 : Throw("IC meshblock mass fraction has incorrect number of species. "
[ - - ][ - - ]
1400 : : "Expected " + std::to_string(nspec));
1401 : :
1402 [ - - ][ - - ]: 0 : storeOptIfSpecd< inciter::ctr::InitiateType, inciter::ctr::Initiate >(
[ - - ]
1403 [ - - ]: 0 : lua_meshblock[i+1], "initiate", mblk_deck[i].get< tag::initiate >(),
1404 : : inciter::ctr::InitiateType::IMPULSE);
1405 : :
1406 [ - - ][ - - ]: 0 : storeVecIfSpecd< tk::real >(lua_meshblock[i+1], "point",
[ - - ][ - - ]
[ - - ]
1407 : 0 : mblk_deck[i].get< tag::point >(), {0.0, 0.0, 0.0});
1408 [ - - ]: 0 : if (mblk_deck[i].get< tag::point >().size() != 3)
1409 [ - - ][ - - ]: 0 : Throw("Point in IC meshblock requires 3 coordinates.");
[ - - ]
1410 : :
1411 [ - - ][ - - ]: 0 : storeIfSpecd< tk::real >(lua_meshblock[i+1], "init_time",
[ - - ][ - - ]
1412 : 0 : mblk_deck[i].get< tag::init_time >(), 0.0);
1413 : :
1414 [ - - ][ - - ]: 0 : storeIfSpecd< tk::real >(lua_meshblock[i+1], "front_width",
[ - - ][ - - ]
1415 : 0 : mblk_deck[i].get< tag::front_width >(), 0.0);
1416 : :
1417 [ - - ][ - - ]: 0 : storeIfSpecd< tk::real >(lua_meshblock[i+1], "front_speed",
[ - - ][ - - ]
1418 : 0 : mblk_deck[i].get< tag::front_speed >(), 0.0);
1419 : : }
1420 : : }
1421 : : }
1422 : : else {
1423 : : // TODO: remove double-specification of defaults
1424 : 178 : auto& ic_deck = gideck.get< tag::ic >();
1425 : 178 : ic_deck.get< tag::materialid >() = 1;
1426 : 178 : ic_deck.get< tag::pressure >() = 0.0;
1427 : 178 : ic_deck.get< tag::temperature >() = 1.0;
1428 : 178 : ic_deck.get< tag::density >() = 0.0;
1429 : 178 : ic_deck.get< tag::energy >() = 0.0;
1430 [ + - ]: 178 : ic_deck.get< tag::velocity >() = {0.0, 0.0, 0.0};
1431 : 178 : ic_deck.get< tag::mass_fractions >() =
1432 [ + - ]: 356 : std::vector< tk::real >(nspec, 1.0/static_cast<tk::real>(nspec));
1433 : : }
1434 : 191 : }
1435 : :
1436 : : void
1437 : 393 : LuaParser::checkStoreMatProp(
1438 : : const sol::table table,
1439 : : const std::string key,
1440 : : std::size_t vecsize,
1441 : : std::vector< tk::real >& storage )
1442 : : // *****************************************************************************
1443 : : // Check and store material property into inpudeck storage
1444 : : //! \param[in] table Sol-table which contains said property
1445 : : //! \param[in] key Key for said property in Sol-table
1446 : : //! \param[in] vecsize Number of said property in Sol-table (based on number of
1447 : : //! materials that are of the same eos type
1448 : : //! \param[in,out] storage Storage space in inputdeck where said property is
1449 : : //! to be stored
1450 : : // *****************************************************************************
1451 : : {
1452 : : // check validity of table
1453 [ + - ][ - + ]: 393 : if (!table[key].valid())
1454 [ - - ][ - - ]: 0 : Throw("Material property '" + key + "' not specified");
[ - - ][ - - ]
1455 [ + - ][ + - ]: 393 : if (sol::table(table[key]).size() != vecsize)
[ - + ]
1456 [ - - ][ - - ]: 0 : Throw("Incorrect number of '" + key + "'s specified. Expected " +
[ - - ][ - - ]
[ - - ][ - - ]
1457 : : std::to_string(vecsize));
1458 : :
1459 : : // store values from table to inputdeck
1460 [ + - ][ + - ]: 393 : storeVecIfSpecd< tk::real >(table, key, storage,
1461 [ + - ]: 786 : std::vector< tk::real >(vecsize, 0.0));
1462 : 393 : }
1463 : :
1464 : : void
1465 : 3 : LuaParser::checkStoreMatPropVec(
1466 : : const sol::table table,
1467 : : const std::string key,
1468 : : std::size_t nspec,
1469 : : std::size_t vecsize,
1470 : : std::vector<std::vector< tk::real >>& storage )
1471 : : // *****************************************************************************
1472 : : // Check and store material property vector into inpudeck storage
1473 : : //! \param[in] table Sol-table which contains said property
1474 : : //! \param[in] key Key for said property in Sol-table
1475 : : //! \param[in] nspec Number of species
1476 : : //! \param[in] vecsize Number of said property in Sol-table (based on number of
1477 : : //! coefficients for the defined species)
1478 : : //! \param[in,out] storage Storage space in inputdeck where said property is
1479 : : //! to be stored
1480 : : // *****************************************************************************
1481 : : {
1482 : : // check validity of table
1483 [ + - ][ + - ]: 3 : if (!table[key].valid())
[ - + ]
1484 [ - - ][ - - ]: 0 : Throw("Material property '" + key + "' not specified");
[ - - ][ - - ]
1485 [ + - ][ + - ]: 3 : if (sol::table(table[key]).size() != nspec)
[ + - ][ - + ]
1486 [ - - ][ - - ]: 0 : Throw("Incorrect number of '" + key + "' vectors specified. Expected " +
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ]
1487 : : std::to_string(nspec) + " vectors");
1488 : :
1489 [ + - ]: 3 : storage.resize(nspec);
1490 : :
1491 [ + - ]: 6 : const auto& tableentry = table[key];
1492 [ + + ]: 9 : for (std::size_t k=0; k < nspec; k++) {
1493 [ + - ][ + - ]: 6 : if (sol::table(tableentry[k+1]).size() != vecsize)
[ + - ][ - + ]
1494 [ - - ][ - - ]: 0 : Throw("Incorrect number of '" + key + "' entries in vector of species "
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ]
1495 : : + std::to_string(k+1) + " specified. Expected " +
1496 : : std::to_string(vecsize));
1497 : :
1498 : : // store values from table to inputdeck
1499 [ + + ]: 54 : for (std::size_t i=0; i<vecsize; ++i)
1500 [ + - ][ + - ]: 48 : storage[k].push_back(tableentry[k+1][i+1]);
[ + - ][ + - ]
1501 : : }
1502 : 3 : }
1503 : :
1504 : : void
1505 : 623 : LuaParser::addOutVar(
1506 : : const std::string& varname,
1507 : : const std::string& alias,
1508 : : std::vector< char >& depv,
1509 : : std::size_t nmat,
1510 : : std::size_t nspec,
1511 : : inciter::ctr::PDEType pde,
1512 : : tk::Centering c,
1513 : : std::vector< inciter::ctr::OutVar >& foutvar )
1514 : : // *****************************************************************************
1515 : : // Check and store field output variables
1516 : : //! \param[in] varname Name of variable requested
1517 : : //! \param[in] alias User specified alias for output
1518 : : //! \param[in] depv List of depvars
1519 : : //! \param[in] nmat Number of materials configured
1520 : : //! \param[in] nspec Number of species configured
1521 : : //! \param[in] pde Type of PDE configured
1522 : : //! \param[in] c Variable centering requested
1523 : : //! \param[in,out] foutvar Input deck storage where output vars are stored
1524 : : // *****************************************************************************
1525 : : {
1526 : : // index-based quantity specification
1527 : : // ----------------------------------
1528 [ + + ]: 623 : if (varname.length() == 2) {
1529 : 81 : auto qty = varname.at(0);
1530 [ + - ][ + - ]: 81 : auto j = std::stoul(std::string{varname.at(1)}) - 1;
1531 : :
1532 [ + + ]: 81 : if (pde == inciter::ctr::PDEType::MULTIMAT) {
1533 : : // multimat/matvar quantities
1534 [ - + ]: 28 : if (qty == 'D') { // density
1535 : : foutvar.emplace_back(
1536 [ - - ][ - - ]: 0 : inciter::ctr::OutVar(c, varname, alias, inciter::densityIdx(nmat,j)) );
[ - - ]
1537 : : }
1538 [ + - ]: 28 : else if (qty == 'F') { // volume fraction
1539 : : foutvar.emplace_back(
1540 [ + - ][ + - ]: 28 : inciter::ctr::OutVar(c, varname, alias, inciter::volfracIdx(nmat,j)) );
[ + - ]
1541 : : }
1542 [ - - ]: 0 : else if (qty == 'M') { // momentum
1543 : : foutvar.emplace_back(
1544 [ - - ][ - - ]: 0 : inciter::ctr::OutVar(c, varname, alias, inciter::momentumIdx(nmat,j)) );
[ - - ]
1545 : : }
1546 [ - - ]: 0 : else if (qty == 'E') { // specific total energy
1547 : : foutvar.emplace_back(
1548 [ - - ][ - - ]: 0 : inciter::ctr::OutVar(c, varname, alias, inciter::energyIdx(nmat,j)) );
[ - - ]
1549 : : }
1550 [ - - ]: 0 : else if (qty == 'U') { // velocity (primitive)
1551 : : foutvar.emplace_back(
1552 [ - - ][ - - ]: 0 : inciter::ctr::OutVar(c, varname, alias, inciter::velocityIdx(nmat,j)) );
[ - - ]
1553 : : }
1554 [ - - ]: 0 : else if (qty == 'P') { // material pressure (primitive)
1555 : : foutvar.emplace_back(
1556 [ - - ][ - - ]: 0 : inciter::ctr::OutVar(c, varname, alias, inciter::pressureIdx(nmat,j)) );
[ - - ]
1557 : : }
1558 : : else {
1559 : : // error out if incorrect matvar used
1560 [ - - ][ - - ]: 0 : Throw("field_output: matvar " + varname + " not found");
[ - - ][ - - ]
1561 : : }
1562 : : }
1563 [ + + ]: 53 : else if (pde == inciter::ctr::PDEType::MULTISPECIES) {
1564 : : // multispecies/matvar quantities
1565 [ + - ]: 6 : if (qty == 'D') { // density
1566 : : foutvar.emplace_back(
1567 [ + - ][ + - ]: 12 : inciter::ctr::OutVar(c, varname, alias,
1568 [ + - ]: 6 : inciter::multispecies::densityIdx(nspec,j)) );
1569 : : }
1570 [ - - ]: 0 : else if (qty == 'M') { // momentum
1571 : : foutvar.emplace_back(
1572 [ - - ][ - - ]: 0 : inciter::ctr::OutVar(c, varname, alias,
1573 [ - - ]: 0 : inciter::multispecies::momentumIdx(nspec,j)) );
1574 : : }
1575 [ - - ]: 0 : else if (qty == 'E') { // specific total energy
1576 : : foutvar.emplace_back(
1577 [ - - ][ - - ]: 0 : inciter::ctr::OutVar(c, varname, alias,
1578 [ - - ]: 0 : inciter::multispecies::energyIdx(nspec,j)) );
1579 : : }
1580 : : else {
1581 : : // error out if incorrect matvar used
1582 [ - - ][ - - ]: 0 : Throw("field_output: matvar " + varname + " not found");
[ - - ][ - - ]
1583 : : }
1584 : : }
1585 : : else {
1586 : : // quantities specified by depvar
1587 [ + + ]: 114 : for (const auto& id : depv)
1588 [ + + ]: 67 : if (std::tolower(qty) == id) {
1589 [ + - ][ + - ]: 47 : foutvar.emplace_back( inciter::ctr::OutVar(c, varname, alias, j) );
[ + - ]
1590 : : }
1591 : : }
1592 : : }
1593 : : // analytic quantity specification
1594 : : // -------------------------------
1595 [ + + ]: 542 : else if (varname.find("analytic") != std::string::npos) {
1596 [ + - ][ + - ]: 58 : foutvar.emplace_back( inciter::ctr::OutVar(c, varname, alias, 0) );
[ + - ]
1597 : : }
1598 : : // name-based tensor quantity specification
1599 : : // ----------------------------------------
1600 [ - + ]: 484 : else if (varname.find("_tensor") != std::string::npos) {
1601 [ - - ]: 0 : std::string namet(varname);
1602 : : // remove the "_tensor" from the varname
1603 [ - - ]: 0 : for (std::size_t i=0; i<7; ++i) namet.pop_back();
1604 : :
1605 [ - - ]: 0 : for (std::size_t i=1; i<=3; ++i) {
1606 [ - - ]: 0 : for (std::size_t j=1; j<=3; ++j) {
1607 [ - - ][ - - ]: 0 : std::string tij(namet + std::to_string(i) + std::to_string(j));
[ - - ][ - - ]
1608 [ - - ][ - - ]: 0 : foutvar.emplace_back( inciter::ctr::OutVar(c, tij, alias, 0, tij) );
1609 : : }
1610 : : }
1611 : : }
1612 : : // name-based quantity specification
1613 : : // ---------------------------------
1614 : : else {
1615 [ + - ]: 484 : foutvar.emplace_back( inciter::ctr::OutVar(c, varname, alias, 0, varname) );
1616 : : }
1617 : 623 : }
|
