Line data Source code
1 : //
2 : // This is a thin wrapper to the amrex::ParmParse class
3 : // This class exists to add some additional parsing capability,
4 : // e.g. parsing Set::Matrix and Set::Vector data types.
5 : //
6 : // :ref:`IO::ParmParse` uses static :code:`Parse()` functions to
7 : // perform cascading class-based input parsing.
8 : // See the :ref:`autodoc` section for instructions on adding documentation.
9 : //
10 : // :bdg-warning-line:`This is standard infrastructure code; make sure you know what you ard doing before you change it.`
11 : //
12 : // .. _query-directives:
13 : //
14 : // **Query directives**
15 : //
16 : // Alamo uses different query directives to standardize reading inputs and automatic documentation.
17 : // The type of query that is used (query vs query_required, etc) triggers different handlers and different
18 : // automatic documentation procedures.
19 : // For instance, the use of a :code:`query_default` causes a default value to be set and added to the metadata
20 : // file, and it also serves as a flag for the autodoc system to document that a default value is available.
21 : // The following table is a reference for the different kinds of query directives.
22 : //
23 : //
24 : // .. table::
25 : // :widths: 1 99
26 : //
27 : // +---------------------------------+-----------------------------------------------------------------+
28 : // | BC Type | Description |
29 : // +=================================+=================================================================+
30 : // | :bdg-warning:`query` | Standard IO for bool, string, Set::Scalarthat does not enforce |
31 : // | | defaults or required values. Not recommended for general use. |
32 : // +---------------------------------+-----------------------------------------------------------------+
33 : // | :bdg-success:`query_required` | Similar to query, but will abort if no value is specified. |
34 : // | | Required values are indicated by :bdg-danger-line:`required`. |
35 : // +---------------------------------+-----------------------------------------------------------------+
36 : // | :bdg-success:`query_default` | Similar to query, but will fill with default value if no value |
37 : // | | is provided. Will also add default value to metadata. |
38 : // | | Default values are indicated by green badge values, e.g. |
39 : // | | :bdg-success:`0.0`. |
40 : // +---------------------------------+-----------------------------------------------------------------+
41 : // | :bdg-success:`query_validate` | For strings, read in a value and enforce that the value is one |
42 : // | | of a supplied number of values. Optionally make required, or |
43 : // | | set the default value to the first supplied value. |
44 : // | | Acceptable options are indicated by blue badge values, e.g. |
45 : // | | :bdg-primary:`1.0`, :bdg-primary:`2.0`. If a default value is |
46 : // | | available, it is indicated by a green badge, e.g. |
47 : // | | :bdg-success:`1.0`. |
48 : // +---------------------------------+-----------------------------------------------------------------+
49 : // | :bdg-success:`query_file` | Read in a string that defines a file name. |
50 : // | | Check to make sure that the file exists and is a regular file, |
51 : // | | and print an informative error message if not (this can be |
52 : // | | disabled). |
53 : // | | Also, copy the file to the output directory, with the full path |
54 : // | | preserved by replacing / with _. |
55 : // | | (This can also be disabled, but doing so is discouraged.) |
56 : // | | Default values are not allowed. |
57 : // | | File paths are indicated by :bdg-secondary-line:`file path`. |
58 : // +---------------------------------+-----------------------------------------------------------------+
59 : // | :bdg-primary:`queryarr` | Read in an array of numbers into either a standard vector or |
60 : // | | into a :code:`Set::Vector` or :code:`Set::Scalar`. |
61 : // | | No defaults or existence checking is performed. |
62 : // +---------------------------------+-----------------------------------------------------------------+
63 : // | :bdg-primary:`queryclass` | Read a class object with a specified prefix. |
64 : // | | How that class is read in is determined by its :code:`Parse` |
65 : // | | function. |
66 : // +---------------------------------+-----------------------------------------------------------------+
67 : //
68 : // .. _query_locator_macros:
69 : //
70 : // **Query macros**
71 : //
72 : // A set of preprocessor macros are defined so that you can call a query function using :code:`pp_` instead
73 : // of :code:`pp.`.
74 : // For instance, the following two can be used interchangeably:
75 : //
76 : // .. code-block:: cpp
77 : //
78 : // pp.query_required("myvar",myvar); /* function version */
79 : // pp_query_required("myvar",myvar); /* preprocessor macro version - preferred*/
80 : //
81 : // Using the preprocessor macros enables code location information to be passed to the parser, so that
82 : // more informative error messages will be printed out.
83 : // Note that **the ParmParse object must always be called** :code:`pp` **for this to work**.
84 : //
85 : //
86 :
87 : #ifndef IO_PARMPARSE
88 : #define IO_PARMPARSE
89 :
90 : #include <filesystem>
91 : #include <exception>
92 : #include <list>
93 :
94 : #include "Util/Util.H"
95 : #include "Set/Set.H"
96 : #include "AMReX_ParmParse.H"
97 :
98 :
99 : #define pp_query_required(...) pp.query_required(__VA_ARGS__,INFO)
100 : #define pp_query_default(...) pp.query_default(__VA_ARGS__,INFO)
101 : #define pp_query_validate(...) pp.query_validate(__VA_ARGS__,INFO)
102 : #define pp_query_file(...) pp.query_file(__VA_ARGS__,INFO)
103 : #define pp_queryarr(...) pp.queryarr(__VA_ARGS__,INFO)
104 : #define pp_queryarr_required(...) pp.queryarr_required(__VA_ARGS__,INFO)
105 : #define pp_queryarr_default(...) pp.queryarr_default(__VA_ARGS__,INFO)
106 : #define pp_query(...) pp.query(__VA_ARGS__)
107 : #define pp_queryclass(...) pp.queryclass(__VA_ARGS__,INFO)
108 : #define pp_forbid(...) pp.forbid(__VA_ARGS__,INFO)
109 :
110 :
111 : namespace IO
112 : {
113 : class ParmParse : public amrex::ParmParse
114 : {
115 : private:
116 901 : void Define()
117 : {
118 901 : if (checked_for_input_files) return;
119 38 : int k = 0;
120 38 : std::string inputfile = "";
121 38 : while (this->querykth("input",k,inputfile))
122 : {
123 0 : Util::Message(INFO,"Including inputs from "+inputfile);
124 0 : this->addfile(inputfile);
125 0 : k++;
126 : }
127 38 : checked_for_input_files = true;
128 38 : }
129 : static bool checked_for_input_files;
130 :
131 : public:
132 648 : ParmParse(std::string arg) : amrex::ParmParse::ParmParse(arg) {Define();} ;
133 253 : ParmParse() : amrex::ParmParse::ParmParse() {Define();} ;
134 7340 : std::string getPrefix() const {return m_prefix;};
135 396 : void ignore(std::string name)
136 : {
137 396 : (void)amrex::ParmParse::contains(name.c_str());
138 396 : }
139 :
140 120 : void forbid(std::string name, std::string explanation,
141 : std::string file = "", std::string func = "", int line = -1)
142 : {
143 120 : if (amrex::ParmParse::contains(full(name).c_str()))
144 : {
145 0 : Util::ParmParseException(INFO,file,func,line,full(name),full(name)," forbidden: ", explanation);
146 : }
147 120 : std::set<std::string> subs = amrex::ParmParse::getEntries(full(name));
148 120 : if (subs.size())
149 : {
150 0 : Util::ParmParseException(INFO,file,func,line,full(name),full(name)," forbidden: ", explanation);
151 : }
152 120 : }
153 :
154 2572 : bool contains(std::string name)
155 : {
156 2572 : if (amrex::ParmParse::contains(name.c_str()))
157 975 : return true;
158 1597 : if (amrex::ParmParse::contains(full(name).c_str()))
159 0 : return true;
160 : {
161 1597 : std::set<std::string> subs = amrex::ParmParse::getEntries(name.c_str());
162 1597 : if (subs.size())
163 52 : return true;
164 1597 : }
165 : {
166 1545 : std::set<std::string> subs = amrex::ParmParse::getEntries(full(name).c_str());
167 1545 : if (subs.size())
168 0 : return true;
169 1545 : }
170 1545 : return false;
171 : }
172 :
173 : template<typename T>
174 249 : int query_required( std::string name, T & value,
175 : std::string file = "", std::string func = "", int line = -1)
176 : {
177 498 : if (!contains(name.c_str()))
178 : {
179 0 : Util::ParmParseException(INFO,file,func,line,full(name),"required value for ",full(name)," missing");
180 : }
181 249 : return query(name.c_str(),value);
182 : }
183 :
184 : template<typename T>
185 1270 : int query_default( std::string name, T & value, T defaultvalue,
186 : std::string = "", std::string = "", int = -1)
187 : {
188 2540 : if (!contains(name.c_str()))
189 : {
190 989 : add(name.c_str(),defaultvalue);
191 : }
192 1270 : return query(name.c_str(),value);
193 : }
194 :
195 2 : int query_validate( std::string name, int & value, std::vector<int> possibleintvals,
196 : std::string file = "", std::string func = "", int line = -1)
197 : {
198 : // First value is accepted by default...
199 :
200 : // set default value
201 2 : value = possibleintvals[0];
202 :
203 : // get the read value (if it exists)
204 2 : int retval = query(name.c_str(),value);
205 :
206 : // check to make sure the read value matches one of the inpus
207 2 : bool ok = false;
208 8 : for (unsigned int i = 0; i < possibleintvals.size(); i++)
209 : {
210 6 : if (value == possibleintvals[i]) ok = true;
211 : }
212 :
213 2 : if (ok) return retval;
214 :
215 0 : std::stringstream ss;
216 0 : ss << possibleintvals[0];
217 0 : for (unsigned int i = 1; i < possibleintvals.size(); i++)
218 0 : ss << "," << possibleintvals[i];
219 :
220 0 : Util::ParmParseException(INFO,file,func,line,full(name),"' expected [", ss.str(), "] but got ", value);
221 :
222 0 : return -1;
223 0 : }
224 :
225 :
226 91 : int query_validate( std::string name, std::string & value, std::vector<const char *> possiblecharvals, bool firstbydefault,
227 : std::string file = "", std::string func = "", int line = -1)
228 : {
229 : // if not using default values, then the input must be specified
230 91 : if (!firstbydefault)
231 : {
232 0 : if (!contains(name.c_str()))
233 : {
234 0 : Util::ParmParseException(INFO,file,func,line,full(name),"required value for ",full(name)," missing");
235 : }
236 : }
237 :
238 : // set default value
239 91 : value = std::string(possiblecharvals[0]);
240 :
241 : // get the read value (if it exists)
242 91 : int retval = query(name.c_str(),value);
243 :
244 : // check to make sure the read value matches one of the inpus
245 91 : bool ok = false;
246 385 : for (unsigned int i = 0; i < possiblecharvals.size(); i++)
247 : {
248 588 : if (value == std::string(possiblecharvals[i])) ok = true;
249 : }
250 :
251 91 : if (ok) return retval;
252 :
253 0 : std::stringstream ss;
254 0 : ss << possiblecharvals[0];
255 0 : for (unsigned int i = 1; i < possiblecharvals.size(); i++)
256 0 : ss << "," << possiblecharvals[i];
257 :
258 0 : Util::ParmParseException(INFO,file,func,line,full(name),"' expected [", ss.str(), "] but got ", value);
259 :
260 0 : return -1;
261 0 : }
262 :
263 91 : int query_validate( std::string name, std::string & value, std::vector<const char *> possiblecharvals,
264 : std::string file = "", std::string func = "", int line = -1)
265 : {
266 91 : return query_validate(name,value,possiblecharvals,true,file,func,line);
267 : }
268 :
269 :
270 : // special case for strings
271 131 : int query_default( std::string name, std::string & value, const char *defaultvalue,
272 : std::string file = "", std::string func = "", int line = -1)
273 : {
274 393 : return query_default(name, value, std::string(defaultvalue), file, func, line);
275 : }
276 : // special case for bools
277 51 : int query_default( std::string name, int & value, bool defaultvalue,
278 : std::string file = "", std::string func = "query_default", int line = -1)
279 : {
280 51 : int defaultint = 0;
281 51 : if (defaultvalue) defaultint = 1;
282 51 : return query_default(name, value, defaultint, file, func, line);
283 : }
284 :
285 :
286 :
287 : // validate filenames
288 2 : int query_file( std::string name, std::string & value, bool copyfile, bool checkfile,
289 : std::string file = "", std::string func = "query_file", int line = -1)
290 : {
291 : try
292 : {
293 4 : if (!contains(name.c_str()))
294 : {
295 0 : Util::ParmParseException(INFO,file,func,line,full(name),full(name)," must be specified");
296 : }
297 :
298 2 : int retval = query(name.c_str(),value);
299 :
300 2 : if (amrex::ParallelDescriptor::IOProcessor())
301 : {
302 2 : if ( checkfile && ! std::filesystem::exists(value))
303 : {
304 0 : Util::ParmParseException(INFO,file,func,line,full(name),full(name)," does not exist");
305 : }
306 2 : if ( checkfile && !std::filesystem::is_regular_file(value))
307 : {
308 0 : Util::ParmParseException(INFO,file,func,line,full(name),full(name)," is not a regular file");
309 : }
310 2 : if ( copyfile )
311 : {
312 2 : Util::CopyFileToOutputDir(value, true, full(name));
313 : }
314 : }
315 2 : return retval;
316 : }
317 0 : catch (...)
318 : {
319 0 : Util::ParmParseException(INFO,file,func,line,full(name));
320 0 : }
321 0 : return -1;
322 : }
323 : int query_file( std::string name, std::string & value, bool copyfile,
324 : std::string file = "", std::string func = "query_file", int line = -1)
325 : {
326 : return query_file(name,value,copyfile,true,file,func,line);
327 : }
328 2 : int query_file( std::string name, std::string & value,
329 : std::string file = "", std::string func = "query_file", int line = -1)
330 : {
331 2 : return query_file(name,value,true,true,file,func,line);
332 : }
333 :
334 :
335 : template<typename T>
336 166 : int queryarr( std::string name, std::vector<T> & value,
337 : std::string /*file*/, std::string /*func*/, int /*line*/)
338 : {
339 166 : return amrex::ParmParse::queryarr(name.c_str(),value);
340 : }
341 10 : int queryarr( std::string name, Set::Vector & value,
342 : std::string file = "", std::string func = "queryarr", int line = -1)
343 : {
344 10 : std::vector<Set::Scalar> vals;
345 10 : amrex::ParmParse::queryarr(name.c_str(), vals);
346 10 : if (vals.size() < AMREX_SPACEDIM)
347 : {
348 0 : Util::ParmParseException(INFO,file,func,line,full(name),full(name)," requires at least ", AMREX_SPACEDIM, " arguments, got ",vals.size());
349 : }
350 31 : for (int i = 0; i < AMREX_SPACEDIM; i++) value(i) = vals[i];
351 10 : return 0;
352 10 : }
353 6 : int queryarr( std::string name, Set::Matrix & value,
354 : std::string file = "", std::string func = "queryarr", int line = -1)
355 : {
356 6 : std::vector<Set::Scalar> vals;
357 6 : amrex::ParmParse::queryarr(name.c_str(), vals);
358 6 : if (vals.size() == 9)
359 : {
360 : #if AMREX_SPACEDIM==2
361 4 : Util::Warning(file,func,line,"Reading a 3D matrix (",full(name),")into a 2D code - some values will be ignored.");
362 4 : value(0,0) = vals[0]; value(0,1)= vals[1];
363 4 : value(1,0) = vals[3]; value(1,1)= vals[4];
364 : #endif
365 : #if AMREX_SPACEDIM==3
366 2 : value(0,0) = vals[0]; value(0,1)= vals[1]; value(0,2)= vals[2];
367 2 : value(1,0) = vals[3]; value(1,1)= vals[4]; value(1,2)= vals[5];
368 2 : value(2,0) = vals[6]; value(2,1)= vals[7]; value(2,2)= vals[8];
369 : #endif
370 : }
371 0 : else if (vals.size() == 4)
372 : {
373 : #if AMREX_SPACEDIM==2
374 0 : value(0,0) = vals[0]; value(0,1)= vals[1];
375 0 : value(1,0) = vals[2]; value(1,1)= vals[3];
376 : #endif
377 : #if AMREX_SPACEDIM==3
378 0 : Util::Warning(file,func,line,"Reading a 2D matrix (",full(name),")into a 3D code - remaining values will be set to zero.");
379 0 : value(0,0) = vals[0]; value(0,1)= vals[1]; value(0,2)= 0.0;
380 0 : value(1,0) = vals[2]; value(1,1)= vals[3]; value(1,2)= 0.0;
381 0 : value(2,0) = 0.0; value(2,1)= 0.0; value(2,2)= 0.0;
382 : #endif
383 : }
384 : else
385 : {
386 0 : Util::ParmParseException(INFO,file,func,line,full(name),full(name)," needs either 4 or 9 components, but got ",vals.size());
387 : }
388 6 : return 0;
389 6 : }
390 : template<typename T>
391 33 : int queryarr_required( std::string name, std::vector<T> & value,
392 : std::string file, std::string func, int line)
393 : {
394 66 : if (!contains(name.c_str()))
395 : {
396 0 : Util::ParmParseException(INFO,file,func,line,full(name),"required value for ",full(name)," missing");
397 : }
398 33 : return queryarr(name,value,file,func,line);
399 : }
400 :
401 :
402 384 : int queryarr_default( std::string name, std::vector<std::string> & value, std::string defaultvalue,
403 : std::string = "", std::string = "", int = -1)
404 : {
405 768 : if (!contains(name.c_str()))
406 : {
407 170 : add(name.c_str(),defaultvalue);
408 : }
409 384 : return queryarr(name.c_str(),value);
410 : }
411 :
412 :
413 :
414 : template <typename T>
415 : int
416 18 : queryclass_enumerate(std::string a_name, std::vector<T> &value, int number = 1,
417 : std::string file = "", std::string func = "", int line = __LINE__)
418 : {
419 18 : value.clear();
420 :
421 : //
422 : // If only one is present with no subscript, then read
423 : // it only and return.
424 : //
425 18 : std::string name = a_name;
426 18 : if (this->contains(name))
427 : {
428 8 : for (int n = 0; n < number; n++)
429 : {
430 4 : T tmp;
431 4 : this->queryclass<T>(name, tmp, file, func, line);
432 4 : value.push_back(tmp);
433 : }
434 4 : return 0;
435 : }
436 :
437 : //
438 : // Some logic to determine whether we are starting with zero
439 : // (model0, model1, model2, ...)
440 : // or one
441 : // (model1, model2, model3, ...)
442 : // since both are supported
443 : //
444 14 : int start = -1;
445 14 : std::string name0 = a_name + std::to_string(0);
446 14 : std::string name1 = a_name + std::to_string(1);
447 28 : if (this->contains(name0.c_str()))
448 : {
449 0 : start = 0;
450 0 : name = name0;
451 : }
452 28 : else if (this->contains(name1.c_str()))
453 : {
454 14 : start = 1;
455 14 : name = name1;
456 : }
457 : else
458 : {
459 0 : Util::Exception(INFO,"Enumerations must begin with 0 or 1");
460 : }
461 :
462 : //
463 : // Iterate over items called (model0), model1, model2, etc
464 : // until no more are found then exit.
465 : //
466 76 : for (int cntr = start; this->contains(name.c_str()); cntr++)
467 : {
468 34 : if (this->contains(name.c_str()))
469 : {
470 17 : T tmp;
471 17 : this->queryclass<T>(name, tmp, file, func, line);
472 17 : value.push_back(tmp);
473 17 : }
474 17 : name = a_name + std::to_string(cntr+1);
475 : }
476 :
477 14 : return 0;
478 18 : }
479 :
480 :
481 : template <typename T>
482 : int
483 16 : query_enumerate(std::string a_name, std::vector<T> &value, int number = 1,
484 : std::string file = "", std::string func = "", int line = __LINE__)
485 : {
486 16 : value.clear();
487 :
488 : //
489 : // If only one is present with no subscript, then read
490 : // it only and return.
491 : //
492 16 : std::string name = a_name;
493 16 : if (this->contains(name))
494 : {
495 0 : for (int n = 0; n < number; n++)
496 : {
497 0 : T tmp;
498 0 : this->query_required(name, tmp, file, func, line);
499 0 : value.push_back(tmp);
500 : }
501 0 : return 0;
502 : }
503 :
504 : //
505 : // Some logic to determine whether we are starting with zero
506 : // (model0, model1, model2, ...)
507 : // or one
508 : // (model1, model2, model3, ...)
509 : // since both are supported
510 : //
511 16 : int start = -1;
512 16 : std::string name0 = a_name + std::to_string(0);
513 16 : std::string name1 = a_name + std::to_string(1);
514 32 : if (this->contains(name0.c_str()))
515 : {
516 16 : start = 0;
517 16 : name = name0;
518 : }
519 0 : else if (this->contains(name1.c_str()))
520 : {
521 0 : start = 1;
522 0 : name = name1;
523 : }
524 : else
525 : {
526 0 : Util::Exception(INFO,"Enumerations must begin with 0 or 1");
527 : }
528 :
529 : //
530 : // Iterate over items called (model0), model1, model2, etc
531 : // until no more are found then exit.
532 : //
533 90 : for (int cntr = start; this->contains(name.c_str()); cntr++)
534 : {
535 42 : if (this->contains(name.c_str()))
536 : {
537 21 : T tmp;
538 21 : this->query_required(name, tmp, file, func, line);
539 21 : value.push_back(tmp);
540 21 : }
541 21 : name = a_name + std::to_string(cntr+1);
542 : }
543 :
544 16 : return 0;
545 16 : }
546 :
547 :
548 :
549 3 : int AnyUnusedInputs()
550 : {
551 3 : int cnt = 0;
552 414 : for (auto li = m_table->begin(), End = m_table->end(); li != End; ++li)
553 : {
554 411 : if (!li->second.m_count && li->first.rfind(getPrefix()+".",0) != std::string::npos)
555 : {
556 0 : Util::Warning(INFO,li->first);
557 0 : cnt++;
558 : }
559 : }
560 3 : return cnt;
561 : }
562 :
563 173 : std::vector<std::string> GetUnusedInputs()
564 : {
565 173 : std::vector<std::string> ret;
566 21138 : for (auto li = m_table->begin(), End = m_table->end(); li != End; ++li)
567 : {
568 20965 : if (!li->second.m_count && li->first.rfind(getPrefix()+".",0) != std::string::npos)
569 : {
570 0 : ret.push_back(li->first);
571 : }
572 : }
573 173 : return ret;
574 0 : }
575 :
576 0 : static int AllUnusedInputs()
577 : {
578 0 : ParmParse pp;
579 0 : int cnt = 0;
580 0 : for (auto li = pp.m_table->begin(), End = pp.m_table->end(); li != End; ++li)
581 : {
582 0 : if (!li->second.m_count)
583 : {
584 0 : Util::Warning(INFO,li->first);
585 0 : cnt++;
586 : }
587 : }
588 0 : return cnt;
589 0 : }
590 0 : std::string prefix ()
591 : {
592 0 : return getPrefix();
593 : }
594 3388 : std::string full (std::string name)
595 : {
596 3388 : std::string prefix = getPrefix();
597 3388 : if (prefix != "") return getPrefix() + "." + name;
598 1520 : else return name;
599 3388 : }
600 :
601 :
602 : using amrex::ParmParse::queryarr;
603 : template<class T>
604 : void queryclass(std::string name, T * value,
605 : std::string file = "", std::string func = "", int line = -1)
606 : {
607 : auto old_prefix = m_prefix;
608 : try
609 : {
610 : if (old_prefix.empty()) m_prefix = name;
611 : else m_prefix.append(".").append(name);
612 : T::Parse(*value, *this);
613 : std::vector<std::string> unused_inputs = GetUnusedInputs();
614 : if (unused_inputs.size())
615 : {
616 : std::stringstream ss;
617 : for (unsigned int i=0; i < unused_inputs.size(); i++)
618 : ss << "\n\t" << unused_inputs[i];
619 : Util::ParmParseException(INFO,file,func,line,name,"The following inputs were specified but not used",ss.str());
620 : }
621 : }
622 : catch (...)
623 : {
624 : m_prefix = old_prefix;
625 : Util::ParmParseException(INFO,file,func,line,full(name));
626 : }
627 : m_prefix = old_prefix;
628 : }
629 : template<class T>
630 173 : void queryclass(std::string name, T & value,
631 : std::string file = "", std::string func = "", int line = __LINE__)
632 : {
633 173 : auto old_prefix = m_prefix;
634 : try
635 : {
636 173 : if (old_prefix.empty()) m_prefix = name;
637 0 : else m_prefix.append(".").append(name);
638 173 : T::Parse(value, *this);
639 173 : std::vector<std::string> unused_inputs = GetUnusedInputs();
640 173 : if (unused_inputs.size())
641 : {
642 0 : std::stringstream ss;
643 0 : for (unsigned int i=0; i < unused_inputs.size(); i++)
644 0 : ss << "\n\t" << unused_inputs[i];
645 0 : Util::ParmParseException(INFO,file,func,line,name,"The following inputs were specified but not used",ss.str());
646 0 : }
647 173 : }
648 0 : catch (...)
649 : {
650 0 : m_prefix = old_prefix;
651 0 : Util::ParmParseException(INFO,file,func,line,full(name));
652 : }
653 173 : m_prefix = old_prefix;
654 173 : }
655 :
656 : template<class T>
657 : void queryclass(T * value,
658 : std::string file = "", std::string func = "", int line = __LINE__)
659 : {
660 : try
661 : {
662 : T::Parse(*value, *this);
663 : }
664 : catch (...)
665 : {
666 : Util::ParmParseException(INFO,file,func,line,getPrefix());
667 : }
668 : }
669 : template<class T>
670 457 : void queryclass(T & value,
671 : std::string file = "", std::string func = "", int line = __LINE__)
672 : {
673 : try
674 : {
675 457 : T::Parse(value, *this);
676 : }
677 0 : catch (...)
678 : {
679 0 : Util::ParmParseException(INFO,file,func,line,getPrefix());
680 : }
681 457 : }
682 :
683 : //
684 : // Variadic template parsing operator to assign a pointer to
685 : // one of a set of possible class objects, then call that method's
686 : // Parse function.
687 : //
688 : // If there is more than one instantiating class, then type must be set.
689 : // Otherwise, no type is necessary.
690 : //
691 : template<typename... IC, typename... Args, typename PTRTYPE>
692 44 : void select (std::string name, PTRTYPE *& ic_eta, Args&&... args)
693 : {
694 : // if there is only one IC arg provided, we don't need to check the type - assume that
695 : // it is the default.
696 : if constexpr (sizeof...(IC) == 0)
697 : {
698 : using first_IC = std::tuple_element_t<0, std::tuple<IC...>>;
699 : ic_eta = new first_IC(std::forward<Args>(args)..., (*this), name + "." + std::string(first_IC::name));
700 : }
701 : // otherwise, check the type.
702 : else
703 : {
704 88 : std::string type = "";
705 132 : this->query_required(name + ".type", type);
706 48 : bool matched = (( type == IC::name
707 157 : ? (ic_eta = new IC(std::forward<Args>(args)..., (*this), name + "." + std::string(IC::name))),
708 : true
709 114 : : false) || ...);
710 44 : if (!matched)
711 0 : Util::Exception(INFO, type, " not a valid type for ", name);
712 44 : }
713 44 : }
714 :
715 : //
716 : // Identical to the above, except sets the type automatically to the
717 : // firs specified
718 : //
719 : template<typename FirstIC, typename... IC, typename... Args, typename PTRTYPE>
720 77 : void select_default (std::string name, PTRTYPE *& ic_eta, Args&&... args)
721 : {
722 154 : std::string type = "";
723 :
724 231 : this->query_default(name + ".type", type, FirstIC::name);
725 :
726 0 : bool matched =
727 154 : (( type == FirstIC::name
728 193 : ? (ic_eta = new FirstIC(std::forward<Args>(args)..., (*this), name + "." + std::string(FirstIC::name))),
729 : true : false))
730 154 : ||
731 19 : (( type == IC::name
732 125 : ? (ic_eta = new IC(std::forward<Args>(args)..., (*this), name + "." + std::string(IC::name))),
733 : true : false) || ...);
734 :
735 :
736 77 : if (!matched)
737 0 : Util::Exception(INFO,type," not a valid type for ",name);
738 77 : }
739 :
740 : //
741 : // Similar to select but specialized for main functions
742 : //
743 : template<typename... INTEGRATOR, typename... Args, typename PTRTYPE>
744 : void select_main (PTRTYPE *& ic_eta, Args&&... args)
745 : {
746 : std::string type = "";
747 :
748 : this->query_required("alamo.program", type);
749 :
750 : bool matched = ((type == INTEGRATOR::name
751 : ? (ic_eta = new INTEGRATOR(std::forward<Args>(args)..., (*this))),
752 : true
753 : : false) || ...);
754 : if (!matched)
755 : Util::Exception(INFO,type," not a valid type for ",type);
756 : }
757 :
758 : //
759 : // Similar to select_main but works for one function only
760 : // and doesn't require a type specifier.
761 : //
762 :
763 : // with variadic arguments
764 : template<typename INTEGRATOR, typename Args, typename PTRTYPE>
765 : void select_only (PTRTYPE *& ic_eta, Args&& args)
766 : {
767 : ic_eta = new INTEGRATOR(std::forward<Args>(args), (*this));
768 : }
769 : // without variadic arguments
770 : template<typename INTEGRATOR, typename PTRTYPE>
771 36 : void select_only (PTRTYPE *& ic_eta)
772 : {
773 36 : ic_eta = new INTEGRATOR((*this));
774 36 : }
775 :
776 :
777 : template <int N>
778 17 : void query_exactly(std::vector<std::string> names, std::pair<std::string, Set::Scalar> values[N])
779 : {
780 17 : int cnt = 0;
781 102 : for (unsigned int n = 0; n < names.size(); n++)
782 : {
783 85 : if (amrex::ParmParse::contains(names[n].c_str()))
784 : {
785 34 : cnt++;
786 : }
787 : }
788 119 : Util::Assert(INFO, TEST(cnt == N), "incorrect number of values specified");
789 :
790 17 : cnt = 0;
791 102 : for (unsigned int n = 0; n < names.size(); n++)
792 : {
793 85 : if (amrex::ParmParse::contains(names[n].c_str()))
794 : {
795 34 : values[cnt].first = names[n];
796 102 : query_required(names[n],values[cnt].second);
797 34 : cnt++;
798 : }
799 : }
800 17 : }
801 :
802 :
803 :
804 :
805 : };
806 : }
807 : #endif
|
