39 #include <boost/format.hpp>
45 namespace berrc = boost::system::errc;
49 namespace LibUtilities
63 :
FieldIO(pComm, sharedFilesystem)
88 std::vector<FieldDefinitionsSharedPtr> &fielddefs,
89 std::vector<std::vector<NekDouble>> &fielddata,
93 double tm0 = 0.0, tm1 = 0.0;
94 if (
m_comm->TreatAsRankZero())
100 ASSERTL1(fielddefs.size() == fielddata.size(),
101 "Length of fielddefs and fielddata incompatible");
102 for (
int f = 0; f < fielddefs.size(); ++f)
105 "Fielddata vector must contain at least one value.");
107 ASSERTL1(fielddata[f].size() == fielddefs[f]->m_fields.size() *
109 "Invalid size of fielddata vector.");
115 std::string filename =
SetUpOutput(outFile,
true, backup);
120 TiXmlDeclaration *decl =
new TiXmlDeclaration(
"1.0",
"utf-8",
"");
121 doc.LinkEndChild(decl);
123 TiXmlElement *root =
new TiXmlElement(
"NEKTAR");
124 doc.LinkEndChild(root);
128 for (
int f = 0; f < fielddefs.size(); ++f)
132 TiXmlElement *elemTag =
new TiXmlElement(
"ELEMENTS");
133 root->LinkEndChild(elemTag);
136 std::string fieldsString;
138 std::stringstream fieldsStringStream;
140 for (std::vector<int>::size_type i = 0;
141 i < fielddefs[f]->m_fields.size(); i++)
145 fieldsStringStream <<
",";
147 fieldsStringStream << fielddefs[f]->m_fields[i];
150 fieldsString = fieldsStringStream.str();
152 elemTag->SetAttribute(
"FIELDS", fieldsString);
155 std::string shapeString;
157 std::stringstream shapeStringStream;
158 shapeStringStream <<
ShapeTypeMap[fielddefs[f]->m_shapeType];
159 if (fielddefs[f]->m_numHomogeneousDir == 1)
161 shapeStringStream <<
"-HomogenousExp1D";
163 else if (fielddefs[f]->m_numHomogeneousDir == 2)
165 shapeStringStream <<
"-HomogenousExp2D";
168 if (fielddefs[f]->m_homoStrips)
170 shapeStringStream <<
"-Strips";
173 shapeString = shapeStringStream.str();
175 elemTag->SetAttribute(
"SHAPE", shapeString);
178 std::string basisString;
180 std::stringstream basisStringStream;
182 for (std::vector<BasisType>::size_type i = 0;
183 i < fielddefs[f]->m_basis.size(); i++)
187 basisStringStream <<
",";
189 basisStringStream <<
BasisTypeMap[fielddefs[f]->m_basis[i]];
192 basisString = basisStringStream.str();
194 elemTag->SetAttribute(
"BASIS", basisString);
197 if (fielddefs[f]->m_numHomogeneousDir)
199 std::string homoLenString;
201 std::stringstream homoLenStringStream;
203 for (
int i = 0; i < fielddefs[f]->m_numHomogeneousDir; ++i)
206 homoLenStringStream <<
",";
208 << fielddefs[f]->m_homogeneousLengths[i];
211 homoLenString = homoLenStringStream.str();
213 elemTag->SetAttribute(
"HOMOGENEOUSLENGTHS", homoLenString);
217 if (fielddefs[f]->m_numHomogeneousDir)
219 if (fielddefs[f]->m_homogeneousYIDs.size() > 0)
221 std::string homoYIDsString;
223 std::stringstream homoYIDsStringStream;
225 for (
int i = 0; i < fielddefs[f]->m_homogeneousYIDs.size();
230 homoYIDsStringStream <<
",";
233 << fielddefs[f]->m_homogeneousYIDs[i];
236 homoYIDsString = homoYIDsStringStream.str();
238 elemTag->SetAttribute(
"HOMOGENEOUSYIDS", homoYIDsString);
241 if (fielddefs[f]->m_homogeneousZIDs.size() > 0)
243 std::string homoZIDsString;
245 std::stringstream homoZIDsStringStream;
247 for (
int i = 0; i < fielddefs[f]->m_homogeneousZIDs.size();
252 homoZIDsStringStream <<
",";
255 << fielddefs[f]->m_homogeneousZIDs[i];
258 homoZIDsString = homoZIDsStringStream.str();
260 elemTag->SetAttribute(
"HOMOGENEOUSZIDS", homoZIDsString);
263 if (fielddefs[f]->m_homogeneousSIDs.size() > 0)
265 std::string homoSIDsString;
267 std::stringstream homoSIDsStringStream;
269 for (
int i = 0; i < fielddefs[f]->m_homogeneousSIDs.size();
274 homoSIDsStringStream <<
",";
277 << fielddefs[f]->m_homogeneousSIDs[i];
280 homoSIDsString = homoSIDsStringStream.str();
282 elemTag->SetAttribute(
"HOMOGENEOUSSIDS", homoSIDsString);
287 std::string numModesString;
289 std::stringstream numModesStringStream;
291 if (fielddefs[f]->m_uniOrder)
293 numModesStringStream <<
"UNIORDER:";
296 for (std::vector<int>::size_type i = 0;
297 i < fielddefs[f]->m_basis.size(); i++)
301 numModesStringStream <<
",";
303 numModesStringStream << fielddefs[f]->m_numModes[i];
309 numModesStringStream <<
"MIXORDER:";
311 for (std::vector<int>::size_type i = 0;
312 i < fielddefs[f]->m_numModes.size(); i++)
316 numModesStringStream <<
",";
318 numModesStringStream << fielddefs[f]->m_numModes[i];
323 numModesString = numModesStringStream.str();
325 elemTag->SetAttribute(
"NUMMODESPERDIR", numModesString);
330 std::string idString;
332 std::stringstream idStringStream;
336 elemTag->SetAttribute(
"ID", idString);
337 elemTag->SetAttribute(
"COMPRESSED",
343 elemTag->SetAttribute(
"BITSIZE",
345 std::string base64string;
348 "Failed to compress field data.");
350 elemTag->LinkEndChild(
new TiXmlText(base64string));
352 doc.SaveFile(filename);
357 if (
m_comm->TreatAsRankZero())
360 std::cout <<
" (" << tm1 - tm0 <<
"s, XML)" << std::endl;
377 const std::string &outFile,
const std::vector<std::string> fileNames,
378 std::vector<std::vector<unsigned int>> &elementList,
382 TiXmlDeclaration *decl =
new TiXmlDeclaration(
"1.0",
"utf-8",
"");
383 doc.LinkEndChild(decl);
385 ASSERTL0(fileNames.size() == elementList.size(),
386 "Outfile names and list of elements ids does not match");
388 TiXmlElement *root =
new TiXmlElement(
"NEKTAR");
389 doc.LinkEndChild(root);
393 for (
int t = 0; t < fileNames.size(); ++t)
395 if (elementList[t].size())
397 TiXmlElement *elemIDs =
new TiXmlElement(
"Partition");
398 root->LinkEndChild(elemIDs);
400 elemIDs->SetAttribute(
"FileName", fileNames[t]);
404 elemIDs->LinkEndChild(
new TiXmlText(IDstr));
408 doc.SaveFile(outFile);
424 const std::string &inFile, std::vector<std::string> &fileNames,
425 std::vector<std::vector<unsigned int>> &elementList,
428 boost::ignore_unused(fieldmetadatamap);
430 TiXmlDocument doc(inFile);
431 bool loadOkay = doc.LoadFile();
433 std::stringstream errstr;
434 errstr <<
"Unable to load file: " << inFile << std::endl;
435 errstr <<
"Reason: " << doc.ErrorDesc() << std::endl;
436 errstr <<
"Position: Line " << doc.ErrorRow() <<
", Column "
437 << doc.ErrorCol() << std::endl;
441 TiXmlHandle docHandle(&doc);
445 TiXmlElement *master = doc.FirstChildElement(
"NEKTAR");
446 ASSERTL0(master,
"Unable to find NEKTAR tag in file.");
449 std::string strPartition =
"Partition";
452 TiXmlElement *fldfileIDs = master->FirstChildElement(strPartition.c_str());
456 strPartition =
"MultipleFldFiles";
457 fldfileIDs = master->FirstChildElement(
"MultipleFldFiles");
459 ASSERTL0(fldfileIDs,
"Unable to find 'Partition' or 'MultipleFldFiles' tag "
460 "within nektar tag.");
465 const char *attr = fldfileIDs->Attribute(
"FileName");
466 ASSERTL0(attr,
"'FileName' not provided as an attribute of '" +
467 strPartition +
"' tag.");
468 fileNames.push_back(std::string(attr));
470 const char *elementIDs = fldfileIDs->GetText();
471 ASSERTL0(elementIDs,
"Element IDs not specified.");
473 std::string elementIDsStr(elementIDs);
475 std::vector<unsigned int> idvec;
478 elementList.push_back(idvec);
480 fldfileIDs = fldfileIDs->NextSiblingElement(strPartition.c_str());
497 std::vector<FieldDefinitionsSharedPtr> &fielddefs,
498 std::vector<std::vector<NekDouble>> &fielddata,
502 std::string infile = infilename;
504 fs::path pinfilename(infilename);
508 if (fs::is_directory(pinfilename))
510 fs::path infofile(
"Info.xml");
511 fs::path fullpath = pinfilename / infofile;
514 std::vector<std::string> filenames;
515 std::vector<std::vector<unsigned int>> elementIDs_OnPartitions;
525 for (
int i = 0; i < filenames.size(); ++i)
527 fs::path pfilename(filenames[i]);
528 fullpath = pinfilename / pfilename;
541 std::map<int, std::vector<int>> FileIDs;
542 std::set<int> LoadFile;
544 for (i = 0; i < elementIDs_OnPartitions.size(); ++i)
546 for (j = 0; j < elementIDs_OnPartitions[i].size(); ++j)
548 FileIDs[elementIDs_OnPartitions[i][j]].push_back(i);
552 for (i = 0; i < ElementIDs.size(); ++i)
554 auto it = FileIDs.find(ElementIDs[i]);
555 if (it != FileIDs.end())
557 for (j = 0; j < it->second.size(); ++j)
559 LoadFile.insert(it->second[j]);
564 for (
auto &iter : LoadFile)
566 fs::path pfilename(filenames[iter]);
567 fullpath = pinfilename / pfilename;
602 TiXmlElement *metadata = 0;
603 TiXmlElement *master = 0;
606 master = xml->Get().FirstChildElement(
"NEKTAR");
607 ASSERTL0(master,
"Unable to find NEKTAR tag in file.");
608 std::string strLoop =
"NEKTAR";
612 metadata = master->FirstChildElement(
"FIELDMETADATA");
615 TiXmlElement *param = metadata->FirstChildElement(
"P");
619 TiXmlAttribute *paramAttr = param->FirstAttribute();
620 std::string attrName(paramAttr->Name());
621 std::string paramString;
623 if (attrName ==
"PARAM")
625 paramString.insert(0, paramAttr->Value());
630 "PARAM not provided as an attribute in "
631 "FIELDMETADATA section");
635 std::string paramBodyStr;
637 TiXmlNode *paramBody = param->FirstChild();
639 paramBodyStr += paramBody->ToText()->Value();
641 fieldmetadatamap[paramString] = paramBodyStr;
642 param = param->NextSiblingElement(
"P");
647 metadata = master->FirstChildElement(
"Metadata");
650 TiXmlElement *param = metadata->FirstChildElement();
654 std::string paramString = param->Value();
655 if (paramString !=
"Provenance")
658 if (param->NoChildren())
660 fieldmetadatamap[paramString] =
"";
664 TiXmlNode *paramBody = param->FirstChild();
665 std::string paramBodyStr = paramBody->ToText()->Value();
666 fieldmetadatamap[paramString] = paramBodyStr;
669 param = param->NextSiblingElement();
690 const std::string &outname,
691 const std::vector<FieldDefinitionsSharedPtr> &fielddefs,
694 ASSERTL0(!outname.empty(),
"Empty path given to SetUpFieldMetaData()");
696 unsigned int nprocs =
m_comm->GetSize();
697 unsigned int rank =
m_comm->GetRank();
699 fs::path specPath(outname);
704 std::vector<size_t> elmtnums(nprocs, 0);
705 std::vector<unsigned int> idlist;
706 for (
size_t i = 0; i < fielddefs.size(); ++i)
708 elmtnums[rank] += fielddefs[i]->m_elementIDs.size();
709 idlist.insert(idlist.end(), fielddefs[i]->m_elementIDs.begin(),
710 fielddefs[i]->m_elementIDs.end());
718 std::vector<std::vector<unsigned int>> ElementIDs(nprocs);
721 ElementIDs[0] = idlist;
722 for (
size_t i = 1; i < nprocs; ++i)
726 std::vector<unsigned int> tmp(elmtnums[i]);
733 std::vector<std::string> filenames;
734 for (
unsigned int i = 0; i < nprocs; ++i)
738 filenames.push_back(pad.str());
742 std::string infofile =
750 if (elmtnums[rank] > 0)
767 std::vector<FieldDefinitionsSharedPtr> &fielddefs,
bool expChild)
770 std::static_pointer_cast<XmlDataSource>(dataSource);
771 TiXmlElement *master =
774 master = xml->Get().FirstChildElement(
"NEKTAR");
775 ASSERTL0(master,
"Unable to find NEKTAR tag in file.");
776 std::string strLoop =
"NEKTAR";
777 TiXmlElement *loopXml = master;
779 TiXmlElement *expansionTypes;
782 expansionTypes = master->FirstChildElement(
"EXPANSIONS");
783 ASSERTL0(expansionTypes,
"Unable to find EXPANSIONS tag in file.");
784 loopXml = expansionTypes;
785 strLoop =
"EXPANSIONS";
791 TiXmlElement *element = loopXml->FirstChildElement(
"ELEMENTS");
796 std::string idString;
797 std::string shapeString;
798 std::string basisString;
799 std::string homoLengthsString;
800 std::string homoSIDsString;
801 std::string homoZIDsString;
802 std::string homoYIDsString;
803 std::string numModesString;
804 std::string numPointsString;
805 std::string fieldsString;
806 std::string pointsString;
807 bool pointDef =
false;
808 bool numPointDef =
false;
809 TiXmlAttribute *attr = element->FirstAttribute();
812 std::string attrName(attr->Name());
813 if (attrName ==
"FIELDS")
815 fieldsString.insert(0, attr->Value());
817 else if (attrName ==
"SHAPE")
819 shapeString.insert(0, attr->Value());
821 else if (attrName ==
"BASIS")
823 basisString.insert(0, attr->Value());
825 else if (attrName ==
"HOMOGENEOUSLENGTHS")
827 homoLengthsString.insert(0, attr->Value());
829 else if (attrName ==
"HOMOGENEOUSSIDS")
831 homoSIDsString.insert(0, attr->Value());
833 else if (attrName ==
"HOMOGENEOUSZIDS")
835 homoZIDsString.insert(0, attr->Value());
837 else if (attrName ==
"HOMOGENEOUSYIDS")
839 homoYIDsString.insert(0, attr->Value());
841 else if (attrName ==
"NUMMODESPERDIR")
843 numModesString.insert(0, attr->Value());
845 else if (attrName ==
"ID")
847 idString.insert(0, attr->Value());
849 else if (attrName ==
"POINTSTYPE")
851 pointsString.insert(0, attr->Value());
854 else if (attrName ==
"NUMPOINTSPERDIR")
856 numPointsString.insert(0, attr->Value());
859 else if (attrName ==
"COMPRESSED")
863 "Compressed formats do not "
864 "match. Expected: " +
866 " but got " + std::string(attr->Value()));
868 else if (attrName ==
"BITSIZE")
876 std::string errstr(
"Unknown attribute: ");
887 if (shapeString.find(
"Strips") != std::string::npos)
897 if ((
loc = shapeString.find_first_of(
"-")) != std::string::npos)
899 if (shapeString.find(
"Exp1D") != std::string::npos)
908 shapeString.erase(
loc, shapeString.length());
912 std::vector<unsigned int> elementIds;
916 ASSERTL0(valid,
"Unable to correctly parse the element ids.");
933 std::string(
"Unable to correctly parse the shape type: ")
938 std::vector<std::string> basisStrings;
939 std::vector<BasisType> basis;
941 ASSERTL0(valid,
"Unable to correctly parse the basis types.");
942 for (std::vector<std::string>::size_type i = 0;
943 i < basisStrings.size(); i++)
957 std::string(
"Unable to correctly parse the basis type: ")
958 .append(basisStrings[i])
963 std::vector<NekDouble> homoLengths;
968 ASSERTL0(valid,
"Unable to correctly parse the number of "
969 "homogeneous lengths.");
973 std::vector<unsigned int> homoSIDs;
978 "Unable to correctly parse homogeneous strips IDs.");
982 std::vector<unsigned int> homoZIDs;
983 std::vector<unsigned int> homoYIDs;
989 "Unable to correctly parse homogeneous planes IDs.");
995 ASSERTL0(valid,
"Unable to correctly parse homogeneous lines "
996 "IDs in z-direction.");
998 ASSERTL0(valid,
"Unable to correctly parse homogeneous lines "
999 "IDs in y-direction.");
1003 std::vector<PointsType> points;
1007 std::vector<std::string> pointsStrings;
1009 ASSERTL0(valid,
"Unable to correctly parse the points types.");
1010 for (std::vector<std::string>::size_type i = 0;
1011 i < pointsStrings.size(); i++)
1026 "Unable to correctly parse the points type: ")
1027 .append(pointsStrings[i])
1033 std::vector<unsigned int> numModes;
1034 bool UniOrder =
false;
1036 if (strstr(numModesString.c_str(),
"UNIORDER:"))
1043 ASSERTL0(valid,
"Unable to correctly parse the number of modes.");
1046 std::vector<unsigned int> numPoints;
1051 "Unable to correctly parse the number of points.");
1055 std::vector<std::string> Fields;
1057 ASSERTL0(valid,
"Unable to correctly parse the number of fields.");
1061 shape, elementIds, basis, UniOrder, numModes, Fields,
1062 numHomoDir, homoLengths, strips, homoSIDs, homoZIDs,
1063 homoYIDs, points, pointDef, numPoints, numPointDef);
1065 fielddefs.push_back(fielddef);
1067 element = element->NextSiblingElement(
"ELEMENTS");
1069 loopXml = loopXml->NextSiblingElement(strLoop);
1082 const std::vector<FieldDefinitionsSharedPtr> &fielddefs,
1083 std::vector<std::vector<NekDouble>> &fielddata)
1087 std::static_pointer_cast<XmlDataSource>(dataSource);
1089 TiXmlElement *master =
1092 master = xml->Get().FirstChildElement(
"NEKTAR");
1093 ASSERTL0(master,
"Unable to find NEKTAR tag in file.");
1098 TiXmlElement *element = master->FirstChildElement(
"ELEMENTS");
1099 ASSERTL0(element,
"Unable to find ELEMENTS tag within nektar tag.");
1103 TiXmlNode *elementChild = element->FirstChild();
1105 "Unable to extract the data from the element tag.");
1106 std::string elementStr;
1107 while (elementChild)
1109 if (elementChild->Type() == TiXmlNode::TINYXML_TEXT)
1111 elementStr += elementChild->ToText()->ValueStr();
1113 elementChild = elementChild->NextSibling();
1116 std::vector<NekDouble> elementFieldData;
1119 const char *CompressStr = element->Attribute(
"COMPRESSED");
1124 "Compressed formats do not match. "
1127 std::string(CompressStr));
1131 elementStr, elementFieldData),
1132 "Failed to decompress field data.");
1133 fielddata.push_back(elementFieldData);
1137 fielddata[cntdumps].size() ==
1138 datasize * fielddefs[cntdumps]->m_fields.size(),
1139 "Input data is not the same length as header infoarmation");
1143 element = element->NextSiblingElement(
"ELEMENTS");
1145 master = master->NextSiblingElement(
"NEKTAR");
#define ASSERTL0(condition, msg)
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mode...
#define WARNINGL0(condition, msg)
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Class for operating on Nektar++ input/output files.
int CheckFieldDefinition(const FieldDefinitionsSharedPtr &fielddefs)
Check field definitions for correctness and return storage size.
DataSourceSharedPtr ImportFieldMetaData(const std::string &filename, FieldMetaDataMap &fieldmetadatamap)
Import the metadata from a field file.
std::string SetUpOutput(const std::string outname, bool perRank, bool backup=false)
Set up the filesystem ready for output.
LibUtilities::CommSharedPtr m_comm
Communicator to use when writing parallel format.
static void AddInfoTag(TagWriterSharedPtr root, const FieldMetaDataMap &fieldmetadatamap)
Add provenance information to the field metadata map.
virtual std::string GetFileEnding() const
Helper function that determines default file extension.
virtual DataSourceSharedPtr v_ImportFieldMetaData(const std::string &filename, FieldMetaDataMap &fieldmetadatamap)
Import field metadata from filename and return the data source which wraps filename.
void v_Import(const std::string &infilename, std::vector< FieldDefinitionsSharedPtr > &fielddefs, std::vector< std::vector< NekDouble >> &fielddata=NullVectorNekDoubleVector, FieldMetaDataMap &fieldinfomap=NullFieldMetaDataMap, const Array< OneD, int > &ElementIDs=NullInt1DArray)
Import an XML format file.
virtual void v_Write(const std::string &outFile, std::vector< FieldDefinitionsSharedPtr > &fielddefs, std::vector< std::vector< NekDouble >> &fielddata, const FieldMetaDataMap &fieldinfomap=NullFieldMetaDataMap, const bool backup=false)
Write an XML file to outFile given the field definitions fielddefs, field data fielddata and metadata...
void ImportFieldDefs(DataSourceSharedPtr dataSource, std::vector< FieldDefinitionsSharedPtr > &fielddefs, bool expChild)
Import field definitions from the target file.
void WriteMultiFldFileIDs(const std::string &outfile, const std::vector< std::string > fileNames, std::vector< std::vector< unsigned int >> &elementList, const FieldMetaDataMap &fieldinfomap=NullFieldMetaDataMap)
Write out a file containing element ID to partition mapping.
static FieldIOSharedPtr create(LibUtilities::CommSharedPtr pComm, bool sharedFilesystem)
Creates an instance of this class.
void ImportMultiFldFileIDs(const std::string &inFile, std::vector< std::string > &fileNames, std::vector< std::vector< unsigned int >> &elementList, FieldMetaDataMap &fieldmetadatamap)
Read file containing element ID to partition mapping.
void ImportFieldData(DataSourceSharedPtr dataSource, const std::vector< FieldDefinitionsSharedPtr > &fielddefs, std::vector< std::vector< NekDouble >> &fielddata)
Import field data from a target file.
FieldIOXml(LibUtilities::CommSharedPtr pComm, bool sharedFilesystem)
Default constructor.
void SetUpFieldMetaData(const std::string &outname, const std::vector< FieldDefinitionsSharedPtr > &fielddefs, const FieldMetaDataMap &fieldmetadatamap)
Set up field meta data map.
static std::string className
Name of class.
tKey RegisterCreatorFunction(tKey idKey, CreatorFunction classCreator, std::string pDesc="")
Register a class with the factory.
static DataSourceSharedPtr create(const std::string &fn)
Create a new XML data source based on the filename.
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
static std::string GenerateSeqString(const std::vector< T > &v)
Generate a compressed comma-separated string representation of a vector of unsigned integers.
static bool GenerateVector(const std::string &str, std::vector< T > &out)
Takes a comma-separated string and converts it to entries in a vector.
static bool GenerateSeqVector(const std::string &str, std::vector< unsigned int > &out)
Takes a comma-separated compressed string and converts it to entries in a vector.
std::string GetBitSizeStr(void)
int ZlibDecodeFromBase64Str(std::string &in64, std::vector< T > &out)
std::string GetCompressString(void)
int ZlibEncodeToBase64Str(std::vector< T > &in, std::string &out64)
const char *const ShapeTypeMap[SIZE_ShapeType]
const char *const BasisTypeMap[]
std::shared_ptr< DataSource > DataSourceSharedPtr
std::map< std::string, std::string > FieldMetaDataMap
const std::string kPointsTypeStr[]
std::string PortablePath(const boost::filesystem::path &path)
create portable path on different platforms for boost::filesystem path
std::shared_ptr< XmlDataSource > XmlDataSourceSharedPtr
static std::vector< std::vector< NekDouble > > NullVectorNekDoubleVector
std::shared_ptr< FieldDefinitions > FieldDefinitionsSharedPtr
FieldIOFactory & GetFieldIOFactory()
Returns the FieldIO factory.
std::shared_ptr< XmlTagWriter > XmlTagWriterSharedPtr
@ SIZE_PointsType
Length of enum list.
std::shared_ptr< Comm > CommSharedPtr
Pointer to a Communicator object.
@ SIZE_BasisType
Length of enum list.
The above copyright notice and this permission notice shall be included.
static Array< OneD, int > NullInt1DArray