Reads and parses information from a Nektar++ XML session file. More...

#include <SessionReader.h>

Inheritance diagram for Nektar::LibUtilities::SessionReader:

Collaboration diagram for Nektar::LibUtilities::SessionReader:

Public Member Functions
	SessionReader (int argc, char *argv[], const std::vector< std::string > &pFilenames, const CommSharedPtr &pComm)

	~SessionReader ()
	Destructor. More...

TiXmlDocument &	GetDocument ()
	Provides direct access to the TiXmlDocument object. More...

TiXmlElement *	GetElement (const std::string &pPath)
	Provides direct access to the TiXmlElement specified. More...

bool	DefinesElement (const std::string &pPath) const
	Tests if a specified element is defined in the XML document. More...

const std::vector< std::string > &	GetFilenames () const
	Returns the filename of the loaded XML document. More...

const std::string &	GetSessionName () const
	Returns the session name of the loaded XML document. More...

const std::string	GetSessionNameRank () const
	Returns the session name with process rank. More...

CommSharedPtr &	GetComm ()
	Returns the communication object. More...

bool	GetSharedFilesystem ()
	Returns the communication object. More...

void	Finalise ()
	Finalises the session. More...

bool	DefinesParameter (const std::string &name) const
	Checks if a parameter is specified in the XML document. More...

const NekDouble &	GetParameter (const std::string &pName) const
	Returns the value of the specified parameter. More...

void	LoadParameter (const std::string &name, int &var) const
	Load an integer parameter. More...

void	LoadParameter (const std::string &name, int &var, const int &def) const
	Check for and load an integer parameter. More...

void	LoadParameter (const std::string &name, NekDouble &var) const
	Load a double precision parameter. More...

void	LoadParameter (const std::string &name, NekDouble &var, const NekDouble &def) const
	Check for and load a double-precision parameter. More...

void	SetParameter (const std::string &name, int &var)
	Set an integer parameter. More...

void	SetParameter (const std::string &name, NekDouble &var)
	Set a double precision parameter. More...

bool	DefinesSolverInfo (const std::string &name) const
	Checks if a solver info property is specified. More...

const std::string &	GetSolverInfo (const std::string &pProperty) const
	Returns the value of the specified solver info property. More...

void	SetSolverInfo (const std::string &pProperty, const std::string &pValue)
	Sets the value of the specified solver info property. More...

template<typename T >
const T	GetSolverInfoAsEnum (const std::string &pName) const
	Returns the value of the specified solver info property as enum. More...

template<typename T >
const T	GetValueAsEnum (const std::string &pName, const std::string &vValue) const
	Returns the value of the specified property and value as enum. More...

void	LoadSolverInfo (const std::string &name, std::string &var, const std::string &def="") const
	Check for and load a solver info property. More...

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. More...

bool	MatchSolverInfo (const std::string &name, const std::string &trueval) const
	Check if the value of a solver info property matches. More...

template<typename T >
bool	MatchSolverInfoAsEnum (const std::string &name, const T &trueval) const
	Check if the value of a solver info property matches. More...

bool	DefinesGlobalSysSolnInfo (const std::string &variable, const std::string &property) const

const std::string &	GetGlobalSysSolnInfo (const std::string &variable, const std::string &property) const

bool	DefinesGeometricInfo (const std::string &name) const
	Checks if a geometric info property is defined. More...

void	LoadGeometricInfo (const std::string &name, std::string &var, const std::string &def="") const
	Checks for and load a geometric info string property. More...

void	LoadGeometricInfo (const std::string &name, bool &var, const bool &def=false) const
	Checks for and loads a geometric info boolean property. More...

void	LoadGeometricInfo (const std::string &name, NekDouble &var, const NekDouble &def=0.0) const
	Checks for and loads a geometric info double-precision property. More...

void	MatchGeometricInfo (const std::string &name, const std::string &trueval, bool &var, const bool &def=false) const
	Check if the value of a geometric info string property matches. More...

const std::string &	GetVariable (const unsigned int &idx) const
	Returns the name of the variable specified by the given index. More...

void	SetVariable (const unsigned int &idx, std::string newname)

std::vector< std::string >	GetVariables () const
	Returns the names of all variables. More...

bool	DefinesFunction (const std::string &name) const
	Checks if a specified function is defined in the XML document. More...

bool	DefinesFunction (const std::string &name, const std::string &variable, const int pDomain=0) const
	Checks if a specified function has a given variable defined. More...

EquationSharedPtr	GetFunction (const std::string &name, const std::string &variable, const int pDomain=0) const
	Returns an EquationSharedPtr to a given function variable. More...

EquationSharedPtr	GetFunction (const std::string &name, const unsigned int &var, const int pDomain=0) const
	Returns an EquationSharedPtr to a given function variable index. More...

enum FunctionType	GetFunctionType (const std::string &name, const std::string &variable, const int pDomain=0) const
	Returns the type of a given function variable. More...

enum FunctionType	GetFunctionType (const std::string &pName, const unsigned int &pVar, const int pDomain=0) const
	Returns the type of a given function variable index. More...

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. More...

std::string	GetFunctionFilename (const std::string &name, const unsigned int &var, const int pDomain=0) const
	Returns the filename to be loaded for a given variable index. More...

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. More...

AnalyticExpressionEvaluator &	GetExpressionEvaluator ()
	Returns the instance of AnalyticExpressionEvaluator specific to this session. More...

bool	DefinesTag (const std::string &pName) const
	Checks if a specified tag is defined. More...

void	SetTag (const std::string &pName, const std::string &pValue)
	Sets a specified tag. More...

const std::string &	GetTag (const std::string &pName) const
	Returns the value of a specified tag. More...

const FilterMap &	GetFilters () const

bool	DefinesCmdLineArgument (const std::string &pName) const
	Checks if a specified cmdline argument has been given. More...

template<typename T >
T	GetCmdLineArgument (const std::string &pName) const
	Retrieves a command-line argument value. More...

void	SubstituteExpressions (std::string &expr)
	Substitutes expressions defined in the XML document. More...

CompositeOrdering	GetCompositeOrdering () const

BndRegionOrdering	GetBndRegionOrdering () const

void	SetUpXmlDoc ()

Static Public Member Functions
static SessionReaderSharedPtr	CreateInstance (int argc, char *argv[])
	Creates an instance of the SessionReader class. More...

static SessionReaderSharedPtr	CreateInstance (int argc, char *argv[], std::vector< std::string > &pFilenames, const CommSharedPtr &pComm=CommSharedPtr())
	Creates an instance of the SessionReader class initialised using a separate list of XML documents. More...

static std::string	RegisterEnumValue (std::string pEnum, std::string pString, int pEnumValue)
	Registers an enumeration value. More...

static std::string	RegisterDefaultSolverInfo (const std::string &pName, const std::string &pValue)
	Registers the default string value of a solver info property. More...

static std::string	RegisterCmdLineArgument (const std::string &pName, const std::string &pShortName, const std::string &pDescription)
	Registers a command-line argument with the session reader. More...

static std::string	RegisterCmdLineFlag (const std::string &pName, const std::string &pShortName, const std::string &pDescription)
	Registers a command-line flag with the session reader. More...

Private Member Functions
	SessionReader (int argc, char *argv[])
	Main constructor. More...

void	InitSession ()

SessionReaderSharedPtr	GetSharedThisPtr ()
	Returns a shared pointer to the current object. More...

void	TestSharedFilesystem ()

std::vector< std::string >	ParseCommandLineArguments (int argc, char *argv[])
	Parse the program arguments and fill m_cmdLineOptions. More...

std::string	ParseSessionName (std::vector< std::string > &filenames)
	Parse the session name. More...

void	LoadDoc (const std::string &pFilename, TiXmlDocument *pDoc) const
	Loads an xml file into a tinyxml doc and decompresses if needed. More...

TiXmlDocument *	MergeDoc (const std::vector< std::string > &pFilenames) const
	Creates an XML document from a list of input files. More...

void	ParseDocument ()
	Loads and parses the specified file. More...

void	CreateComm (int &argc, char *argv[])
	Loads the given XML document and instantiates an appropriate communication object. More...

void	PartitionMesh ()
	Partitions the mesh when running in parallel. More...

void	PartitionComm ()
	Partitions the comm object based on session parameters. More...

void	ReadParameters (TiXmlElement *conditions)
	Reads the PARAMETERS section of the XML document. More...

void	ReadSolverInfo (TiXmlElement *conditions)
	Reads the SOLVERINFO section of the XML document. More...

void	ReadGlobalSysSolnInfo (TiXmlElement *conditions)
	Reads the GLOBALSYSSOLNINFO section of the XML document. More...

void	ReadExpressions (TiXmlElement *conditions)
	Reads the EXPRESSIONS section of the XML document. More...

void	ReadVariables (TiXmlElement *conditions)
	Reads the VARIABLES section of the XML document. More...

void	ReadFunctions (TiXmlElement *conditions)
	Reads the FUNCTIONS section of the XML document. More...

void	ReadFilters (TiXmlElement *filters)
	Reads the FILTERS section of the XML document. More...

void	CmdLineOverride ()
	Enforce parameters from command line arguments. More...

void	VerifySolverInfo ()
	Check values of solver info options are valid. More...

void	ParseEquals (const std::string &line, std::string &lhs, std::string &rhs)
	Parse a string in the form lhs = rhs. More...

Static Private Member Functions
static EnumMapList &	GetSolverInfoEnums ()
	String to enumeration map for Solver Info parameters. More...

static SolverInfoMap &	GetSolverInfoDefaults ()
	Default solver info options. More...

static GloSysSolnInfoList &	GetGloSysSolnList ()
	GlobalSysSoln Info map. More...

static CmdLineArgMap &	GetCmdLineArgMap ()
	CmdLine argument map. More...

Private Attributes
boost::program_options::variables_map	m_cmdLineOptions

CommSharedPtr	m_comm
	Communication object. More...

std::vector< std::string >	m_filenames
	Filenames. More...

std::string	m_sessionName
	Session name of the loaded XML document (filename minus ext). More...

TiXmlDocument *	m_xmlDoc
	Pointer to the loaded XML document. More...

ParameterMap	m_parameters
	Parameters. More...

SolverInfoMap	m_solverInfo
	Solver information properties. More...

GeometricInfoMap	m_geometricInfo
	Geometric information properties. More...

ExpressionMap	m_expressions
	Expressions. More...

AnalyticExpressionEvaluator	m_exprEvaluator
	Analytic expression evaluator instance. More...

FunctionMap	m_functions
	Functions. More...

VariableList	m_variables
	Variables. More...

TagMap	m_tags
	Custom tags. More...

FilterMap	m_filters
	Filters map. More...

bool	m_verbose
	Be verbose. More...

bool	m_sharedFilesystem
	Running on a shared filesystem. More...

CompositeOrdering	m_compOrder
	Map of original composite ordering for parallel periodic bcs. More...

BndRegionOrdering	m_bndRegOrder
	Map of original boundary region ordering for parallel periodic bcs. More...

Friends
class	MemoryManager< SessionReader >
	Support creation through MemoryManager. More...

Detailed Description

Reads and parses information from a Nektar++ XML session file.

This class provides an interface to Nektar++-specific content in a supplied XML document. It also initialises a Nektar++ session including setting up communication for parallel execution and where necessary partitioning the supplied mesh for running across multiple processes.

A session should be initialised at the beginning of a user's application by passing the command-line arguments. This not only allows the SessionReader to extract the name of the XML document to load containing Nektar++ session information, but also supplies the MPI arguments necessary for setting up parallel communication. The SessionReader should be initialised using the CreateInstance function:

LibUtilities::SessionReaderSharedPtr vSession

= LibUtilities::SessionReader::CreateInstance(argc, argv);

The instance vSession can now be passed to other key Nektar++ components during their construction.

Note: At the end of the user application, it is important to call the Finalise routine in order to finalise any MPI communication and correctly free resources.

The SessionReader class provides streamlined, validated access to session parameters, solver information and functions defined within a Nektar++ XML document. The available routines and their usage is documented below.

In the case of solver information properties, the classes to which these parameters are pertinent may register with the SessionReader class the set of valid values for a given property. Such values may also be associated with an enumeration value for more transparent use of the property values in code.

Definition at line 123 of file SessionReader.h.

Constructor & Destructor Documentation

Nektar::LibUtilities::SessionReader::SessionReader	(	int	argc,
		char *	argv[],
		const std::vector< std::string > &	pFilenames,
		const CommSharedPtr &	pComm
	)

Definition at line 212 of file SessionReader.cpp.

References ASSERTL0.

         {
             ASSERTL0(pFilenames.size() > 0, "No filenames specified.");
 
             ParseCommandLineArguments(argc, argv);
             m_xmlDoc      = 0;
             m_filenames   = pFilenames;
 
             m_sessionName = ParseSessionName(m_filenames);
 
             // Create communicator
             if (!pComm.get())
             {
                 CreateComm(argc, argv);
             }
             else
             {
                 m_comm = pComm;
 
                 if (m_comm->GetSize() > 1)
                 {
                     GetSolverInfoDefaults()["GLOBALSYSSOLN"] =
                         "IterativeStaticCond";
                 }
             }
 
             TestSharedFilesystem();
 
             // If running in parallel change the default global sys solution
             // type.
             if (m_comm->GetSize() > 1)
             {
                 GetSolverInfoDefaults()["GLOBALSYSSOLN"] =
                     "IterativeStaticCond";
             }
         }

Nektar::LibUtilities::SessionReader::~SessionReader ( )

Destructor.

Definition at line 257 of file SessionReader.cpp.

         {
             delete m_xmlDoc;
         }

Nektar::LibUtilities::SessionReader::SessionReader	(	int	argc,
		char *	argv[]
	)

private

Main constructor.

This constructor parses the command-line arguments given to the user application to set up any MPI communication, read supplied XML session files, and partition meshes where necessary.

Parameters

argc	Number of command-line arguments
argv	Array of command-line arguments

Definition at line 185 of file SessionReader.cpp.

References ASSERTL0.

         {
             m_xmlDoc    = 0;
             m_filenames = ParseCommandLineArguments(argc, argv);
 
             ASSERTL0(m_filenames.size() > 0, "No session file(s) given.");
 
             m_sessionName = ParseSessionName(m_filenames);
 
             // Create communicator
             CreateComm(argc, argv);
 
             TestSharedFilesystem();
 
             // If running in parallel change the default global sys solution
             // type.
             if (m_comm->GetSize() > 1)
             {
                 GetSolverInfoDefaults()["GLOBALSYSSOLN"] =
                     "IterativeStaticCond";
             }
         }

Member Function Documentation

void Nektar::LibUtilities::SessionReader::CmdLineOverride ( )

private

Enforce parameters from command line arguments.

Definition at line 2622 of file SessionReader.cpp.

References ASSERTL0, and Nektar::lhs.

         {
             // Parse solver info overrides
             if (m_cmdLineOptions.count("solverinfo"))
             {
                 std::vector<std::string> solverInfoList =
                     m_cmdLineOptions["solverinfo"].as<
                         std::vector<std::string> >();
 
                 for (int i = 0; i < solverInfoList.size(); ++i)
                 {
                     std::string lhs, rhs;
 
                     try
                     {
                         ParseEquals(solverInfoList[i], lhs, rhs);
                     }
                     catch (...)
                     {
                         ASSERTL0(false, "Parse error with command line "
                                  "option: "+solverInfoList[i]);
                     }
 
                     std::string lhsUpper = boost::to_upper_copy(lhs);
                     m_solverInfo[lhsUpper] = rhs;
                 }
             }
 
             if (m_cmdLineOptions.count("parameter"))
             {
                 std::vector<std::string> parametersList =
                     m_cmdLineOptions["parameter"].as<
                         std::vector<std::string> >();
 
                 for (int i = 0; i < parametersList.size(); ++i)
                 {
                     std::string lhs, rhs;
 
                     try
                     {
                         ParseEquals(parametersList[i], lhs, rhs);
                     }
                     catch (...)
                     {
                         ASSERTL0(false, "Parse error with command line "
                                  "option: "+parametersList[i]);
                     }
 
                     std::string lhsUpper = boost::to_upper_copy(lhs);
 
                     try
                     {
                         m_parameters[lhsUpper] =
                             boost::lexical_cast<NekDouble>(rhs);
                     }
                     catch (...)
                     {
                         ASSERTL0(false, "Unable to convert string: "+rhs+
                                  "to double value.");
                     }
                 }
             }
         }

void Nektar::LibUtilities::SessionReader::CreateComm	(	int &	argc,
		char *	argv[]
	)

private

Loads the given XML document and instantiates an appropriate communication object.

Definition at line 1573 of file SessionReader.cpp.

References Nektar::LibUtilities::NekFactory< tKey, tBase, >::CreateInstance(), and Nektar::LibUtilities::GetCommFactory().

         {
             if (argc == 0)
             {
                 m_comm = GetCommFactory().CreateInstance("Serial", 0, 0);
             }
             else
             {
                 string vCommModule("Serial");
                 if (GetCommFactory().ModuleExists("ParallelMPI"))
                 {
                     vCommModule = "ParallelMPI";
                 }
 
                 m_comm = GetCommFactory().CreateInstance(vCommModule,argc,argv);
             }
         }

static SessionReaderSharedPtr Nektar::LibUtilities::SessionReader::CreateInstance	(	int	argc,
		char *	argv[]
	)

inlinestatic

Creates an instance of the SessionReader class.

This function should be used by an application to instantiate the session reader. It should be called at the very beginning of the application before any other processing of command-line arguments. After instantiating the class and setting up any parallel communication, it also calls the main initialisation of the object.

Definition at line 140 of file SessionReader.h.

References CellMLToNektar.cellml_metadata::p.

Referenced by main(), Nektar::Utilities::InputMCF::ParseFile(), Nektar::Utilities::InputNekpp::Process(), Nektar::FieldUtils::InputXml::Process(), Nektar::FieldUtils::ProcessDisplacement::Process(), Nektar::FieldUtils::ProcessInterpField::Process(), Nektar::Utilities::OutputNekpp::Process(), Nektar::FieldUtils::ProcessInterpPoints::Process(), Nektar::SolverUtils::Driver::v_InitObject(), and Nektar::VortexWaveInteraction::VortexWaveInteraction().

             {
                 SessionReaderSharedPtr p = MemoryManager<
                     LibUtilities::SessionReader>::AllocateSharedPtr(argc, argv);
                 p->InitSession();
                 return p;
             }

static SessionReaderSharedPtr Nektar::LibUtilities::SessionReader::CreateInstance	(	int	argc,
		char *	argv[],
		std::vector< std::string > &	pFilenames,
		const CommSharedPtr &	pComm = `CommSharedPtr()`
	)

inlinestatic

Creates an instance of the SessionReader class initialised using a separate list of XML documents.

This function should be used by an application to instantiate the session reader. It may be called after processing of command-line arguments. After instantiating the class and setting up any parallel communication, it also calls the main initialisation of the object.

Definition at line 159 of file SessionReader.h.

References CellMLToNektar.cellml_metadata::p.

             {
                 SessionReaderSharedPtr p = MemoryManager<
                     LibUtilities::SessionReader>
                         ::AllocateSharedPtr(argc, argv, pFilenames, pComm);
                 p->InitSession();
                 return p;
             }

bool Nektar::LibUtilities::SessionReader::DefinesCmdLineArgument ( const std::string & pName ) const

Checks if a specified cmdline argument has been given.

Definition at line 1395 of file SessionReader.cpp.

         {
             return (m_cmdLineOptions.find(pName) != m_cmdLineOptions.end());
         }

bool Nektar::LibUtilities::SessionReader::DefinesElement ( const std::string & pPath ) const

Tests if a specified element is defined in the XML document.

Definition at line 601 of file SessionReader.cpp.

References ASSERTL0.

         {
             std::string vPath = boost::to_upper_copy(pPath);
             std::vector<std::string> st;
             boost::split(st, vPath, boost::is_any_of("\\/ "));
             ASSERTL0(st.size() > 0, "No path given in XML element request.");
 
             TiXmlElement* vReturn = m_xmlDoc->FirstChildElement(st[0].c_str());
             ASSERTL0(vReturn, std::string("Cannot find element '")
                               + st[0] + std::string("'."));
             for (int i = 1; i < st.size(); ++i)
             {
                 vReturn = vReturn->FirstChildElement(st[i].c_str());
                 if (!vReturn) return false;
             }
             return true;
         }

bool Nektar::LibUtilities::SessionReader::DefinesFunction ( const std::string & name ) const

Checks if a specified function is defined in the XML document.

Definition at line 1091 of file SessionReader.cpp.

         {
             FunctionMap::const_iterator it1;
             std::string vName = boost::to_upper_copy(pName);
 
             if ((it1 = m_functions.find(vName)) != m_functions.end())
             {
                 return true;
             }
             return false;
         }

bool Nektar::LibUtilities::SessionReader::DefinesFunction	(	const std::string &	name,
		const std::string &	variable,
		const int	pDomain = `0`
	)		const

Checks if a specified function has a given variable defined.

Definition at line 1107 of file SessionReader.cpp.

         {
             FunctionMap::const_iterator it1;
             FunctionVariableMap::const_iterator it2;
             std::string vName = boost::to_upper_copy(pName);
 
             // Check function exists
             if ((it1 = m_functions.find(vName))     != m_functions.end())
             {
                 pair<std::string, int> key(pVariable,pDomain);
                 pair<std::string, int> defkey("*",pDomain);
                 bool varExists =
                     (it2 = it1->second.find(key)) != it1->second.end() ||
                     (it2 = it1->second.find(defkey)) != it1->second.end();
                 return varExists;
             }
             return false;
         }

bool Nektar::LibUtilities::SessionReader::DefinesGeometricInfo ( const std::string & name ) const

Checks if a geometric info property is defined.

Definition at line 956 of file SessionReader.cpp.

         {
             std::string vName = boost::to_upper_copy(pName);
             GeometricInfoMap::const_iterator iter = m_geometricInfo.find(vName);
             return (iter != m_geometricInfo.end());
         }

bool Nektar::LibUtilities::SessionReader::DefinesGlobalSysSolnInfo	(	const std::string &	variable,
		const std::string &	property
	)		const

Definition at line 910 of file SessionReader.cpp.

         {
 
             GloSysSolnInfoList::const_iterator iter =
                     GetGloSysSolnList().find(pVariable);
             if(iter == GetGloSysSolnList().end())
             {
                 return false;
             }
 
             std::string vProperty = boost::to_upper_copy(pProperty);
 
             GloSysInfoMap::const_iterator iter1 = iter->second.find(vProperty);
             if(iter1 == iter->second.end())
             {
                 return false;
             }
 
             return true;
         }

bool Nektar::LibUtilities::SessionReader::DefinesParameter ( const std::string & name ) const

Checks if a parameter is specified in the XML document.

Definition at line 683 of file SessionReader.cpp.

         {
             std::string vName = boost::to_upper_copy(pName);
             ParameterMap::const_iterator paramIter = m_parameters.find(vName);
             return (paramIter != m_parameters.end());
         }

bool Nektar::LibUtilities::SessionReader::DefinesSolverInfo ( const std::string & name ) const

Checks if a solver info property is specified.

Definition at line 806 of file SessionReader.cpp.

Referenced by GetSolverInfoAsEnum().

         {
             std::string vName = boost::to_upper_copy(pName);
             SolverInfoMap::const_iterator infoIter = m_solverInfo.find(vName);
             return (infoIter != m_solverInfo.end());
         }

bool Nektar::LibUtilities::SessionReader::DefinesTag ( const std::string & pName ) const

Checks if a specified tag is defined.

Definition at line 1350 of file SessionReader.cpp.

         {
             std::string vName = boost::to_upper_copy(pName);
             TagMap::const_iterator vTagIterator = m_tags.find(vName);
             return (vTagIterator != m_tags.end());
         }

void Nektar::LibUtilities::SessionReader::Finalise ( )

Finalises the session.

This routine finalises any parallel communication.

Note: This routine should be called at the very end of a users application.

Definition at line 674 of file SessionReader.cpp.

         {
             m_comm->Finalise();
         }

BndRegionOrdering Nektar::LibUtilities::SessionReader::GetBndRegionOrdering ( ) const

Definition at line 1420 of file SessionReader.cpp.

         {
             return m_bndRegOrder;
         }

CmdLineArgMap & Nektar::LibUtilities::SessionReader::GetCmdLineArgMap ( )

staticprivate

CmdLine argument map.

Lists the possible command-line argument which can be specified for this executable.

This list is populated through the RegisterCmdLineArgument static member function which is called statically from various classes to register command-line arguments they need.

Definition at line 170 of file SessionReader.cpp.

Referenced by RegisterCmdLineArgument(), and RegisterCmdLineFlag().

         {
             static CmdLineArgMap cmdLineArguments;
             return cmdLineArguments;
         }

template<typename T >

T Nektar::LibUtilities::SessionReader::GetCmdLineArgument ( const std::string & pName ) const

inline

Retrieves a command-line argument value.

Definition at line 406 of file SessionReader.h.

References m_cmdLineOptions.

             {
                 return m_cmdLineOptions.find(pName)->second.as<T>();
             }

CommSharedPtr & Nektar::LibUtilities::SessionReader::GetComm ( )

Returns the communication object.

Definition at line 658 of file SessionReader.cpp.

         {
             return m_comm;
         }

CompositeOrdering Nektar::LibUtilities::SessionReader::GetCompositeOrdering ( ) const

Definition at line 1415 of file SessionReader.cpp.

         {
             return m_compOrder;
         }

TiXmlDocument & Nektar::LibUtilities::SessionReader::GetDocument ( )

Provides direct access to the TiXmlDocument object.

Definition at line 549 of file SessionReader.cpp.

References ASSERTL1.

         {
             ASSERTL1(m_xmlDoc, "XML Document not defined.");
             return *m_xmlDoc;
         }

TiXmlElement * Nektar::LibUtilities::SessionReader::GetElement ( const std::string & pPath )

Provides direct access to the TiXmlElement specified.

The single parameter specifies a path to the requested element in a similar format to the filesystem path. Given the following XML:

<NEKTAR>
  <CONDITIONS>
    <PARAMETERS>
    ...
    </PARAMETERS>
  </CONDITIONS>
</NEKTAR>

the PARAMETERS element would be retrieved by requesting the path:

Nektar/Conditions/Parameters

Note: Paths are case-insensitive.

Parameters

pPath Path to requested element.

Returns: Direct pointer to requested XML Element.

Definition at line 578 of file SessionReader.cpp.

References ASSERTL0.

         {
             std::string vPath = boost::to_upper_copy(pPath);
             std::vector<std::string> st;
             boost::split(st, vPath, boost::is_any_of("\\/ "));
             ASSERTL0(st.size() > 0, "No path given in XML element request.");
 
             TiXmlElement* vReturn = m_xmlDoc->FirstChildElement(st[0].c_str());
             ASSERTL0(vReturn, std::string("Cannot find element '")
                               + st[0] + std::string("'."));
             for (int i = 1; i < st.size(); ++i)
             {
                 vReturn = vReturn->FirstChildElement(st[i].c_str());
                 ASSERTL0(vReturn, std::string("Cannot find element '")
                                   + st[i] + std::string("'."));
             }
             return vReturn;
         }

AnalyticExpressionEvaluator & Nektar::LibUtilities::SessionReader::GetExpressionEvaluator ( )

Returns the instance of AnalyticExpressionEvaluator specific to this session.

Definition at line 1341 of file SessionReader.cpp.

         {
             return m_exprEvaluator;
         }

const std::vector< std::string > & Nektar::LibUtilities::SessionReader::GetFilenames ( ) const

Returns the filename of the loaded XML document.

Definition at line 623 of file SessionReader.cpp.

         {
             return m_filenames;
         }

const FilterMap & Nektar::LibUtilities::SessionReader::GetFilters ( ) const

Definition at line 1386 of file SessionReader.cpp.

         {
             return m_filters;
         }

EquationSharedPtr Nektar::LibUtilities::SessionReader::GetFunction	(	const std::string &	name,
		const std::string &	variable,
		const int	pDomain = `0`
	)		const

Returns an EquationSharedPtr to a given function variable.

Definition at line 1133 of file SessionReader.cpp.

References ASSERTL0, and Nektar::LibUtilities::eFunctionTypeExpression.

         {
             FunctionMap::const_iterator it1;
             FunctionVariableMap::const_iterator it2, it3;
             std::string vName = boost::to_upper_copy(pName);
 
             ASSERTL0((it1 = m_functions.find(vName)) != m_functions.end(),
                      std::string("No such function '") + pName
                      + std::string("' has been defined in the session file."));
 
             // Check for specific and wildcard definitions
             pair<std::string,int> key(pVariable,pDomain);
             pair<std::string,int> defkey("*",pDomain);
             bool specific = (it2 = it1->second.find(key)) !=
                 it1->second.end();
             bool wildcard = (it3 = it1->second.find(defkey)) !=
                 it1->second.end();
 
             // Check function is defined somewhere
             ASSERTL0(specific || wildcard,
                      "No such variable " + pVariable
                      + " in domain " + boost::lexical_cast<string>(pDomain)
                      + " defined for function " + pName
                      + " in session file.");
 
             // If not specific, must be wildcard
             if (!specific)
             {
                 it2 = it3;
             }
 
             ASSERTL0((it2->second.m_type == eFunctionTypeExpression),
                     std::string("Function is defined by a file."));
             return it2->second.m_expression;
         }

EquationSharedPtr Nektar::LibUtilities::SessionReader::GetFunction	(	const std::string &	name,
		const unsigned int &	var,
		const int	pDomain = `0`
	)		const

Returns an EquationSharedPtr to a given function variable index.

Definition at line 1176 of file SessionReader.cpp.

References ASSERTL0.

         {
             ASSERTL0(pVar < m_variables.size(), "Variable index out of range.");
             return GetFunction(pName, m_variables[pVar],pDomain);
         }

std::string Nektar::LibUtilities::SessionReader::GetFunctionFilename	(	const std::string &	name,
		const std::string &	variable,
		const int	pDomain = `0`
	)		const

Returns the filename to be loaded for a given variable.

Definition at line 1244 of file SessionReader.cpp.

References ASSERTL0.

         {
             FunctionMap::const_iterator it1;
             FunctionVariableMap::const_iterator it2, it3;
             std::string vName = boost::to_upper_copy(pName);
 
             it1 = m_functions.find(vName);
             ASSERTL0 (it1 != m_functions.end(),
                       std::string("Function '") + pName
                       + std::string("' not found."));
 
             // Check for specific and wildcard definitions
             pair<std::string,int> key(pVariable,pDomain);
             pair<std::string,int> defkey("*",pDomain);
             bool specific = (it2 = it1->second.find(key)) !=
                             it1->second.end();
             bool wildcard = (it3 = it1->second.find(defkey)) !=
                             it1->second.end();
 
             // Check function is defined somewhere
             ASSERTL0(specific || wildcard,
                      "No such variable " + pVariable
                      + " in domain " + boost::lexical_cast<string>(pDomain)
                      + " defined for function " + pName
                      + " in session file.");
 
             // If not specific, must be wildcard
             if (!specific)
             {
                 it2 = it3;
             }
 
             return it2->second.m_filename;
         }

std::string Nektar::LibUtilities::SessionReader::GetFunctionFilename	(	const std::string &	name,
		const unsigned int &	var,
		const int	pDomain = `0`
	)		const

Returns the filename to be loaded for a given variable index.

Definition at line 1286 of file SessionReader.cpp.

References ASSERTL0.

         {
             ASSERTL0(pVar < m_variables.size(), "Variable index out of range.");
             return GetFunctionFilename(pName, m_variables[pVar],pDomain);
         }

std::string Nektar::LibUtilities::SessionReader::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.

Definition at line 1299 of file SessionReader.cpp.

References ASSERTL0.

         {
             FunctionMap::const_iterator it1;
             FunctionVariableMap::const_iterator it2, it3;
             std::string vName = boost::to_upper_copy(pName);
 
             it1 = m_functions.find(vName);
             ASSERTL0 (it1 != m_functions.end(),
                       std::string("Function '") + pName
                       + std::string("' not found."));
 
             // Check for specific and wildcard definitions
             pair<std::string,int> key(pVariable,pDomain);
             pair<std::string,int> defkey("*",pDomain);
             bool specific = (it2 = it1->second.find(key)) !=
                             it1->second.end();
             bool wildcard = (it3 = it1->second.find(defkey)) !=
                             it1->second.end();
 
             // Check function is defined somewhere
             ASSERTL0(specific || wildcard,
                      "No such variable " + pVariable
                      + " in domain " + boost::lexical_cast<string>(pDomain)
                      + " defined for function " + pName
                      + " in session file.");
 
             // If not specific, must be wildcard
             if (!specific)
             {
                 it2 = it3;
             }
 
             return it2->second.m_fileVariable;
         }

enum FunctionType Nektar::LibUtilities::SessionReader::GetFunctionType	(	const std::string &	name,
		const std::string &	variable,
		const int	pDomain = `0`
	)		const

Returns the type of a given function variable.

Definition at line 1189 of file SessionReader.cpp.

References ASSERTL0.

         {
             FunctionMap::const_iterator it1;
             FunctionVariableMap::const_iterator it2, it3;
             std::string vName = boost::to_upper_copy(pName);
 
             it1 = m_functions.find(vName);
             ASSERTL0 (it1 != m_functions.end(),
                       std::string("Function '") + pName
                       + std::string("' not found."));
 
             // Check for specific and wildcard definitions
             pair<std::string,int> key(pVariable,pDomain);
             pair<std::string,int> defkey("*",pDomain);
             bool specific = (it2 = it1->second.find(key)) !=
                             it1->second.end();
             bool wildcard = (it3 = it1->second.find(defkey)) !=
                             it1->second.end();
 
             // Check function is defined somewhere
             ASSERTL0(specific || wildcard,
                      "No such variable " + pVariable
                      + " in domain " + boost::lexical_cast<string>(pDomain)
                      + " defined for function " + pName
                      + " in session file.");
 
             // If not specific, must be wildcard
             if (!specific)
             {
                 it2 = it3;
             }
 
             return it2->second.m_type;
         }

enum FunctionType Nektar::LibUtilities::SessionReader::GetFunctionType	(	const std::string &	pName,
		const unsigned int &	pVar,
		const int	pDomain = `0`
	)		const

Returns the type of a given function variable index.

Definition at line 1231 of file SessionReader.cpp.

References ASSERTL0.

         {
             ASSERTL0(pVar < m_variables.size(), "Variable index out of range.");
             return GetFunctionType(pName, m_variables[pVar],pDomain);
         }

const std::string & Nektar::LibUtilities::SessionReader::GetGlobalSysSolnInfo	(	const std::string &	variable,
		const std::string &	property
	)		const

Definition at line 936 of file SessionReader.cpp.

References ASSERTL0, and Nektar::StdRegions::find().

         {
             GloSysSolnInfoList::const_iterator iter;
 
             ASSERTL0( (iter = GetGloSysSolnList().find(pVariable)) !=
                               GetGloSysSolnList().end(),
                       "Failed to find variable in GlobalSysSolnInfoList");
 
             std::string vProperty = boost::to_upper_copy(pProperty);
             GloSysInfoMap::const_iterator iter1;
 
             ASSERTL0( (iter1 = iter->second.find(vProperty)) != iter->second.end(),
                       "Failed to find property: " + vProperty + " in GlobalSysSolnInfoList");
 
             return iter1->second;
         }

GloSysSolnInfoList & Nektar::LibUtilities::SessionReader::GetGloSysSolnList ( )

staticprivate

GlobalSysSoln Info map.

List of values for GlobalSysSoln parameters to be used to override details given in SolverInfo

This list is populated by ReadGlobalSysSoln if the GLOBALSYSSOLNINFO section is defined in the input file. This List allows for details to define for the Global Sys solver for each variable.

Definition at line 156 of file SessionReader.cpp.

         {
             static GloSysSolnInfoList gloSysSolnInfoList;
             return gloSysSolnInfoList;
         }

const NekDouble & Nektar::LibUtilities::SessionReader::GetParameter ( const std::string & pName ) const

Returns the value of the specified parameter.

If the parameter is not defined, termination occurs. Therefore, the parameters existence should be tested for using DefinesParameter before calling this function.

Parameters

pName The name of a floating-point parameter.

Returns: The value of the floating-point parameter.

Definition at line 699 of file SessionReader.cpp.

References ASSERTL0.

         {
             std::string vName = boost::to_upper_copy(pName);
             ParameterMap::const_iterator paramIter = m_parameters.find(vName);
 
             ASSERTL0(paramIter != m_parameters.end(),
                      "Unable to find requested parameter: " + pName);
 
             return paramIter->second;
         }

const std::string & Nektar::LibUtilities::SessionReader::GetSessionName ( ) const

Returns the session name of the loaded XML document.

Definition at line 632 of file SessionReader.cpp.

         {
             return m_sessionName;
         }

const std::string Nektar::LibUtilities::SessionReader::GetSessionNameRank ( ) const

Returns the session name with process rank.

Output is of the form [sessionName]_P[idx] where idx is the rank of the process.

Definition at line 642 of file SessionReader.cpp.

References Nektar::LibUtilities::PortablePath().

         {
             std::string  dirname = m_sessionName + "_xml";
             fs::path     pdirname(dirname);
 
             std::string vFilename = "P" + boost::lexical_cast<std::string>(m_comm->GetRowComm()->GetRank());
             fs::path    pFilename(vFilename);
 
             fs::path fullpath = pdirname / pFilename;
 
             return PortablePath(fullpath);
         }

bool Nektar::LibUtilities::SessionReader::GetSharedFilesystem ( )

Returns the communication object.

Definition at line 663 of file SessionReader.cpp.

         {
             return m_sharedFilesystem;
         }

SessionReaderSharedPtr Nektar::LibUtilities::SessionReader::GetSharedThisPtr ( )

inlineprivate

Returns a shared pointer to the current object.

This allows a member function to pass a shared pointer to itself during a call to another function.

Definition at line 714 of file SessionReader.h.

         {
             return shared_from_this();
         }

const std::string & Nektar::LibUtilities::SessionReader::GetSolverInfo ( const std::string & pProperty ) const

Returns the value of the specified solver info property.

Definition at line 817 of file SessionReader.cpp.

References ASSERTL1.

Referenced by GetSolverInfoAsEnum().

         {
             std::string vProperty = boost::to_upper_copy(pProperty);
             SolverInfoMap::const_iterator iter = m_solverInfo.find(vProperty);
 
             ASSERTL1(iter != m_solverInfo.end(),
                      "Unable to find requested property: " + pProperty);
 
             return iter->second;
         }

template<typename T >

const T Nektar::LibUtilities::SessionReader::GetSolverInfoAsEnum ( const std::string & pName ) const

inline

Returns the value of the specified solver info property as enum.

Definition at line 560 of file SessionReader.h.

References ASSERTL0, DefinesSolverInfo(), Nektar::StdRegions::find(), GetSolverInfo(), GetSolverInfoEnums(), and Nektar::iterator.

         {
             std::string vName = boost::to_upper_copy(pName);
             ASSERTL0(DefinesSolverInfo(vName),
                      "Solver info '" + pName + "' not defined.");
 
             std::string vValue = GetSolverInfo(vName);
             EnumMapList::iterator x;
             ASSERTL0((x = GetSolverInfoEnums().find(vName)) !=
                           GetSolverInfoEnums().end(),
                      "Enum for SolverInfo property '" + pName + "' not found.");
 
             EnumMap::iterator y;
             ASSERTL0((y = x->second.find(vValue)) != x->second.end(),
                      "Value of SolverInfo property '" + pName +
                      "' is invalid.");
 
             return T(y->second);
         }

SolverInfoMap & Nektar::LibUtilities::SessionReader::GetSolverInfoDefaults ( )

staticprivate

Default solver info options.

List of default values for solver information parameters to be used in the case of them not being provided.

This list is populated through the RegisterDefaultSolverInfo static member variable which is called statically from various classes to register the default value for a given parameter.

Definition at line 140 of file SessionReader.cpp.

Referenced by RegisterDefaultSolverInfo().

         {
             static SolverInfoMap solverInfoMap;
             return solverInfoMap;
         }

EnumMapList & Nektar::LibUtilities::SessionReader::GetSolverInfoEnums ( )

staticprivate

String to enumeration map for Solver Info parameters.

This map of maps stores the list of valid string values for a number of solver information parameters. The top level map connects different parameter names to their list of possible values. The list of possible values is also a map, mapping a valid string to a corresponding enum value.

This list is populated through the RegisterEnumValue static member function which is called statically from various classes to register the valid values for solver info parameters associated with them. The map is therefore fully populated before the SessionReader class is instantiated and a file is read in and parsed.

Definition at line 125 of file SessionReader.cpp.

Referenced by GetSolverInfoAsEnum(), GetValueAsEnum(), and RegisterEnumValue().

         {
             static EnumMapList solverInfoEnums;
             return solverInfoEnums;
         }

const std::string & Nektar::LibUtilities::SessionReader::GetTag ( const std::string & pName ) const

Returns the value of a specified tag.

Definition at line 1373 of file SessionReader.cpp.

References ASSERTL0.

         {
             std::string vName = boost::to_upper_copy(pName);
             TagMap::const_iterator vTagIterator = m_tags.find(vName);
             ASSERTL0(vTagIterator != m_tags.end(),
                      "Requested tag does not exist.");
             return vTagIterator->second;
         }

template<typename T >

const T Nektar::LibUtilities::SessionReader::GetValueAsEnum	(	const std::string &	pName,
		const std::string &	vValue
	)		const

inline

Returns the value of the specified property and value as enum.

Definition at line 587 of file SessionReader.h.

References ASSERTL0, Nektar::StdRegions::find(), GetSolverInfoEnums(), and Nektar::iterator.

         {
             std::string vName  = boost::to_upper_copy(pName);
 
             EnumMapList::iterator x;
             ASSERTL0((x = GetSolverInfoEnums().find(vName)) !=
                           GetSolverInfoEnums().end(),
                      "Enum for property '" + pName + "' not found.");
 
             EnumMap::iterator y;
             ASSERTL0((y = x->second.find(pValue)) != x->second.end(),
                      "Value of property '" + pValue + "' is invalid.");
             return T(y->second);
         }

const std::string & Nektar::LibUtilities::SessionReader::GetVariable ( const unsigned int & idx ) const

Returns the name of the variable specified by the given index.

Definition at line 1059 of file SessionReader.cpp.

References ASSERTL0.

         {
             ASSERTL0(idx < m_variables.size(), "Variable index out of range.");
             return m_variables[idx];
         }

std::vector< std::string > Nektar::LibUtilities::SessionReader::GetVariables ( ) const

Returns the names of all variables.

Definition at line 1082 of file SessionReader.cpp.

         {
             return m_variables;
         }

void Nektar::LibUtilities::SessionReader::InitSession ( )

private

Performs the main initialisation of the object. The XML file provided on the command-line is loaded and any mesh partitioning is done. The resulting process-specific XML file (containing the process's geometry partition) is then reloaded and parsed.

Definition at line 269 of file SessionReader.cpp.

References Nektar::iterator.

         {
             m_exprEvaluator.SetRandomSeed((m_comm->GetRank() + 1) * time(NULL));
 
             // Split up the communicator
             PartitionComm();
 
             // Partition mesh
             PartitionMesh();
 
             // Parse the XML data in #m_xmlDoc
             ParseDocument();
 
             // Override SOLVERINFO and parameters with any specified on the
             // command line.
             CmdLineOverride();
 
             // Verify SOLVERINFO values
             VerifySolverInfo();
 
             // In verbose mode, print out parameters and solver info sections
             if (m_verbose && m_comm)
             {
                 if (m_comm->TreatAsRankZero() && m_parameters.size() > 0)
                 {
                     cout << "Parameters:" << endl;
                     ParameterMap::iterator x;
                     for (x = m_parameters.begin(); x != m_parameters.end(); ++x)
                     {
                         cout << "\t" << x->first << " = " << x->second << endl;
                     }
                     cout << endl;
                 }
 
                 if (m_comm->TreatAsRankZero() && m_solverInfo.size() > 0)
                 {
                     cout << "Solver Info:" << endl;
                     SolverInfoMap::iterator x;
                     for (x = m_solverInfo.begin(); x != m_solverInfo.end(); ++x)
                     {
                         cout << "\t" << x->first << " = " << x->second << endl;
                     }
                     cout << endl;
                 }
             }
         }

void Nektar::LibUtilities::SessionReader::LoadDoc	(	const std::string &	pFilename,
		TiXmlDocument *	pDoc
	)		const

private

Loads an xml file into a tinyxml doc and decompresses if needed.

Definition at line 1428 of file SessionReader.cpp.

References ASSERTL0, CellMLToNektar.pycml::copy(), CellMLToNektar.pycml::format, and Nektar::LibUtilities::PortablePath().

         {
             if (pFilename.size() > 3 &&
                 pFilename.substr(pFilename.size() - 3, 3) == ".gz")
             {
                 ifstream file(pFilename.c_str(),
                               ios_base::in | ios_base::binary);
                 ASSERTL0(file.good(), "Unable to open file: " + pFilename);
                 stringstream ss;
                 io::filtering_streambuf<io::input> in;
                 in.push(io::gzip_decompressor());
                 in.push(file);
                 try
                 {
                     io::copy(in, ss);
                     ss >> (*pDoc);
                 }
                 catch (io::gzip_error& e)
                 {
                     ASSERTL0(false,
                              "Error: File '" + pFilename + "' is corrupt.");
                 }
             }
             else if (pFilename.size() > 4 &&
                     pFilename.substr(pFilename.size() - 4, 4) == "_xml")
             {
                 fs::path    pdirname(pFilename);
                 boost::format pad("P%1$07d.xml");
                 pad % m_comm->GetRank();
                 fs::path    pRankFilename(pad.str());
                 fs::path fullpath = pdirname / pRankFilename;
 
                 ifstream file(PortablePath(fullpath).c_str());
                 ASSERTL0(file.good(), "Unable to open file: " + fullpath.string());
                 file >> (*pDoc);
             }
             else
             {
                 ifstream file(pFilename.c_str());
                 ASSERTL0(file.good(), "Unable to open file: " + pFilename);
                 file >> (*pDoc);
             }
         }

void Nektar::LibUtilities::SessionReader::LoadGeometricInfo	(	const std::string &	name,
		std::string &	var,
		const std::string &	def = `""`
	)		const

Checks for and load a geometric info string property.

Definition at line 967 of file SessionReader.cpp.

         {
             std::string vName = boost::to_upper_copy(pName);
             GeometricInfoMap::const_iterator iter = m_geometricInfo.find(vName);
             if(iter != m_geometricInfo.end())
             {
                 pVar = iter->second;
             }
             else
             {
                 pVar = pDefault;
             }
         }

void Nektar::LibUtilities::SessionReader::LoadGeometricInfo	(	const std::string &	name,
		bool &	var,
		const bool &	def = `false`
	)		const

Checks for and loads a geometric info boolean property.

Definition at line 988 of file SessionReader.cpp.

         {
             std::string vName = boost::to_upper_copy(pName);
             GeometricInfoMap::const_iterator iter = m_geometricInfo.find(vName);
             if(iter != m_geometricInfo.end())
             {
                 if (iter->second == "TRUE")
                 {
                     pVar = true;
                 }
                 else
                 {
                     pVar = false;
                 }
             }
             else
             {
                 pVar = pDefault;
             }
         }

void Nektar::LibUtilities::SessionReader::LoadGeometricInfo	(	const std::string &	name,
		NekDouble &	var,
		const NekDouble &	def = `0.0`
	)		const

Checks for and loads a geometric info double-precision property.

Definition at line 1016 of file SessionReader.cpp.

         {
             std::string vName = boost::to_upper_copy(pName);
             GeometricInfoMap::const_iterator iter = m_geometricInfo.find(vName);
             if(iter != m_geometricInfo.end())
             {
                 pVar = std::atoi(iter->second.c_str());
             }
             else
             {
                 pVar = pDefault;
             }
         }

void Nektar::LibUtilities::SessionReader::LoadParameter	(	const std::string &	name,
		int &	var
	)		const

Load an integer parameter.

Definition at line 715 of file SessionReader.cpp.

References ASSERTL0.

         {
             std::string vName = boost::to_upper_copy(pName);
             ParameterMap::const_iterator paramIter = m_parameters.find(vName);
             ASSERTL0(paramIter != m_parameters.end(), "Required parameter '" +
                      pName + "' not specified in session.");
             pVar = (int)round(paramIter->second);
         }

void Nektar::LibUtilities::SessionReader::LoadParameter	(	const std::string &	name,
		int &	var,
		const int &	def
	)		const

Check for and load an integer parameter.

Definition at line 729 of file SessionReader.cpp.

         {
             std::string vName = boost::to_upper_copy(pName);
             ParameterMap::const_iterator paramIter = m_parameters.find(vName);
             if(paramIter != m_parameters.end())
             {
                 pVar = (int)round(paramIter->second);
             }
             else
             {
                 pVar  = pDefault;
             }
         }

void Nektar::LibUtilities::SessionReader::LoadParameter	(	const std::string &	name,
		NekDouble &	var
	)		const

Load a double precision parameter.

Definition at line 748 of file SessionReader.cpp.

References ASSERTL0.

         {
             std::string vName = boost::to_upper_copy(pName);
             ParameterMap::const_iterator paramIter = m_parameters.find(vName);
             ASSERTL0(paramIter != m_parameters.end(), "Required parameter '" +
                      pName + "' not specified in session.");
             pVar = paramIter->second;
         }

void Nektar::LibUtilities::SessionReader::LoadParameter	(	const std::string &	name,
		NekDouble &	var,
		const NekDouble &	def
	)		const

Check for and load a double-precision parameter.

Definition at line 762 of file SessionReader.cpp.

         {
             std::string vName = boost::to_upper_copy(pName);
             ParameterMap::const_iterator paramIter = m_parameters.find(vName);
             if(paramIter != m_parameters.end())
             {
                 pVar = paramIter->second;
             }
             else
             {
                 pVar = pDefault;
             }
         }

void Nektar::LibUtilities::SessionReader::LoadSolverInfo	(	const std::string &	name,
		std::string &	var,
		const std::string &	def = `""`
	)		const

Check for and load a solver info property.

Definition at line 847 of file SessionReader.cpp.

         {
             std::string vName = boost::to_upper_copy(pName);
             SolverInfoMap::const_iterator infoIter = m_solverInfo.find(vName);
             if(infoIter != m_solverInfo.end())
             {
                 pVar = infoIter->second;
             }
             else
             {
                 pVar = pDefault;
             }
         }

void Nektar::LibUtilities::SessionReader::MatchGeometricInfo	(	const std::string &	name,
		const std::string &	trueval,
		bool &	var,
		const bool &	def = `false`
	)		const

Check if the value of a geometric info string property matches.

Definition at line 1037 of file SessionReader.cpp.

         {
             std::string vName = boost::to_upper_copy(pName);
             GeometricInfoMap::const_iterator iter = m_geometricInfo.find(vName);
             if(iter != m_geometricInfo.end())
             {
                 pVar = boost::iequals(iter->second, pTrueVal);
             }
             else
             {
                 pVar  = pDefault;
             }
         }

void Nektar::LibUtilities::SessionReader::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.

Definition at line 868 of file SessionReader.cpp.

         {
             std::string vName = boost::to_upper_copy(pName);
             SolverInfoMap::const_iterator infoIter = m_solverInfo.find(vName);
             if(infoIter != m_solverInfo.end())
             {
                 pVar = boost::iequals(infoIter->second, pTrueVal);
             }
             else
             {
                 pVar = pDefault;
             }
         }

bool Nektar::LibUtilities::SessionReader::MatchSolverInfo	(	const std::string &	name,
		const std::string &	trueval
	)		const

Check if the value of a solver info property matches.

Definition at line 890 of file SessionReader.cpp.

         {
             if (DefinesSolverInfo(pName))
             {
                 std::string vName = boost::to_upper_copy(pName);
                 SolverInfoMap::const_iterator iter = m_solverInfo.find(vName);
                 if(iter != m_solverInfo.end())
                 {
                     return true;
                 }
             }
             return false;
         }

template<typename T >

bool Nektar::LibUtilities::SessionReader::MatchSolverInfoAsEnum	(	const std::string &	name,
		const T &	trueval
	)		const

inline

Check if the value of a solver info property matches.

Definition at line 549 of file SessionReader.h.

         {
             return (GetSolverInfoAsEnum<T>(name) == trueval);
         }

TiXmlDocument * Nektar::LibUtilities::SessionReader::MergeDoc ( const std::vector< std::string > & pFilenames ) const

private

Creates an XML document from a list of input files.

Definition at line 1477 of file SessionReader.cpp.

References ASSERTL0, CellMLToNektar.cellml_metadata::p, and WARNINGL0.

         {
             ASSERTL0(pFilenames.size() > 0, "No filenames for merging.");
 
             // Read the first document
             TiXmlDocument *vMainDoc = new TiXmlDocument;
             LoadDoc(pFilenames[0], vMainDoc);
 
             TiXmlHandle vMainHandle(vMainDoc);
             TiXmlElement* vMainNektar =
                 vMainHandle.FirstChildElement("NEKTAR").Element();
 
             // Read all subsequent XML documents.
             // For each element within the NEKTAR tag, use it to replace the
             // version already present in the loaded XML data.
             for (int i = 1; i < pFilenames.size(); ++i)
             {
                 if((pFilenames[i].compare(pFilenames[i].size()-3,3,"xml") == 0)
                    ||(pFilenames[i].compare(pFilenames[i].size()-6,6,"xml.gz") == 0))
                 {
                     TiXmlDocument* vTempDoc = new TiXmlDocument;
                     LoadDoc(pFilenames[i], vTempDoc);
 
                     TiXmlHandle docHandle(vTempDoc);
                     TiXmlElement* vTempNektar;
                     vTempNektar = docHandle.FirstChildElement("NEKTAR").Element();
                     ASSERTL0(vTempNektar, "Unable to find NEKTAR tag in file.");
                     TiXmlElement* p = vTempNektar->FirstChildElement();
 
                     while (p)
                     {
                         TiXmlElement *vMainEntry =
                             vMainNektar->FirstChildElement(p->Value());
 
                         // First check if the new item is in fact blank
                         if (!p->FirstChild() && vMainEntry)
                         {
                             std::string warningmsg =
                                 "File " + pFilenames[i] + " contains " +
                                 "an empty XML element " +
                                 std::string(p->Value()) +
                                 " which will be ignored.";
                             WARNINGL0(false, warningmsg.c_str());
                         }
                         else
                         {
                             if (vMainEntry)
                             {
                                 vMainNektar->RemoveChild(vMainEntry);
                             }
                             TiXmlElement *q = new TiXmlElement(*p);
                             vMainNektar->LinkEndChild(q);
                         }
                         p = p->NextSiblingElement();
                     }
 
                     delete vTempDoc;
                 }
             }
             return vMainDoc;
         }

std::vector< std::string > Nektar::LibUtilities::SessionReader::ParseCommandLineArguments	(	int	argc,
		char *	argv[]
	)

private

Parse the program arguments and fill m_cmdLineOptions.

Parses the command-line arguments for known options and filenames.

Definition at line 359 of file SessionReader.cpp.

References Nektar::iterator, Nektar::NekConstants::kGitBranch, Nektar::NekConstants::kGitSha1, NEKTAR_VERSION, CellMLToNektar.cellml_metadata::p, and CellMLToNektar.translators::run().

         {
             // List the publically visible options (listed using --help)
             po::options_description desc("Allowed options");
             desc.add_options()
                 ("verbose,v",    "be verbose")
                 ("version,V",    "print version information")
                 ("help,h",       "print this help message")
                 ("solverinfo,I", po::value<vector<std::string> >(),
                                  "override a SOLVERINFO property")
                 ("parameter,P",  po::value<vector<std::string> >(),
                                  "override a parameter")
                 ("npx",          po::value<int>(),
                                  "number of procs in X-dir")
                 ("npy",          po::value<int>(),
                                  "number of procs in Y-dir")
                 ("npz",          po::value<int>(),
                                  "number of procs in Z-dir")
                 ("nsz",          po::value<int>(),
                                  "number of slices in Z-dir")
                 ("part-only",    po::value<int>(),
                                  "only partition mesh into N partitions.")
                 ("part-only-overlapping",    po::value<int>(),
                                  "only partition mesh into N overlapping partitions.")
                 ("part-info",    "Output partition information")
             ;
 
             CmdLineArgMap::const_iterator cmdIt;
             for (cmdIt  = GetCmdLineArgMap().begin();
                  cmdIt != GetCmdLineArgMap().end(); ++cmdIt)
             {
                 std::string names = cmdIt->first;
                 if (cmdIt->second.shortName != "")
                 {
                     names += "," + cmdIt->second.shortName;
                 }
                 if (cmdIt->second.isFlag)
                 {
                     desc.add_options()
                         (names.c_str(), cmdIt->second.description.c_str())
                     ;
                 }
                 else
                 {
                     desc.add_options()
                         (names.c_str(), po::value<std::string>(),
                          cmdIt->second.description.c_str())
                     ;
                 }
             }
 
             // List hidden options (e.g. session file arguments are not actually
             // specified using the input-file option by the user).
             po::options_description hidden("Hidden options");
             hidden.add_options()
                     ("input-file", po::value< vector<string> >(),
                                    "input filename")
             ;
 
             // Combine all options for the parser
             po::options_description all("All options");
             all.add(desc).add(hidden);
 
             // Session file is a positional option
             po::positional_options_description p;
             p.add("input-file", -1);
 
             // Parse the command-line options
             po::parsed_options parsed = po::command_line_parser(argc, argv).
                                                 options(all).
                                                 positional(p).
                                                 allow_unregistered().
                                                 run();
 
             // Extract known options to map and update
             po::store(parsed, m_cmdLineOptions);
             po::notify(m_cmdLineOptions);
 
             // Help message
             if (m_cmdLineOptions.count("help"))
             {
                 cout << desc;
                 exit(0);
             }
 
             // Version information
             if (m_cmdLineOptions.count("version"))
             {
                 cout << "Nektar++ version " << NEKTAR_VERSION;
 
                 if (NekConstants::kGitSha1 != "GITDIR-NOTFOUND")
                 {
                     string sha1(NekConstants::kGitSha1);
                     string branch(NekConstants::kGitBranch);
                     boost::replace_all(branch, "refs/heads/", "");
 
                     cout << " (git changeset " << sha1.substr(0, 8) << ", ";
 
                     if (branch == "")
                     {
                         cout << "detached head";
                     }
                     else
                     {
                         cout << "head " << branch;
                     }
 
                     cout << ")";
                 }
 
                 cout << endl;
                 exit(0);
             }
 
             // Enable verbose mode
             if (m_cmdLineOptions.count("verbose"))
             {
                 m_verbose = true;
             }
             else
             {
                 m_verbose = false;
             }
 
             // Print a warning for unknown options
             std::vector< po::basic_option<char> >::iterator x;
             for (x = parsed.options.begin(); x != parsed.options.end(); ++x)
             {
                 if (x->unregistered)
                 {
                     cout << "Warning: Unknown option: " << x->string_key
                          << endl;
                 }
             }
 
             // Return the vector of filename(s) given as positional options
             if (m_cmdLineOptions.count("input-file"))
             {
                 return m_cmdLineOptions["input-file"].as<
                     std::vector<std::string> >();
             }
             else
             {
                 return std::vector<std::string>();
             }
         }

void Nektar::LibUtilities::SessionReader::ParseDocument ( )

private

Loads and parses the specified file.

Definition at line 1544 of file SessionReader.cpp.

References ASSERTL0.

         {
             // Check we actually have a document loaded.
             ASSERTL0(m_xmlDoc, "No XML document loaded.");
 
             // Look for all data in CONDITIONS block.
             TiXmlHandle docHandle(m_xmlDoc);
             TiXmlElement* e;
             e = docHandle.FirstChildElement("NEKTAR").
                 FirstChildElement("CONDITIONS").Element();
 
             // Read the various sections of the CONDITIONS block
             ReadParameters        (e);
             ReadSolverInfo        (e);
             ReadGlobalSysSolnInfo (e);
             ReadExpressions       (e);
             ReadVariables         (e);
             ReadFunctions         (e);
 
             e = docHandle.FirstChildElement("NEKTAR").
                 FirstChildElement("FILTERS").Element();
 
             ReadFilters(e);
         }

void Nektar::LibUtilities::SessionReader::ParseEquals	(	const std::string &	line,
		std::string &	lhs,
		std::string &	rhs
	)

private

Parse a string in the form lhs = rhs.

Pull out lhs and rhs and eliminate any spaces.

Definition at line 2596 of file SessionReader.cpp.

         {
             /// Pull out lhs and rhs and eliminate any spaces.
             int beg = line.find_first_not_of(" ");
             int end = line.find_first_of("=");
             // Check for no parameter name
             if (beg == end) throw 1;
             // Check for no parameter value
             if (end != line.find_last_of("=")) throw 1;
             // Check for no equals sign
             if (end == std::string::npos) throw 1;
 
             lhs = line.substr(line.find_first_not_of(" "),
                               end-beg);
             lhs = lhs .substr(0, lhs.find_last_not_of(" ")+1);
             rhs = line.substr(line.find_last_of("=")+1);
             rhs = rhs .substr(rhs.find_first_not_of(" "));
             rhs = rhs .substr(0, rhs.find_last_not_of(" ")+1);
         }

std::string Nektar::LibUtilities::SessionReader::ParseSessionName ( std::vector< std::string > & filenames )

private

Parse the session name.

Definition at line 511 of file SessionReader.cpp.

References ASSERTL0.

         {
             ASSERTL0(!filenames.empty(),
                      "At least one filename expected.");
 
             std::string retval = "";
 
             // First input file defines the session name
             std::string fname = filenames[0];
 
             // If loading a pre-partitioned mesh, remove _xml extension
             if (fname.size() > 4 &&
                 fname.substr(fname.size() - 4, 4) == "_xml")
             {
                 retval = fname.substr(0, fname.find_last_of("_"));
             }
             // otherwise remove the .xml extension
             else if (fname.size() > 4 &&
                 fname.substr(fname.size() - 4, 4) == ".xml")
             {
                 retval = fname.substr(0, fname.find_last_of("."));
             }
             // If compressed .xml.gz, remove both extensions
             else if (fname.size() > 7 &&
                 fname.substr(fname.size() - 7, 7) == ".xml.gz")
             {
                 retval = fname.substr(0, fname.find_last_of("."));
                 retval = retval.substr(0, retval.find_last_of("."));
             }
 
             return retval;
         }

void Nektar::LibUtilities::SessionReader::PartitionComm ( )

private

Partitions the comm object based on session parameters.

Splits the processes into a cartesian grid and creates communicators for each row and column of the grid. The grid is defined by the PROC_X parameter which, if specified, gives the number of processes spanned by the Fourier direction. PROC_X must exactly divide the total number of processes or an error is thrown.

Definition at line 1876 of file SessionReader.cpp.

References ASSERTL0.

         {
             if (m_comm->GetSize() > 1)
             {
                 int nProcZ  = 1;
                 int nProcY  = 1;
                 int nProcX  = 1;
                 int nStripZ = 1;
                 if (DefinesCmdLineArgument("npx")) {
                     nProcX = GetCmdLineArgument<int>("npx");
                 }
                 if (DefinesCmdLineArgument("npy")) {
                     nProcY = GetCmdLineArgument<int>("npy");
                 }
                 if (DefinesCmdLineArgument("npz")) {
                     nProcZ = GetCmdLineArgument<int>("npz");
                 }
                 if (DefinesCmdLineArgument("nsz")) {
                     nStripZ = GetCmdLineArgument<int>("nsz");
                 }
                 ASSERTL0(m_comm->GetSize() % (nProcZ*nProcY*nProcX) == 0,
                          "Cannot exactly partition using PROC_Z value.");
                 ASSERTL0(nProcZ % nProcY == 0,
                          "Cannot exactly partition using PROC_Y value.");
                 ASSERTL0(nProcY % nProcX == 0,
                          "Cannot exactly partition using PROC_X value.");
 
                 // Number of processes associated with the spectral method
                 int nProcSm  = nProcZ * nProcY * nProcX;
 
                 // Number of processes associated with the spectral element
                 // method.
                 int nProcSem = m_comm->GetSize() / nProcSm;
 
                 m_comm->SplitComm(nProcSm,nProcSem);
                 m_comm->GetColumnComm()->SplitComm(nProcZ/nStripZ,nStripZ);
                 m_comm->GetColumnComm()->GetColumnComm()->SplitComm(
                                             (nProcY*nProcX),nProcZ/nStripZ);
                 m_comm->GetColumnComm()->GetColumnComm()->GetColumnComm()
                                             ->SplitComm(nProcX,nProcY);
             }
         }

void Nektar::LibUtilities::SessionReader::PartitionMesh ( )

private

Partitions the mesh when running in parallel.

Definition at line 1597 of file SessionReader.cpp.

References ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, >::CreateInstance(), Gs::Finalise(), CellMLToNektar.pycml::format, Nektar::LibUtilities::GetMeshPartitionFactory(), Nektar::StdRegions::GetSize(), Nektar::iterator, and Nektar::LibUtilities::PortablePath().

         {
             ASSERTL0(m_comm.get(), "Communication not initialised.");
 
             // Get row of comm, or the whole comm if not split
             CommSharedPtr vCommMesh = m_comm->GetRowComm();
             const bool isRoot = m_comm->TreatAsRankZero();
 
             // Delete any existing loaded mesh
             if (m_xmlDoc)
             {
                 delete m_xmlDoc;
             }
 
             // Load file for root process only (since this is always needed)
             // and determine if the provided geometry has already been
             // partitioned. This will be the case if the user provides the
             // directory of mesh partitions as an input. Partitioned geometries
             // have the attribute
             //    PARTITION=X
             // where X is the number of the partition (and should match the
             // process rank). The result is shared with all other processes.
             int isPartitioned = 0;
             if (isRoot)
             {
                 m_xmlDoc = MergeDoc(m_filenames);
                 if (DefinesElement("Nektar/Geometry"))
                 {
                     if (GetElement("Nektar/Geometry")->Attribute("PARTITION"))
                     {
                         cout << "Using pre-partitioned mesh." << endl;
                         isPartitioned = 1;
                     }
                 }
             }
             GetComm()->Bcast(isPartitioned, 0);
 
             // If the mesh is already partitioned, we are done. Remaining
             // processes must load their partitions.
             if (isPartitioned)
             {
                 if (!isRoot)
                 {
                     m_xmlDoc = MergeDoc(m_filenames);
                 }
                 return;
             }
 
             // Default partitioner to use is Metis. Use Scotch as default
             // if it is installed. Override default with command-line flags
             // if they are set.
             string vPartitionerName = "Metis";
             if (GetMeshPartitionFactory().ModuleExists("Scotch"))
             {
                 vPartitionerName = "Scotch";
             }
             if (DefinesCmdLineArgument("use-metis"))
             {
                 vPartitionerName = "Metis";
             }
             if (DefinesCmdLineArgument("use-scotch"))
             {
                 vPartitionerName = "Scotch";
             }
 
             // Mesh has not been partitioned so do partitioning if required.
             // Note in the serial case nothing is done as we have already loaded
             // the mesh.
             if (DefinesCmdLineArgument("part-only")||
                 DefinesCmdLineArgument("part-only-overlapping"))
             {
                 // Perform partitioning of the mesh only. For this we insist
                 // the code is run in serial (parallel execution is pointless).
                 ASSERTL0(GetComm()->GetSize() == 1,
                         "The 'part-only' option should be used in serial.");
 
                 // Number of partitions is specified by the parameter.
                 int nParts; 
                 SessionReaderSharedPtr vSession     = GetSharedThisPtr();
                 MeshPartitionSharedPtr vPartitioner =
                         GetMeshPartitionFactory().CreateInstance(
                                             vPartitionerName, vSession);
                 if(DefinesCmdLineArgument("part-only"))
                 {
                     nParts = GetCmdLineArgument<int>("part-only");
                     vPartitioner->PartitionMesh(nParts, true);
                 }
                 else  
                 {
                     nParts = GetCmdLineArgument<int>("part-only-overlapping");
                     vPartitioner->PartitionMesh(nParts, true, true);
                 }
                 vPartitioner->WriteAllPartitions(vSession);
                 vPartitioner->GetCompositeOrdering(m_compOrder);
                 vPartitioner->GetBndRegionOrdering(m_bndRegOrder);
 
                 if (isRoot && DefinesCmdLineArgument("part-info"))
                 {
                     vPartitioner->PrintPartInfo(std::cout);
                 }
 
                 Finalise();
                 exit(0);
             }
             else if (vCommMesh->GetSize() > 1)
             {
                 SessionReaderSharedPtr vSession     = GetSharedThisPtr();
                 int nParts = vCommMesh->GetSize();
                 if (m_sharedFilesystem)
                 {
                     CommSharedPtr vComm = GetComm();
                     vector<unsigned int> keys, vals;
                     int i;
 
                     if (isRoot)
                     {
                         m_xmlDoc = MergeDoc(m_filenames);
 
                         MeshPartitionSharedPtr vPartitioner =
                                 GetMeshPartitionFactory().CreateInstance(
                                                     vPartitionerName, vSession);
                         vPartitioner->PartitionMesh(nParts, true);
                         vPartitioner->WriteAllPartitions(vSession);
                         vPartitioner->GetCompositeOrdering(m_compOrder);
                         vPartitioner->GetBndRegionOrdering(m_bndRegOrder);
 
                         // Communicate orderings to the other processors.
 
                         // First send sizes of the orderings and boundary
                         // regions to allocate storage on the remote end.
                         keys.resize(2);
                         keys[0] = m_compOrder.size();
                         keys[1] = m_bndRegOrder.size();
                         vComm->Bcast(keys, 0);
 
                         // Construct the keys and sizes of values for composite
                         // ordering
                         CompositeOrdering::iterator cIt;
                         keys.resize(m_compOrder.size());
                         vals.resize(m_compOrder.size());
 
                         for (cIt  = m_compOrder.begin(), i = 0;
                              cIt != m_compOrder.end(); ++cIt, ++i)
                         {
                             keys[i] = cIt->first;
                             vals[i] = cIt->second.size();
                         }
 
                         // Send across data.
                         vComm->Bcast(keys, 0);
                         vComm->Bcast(vals, 0);
                         for (cIt  = m_compOrder.begin();
                                 cIt != m_compOrder.end(); ++cIt)
                         {
                             vComm->Bcast(cIt->second, 0);
                         }
 
                         // Construct the keys and sizes of values for composite
                         // ordering
                         BndRegionOrdering::iterator bIt;
                         keys.resize(m_bndRegOrder.size());
                         vals.resize(m_bndRegOrder.size());
 
                         for (bIt  = m_bndRegOrder.begin(), i = 0;
                              bIt != m_bndRegOrder.end(); ++bIt, ++i)
                         {
                             keys[i] = bIt->first;
                             vals[i] = bIt->second.size();
                         }
 
                         // Send across data.
                         vComm->Bcast(keys, 0);
                         vComm->Bcast(vals, 0);
                         for (bIt  = m_bndRegOrder.begin();
                                 bIt != m_bndRegOrder.end(); ++bIt)
                         {
                             vComm->Bcast(bIt->second, 0);
                         }
 
                         if (DefinesCmdLineArgument("part-info"))
                         {
                             vPartitioner->PrintPartInfo(std::cout);
                         }
                     }
                     else
                     {
                         keys.resize(2);
                         vComm->Bcast(keys, 0);
 
                         int cmpSize = keys[0];
                         int bndSize = keys[1];
 
                         keys.resize(cmpSize);
                         vals.resize(cmpSize);
                         vComm->Bcast(keys, 0);
                         vComm->Bcast(vals, 0);
 
                         for (int i = 0; i < keys.size(); ++i)
                         {
                             vector<unsigned int> tmp(vals[i]);
                             vComm->Bcast(tmp, 0);
                             m_compOrder[keys[i]] = tmp;
                         }
 
                         keys.resize(bndSize);
                         vals.resize(bndSize);
                         vComm->Bcast(keys, 0);
                         vComm->Bcast(vals, 0);
 
                         for (int i = 0; i < keys.size(); ++i)
                         {
                             vector<unsigned int> tmp(vals[i]);
                             vComm->Bcast(tmp, 0);
                             m_bndRegOrder[keys[i]] = tmp;
                         }
                     }
                 }
                 else
                 {
                     // Need to load mesh on non-root processes.
                     if (!isRoot)
                     {
                         m_xmlDoc = MergeDoc(m_filenames);
                     }
 
                     // Partitioner now operates in parallel
                     // Each process receives partitioning over interconnect
                     // and writes its own session file to the working directory.
                     MeshPartitionSharedPtr vPartitioner =
                                 GetMeshPartitionFactory().CreateInstance(
                                                     vPartitionerName, vSession);
                     vPartitioner->PartitionMesh(nParts, false);
                     vPartitioner->WriteLocalPartition(vSession);
                     vPartitioner->GetCompositeOrdering(m_compOrder);
                     vPartitioner->GetBndRegionOrdering(m_bndRegOrder);
 
                     if (DefinesCmdLineArgument("part-info") && isRoot)
                     {
                         vPartitioner->PrintPartInfo(std::cout);
                     }
                 }
                 m_comm->Block();
 
                 std::string  dirname = GetSessionName() + "_xml";
                 fs::path    pdirname(dirname);
                 boost::format pad("P%1$07d.xml");
                 pad % m_comm->GetRowComm()->GetRank();
                 fs::path    pFilename(pad.str());
                 fs::path fullpath = pdirname / pFilename;
 
                 std::string vFilename = PortablePath(fullpath);
 
                 if (m_xmlDoc)
                 {
                     delete m_xmlDoc;
                 }
                 m_xmlDoc = new TiXmlDocument(vFilename);
 
                 ASSERTL0(m_xmlDoc, "Failed to create XML document object.");
 
                 bool loadOkay = m_xmlDoc->LoadFile(vFilename);
                 ASSERTL0(loadOkay, "Unable to load file: " + vFilename       +
                          ". Check XML standards compliance. Error on line: " +
                          boost::lexical_cast<std::string>(m_xmlDoc->Row()));
             }
             else
             {
                 m_xmlDoc = MergeDoc(m_filenames);
             }
         }

void Nektar::LibUtilities::SessionReader::ReadExpressions ( TiXmlElement * conditions )

private

Reads the EXPRESSIONS section of the XML document.

Definition at line 2217 of file SessionReader.cpp.

References ASSERTL0, and Nektar::iterator.

         {
             m_expressions.clear();
 
             if (!conditions)
             {
                 return;
             }
 
             TiXmlElement *expressionsElement =
                 conditions->FirstChildElement("EXPRESSIONS");
 
             if (expressionsElement)
             {
                 TiXmlElement *expr = expressionsElement->FirstChildElement("E");
 
                 while (expr)
                 {
                     stringstream tagcontent;
                     tagcontent << *expr;
                     ASSERTL0(expr->Attribute("NAME"),
                              "Missing NAME attribute in expression "
                              "definition: \n\t'" + tagcontent.str() + "'");
                     std::string nameString = expr->Attribute("NAME");
                     ASSERTL0(!nameString.empty(),
                              "Expressions must have a non-empty name: \n\t'"
                              + tagcontent.str() + "'");
 
                     ASSERTL0(expr->Attribute("VALUE"),
                              "Missing VALUE attribute in expression "
                              "definition: \n\t'" + tagcontent.str() + "'");
                     std::string valString = expr->Attribute("VALUE");
                     ASSERTL0(!valString.empty(),
                              "Expressions must have a non-empty value: \n\t'"
                             + tagcontent.str() + "'");
 
                     ExpressionMap::iterator exprIter
                                             = m_expressions.find(nameString);
                     ASSERTL0(exprIter == m_expressions.end(),
                              std::string("Expression '") + nameString
                              + std::string("' already specified."));
 
                     m_expressions[nameString] = valString;
                     expr = expr->NextSiblingElement("E");
                 }
             }
         }

void Nektar::LibUtilities::SessionReader::ReadFilters ( TiXmlElement * filters )

private

Reads the FILTERS section of the XML document.

Definition at line 2555 of file SessionReader.cpp.

References ASSERTL0.

         {
             if (!filters)
             {
                 return;
             }
 
             m_filters.clear();
 
             TiXmlElement *filter = filters->FirstChildElement("FILTER");
             while (filter)
             {
                 ASSERTL0(filter->Attribute("TYPE"),
                         "Missing attribute 'TYPE' for filter.");
                 std::string typeStr = filter->Attribute("TYPE");
 
                 std::map<std::string, std::string> vParams;
 
                 TiXmlElement *param = filter->FirstChildElement("PARAM");
                 while (param)
                 {
                     ASSERTL0(param->Attribute("NAME"),
                             "Missing attribute 'NAME' for parameter in filter "
                             + typeStr + "'.");
                     std::string nameStr = param->Attribute("NAME");
 
                     ASSERTL0(param->GetText(), "Empty value string for param.");
                     std::string valueStr = param->GetText();
 
                     vParams[nameStr] = valueStr;
 
                     param = param->NextSiblingElement("PARAM");
                 }
 
                 m_filters.push_back(
                     std::pair<std::string, FilterParams>(typeStr, vParams));
 
                 filter = filter->NextSiblingElement("FILTER");
             }
         }

void Nektar::LibUtilities::SessionReader::ReadFunctions ( TiXmlElement * conditions )

private

Reads the FUNCTIONS section of the XML document.

Definition at line 2352 of file SessionReader.cpp.

References ASSERTL0, Nektar::LibUtilities::eFunctionTypeExpression, Nektar::LibUtilities::eFunctionTypeFile, Nektar::LibUtilities::eFunctionTypeTransientFile, Nektar::iterator, Nektar::LibUtilities::FunctionVariableDefinition::m_expression, Nektar::LibUtilities::FunctionVariableDefinition::m_filename, Nektar::LibUtilities::FunctionVariableDefinition::m_fileVariable, and Nektar::LibUtilities::FunctionVariableDefinition::m_type.

         {
             m_functions.clear();
 
             if (!conditions)
             {
                 return;
             }
 
             // Scan through conditions section looking for functions.
             TiXmlElement *function = conditions->FirstChildElement("FUNCTION");
             while (function)
             {
                 stringstream tagcontent;
                 tagcontent << *function;
 
                 // Every function must have a NAME attribute
                 ASSERTL0(function->Attribute("NAME"),
                          "Functions must have a NAME attribute defined in XML "
                          "element: \n\t'" + tagcontent.str() + "'");
                 std::string functionStr = function->Attribute("NAME");
                 ASSERTL0(!functionStr.empty(),
                          "Functions must have a non-empty name in XML "
                          "element: \n\t'" + tagcontent.str() + "'");
 
                 // Store function names in uppercase to remain case-insensitive.
                 boost::to_upper(functionStr);
 
                 // Retrieve first entry (variable, or file)
                 TiXmlElement *variable  = function->FirstChildElement();
 
                 // Create new function structure with default type of none.
                 FunctionVariableMap functionVarMap;
 
                 // Process all entries in the function block
                 while (variable)
                 {
                     FunctionVariableDefinition funcDef;
                     std::string conditionType = variable->Value();
 
                     // If no var is specified, assume wildcard
                     std::string variableStr;
                     if (!variable->Attribute("VAR"))
                     {
                         variableStr = "*";
                     }
                     else
                     {
                         variableStr = variable->Attribute("VAR");
                     }
 
                     // Parse list of variables
                     std::vector<std::string> variableList;
                     ParseUtils::GenerateOrderedStringVector(variableStr.c_str(),
                                                             variableList);
 
                     // If no domain string put to 0
                     std::string domainStr;
                     if (!variable->Attribute("DOMAIN"))
                     {
                         domainStr = "0";
                     }
                     else
                     {
                         domainStr = variable->Attribute("DOMAIN");
                     }
 
                     // Parse list of variables
                     std::vector<std::string> varSplit;
                     std::vector<unsigned int> domainList;
                     ParseUtils::GenerateSeqVector(domainStr.c_str(), domainList);
 
                     // Expressions are denoted by E
                     if (conditionType == "E")
                     {
                         funcDef.m_type = eFunctionTypeExpression;
 
                         // Expression must have a VALUE.
                         ASSERTL0(variable->Attribute("VALUE"),
                                  "Attribute VALUE expected for function '"
                                  + functionStr + "'.");
                         std::string fcnStr = variable->Attribute("VALUE");
 
                         ASSERTL0(!fcnStr.empty(),
                                  (std::string("Expression for var: ")
                                  + variableStr
                                  + std::string(" must be specified.")).c_str());
 
                         SubstituteExpressions(fcnStr);
 
                         // set expression
                         funcDef.m_expression = MemoryManager<Equation>
                             ::AllocateSharedPtr(GetSharedThisPtr(),fcnStr);
                     }
 
                     // Files are denoted by F
                     else if (conditionType == "F")
                     {
                         if (variable->Attribute("TIMEDEPENDENT") &&
                             boost::lexical_cast<bool>(variable->Attribute("TIMEDEPENDENT")))
                         {
                             funcDef.m_type = eFunctionTypeTransientFile;
                         }
                         else
                         {
                             funcDef.m_type = eFunctionTypeFile;
                         }
 
                         // File must have a FILE.
                         ASSERTL0(variable->Attribute("FILE"),
                                  "Attribute FILE expected for function '"
                                  + functionStr + "'.");
                         std::string filenameStr = variable->Attribute("FILE");
 
                         ASSERTL0(!filenameStr.empty(),
                                  "A filename must be specified for the FILE "
                                  "attribute of function '" + functionStr
                                  + "'.");
 
                         std::vector<std::string> fSplit;
                         boost::split(fSplit, filenameStr, boost::is_any_of(":"));
 
                         ASSERTL0(fSplit.size() == 1 || fSplit.size() == 2,
                                  "Incorrect filename specification in function "
                                  + functionStr + "'. "
                                  "Specify variables inside file as: "
                                  "filename:var1,var2");
 
                         // set the filename
                         funcDef.m_filename = fSplit[0];
 
                         if (fSplit.size() == 2)
                         {
                             ASSERTL0(variableList[0] != "*",
                                      "Filename variable mapping not valid "
                                      "when using * as a variable inside "
                                      "function '" + functionStr + "'.");
 
                             boost::split(
                                 varSplit, fSplit[1], boost::is_any_of(","));
                             ASSERTL0(varSplit.size() == variableList.size(),
                                      "Filename variables should contain the "
                                      "same number of variables defined in "
                                      "VAR in function " + functionStr + "'.");
                         }
                     }
 
                     // Nothing else supported so throw an error
                     else
                     {
                         stringstream tagcontent;
                         tagcontent << *variable;
 
                         ASSERTL0(false,
                                 "Identifier " + conditionType + " in function "
                                 + std::string(function->Attribute("NAME"))
                                 + " is not recognised in XML element: \n\t'"
                                 + tagcontent.str() + "'");
                     }
 
 
 
                     // Add variables to function
                     for (unsigned int i = 0; i < variableList.size(); ++i)
                     {
                         for(unsigned int j = 0; j < domainList.size(); ++j)
                         {
                             // Check it has not already been defined
                             pair<std::string,int> key(variableList[i],domainList[j]);
                             FunctionVariableMap::iterator fcnsIter
                                 = functionVarMap.find(key);
                             ASSERTL0(fcnsIter == functionVarMap.end(),
                                      "Error setting expression '" + variableList[i]
                                      + " in domain "
                                      + boost::lexical_cast<std::string>(domainList[j])
                                      + "' in function '" + functionStr + "'. "
                                      "Expression has already been defined.");
 
                             if (varSplit.size() > 0)
                             {
                                 FunctionVariableDefinition funcDef2 = funcDef;
                                 funcDef2.m_fileVariable = varSplit[i];
                                 functionVarMap[key] = funcDef2;
                             }
                             else
                             {
                                 functionVarMap[key] = funcDef;
                             }
                         }
                     }
 
                     variable = variable->NextSiblingElement();
                 }
                 // Add function definition to map
                 m_functions[functionStr] = functionVarMap;
                 function = function->NextSiblingElement("FUNCTION");
             }
         }

void Nektar::LibUtilities::SessionReader::ReadGlobalSysSolnInfo ( TiXmlElement * conditions )

private

Reads the GLOBALSYSSOLNINFO section of the XML document.

Definition at line 2083 of file SessionReader.cpp.

References ASSERTL0, Nektar::StdRegions::find(), and Nektar::iterator.

         {
             GetGloSysSolnList().clear();
 
             if (!conditions)
             {
                 return;
             }
 
             TiXmlElement *GlobalSys =
                             conditions->FirstChildElement("GLOBALSYSSOLNINFO");
 
             if(!GlobalSys)
             {
                 return;
             }
 
             TiXmlElement *VarInfo   = GlobalSys->FirstChildElement("V");
 
             while (VarInfo)
             {
                 std::stringstream tagcontent;
                 tagcontent << *VarInfo;
                 ASSERTL0(VarInfo->Attribute("VAR"),
                          "Missing VAR attribute in GobalSysSolnInfo XML "
                          "element: \n\t'" + tagcontent.str() + "'");
 
                 std::string VarList = VarInfo->Attribute("VAR");
                 ASSERTL0(!VarList.empty(),
                          "VAR attribute must be non-empty in XML element:\n\t'"
                          + tagcontent.str() + "'");
 
                 // generate a list of variables.
                 std::vector<std::string> varStrings;
                 bool valid = ParseUtils::GenerateOrderedStringVector(
                                                 VarList.c_str(),varStrings);
 
                 ASSERTL0(valid,"Unable to process list of variable in XML "
                                "element \n\t'" + tagcontent.str() + "'");
 
                 if(varStrings.size())
                 {
                     TiXmlElement *SysSolnInfo = VarInfo->FirstChildElement("I");
 
                     while (SysSolnInfo)
                     {
                         tagcontent.clear();
                         tagcontent << *SysSolnInfo;
                         // read the property name
                         ASSERTL0(SysSolnInfo->Attribute("PROPERTY"),
                                  "Missing PROPERTY attribute in "
                                  "GlobalSysSolnInfo for variable(s) '"
                                  + VarList + "' in XML element: \n\t'"
                                  + tagcontent.str() + "'");
 
                         std::string SysSolnProperty =
                             SysSolnInfo->Attribute("PROPERTY");
 
                         ASSERTL0(!SysSolnProperty.empty(),
                                  "GlobalSysSolnIno properties must have a "
                                  "non-empty name for variable(s) : '"
                                  + VarList + "' in XML element: \n\t'"
                                  + tagcontent.str() + "'");
 
                         // make sure that solver property is capitalised
                         std::string SysSolnPropertyUpper =
                                         boost::to_upper_copy(SysSolnProperty);
 
                         // read the value
                         ASSERTL0(SysSolnInfo->Attribute("VALUE"),
                                  "Missing VALUE attribute in GlobalSysSolnInfo "
                                  "for variable(s) '" + VarList
                                  + "' in XML element: \n\t"
                                  + tagcontent.str() + "'");
 
                         std::string SysSolnValue =
                                             SysSolnInfo->Attribute("VALUE");
                         ASSERTL0(!SysSolnValue.empty(),
                                  "GlobalSysSolnInfo properties must have a "
                                  "non-empty value for variable(s) '"
                                  + VarList + "' in XML element: \n\t'"
                                  + tagcontent.str() + "'");
 
                         // Store values under variable map.
                         for(int i = 0; i < varStrings.size(); ++i)
                         {
                             GloSysSolnInfoList::iterator x;
                             if ((x = GetGloSysSolnList().find(varStrings[i])) ==
                                     GetGloSysSolnList().end())
                             {
                                 (GetGloSysSolnList()[varStrings[i]])[
                                         SysSolnPropertyUpper] = SysSolnValue;
                             }
                             else
                             {
                                 x->second[SysSolnPropertyUpper] = SysSolnValue;
                             }
                         }
 
                         SysSolnInfo = SysSolnInfo->NextSiblingElement("I");
                     }
                     VarInfo = VarInfo->NextSiblingElement("V");
                 }
             }
 
             if (m_verbose && GetGloSysSolnList().size() > 0 && m_comm)
             {
                 if(m_comm->GetRank() == 0)
                 {
                     cout << "GlobalSysSoln Info:" << endl;
 
                     GloSysSolnInfoList::iterator x;
                     for (x = GetGloSysSolnList().begin();
                          x != GetGloSysSolnList().end();
                          ++x)
                     {
                         cout << "\t Variable: " << x->first <<  endl;
 
                         GloSysInfoMap::iterator y;
                         for (y = x->second.begin(); y != x->second.end(); ++y)
                         {
                             cout << "\t\t " << y->first  << " = " << y->second
                                  << endl;
                         }
                     }
                     cout << endl;
                 }
             }
         }

void Nektar::LibUtilities::SessionReader::ReadParameters ( TiXmlElement * conditions )

private

Reads the PARAMETERS section of the XML document.

Definition at line 1923 of file SessionReader.cpp.

References ASSERTL0, Nektar::LibUtilities::Equation::Evaluate(), and Nektar::lhs.

         {
             m_parameters.clear();
 
             if (!conditions)
             {
                 return;
             }
 
             TiXmlElement *parametersElement = conditions->FirstChildElement(
                 "PARAMETERS");
 
             // See if we have parameters defined.  They are optional so we go on
             // if not.
             if (parametersElement)
             {
                 TiXmlElement *parameter =
                     parametersElement->FirstChildElement("P");
 
                 ParameterMap caseSensitiveParameters;
 
                 // Multiple nodes will only occur if there is a comment in
                 // between definitions.
                 while (parameter)
                 {
                     stringstream tagcontent;
                     tagcontent << *parameter;
                     TiXmlNode *node = parameter->FirstChild();
 
                     while (node && node->Type() != TiXmlNode::TINYXML_TEXT)
                     {
                         node = node->NextSibling();
                     }
 
                     if (node)
                     {
                         // Format is "paramName = value"
                         std::string line = node->ToText()->Value(), lhs, rhs;
 
                         try {
                             ParseEquals(line, lhs, rhs);
                         }
                         catch (...)
                         {
                             ASSERTL0(false, "Syntax error in parameter "
                                      "expression '" + line
                                      + "' in XML element: \n\t'"
                                      + tagcontent.str() + "'");
                         }
 
                         // We want the list of parameters to have their RHS
                         // evaluated, so we use the expression evaluator to do
                         // the dirty work.
                         if (!lhs.empty() && !rhs.empty())
                         {
                             NekDouble value=0.0;
                             try
                             {
                                 LibUtilities::Equation expession(
                                     GetSharedThisPtr(), rhs);
                                 value = expession.Evaluate();
                             }
                             catch (const std::runtime_error &)
                             {
                                 ASSERTL0(false,
                                          "Error evaluating parameter expression"
                                          " '" + rhs + "' in XML element: \n\t'"
                                          + tagcontent.str() + "'");
                             }
                             m_exprEvaluator.SetParameter(lhs, value);
                             caseSensitiveParameters[lhs] = value;
                             boost::to_upper(lhs);
                             m_parameters[lhs] = value;
                         }
                     }
 
                     parameter = parameter->NextSiblingElement();
                 }
             }
         }

void Nektar::LibUtilities::SessionReader::ReadSolverInfo ( TiXmlElement * conditions )

private

Reads the SOLVERINFO section of the XML document.

Definition at line 2008 of file SessionReader.cpp.

References ASSERTL0.

         {
             m_solverInfo.clear();
             m_solverInfo = GetSolverInfoDefaults();
 
             if (!conditions)
             {
                 return;
             }
 
             TiXmlElement *solverInfoElement =
                 conditions->FirstChildElement("SOLVERINFO");
 
             if (solverInfoElement)
             {
                 TiXmlElement *solverInfo =
                     solverInfoElement->FirstChildElement("I");
 
                 while (solverInfo)
                 {
                     std::stringstream tagcontent;
                     tagcontent << *solverInfo;
                     // read the property name
                     ASSERTL0(solverInfo->Attribute("PROPERTY"),
                              "Missing PROPERTY attribute in solver info "
                              "XML element: \n\t'" + tagcontent.str() + "'");
                     std::string solverProperty =
                         solverInfo->Attribute("PROPERTY");
                     ASSERTL0(!solverProperty.empty(),
                              "PROPERTY attribute must be non-empty in XML "
                              "element: \n\t'" + tagcontent.str() + "'");
 
                     // make sure that solver property is capitalised
                     std::string solverPropertyUpper =
                         boost::to_upper_copy(solverProperty);
 
                     // read the value
                     ASSERTL0(solverInfo->Attribute("VALUE"),
                             "Missing VALUE attribute in solver info "
                             "XML element: \n\t'" + tagcontent.str() + "'");
                     std::string solverValue    = solverInfo->Attribute("VALUE");
                     ASSERTL0(!solverValue.empty(),
                              "VALUE attribute must be non-empty in XML "
                              "element: \n\t'" + tagcontent.str() + "'");
 
                     // Set Variable
                     m_solverInfo[solverPropertyUpper] = solverValue;
                     solverInfo = solverInfo->NextSiblingElement("I");
                 }
             }
 
             if (m_comm && m_comm->GetRowComm()->GetSize() > 1)
             {
                 ASSERTL0(
                     m_solverInfo["GLOBALSYSSOLN"] == "IterativeFull"       ||
                     m_solverInfo["GLOBALSYSSOLN"] == "IterativeStaticCond" ||
                     m_solverInfo["GLOBALSYSSOLN"] ==
                         "IterativeMultiLevelStaticCond"                    ||
                     m_solverInfo["GLOBALSYSSOLN"] == "XxtFull"             ||
                     m_solverInfo["GLOBALSYSSOLN"] == "XxtStaticCond"       ||
                     m_solverInfo["GLOBALSYSSOLN"] ==
                         "XxtMultiLevelStaticCond"                          ||
                     m_solverInfo["GLOBALSYSSOLN"] == "PETScFull"           ||
                     m_solverInfo["GLOBALSYSSOLN"] == "PETScStaticCond"     ||
                     m_solverInfo["GLOBALSYSSOLN"] ==
                         "PETScMultiLevelStaticCond",
                     "A parallel solver must be used when run in parallel.");
             }
         }

void Nektar::LibUtilities::SessionReader::ReadVariables ( TiXmlElement * conditions )

private

Reads the VARIABLES section of the XML document.

All elements are of the form: "<V ID="#"> name = value </V>", with ? being the element type.

Definition at line 2269 of file SessionReader.cpp.

References ASSERTL0, and Nektar::StdRegions::find().

         {
             m_variables.clear();
 
             if (!conditions)
             {
                 return;
             }
 
             TiXmlElement *variablesElement =
                 conditions->FirstChildElement("VARIABLES");
 
             // See if we have parameters defined. They are optional so we go on
             // if not.
             if (variablesElement)
             {
                 TiXmlElement *varElement =
                     variablesElement->FirstChildElement("V");
 
                 // Sequential counter for the composite numbers.
                 int nextVariableNumber = -1;
 
                 while (varElement)
                 {
                     stringstream tagcontent;
                     tagcontent << *varElement;
 
                     /// All elements are of the form: "<V ID="#"> name = value
                     /// </V>", with ? being the element type.
                     nextVariableNumber++;
 
                     int i;
                     int err = varElement->QueryIntAttribute("ID", &i);
                     ASSERTL0(err == TIXML_SUCCESS,
                              "Variables must have a unique ID number attribute "
                              "in XML element: \n\t'" + tagcontent.str() + "'");
                     ASSERTL0(i == nextVariableNumber,
                              "ID numbers for variables must begin with zero and"
                              " be sequential in XML element: \n\t'"
                              + tagcontent.str() + "'");
 
                     TiXmlNode* varChild = varElement->FirstChild();
                     // This is primarily to skip comments that may be present.
                     // Comments appear as nodes just like elements.  We are
                     // specifically looking for text in the body of the
                     // definition.
                     while(varChild && varChild->Type() != TiXmlNode::TINYXML_TEXT)
                     {
                         varChild = varChild->NextSibling();
                     }
 
                     ASSERTL0(varChild,
                              "Unable to read variable definition body for "
                              "variable with ID "
                              + boost::lexical_cast<string>(i)
                              + " in XML element: \n\t'"
                              + tagcontent.str() + "'");
                     std::string variableName = varChild->ToText()->ValueStr();
 
                     std::istringstream variableStrm(variableName);
                     variableStrm >> variableName;
 
                     ASSERTL0(std::find(m_variables.begin(), m_variables.end(),
                                        variableName) == m_variables.end(),
                              "Variable with ID "
                              + boost::lexical_cast<string>(i)
                              + " in XML element \n\t'" + tagcontent.str()
                              + "'\nhas already been defined.");
 
                     m_variables.push_back(variableName);
 
                     varElement = varElement->NextSiblingElement("V");
                 }
 
                 ASSERTL0(nextVariableNumber > -1,
                          "Number of variables must be greater than zero.");
             }
         }

std::string Nektar::LibUtilities::SessionReader::RegisterCmdLineArgument	(	const std::string &	pName,
		const std::string &	pShortName,
		const std::string &	pDescription
	)

inlinestatic

Registers a command-line argument with the session reader.

Definition at line 677 of file SessionReader.h.

References ASSERTL0, GetCmdLineArgMap(), and Nektar::LibUtilities::CmdLineArg::shortName.

         {
             ASSERTL0(!pName.empty(), "Empty name for cmdline argument.");
             CmdLineArg x;
             x.shortName = pShortName;
             x.description = pDescription;
             x.isFlag = false;
             GetCmdLineArgMap()[pName] = x;
             return pName;
         }

std::string Nektar::LibUtilities::SessionReader::RegisterCmdLineFlag	(	const std::string &	pName,
		const std::string &	pShortName,
		const std::string &	pDescription
	)

inlinestatic

Registers a command-line flag with the session reader.

Definition at line 695 of file SessionReader.h.

References ASSERTL0, GetCmdLineArgMap(), and Nektar::LibUtilities::CmdLineArg::shortName.

         {
             ASSERTL0(!pName.empty(), "Empty name for cmdline argument.");
             CmdLineArg x;
             x.shortName = pShortName;
             x.description = pDescription;
             x.isFlag = true;
             GetCmdLineArgMap()[pName] = x;
             return pName;
         }

std::string Nektar::LibUtilities::SessionReader::RegisterDefaultSolverInfo	(	const std::string &	pName,
		const std::string &	pValue
	)

inlinestatic

Registers the default string value of a solver info property.

A default value for a given solver info property may be registered using this function. The property will take this value until it is overwritten by a value specified in the XML document, or specified as a command-line argument. Usage has the form:

std::string GlobalLinSys::def
    = LibUtilities::SessionReader::RegisterDefaultSolverInfo(
        "GlobalSysSoln","DirectMultiLevelStaticCond");

Parameters

pName	The name of the property.
pValue	The default value of the property.

Returns: The default value of the property provided by #pValue.

Definition at line 664 of file SessionReader.h.

References GetSolverInfoDefaults().

         {
             std::string vName = boost::to_upper_copy(pName);
             GetSolverInfoDefaults()[vName] = pValue;
             return pValue;
         }

std::string Nektar::LibUtilities::SessionReader::RegisterEnumValue	(	std::string	pEnum,
		std::string	pString,
		int	pEnumValue
	)

inlinestatic

Registers an enumeration value.

A set of valid values for a given solver info property may be registered using this function. It must be called statically during the initialisation of a static variable. For example:

std::string GlobalLinSys::lookupIds[2] = {
    LibUtilities::SessionReader::RegisterEnumValue(
                                 "GlobalSysSoln",
                                 "DirectFull",
                                 MultiRegions::eDirectFullMatrix),
    LibUtilities::SessionReader::RegisterEnumValue(
                                 "GlobalSysSoln",
                                 "DirectStaticCond",
                                 MultiRegions::eDirectStaticCond)
}

Parameters

pEnum	The name of the property.
pString	A valid value for the property.
pEnumValue	An enumeration value corresponding to this value.

Returns: The value for the property provided by #pString.

Definition at line 631 of file SessionReader.h.

References Nektar::StdRegions::find(), GetSolverInfoEnums(), and Nektar::iterator.

         {
             std::string vEnum = boost::to_upper_copy(pEnum);
             EnumMapList::iterator x;
             if ((x = GetSolverInfoEnums().find(vEnum)) ==
                      GetSolverInfoEnums().end())
             {
                 GetSolverInfoEnums()[vEnum] = EnumMap();
                 x = GetSolverInfoEnums().find(vEnum);
             }
             x->second[pString] = pEnumValue;
             return pString;
         }

void Nektar::LibUtilities::SessionReader::SetParameter	(	const std::string &	name,
		int &	var
	)

Set an integer parameter.

Definition at line 784 of file SessionReader.cpp.

         {
             std::string vName = boost::to_upper_copy(pName);
             m_parameters[vName] = pVar;
         }

void Nektar::LibUtilities::SessionReader::SetParameter	(	const std::string &	name,
		NekDouble &	var
	)

Set a double precision parameter.

Definition at line 794 of file SessionReader.cpp.

         {
             std::string vName = boost::to_upper_copy(pName);
             m_parameters[vName] = pVar;
         }

void Nektar::LibUtilities::SessionReader::SetSolverInfo	(	const std::string &	pProperty,
		const std::string &	pValue
	)

Sets the value of the specified solver info property.

Definition at line 832 of file SessionReader.cpp.

References ASSERTL1, and Nektar::iterator.

         {
             std::string vProperty = boost::to_upper_copy(pProperty);
             SolverInfoMap::iterator iter = m_solverInfo.find(vProperty);
 
             ASSERTL1(iter != m_solverInfo.end(),
                      "Unable to find requested property: " + pProperty);
 
             iter->second = pValue;
         }

void Nektar::LibUtilities::SessionReader::SetTag	(	const std::string &	pName,
		const std::string &	pValue
	)

Sets a specified tag.

Definition at line 1361 of file SessionReader.cpp.

         {
             std::string vName = boost::to_upper_copy(pName);
             m_tags[vName] = pValue;
         }

void Nektar::LibUtilities::SessionReader::SetUpXmlDoc ( void )

Definition at line 2708 of file SessionReader.cpp.

         {
             m_xmlDoc = MergeDoc(m_filenames);
         }

void Nektar::LibUtilities::SessionReader::SetVariable	(	const unsigned int &	idx,
		std::string	newname
	)

Definition at line 1071 of file SessionReader.cpp.

References ASSERTL0.

         {
             ASSERTL0(idx < m_variables.size(), "Variable index out of range.");
             m_variables[idx] = newname;
         }

void Nektar::LibUtilities::SessionReader::SubstituteExpressions ( std::string & expr )

Substitutes expressions defined in the XML document.

Definition at line 1405 of file SessionReader.cpp.

References Nektar::iterator.

         {
             ExpressionMap::iterator exprIter;
             for (exprIter  = m_expressions.begin();
                  exprIter != m_expressions.end(); ++exprIter)
             {
                 boost::replace_all(pExpr, exprIter->first, exprIter->second);
             }
         }

void Nektar::LibUtilities::SessionReader::TestSharedFilesystem ( )

private

Definition at line 317 of file SessionReader.cpp.

References ASSERTL1, and Nektar::LibUtilities::ReduceSum.

         {
             m_sharedFilesystem = false;
 
             if (m_comm->GetSize() > 1)
             {
                 if (m_comm->GetRank() == 0)
                 {
                     std::ofstream testfile("shared-fs-testfile");
                     testfile << "" << std::endl;
                     ASSERTL1(!testfile.fail(), "Test file creation failed");
                     testfile.close();
                 }
                 m_comm->Block();
 
                 int exists = (bool)boost::filesystem::exists("shared-fs-testfile");
                 m_comm->AllReduce(exists, LibUtilities::ReduceSum);
 
                 m_sharedFilesystem = (exists == m_comm->GetSize());
 
                 if ((m_sharedFilesystem && m_comm->GetRank() == 0) ||
                     !m_sharedFilesystem)
                 {
                     std::remove("shared-fs-testfile");
                 }
             }
             else
             {
                 m_sharedFilesystem = false;
             }
 
             if (m_verbose && m_comm->GetRank() == 0 && m_sharedFilesystem)
             {
                 cout << "Shared filesystem detected" << endl;
             }
         }

void Nektar::LibUtilities::SessionReader::VerifySolverInfo ( )

private

Check values of solver info options are valid.

Definition at line 2686 of file SessionReader.cpp.

References ASSERTL0.

         {
             SolverInfoMap::const_iterator x;
             for (x = m_solverInfo.begin(); x != m_solverInfo.end(); ++x)
             {
                 std::string solverProperty = x->first;
                 std::string solverValue = x->second;
 
                 EnumMapList::const_iterator propIt =
                     GetSolverInfoEnums().find(solverProperty);
                 if (propIt != GetSolverInfoEnums().end())
                 {
                     EnumMap::const_iterator valIt =
                         propIt->second.find(solverValue);
                     ASSERTL0(valIt != propIt->second.end(),
                              "Value '" + solverValue + "' is not valid for "
                              "property '" + solverProperty + "'");
                 }
             }
         }

Friends And Related Function Documentation

friend class MemoryManager< SessionReader >

friend

Support creation through MemoryManager.

Definition at line 128 of file SessionReader.h.

Member Data Documentation

BndRegionOrdering Nektar::LibUtilities::SessionReader::m_bndRegOrder

private

Map of original boundary region ordering for parallel periodic bcs.

Definition at line 468 of file SessionReader.h.

boost::program_options::variables_map Nektar::LibUtilities::SessionReader::m_cmdLineOptions

private

Definition at line 432 of file SessionReader.h.

Referenced by GetCmdLineArgument().

CommSharedPtr Nektar::LibUtilities::SessionReader::m_comm

private

Communication object.

Definition at line 435 of file SessionReader.h.

CompositeOrdering Nektar::LibUtilities::SessionReader::m_compOrder

private

Map of original composite ordering for parallel periodic bcs.

Definition at line 465 of file SessionReader.h.

ExpressionMap Nektar::LibUtilities::SessionReader::m_expressions

private

Expressions.

Definition at line 449 of file SessionReader.h.

AnalyticExpressionEvaluator Nektar::LibUtilities::SessionReader::m_exprEvaluator

private

Analytic expression evaluator instance.

Definition at line 451 of file SessionReader.h.

std::vector<std::string> Nektar::LibUtilities::SessionReader::m_filenames

private

Filenames.

Definition at line 437 of file SessionReader.h.

FilterMap Nektar::LibUtilities::SessionReader::m_filters

private

Filters map.

Definition at line 459 of file SessionReader.h.

FunctionMap Nektar::LibUtilities::SessionReader::m_functions

private

Functions.

Definition at line 453 of file SessionReader.h.

GeometricInfoMap Nektar::LibUtilities::SessionReader::m_geometricInfo

private

Geometric information properties.

Definition at line 447 of file SessionReader.h.

ParameterMap Nektar::LibUtilities::SessionReader::m_parameters

private

Parameters.

Definition at line 443 of file SessionReader.h.

std::string Nektar::LibUtilities::SessionReader::m_sessionName

private

Session name of the loaded XML document (filename minus ext).

Definition at line 439 of file SessionReader.h.

bool Nektar::LibUtilities::SessionReader::m_sharedFilesystem

private

Running on a shared filesystem.

Definition at line 463 of file SessionReader.h.

SolverInfoMap Nektar::LibUtilities::SessionReader::m_solverInfo

private

Solver information properties.

Definition at line 445 of file SessionReader.h.

TagMap Nektar::LibUtilities::SessionReader::m_tags

private

Custom tags.

Definition at line 457 of file SessionReader.h.

VariableList Nektar::LibUtilities::SessionReader::m_variables

private

Variables.

Definition at line 455 of file SessionReader.h.

bool Nektar::LibUtilities::SessionReader::m_verbose

private

Be verbose.

Definition at line 461 of file SessionReader.h.

TiXmlDocument* Nektar::LibUtilities::SessionReader::m_xmlDoc

private

Pointer to the loaded XML document.

Definition at line 441 of file SessionReader.h.

Public Member Functions

Static Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation