Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Member Functions | Static Public Member Functions | Private Member Functions | Static Private Member Functions | Private Attributes | Friends | List of all members
Nektar::LibUtilities::SessionReader Class Reference

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

#include <SessionReader.h>

Collaboration diagram for Nektar::LibUtilities::SessionReader:
Collaboration graph
[legend]

Public Member Functions

 SessionReader (int argc, char *argv[], const std::vector< std::string > &pFilenames, const CommSharedPtr &pComm)
 ~SessionReader ()
 Destructor.
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.
const std::string GetSessionNameRank () const
 Returns the session name with process rank.
CommSharedPtr & GetComm ()
 Returns the communication object.
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.
void LoadParameter (const std::string &name, int &var) const
 Load an integer 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, 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, 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 DefinesGlobalSysSolnInfo (const std::string &variable, const std::string &property) const
const std::string & GetGlobalSysSolnInfo (const std::string &variable, const std::string &property) const
bool DefinesGeometricInfo (const std::string &name) const
 Checks if a geometric info property is defined.
void LoadGeometricInfo (const std::string &name, std::string &var, const std::string &def="") const
 Checks for and load a geometric info string property.
void LoadGeometricInfo (const std::string &name, bool &var, const bool &def=false) const
 Checks for and loads a geometric info boolean property.
void LoadGeometricInfo (const std::string &name, NekDouble &var, const NekDouble &def=0.0) const
 Checks for and loads a geometric info double-precision property.
void MatchGeometricInfo (const std::string &name, const std::string &trueval, bool &var, const bool &def=false) const
 Check if the value of a geometric info string property matches.
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.
AnalyticExpressionEvaluator & GetExpressionEvaluator ()
 Returns the instance of AnalyticExpressionEvaluator 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.
void SubstituteExpressions (std::string &expr)
 Substitutes expressions defined in the XML document.
CompositeOrdering GetCompositeOrdering () const
BndRegionOrdering GetBndRegionOrdering () const
void SetUpXmlDoc ()

Static Public Member Functions

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

Private Member Functions

 SessionReader (int argc, char *argv[])
 Main constructor.
void InitSession ()
SessionReaderSharedPtr GetSharedThisPtr ()
 Returns a shared pointer to the current object.
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 PartitionMesh ()
 Partitions the mesh when running in parallel.
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 ReadExpressions (TiXmlElement *conditions)
 Reads the EXPRESSIONS 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 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.
ExpressionMap m_expressions
 Expressions.
AnalyticExpressionEvaluator m_exprEvaluator
 Analytic expression evaluator instance.
FunctionMap m_functions
 Functions.
VariableList m_variables
 Variables.
TagMap m_tags
 Custom tags.
FilterMap m_filters
 Filters map.
bool m_verbose
 Be verbose.
CompositeOrdering m_compOrder
 Map of original composite ordering for parallel periodic bcs.
BndRegionOrdering m_bndRegOrder
 Map of original boundary region ordering for parallel periodic bcs.

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

Constructor & Destructor Documentation

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

Definition at line 210 of file SessionReader.cpp.

References ASSERTL0.

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

Destructor.

Definition at line 253 of file SessionReader.cpp.

{
delete m_xmlDoc;
}
Nektar::LibUtilities::SessionReader::SessionReader ( int  argc,
char *  argv[] 
)
private

Main constructor.

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

Parameters
argcNumber of command-line arguments
argvArray of command-line arguments

Definition at line 185 of file SessionReader.cpp.

References ASSERTL0.

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

Member Function Documentation

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

Enforce parameters from command line arguments.

Definition at line 2563 of file SessionReader.cpp.

References ASSERTL0, and Nektar::lhs.

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

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

Definition at line 1507 of file SessionReader.cpp.

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

{
if (argc == 0)
{
m_comm = GetCommFactory().CreateInstance("Serial", 0, 0);
}
else
{
string vCommModule("Serial");
if (GetCommFactory().ModuleExists("ParallelMPI"))
{
vCommModule = "ParallelMPI";
}
m_comm = GetCommFactory().CreateInstance(vCommModule,argc,argv);
}
}
static SessionReaderSharedPtr Nektar::LibUtilities::SessionReader::CreateInstance ( int  argc,
char *  argv[] 
)
inlinestatic

Creates an instance of the SessionReader class.

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

Definition at line 140 of file SessionReader.h.

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

{
SessionReaderSharedPtr p = MemoryManager<
LibUtilities::SessionReader>::AllocateSharedPtr(argc, argv);
p->InitSession();
return p;
}
static SessionReaderSharedPtr Nektar::LibUtilities::SessionReader::CreateInstance ( int  argc,
char *  argv[],
std::vector< std::string > &  pFilenames,
const CommSharedPtr &  pComm = CommSharedPtr() 
)
inlinestatic

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

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

Definition at line 159 of file SessionReader.h.

{
SessionReaderSharedPtr p = MemoryManager<
LibUtilities::SessionReader>
::AllocateSharedPtr(argc, argv, pFilenames, pComm);
p->InitSession();
return p;
}
bool Nektar::LibUtilities::SessionReader::DefinesCmdLineArgument ( const std::string &  pName) const

Checks if a specified cmdline argument has been given.

Definition at line 1343 of file SessionReader.cpp.

{
return (m_cmdLineOptions.find(pName) != m_cmdLineOptions.end());
}
bool Nektar::LibUtilities::SessionReader::DefinesElement ( const std::string &  pPath) const

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

Definition at line 553 of file SessionReader.cpp.

References ASSERTL0.

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

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

Definition at line 1039 of file SessionReader.cpp.

{
FunctionMap::const_iterator it1;
std::string vName = boost::to_upper_copy(pName);
if ((it1 = m_functions.find(vName)) != m_functions.end())
{
return true;
}
return false;
}
bool Nektar::LibUtilities::SessionReader::DefinesFunction ( const std::string &  name,
const std::string &  variable,
const int  pDomain = 0 
) const

Checks if a specified function has a given variable defined.

Definition at line 1055 of file SessionReader.cpp.

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

Checks if a geometric info property is defined.

Definition at line 904 of file SessionReader.cpp.

{
std::string vName = boost::to_upper_copy(pName);
GeometricInfoMap::const_iterator iter = m_geometricInfo.find(vName);
return (iter != m_geometricInfo.end());
}
bool Nektar::LibUtilities::SessionReader::DefinesGlobalSysSolnInfo ( const std::string &  variable,
const std::string &  property 
) const

Definition at line 858 of file SessionReader.cpp.

{
GloSysSolnInfoList::const_iterator iter =
GetGloSysSolnList().find(pVariable);
if(iter == GetGloSysSolnList().end())
{
return false;
}
std::string vProperty = boost::to_upper_copy(pProperty);
GloSysInfoMap::const_iterator iter1 = iter->second.find(vProperty);
if(iter1 == iter->second.end())
{
return false;
}
return true;
}
bool Nektar::LibUtilities::SessionReader::DefinesParameter ( const std::string &  name) const

Checks if a parameter is specified in the XML document.

Definition at line 631 of file SessionReader.cpp.

{
std::string vName = boost::to_upper_copy(pName);
ParameterMap::const_iterator paramIter = m_parameters.find(vName);
return (paramIter != m_parameters.end());
}
bool Nektar::LibUtilities::SessionReader::DefinesSolverInfo ( const std::string &  name) const

Checks if a solver info property is specified.

Definition at line 754 of file SessionReader.cpp.

Referenced by GetSolverInfoAsEnum().

{
std::string vName = boost::to_upper_copy(pName);
SolverInfoMap::const_iterator infoIter = m_solverInfo.find(vName);
return (infoIter != m_solverInfo.end());
}
bool Nektar::LibUtilities::SessionReader::DefinesTag ( const std::string &  pName) const

Checks if a specified tag is defined.

Definition at line 1298 of file SessionReader.cpp.

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

Finalises the session.

This routine finalises any parallel communication.

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

Definition at line 622 of file SessionReader.cpp.

{
m_comm->Finalise();
}
BndRegionOrdering Nektar::LibUtilities::SessionReader::GetBndRegionOrdering ( ) const

Definition at line 1368 of file SessionReader.cpp.

{
return m_bndRegOrder;
}
CmdLineArgMap & Nektar::LibUtilities::SessionReader::GetCmdLineArgMap ( )
staticprivate

CmdLine argument map.

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

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

Definition at line 170 of file SessionReader.cpp.

Referenced by RegisterCmdLineArgument(), and RegisterCmdLineFlag().

{
static CmdLineArgMap cmdLineArguments;
return cmdLineArguments;
}
template<typename T >
T Nektar::LibUtilities::SessionReader::GetCmdLineArgument ( const std::string &  pName) const
inline

Retrieves a command-line argument value.

Definition at line 404 of file SessionReader.h.

References m_cmdLineOptions.

{
return m_cmdLineOptions.find(pName)->second.as<T>();
}
CommSharedPtr & Nektar::LibUtilities::SessionReader::GetComm ( )

Returns the communication object.

Definition at line 610 of file SessionReader.cpp.

{
return m_comm;
}
CompositeOrdering Nektar::LibUtilities::SessionReader::GetCompositeOrdering ( ) const

Definition at line 1363 of file SessionReader.cpp.

{
return m_compOrder;
}
TiXmlDocument & Nektar::LibUtilities::SessionReader::GetDocument ( )

Provides direct access to the TiXmlDocument object.

Definition at line 501 of file SessionReader.cpp.

References ASSERTL1.

{
ASSERTL1(m_xmlDoc, "XML Document not defined.");
return *m_xmlDoc;
}
TiXmlElement * Nektar::LibUtilities::SessionReader::GetElement ( const std::string &  pPath)

Provides direct access to the TiXmlElement specified.

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

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

the PARAMETERS element would be retrieved by requesting the path:

Nektar/Conditions/Parameters
Note
Paths are case-insensitive.
Parameters
pPathPath to requested element.
Returns
Direct pointer to requested XML Element.

Definition at line 530 of file SessionReader.cpp.

References ASSERTL0.

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

Returns the instance of AnalyticExpressionEvaluator specific to this session.

Definition at line 1289 of file SessionReader.cpp.

{
return m_exprEvaluator;
}
const std::vector< std::string > & Nektar::LibUtilities::SessionReader::GetFilenames ( ) const

Returns the filename of the loaded XML document.

Definition at line 575 of file SessionReader.cpp.

{
return m_filenames;
}
const FilterMap & Nektar::LibUtilities::SessionReader::GetFilters ( ) const

Definition at line 1334 of file SessionReader.cpp.

{
return m_filters;
}
EquationSharedPtr Nektar::LibUtilities::SessionReader::GetFunction ( const std::string &  name,
const std::string &  variable,
const int  pDomain = 0 
) const

Returns an EquationSharedPtr to a given function variable.

Definition at line 1081 of file SessionReader.cpp.

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

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

Returns an EquationSharedPtr to a given function variable index.

Definition at line 1124 of file SessionReader.cpp.

References ASSERTL0.

{
ASSERTL0(pVar < m_variables.size(), "Variable index out of range.");
return GetFunction(pName, m_variables[pVar],pDomain);
}
std::string Nektar::LibUtilities::SessionReader::GetFunctionFilename ( const std::string &  name,
const std::string &  variable,
const int  pDomain = 0 
) const

Returns the filename to be loaded for a given variable.

Definition at line 1192 of file SessionReader.cpp.

References ASSERTL0.

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

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

Definition at line 1234 of file SessionReader.cpp.

References ASSERTL0.

{
ASSERTL0(pVar < m_variables.size(), "Variable index out of range.");
return GetFunctionFilename(pName, m_variables[pVar],pDomain);
}
std::string Nektar::LibUtilities::SessionReader::GetFunctionFilenameVariable ( const std::string &  name,
const std::string &  variable,
const int  pDomain = 0 
) const

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

Definition at line 1247 of file SessionReader.cpp.

References ASSERTL0.

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

Returns the type of a given function variable.

Definition at line 1137 of file SessionReader.cpp.

References ASSERTL0.

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

Returns the type of a given function variable index.

Definition at line 1179 of file SessionReader.cpp.

References ASSERTL0.

{
ASSERTL0(pVar < m_variables.size(), "Variable index out of range.");
return GetFunctionType(pName, m_variables[pVar],pDomain);
}
const std::string & Nektar::LibUtilities::SessionReader::GetGlobalSysSolnInfo ( const std::string &  variable,
const std::string &  property 
) const

Definition at line 884 of file SessionReader.cpp.

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

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

GlobalSysSoln Info map.

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

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

Definition at line 156 of file SessionReader.cpp.

{
static GloSysSolnInfoList gloSysSolnInfoList;
return gloSysSolnInfoList;
}
const NekDouble & Nektar::LibUtilities::SessionReader::GetParameter ( const std::string &  pName) const

Returns the value of the specified parameter.

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

Parameters
pNameThe name of a floating-point parameter.
Returns
The value of the floating-point parameter.

Definition at line 647 of file SessionReader.cpp.

References ASSERTL0.

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

Returns the session name of the loaded XML document.

Definition at line 584 of file SessionReader.cpp.

{
return m_sessionName;
}
const std::string Nektar::LibUtilities::SessionReader::GetSessionNameRank ( ) const

Returns the session name with process rank.

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

Definition at line 594 of file SessionReader.cpp.

References Nektar::LibUtilities::PortablePath().

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

Returns a shared pointer to the current object.

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

Definition at line 706 of file SessionReader.h.

{
return shared_from_this();
}
const std::string & Nektar::LibUtilities::SessionReader::GetSolverInfo ( const std::string &  pProperty) const

Returns the value of the specified solver info property.

Definition at line 765 of file SessionReader.cpp.

References ASSERTL1.

Referenced by GetSolverInfoAsEnum().

{
std::string vProperty = boost::to_upper_copy(pProperty);
SolverInfoMap::const_iterator iter = m_solverInfo.find(vProperty);
ASSERTL1(iter != m_solverInfo.end(),
"Unable to find requested property: " + pProperty);
return iter->second;
}
template<typename T >
const T Nektar::LibUtilities::SessionReader::GetSolverInfoAsEnum ( const std::string &  pName) const
inline

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

Definition at line 552 of file SessionReader.h.

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

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

Default solver info options.

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

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

Definition at line 140 of file SessionReader.cpp.

Referenced by RegisterDefaultSolverInfo().

{
static SolverInfoMap solverInfoMap;
return solverInfoMap;
}
EnumMapList & Nektar::LibUtilities::SessionReader::GetSolverInfoEnums ( )
staticprivate

String to enumeration map for Solver Info parameters.

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

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

Definition at line 125 of file SessionReader.cpp.

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

{
static EnumMapList solverInfoEnums;
return solverInfoEnums;
}
const std::string & Nektar::LibUtilities::SessionReader::GetTag ( const std::string &  pName) const

Returns the value of a specified tag.

Definition at line 1321 of file SessionReader.cpp.

References ASSERTL0.

{
std::string vName = boost::to_upper_copy(pName);
TagMap::const_iterator vTagIterator = m_tags.find(vName);
ASSERTL0(vTagIterator != m_tags.end(),
"Requested tag does not exist.");
return vTagIterator->second;
}
template<typename T >
const T Nektar::LibUtilities::SessionReader::GetValueAsEnum ( const std::string &  pName,
const std::string &  vValue 
) const
inline

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

Definition at line 579 of file SessionReader.h.

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

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

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

Definition at line 1007 of file SessionReader.cpp.

References ASSERTL0.

{
ASSERTL0(idx < m_variables.size(), "Variable index out of range.");
return m_variables[idx];
}
std::vector< std::string > Nektar::LibUtilities::SessionReader::GetVariables ( ) const

Returns the names of all variables.

Definition at line 1030 of file SessionReader.cpp.

{
return m_variables;
}
void Nektar::LibUtilities::SessionReader::InitSession ( )
private

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

Definition at line 265 of file SessionReader.cpp.

References Nektar::iterator.

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

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

Definition at line 1376 of file SessionReader.cpp.

References ASSERTL0, and Nektar::LibUtilities::PortablePath().

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

Checks for and load a geometric info string property.

Definition at line 915 of file SessionReader.cpp.

{
std::string vName = boost::to_upper_copy(pName);
GeometricInfoMap::const_iterator iter = m_geometricInfo.find(vName);
if(iter != m_geometricInfo.end())
{
pVar = iter->second;
}
else
{
pVar = pDefault;
}
}
void Nektar::LibUtilities::SessionReader::LoadGeometricInfo ( const std::string &  name,
bool &  var,
const bool &  def = false 
) const

Checks for and loads a geometric info boolean property.

Definition at line 936 of file SessionReader.cpp.

{
std::string vName = boost::to_upper_copy(pName);
GeometricInfoMap::const_iterator iter = m_geometricInfo.find(vName);
if(iter != m_geometricInfo.end())
{
if (iter->second == "TRUE")
{
pVar = true;
}
else
{
pVar = false;
}
}
else
{
pVar = pDefault;
}
}
void Nektar::LibUtilities::SessionReader::LoadGeometricInfo ( const std::string &  name,
NekDouble &  var,
const NekDouble &  def = 0.0 
) const

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

Definition at line 964 of file SessionReader.cpp.

{
std::string vName = boost::to_upper_copy(pName);
GeometricInfoMap::const_iterator iter = m_geometricInfo.find(vName);
if(iter != m_geometricInfo.end())
{
pVar = std::atoi(iter->second.c_str());
}
else
{
pVar = pDefault;
}
}
void Nektar::LibUtilities::SessionReader::LoadParameter ( const std::string &  name,
int &  var 
) const

Load an integer parameter.

Definition at line 663 of file SessionReader.cpp.

References ASSERTL0.

{
std::string vName = boost::to_upper_copy(pName);
ParameterMap::const_iterator paramIter = m_parameters.find(vName);
ASSERTL0(paramIter != m_parameters.end(), "Required parameter '" +
pName + "' not specified in session.");
pVar = (int)floor(paramIter->second);
}
void Nektar::LibUtilities::SessionReader::LoadParameter ( const std::string &  name,
int &  var,
const int &  def 
) const

Check for and load an integer parameter.

Definition at line 677 of file SessionReader.cpp.

{
std::string vName = boost::to_upper_copy(pName);
ParameterMap::const_iterator paramIter = m_parameters.find(vName);
if(paramIter != m_parameters.end())
{
pVar = (int)floor(paramIter->second);
}
else
{
pVar = pDefault;
}
}
void Nektar::LibUtilities::SessionReader::LoadParameter ( const std::string &  name,
NekDouble &  var 
) const

Load a double precision parameter.

Definition at line 696 of file SessionReader.cpp.

References ASSERTL0.

{
std::string vName = boost::to_upper_copy(pName);
ParameterMap::const_iterator paramIter = m_parameters.find(vName);
ASSERTL0(paramIter != m_parameters.end(), "Required parameter '" +
pName + "' not specified in session.");
pVar = paramIter->second;
}
void Nektar::LibUtilities::SessionReader::LoadParameter ( const std::string &  name,
NekDouble &  var,
const NekDouble &  def 
) const

Check for and load a double-precision parameter.

Definition at line 710 of file SessionReader.cpp.

{
std::string vName = boost::to_upper_copy(pName);
ParameterMap::const_iterator paramIter = m_parameters.find(vName);
if(paramIter != m_parameters.end())
{
pVar = paramIter->second;
}
else
{
pVar = pDefault;
}
}
void Nektar::LibUtilities::SessionReader::LoadSolverInfo ( const std::string &  name,
std::string &  var,
const std::string &  def = "" 
) const

Check for and load a solver info property.

Definition at line 795 of file SessionReader.cpp.

{
std::string vName = boost::to_upper_copy(pName);
SolverInfoMap::const_iterator infoIter = m_solverInfo.find(vName);
if(infoIter != m_solverInfo.end())
{
pVar = infoIter->second;
}
else
{
pVar = pDefault;
}
}
void Nektar::LibUtilities::SessionReader::MatchGeometricInfo ( const std::string &  name,
const std::string &  trueval,
bool &  var,
const bool &  def = false 
) const

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

Definition at line 985 of file SessionReader.cpp.

{
std::string vName = boost::to_upper_copy(pName);
GeometricInfoMap::const_iterator iter = m_geometricInfo.find(vName);
if(iter != m_geometricInfo.end())
{
pVar = boost::iequals(iter->second, pTrueVal);
}
else
{
pVar = pDefault;
}
}
void Nektar::LibUtilities::SessionReader::MatchSolverInfo ( const std::string &  name,
const std::string &  trueval,
bool &  var,
const bool &  def = false 
) const

Check if the value of a solver info property matches.

Definition at line 816 of file SessionReader.cpp.

{
std::string vName = boost::to_upper_copy(pName);
SolverInfoMap::const_iterator infoIter = m_solverInfo.find(vName);
if(infoIter != m_solverInfo.end())
{
pVar = boost::iequals(infoIter->second, pTrueVal);
}
else
{
pVar = pDefault;
}
}
bool Nektar::LibUtilities::SessionReader::MatchSolverInfo ( const std::string &  name,
const std::string &  trueval 
) const

Check if the value of a solver info property matches.

Definition at line 838 of file SessionReader.cpp.

{
if (DefinesSolverInfo(pName))
{
std::string vName = boost::to_upper_copy(pName);
SolverInfoMap::const_iterator iter = m_solverInfo.find(vName);
if(iter != m_solverInfo.end())
{
return true;
}
}
return false;
}
template<typename T >
bool Nektar::LibUtilities::SessionReader::MatchSolverInfoAsEnum ( const std::string &  name,
const T &  trueval 
) const
inline

Check if the value of a solver info property matches.

Definition at line 541 of file SessionReader.h.

{
return (GetSolverInfoAsEnum<T>(name) == trueval);
}
TiXmlDocument * Nektar::LibUtilities::SessionReader::MergeDoc ( const std::vector< std::string > &  pFilenames) const
private

Creates an XML document from a list of input files.

Definition at line 1425 of file SessionReader.cpp.

References ASSERTL0.

{
ASSERTL0(pFilenames.size() > 0, "No filenames for merging.");
// Read the first document
TiXmlDocument *vMainDoc = new TiXmlDocument;
LoadDoc(pFilenames[0], vMainDoc);
TiXmlHandle vMainHandle(vMainDoc);
TiXmlElement* vMainNektar =
vMainHandle.FirstChildElement("NEKTAR").Element();
// Read all subsequent XML documents.
// For each element within the NEKTAR tag, use it to replace the
// version already present in the loaded XML data.
for (int i = 1; i < pFilenames.size(); ++i)
{
if((pFilenames[i].compare(pFilenames[i].size()-3,3,"xml") == 0)
||(pFilenames[i].compare(pFilenames[i].size()-6,6,"xml.gz") == 0))
{
TiXmlDocument* vTempDoc = new TiXmlDocument;
LoadDoc(pFilenames[i], vTempDoc);
TiXmlHandle docHandle(vTempDoc);
TiXmlElement* vTempNektar;
vTempNektar = docHandle.FirstChildElement("NEKTAR").Element();
ASSERTL0(vTempNektar, "Unable to find NEKTAR tag in file.");
TiXmlElement* p = vTempNektar->FirstChildElement();
while (p)
{
TiXmlElement *vMainEntry =
vMainNektar->FirstChildElement(p->Value());
TiXmlElement *q = new TiXmlElement(*p);
if (vMainEntry)
{
vMainNektar->RemoveChild(vMainEntry);
}
vMainNektar->LinkEndChild(q);
p = p->NextSiblingElement();
}
delete vTempDoc;
}
}
return vMainDoc;
}
std::vector< std::string > Nektar::LibUtilities::SessionReader::ParseCommandLineArguments ( int  argc,
char *  argv[] 
)
private

Parse the program arguments and fill m_cmdLineOptions.

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

Definition at line 314 of file SessionReader.cpp.

References Nektar::iterator, Nektar::NekConstants::kGitBranch, Nektar::NekConstants::kGitSha1, and NEKTAR_VERSION.

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

Loads and parses the specified file.

Definition at line 1478 of file SessionReader.cpp.

References ASSERTL0.

{
// Check we actually have a document loaded.
ASSERTL0(m_xmlDoc, "No XML document loaded.");
// Look for all data in CONDITIONS block.
TiXmlHandle docHandle(m_xmlDoc);
TiXmlElement* e;
e = docHandle.FirstChildElement("NEKTAR").
FirstChildElement("CONDITIONS").Element();
// Read the various sections of the CONDITIONS block
ReadParameters (e);
ReadSolverInfo (e);
ReadGlobalSysSolnInfo (e);
ReadExpressions (e);
ReadVariables (e);
ReadFunctions (e);
e = docHandle.FirstChildElement("NEKTAR").
FirstChildElement("FILTERS").Element();
ReadFilters(e);
}
void Nektar::LibUtilities::SessionReader::ParseEquals ( const std::string &  line,
std::string &  lhs,
std::string &  rhs 
)
private

Parse a string in the form lhs = rhs.

Pull out lhs and rhs and eliminate any spaces.

Definition at line 2537 of file SessionReader.cpp.

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

Parse the session name.

Definition at line 463 of file SessionReader.cpp.

References ASSERTL0.

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

Partitions the comm object based on session parameters.

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

Definition at line 1811 of file SessionReader.cpp.

References ASSERTL0.

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

Partitions the mesh when running in parallel.

Definition at line 1531 of file SessionReader.cpp.

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

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

Reads the EXPRESSIONS section of the XML document.

Definition at line 2158 of file SessionReader.cpp.

References ASSERTL0, and Nektar::iterator.

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

Reads the FILTERS section of the XML document.

Definition at line 2496 of file SessionReader.cpp.

References ASSERTL0.

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

Reads the FUNCTIONS section of the XML document.

Definition at line 2293 of file SessionReader.cpp.

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

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

Reads the GLOBALSYSSOLNINFO section of the XML document.

Definition at line 2024 of file SessionReader.cpp.

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

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

Reads the PARAMETERS section of the XML document.

Definition at line 1853 of file SessionReader.cpp.

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

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

Reads the SOLVERINFO section of the XML document.

Definition at line 1938 of file SessionReader.cpp.

References ASSERTL0.

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

Reads the VARIABLES section of the XML document.

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

Definition at line 2210 of file SessionReader.cpp.

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

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

Registers a command-line argument with the session reader.

Definition at line 669 of file SessionReader.h.

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

{
ASSERTL0(!pName.empty(), "Empty name for cmdline argument.");
CmdLineArg x;
x.shortName = pShortName;
x.description = pDescription;
x.isFlag = false;
GetCmdLineArgMap()[pName] = x;
return pName;
}
std::string Nektar::LibUtilities::SessionReader::RegisterCmdLineFlag ( const std::string &  pName,
const std::string &  pShortName,
const std::string &  pDescription 
)
inlinestatic

Registers a command-line flag with the session reader.

Definition at line 687 of file SessionReader.h.

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

Referenced by main().

{
ASSERTL0(!pName.empty(), "Empty name for cmdline argument.");
CmdLineArg x;
x.shortName = pShortName;
x.description = pDescription;
x.isFlag = true;
GetCmdLineArgMap()[pName] = x;
return pName;
}
std::string Nektar::LibUtilities::SessionReader::RegisterDefaultSolverInfo ( const std::string &  pName,
const std::string &  pValue 
)
inlinestatic

Registers the default string value of a solver info property.

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

std::string GlobalLinSys::def
= LibUtilities::SessionReader::RegisterDefaultSolverInfo(
"GlobalSysSoln","DirectMultiLevelStaticCond");
Parameters
pNameThe name of the property.
pValueThe default value of the property.
Returns
The default value of the property provided by #pValue.

Definition at line 656 of file SessionReader.h.

References GetSolverInfoDefaults().

{
std::string vName = boost::to_upper_copy(pName);
GetSolverInfoDefaults()[vName] = pValue;
return pValue;
}
std::string Nektar::LibUtilities::SessionReader::RegisterEnumValue ( std::string  pEnum,
std::string  pString,
int  pEnumValue 
)
inlinestatic

Registers an enumeration value.

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

std::string GlobalLinSys::lookupIds[2] = {
LibUtilities::SessionReader::RegisterEnumValue(
"GlobalSysSoln",
"DirectFull",
MultiRegions::eDirectFullMatrix),
LibUtilities::SessionReader::RegisterEnumValue(
"GlobalSysSoln",
"DirectStaticCond",
MultiRegions::eDirectStaticCond)
}
Parameters
pEnumThe name of the property.
pStringA valid value for the property.
pEnumValueAn enumeration value corresponding to this value.
Returns
The value for the property provided by #pString.

Definition at line 623 of file SessionReader.h.

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

{
std::string vEnum = boost::to_upper_copy(pEnum);
EnumMapList::iterator x;
if ((x = GetSolverInfoEnums().find(vEnum)) ==
GetSolverInfoEnums().end())
{
GetSolverInfoEnums()[vEnum] = EnumMap();
x = GetSolverInfoEnums().find(vEnum);
}
x->second[pString] = pEnumValue;
return pString;
}
void Nektar::LibUtilities::SessionReader::SetParameter ( const std::string &  name,
int &  var 
)

Set an integer parameter.

Definition at line 732 of file SessionReader.cpp.

{
std::string vName = boost::to_upper_copy(pName);
m_parameters[vName] = pVar;
}
void Nektar::LibUtilities::SessionReader::SetParameter ( const std::string &  name,
NekDouble &  var 
)

Set a double precision parameter.

Definition at line 742 of file SessionReader.cpp.

{
std::string vName = boost::to_upper_copy(pName);
m_parameters[vName] = pVar;
}
void Nektar::LibUtilities::SessionReader::SetSolverInfo ( const std::string &  pProperty,
const std::string &  pValue 
)

Sets the value of the specified solver info property.

Definition at line 780 of file SessionReader.cpp.

References ASSERTL1, and Nektar::iterator.

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

Sets a specified tag.

Definition at line 1309 of file SessionReader.cpp.

{
std::string vName = boost::to_upper_copy(pName);
m_tags[vName] = pValue;
}
void Nektar::LibUtilities::SessionReader::SetUpXmlDoc ( void  )

Definition at line 2627 of file SessionReader.cpp.

{
m_xmlDoc = MergeDoc(m_filenames);
}
void Nektar::LibUtilities::SessionReader::SetVariable ( const unsigned int &  idx,
std::string  newname 
)

Definition at line 1019 of file SessionReader.cpp.

References ASSERTL0.

{
ASSERTL0(idx < m_variables.size(), "Variable index out of range.");
m_variables[idx] = newname;
}
void Nektar::LibUtilities::SessionReader::SubstituteExpressions ( std::string &  expr)

Substitutes expressions defined in the XML document.

Definition at line 1353 of file SessionReader.cpp.

References Nektar::iterator.

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

Friends And Related Function Documentation

friend class MemoryManager< SessionReader >
friend

Support creation through MemoryManager.

Definition at line 128 of file SessionReader.h.

Member Data Documentation

BndRegionOrdering Nektar::LibUtilities::SessionReader::m_bndRegOrder
private

Map of original boundary region ordering for parallel periodic bcs.

Definition at line 464 of file SessionReader.h.

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

Definition at line 430 of file SessionReader.h.

Referenced by GetCmdLineArgument().

CommSharedPtr Nektar::LibUtilities::SessionReader::m_comm
private

Communication object.

Definition at line 433 of file SessionReader.h.

CompositeOrdering Nektar::LibUtilities::SessionReader::m_compOrder
private

Map of original composite ordering for parallel periodic bcs.

Definition at line 461 of file SessionReader.h.

ExpressionMap Nektar::LibUtilities::SessionReader::m_expressions
private

Expressions.

Definition at line 447 of file SessionReader.h.

AnalyticExpressionEvaluator Nektar::LibUtilities::SessionReader::m_exprEvaluator
private

Analytic expression evaluator instance.

Definition at line 449 of file SessionReader.h.

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

Filenames.

Definition at line 435 of file SessionReader.h.

FilterMap Nektar::LibUtilities::SessionReader::m_filters
private

Filters map.

Definition at line 457 of file SessionReader.h.

FunctionMap Nektar::LibUtilities::SessionReader::m_functions
private

Functions.

Definition at line 451 of file SessionReader.h.

GeometricInfoMap Nektar::LibUtilities::SessionReader::m_geometricInfo
private

Geometric information properties.

Definition at line 445 of file SessionReader.h.

ParameterMap Nektar::LibUtilities::SessionReader::m_parameters
private

Parameters.

Definition at line 441 of file SessionReader.h.

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

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

Definition at line 437 of file SessionReader.h.

SolverInfoMap Nektar::LibUtilities::SessionReader::m_solverInfo
private

Solver information properties.

Definition at line 443 of file SessionReader.h.

TagMap Nektar::LibUtilities::SessionReader::m_tags
private

Custom tags.

Definition at line 455 of file SessionReader.h.

VariableList Nektar::LibUtilities::SessionReader::m_variables
private

Variables.

Definition at line 453 of file SessionReader.h.

bool Nektar::LibUtilities::SessionReader::m_verbose
private

Be verbose.

Definition at line 459 of file SessionReader.h.

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

Pointer to the loaded XML document.

Definition at line 439 of file SessionReader.h.

Generated on Wed Mar 4 2015 16:33:35 for Nektar++ by   doxygen 1.8.1.2