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, const int &timelevel)
	~SessionReader ()
	Destructor.
void	InitSession (const std::vector< std::string > &filenames=std::vector< std::string >())
TiXmlDocument &	GetDocument ()
	Provides direct access to the TiXmlDocument object.
TiXmlElement *	GetElement (const std::string &pPath)
	Provides direct access to the TiXmlElement specified.
bool	DefinesElement (const std::string &pPath) const
	Tests if a specified element is defined in the XML document.
const std::vector< std::string > &	GetFilenames () const
	Returns the filename of the loaded XML document.
const std::string &	GetSessionName () const
	Returns the session name of the loaded XML document.
CommSharedPtr	GetComm ()
	Returns the communication object.
bool	GetSharedFilesystem ()
	Returns if file system shared.
void	Finalise ()
	Finalises the session.
bool	DefinesParameter (const std::string &name) const
	Checks if a parameter is specified in the XML document.
const NekDouble &	GetParameter (const std::string &pName) const
	Returns the value of the specified parameter.
const ParameterMap &	GetParameters ()
void	LoadParameter (const std::string &name, int &var) const
	Load an integer parameter.
void	LoadParameter (const std::string &name, unsigned int &var) const
	Load an unsigned integer parameter.
void	LoadParameter (const std::string &name, size_t &var) const
	Load an size_t parameter.
void	LoadParameter (const std::string &name, int &var, const int &def) const
	Check for and load an integer parameter.
void	LoadParameter (const std::string &name, unsigned int &var, const unsigned int &def) const
	Check for and load an unsigned integer parameter.
void	LoadParameter (const std::string &name, size_t &var, const size_t &def) const
	Check for and load an size_t parameter.
void	LoadParameter (const std::string &name, NekDouble &var) const
	Load a double precision parameter.
void	LoadParameter (const std::string &name, NekDouble &var, const NekDouble &def) const
	Check for and load a double-precision parameter.
void	SetParameter (const std::string &name, int &var)
	Set an integer parameter.
void	SetParameter (const std::string &name, unsigned int &var)
	Set an unsigned integer parameter.
void	SetParameter (const std::string &name, size_t &var)
	Set an size_t parameter.
void	SetParameter (const std::string &name, NekDouble &var)
	Set a double precision parameter.
bool	DefinesSolverInfo (const std::string &name) const
	Checks if a solver info property is specified.
const std::string &	GetSolverInfo (const std::string &pProperty) const
	Returns the value of the specified solver info property.
void	SetSolverInfo (const std::string &pProperty, const std::string &pValue)
	Sets the value of the specified solver info property.
template<typename T >
const T	GetSolverInfoAsEnum (const std::string &pName) const
	Returns the value of the specified solver info property as enum.
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.
void	LoadSolverInfo (const std::string &name, std::string &var, const std::string &def="") const
	Check for and load a solver info property.
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.
bool	MatchSolverInfo (const std::string &name, const std::string &trueval) const
	Check if the value of a solver info property matches.
template<typename T >
bool	MatchSolverInfoAsEnum (const std::string &name, const T &trueval) const
	Check if the value of a solver info property matches.
bool	GetBackups () const
	Returns the backups.
bool	DefinesGlobalSysSolnInfo (const std::string &variable, const std::string &property) const
const std::string &	GetGlobalSysSolnInfo (const std::string &variable, const std::string &property) const
void	SetGlobalSysSolnInfo (const std::string &variable, const std::string &property, const std::string &value)
bool	DefinesTimeIntScheme () const
	Returns true if the TIMEINTEGRATIONSCHEME section is defined in the session file.
const TimeIntScheme &	GetTimeIntScheme () const
	Returns the time integration scheme structure m_timeIntScheme from the session file.
std::string	GetGeometryType () const
const std::string &	GetVariable (const unsigned int &idx) const
	Returns the name of the variable specified by the given index.
void	SetVariable (const unsigned int &idx, std::string newname)
std::vector< std::string >	GetVariables () const
	Returns the names of all variables.
bool	DefinesFunction (const std::string &name) const
	Checks if a specified function is defined in the XML document.
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.
EquationSharedPtr	GetFunction (const std::string &name, const std::string &variable, const int pDomain=0) const
	Returns an EquationSharedPtr to a given function variable.
EquationSharedPtr	GetFunction (const std::string &name, const unsigned int &var, const int pDomain=0) const
	Returns an EquationSharedPtr to a given function variable index.
enum FunctionType	GetFunctionType (const std::string &name, const std::string &variable, const int pDomain=0) const
	Returns the type of a given function variable.
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.
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.
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.
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.
InterpreterSharedPtr	GetInterpreter ()
	Returns the instance of the Interpreter specific to this session.
bool	DefinesTag (const std::string &pName) const
	Checks if a specified tag is defined.
void	SetTag (const std::string &pName, const std::string &pValue)
	Sets a specified tag.
const std::string &	GetTag (const std::string &pName) const
	Returns the value of a specified tag.
const FilterMap &	GetFilters () const
bool	DefinesCmdLineArgument (const std::string &pName) const
	Checks if a specified cmdline argument has been given.
template<typename T >
T	GetCmdLineArgument (const std::string &pName) const
	Retrieves a command-line argument value.
bool	GetUpdateOptFile () const
	Get bool to update optimisation file.
void	SetUpdateOptFile (bool flag)
	Set bool to update optimisation file.
size_t	GetTimeLevel (void) const
	Get time level (Parallel-in-Time)

Static Public Member Functions
static SessionReaderSharedPtr	CreateInstance (int argc, char *argv[])
	Creates an instance of the SessionReader class.
static SessionReaderSharedPtr	CreateInstance (int argc, char *argv[], std::vector< std::string > &pFilenames, const CommSharedPtr &pComm=CommSharedPtr(), const int &timelevel=0)
	Creates an instance of the SessionReader class initialised using a separate list of XML documents.
static std::string	RegisterEnumValue (std::string pEnum, std::string pString, int pEnumValue)
	Registers an enumeration value.
static std::string	RegisterDefaultSolverInfo (const std::string &pName, const std::string &pValue)
	Registers the default string value of a solver info property.
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.
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.
static void	GetXMLElementTimeLevel (TiXmlElement *&element, const size_t timeLevel, const bool enableCheck=true)
	Get XML elment time level (Parallel-in-Time)

Private Member Functions
	SessionReader (int argc, char *argv[])
	Main constructor.
void	TestSharedFilesystem ()
std::vector< std::string >	ParseCommandLineArguments (int argc, char *argv[])
	Parse the program arguments and fill m_cmdLineOptions.
std::string	ParseSessionName (std::vector< std::string > &filenames)
	Parse the session name.
void	LoadDoc (const std::string &pFilename, TiXmlDocument *pDoc) const
	Loads an xml file into a tinyxml doc and decompresses if needed.
TiXmlDocument *	MergeDoc (const std::vector< std::string > &pFilenames) const
	Creates an XML document from a list of input files.
void	ParseDocument ()
	Loads and parses the specified file.
void	CreateComm (int &argc, char *argv[])
	Loads the given XML document and instantiates an appropriate communication object.
void	PartitionComm ()
	Partitions the comm object based on session parameters.
void	ReadParameters (TiXmlElement *conditions)
	Reads the PARAMETERS section of the XML document.
void	ReadSolverInfo (TiXmlElement *conditions)
	Reads the SOLVERINFO section of the XML document.
void	ReadGlobalSysSolnInfo (TiXmlElement *conditions)
	Reads the GLOBALSYSSOLNINFO section of the XML document.
void	ReadTimeIntScheme (TiXmlElement *conditions)
	Reads the TIMEINTEGRATIONSCHEME section of the XML document.
void	ReadVariables (TiXmlElement *conditions)
	Reads the VARIABLES section of the XML document.
void	ReadFunctions (TiXmlElement *conditions)
	Reads the FUNCTIONS section of the XML document.
void	ReadFilters (TiXmlElement *filters)
	Reads the FILTERS section of the XML document.
void	CmdLineOverride ()
	Enforce parameters from command line arguments.
void	VerifySolverInfo ()
	Check values of solver info options are valid.
void	ParseEquals (const std::string &line, std::string &lhs, std::string &rhs)
	Parse a string in the form lhs = rhs.

Static Private Member Functions
static EnumMapList &	GetSolverInfoEnums ()
	String to enumeration map for Solver Info parameters.
static SolverInfoMap &	GetSolverInfoDefaults ()
	Default solver info options.
static GloSysSolnInfoList &	GetGloSysSolnList ()
	GlobalSysSoln Info map.
static CmdLineArgMap &	GetCmdLineArgMap ()
	CmdLine argument map.

Private Attributes
boost::program_options::variables_map	m_cmdLineOptions
CommSharedPtr	m_comm
	Communication object.
std::vector< std::string >	m_filenames
	Filenames.
std::string	m_sessionName
	Session name of the loaded XML document (filename minus ext).
TiXmlDocument *	m_xmlDoc
	Pointer to the loaded XML document.
ParameterMap	m_parameters
	Parameters.
SolverInfoMap	m_solverInfo
	Solver information properties.
GeometricInfoMap	m_geometricInfo
	Geometric information properties.
InterpreterSharedPtr	m_interpreter
	Interpreter instance.
FunctionMap	m_functions
	Functions.
VariableList	m_variables
	Variables.
TagMap	m_tags
	Custom tags.
FilterMap	m_filters
	Filters map.
TimeIntScheme	m_timeIntScheme
	Time integration scheme information.
size_t	m_timeLevel = 0
	Time level.
bool	m_verbose
	Be verbose.
bool	m_sharedFilesystem
	Running on a shared filesystem.
bool	m_backups = true
	Backups.
bool	m_updateOptFile
	Update optimisation file.

Friends
class	MemoryManager< SessionReader >
	Support creation through MemoryManager.

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 122 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,
		const int &	timelevel
	)

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

{
    ASSERTL0(pFilenames.size() > 0, "No filenames specified.");
 
    ParseCommandLineArguments(argc, argv);
    m_xmlDoc    = nullptr;
    m_filenames = pFilenames;
 
    m_sessionName = ParseSessionName(m_filenames);
 
    // Create communicator
    if (!pComm.get())
    {
        CreateComm(argc, argv);
    }
    else
    {
        m_comm = pComm;
    }
 
    TestSharedFilesystem();
 
    // Split up the communicator
    PartitionComm();
 
    // If running in parallel change the default global sys solution
    // type.
    if (m_comm->GetSpaceComm()->GetSize() > 1)
    {
        GetSolverInfoDefaults()["GLOBALSYSSOLN"] = "IterativeStaticCond";
    }
 
    m_interpreter = MemoryManager<Interpreter>::AllocateSharedPtr();
    m_interpreter->SetRandomSeed((m_comm->GetSpaceComm()->GetRank() + 1) *
                                 (unsigned int)time(nullptr));
 
    // Set time level (Parallel-in-Time)
    m_timeLevel = timelevel;
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, CreateComm(), GetSolverInfoDefaults(), m_comm, m_filenames, m_interpreter, m_sessionName, m_timeLevel, m_xmlDoc, ParseCommandLineArguments(), ParseSessionName(), PartitionComm(), and TestSharedFilesystem().

~SessionReader()

Nektar::LibUtilities::SessionReader::~SessionReader

(

)

Destructor.

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

{
    if (m_xmlDoc)
    {
        delete m_xmlDoc;
    }
}

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

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

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, CreateComm(), GetSolverInfoDefaults(), m_comm, m_filenames, m_interpreter, m_sessionName, m_xmlDoc, ParseCommandLineArguments(), ParseSessionName(), PartitionComm(), and TestSharedFilesystem().

Member Function Documentation

CmdLineOverride()

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

private

Enforce parameters from command line arguments.

Definition at line 2568 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_interpreter->SetParameter(lhs, std::stod(rhs));
                m_parameters[lhsUpper] = std::stod(rhs);
            }
            catch (...)
            {
                NEKERROR(ErrorUtil::efatal, "Unable to convert string: " + rhs +
                                                "to double value.");
            }
        }
    }
}

References Nektar::ErrorUtil::efatal, m_cmdLineOptions, m_interpreter, m_parameters, m_solverInfo, NEKERROR, and ParseEquals().

Referenced by InitSession().

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 1686 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(), Nektar::LibUtilities::GetCommFactory(), m_cmdLineOptions, and m_comm.

Referenced by SessionReader(), and SessionReader().

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

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

References Nektar::MemoryManager< DataType >::AllocateSharedPtr().

Referenced by Nektar::MovementTests::CreateSession(), Diffusion::Diffusion(), main(), SessionReader_CreateInstance(), Nektar::SolverUtils::DriverParallelInTime::SetParallelInTimeEquationSystem(), Nektar::VarcoeffHashingTest::setupContFieldSolve(), Nektar::SolverUtils::Driver::v_InitObject(), Nektar::FieldUtils::InputXml::v_Process(), Nektar::FieldUtils::ProcessDisplacement::v_Process(), Nektar::FieldUtils::ProcessHomogeneousPlane::v_Process(), Nektar::FieldUtils::ProcessInterpField::v_Process(), Nektar::FieldUtils::ProcessInterpPoints::v_Process(), 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(), const int &  timelevel = 0  )

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

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

References Nektar::MemoryManager< DataType >::AllocateSharedPtr().

DefinesCmdLineArgument()

bool Nektar::LibUtilities::SessionReader::DefinesCmdLineArgument

(

const std::string &

pName

)

const

Checks if a specified cmdline argument has been given.

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

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

References m_cmdLineOptions.

Referenced by InitSession(), and PartitionComm().

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 722 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, and m_xmlDoc.

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

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

References m_functions.

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

References m_functions.

DefinesGlobalSysSolnInfo()

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

Definition at line 1086 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;
}

References GetGloSysSolnList().

DefinesParameter()

bool Nektar::LibUtilities::SessionReader::DefinesParameter

(

const std::string &

name

)

const

Checks if a parameter is specified in the XML document.

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

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

References m_parameters.

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

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

References m_solverInfo.

Referenced by export_SessionReader(), GetSolverInfoAsEnum(), and MatchSolverInfo().

DefinesTag()

bool Nektar::LibUtilities::SessionReader::DefinesTag

(

const std::string &

pName

)

const

Checks if a specified tag is defined.

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

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

References m_tags.

DefinesTimeIntScheme()

bool Nektar::LibUtilities::SessionReader::DefinesTimeIntScheme

(

)

const

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

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

{
    return m_timeIntScheme.method != "";
}

References m_timeIntScheme, and Nektar::LibUtilities::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 778 of file BasicUtils/SessionReader.cpp.

{
    m_comm->Finalise();
}

References m_comm.

Referenced by export_SessionReader().

GetBackups()

bool Nektar::LibUtilities::SessionReader::GetBackups

(

)

const

Returns the backups.

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

{
    return m_backups;
}

References m_backups.

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

{
    static CmdLineArgMap cmdLineArguments;
    return cmdLineArguments;
}

Referenced by ParseCommandLineArguments(), 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 368 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 762 of file BasicUtils/SessionReader.cpp.

{
    return m_comm;
}

References m_comm.

Referenced by export_SessionReader().

GetDocument()

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

(

)

Provides direct access to the TiXmlDocument object.

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

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

References ASSERTL1, and m_xmlDoc.

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 700 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, and m_xmlDoc.

GetFilenames()

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

(

)

const

Returns the filename of the loaded XML document.

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

{
    return m_filenames;
}

References m_filenames.

GetFilters()

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

(

)

const

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

{
    return m_filters;
}

References 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 1270 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 " + std::to_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, Nektar::LibUtilities::eFunctionTypeExpression, and m_functions.

Referenced by export_SessionReader(), and GetFunction().

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

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

References ASSERTL0, GetFunction(), and m_variables.

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 1369 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 " + std::to_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, and m_functions.

Referenced by GetFunctionFilename().

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

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

References ASSERTL0, GetFunctionFilename(), and m_variables.

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 1417 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 " + std::to_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, and m_functions.

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 1321 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 " + std::to_string(pDomain) +
                                       " defined for function " + pName +
                                       " in session file.");
 
    // If not specific, must be wildcard
    if (!specific)
    {
        it2 = it3;
    }
 
    return it2->second.m_type;
}

References ASSERTL0, and m_functions.

Referenced by GetFunctionType().

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

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

References ASSERTL0, GetFunctionType(), and m_variables.

GetGeometryType()

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

(

)

const

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

{
    TiXmlElement *xmlGeom =
        m_xmlDoc->FirstChildElement("NEKTAR")->FirstChildElement("GEOMETRY");
    ASSERTL1(xmlGeom, "Failed to find a GEOMETRY section in m_xmlDoc");
 
    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";
}

References ASSERTL1, and m_xmlDoc.

GetGlobalSysSolnInfo()

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

Definition at line 1109 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, and GetGloSysSolnList().

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

{
    static GloSysSolnInfoList gloSysSolnInfoList;
    return gloSysSolnInfoList;
}

Referenced by DefinesGlobalSysSolnInfo(), GetGlobalSysSolnInfo(), ReadGlobalSysSolnInfo(), and SetGlobalSysSolnInfo().

GetInterpreter()

InterpreterSharedPtr Nektar::LibUtilities::SessionReader::GetInterpreter

(

)

Returns the instance of the Interpreter specific to this session.

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

{
    return m_interpreter;
}

References 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 800 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, and m_parameters.

Referenced by export_SessionReader().

GetParameters()

const ParameterMap & Nektar::LibUtilities::SessionReader::GetParameters

(

)

Getter for the session's parameters

Returns

A reference to the parameter map

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

{
    return m_parameters;
}

References m_parameters.

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

{
    return m_sessionName;
}

References m_sessionName.

Referenced by export_SessionReader().

GetSharedFilesystem()

bool Nektar::LibUtilities::SessionReader::GetSharedFilesystem

(

)

Returns if file system shared.

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

{
    return m_sharedFilesystem;
}

References m_sharedFilesystem.

Referenced by export_SessionReader().

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 1001 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, and m_solverInfo.

Referenced by export_SessionReader(), and 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 517 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 140 of file BasicUtils/SessionReader.cpp.

{
    static SolverInfoMap solverInfoMap;
    return solverInfoMap;
}

Referenced by ReadSolverInfo(), RegisterDefaultSolverInfo(), SessionReader(), and SessionReader().

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

{
    static EnumMapList solverInfoEnums;
    return solverInfoEnums;
}

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

GetTag()

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

(

const std::string &

pName

)

const

Returns the value of a specified tag.

Definition at line 1472 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, and m_tags.

GetTimeIntScheme()

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

(

)

const

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

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

{
    return m_timeIntScheme;
}

References m_timeIntScheme.

GetTimeLevel()

size_t Nektar::LibUtilities::SessionReader::GetTimeLevel ( void  ) const

inline

Get time level (Parallel-in-Time)

Definition at line 394 of file SessionReader.h.

    {
        return m_timeLevel;
    }

References m_timeLevel.

GetUpdateOptFile()

bool Nektar::LibUtilities::SessionReader::GetUpdateOptFile ( ) const

inline

Get bool to update optimisation file.

Definition at line 382 of file SessionReader.h.

    {
        return m_updateOptFile;
    }

References m_updateOptFile.

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

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

References ASSERTL0, and m_variables.

Referenced by export_SessionReader().

GetVariables()

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

(

)

const

Returns the names of all variables.

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

{
    return m_variables;
}

References m_variables.

Referenced by export_SessionReader().

GetXMLElementTimeLevel()

void Nektar::LibUtilities::SessionReader::GetXMLElementTimeLevel ( TiXmlElement *&  element, const size_t  timeLevel, const bool  enableCheck = true  )

static

Get XML elment time level (Parallel-in-Time)

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

{
    if (Element && Element->FirstChildElement("TIMELEVEL"))
    {
        Element = Element->FirstChildElement("TIMELEVEL");
        std::string timeLevelStr;
        while (Element)
        {
            std::stringstream tagcontent;
            tagcontent << *Element;
            ASSERTL0(Element->Attribute("VALUE"),
                     "Missing LEVEL attribute in solver info "
                     "XML element: \n\t'" +
                         tagcontent.str() + "'");
            timeLevelStr = Element->Attribute("VALUE");
            ASSERTL0(!timeLevelStr.empty(),
                     "LEVEL attribute must be non-empty in XML "
                     "element: \n\t'" +
                         tagcontent.str() + "'");
            if (stoi(timeLevelStr) == timeLevel)
            {
                break;
            }
            Element = Element->NextSiblingElement("TIMELEVEL");
        }
        if (enableCheck)
        {
            ASSERTL0(stoi(timeLevelStr) == timeLevel,
                     "TIMELEVEL value " + std::to_string(timeLevel) +
                         " not found in solver info "
                         "XML element: \n\t'");
        }
    }
}

References ASSERTL0.

Referenced by Nektar::Collections::CollectionOptimisation::CollectionOptimisation(), Nektar::GlobalMapping::Mapping::Load(), Nektar::SolverUtils::Forcing::Load(), Nektar::SpatialDomains::BoundaryConditions::ReadBoundaryConditions(), Nektar::SpatialDomains::BoundaryConditions::ReadBoundaryRegions(), Nektar::SpatialDomains::MeshPartition::ReadConditions(), Nektar::SpatialDomains::MeshGraph::ReadExpansionInfo(), Nektar::SpatialDomains::MeshPartition::ReadExpansions(), ReadFilters(), ReadFunctions(), ReadGlobalSysSolnInfo(), ReadParameters(), ReadSolverInfo(), ReadTimeIntScheme(), ReadVariables(), Nektar::GlobalMapping::Mapping::ReplaceField(), Nektar::Collections::CollectionOptimisation::UpdateOptFile(), Nektar::SpatialDomains::MeshGraphIOHDF5::v_PartitionMesh(), and Nektar::SpatialDomains::MeshGraphIOXml::WriteXMLGeometry().

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

{
    // Re-load filenames for session if required.
    if (filenames.size() > 0)
    {
        m_filenames = filenames;
    }
 
    // check specified  opt file
    std::string optfile;
    int exists;
 
    if (DefinesCmdLineArgument("use-opt-file"))
    {
        optfile =
            m_cmdLineOptions.find("use-opt-file")->second.as<std::string>();
        exists = fs::exists(optfile.c_str());
        ASSERTL0(exists, "A valid .opt file was not specified "
                         "with the --use-opt-file command line option");
 
        m_filenames.push_back(optfile);
 
        // put opt file at beginning
        std::rotate(m_filenames.rbegin(), m_filenames.rbegin() + 1,
                    m_filenames.rend());
    }
    else // check for write-opt-file
    {
        // check for opt file
        optfile = m_sessionName.substr(0, m_sessionName.find("_xml/")) + ".opt";
        exists  = fs::exists(optfile.c_str());
 
        // For Paralell-in-Time
        if (exists && m_comm->IsParallelInTime())
        {
            TiXmlDocument doc;
            doc.LoadFile(optfile);
            TiXmlElement *xmlTag = doc.FirstChildElement("NEKTAR")
                                       ->FirstChildElement("COLLECTIONS")
                                       ->FirstChildElement("TIMELEVEL");
            if (xmlTag)
            {
                // if there is a TIMELEVEL tag, then turn existing flag to false
                // and check if the required time level is specified in the
                // optfile.
                exists = false;
                while (xmlTag)
                {
                    if (m_timeLevel == stoi(xmlTag->Attribute("VALUE")))
                    {
                        exists = true;
                        break;
                    }
                    xmlTag = xmlTag->NextSiblingElement();
                }
            }
        }
 
        if (exists)
        {
            m_filenames.push_back(optfile);
            // rotate order so opt file can be overwritten by
            // direct choice in xml file
            std::rotate(m_filenames.rbegin(), m_filenames.rbegin() + 1,
                        m_filenames.rend());
        }
        else
        {
            m_updateOptFile = true;
        }
    }
 
    // 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();
 
    // Disable backups if NEKTAR_DISABLE_BACKUPS is set.
    if (std::getenv("NEKTAR_DISABLE_BACKUPS") != nullptr)
    {
        m_backups = false;
    }
 
    // 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;
        }
    }
}

References ASSERTL0, CmdLineOverride(), DefinesCmdLineArgument(), m_backups, m_cmdLineOptions, m_comm, m_filenames, m_parameters, m_sessionName, m_solverInfo, m_timeLevel, m_updateOptFile, m_verbose, m_xmlDoc, MergeDoc(), ParseDocument(), and VerifySolverInfo().

Referenced by export_SessionReader().

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 1539 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->GetSpaceComm()->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, Nektar::ErrorUtil::efatal, m_comm, NEKERROR, and Nektar::LibUtilities::PortablePath().

Referenced by MergeDoc().

LoadParameter() [1/8]

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

Load an integer parameter.

Definition at line 823 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, and m_parameters.

LoadParameter() [2/8]

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

References m_parameters.

LoadParameter() [3/8]

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

Load a double precision parameter.

Definition at line 920 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, and m_parameters.

LoadParameter() [4/8]

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

References m_parameters.

LoadParameter() [5/8]

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

Load an size_t parameter.

Definition at line 888 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, and m_parameters.

LoadParameter() [6/8]

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

Check for and load an size_t parameter.

Definition at line 901 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;
    }
}

References m_parameters.

LoadParameter() [7/8]

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

Load an unsigned integer parameter.

Definition at line 855 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<unsigned int>(param);
}

References ASSERTL0, and m_parameters.

LoadParameter() [8/8]

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

Check for and load an unsigned integer parameter.

Definition at line 869 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<unsigned int>(param);
    }
    else
    {
        pVar = pDefault;
    }
}

References m_parameters.

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

References m_solverInfo.

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

References DefinesSolverInfo(), and m_solverInfo.

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

References m_solverInfo.

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

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

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 1586 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 =
        GetChildElementOrThrow(pFilenames[0], "NEKTAR", vMainHandle);
 
    // 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) ||
            (pFilenames[i].compare(pFilenames[i].size() - 3, 3, "opt") == 0))
        {
            TiXmlDocument *vTempDoc = new TiXmlDocument;
            LoadDoc(pFilenames[i], vTempDoc);
 
            TiXmlHandle docHandle(vTempDoc);
            TiXmlElement *vTempNektar =
                GetChildElementOrThrow(pFilenames[i], "NEKTAR", docHandle);
            TiXmlElement *p = vTempNektar->FirstChildElement();
 
            while (p)
            {
                TiXmlElement *vMainEntry =
                    vMainNektar->FirstChildElement(p->Value());
 
                // First check if the new item is in fact blank
                // replace if it is a COLLECTIONS section however.
                if (!p->FirstChild() && vMainEntry &&
                    !boost::iequals(p->Value(), "COLLECTIONS"))
                {
                    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, Nektar::ErrorUtil::ewarning, Nektar::LibUtilities::GetChildElementOrThrow(), LoadDoc(), and NEKERROR.

Referenced by InitSession().

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

{
    // List the publically visible options (listed using --help).
    po::options_description desc("Allowed options");
    po::options_description dep("Deprecated options");
 
    // clang-format off
    desc.add_options()
        ("force-output,f","disables backups files and forces output to be "
                          "written without any checks")
        ("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")
        ("verbose,v",    "be verbose")
        ("version,V",    "print version information")
        ("no-exp-opt",   "Do not use expansion optimisation for collections")
        ("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")
        ("npt",          po::value<int>(),
                         "number of procs in T-dir (parareal)")
        ("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")
        ("write-opt-file","write an optimisation file")
        ("use-opt-file", po::value<std::string>(),
                         "use an optimisation file");
    // clang-format on
 
#ifdef NEKTAR_USE_CWIPI
    desc.add_options()("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());
        }
    }
 
    // Deprecated options: introduced in 5.4.0 to homogenise command-line
    // options to use '-' instead of camelCase or no spaces.
    std::map<std::string, std::string> deprecated = {
        {"forceoutput", "force-output"},
        {"writeoptfile", "write-opt-file"},
        {"useoptfile", "use-opt-file"}};
 
    for (auto &d : deprecated)
    {
        std::string description = "Deprecated: use --" + d.second;
        dep.add_options()(d.first.c_str(), 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(dep).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);
    }
 
    // Deal with deprecated options.
    for (auto &d : deprecated)
    {
        if (m_cmdLineOptions.count(d.first))
        {
            std::cerr << "Warning: --" << d.first << " deprecated: use --"
                      << d.second << std::endl;
            m_cmdLineOptions.emplace(
                d.second, po::variable_value(m_cmdLineOptions[d.first]));
        }
    }
 
    // Enable verbose mode
    if (m_cmdLineOptions.count("verbose"))
    {
        m_verbose = true;
    }
    else
    {
        m_verbose = false;
    }
 
    // Disable backups
    if (m_cmdLineOptions.count("force-output"))
    {
        m_backups = false;
    }
    else
    {
        m_backups = true;
    }
 
    // Enable update optimisation file
    if (m_cmdLineOptions.count("write-opt-file"))
    {
        m_updateOptFile = true;
    }
    else
    {
        m_updateOptFile = 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 GetCmdLineArgMap(), Nektar::NekConstants::kGitBranch, Nektar::NekConstants::kGitSha1, m_backups, m_cmdLineOptions, m_updateOptFile, m_verbose, and NEKTAR_VERSION.

Referenced by SessionReader(), and SessionReader().

ParseDocument()

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

private

Loads and parses the specified file.

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

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

References ASSERTL0, m_xmlDoc, ReadFilters(), ReadFunctions(), ReadGlobalSysSolnInfo(), ReadParameters(), ReadSolverInfo(), ReadTimeIntScheme(), and ReadVariables().

Referenced by InitSession().

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

Referenced by CmdLineOverride(), and ReadParameters().

ParseSessionName()

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

private

Parse the session name.

Definition at line 640 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.

Referenced by SessionReader(), and SessionReader().

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.

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

{
    if (m_comm->GetSize() > 1)
    {
        int nProcZ  = 1;
        int nProcY  = 1;
        int nProcX  = 1;
        int nStripZ = 1;
        int nTime   = 0;
        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");
        }
        if (DefinesCmdLineArgument("npt"))
        {
            nTime = GetCmdLineArgument<int>("npt");
        }
 
        if (nTime)
        {
            ASSERTL0(m_comm->GetSize() % nTime == 0,
                     "Cannot exactly partition time using npt value.");
            ASSERTL0((m_comm->GetSize() / nTime) % (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.");
        }
        else
        {
            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 = nTime ? m_comm->GetSize() / nTime / nProcSm
                             : m_comm->GetSize() / nProcSm;
 
        m_comm->SplitComm(nProcSm, nProcSem, nTime);
        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, DefinesCmdLineArgument(), and m_comm.

Referenced by SessionReader(), and SessionReader().

ReadFilters()

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

private

Reads the FILTERS section of the XML document.

Definition at line 2477 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");
 
        int domainID = -1;
        if (filter->Attribute("DOMAIN"))
        {
            // domainID = int(filter->Attribute("DOMAIN"));
            int err = filter->QueryIntAttribute("DOMAIN", &domainID);
            ASSERTL0(err == TIXML_SUCCESS,
                     "Unable to read attribute DOMAIN in filter.");
        }
 
        std::map<std::string, std::string> vParams;
 
        TiXmlElement *element = filter;
        GetXMLElementTimeLevel(element, m_timeLevel, false);
        TiXmlElement *param = element->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");
        }
 
        FilterDefinition filterDef;
        filterDef.domain = domainID;
        filterDef.name   = typeStr;
        filterDef.params = vParams;
        m_filters.push_back(filterDef);
 
        filter = filter->NextSiblingElement("FILTER");
    }
}

References ASSERTL0, Nektar::LibUtilities::FilterDefinition::domain, GetXMLElementTimeLevel(), m_filters, m_timeLevel, Nektar::LibUtilities::FilterDefinition::name, and Nektar::LibUtilities::FilterDefinition::params.

Referenced by ParseDocument().

ReadFunctions()

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

private

Reads the FUNCTIONS section of the XML document.

Definition at line 2252 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 *element = function;
        GetXMLElementTimeLevel(element, m_timeLevel, false);
        TiXmlElement *variable = element->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 is specified, put to 0
            std::string domainStr;
            if (!variable->Attribute("DOMAIN"))
            {
                domainStr = "0";
            }
            else
            {
                domainStr = variable->Attribute("DOMAIN");
            }
 
            // Parse list of domains
            std::vector<std::string> varSplit;
            std::vector<unsigned int> domainList;
            ParseUtils::GenerateSeqVector(domainStr, domainList);
 
            // if no evars is specified, put "x y z t"
            std::string evarsStr = "x y z t";
            if (variable->Attribute("EVARS"))
            {
                evarsStr =
                    evarsStr + std::string(" ") + variable->Attribute("EVARS");
            }
 
            // 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());
 
                // set expression
                funcDef.m_expression =
                    MemoryManager<Equation>::AllocateSharedPtr(
                        m_interpreter, fcnStr, evarsStr);
            }
 
            // Files are denoted by F
            else if (conditionType == "F")
            {
                // Check if transient or not
                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
                fs::path fullpath = fSplit[0];
                fs::path ftype    = fullpath.extension();
                if (fullpath.parent_path().extension() == ".pit")
                {
                    string filename = fullpath.stem().string();
                    fullpath        = fullpath.parent_path();
                    size_t start    = filename.find_last_of("_") + 1;
                    int index =
                        atoi(filename.substr(start, filename.size()).c_str());
                    fullpath /= filename.substr(0, start) +
                                std::to_string(
                                    index + m_comm->GetTimeComm()->GetRank()) +
                                ftype.string();
                }
                funcDef.m_filename = fullpath.string();
 
                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 " + std::to_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 Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::ErrorUtil::efatal, Nektar::LibUtilities::eFunctionTypeExpression, Nektar::LibUtilities::eFunctionTypeFile, Nektar::LibUtilities::eFunctionTypeTransientFile, Nektar::ParseUtils::GenerateSeqVector(), Nektar::ParseUtils::GenerateVector(), GetXMLElementTimeLevel(), m_comm, Nektar::LibUtilities::FunctionVariableDefinition::m_expression, Nektar::LibUtilities::FunctionVariableDefinition::m_filename, Nektar::LibUtilities::FunctionVariableDefinition::m_fileVariable, m_functions, m_interpreter, m_timeLevel, Nektar::LibUtilities::FunctionVariableDefinition::m_type, and NEKERROR.

Referenced by ParseDocument().

ReadGlobalSysSolnInfo()

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

private

Reads the GLOBALSYSSOLNINFO section of the XML document.

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

{
    GetGloSysSolnList().clear();
 
    if (!conditions)
    {
        return;
    }
 
    TiXmlElement *GlobalSys =
        conditions->FirstChildElement("GLOBALSYSSOLNINFO");
    GetXMLElementTimeLevel(GlobalSys, m_timeLevel);
 
    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, Nektar::ParseUtils::GenerateVector(), GetGloSysSolnList(), GetXMLElementTimeLevel(), m_comm, m_timeLevel, and m_verbose.

Referenced by ParseDocument().

ReadParameters()

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

private

Reads the PARAMETERS section of the XML document.

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

{
    m_parameters.clear();
 
    if (!conditions)
    {
        return;
    }
 
    TiXmlElement *parametersElement =
        conditions->FirstChildElement("PARAMETERS");
    GetXMLElementTimeLevel(parametersElement, m_timeLevel);
 
    // 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::ErrorUtil::efatal, Nektar::LibUtilities::Equation::Evaluate(), GetXMLElementTimeLevel(), m_interpreter, m_parameters, m_timeLevel, NEKERROR, and ParseEquals().

Referenced by ParseDocument().

ReadSolverInfo()

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

private

Reads the SOLVERINFO section of the XML document.

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

{
    m_solverInfo.clear();
    m_solverInfo = GetSolverInfoDefaults();
 
    if (!conditions)
    {
        return;
    }
 
    TiXmlElement *solverInfoElement =
        conditions->FirstChildElement("SOLVERINFO");
    GetXMLElementTimeLevel(solverInfoElement, m_timeLevel);
 
    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, GetSolverInfoDefaults(), GetXMLElementTimeLevel(), m_comm, m_solverInfo, and m_timeLevel.

Referenced by ParseDocument().

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

{
    if (!conditions)
    {
        return;
    }
 
    TiXmlElement *timeInt =
        conditions->FirstChildElement("TIMEINTEGRATIONSCHEME");
    GetXMLElementTimeLevel(timeInt, m_timeLevel);
 
    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 = std::stol(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] = std::stod(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, Nektar::ErrorUtil::efatal, Nektar::LibUtilities::TimeIntScheme::freeParams, GetXMLElementTimeLevel(), m_comm, m_timeIntScheme, m_timeLevel, m_verbose, Nektar::LibUtilities::TimeIntScheme::method, NEKERROR, Nektar::LibUtilities::TimeIntScheme::order, and Nektar::LibUtilities::TimeIntScheme::variant.

Referenced by ParseDocument().

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

{
    m_variables.clear();
 
    if (!conditions)
    {
        return;
    }
 
    TiXmlElement *variablesElement = conditions->FirstChildElement("VARIABLES");
    GetXMLElementTimeLevel(variablesElement, m_timeLevel);
 
    // 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 " +
                                   std::to_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 " + std::to_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, GetXMLElementTimeLevel(), m_timeLevel, and m_variables.

Referenced by ParseDocument().

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 625 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 641 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 614 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 580 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().

SetGlobalSysSolnInfo()

void Nektar::LibUtilities::SessionReader::SetGlobalSysSolnInfo	(	const std::string &	variable,
		const std::string &	property,
		const std::string &	value
	)

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

{
 
    std::string vProperty = boost::to_upper_copy(pProperty);
 
    auto iter = GetGloSysSolnList().find(pVariable);
    if (iter == GetGloSysSolnList().end())
    {
        (GetGloSysSolnList()[pVariable])[vProperty] = pValue;
    }
    else
    {
        iter->second[vProperty] = pValue;
    }
}

References GetGloSysSolnList().

SetParameter() [1/4]

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

Set an integer parameter.

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

{
    std::string vName   = boost::to_upper_copy(pName);
    m_parameters[vName] = pVar;
    m_interpreter->SetParameter(pName, pVar);
}

References m_interpreter, and m_parameters.

Referenced by export_SessionReader().

SetParameter() [2/4]

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

Set a double precision parameter.

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

{
    std::string vName   = boost::to_upper_copy(pName);
    m_parameters[vName] = pVar;
    m_interpreter->SetParameter(pName, pVar);
}

References m_interpreter, and m_parameters.

SetParameter() [3/4]

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

Set an size_t parameter.

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

{
    std::string vName   = boost::to_upper_copy(pName);
    m_parameters[vName] = pVar;
    m_interpreter->SetParameter(pName, pVar);
}

References m_interpreter, and m_parameters.

SetParameter() [4/4]

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

Set an unsigned integer parameter.

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

{
    std::string vName   = boost::to_upper_copy(pName);
    m_parameters[vName] = pVar;
    m_interpreter->SetParameter(pName, pVar);
}

References m_interpreter, and m_parameters.

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 1016 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, and m_solverInfo.

Referenced by export_SessionReader().

SetTag()

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

Sets a specified tag.

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

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

References m_tags.

SetUpdateOptFile()

void Nektar::LibUtilities::SessionReader::SetUpdateOptFile ( bool  flag )

inline

Set bool to update optimisation file.

Definition at line 388 of file SessionReader.h.

    {
        m_updateOptFile = flag;
    }

References m_updateOptFile.

SetVariable()

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

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

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

References ASSERTL0, and m_variables.

TestSharedFilesystem()

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

private

Definition at line 398 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 = fs::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, m_comm, m_sharedFilesystem, m_verbose, and Nektar::LibUtilities::ReduceSum.

Referenced by SessionReader(), and SessionReader().

VerifySolverInfo()

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

private

Check values of solver info options are valid.

Definition at line 2635 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, GetSolverInfoEnums(), and m_solverInfo.

Referenced by InitSession().

Friends And Related Symbol Documentation

MemoryManager< SessionReader >

friend class MemoryManager< SessionReader >

friend

Support creation through MemoryManager.

Definition at line 111 of file SessionReader.h.

Member Data Documentation

m_backups

bool Nektar::LibUtilities::SessionReader::m_backups = true

private

Backups.

Definition at line 440 of file SessionReader.h.

Referenced by GetBackups(), InitSession(), and ParseCommandLineArguments().

m_cmdLineOptions

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

private

Definition at line 405 of file SessionReader.h.

Referenced by CmdLineOverride(), CreateComm(), DefinesCmdLineArgument(), GetCmdLineArgument(), InitSession(), and ParseCommandLineArguments().

m_comm

CommSharedPtr Nektar::LibUtilities::SessionReader::m_comm

private

Communication object.

Definition at line 408 of file SessionReader.h.

Referenced by CreateComm(), Finalise(), GetComm(), InitSession(), LoadDoc(), PartitionComm(), ReadFunctions(), ReadGlobalSysSolnInfo(), ReadSolverInfo(), ReadTimeIntScheme(), SessionReader(), SessionReader(), and TestSharedFilesystem().

m_filenames

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

private

Filenames.

Definition at line 410 of file SessionReader.h.

Referenced by GetFilenames(), InitSession(), SessionReader(), and SessionReader().

m_filters

FilterMap Nektar::LibUtilities::SessionReader::m_filters

private

Filters map.

Definition at line 430 of file SessionReader.h.

Referenced by GetFilters(), and ReadFilters().

m_functions

FunctionMap Nektar::LibUtilities::SessionReader::m_functions

private

Functions.

Definition at line 424 of file SessionReader.h.

Referenced by DefinesFunction(), DefinesFunction(), GetFunction(), GetFunctionFilename(), GetFunctionFilenameVariable(), GetFunctionType(), and ReadFunctions().

m_geometricInfo

GeometricInfoMap Nektar::LibUtilities::SessionReader::m_geometricInfo

private

Geometric information properties.

Definition at line 420 of file SessionReader.h.

m_interpreter

InterpreterSharedPtr Nektar::LibUtilities::SessionReader::m_interpreter

private

Interpreter instance.

Definition at line 422 of file SessionReader.h.

Referenced by CmdLineOverride(), GetInterpreter(), ReadFunctions(), ReadParameters(), SessionReader(), SessionReader(), SetParameter(), SetParameter(), SetParameter(), and SetParameter().

m_parameters

ParameterMap Nektar::LibUtilities::SessionReader::m_parameters

private

Parameters.

Definition at line 416 of file SessionReader.h.

Referenced by CmdLineOverride(), DefinesParameter(), GetParameter(), GetParameters(), InitSession(), LoadParameter(), LoadParameter(), LoadParameter(), LoadParameter(), LoadParameter(), LoadParameter(), LoadParameter(), LoadParameter(), ReadParameters(), SetParameter(), SetParameter(), SetParameter(), and SetParameter().

m_sessionName

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

private

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

Definition at line 412 of file SessionReader.h.

Referenced by GetSessionName(), InitSession(), SessionReader(), and SessionReader().

m_sharedFilesystem

bool Nektar::LibUtilities::SessionReader::m_sharedFilesystem

private

Running on a shared filesystem.

Definition at line 438 of file SessionReader.h.

Referenced by GetSharedFilesystem(), and TestSharedFilesystem().

m_solverInfo

SolverInfoMap Nektar::LibUtilities::SessionReader::m_solverInfo

private

Solver information properties.

Definition at line 418 of file SessionReader.h.

Referenced by CmdLineOverride(), DefinesSolverInfo(), GetSolverInfo(), InitSession(), LoadSolverInfo(), MatchSolverInfo(), MatchSolverInfo(), ReadSolverInfo(), SetSolverInfo(), and VerifySolverInfo().

m_tags

TagMap Nektar::LibUtilities::SessionReader::m_tags

private

Custom tags.

Definition at line 428 of file SessionReader.h.

Referenced by DefinesTag(), GetTag(), and SetTag().

m_timeIntScheme

TimeIntScheme Nektar::LibUtilities::SessionReader::m_timeIntScheme

private

Time integration scheme information.

Definition at line 432 of file SessionReader.h.

Referenced by DefinesTimeIntScheme(), GetTimeIntScheme(), and ReadTimeIntScheme().

m_timeLevel

size_t Nektar::LibUtilities::SessionReader::m_timeLevel = 0

private

Time level.

Definition at line 434 of file SessionReader.h.

Referenced by GetTimeLevel(), InitSession(), ReadFilters(), ReadFunctions(), ReadGlobalSysSolnInfo(), ReadParameters(), ReadSolverInfo(), ReadTimeIntScheme(), ReadVariables(), and SessionReader().

m_updateOptFile

bool Nektar::LibUtilities::SessionReader::m_updateOptFile

private

Update optimisation file.

Definition at line 442 of file SessionReader.h.

Referenced by GetUpdateOptFile(), InitSession(), ParseCommandLineArguments(), and SetUpdateOptFile().

m_variables

VariableList Nektar::LibUtilities::SessionReader::m_variables

private

Variables.

Definition at line 426 of file SessionReader.h.

Referenced by GetFunction(), GetFunctionFilename(), GetFunctionType(), GetVariable(), GetVariables(), ReadVariables(), and SetVariable().

m_verbose

bool Nektar::LibUtilities::SessionReader::m_verbose

private

Be verbose.

Definition at line 436 of file SessionReader.h.

Referenced by InitSession(), ParseCommandLineArguments(), ReadGlobalSysSolnInfo(), ReadTimeIntScheme(), and TestSharedFilesystem().

m_xmlDoc

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

private

Pointer to the loaded XML document.

Definition at line 414 of file SessionReader.h.

Referenced by DefinesElement(), GetDocument(), GetElement(), GetGeometryType(), InitSession(), ParseDocument(), SessionReader(), SessionReader(), and ~SessionReader().