Nektar++
BasicUtils/SessionReader.cpp
Go to the documentation of this file.
1///////////////////////////////////////////////////////////////////////////////
2//
3// File: SessionReader.cpp
4//
5// For more information, please see: http://www.nektar.info
6//
7// The MIT License
8//
9// Copyright (c) 2006 Division of Applied Mathematics, Brown University (USA),
10// Department of Aeronautics, Imperial College London (UK), and Scientific
11// Computing and Imaging Institute, University of Utah (USA).
12//
13// Permission is hereby granted, free of charge, to any person obtaining a
14// copy of this software and associated documentation files (the "Software"),
15// to deal in the Software without restriction, including without limitation
16// the rights to use, copy, modify, merge, publish, distribute, sublicense,
17// and/or sell copies of the Software, and to permit persons to whom the
18// Software is furnished to do so, subject to the following conditions:
19//
20// The above copyright notice and this permission notice shall be included
21// in all copies or substantial portions of the Software.
22//
23// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
24// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
25// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
26// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
27// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
28// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
29// DEALINGS IN THE SOFTWARE.
30//
31// Description: Session reader
32//
33///////////////////////////////////////////////////////////////////////////////
34
35#ifndef TIXML_USE_STL
36#define TIXML_USE_STL
37#endif
38
41
42#include <fstream>
43#include <iostream>
44#include <string>
45
46#include <boost/algorithm/string.hpp>
47#include <boost/iostreams/copy.hpp>
48#include <boost/iostreams/filter/gzip.hpp>
49#include <boost/iostreams/filtering_streambuf.hpp>
50
51#include <tinyxml.h>
52
60
61#include <boost/format.hpp>
62#include <boost/program_options.hpp>
63
64#ifndef NEKTAR_VERSION
65#define NEKTAR_VERSION "Unknown"
66#endif
67
68using namespace std;
69
70namespace po = boost::program_options;
71namespace io = boost::iostreams;
72
74{
75/**
76 * @class SessionReader
77 *
78 * This class provides an interface to Nektar++-specific content in a
79 * supplied XML document. It also initialises a Nektar++ session
80 * including setting up communication for parallel execution and where
81 * necessary partitioning the supplied mesh for running across multiple
82 * processes.
83 *
84 * A session should be initialised at the beginning of a user's
85 * application by passing the command-line arguments. This not only
86 * allows the SessionReader to extract the name of the XML document to
87 * load containing Nektar++ session information, but also supplies the
88 * MPI arguments necessary for setting up parallel communication. The
89 * SessionReader should be initialised using the #CreateInstance
90 * function:
91 * @code
92 * LibUtilities::SessionReaderSharedPtr vSession
93 * = LibUtilities::SessionReader::CreateInstance(argc, argv);
94 * @endcode
95 * The instance \c vSession can now be passed to other key Nektar++
96 * components during their construction.
97 * @note At the end of the user application, it is important to call the
98 * #Finalise routine in order to finalise any MPI communication and
99 * correctly free resources.
100 *
101 * The SessionReader class provides streamlined, validated access to
102 * session parameters, solver information and functions defined within a
103 * Nektar++ XML document. The available routines and their usage is
104 * documented below.
105 *
106 * In the case of solver information properties, the classes to which
107 * these parameters are pertinent may register with the SessionReader
108 * class the set of valid values for a given property. Such values may
109 * also be associated with an enumeration value for more transparent use
110 * of the property values in code.
111 */
112
113/**
114 * This map of maps stores the list of valid string values for a number
115 * of solver information parameters. The top level map connects
116 * different parameter names to their list of possible values. The list
117 * of possible values is also a map, mapping a valid string to a
118 * corresponding enum value.
119 *
120 * This list is populated through the #RegisterEnumValue static member
121 * function which is called statically from various classes to register
122 * the valid values for solver info parameters associated with them. The
123 * map is therefore fully populated before the SessionReader class is
124 * instantiated and a file is read in and parsed.
125 */
127{
128 static EnumMapList solverInfoEnums;
129 return solverInfoEnums;
130}
131
132/**
133 * List of default values for solver information parameters to be used
134 * in the case of them not being provided.
135 *
136 * This list is populated through the #RegisterDefaultSolverInfo static
137 * member variable which is called statically from various classes to
138 * register the default value for a given parameter.
139 */
141{
142 static SolverInfoMap solverInfoMap;
143 return solverInfoMap;
144}
145
146/**
147 * List of values for GlobalSysSoln parameters to be used to override
148 * details given in SolverInfo
149 *
150 * This list is populated by ReadGlobalSysSolnInfo if the
151 * GLOBALSYSSOLNINFO section is defined in the input file.
152 * This List allows for details to define for the Global Sys
153 * solver for each variable.
154 */
156{
157 static GloSysSolnInfoList gloSysSolnInfoList;
158 return gloSysSolnInfoList;
159}
160
161/**
162 * Lists the possible command-line argument which can be specified for
163 * this executable.
164 *
165 * This list is populated through the #RegisterCmdLineArgument static
166 * member function which is called statically from various classes to
167 * register command-line arguments they need.
168 */
170{
171 static CmdLineArgMap cmdLineArguments;
172 return cmdLineArguments;
173}
174
175/**
176 * This constructor parses the command-line arguments given to the user
177 * application to set up any MPI communication, read supplied XML
178 * session files, and partition meshes where necessary.
179 *
180 * @param argc Number of command-line arguments
181 * @param argv Array of command-line arguments
182 */
183SessionReader::SessionReader(int argc, char *argv[])
184{
185 m_xmlDoc = nullptr;
187
188 ASSERTL0(m_filenames.size() > 0, "No session file(s) given.");
189
191
192 // Create communicator
193 CreateComm(argc, argv);
194
196
197 // Split up the communicator
199
200 // If running in parallel change the default global sys solution
201 // type.
202 if (m_comm->GetSpaceComm()->GetSize() > 1)
203 {
204 GetSolverInfoDefaults()["GLOBALSYSSOLN"] = "IterativeStaticCond";
205 }
206
208 m_interpreter->SetRandomSeed((m_comm->GetSpaceComm()->GetRank() + 1) *
209 (unsigned int)time(nullptr));
210}
211
212/**
213 *
214 */
215SessionReader::SessionReader(int argc, char *argv[],
216 const std::vector<std::string> &pFilenames,
217 const CommSharedPtr &pComm, const int &timelevel)
218{
219 ASSERTL0(pFilenames.size() > 0, "No filenames specified.");
220
221 ParseCommandLineArguments(argc, argv);
222 m_xmlDoc = nullptr;
223 m_filenames = pFilenames;
224
226
227 // Create communicator
228 if (!pComm.get())
229 {
230 CreateComm(argc, argv);
231 }
232 else
233 {
234 m_comm = pComm;
235 }
236
238
239 // Split up the communicator
241
242 // If running in parallel change the default global sys solution
243 // type.
244 if (m_comm->GetSpaceComm()->GetSize() > 1)
245 {
246 GetSolverInfoDefaults()["GLOBALSYSSOLN"] = "IterativeStaticCond";
247 }
248
250 m_interpreter->SetRandomSeed((m_comm->GetSpaceComm()->GetRank() + 1) *
251 (unsigned int)time(nullptr));
252
253 // Set time level (Parallel-in-Time)
254 m_timeLevel = timelevel;
255}
256
257/**
258 *
259 */
261{
262 if (m_xmlDoc)
263 {
264 delete m_xmlDoc;
265 }
266}
267
268/**
269 * Performs the main initialisation of the object. The XML file provided
270 * on the command-line is loaded and any mesh partitioning is done. The
271 * resulting process-specific XML file (containing the process's
272 * geometry partition) is then reloaded and parsed.
273 */
274void SessionReader::InitSession(const std::vector<std::string> &filenames)
275{
276 // Re-load filenames for session if required.
277 if (filenames.size() > 0)
278 {
279 m_filenames = filenames;
280 }
281
282 // check specified opt file
283 std::string optfile;
284 int exists;
285
286 if (DefinesCmdLineArgument("use-opt-file"))
287 {
288 optfile =
289 m_cmdLineOptions.find("use-opt-file")->second.as<std::string>();
290 exists = fs::exists(optfile.c_str());
291 ASSERTL0(exists, "A valid .opt file was not specified "
292 "with the --use-opt-file command line option");
293
294 m_filenames.push_back(optfile);
295
296 // put opt file at beginning
297 std::rotate(m_filenames.rbegin(), m_filenames.rbegin() + 1,
298 m_filenames.rend());
299 }
300 else // check for write-opt-file
301 {
302 // check for opt file
303 optfile = m_sessionName.substr(0, m_sessionName.find("_xml/")) + ".opt";
304 exists = fs::exists(optfile.c_str());
305
306 // For Paralell-in-Time
307 if (exists && m_comm->IsParallelInTime())
308 {
309 TiXmlDocument doc;
310 doc.LoadFile(optfile);
311 TiXmlElement *xmlTag = doc.FirstChildElement("NEKTAR")
312 ->FirstChildElement("COLLECTIONS")
313 ->FirstChildElement("TIMELEVEL");
314 if (xmlTag)
315 {
316 // if there is a TIMELEVEL tag, then turn existing flag to false
317 // and check if the required time level is specified in the
318 // optfile.
319 exists = false;
320 while (xmlTag)
321 {
322 if (m_timeLevel == stoi(xmlTag->Attribute("VALUE")))
323 {
324 exists = true;
325 break;
326 }
327 xmlTag = xmlTag->NextSiblingElement();
328 }
329 }
330 }
331
332 if (exists)
333 {
334 m_filenames.push_back(optfile);
335 // rotate order so opt file can be overwritten by
336 // direct choice in xml file
337 std::rotate(m_filenames.rbegin(), m_filenames.rbegin() + 1,
338 m_filenames.rend());
339 }
340 else
341 {
342 m_updateOptFile = true;
343 }
344 }
345
346 // Merge document if required.
347 if (m_xmlDoc)
348 {
349 delete m_xmlDoc;
350 }
351
353
354 // Parse the XML data in #m_xmlDoc
356
357 // Override SOLVERINFO and parameters with any specified on the
358 // command line.
360
361 // Verify SOLVERINFO values
363
364 // Disable backups if NEKTAR_DISABLE_BACKUPS is set.
365 if (std::getenv("NEKTAR_DISABLE_BACKUPS") != nullptr)
366 {
367 m_backups = false;
368 }
369
370 // In verbose mode, print out parameters and solver info sections
371 if (m_verbose && m_comm)
372 {
373 if (m_comm->TreatAsRankZero() && m_parameters.size() > 0)
374 {
375 cout << "Parameters:" << endl;
376 for (auto &x : m_parameters)
377 {
378 cout << "\t" << x.first << " = " << x.second << endl;
379 }
380 cout << endl;
381 }
382
383 if (m_comm->TreatAsRankZero() && m_solverInfo.size() > 0)
384 {
385 cout << "Solver Info:" << endl;
386 for (auto &x : m_solverInfo)
387 {
388 cout << "\t" << x.first << " = " << x.second << endl;
389 }
390 cout << endl;
391 }
392 }
393}
394
395/**
396 *
397 */
399{
400 m_sharedFilesystem = false;
401
402 if (m_comm->GetSize() > 1)
403 {
404 if (m_comm->GetRank() == 0)
405 {
406 std::ofstream testfile("shared-fs-testfile");
407 testfile << "" << std::endl;
408 ASSERTL1(!testfile.fail(), "Test file creation failed");
409 testfile.close();
410 }
411 m_comm->Block();
412
413 int exists = fs::exists("shared-fs-testfile");
414 m_comm->AllReduce(exists, LibUtilities::ReduceSum);
415
416 m_sharedFilesystem = (exists == m_comm->GetSize());
417
418 if ((m_sharedFilesystem && m_comm->GetRank() == 0) ||
420 {
421 std::remove("shared-fs-testfile");
422 }
423 }
424 else
425 {
426 m_sharedFilesystem = false;
427 }
428
429 if (m_verbose && m_comm->GetRank() == 0 && m_sharedFilesystem)
430 {
431 cout << "Shared filesystem detected" << endl;
432 }
433}
434
435/**
436 * @brief Parses the command-line arguments for known options and
437 * filenames.
438 */
439std::vector<std::string> SessionReader::ParseCommandLineArguments(int argc,
440 char *argv[])
441{
442 // List the publically visible options (listed using --help).
443 po::options_description desc("Allowed options");
444 po::options_description dep("Deprecated options");
445
446 // clang-format off
447 desc.add_options()
448 ("force-output,f","disables backups files and forces output to be "
449 "written without any checks")
450 ("help,h", "print this help message")
451 ("solverinfo,I", po::value<vector<std::string>>(),
452 "override a SOLVERINFO property")
453 ("parameter,P", po::value<vector<std::string>>(),
454 "override a parameter")
455 ("verbose,v", "be verbose")
456 ("version,V", "print version information")
457 ("no-exp-opt", "Do not use expansion optimisation for collections")
458 ("npx", po::value<int>(),
459 "number of procs in X-dir")
460 ("npy", po::value<int>(),
461 "number of procs in Y-dir")
462 ("npz", po::value<int>(),
463 "number of procs in Z-dir")
464 ("nsz", po::value<int>(),
465 "number of slices in Z-dir")
466 ("npt", po::value<int>(),
467 "number of procs in T-dir (parareal)")
468 ("part-only", po::value<int>(),
469 "only partition mesh into N partitions.")
470 ("part-only-overlapping", po::value<int>(),
471 "only partition mesh into N overlapping partitions.")
472 ("part-info", "output partition information")
473 ("write-opt-file","write an optimisation file")
474 ("use-opt-file", po::value<std::string>(),
475 "use an optimisation file");
476 // clang-format on
477
478#ifdef NEKTAR_USE_CWIPI
479 desc.add_options()("cwipi", po::value<std::string>(), "set CWIPI name");
480#endif
481
482 for (auto &cmdIt : GetCmdLineArgMap())
483 {
484 std::string names = cmdIt.first;
485 if (cmdIt.second.shortName != "")
486 {
487 names += "," + cmdIt.second.shortName;
488 }
489 if (cmdIt.second.isFlag)
490 {
491 desc.add_options()(names.c_str(), cmdIt.second.description.c_str());
492 }
493 else
494 {
495 desc.add_options()(names.c_str(), po::value<std::string>(),
496 cmdIt.second.description.c_str());
497 }
498 }
499
500 // Deprecated options: introduced in 5.4.0 to homogenise command-line
501 // options to use '-' instead of camelCase or no spaces.
502 std::map<std::string, std::string> deprecated = {
503 {"forceoutput", "force-output"},
504 {"writeoptfile", "write-opt-file"},
505 {"useoptfile", "use-opt-file"}};
506
507 for (auto &d : deprecated)
508 {
509 std::string description = "Deprecated: use --" + d.second;
510 dep.add_options()(d.first.c_str(), description.c_str());
511 }
512
513 // List hidden options (e.g. session file arguments are not actually
514 // specified using the input-file option by the user).
515 po::options_description hidden("Hidden options");
516
517 hidden.add_options()("input-file", po::value<vector<string>>(),
518 "input filename");
519
520 // Combine all options for the parser
521 po::options_description all("All options");
522 all.add(desc).add(dep).add(hidden);
523
524 // Session file is a positional option
525 po::positional_options_description p;
526 p.add("input-file", -1);
527
528 // Parse the command-line options
529 po::parsed_options parsed = po::command_line_parser(argc, argv)
530 .options(all)
531 .positional(p)
532 .allow_unregistered()
533 .run();
534
535 // Extract known options to map and update
536 po::store(parsed, m_cmdLineOptions);
537 po::notify(m_cmdLineOptions);
538
539 // Help message
540 if (m_cmdLineOptions.count("help"))
541 {
542 cout << desc;
543 exit(0);
544 }
545
546 // Version information
547 if (m_cmdLineOptions.count("version"))
548 {
549 cout << "Nektar++ version " << NEKTAR_VERSION;
550
551 if (NekConstants::kGitSha1 != "GITDIR-NOTFOUND")
552 {
554 string branch(NekConstants::kGitBranch);
555 boost::replace_all(branch, "refs/heads/", "");
556
557 cout << " (git changeset " << sha1.substr(0, 8) << ", ";
558
559 if (branch == "")
560 {
561 cout << "detached head";
562 }
563 else
564 {
565 cout << "head " << branch;
566 }
567
568 cout << ")";
569 }
570
571 cout << endl;
572 exit(0);
573 }
574
575 // Deal with deprecated options.
576 for (auto &d : deprecated)
577 {
578 if (m_cmdLineOptions.count(d.first))
579 {
580 std::cerr << "Warning: --" << d.first << " deprecated: use --"
581 << d.second << std::endl;
582 m_cmdLineOptions.emplace(
583 d.second, po::variable_value(m_cmdLineOptions[d.first]));
584 }
585 }
586
587 // Enable verbose mode
588 if (m_cmdLineOptions.count("verbose"))
589 {
590 m_verbose = true;
591 }
592 else
593 {
594 m_verbose = false;
595 }
596
597 // Disable backups
598 if (m_cmdLineOptions.count("force-output"))
599 {
600 m_backups = false;
601 }
602 else
603 {
604 m_backups = true;
605 }
606
607 // Enable update optimisation file
608 if (m_cmdLineOptions.count("write-opt-file"))
609 {
610 m_updateOptFile = true;
611 }
612 else
613 {
614 m_updateOptFile = false;
615 }
616
617 // Print a warning for unknown options
618 for (auto &x : parsed.options)
619 {
620 if (x.unregistered)
621 {
622 cout << "Warning: Unknown option: " << x.string_key << endl;
623 }
624 }
625
626 // Return the vector of filename(s) given as positional options
627 if (m_cmdLineOptions.count("input-file"))
628 {
629 return m_cmdLineOptions["input-file"].as<std::vector<std::string>>();
630 }
631 else
632 {
633 return std::vector<std::string>();
634 }
635}
636
637/**
638 *
639 */
640std::string SessionReader::ParseSessionName(std::vector<std::string> &filenames)
641{
642 ASSERTL0(!filenames.empty(), "At least one filename expected.");
643
644 std::string retval = "";
645
646 // First input file defines the session name
647 std::string fname = filenames[0];
648
649 // If loading a pre-partitioned mesh, remove _xml extension
650 if (fname.size() > 4 && fname.substr(fname.size() - 4, 4) == "_xml")
651 {
652 retval = fname.substr(0, fname.find_last_of("_"));
653 }
654 // otherwise remove the .xml extension
655 else if (fname.size() > 4 && fname.substr(fname.size() - 4, 4) == ".xml")
656 {
657 retval = fname.substr(0, fname.find_last_of("."));
658 }
659 // If compressed .xml.gz, remove both extensions
660 else if (fname.size() > 7 && fname.substr(fname.size() - 7, 7) == ".xml.gz")
661 {
662 retval = fname.substr(0, fname.find_last_of("."));
663 retval = retval.substr(0, retval.find_last_of("."));
664 }
665
666 return retval;
667}
668
669/**
670 *
671 */
673{
674 ASSERTL1(m_xmlDoc, "XML Document not defined.");
675 return *m_xmlDoc;
676}
677
678/**
679 * The single parameter specifies a path to the requested element in a
680 * similar format to the filesystem path. Given the following XML:
681 * @code
682 * <NEKTAR>
683 * <CONDITIONS>
684 * <PARAMETERS>
685 * ...
686 * </PARAMETERS>
687 * </CONDITIONS>
688 * </NEKTAR>
689 * @endcode
690 * the PARAMETERS element would be retrieved by requesting the path:
691 * @code
692 * Nektar/Conditions/Parameters
693 * @endcode
694 * @note Paths are case-insensitive.
695 *
696 * @param pPath Path to requested element.
697 *
698 * @return Direct pointer to requested XML Element.
699 */
700TiXmlElement *SessionReader::GetElement(const string &pPath)
701{
702 std::string vPath = boost::to_upper_copy(pPath);
703 std::vector<std::string> st;
704 boost::split(st, vPath, boost::is_any_of("\\/ "));
705 ASSERTL0(st.size() > 0, "No path given in XML element request.");
706
707 TiXmlElement *vReturn = m_xmlDoc->FirstChildElement(st[0].c_str());
708 ASSERTL0(vReturn,
709 std::string("Cannot find element '") + st[0] + std::string("'."));
710 for (int i = 1; i < st.size(); ++i)
711 {
712 vReturn = vReturn->FirstChildElement(st[i].c_str());
713 ASSERTL0(vReturn, std::string("Cannot find element '") + st[i] +
714 std::string("'."));
715 }
716 return vReturn;
717}
718
719/**
720 *
721 */
722bool SessionReader::DefinesElement(const std::string &pPath) const
723{
724 std::string vPath = boost::to_upper_copy(pPath);
725 std::vector<std::string> st;
726 boost::split(st, vPath, boost::is_any_of("\\/ "));
727 ASSERTL0(st.size() > 0, "No path given in XML element request.");
728
729 TiXmlElement *vReturn = m_xmlDoc->FirstChildElement(st[0].c_str());
730 ASSERTL0(vReturn,
731 std::string("Cannot find element '") + st[0] + std::string("'."));
732 for (int i = 1; i < st.size(); ++i)
733 {
734 vReturn = vReturn->FirstChildElement(st[i].c_str());
735 if (!vReturn)
736 {
737 return false;
738 }
739 }
740 return true;
741}
742
743/**
744 *
745 */
746const std::vector<std::string> &SessionReader::GetFilenames() const
747{
748 return m_filenames;
749}
750
751/**
752 *
753 */
754const std::string &SessionReader::GetSessionName() const
755{
756 return m_sessionName;
757}
758
759/**
760 *
761 */
763{
764 return m_comm;
765}
766
768{
769 return m_sharedFilesystem;
770}
771
772/**
773 * This routine finalises any parallel communication.
774 *
775 * @note This routine should be called at the very end of a users
776 * application.
777 */
779{
780 m_comm->Finalise();
781}
782
783/**
784 *
785 */
786bool SessionReader::DefinesParameter(const std::string &pName) const
787{
788 std::string vName = boost::to_upper_copy(pName);
789 return m_parameters.find(vName) != m_parameters.end();
790}
791
792/**
793 * If the parameter is not defined, termination occurs. Therefore, the
794 * parameters existence should be tested for using #DefinesParameter
795 * before calling this function.
796 *
797 * @param pName The name of a floating-point parameter.
798 * @returns The value of the floating-point parameter.
799 */
800const NekDouble &SessionReader::GetParameter(const std::string &pName) const
801{
802 std::string vName = boost::to_upper_copy(pName);
803 auto paramIter = m_parameters.find(vName);
804
805 ASSERTL0(paramIter != m_parameters.end(),
806 "Unable to find requested parameter: " + pName);
807
808 return paramIter->second;
809}
810
811/**
812 * Getter for the session's parameters
813 * @returns A reference to the parameter map
814 */
816{
817 return m_parameters;
818}
819
820/**
821 *
822 */
823void SessionReader::LoadParameter(const std::string &pName, int &pVar) const
824{
825 std::string vName = boost::to_upper_copy(pName);
826 auto paramIter = m_parameters.find(vName);
827 ASSERTL0(paramIter != m_parameters.end(),
828 "Required parameter '" + pName + "' not specified in session.");
829 NekDouble param = round(paramIter->second);
830 pVar = checked_cast<int>(param);
831}
832
833/**
834 *
835 */
836void SessionReader::LoadParameter(const std::string &pName, int &pVar,
837 const int &pDefault) const
838{
839 std::string vName = boost::to_upper_copy(pName);
840 auto paramIter = m_parameters.find(vName);
841 if (paramIter != m_parameters.end())
842 {
843 NekDouble param = round(paramIter->second);
844 pVar = checked_cast<int>(param);
845 }
846 else
847 {
848 pVar = pDefault;
849 }
850}
851
852/**
853 *
854 */
855void SessionReader::LoadParameter(const std::string &pName,
856 unsigned int &pVar) const
857{
858 std::string vName = boost::to_upper_copy(pName);
859 auto paramIter = m_parameters.find(vName);
860 ASSERTL0(paramIter != m_parameters.end(),
861 "Required parameter '" + pName + "' not specified in session.");
862 NekDouble param = round(paramIter->second);
863 pVar = checked_cast<unsigned int>(param);
864}
865
866/**
867 *
868 */
869void SessionReader::LoadParameter(const std::string &pName, unsigned int &pVar,
870 const unsigned int &pDefault) const
871{
872 std::string vName = boost::to_upper_copy(pName);
873 auto paramIter = m_parameters.find(vName);
874 if (paramIter != m_parameters.end())
875 {
876 NekDouble param = round(paramIter->second);
877 pVar = checked_cast<unsigned int>(param);
878 }
879 else
880 {
881 pVar = pDefault;
882 }
883}
884
885/**
886 *
887 */
888void SessionReader::LoadParameter(const std::string &pName, size_t &pVar) const
889{
890 std::string vName = boost::to_upper_copy(pName);
891 auto paramIter = m_parameters.find(vName);
892 ASSERTL0(paramIter != m_parameters.end(),
893 "Required parameter '" + pName + "' not specified in session.");
894 NekDouble param = round(paramIter->second);
895 pVar = checked_cast<int>(param);
896}
897
898/**
899 *
900 */
901void SessionReader::LoadParameter(const std::string &pName, size_t &pVar,
902 const size_t &pDefault) const
903{
904 std::string vName = boost::to_upper_copy(pName);
905 auto paramIter = m_parameters.find(vName);
906 if (paramIter != m_parameters.end())
907 {
908 NekDouble param = round(paramIter->second);
909 pVar = checked_cast<int>(param);
910 }
911 else
912 {
913 pVar = pDefault;
914 }
915}
916
917/**
918 *
919 */
920void SessionReader::LoadParameter(const std::string &pName,
921 NekDouble &pVar) const
922{
923 std::string vName = boost::to_upper_copy(pName);
924 auto paramIter = m_parameters.find(vName);
925 ASSERTL0(paramIter != m_parameters.end(),
926 "Required parameter '" + pName + "' not specified in session.");
927 pVar = paramIter->second;
928}
929
930/**
931 *
932 */
933void SessionReader::LoadParameter(const std::string &pName, NekDouble &pVar,
934 const NekDouble &pDefault) const
935{
936 std::string vName = boost::to_upper_copy(pName);
937 auto paramIter = m_parameters.find(vName);
938 if (paramIter != m_parameters.end())
939 {
940 pVar = paramIter->second;
941 }
942 else
943 {
944 pVar = pDefault;
945 }
946}
947
948/**
949 *
950 */
951void SessionReader::SetParameter(const std::string &pName, int &pVar)
952{
953 std::string vName = boost::to_upper_copy(pName);
954 m_parameters[vName] = pVar;
955}
956
957/**
958 *
959 */
960void SessionReader::SetParameter(const std::string &pName, unsigned int &pVar)
961{
962 std::string vName = boost::to_upper_copy(pName);
963 m_parameters[vName] = pVar;
964}
965
966/**
967 *
968 */
969void SessionReader::SetParameter(const std::string &pName, size_t &pVar)
970{
971 std::string vName = boost::to_upper_copy(pName);
972 m_parameters[vName] = pVar;
973}
974
975/**
976 *
977 */
978void SessionReader::SetParameter(const std::string &pName, NekDouble &pVar)
979{
980 std::string vName = boost::to_upper_copy(pName);
981 m_parameters[vName] = pVar;
982}
983
984/**
985 *
986 */
987bool SessionReader::DefinesSolverInfo(const std::string &pName) const
988{
989 std::string vName = boost::to_upper_copy(pName);
990 auto infoIter = m_solverInfo.find(vName);
991 return (infoIter != m_solverInfo.end());
992}
993
994/**
995 *
996 */
998 const std::string &pProperty) const
999{
1000 std::string vProperty = boost::to_upper_copy(pProperty);
1001 auto iter = m_solverInfo.find(vProperty);
1002
1003 ASSERTL1(iter != m_solverInfo.end(),
1004 "Unable to find requested property: " + pProperty);
1005
1006 return iter->second;
1007}
1008
1009/**
1010 *
1011 */
1012void SessionReader::SetSolverInfo(const std::string &pProperty,
1013 const std::string &pValue)
1014{
1015 std::string vProperty = boost::to_upper_copy(pProperty);
1016 auto iter = m_solverInfo.find(vProperty);
1017
1018 ASSERTL1(iter != m_solverInfo.end(),
1019 "Unable to find requested property: " + pProperty);
1020
1021 iter->second = pValue;
1022}
1023
1024/**
1025 *
1026 */
1027void SessionReader::LoadSolverInfo(const std::string &pName, std::string &pVar,
1028 const std::string &pDefault) const
1029{
1030 std::string vName = boost::to_upper_copy(pName);
1031 auto infoIter = m_solverInfo.find(vName);
1032 if (infoIter != m_solverInfo.end())
1033 {
1034 pVar = infoIter->second;
1035 }
1036 else
1037 {
1038 pVar = pDefault;
1039 }
1040}
1041
1042/**
1043 *
1044 */
1045void SessionReader::MatchSolverInfo(const std::string &pName,
1046 const std::string &pTrueVal, bool &pVar,
1047 const bool &pDefault) const
1048{
1049 std::string vName = boost::to_upper_copy(pName);
1050 auto infoIter = m_solverInfo.find(vName);
1051 if (infoIter != m_solverInfo.end())
1052 {
1053 pVar = boost::iequals(infoIter->second, pTrueVal);
1054 }
1055 else
1056 {
1057 pVar = pDefault;
1058 }
1059}
1060
1061/**
1062 *
1063 */
1064bool SessionReader::MatchSolverInfo(const std::string &pName,
1065 const std::string &pTrueVal) const
1066{
1067 if (DefinesSolverInfo(pName))
1068 {
1069 std::string vName = boost::to_upper_copy(pName);
1070 auto iter = m_solverInfo.find(vName);
1071 if (iter != m_solverInfo.end())
1072 {
1073 return boost::iequals(iter->second, pTrueVal);
1074 }
1075 }
1076 return false;
1077}
1078
1079/**
1080 *
1081 */
1082bool SessionReader::DefinesGlobalSysSolnInfo(const std::string &pVariable,
1083 const std::string &pProperty) const
1084{
1085 auto iter = GetGloSysSolnList().find(pVariable);
1086 if (iter == GetGloSysSolnList().end())
1087 {
1088 return false;
1089 }
1090
1091 std::string vProperty = boost::to_upper_copy(pProperty);
1092
1093 auto iter1 = iter->second.find(vProperty);
1094 if (iter1 == iter->second.end())
1095 {
1096 return false;
1097 }
1098
1099 return true;
1100}
1101
1102/**
1103 *
1104 */
1106 const std::string &pVariable, const std::string &pProperty) const
1107{
1108 auto iter = GetGloSysSolnList().find(pVariable);
1109 ASSERTL0(iter != GetGloSysSolnList().end(),
1110 "Failed to find variable in GlobalSysSolnInfoList");
1111
1112 std::string vProperty = boost::to_upper_copy(pProperty);
1113 auto iter1 = iter->second.find(vProperty);
1114
1115 ASSERTL0(iter1 != iter->second.end(),
1116 "Failed to find property: " + vProperty +
1117 " in GlobalSysSolnInfoList");
1118
1119 return iter1->second;
1120}
1121
1122/**
1123 * @brief Returns true if the TIMEINTEGRATIONSCHEME section is defined
1124 * in the session file.
1125 */
1127{
1128 return m_timeIntScheme.method != "";
1129}
1130
1131/**
1132 * @brief Returns the time integration scheme structure #m_timeIntScheme
1133 * from the session file.
1134 */
1136{
1137 return m_timeIntScheme;
1138}
1139
1140/**
1141 *
1142 */
1144{
1145 TiXmlElement *xmlGeom =
1146 m_xmlDoc->FirstChildElement("NEKTAR")->FirstChildElement("GEOMETRY");
1147 ASSERTL1(xmlGeom, "Failed to find a GEOMETRY section in m_xmlDoc");
1148
1149 TiXmlAttribute *attr = xmlGeom->FirstAttribute();
1150 while (attr)
1151 {
1152 std::string attrName(attr->Name());
1153 if (attrName == "HDF5FILE")
1154 {
1155 // there is a file pointer, therefore is HDF5
1156 return "HDF5";
1157 }
1158 // Get the next attribute.
1159 attr = attr->Next();
1160 }
1161
1162 // Check the VERTEX block. If this is compressed, assume the file is
1163 // compressed, otherwise assume uncompressed.
1164 TiXmlElement *element = xmlGeom->FirstChildElement("VERTEX");
1165 string IsCompressed;
1166 element->QueryStringAttribute("COMPRESSED", &IsCompressed);
1167
1168 if (IsCompressed.size() > 0)
1169 {
1170 return "XmlCompressed";
1171 }
1172
1173 // no file pointer or compressed, just standard xml
1174 return "Xml";
1175}
1176
1177/**
1178 *
1179 */
1180const std::string &SessionReader::GetVariable(const unsigned int &idx) const
1181{
1182 ASSERTL0(idx < m_variables.size(), "Variable index out of range.");
1183 return m_variables[idx];
1184}
1185
1186/**
1187 *
1188 */
1189void SessionReader::SetVariable(const unsigned int &idx, std::string newname)
1190{
1191 ASSERTL0(idx < m_variables.size(), "Variable index out of range.");
1192 m_variables[idx] = newname;
1193}
1194
1195/**
1196 *
1197 */
1198std::vector<std::string> SessionReader::GetVariables() const
1199{
1200 return m_variables;
1201}
1202
1203/**
1204 *
1205 */
1207{
1208 return m_backups;
1209}
1210
1211/**
1212 *
1213 */
1214bool SessionReader::DefinesFunction(const std::string &pName) const
1215{
1216 std::string vName = boost::to_upper_copy(pName);
1217 return m_functions.find(vName) != m_functions.end();
1218}
1219
1220/**
1221 *
1222 */
1223bool SessionReader::DefinesFunction(const std::string &pName,
1224 const std::string &pVariable,
1225 const int pDomain) const
1226{
1227 std::string vName = boost::to_upper_copy(pName);
1228
1229 // Check function exists
1230 auto it1 = m_functions.find(vName);
1231 if (it1 != m_functions.end())
1232 {
1233 pair<std::string, int> key(pVariable, pDomain);
1234 pair<std::string, int> defkey("*", pDomain);
1235 bool varExists = it1->second.find(key) != it1->second.end() ||
1236 it1->second.find(defkey) != it1->second.end();
1237 return varExists;
1238 }
1239 return false;
1240}
1241
1242/**
1243 *
1244 */
1246 const std::string &pVariable,
1247 const int pDomain) const
1248{
1249 std::string vName = boost::to_upper_copy(pName);
1250 auto it1 = m_functions.find(vName);
1251
1252 ASSERTL0(it1 != m_functions.end(),
1253 std::string("No such function '") + pName +
1254 std::string("' has been defined in the session file."));
1255
1256 // Check for specific and wildcard definitions
1257 pair<std::string, int> key(pVariable, pDomain);
1258 pair<std::string, int> defkey("*", pDomain);
1259
1260 auto it2 = it1->second.find(key);
1261 auto it3 = it1->second.find(defkey);
1262 bool specific = it2 != it1->second.end();
1263 bool wildcard = it3 != it1->second.end();
1264
1265 // Check function is defined somewhere
1266 ASSERTL0(specific || wildcard, "No such variable " + pVariable +
1267 " in domain " + std::to_string(pDomain) +
1268 " defined for function " + pName +
1269 " in session file.");
1270
1271 // If not specific, must be wildcard
1272 if (!specific)
1273 {
1274 it2 = it3;
1275 }
1276
1277 ASSERTL0((it2->second.m_type == eFunctionTypeExpression),
1278 std::string("Function is defined by a file."));
1279 return it2->second.m_expression;
1280}
1281
1282/**
1283 *
1284 */
1286 const unsigned int &pVar,
1287 const int pDomain) const
1288{
1289 ASSERTL0(pVar < m_variables.size(), "Variable index out of range.");
1290 return GetFunction(pName, m_variables[pVar], pDomain);
1291}
1292
1293/**
1294 *
1295 */
1296enum FunctionType SessionReader::GetFunctionType(const std::string &pName,
1297 const std::string &pVariable,
1298 const int pDomain) const
1299{
1300 std::string vName = boost::to_upper_copy(pName);
1301 auto it1 = m_functions.find(vName);
1302
1303 ASSERTL0(it1 != m_functions.end(),
1304 std::string("Function '") + pName + std::string("' not found."));
1305
1306 // Check for specific and wildcard definitions
1307 pair<std::string, int> key(pVariable, pDomain);
1308 pair<std::string, int> defkey("*", pDomain);
1309
1310 auto it2 = it1->second.find(key);
1311 auto it3 = it1->second.find(defkey);
1312 bool specific = it2 != it1->second.end();
1313 bool wildcard = it3 != it1->second.end();
1314
1315 // Check function is defined somewhere
1316 ASSERTL0(specific || wildcard, "No such variable " + pVariable +
1317 " in domain " + std::to_string(pDomain) +
1318 " defined for function " + pName +
1319 " in session file.");
1320
1321 // If not specific, must be wildcard
1322 if (!specific)
1323 {
1324 it2 = it3;
1325 }
1326
1327 return it2->second.m_type;
1328}
1329
1330/**
1331 *
1332 */
1333enum FunctionType SessionReader::GetFunctionType(const std::string &pName,
1334 const unsigned int &pVar,
1335 const int pDomain) const
1336{
1337 ASSERTL0(pVar < m_variables.size(), "Variable index out of range.");
1338 return GetFunctionType(pName, m_variables[pVar], pDomain);
1339}
1340
1341/**
1342 *
1343 */
1344std::string SessionReader::GetFunctionFilename(const std::string &pName,
1345 const std::string &pVariable,
1346 const int pDomain) const
1347{
1348 std::string vName = boost::to_upper_copy(pName);
1349 auto it1 = m_functions.find(vName);
1350
1351 ASSERTL0(it1 != m_functions.end(),
1352 std::string("Function '") + pName + std::string("' not found."));
1353
1354 // Check for specific and wildcard definitions
1355 pair<std::string, int> key(pVariable, pDomain);
1356 pair<std::string, int> defkey("*", pDomain);
1357
1358 auto it2 = it1->second.find(key);
1359 auto it3 = it1->second.find(defkey);
1360 bool specific = it2 != it1->second.end();
1361 bool wildcard = it3 != it1->second.end();
1362
1363 // Check function is defined somewhere
1364 ASSERTL0(specific || wildcard, "No such variable " + pVariable +
1365 " in domain " + std::to_string(pDomain) +
1366 " defined for function " + pName +
1367 " in session file.");
1368
1369 // If not specific, must be wildcard
1370 if (!specific)
1371 {
1372 it2 = it3;
1373 }
1374
1375 return it2->second.m_filename;
1376}
1377
1378/**
1379 *
1380 */
1381std::string SessionReader::GetFunctionFilename(const std::string &pName,
1382 const unsigned int &pVar,
1383 const int pDomain) const
1384{
1385 ASSERTL0(pVar < m_variables.size(), "Variable index out of range.");
1386 return GetFunctionFilename(pName, m_variables[pVar], pDomain);
1387}
1388
1389/**
1390 *
1391 */
1393 const std::string &pName, const std::string &pVariable,
1394 const int pDomain) const
1395{
1396 std::string vName = boost::to_upper_copy(pName);
1397 auto it1 = m_functions.find(vName);
1398
1399 ASSERTL0(it1 != m_functions.end(),
1400 std::string("Function '") + pName + std::string("' not found."));
1401
1402 // Check for specific and wildcard definitions
1403 pair<std::string, int> key(pVariable, pDomain);
1404 pair<std::string, int> defkey("*", pDomain);
1405
1406 auto it2 = it1->second.find(key);
1407 auto it3 = it1->second.find(defkey);
1408 bool specific = it2 != it1->second.end();
1409 bool wildcard = it3 != it1->second.end();
1410
1411 // Check function is defined somewhere
1412 ASSERTL0(specific || wildcard, "No such variable " + pVariable +
1413 " in domain " + std::to_string(pDomain) +
1414 " defined for function " + pName +
1415 " in session file.");
1416
1417 // If not specific, must be wildcard
1418 if (!specific)
1419 {
1420 it2 = it3;
1421 }
1422
1423 return it2->second.m_fileVariable;
1424}
1425
1426/**
1427 *
1428 */
1429bool SessionReader::DefinesTag(const std::string &pName) const
1430{
1431 std::string vName = boost::to_upper_copy(pName);
1432 return m_tags.find(vName) != m_tags.end();
1433}
1434
1435/**
1436 *
1437 */
1438void SessionReader::SetTag(const std::string &pName, const std::string &pValue)
1439{
1440 std::string vName = boost::to_upper_copy(pName);
1441 m_tags[vName] = pValue;
1442}
1443
1444/**
1445 *
1446 */
1447const std::string &SessionReader::GetTag(const std::string &pName) const
1448{
1449 std::string vName = boost::to_upper_copy(pName);
1450 auto vTagIterator = m_tags.find(vName);
1451 ASSERTL0(vTagIterator != m_tags.end(), "Requested tag does not exist.");
1452 return vTagIterator->second;
1453}
1454
1455/**
1456 *
1457 */
1459{
1460 return m_filters;
1461}
1462
1463/**
1464 *
1465 */
1466bool SessionReader::DefinesCmdLineArgument(const std::string &pName) const
1467{
1468 return (m_cmdLineOptions.find(pName) != m_cmdLineOptions.end());
1469}
1470
1471/**
1472 *
1473 */
1474void SessionReader::GetXMLElementTimeLevel(TiXmlElement *&Element,
1475 const size_t timeLevel,
1476 const bool enableCheck)
1477{
1478 if (Element && Element->FirstChildElement("TIMELEVEL"))
1479 {
1480 Element = Element->FirstChildElement("TIMELEVEL");
1481 std::string timeLevelStr;
1482 while (Element)
1483 {
1484 std::stringstream tagcontent;
1485 tagcontent << *Element;
1486 ASSERTL0(Element->Attribute("VALUE"),
1487 "Missing LEVEL attribute in solver info "
1488 "XML element: \n\t'" +
1489 tagcontent.str() + "'");
1490 timeLevelStr = Element->Attribute("VALUE");
1491 ASSERTL0(!timeLevelStr.empty(),
1492 "LEVEL attribute must be non-empty in XML "
1493 "element: \n\t'" +
1494 tagcontent.str() + "'");
1495 if (stoi(timeLevelStr) == timeLevel)
1496 {
1497 break;
1498 }
1499 Element = Element->NextSiblingElement("TIMELEVEL");
1500 }
1501 if (enableCheck)
1502 {
1503 ASSERTL0(stoi(timeLevelStr) == timeLevel,
1504 "TIMELEVEL value " + std::to_string(timeLevel) +
1505 " not found in solver info "
1506 "XML element: \n\t'");
1507 }
1508 }
1509}
1510
1511/**
1512 *
1513 */
1514void SessionReader::LoadDoc(const std::string &pFilename,
1515 TiXmlDocument *pDoc) const
1516{
1517 if (pFilename.size() > 3 &&
1518 pFilename.substr(pFilename.size() - 3, 3) == ".gz")
1519 {
1520 ifstream file(pFilename.c_str(), ios_base::in | ios_base::binary);
1521 ASSERTL0(file.good(), "Unable to open file: " + pFilename);
1522 stringstream ss;
1523 io::filtering_streambuf<io::input> in;
1524 in.push(io::gzip_decompressor());
1525 in.push(file);
1526 try
1527 {
1528 io::copy(in, ss);
1529 ss >> (*pDoc);
1530 }
1531 catch (io::gzip_error &)
1532 {
1534 "Error: File '" + pFilename + "' is corrupt.");
1535 }
1536 }
1537 else if (pFilename.size() > 4 &&
1538 pFilename.substr(pFilename.size() - 4, 4) == "_xml")
1539 {
1540 fs::path pdirname(pFilename);
1541 boost::format pad("P%1$07d.xml");
1542 pad % m_comm->GetSpaceComm()->GetRank();
1543 fs::path pRankFilename(pad.str());
1544 fs::path fullpath = pdirname / pRankFilename;
1545
1546 ifstream file(PortablePath(fullpath).c_str());
1547 ASSERTL0(file.good(), "Unable to open file: " + fullpath.string());
1548 file >> (*pDoc);
1549 }
1550 else
1551 {
1552 ifstream file(pFilename.c_str());
1553 ASSERTL0(file.good(), "Unable to open file: " + pFilename);
1554 file >> (*pDoc);
1555 }
1556}
1557
1558/**
1559 *
1560 */
1562 const std::vector<std::string> &pFilenames) const
1563{
1564 ASSERTL0(pFilenames.size() > 0, "No filenames for merging.");
1565
1566 // Read the first document
1567 TiXmlDocument *vMainDoc = new TiXmlDocument;
1568 LoadDoc(pFilenames[0], vMainDoc);
1569
1570 TiXmlHandle vMainHandle(vMainDoc);
1571 TiXmlElement *vMainNektar =
1572 GetChildElementOrThrow(pFilenames[0], "NEKTAR", vMainHandle);
1573
1574 // Read all subsequent XML documents.
1575 // For each element within the NEKTAR tag, use it to replace the
1576 // version already present in the loaded XML data.
1577 for (int i = 1; i < pFilenames.size(); ++i)
1578 {
1579 if ((pFilenames[i].compare(pFilenames[i].size() - 3, 3, "xml") == 0) ||
1580 (pFilenames[i].compare(pFilenames[i].size() - 6, 6, "xml.gz") ==
1581 0) ||
1582 (pFilenames[i].compare(pFilenames[i].size() - 3, 3, "opt") == 0))
1583 {
1584 TiXmlDocument *vTempDoc = new TiXmlDocument;
1585 LoadDoc(pFilenames[i], vTempDoc);
1586
1587 TiXmlHandle docHandle(vTempDoc);
1588 TiXmlElement *vTempNektar =
1589 GetChildElementOrThrow(pFilenames[i], "NEKTAR", docHandle);
1590 TiXmlElement *p = vTempNektar->FirstChildElement();
1591
1592 while (p)
1593 {
1594 TiXmlElement *vMainEntry =
1595 vMainNektar->FirstChildElement(p->Value());
1596
1597 // First check if the new item is in fact blank
1598 // replace if it is a COLLECTIONS section however.
1599 if (!p->FirstChild() && vMainEntry &&
1600 !boost::iequals(p->Value(), "COLLECTIONS"))
1601 {
1602 std::string warningmsg =
1603 "File " + pFilenames[i] + " contains " +
1604 "an empty XML element " + std::string(p->Value()) +
1605 " which will be ignored.";
1606 NEKERROR(ErrorUtil::ewarning, warningmsg.c_str());
1607 }
1608 else
1609 {
1610 if (vMainEntry)
1611 {
1612 vMainNektar->RemoveChild(vMainEntry);
1613 }
1614 TiXmlElement *q = new TiXmlElement(*p);
1615 vMainNektar->LinkEndChild(q);
1616 }
1617 p = p->NextSiblingElement();
1618 }
1619 delete vTempDoc;
1620 }
1621 }
1622 return vMainDoc;
1623}
1624
1625/**
1626 *
1627 */
1629{
1630 // Check we actually have a document loaded.
1631 ASSERTL0(m_xmlDoc, "No XML document loaded.");
1632
1633 TiXmlHandle docHandle(m_xmlDoc);
1634 TiXmlElement *e;
1635
1636 // Look for all data in CONDITIONS block.
1637 e = docHandle.FirstChildElement("NEKTAR")
1638 .FirstChildElement("CONDITIONS")
1639 .Element();
1640
1641 // Read the various sections of the CONDITIONS block
1642 ReadParameters(e);
1643 ReadSolverInfo(e);
1646 ReadVariables(e);
1647 ReadFunctions(e);
1648
1649 // Look for all data in FILTERS block.
1650 e = docHandle.FirstChildElement("NEKTAR")
1651 .FirstChildElement("FILTERS")
1652 .Element();
1653
1654 // Read the various sections of the FILTERS block
1655 ReadFilters(e);
1656}
1657
1658/**
1659 *
1660 */
1661void SessionReader::CreateComm(int &argc, char *argv[])
1662{
1663 if (argc == 0)
1664 {
1665 m_comm = GetCommFactory().CreateInstance("Serial", 0, 0);
1666 }
1667 else
1668 {
1669 string vCommModule("Serial");
1670 if (GetCommFactory().ModuleExists("ParallelMPI"))
1671 {
1672 vCommModule = "ParallelMPI";
1673 }
1674 if (m_cmdLineOptions.count("cwipi") &&
1675 GetCommFactory().ModuleExists("CWIPI"))
1676 {
1677 vCommModule = "CWIPI";
1678 }
1679
1680 m_comm = GetCommFactory().CreateInstance(vCommModule, argc, argv);
1681 }
1682}
1683
1684/**
1685 * Splits the processes into a cartesian grid and creates communicators
1686 * for each row and column of the grid.
1687 */
1689{
1690 if (m_comm->GetSize() > 1)
1691 {
1692 int nProcZ = 1;
1693 int nProcY = 1;
1694 int nProcX = 1;
1695 int nStripZ = 1;
1696 int nTime = 1;
1697 if (DefinesCmdLineArgument("npx"))
1698 {
1699 nProcX = GetCmdLineArgument<int>("npx");
1700 }
1701 if (DefinesCmdLineArgument("npy"))
1702 {
1703 nProcY = GetCmdLineArgument<int>("npy");
1704 }
1705 if (DefinesCmdLineArgument("npz"))
1706 {
1707 nProcZ = GetCmdLineArgument<int>("npz");
1708 }
1709 if (DefinesCmdLineArgument("nsz"))
1710 {
1711 nStripZ = GetCmdLineArgument<int>("nsz");
1712 }
1713 if (DefinesCmdLineArgument("npt"))
1714 {
1715 nTime = GetCmdLineArgument<int>("npt");
1716 }
1717 ASSERTL0(m_comm->GetSize() % nTime == 0,
1718 "Cannot exactly partition time using npt value.");
1719 ASSERTL0((m_comm->GetSize() / nTime) % (nProcZ * nProcY * nProcX) == 0,
1720 "Cannot exactly partition using PROC_Z value.");
1721 ASSERTL0(nProcZ % nProcY == 0,
1722 "Cannot exactly partition using PROC_Y value.");
1723 ASSERTL0(nProcY % nProcX == 0,
1724 "Cannot exactly partition using PROC_X value.");
1725
1726 // Number of processes associated with the spectral method
1727 int nProcSm = nProcZ * nProcY * nProcX;
1728
1729 // Number of processes associated with the spectral element
1730 // method.
1731 int nProcSem = m_comm->GetSize() / nTime / nProcSm;
1732
1733 m_comm->SplitComm(nProcSm, nProcSem, nTime);
1734 m_comm->GetColumnComm()->SplitComm(nProcZ / nStripZ, nStripZ);
1735 m_comm->GetColumnComm()->GetColumnComm()->SplitComm((nProcY * nProcX),
1736 nProcZ / nStripZ);
1737 m_comm->GetColumnComm()->GetColumnComm()->GetColumnComm()->SplitComm(
1738 nProcX, nProcY);
1739 }
1740}
1741
1742/**
1743 *
1744 */
1745void SessionReader::ReadParameters(TiXmlElement *conditions)
1746{
1747 m_parameters.clear();
1748
1749 if (!conditions)
1750 {
1751 return;
1752 }
1753
1754 TiXmlElement *parametersElement =
1755 conditions->FirstChildElement("PARAMETERS");
1756 GetXMLElementTimeLevel(parametersElement, m_timeLevel);
1757
1758 // See if we have parameters defined. They are optional so we go on
1759 // if not.
1760 if (parametersElement)
1761 {
1762 TiXmlElement *parameter = parametersElement->FirstChildElement("P");
1763
1764 ParameterMap caseSensitiveParameters;
1765
1766 // Multiple nodes will only occur if there is a comment in
1767 // between definitions.
1768 while (parameter)
1769 {
1770 stringstream tagcontent;
1771 tagcontent << *parameter;
1772 TiXmlNode *node = parameter->FirstChild();
1773
1774 while (node && node->Type() != TiXmlNode::TINYXML_TEXT)
1775 {
1776 node = node->NextSibling();
1777 }
1778
1779 if (node)
1780 {
1781 // Format is "paramName = value"
1782 std::string line = node->ToText()->Value(), lhs, rhs;
1783
1784 try
1785 {
1786 ParseEquals(line, lhs, rhs);
1787 }
1788 catch (...)
1789 {
1791 "Syntax error in parameter expression '" + line +
1792 "' in XML element: \n\t'" + tagcontent.str() +
1793 "'");
1794 }
1795
1796 // We want the list of parameters to have their RHS
1797 // evaluated, so we use the expression evaluator to do
1798 // the dirty work.
1799 if (!lhs.empty() && !rhs.empty())
1800 {
1801 NekDouble value = 0.0;
1802 try
1803 {
1804 LibUtilities::Equation expession(m_interpreter, rhs);
1805 value = expession.Evaluate();
1806 }
1807 catch (const std::runtime_error &)
1808 {
1810 "Error evaluating parameter expression"
1811 " '" +
1812 rhs + "' in XML element: \n\t'" +
1813 tagcontent.str() + "'");
1814 }
1815 m_interpreter->SetParameter(lhs, value);
1816 caseSensitiveParameters[lhs] = value;
1817 boost::to_upper(lhs);
1818 m_parameters[lhs] = value;
1819 }
1820 }
1821 parameter = parameter->NextSiblingElement();
1822 }
1823 }
1824}
1825
1826/**
1827 *
1828 */
1829void SessionReader::ReadSolverInfo(TiXmlElement *conditions)
1830{
1831 m_solverInfo.clear();
1833
1834 if (!conditions)
1835 {
1836 return;
1837 }
1838
1839 TiXmlElement *solverInfoElement =
1840 conditions->FirstChildElement("SOLVERINFO");
1841 GetXMLElementTimeLevel(solverInfoElement, m_timeLevel);
1842
1843 if (solverInfoElement)
1844 {
1845 TiXmlElement *solverInfo = solverInfoElement->FirstChildElement("I");
1846
1847 while (solverInfo)
1848 {
1849 std::stringstream tagcontent;
1850 tagcontent << *solverInfo;
1851 // read the property name
1852 ASSERTL0(solverInfo->Attribute("PROPERTY"),
1853 "Missing PROPERTY attribute in solver info "
1854 "XML element: \n\t'" +
1855 tagcontent.str() + "'");
1856 std::string solverProperty = solverInfo->Attribute("PROPERTY");
1857 ASSERTL0(!solverProperty.empty(),
1858 "PROPERTY attribute must be non-empty in XML "
1859 "element: \n\t'" +
1860 tagcontent.str() + "'");
1861
1862 // make sure that solver property is capitalised
1863 std::string solverPropertyUpper =
1864 boost::to_upper_copy(solverProperty);
1865
1866 // read the value
1867 ASSERTL0(solverInfo->Attribute("VALUE"),
1868 "Missing VALUE attribute in solver info "
1869 "XML element: \n\t'" +
1870 tagcontent.str() + "'");
1871 std::string solverValue = solverInfo->Attribute("VALUE");
1872 ASSERTL0(!solverValue.empty(),
1873 "VALUE attribute must be non-empty in XML "
1874 "element: \n\t'" +
1875 tagcontent.str() + "'");
1876
1877 // Set Variable
1878 m_solverInfo[solverPropertyUpper] = solverValue;
1879 solverInfo = solverInfo->NextSiblingElement("I");
1880 }
1881 }
1882
1883 if (m_comm && m_comm->GetRowComm()->GetSize() > 1)
1884 {
1885 ASSERTL0(
1886 m_solverInfo["GLOBALSYSSOLN"] == "IterativeFull" ||
1887 m_solverInfo["GLOBALSYSSOLN"] == "IterativeStaticCond" ||
1888 m_solverInfo["GLOBALSYSSOLN"] ==
1889 "IterativeMultiLevelStaticCond" ||
1890 m_solverInfo["GLOBALSYSSOLN"] == "XxtFull" ||
1891 m_solverInfo["GLOBALSYSSOLN"] == "XxtStaticCond" ||
1892 m_solverInfo["GLOBALSYSSOLN"] == "XxtMultiLevelStaticCond" ||
1893 m_solverInfo["GLOBALSYSSOLN"] == "PETScFull" ||
1894 m_solverInfo["GLOBALSYSSOLN"] == "PETScStaticCond" ||
1895 m_solverInfo["GLOBALSYSSOLN"] == "PETScMultiLevelStaticCond",
1896 "A parallel solver must be used when run in parallel.");
1897 }
1898}
1899
1900/**
1901 *
1902 */
1903void SessionReader::ReadGlobalSysSolnInfo(TiXmlElement *conditions)
1904{
1905 GetGloSysSolnList().clear();
1906
1907 if (!conditions)
1908 {
1909 return;
1910 }
1911
1912 TiXmlElement *GlobalSys =
1913 conditions->FirstChildElement("GLOBALSYSSOLNINFO");
1915
1916 if (!GlobalSys)
1917 {
1918 return;
1919 }
1920
1921 TiXmlElement *VarInfo = GlobalSys->FirstChildElement("V");
1922
1923 while (VarInfo)
1924 {
1925 std::stringstream tagcontent;
1926 tagcontent << *VarInfo;
1927
1928 ASSERTL0(VarInfo->Attribute("VAR"),
1929 "Missing VAR attribute in GobalSysSolnInfo XML "
1930 "element: \n\t'" +
1931 tagcontent.str() + "'");
1932 std::string VarList = VarInfo->Attribute("VAR");
1933 ASSERTL0(!VarList.empty(),
1934 "VAR attribute must be non-empty in XML element:\n\t'" +
1935 tagcontent.str() + "'");
1936
1937 // generate a list of variables.
1938 std::vector<std::string> varStrings;
1939 bool valid = ParseUtils::GenerateVector(VarList, varStrings);
1940
1941 ASSERTL0(valid, "Unable to process list of variable in XML "
1942 "element \n\t'" +
1943 tagcontent.str() + "'");
1944
1945 if (varStrings.size())
1946 {
1947 TiXmlElement *SysSolnInfo = VarInfo->FirstChildElement("I");
1948
1949 while (SysSolnInfo)
1950 {
1951 tagcontent.clear();
1952 tagcontent << *SysSolnInfo;
1953 // read the property name
1954 ASSERTL0(SysSolnInfo->Attribute("PROPERTY"),
1955 "Missing PROPERTY attribute in "
1956 "GlobalSysSolnInfo for variable(s) '" +
1957 VarList + "' in XML element: \n\t'" +
1958 tagcontent.str() + "'");
1959 std::string SysSolnProperty =
1960 SysSolnInfo->Attribute("PROPERTY");
1961 ASSERTL0(!SysSolnProperty.empty(),
1962 "GlobalSysSolnIno properties must have a "
1963 "non-empty name for variable(s) : '" +
1964 VarList + "' in XML element: \n\t'" +
1965 tagcontent.str() + "'");
1966
1967 // make sure that solver property is capitalised
1968 std::string SysSolnPropertyUpper =
1969 boost::to_upper_copy(SysSolnProperty);
1970
1971 // read the value
1972 ASSERTL0(SysSolnInfo->Attribute("VALUE"),
1973 "Missing VALUE attribute in GlobalSysSolnInfo "
1974 "for variable(s) '" +
1975 VarList + "' in XML element: \n\t" +
1976 tagcontent.str() + "'");
1977 std::string SysSolnValue = SysSolnInfo->Attribute("VALUE");
1978 ASSERTL0(!SysSolnValue.empty(),
1979 "GlobalSysSolnInfo properties must have a "
1980 "non-empty value for variable(s) '" +
1981 VarList + "' in XML element: \n\t'" +
1982 tagcontent.str() + "'");
1983
1984 // Store values under variable map.
1985 for (int i = 0; i < varStrings.size(); ++i)
1986 {
1987 auto x = GetGloSysSolnList().find(varStrings[i]);
1988 if (x == GetGloSysSolnList().end())
1989 {
1990 (GetGloSysSolnList()[varStrings[i]])
1991 [SysSolnPropertyUpper] = SysSolnValue;
1992 }
1993 else
1994 {
1995 x->second[SysSolnPropertyUpper] = SysSolnValue;
1996 }
1997 }
1998 SysSolnInfo = SysSolnInfo->NextSiblingElement("I");
1999 }
2000 VarInfo = VarInfo->NextSiblingElement("V");
2001 }
2002 }
2003
2004 if (m_verbose && GetGloSysSolnList().size() > 0 && m_comm)
2005 {
2006 if (m_comm->GetRank() == 0)
2007 {
2008 cout << "GlobalSysSoln Info:" << endl;
2009
2010 for (auto &x : GetGloSysSolnList())
2011 {
2012 cout << "\t Variable: " << x.first << endl;
2013
2014 for (auto &y : x.second)
2015 {
2016 cout << "\t\t " << y.first << " = " << y.second << endl;
2017 }
2018 }
2019 cout << endl;
2020 }
2021 }
2022}
2023
2024/**
2025 * @brief Read the time-integration scheme structure, if present.
2026 */
2027void SessionReader::ReadTimeIntScheme(TiXmlElement *conditions)
2028{
2029 if (!conditions)
2030 {
2031 return;
2032 }
2033
2034 TiXmlElement *timeInt =
2035 conditions->FirstChildElement("TIMEINTEGRATIONSCHEME");
2037
2038 if (!timeInt)
2039 {
2040 return;
2041 }
2042
2043 TiXmlElement *method = timeInt->FirstChildElement("METHOD");
2044 TiXmlElement *variant = timeInt->FirstChildElement("VARIANT");
2045 TiXmlElement *order = timeInt->FirstChildElement("ORDER");
2046 TiXmlElement *params = timeInt->FirstChildElement("FREEPARAMETERS");
2047
2048 // Only the method and order are required.
2049 ASSERTL0(method, "Missing METHOD tag inside "
2050 "TIMEINTEGRATIONSCHEME.");
2051 ASSERTL0(order, "Missing ORDER tag inside "
2052 "TIMEINTEGRATIONSCHEME.");
2053
2054 m_timeIntScheme.method = method->GetText();
2055
2056 std::string orderStr = order->GetText();
2057
2058 // Only the method and order are required.
2059 ASSERTL0(m_timeIntScheme.method.size() > 0,
2060 "Empty text inside METHOD tag in TIMEINTEGRATIONSCHEME.");
2061 ASSERTL0(orderStr.size() > 0,
2062 "Empty text inside ORDER tag in TIMEINTEGRATIONSCHEME.");
2063 try
2064 {
2065 m_timeIntScheme.order = std::stol(orderStr);
2066 }
2067 catch (...)
2068 {
2069 NEKERROR(ErrorUtil::efatal, "In ORDER tag, unable to convert "
2070 "string '" +
2071 orderStr + "' to an unsigned integer.");
2072 }
2073
2074 if (variant)
2075 {
2076 m_timeIntScheme.variant = variant->GetText();
2077 }
2078
2079 if (params)
2080 {
2081 std::string paramsStr = params->GetText();
2082 ASSERTL0(paramsStr.size() > 0,
2083 "Empty text inside FREEPARAMETERS tag in "
2084 "TIMEINTEGRATIONSCHEME.");
2085
2086 std::vector<std::string> pSplit;
2087 boost::split(pSplit, paramsStr, boost::is_any_of(" "));
2088
2089 m_timeIntScheme.freeParams.resize(pSplit.size());
2090 for (size_t i = 0; i < pSplit.size(); ++i)
2091 {
2092 try
2093 {
2094 m_timeIntScheme.freeParams[i] = std::stod(pSplit[i]);
2095 }
2096 catch (...)
2097 {
2098 NEKERROR(ErrorUtil::efatal, "In FREEPARAMETERS tag, "
2099 "unable to convert string '" +
2100 pSplit[i] +
2101 "' "
2102 "to a floating-point value.");
2103 }
2104 }
2105 }
2106
2107 if (m_verbose && m_comm)
2108 {
2109 if (m_comm->GetRank() == 0)
2110 {
2111 cout << "Trying to use time integration scheme:" << endl;
2112 cout << "\t Method : " << m_timeIntScheme.method << endl;
2113 cout << "\t Variant: " << m_timeIntScheme.variant << endl;
2114 cout << "\t Order : " << m_timeIntScheme.order << endl;
2115
2116 if (m_timeIntScheme.freeParams.size() > 0)
2117 {
2118 cout << "\t Params :";
2119 for (auto &x : m_timeIntScheme.freeParams)
2120 {
2121 cout << " " << x;
2122 }
2123 cout << endl;
2124 }
2125 }
2126 }
2127}
2128
2129/**
2130 *
2131 */
2132void SessionReader::ReadVariables(TiXmlElement *conditions)
2133{
2134 m_variables.clear();
2135
2136 if (!conditions)
2137 {
2138 return;
2139 }
2140
2141 TiXmlElement *variablesElement = conditions->FirstChildElement("VARIABLES");
2142 GetXMLElementTimeLevel(variablesElement, m_timeLevel);
2143
2144 // See if we have parameters defined. They are optional so we go on
2145 // if not.
2146 if (variablesElement)
2147 {
2148 TiXmlElement *varElement = variablesElement->FirstChildElement("V");
2149
2150 // Sequential counter for the composite numbers.
2151 int nextVariableNumber = -1;
2152
2153 while (varElement)
2154 {
2155 stringstream tagcontent;
2156 tagcontent << *varElement;
2157
2158 /// All elements are of the form: "<V ID="#"> name = value
2159 /// </V>", with ? being the element type.
2160 nextVariableNumber++;
2161
2162 int i;
2163 int err = varElement->QueryIntAttribute("ID", &i);
2164 ASSERTL0(err == TIXML_SUCCESS,
2165 "Variables must have a unique ID number attribute "
2166 "in XML element: \n\t'" +
2167 tagcontent.str() + "'");
2168 ASSERTL0(i == nextVariableNumber,
2169 "ID numbers for variables must begin with zero and"
2170 " be sequential in XML element: \n\t'" +
2171 tagcontent.str() + "'");
2172
2173 TiXmlNode *varChild = varElement->FirstChild();
2174 // This is primarily to skip comments that may be present.
2175 // Comments appear as nodes just like elements. We are
2176 // specifically looking for text in the body of the
2177 // definition.
2178 while (varChild && varChild->Type() != TiXmlNode::TINYXML_TEXT)
2179 {
2180 varChild = varChild->NextSibling();
2181 }
2182
2183 ASSERTL0(varChild, "Unable to read variable definition body for "
2184 "variable with ID " +
2185 std::to_string(i) +
2186 " in XML element: \n\t'" + tagcontent.str() +
2187 "'");
2188 std::string variableName = varChild->ToText()->ValueStr();
2189
2190 std::istringstream variableStrm(variableName);
2191 variableStrm >> variableName;
2192
2194 variableName) == m_variables.end(),
2195 "Variable with ID " + std::to_string(i) +
2196 " in XML element \n\t'" + tagcontent.str() +
2197 "'\nhas already been defined.");
2198
2199 m_variables.push_back(variableName);
2200
2201 varElement = varElement->NextSiblingElement("V");
2202 }
2203
2204 ASSERTL0(nextVariableNumber > -1,
2205 "Number of variables must be greater than zero.");
2206 }
2207}
2208
2209/**
2210 *
2211 */
2212void SessionReader::ReadFunctions(TiXmlElement *conditions)
2213{
2214 m_functions.clear();
2215
2216 if (!conditions)
2217 {
2218 return;
2219 }
2220
2221 // Scan through conditions section looking for functions.
2222 TiXmlElement *function = conditions->FirstChildElement("FUNCTION");
2223
2224 while (function)
2225 {
2226 stringstream tagcontent;
2227 tagcontent << *function;
2228
2229 // Every function must have a NAME attribute
2230 ASSERTL0(function->Attribute("NAME"),
2231 "Functions must have a NAME attribute defined in XML "
2232 "element: \n\t'" +
2233 tagcontent.str() + "'");
2234 std::string functionStr = function->Attribute("NAME");
2235 ASSERTL0(!functionStr.empty(),
2236 "Functions must have a non-empty name in XML "
2237 "element: \n\t'" +
2238 tagcontent.str() + "'");
2239
2240 // Store function names in uppercase to remain case-insensitive.
2241 boost::to_upper(functionStr);
2242
2243 // Retrieve first entry (variable, or file)
2244 TiXmlElement *element = function;
2245 GetXMLElementTimeLevel(element, m_timeLevel, false);
2246 TiXmlElement *variable = element->FirstChildElement();
2247
2248 // Create new function structure with default type of none.
2249 FunctionVariableMap functionVarMap;
2250
2251 // Process all entries in the function block
2252 while (variable)
2253 {
2255 std::string conditionType = variable->Value();
2256
2257 // If no var is specified, assume wildcard
2258 std::string variableStr;
2259 if (!variable->Attribute("VAR"))
2260 {
2261 variableStr = "*";
2262 }
2263 else
2264 {
2265 variableStr = variable->Attribute("VAR");
2266 }
2267
2268 // Parse list of variables
2269 std::vector<std::string> variableList;
2270 ParseUtils::GenerateVector(variableStr, variableList);
2271
2272 // If no domain is specified, put to 0
2273 std::string domainStr;
2274 if (!variable->Attribute("DOMAIN"))
2275 {
2276 domainStr = "0";
2277 }
2278 else
2279 {
2280 domainStr = variable->Attribute("DOMAIN");
2281 }
2282
2283 // Parse list of domains
2284 std::vector<std::string> varSplit;
2285 std::vector<unsigned int> domainList;
2286 ParseUtils::GenerateSeqVector(domainStr, domainList);
2287
2288 // if no evars is specified, put "x y z t"
2289 std::string evarsStr = "x y z t";
2290 if (variable->Attribute("EVARS"))
2291 {
2292 evarsStr =
2293 evarsStr + std::string(" ") + variable->Attribute("EVARS");
2294 }
2295
2296 // Expressions are denoted by E
2297 if (conditionType == "E")
2298 {
2300
2301 // Expression must have a VALUE.
2302 ASSERTL0(variable->Attribute("VALUE"),
2303 "Attribute VALUE expected for function '" +
2304 functionStr + "'.");
2305 std::string fcnStr = variable->Attribute("VALUE");
2306 ASSERTL0(!fcnStr.empty(),
2307 (std::string("Expression for var: ") + variableStr +
2308 std::string(" must be specified."))
2309 .c_str());
2310
2311 // set expression
2312 funcDef.m_expression =
2314 m_interpreter, fcnStr, evarsStr);
2315 }
2316
2317 // Files are denoted by F
2318 else if (conditionType == "F")
2319 {
2320 // Check if transient or not
2321 if (variable->Attribute("TIMEDEPENDENT") &&
2322 boost::lexical_cast<bool>(
2323 variable->Attribute("TIMEDEPENDENT")))
2324 {
2326 }
2327 else
2328 {
2329 funcDef.m_type = eFunctionTypeFile;
2330 }
2331
2332 // File must have a FILE.
2333 ASSERTL0(variable->Attribute("FILE"),
2334 "Attribute FILE expected for function '" +
2335 functionStr + "'.");
2336 std::string filenameStr = variable->Attribute("FILE");
2337 ASSERTL0(!filenameStr.empty(),
2338 "A filename must be specified for the FILE "
2339 "attribute of function '" +
2340 functionStr + "'.");
2341
2342 std::vector<std::string> fSplit;
2343 boost::split(fSplit, filenameStr, boost::is_any_of(":"));
2344 ASSERTL0(fSplit.size() == 1 || fSplit.size() == 2,
2345 "Incorrect filename specification in function " +
2346 functionStr +
2347 "'. "
2348 "Specify variables inside file as: "
2349 "filename:var1,var2");
2350
2351 // set the filename
2352 fs::path fullpath = fSplit[0];
2353 fs::path ftype = fullpath.extension();
2354 if (fullpath.parent_path().extension() == ".pit")
2355 {
2356 string filename = fullpath.stem().string();
2357 fullpath = fullpath.parent_path();
2358 size_t start = filename.find_last_of("_") + 1;
2359 int index =
2360 atoi(filename.substr(start, filename.size()).c_str());
2361 fullpath /= filename.substr(0, start) +
2362 std::to_string(
2363 index + m_comm->GetTimeComm()->GetRank()) +
2364 ftype.string();
2365 }
2366 funcDef.m_filename = fullpath.string();
2367
2368 if (fSplit.size() == 2)
2369 {
2370 ASSERTL0(variableList[0] != "*",
2371 "Filename variable mapping not valid "
2372 "when using * as a variable inside "
2373 "function '" +
2374 functionStr + "'.");
2375
2376 boost::split(varSplit, fSplit[1], boost::is_any_of(","));
2377 ASSERTL0(varSplit.size() == variableList.size(),
2378 "Filename variables should contain the "
2379 "same number of variables defined in "
2380 "VAR in function " +
2381 functionStr + "'.");
2382 }
2383 }
2384
2385 // Nothing else supported so throw an error
2386 else
2387 {
2388 stringstream tagcontent;
2389 tagcontent << *variable;
2390
2392 "Identifier " + conditionType + " in function " +
2393 std::string(function->Attribute("NAME")) +
2394 " is not recognised in XML element: \n\t'" +
2395 tagcontent.str() + "'");
2396 }
2397
2398 // Add variables to function
2399 for (unsigned int i = 0; i < variableList.size(); ++i)
2400 {
2401 for (unsigned int j = 0; j < domainList.size(); ++j)
2402 {
2403 // Check it has not already been defined
2404 pair<std::string, int> key(variableList[i], domainList[j]);
2405 auto fcnsIter = functionVarMap.find(key);
2406 ASSERTL0(fcnsIter == functionVarMap.end(),
2407 "Error setting expression '" + variableList[i] +
2408 " in domain " + std::to_string(domainList[j]) +
2409 "' in function '" + functionStr +
2410 "'. "
2411 "Expression has already been defined.");
2412
2413 if (varSplit.size() > 0)
2414 {
2415 FunctionVariableDefinition funcDef2 = funcDef;
2416 funcDef2.m_fileVariable = varSplit[i];
2417 functionVarMap[key] = funcDef2;
2418 }
2419 else
2420 {
2421 functionVarMap[key] = funcDef;
2422 }
2423 }
2424 }
2425 variable = variable->NextSiblingElement();
2426 }
2427
2428 // Add function definition to map
2429 m_functions[functionStr] = functionVarMap;
2430 function = function->NextSiblingElement("FUNCTION");
2431 }
2432}
2433
2434/**
2435 *
2436 */
2437void SessionReader::ReadFilters(TiXmlElement *filters)
2438{
2439 if (!filters)
2440 {
2441 return;
2442 }
2443
2444 m_filters.clear();
2445
2446 TiXmlElement *filter = filters->FirstChildElement("FILTER");
2447
2448 while (filter)
2449 {
2450 ASSERTL0(filter->Attribute("TYPE"),
2451 "Missing attribute 'TYPE' for filter.");
2452 std::string typeStr = filter->Attribute("TYPE");
2453
2454 int domainID = -1;
2455 if (filter->Attribute("DOMAIN"))
2456 {
2457 // domainID = int(filter->Attribute("DOMAIN"));
2458 int err = filter->QueryIntAttribute("DOMAIN", &domainID);
2459 ASSERTL0(err == TIXML_SUCCESS,
2460 "Unable to read attribute DOMAIN in filter.");
2461 }
2462
2463 std::map<std::string, std::string> vParams;
2464
2465 TiXmlElement *element = filter;
2466 GetXMLElementTimeLevel(element, m_timeLevel, false);
2467 TiXmlElement *param = element->FirstChildElement("PARAM");
2468 while (param)
2469 {
2470 ASSERTL0(param->Attribute("NAME"),
2471 "Missing attribute 'NAME' for parameter in filter " +
2472 typeStr + "'.");
2473 std::string nameStr = param->Attribute("NAME");
2474
2475 ASSERTL0(param->GetText(), "Empty value string for param.");
2476 std::string valueStr = param->GetText();
2477
2478 vParams[nameStr] = valueStr;
2479
2480 param = param->NextSiblingElement("PARAM");
2481 }
2482
2483 FilterDefinition filterDef;
2484 filterDef.domain = domainID;
2485 filterDef.name = typeStr;
2486 filterDef.params = vParams;
2487 m_filters.push_back(filterDef);
2488
2489 filter = filter->NextSiblingElement("FILTER");
2490 }
2491}
2492
2493/**
2494 *
2495 */
2496void SessionReader::ParseEquals(const std::string &line, std::string &lhs,
2497 std::string &rhs)
2498{
2499 /// Pull out lhs and rhs and eliminate any spaces.
2500 size_t beg = line.find_first_not_of(" ");
2501 size_t end = line.find_first_of("=");
2502 // Check for no parameter name
2503 if (beg == end)
2504 {
2505 throw 1;
2506 }
2507 // Check for no parameter value
2508 if (end != line.find_last_of("="))
2509 {
2510 throw 1;
2511 }
2512 // Check for no equals sign
2513 if (end == std::string::npos)
2514 {
2515 throw 1;
2516 }
2517
2518 lhs = line.substr(line.find_first_not_of(" "), end - beg);
2519 lhs = lhs.substr(0, lhs.find_last_not_of(" ") + 1);
2520 rhs = line.substr(line.find_last_of("=") + 1);
2521 rhs = rhs.substr(rhs.find_first_not_of(" "));
2522 rhs = rhs.substr(0, rhs.find_last_not_of(" ") + 1);
2523}
2524
2525/**
2526 *
2527 */
2529{
2530 // Parse solver info overrides
2531 if (m_cmdLineOptions.count("solverinfo"))
2532 {
2533 std::vector<std::string> solverInfoList =
2534 m_cmdLineOptions["solverinfo"].as<std::vector<std::string>>();
2535
2536 for (size_t i = 0; i < solverInfoList.size(); ++i)
2537 {
2538 std::string lhs, rhs;
2539
2540 try
2541 {
2542 ParseEquals(solverInfoList[i], lhs, rhs);
2543 }
2544 catch (...)
2545 {
2546 NEKERROR(ErrorUtil::efatal, "Parse error with command line "
2547 "option: " +
2548 solverInfoList[i]);
2549 }
2550
2551 std::string lhsUpper = boost::to_upper_copy(lhs);
2552 m_solverInfo[lhsUpper] = rhs;
2553 }
2554 }
2555
2556 if (m_cmdLineOptions.count("parameter"))
2557 {
2558 std::vector<std::string> parametersList =
2559 m_cmdLineOptions["parameter"].as<std::vector<std::string>>();
2560
2561 for (size_t i = 0; i < parametersList.size(); ++i)
2562 {
2563 std::string lhs, rhs;
2564
2565 try
2566 {
2567 ParseEquals(parametersList[i], lhs, rhs);
2568 }
2569 catch (...)
2570 {
2571 NEKERROR(ErrorUtil::efatal, "Parse error with command line "
2572 "option: " +
2573 parametersList[i]);
2574 }
2575
2576 std::string lhsUpper = boost::to_upper_copy(lhs);
2577
2578 try
2579 {
2580 m_parameters[lhsUpper] = std::stod(rhs);
2581 }
2582 catch (...)
2583 {
2584 NEKERROR(ErrorUtil::efatal, "Unable to convert string: " + rhs +
2585 "to double value.");
2586 }
2587 }
2588 }
2589}
2590
2591/**
2592 *
2593 */
2595{
2596 for (auto &x : m_solverInfo)
2597 {
2598 std::string solverProperty = x.first;
2599 std::string solverValue = x.second;
2600
2601 auto propIt = GetSolverInfoEnums().find(solverProperty);
2602 if (propIt != GetSolverInfoEnums().end())
2603 {
2604 auto valIt = propIt->second.find(solverValue);
2605 ASSERTL0(valIt != propIt->second.end(), "Value '" + solverValue +
2606 "' is not valid for "
2607 "property '" +
2608 solverProperty + "'");
2609 }
2610 }
2611}
2612
2613/**
2614 *
2615 */
2617{
2618 return m_interpreter;
2619}
2620
2621/**
2622 * Helper function that gets a pointer to a child element, or throws an
2623 * exception if no such element exists
2624 */
2625TiXmlElement *GetChildElementOrThrow(const std::string &filename,
2626 std::string elementName,
2627 const TiXmlHandle &docHandle)
2628{
2629 TiXmlElement *element = docHandle.FirstChildElement(elementName).Element();
2630
2631 if (!element)
2632 {
2633 NEKERROR(ErrorUtil::efatal, "Unable to find '" + elementName +
2634 "' XML node in " + filename);
2635 }
2636
2637 return element;
2638}
2639
2640} // namespace Nektar::LibUtilities
#define NEKTAR_VERSION
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:208
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mode...
Definition: ErrorUtil.hpp:202
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:242
tBaseSharedPtr CreateInstance(tKey idKey, tParam... args)
Create an instance of the class referred to by idKey.
const std::string & GetGlobalSysSolnInfo(const std::string &variable, const std::string &property) const
void ReadSolverInfo(TiXmlElement *conditions)
Reads the SOLVERINFO section of the XML document.
bool DefinesFunction(const std::string &name) const
Checks if a specified function is defined in the XML document.
std::string GetFunctionFilenameVariable(const std::string &name, const std::string &variable, const int pDomain=0) const
Returns the filename variable to be loaded for a given variable index.
std::vector< std::string > ParseCommandLineArguments(int argc, char *argv[])
Parse the program arguments and fill m_cmdLineOptions.
static SolverInfoMap & GetSolverInfoDefaults()
Default solver info options.
TimeIntScheme m_timeIntScheme
Time integration scheme information.
InterpreterSharedPtr GetInterpreter()
Returns the instance of the Interpreter specific to this session.
TiXmlElement * GetElement(const std::string &pPath)
Provides direct access to the TiXmlElement specified.
void ReadVariables(TiXmlElement *conditions)
Reads the VARIABLES section of the XML document.
bool DefinesSolverInfo(const std::string &name) const
Checks if a solver info property is specified.
const std::string & GetSessionName() const
Returns the session name of the loaded XML document.
void ReadTimeIntScheme(TiXmlElement *conditions)
Reads the TIMEINTEGRATIONSCHEME section of the XML document.
void ReadFilters(TiXmlElement *filters)
Reads the FILTERS section of the XML document.
void ReadGlobalSysSolnInfo(TiXmlElement *conditions)
Reads the GLOBALSYSSOLNINFO section of the XML document.
bool GetBackups() const
Returns the backups.
void InitSession(const std::vector< std::string > &filenames=std::vector< std::string >())
VariableList m_variables
Variables.
SolverInfoMap m_solverInfo
Solver information properties.
std::vector< std::string > GetVariables() const
Returns the names of all variables.
static CmdLineArgMap & GetCmdLineArgMap()
CmdLine argument map.
TiXmlDocument * MergeDoc(const std::vector< std::string > &pFilenames) const
Creates an XML document from a list of input files.
void SetVariable(const unsigned int &idx, std::string newname)
void CmdLineOverride()
Enforce parameters from command line arguments.
void ParseDocument()
Loads and parses the specified file.
bool m_sharedFilesystem
Running on a shared filesystem.
static void GetXMLElementTimeLevel(TiXmlElement *&element, const size_t timeLevel, const bool enableCheck=true)
Get XML elment time level (Parallel-in-Time)
std::string ParseSessionName(std::vector< std::string > &filenames)
Parse the session name.
std::string GetFunctionFilename(const std::string &name, const std::string &variable, const int pDomain=0) const
Returns the filename to be loaded for a given variable.
enum FunctionType GetFunctionType(const std::string &name, const std::string &variable, const int pDomain=0) const
Returns the type of a given function variable.
bool DefinesTag(const std::string &pName) const
Checks if a specified tag is defined.
bool m_updateOptFile
Update optimisation file.
void LoadParameter(const std::string &name, int &var) const
Load an integer parameter.
CommSharedPtr GetComm()
Returns the communication object.
const NekDouble & GetParameter(const std::string &pName) const
Returns the value of the specified parameter.
ParameterMap m_parameters
Parameters.
void SetParameter(const std::string &name, int &var)
Set an integer parameter.
InterpreterSharedPtr m_interpreter
Interpreter instance.
static EnumMapList & GetSolverInfoEnums()
String to enumeration map for Solver Info parameters.
void VerifySolverInfo()
Check values of solver info options are valid.
SessionReader(int argc, char *argv[], const std::vector< std::string > &pFilenames, const CommSharedPtr &pComm, const int &timelevel)
void SetSolverInfo(const std::string &pProperty, const std::string &pValue)
Sets the value of the specified solver info property.
const std::string & GetVariable(const unsigned int &idx) const
Returns the name of the variable specified by the given index.
EquationSharedPtr GetFunction(const std::string &name, const std::string &variable, const int pDomain=0) const
Returns an EquationSharedPtr to a given function variable.
const std::string & GetTag(const std::string &pName) const
Returns the value of a specified tag.
FunctionMap m_functions
Functions.
TiXmlDocument & GetDocument()
Provides direct access to the TiXmlDocument object.
bool DefinesElement(const std::string &pPath) const
Tests if a specified element is defined in the XML document.
std::vector< std::string > m_filenames
Filenames.
bool DefinesGlobalSysSolnInfo(const std::string &variable, const std::string &property) const
void ReadFunctions(TiXmlElement *conditions)
Reads the FUNCTIONS section of the XML document.
void LoadDoc(const std::string &pFilename, TiXmlDocument *pDoc) const
Loads an xml file into a tinyxml doc and decompresses if needed.
bool DefinesParameter(const std::string &name) const
Checks if a parameter is specified in the XML document.
const TimeIntScheme & GetTimeIntScheme() const
Returns the time integration scheme structure m_timeIntScheme from the session file.
void SetTag(const std::string &pName, const std::string &pValue)
Sets a specified tag.
boost::program_options::variables_map m_cmdLineOptions
std::string m_sessionName
Session name of the loaded XML document (filename minus ext).
CommSharedPtr m_comm
Communication object.
void MatchSolverInfo(const std::string &name, const std::string &trueval, bool &var, const bool &def=false) const
Check if the value of a solver info property matches.
void CreateComm(int &argc, char *argv[])
Loads the given XML document and instantiates an appropriate communication object.
const std::string & GetSolverInfo(const std::string &pProperty) const
Returns the value of the specified solver info property.
void ParseEquals(const std::string &line, std::string &lhs, std::string &rhs)
Parse a string in the form lhs = rhs.
bool DefinesTimeIntScheme() const
Returns true if the TIMEINTEGRATIONSCHEME section is defined in the session file.
const std::vector< std::string > & GetFilenames() const
Returns the filename of the loaded XML document.
bool GetSharedFilesystem()
Returns if file system shared.
static GloSysSolnInfoList & GetGloSysSolnList()
GlobalSysSoln Info map.
void PartitionComm()
Partitions the comm object based on session parameters.
bool DefinesCmdLineArgument(const std::string &pName) const
Checks if a specified cmdline argument has been given.
TiXmlDocument * m_xmlDoc
Pointer to the loaded XML document.
void ReadParameters(TiXmlElement *conditions)
Reads the PARAMETERS section of the XML document.
void LoadSolverInfo(const std::string &name, std::string &var, const std::string &def="") const
Check for and load a solver info property.
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
static bool GenerateVector(const std::string &str, std::vector< T > &out)
Takes a comma-separated string and converts it to entries in a vector.
Definition: ParseUtils.cpp:130
static bool GenerateSeqVector(const std::string &str, std::vector< unsigned int > &out)
Takes a comma-separated compressed string and converts it to entries in a vector.
Definition: ParseUtils.cpp:104
def copy(self)
Definition: pycml.py:2663
def description(self, force=False, cellml=False)
Definition: pycml.py:2670
std::shared_ptr< Interpreter > InterpreterSharedPtr
Definition: Interpreter.h:322
std::map< std::string, std::string > SolverInfoMap
Definition: SessionReader.h:56
std::map< std::string, GloSysInfoMap > GloSysSolnInfoList
Definition: SessionReader.h:83
std::map< std::pair< std::string, int >, FunctionVariableDefinition > FunctionVariableMap
std::map< std::string, NekDouble > ParameterMap
Definition: SessionReader.h:57
static std::string PortablePath(const fs::path &path)
create portable path on different platforms for std::filesystem path.
Definition: Filesystem.hpp:66
std::shared_ptr< Equation > EquationSharedPtr
Definition: Equation.h:125
TiXmlElement * GetChildElementOrThrow(const std::string &filename, std::string elementName, const TiXmlHandle &docHandle)
std::map< std::string, EnumMap > EnumMapList
Definition: SessionReader.h:80
std::vector< FilterDefinition > FilterMap
Definition: SessionReader.h:68
CommFactory & GetCommFactory()
std::map< std::string, CmdLineArg > CmdLineArgMap
Definition: SessionReader.h:77
std::shared_ptr< Comm > CommSharedPtr
Pointer to a Communicator object.
Definition: Comm.h:55
const std::string kGitBranch
Definition: GitRevision.h:46
const std::string kGitSha1
Definition: GitRevision.h:45
InputIterator find(InputIterator first, InputIterator last, InputIterator startingpoint, const EqualityComparable &value)
Definition: StdRegions.hpp:475
std::vector< double > d(NPUPPER *NPUPPER)
std::vector< double > q(NPUPPER *NPUPPER)
double NekDouble
Definition: sha1.cpp:72
STL namespace.
std::vector< NekDouble > freeParams
Definition: SessionReader.h:93