Nektar::LibUtilities::SessionReader Class Reference

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

#include <SessionReader.h>

Public Member Functions
	SessionReader (int argc, char *argv[], const std::vector< std::string > &pFilenames, const CommSharedPtr &pComm)
	~SessionReader ()
	Destructor. More...
void	InitSession (const std::vector< std::string > &filenames=std::vector< std::string >())
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 if file system shared. 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	DefinesTimeIntScheme () const
	Returns true if the TIMEINTEGRATIONSCHEME section is defined in the session file. More...
const TimeIntScheme &	GetTimeIntScheme () const
	Returns the time integration scheme structure m_timeIntScheme from the session file. More...
std::string	GetGeometryType () 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...
InterpreterSharedPtr	GetInterpreter ()
	Returns the instance of the Interpreter 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...
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	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	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	ReadTimeIntScheme (TiXmlElement *conditions)
	Reads the TIMEINTEGRATIONSCHEME 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...
InterpreterSharedPtr	m_interpreter
	Interpreter instance. More...
FunctionMap	m_functions
	Functions. More...
VariableList	m_variables
	Variables. More...
TagMap	m_tags
	Custom tags. More...
FilterMap	m_filters
	Filters map. More...
TimeIntScheme	m_timeIntScheme
	Time integration scheme information. More...
bool	m_verbose
	Be verbose. More...
bool	m_sharedFilesystem
	Running on a shared filesystem. 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 124 of file SessionReader.h.

Constructor & Destructor Documentation

SessionReader() [1/2]

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

Definition at line 222 of file BasicUtils/SessionReader.cpp.

        {
            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;
            }
 
            TestSharedFilesystem();
 
            // If running in parallel change the default global sys solution
            // type.
            if (m_comm->GetSize() > 1)
            {
                GetSolverInfoDefaults()["GLOBALSYSSOLN"] =
                    "IterativeStaticCond";
            }
 
            m_interpreter = MemoryManager<Interpreter>::AllocateSharedPtr();
            m_interpreter->SetRandomSeed((m_comm->GetRank() + 1)
                                            * (unsigned int)time(NULL));
 
            // Split up the communicator
            PartitionComm();
        }

References ASSERTL0.

~SessionReader()

Nektar::LibUtilities::SessionReader::~SessionReader

(

)

Destructor.

Definition at line 268 of file BasicUtils/SessionReader.cpp.

        {
            if (m_xmlDoc)
            {
                delete m_xmlDoc;
            }
        }

SessionReader() [2/2]

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 188 of file BasicUtils/SessionReader.cpp.

        {
            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";
            }
 
            m_interpreter = MemoryManager<Interpreter>::AllocateSharedPtr();
            m_interpreter->SetRandomSeed((m_comm->GetRank() + 1)
                                            * (unsigned int)time(NULL));
 
            // Split up the communicator
            PartitionComm();
        }

References ASSERTL0.

Member Function Documentation

CmdLineOverride()

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

private

Enforce parameters from command line arguments.

Definition at line 2484 of file BasicUtils/SessionReader.cpp.

        {
            // Parse solver info overrides
            if (m_cmdLineOptions.count("solverinfo"))
            {
                std::vector<std::string> solverInfoList =
                    m_cmdLineOptions["solverinfo"].as<
                        std::vector<std::string> >();
 
                for (size_t i = 0; i < solverInfoList.size(); ++i)
                {
                    std::string lhs, rhs;
 
                    try
                    {
                        ParseEquals(solverInfoList[i], lhs, rhs);
                    }
                    catch (...)
                    {
                        NEKERROR(ErrorUtil::efatal,
                                 "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 (size_t i = 0; i < parametersList.size(); ++i)
                {
                    std::string lhs, rhs;
 
                    try
                    {
                        ParseEquals(parametersList[i], lhs, rhs);
                    }
                    catch (...)
                    {
                        NEKERROR(ErrorUtil::efatal,
                                 "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 (...)
                    {
                        NEKERROR(ErrorUtil::efatal,
                                 "Unable to convert string: "+rhs+
                                 "to double value.");
                    }
                }
            }
        }

References NEKERROR.

CreateComm()

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

private

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

Definition at line 1607 of file BasicUtils/SessionReader.cpp.

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

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

CreateInstance() [1/2]

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.

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

References CellMLToNektar.cellml_metadata::p.

Referenced by main(), Nektar::FieldUtils::InputXml::Process(), Nektar::FieldUtils::ProcessDisplacement::Process(), Nektar::FieldUtils::ProcessHomogeneousPlane::Process(), Nektar::FieldUtils::ProcessInterpField::Process(), Nektar::FieldUtils::ProcessInterpPoints::Process(), SessionReader_CreateInstance(), Nektar::SolverUtils::Driver::v_InitObject(), and Nektar::VortexWaveInteraction::VortexWaveInteraction().

CreateInstance() [2/2]

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 158 of file SessionReader.h.

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

References CellMLToNektar.cellml_metadata::p.

DefinesCmdLineArgument()

bool Nektar::LibUtilities::SessionReader::DefinesCmdLineArgument

(

const std::string &

pName

)

const

Checks if a specified cmdline argument has been given.

Definition at line 1440 of file BasicUtils/SessionReader.cpp.

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

DefinesElement()

bool Nektar::LibUtilities::SessionReader::DefinesElement

(

const std::string &

pPath

)

const

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

Definition at line 620 of file BasicUtils/SessionReader.cpp.

        {
            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;
        }

References ASSERTL0.

DefinesFunction() [1/2]

bool Nektar::LibUtilities::SessionReader::DefinesFunction

(

const std::string &

name

)

const

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

Definition at line 1156 of file BasicUtils/SessionReader.cpp.

        {
            std::string vName = boost::to_upper_copy(pName);
            return m_functions.find(vName) != m_functions.end();
        }

DefinesFunction() [2/2]

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 1166 of file BasicUtils/SessionReader.cpp.

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

DefinesGeometricInfo()

bool Nektar::LibUtilities::SessionReader::DefinesGeometricInfo

(

const std::string &

name

)

const

Checks if a geometric info property is defined.

Definition at line 1022 of file BasicUtils/SessionReader.cpp.

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

DefinesGlobalSysSolnInfo()

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

Definition at line 930 of file BasicUtils/SessionReader.cpp.

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

DefinesParameter()

bool Nektar::LibUtilities::SessionReader::DefinesParameter

(

const std::string &

name

)

const

Checks if a parameter is specified in the XML document.

Definition at line 702 of file BasicUtils/SessionReader.cpp.

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

Referenced by export_SessionReader().

DefinesSolverInfo()

bool Nektar::LibUtilities::SessionReader::DefinesSolverInfo

(

const std::string &

name

)

const

Checks if a solver info property is specified.

Definition at line 826 of file BasicUtils/SessionReader.cpp.

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

Referenced by GetSolverInfoAsEnum().

DefinesTag()

bool Nektar::LibUtilities::SessionReader::DefinesTag

(

const std::string &

pName

)

const

Checks if a specified tag is defined.

Definition at line 1396 of file BasicUtils/SessionReader.cpp.

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

DefinesTimeIntScheme()

bool Nektar::LibUtilities::SessionReader::DefinesTimeIntScheme

(

)

const

Returns true if the TIMEINTEGRATIONSCHEME section is defined in the session file.

Definition at line 973 of file BasicUtils/SessionReader.cpp.

        {
            return m_timeIntScheme.method != "";
        }

Finalise()

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 693 of file BasicUtils/SessionReader.cpp.

        {
            m_comm->Finalise();
        }

Referenced by export_SessionReader().

GetCmdLineArgMap()

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 173 of file BasicUtils/SessionReader.cpp.

        {
            static CmdLineArgMap cmdLineArguments;
            return cmdLineArguments;
        }

Referenced by RegisterCmdLineArgument(), and RegisterCmdLineFlag().

GetCmdLineArgument()

template<typename T >

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

inline

Retrieves a command-line argument value.

Definition at line 411 of file SessionReader.h.

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

References m_cmdLineOptions.

GetComm()

CommSharedPtr Nektar::LibUtilities::SessionReader::GetComm

(

)

Returns the communication object.

Definition at line 677 of file BasicUtils/SessionReader.cpp.

        {
            return m_comm;
        }

Referenced by export_SessionReader().

GetDocument()

TiXmlDocument & Nektar::LibUtilities::SessionReader::GetDocument

(

)

Provides direct access to the TiXmlDocument object.

Definition at line 568 of file BasicUtils/SessionReader.cpp.

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

References ASSERTL1.

GetElement()

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 597 of file BasicUtils/SessionReader.cpp.

        {
            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;
        }

References ASSERTL0.

GetFilenames()

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

(

)

const

Returns the filename of the loaded XML document.

Definition at line 642 of file BasicUtils/SessionReader.cpp.

        {
            return m_filenames;
        }

GetFilters()

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

(

)

const

Definition at line 1431 of file BasicUtils/SessionReader.cpp.

        {
            return m_filters;
        }

GetFunction() [1/2]

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 1191 of file BasicUtils/SessionReader.cpp.

        {
            std::string vName = boost::to_upper_copy(pName);
            auto it1 = m_functions.find(vName);
 
            ASSERTL0(it1 != 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);
 
            auto it2 = it1->second.find(key);
            auto it3 = it1->second.find(defkey);
            bool specific = it2 != it1->second.end();
            bool wildcard = it3 != 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;
        }

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

GetFunction() [2/2]

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 1234 of file BasicUtils/SessionReader.cpp.

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

References ASSERTL0.

GetFunctionFilename() [1/2]

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 1301 of file BasicUtils/SessionReader.cpp.

        {
            std::string vName = boost::to_upper_copy(pName);
            auto 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);
 
            auto it2 = it1->second.find(key);
            auto it3 = it1->second.find(defkey);
            bool specific = it2 != it1->second.end();
            bool wildcard = it3 != 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;
        }

References ASSERTL0.

GetFunctionFilename() [2/2]

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 1342 of file BasicUtils/SessionReader.cpp.

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

References ASSERTL0.

GetFunctionFilenameVariable()

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 1355 of file BasicUtils/SessionReader.cpp.

        {
            std::string vName = boost::to_upper_copy(pName);
            auto 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);
 
            auto it2 = it1->second.find(key);
            auto it3 = it1->second.find(defkey);
            bool specific = it2 != it1->second.end();
            bool wildcard = it3 != 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;
        }

References ASSERTL0.

GetFunctionType() [1/2]

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 1234 of file BasicUtils/SessionReader.cpp.

        {
            std::string vName = boost::to_upper_copy(pName);
            auto 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);
 
            auto it2 = it1->second.find(key);
            auto it3 = it1->second.find(defkey);
            bool specific = it2 != it1->second.end();
            bool wildcard = it3 != 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;
        }

GetFunctionType() [2/2]

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 1234 of file BasicUtils/SessionReader.cpp.

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

GetGeometryType()

std::string Nektar::LibUtilities::SessionReader::GetGeometryType

(

)

const

Definition at line 987 of file BasicUtils/SessionReader.cpp.

        {
            TiXmlElement *xmlGeom = m_xmlDoc->FirstChildElement("NEKTAR")
                ->FirstChildElement("GEOMETRY");
            TiXmlAttribute *attr  = xmlGeom->FirstAttribute();
            while (attr)
            {
                std::string attrName(attr->Name());
                if (attrName == "HDF5FILE")
                {
                    // there is a file pointer, therefore is HDF5
                    return "HDF5";
                }
                // Get the next attribute.
                attr = attr->Next();
            }
 
            // Check the VERTEX block. If this is compressed, assume the file is
            // compressed, otherwise assume uncompressed.
            TiXmlElement *element = xmlGeom->FirstChildElement("VERTEX");
            string IsCompressed;
            element->QueryStringAttribute("COMPRESSED", &IsCompressed);
 
            if (IsCompressed.size() > 0)
            {
                return "XmlCompressed";
            }
 
            // no file pointer or compressed, just standard xml
            return "Xml";
        }

GetGlobalSysSolnInfo()

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

Definition at line 954 of file BasicUtils/SessionReader.cpp.

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

References ASSERTL0.

GetGloSysSolnList()

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 159 of file BasicUtils/SessionReader.cpp.

        {
            static GloSysSolnInfoList gloSysSolnInfoList;
            return gloSysSolnInfoList;
        }

GetInterpreter()

InterpreterSharedPtr Nektar::LibUtilities::SessionReader::GetInterpreter

(

)

Returns the instance of the Interpreter specific to this session.

Definition at line 2575 of file BasicUtils/SessionReader.cpp.

        {
            return m_interpreter;
        }

GetParameter()

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 717 of file BasicUtils/SessionReader.cpp.

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

References ASSERTL0.

Referenced by export_SessionReader().

GetSessionName()

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

(

)

const

Returns the session name of the loaded XML document.

Definition at line 651 of file BasicUtils/SessionReader.cpp.

        {
            return m_sessionName;
        }

Referenced by export_SessionReader().

GetSessionNameRank()

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 661 of file BasicUtils/SessionReader.cpp.

        {
            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);
        }

References Nektar::LibUtilities::PortablePath().

GetSharedFilesystem()

bool Nektar::LibUtilities::SessionReader::GetSharedFilesystem

(

)

Returns if file system shared.

Definition at line 682 of file BasicUtils/SessionReader.cpp.

        {
            return m_sharedFilesystem;
        }

GetSolverInfo()

const std::string & Nektar::LibUtilities::SessionReader::GetSolverInfo

(

const std::string &

pProperty

)

const

Returns the value of the specified solver info property.

Definition at line 837 of file BasicUtils/SessionReader.cpp.

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

References ASSERTL1.

Referenced by GetSolverInfoAsEnum().

GetSolverInfoAsEnum()

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 556 of file SessionReader.h.

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

References ASSERTL0, DefinesSolverInfo(), GetSolverInfo(), and GetSolverInfoEnums().

GetSolverInfoDefaults()

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 143 of file BasicUtils/SessionReader.cpp.

        {
            static SolverInfoMap solverInfoMap;
            return solverInfoMap;
        }

Referenced by RegisterDefaultSolverInfo().

GetSolverInfoEnums()

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 128 of file BasicUtils/SessionReader.cpp.

        {
            static EnumMapList solverInfoEnums;
            return solverInfoEnums;
        }

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

GetTag()

const std::string & Nektar::LibUtilities::SessionReader::GetTag

(

const std::string &

pName

)

const

Returns the value of a specified tag.

Definition at line 1418 of file BasicUtils/SessionReader.cpp.

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

References ASSERTL0.

GetTimeIntScheme()

const TimeIntScheme & Nektar::LibUtilities::SessionReader::GetTimeIntScheme

(

)

const

Returns the time integration scheme structure m_timeIntScheme from the session file.

Definition at line 982 of file BasicUtils/SessionReader.cpp.

        {
            return m_timeIntScheme;
        }

GetValueAsEnum()

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 582 of file SessionReader.h.

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

References ASSERTL0, and GetSolverInfoEnums().

GetVariable()

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 1124 of file BasicUtils/SessionReader.cpp.

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

References ASSERTL0.

Referenced by export_SessionReader().

GetVariables()

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

(

)

const

Returns the names of all variables.

Definition at line 1147 of file BasicUtils/SessionReader.cpp.

        {
            return m_variables;
        }

InitSession()

void Nektar::LibUtilities::SessionReader::InitSession

(

const std::vector< std::string > &

filenames = std::vector<std::string>()

)

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 283 of file BasicUtils/SessionReader.cpp.

        {
            // Re-load filenames for session if required.
            if (filenames.size() > 0)
            {
                m_filenames = filenames;
            }
 
            // Merge document if required.
            if (m_xmlDoc)
            {
                delete m_xmlDoc;
            }
 
            m_xmlDoc = MergeDoc(m_filenames);
 
            // 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;
                    for (auto &x : m_parameters)
                    {
                        cout << "\t" << x.first << " = " << x.second << endl;
                    }
                    cout << endl;
                }
 
                if (m_comm->TreatAsRankZero() && m_solverInfo.size() > 0)
                {
                    cout << "Solver Info:" << endl;
                    for (auto &x : m_solverInfo)
                    {
                        cout << "\t" << x.first << " = " << x.second << endl;
                    }
                    cout << endl;
                }
            }
        }

LoadDoc()

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 1461 of file BasicUtils/SessionReader.cpp.

        {
            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&)
                {
                    NEKERROR(ErrorUtil::efatal,
                             "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);
            }
        }

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

LoadGeometricInfo() [1/3]

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 1053 of file BasicUtils/SessionReader.cpp.

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

LoadGeometricInfo() [2/3]

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 1081 of file BasicUtils/SessionReader.cpp.

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

LoadGeometricInfo() [3/3]

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 1032 of file BasicUtils/SessionReader.cpp.

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

LoadParameter() [1/4]

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

Load an integer parameter.

Definition at line 733 of file BasicUtils/SessionReader.cpp.

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

References ASSERTL0.

LoadParameter() [2/4]

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 748 of file BasicUtils/SessionReader.cpp.

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

LoadParameter() [3/4]

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

Load a double precision parameter.

Definition at line 768 of file BasicUtils/SessionReader.cpp.

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

References ASSERTL0.

LoadParameter() [4/4]

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 782 of file BasicUtils/SessionReader.cpp.

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

LoadSolverInfo()

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 867 of file BasicUtils/SessionReader.cpp.

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

MatchGeometricInfo()

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 1102 of file BasicUtils/SessionReader.cpp.

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

MatchSolverInfo() [1/2]

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 910 of file BasicUtils/SessionReader.cpp.

        {
            if (DefinesSolverInfo(pName))
            {
                std::string vName = boost::to_upper_copy(pName);
                auto iter = m_solverInfo.find(vName);
                if(iter != m_solverInfo.end())
                {
                    return boost::iequals(iter->second, pTrueVal);
                }
            }
            return false;
        }

MatchSolverInfo() [2/2]

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 888 of file BasicUtils/SessionReader.cpp.

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

MatchSolverInfoAsEnum()

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 545 of file SessionReader.h.

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

References CellMLToNektar.pycml::name.

MergeDoc()

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 1510 of file BasicUtils/SessionReader.cpp.

        {
            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.";
                            NEKERROR(ErrorUtil::ewarning, warningmsg.c_str());
                        }
                        else
                        {
                            if (vMainEntry)
                            {
                                vMainNektar->RemoveChild(vMainEntry);
                            }
                            TiXmlElement *q = new TiXmlElement(*p);
                            vMainNektar->LinkEndChild(q);
                        }
                        p = p->NextSiblingElement();
                    }
 
                    delete vTempDoc;
                }
            }
            return vMainDoc;
        }

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

ParseCommandLineArguments()

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 377 of file BasicUtils/SessionReader.cpp.

        {
            // 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")
#ifdef NEKTAR_USE_CWIPI
                ("cwipi",        po::value<std::string>(),
                                 "set CWIPI name")
#endif
            ;
 
            for (auto &cmdIt : GetCmdLineArgMap())
            {
                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
            for (auto &x : parsed.options)
            {
                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>();
            }
        }

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

ParseDocument()

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

private

Loads and parses the specified file.

Definition at line 1577 of file BasicUtils/SessionReader.cpp.

        {
            // 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);
            ReadTimeIntScheme     (e);
            ReadExpressions       (e);
            ReadVariables         (e);
            ReadFunctions         (e);
 
            e = docHandle.FirstChildElement("NEKTAR").
                FirstChildElement("FILTERS").Element();
 
            ReadFilters(e);
        }

References ASSERTL0.

ParseEquals()

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 2458 of file BasicUtils/SessionReader.cpp.

        {
            /// Pull out lhs and rhs and eliminate any spaces.
            size_t beg = line.find_first_not_of(" ");
            size_t 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);
        }

ParseSessionName()

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

private

Parse the session name.

Definition at line 530 of file BasicUtils/SessionReader.cpp.

        {
            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;
        }

References ASSERTL0.

PartitionComm()

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 1638 of file BasicUtils/SessionReader.cpp.

        {
            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);
            }
        }

References ASSERTL0.

ReadExpressions()

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

private

Reads the EXPRESSIONS section of the XML document.

Definition at line 2075 of file BasicUtils/SessionReader.cpp.

        {
            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() + "'");
 
                    auto 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");
                }
            }
        }

References ASSERTL0.

ReadFilters()

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

private

Reads the FILTERS section of the XML document.

Definition at line 2417 of file BasicUtils/SessionReader.cpp.

        {
            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");
            }
        }

References ASSERTL0.

ReadFunctions()

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

private

Reads the FUNCTIONS section of the XML document.

Definition at line 2209 of file BasicUtils/SessionReader.cpp.

        {
            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::GenerateVector(variableStr, variableList);
 
                    // If no domain string put to 0
                    std::string domainStr;
                    if (!variable->Attribute("DOMAIN"))
                    {
                        domainStr = "0";
                    }
                    else
                    {
                        domainStr = variable->Attribute("DOMAIN");
                    }
 
                    // If no domain string put to 0
                    std::string evarsStr = "x y z t";
                    if (variable->Attribute("EVARS"))
                    {
                        evarsStr = evarsStr + std::string(" ") + variable->Attribute("EVARS");
                    }
 
                    // Parse list of variables
                    std::vector<std::string> varSplit;
                    std::vector<unsigned int> domainList;
                    ParseUtils::GenerateSeqVector(domainStr, 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(m_interpreter, fcnStr, evarsStr);
                    }
 
                    // 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;
 
                        NEKERROR(ErrorUtil::efatal,
                                "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]);
                            auto 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");
            }
        }

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

ReadGlobalSysSolnInfo()

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

private

Reads the GLOBALSYSSOLNINFO section of the XML document.

Definition at line 1845 of file BasicUtils/SessionReader.cpp.

        {
            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::GenerateVector(VarList, 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)
                        {
                            auto x = GetGloSysSolnList().find(varStrings[i]);
                            if (x == 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;
 
                    for (auto &x : GetGloSysSolnList())
                    {
                        cout << "\t Variable: " << x.first <<  endl;
 
                        for (auto &y : x.second)
                        {
                            cout << "\t\t " << y.first  << " = " << y.second
                                 << endl;
                        }
                    }
                    cout << endl;
                }
            }
        }

References ASSERTL0.

ReadParameters()

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

private

Reads the PARAMETERS section of the XML document.

Definition at line 1685 of file BasicUtils/SessionReader.cpp.

        {
            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 (...)
                        {
                            NEKERROR(ErrorUtil::efatal,
                                     "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(
                                    m_interpreter, rhs);
                                value = expession.Evaluate();
                            }
                            catch (const std::runtime_error &)
                            {
                                NEKERROR(ErrorUtil::efatal,
                                         "Error evaluating parameter expression"
                                         " '" + rhs + "' in XML element: \n\t'"
                                         + tagcontent.str() + "'");
                            }
                            m_interpreter->SetParameter(lhs, value);
                            caseSensitiveParameters[lhs] = value;
                            boost::to_upper(lhs);
                            m_parameters[lhs] = value;
                        }
                    }
 
                    parameter = parameter->NextSiblingElement();
                }
            }
        }

References Nektar::LibUtilities::Equation::Evaluate(), and NEKERROR.

ReadSolverInfo()

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

private

Reads the SOLVERINFO section of the XML document.

Definition at line 1770 of file BasicUtils/SessionReader.cpp.

        {
            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.");
            }
        }

References ASSERTL0.

ReadTimeIntScheme()

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

private

Reads the TIMEINTEGRATIONSCHEME section of the XML document.

Read the time-integration scheme structure, if present.

Definition at line 1972 of file BasicUtils/SessionReader.cpp.

        {
            if (!conditions)
            {
                return;
            }
 
            TiXmlElement *timeInt = conditions->FirstChildElement(
                "TIMEINTEGRATIONSCHEME");
 
            if (!timeInt)
            {
                return;
            }
 
            TiXmlElement *method = timeInt->FirstChildElement("METHOD");
            TiXmlElement *variant = timeInt->FirstChildElement("VARIANT");
            TiXmlElement *order = timeInt->FirstChildElement("ORDER");
            TiXmlElement *params = timeInt->FirstChildElement("FREEPARAMETERS");
 
            // Only the method and order are required.
            ASSERTL0(method, "Missing METHOD tag inside "
                     "TIMEINTEGRATIONSCHEME.");
            ASSERTL0(order, "Missing ORDER tag inside "
                     "TIMEINTEGRATIONSCHEME.");
 
            m_timeIntScheme.method = method->GetText();
 
            std::string orderStr = order->GetText();
 
            // Only the method and order are required.
            ASSERTL0(m_timeIntScheme.method.size() > 0,
                     "Empty text inside METHOD tag in TIMEINTEGRATIONSCHEME.");
            ASSERTL0(orderStr.size() > 0,
                     "Empty text inside ORDER tag in TIMEINTEGRATIONSCHEME.");
            try
            {
                m_timeIntScheme.order = boost::lexical_cast<unsigned int>(
                    orderStr);
            }
            catch(...)
            {
                NEKERROR(ErrorUtil::efatal, "In ORDER tag, unable to convert "
                         "string '" + orderStr + "' to an unsigned integer.");
            }
 
            if (variant)
            {
                m_timeIntScheme.variant = variant->GetText();
            }
 
            if (params)
            {
                std::string paramsStr = params->GetText();
                ASSERTL0(paramsStr.size() > 0,
                         "Empty text inside FREEPARAMETERS tag in "
                         "TIMEINTEGRATIONSCHEME.");
 
                std::vector<std::string> pSplit;
                boost::split(pSplit, paramsStr, boost::is_any_of(" "));
 
                m_timeIntScheme.freeParams.resize(pSplit.size());
                for (size_t i = 0; i < pSplit.size(); ++i)
                {
                    try
                    {
                        m_timeIntScheme.freeParams[i] = boost::lexical_cast<
                            NekDouble>(pSplit[i]);
                    }
                    catch (...)
                    {
                        NEKERROR(ErrorUtil::efatal, "In FREEPARAMETERS tag, "
                                 "unable to convert string '" + pSplit[i] + "' "
                                 "to a floating-point value.");
                    }
                }
            }
 
            if (m_verbose && m_comm)
            {
                if (m_comm->GetRank() == 0)
                {
                    cout << "Trying to use time integration scheme:" << endl;
                    cout << "\t Method : " << m_timeIntScheme.method << endl;
                    cout << "\t Variant: " << m_timeIntScheme.variant << endl;
                    cout << "\t Order  : " << m_timeIntScheme.order << endl;
 
                    if (m_timeIntScheme.freeParams.size() > 0)
                    {
                        cout << "\t Params :";
                        for (auto &x : m_timeIntScheme.freeParams)
                        {
                            cout << " " << x;
                        }
                        cout << endl;
                    }
                }
            }
        }

References ASSERTL0, and NEKERROR.

ReadVariables()

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 2126 of file BasicUtils/SessionReader.cpp.

        {
            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.");
            }
        }

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

RegisterCmdLineArgument()

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 672 of file SessionReader.h.

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

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

RegisterCmdLineFlag()

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 690 of file SessionReader.h.

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

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

RegisterDefaultSolverInfo()

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 659 of file SessionReader.h.

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

References GetSolverInfoDefaults().

RegisterEnumValue()

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 625 of file SessionReader.h.

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

References GetSolverInfoEnums().

SetParameter() [1/2]

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

Set an integer parameter.

Definition at line 804 of file BasicUtils/SessionReader.cpp.

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

SetParameter() [2/2]

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

Set a double precision parameter.

Definition at line 814 of file BasicUtils/SessionReader.cpp.

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

SetSolverInfo()

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 852 of file BasicUtils/SessionReader.cpp.

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

References ASSERTL1.

SetTag()

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

Sets a specified tag.

Definition at line 1406 of file BasicUtils/SessionReader.cpp.

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

SetUpXmlDoc()

void Nektar::LibUtilities::SessionReader::SetUpXmlDoc

(

void

)

Definition at line 2570 of file BasicUtils/SessionReader.cpp.

        {
            m_xmlDoc = MergeDoc(m_filenames);
        }

SetVariable()

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

Definition at line 1136 of file BasicUtils/SessionReader.cpp.

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

References ASSERTL0.

SubstituteExpressions()

void Nektar::LibUtilities::SessionReader::SubstituteExpressions

(

std::string &

expr

)

Substitutes expressions defined in the XML document.

Definition at line 1450 of file BasicUtils/SessionReader.cpp.

        {
            for (auto &exprIter : m_expressions)
            {
                boost::replace_all(pExpr, exprIter.first, exprIter.second);
            }
        }

TestSharedFilesystem()

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

private

Definition at line 335 of file BasicUtils/SessionReader.cpp.

        {
            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;
            }
        }

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

VerifySolverInfo()

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

private

Check values of solver info options are valid.

Definition at line 2551 of file BasicUtils/SessionReader.cpp.

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

References ASSERTL0.

Friends And Related Function Documentation

MemoryManager< SessionReader >

friend class MemoryManager< SessionReader >

friend

Support creation through MemoryManager.

Definition at line 112 of file SessionReader.h.

Member Data Documentation

m_cmdLineOptions

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

private

Definition at line 435 of file SessionReader.h.

Referenced by GetCmdLineArgument().

m_comm

CommSharedPtr Nektar::LibUtilities::SessionReader::m_comm

private

Communication object.

Definition at line 438 of file SessionReader.h.

m_expressions

ExpressionMap Nektar::LibUtilities::SessionReader::m_expressions

private

Expressions.

Definition at line 452 of file SessionReader.h.

m_filenames

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

private

Filenames.

Definition at line 440 of file SessionReader.h.

m_filters

FilterMap Nektar::LibUtilities::SessionReader::m_filters

private

Filters map.

Definition at line 462 of file SessionReader.h.

m_functions

FunctionMap Nektar::LibUtilities::SessionReader::m_functions

private

Functions.

Definition at line 456 of file SessionReader.h.

m_geometricInfo

GeometricInfoMap Nektar::LibUtilities::SessionReader::m_geometricInfo

private

Geometric information properties.

Definition at line 450 of file SessionReader.h.

m_interpreter

InterpreterSharedPtr Nektar::LibUtilities::SessionReader::m_interpreter

private

Interpreter instance.

Definition at line 454 of file SessionReader.h.

m_parameters

ParameterMap Nektar::LibUtilities::SessionReader::m_parameters

private

Parameters.

Definition at line 446 of file SessionReader.h.

m_sessionName

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

private

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

Definition at line 442 of file SessionReader.h.

m_sharedFilesystem

bool Nektar::LibUtilities::SessionReader::m_sharedFilesystem

private

Running on a shared filesystem.

Definition at line 468 of file SessionReader.h.

m_solverInfo

SolverInfoMap Nektar::LibUtilities::SessionReader::m_solverInfo

private

Solver information properties.

Definition at line 448 of file SessionReader.h.

m_tags

TagMap Nektar::LibUtilities::SessionReader::m_tags

private

Custom tags.

Definition at line 460 of file SessionReader.h.

m_timeIntScheme

TimeIntScheme Nektar::LibUtilities::SessionReader::m_timeIntScheme

private

Time integration scheme information.

Definition at line 464 of file SessionReader.h.

m_variables

VariableList Nektar::LibUtilities::SessionReader::m_variables

private

Variables.

Definition at line 458 of file SessionReader.h.

m_verbose

bool Nektar::LibUtilities::SessionReader::m_verbose

private

Be verbose.

Definition at line 466 of file SessionReader.h.

m_xmlDoc

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

private

Pointer to the loaded XML document.

Definition at line 444 of file SessionReader.h.