Class for operating on FLD files. More...

#include <FieldIO.h>

Inheritance diagram for Nektar::LibUtilities::FieldIO:

Public Member Functions
	FieldIO (LibUtilities::CommSharedPtr pComm, bool sharedFilesystem=false)
	Constructor. More...

void	Write (const std::string &outFile, std::vector< FieldDefinitionsSharedPtr > &fielddefs, std::vector< std::vector< NekDouble > > &fielddata, const FieldMetaDataMap &fieldinfomap=NullFieldMetaDataMap)
	Write data in FLD format. More...

void	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)
	Imports an FLD file. More...

void	ImportFieldMetaData (std::string filename, FieldMetaDataMap &fieldmetadatamap)
	Imports the definition of the meta data. More...

void	ImportFieldMetaData (TiXmlDocument &doc, FieldMetaDataMap &fieldmetadatamap)
	Imports the definition of the meta data. More...

void	ImportFieldDefs (TiXmlDocument &doc, std::vector< FieldDefinitionsSharedPtr > &fielddefs, bool expChild)
	Imports the definition of the fields. More...

void	ImportFieldData (TiXmlDocument &doc, const std::vector< FieldDefinitionsSharedPtr > &fielddefs, std::vector< std::vector< NekDouble > > &fielddata)
	Imports the data fileds. More...

void	WriteMultiFldFileIDs (const std::string &outfile, const std::vector< std::string > fileNames, std::vector< std::vector< unsigned int > > &elementList, const FieldMetaDataMap &fieldinfomap=NullFieldMetaDataMap)

Protected Member Functions
void	AddInfoTag (TiXmlElement *root, const FieldMetaDataMap &fieldmetadatamap)
	add information about provenance and fieldmetadata More...

void	GenerateSeqString (const std::vector< unsigned int > &elmtids, std::string &idString)

std::string	SetUpOutput (const std::string outname)

void	SetUpFieldMetaData (const std::string outname, const std::vector< FieldDefinitionsSharedPtr > &fielddefs, const FieldMetaDataMap &fieldmetadatamap)

void	ImportMultiFldFileIDs (const std::string &inFile, std::vector< std::string > &fileNames, std::vector< std::vector< unsigned int > > &elementList, FieldMetaDataMap &fieldmetadatamap)

int	CheckFieldDefinition (const FieldDefinitionsSharedPtr &fielddefs)

virtual std::string	GetFileEnding () const

Protected Attributes
LibUtilities::CommSharedPtr	m_comm
	Communicator to use when writing parallel format. More...

bool	m_sharedFilesystem
	True if same filesystem accessible by all processes. More...

Detailed Description

Class for operating on FLD files.

Definition at line 137 of file FieldIO.h.

Constructor & Destructor Documentation

Nektar::LibUtilities::FieldIO::FieldIO	(	LibUtilities::CommSharedPtr	pComm,
		bool	sharedFilesystem = `false`
	)

Constructor.

Definition at line 149 of file FieldIO.cpp.

                                                                        :
             m_comm(pComm),
             m_sharedFilesystem(sharedFilesystem)
         {
         }

Member Function Documentation

void Nektar::LibUtilities::FieldIO::AddInfoTag	(	TiXmlElement *	root,
		const FieldMetaDataMap &	fieldmetadatamap
	)

protected

add information about provenance and fieldmetadata

Definition at line 1084 of file FieldIO.cpp.

References Nektar::NekConstants::kGitBranch, Nektar::NekConstants::kGitSha1, NEKTAR_VERSION, and Nektar::LibUtilities::NullFieldMetaDataMap.

Referenced by Write(), and WriteMultiFldFileIDs().

         {
             FieldMetaDataMap ProvenanceMap;
 
             // Nektar++ release version from VERSION file
             ProvenanceMap["NektarVersion"] = string(NEKTAR_VERSION);
 
             // Date/time stamp
             ptime::time_facet *facet = new ptime::time_facet("%d-%b-%Y %H:%M:%S");
             std::stringstream wss;
             wss.imbue(locale(wss.getloc(), facet));
             wss << ptime::second_clock::local_time();
             ProvenanceMap["Timestamp"] = wss.str();
 
             // Hostname
             boost::system::error_code ec;
             ProvenanceMap["Hostname"] = ip::host_name(ec);
 
             // Git information
             // If built from a distributed package, do not include this
             if (NekConstants::kGitSha1 != "GITDIR-NOTFOUND")
             {
                 ProvenanceMap["GitSHA1"]   = NekConstants::kGitSha1;
                 ProvenanceMap["GitBranch"] = NekConstants::kGitBranch;
             }
 
             TiXmlElement * infoTag = new TiXmlElement("Metadata");
             root->LinkEndChild(infoTag);
 
             TiXmlElement * v;
             FieldMetaDataMap::const_iterator infoit;
 
             TiXmlElement * provTag = new TiXmlElement("Provenance");
             infoTag->LinkEndChild(provTag);
             for (infoit = ProvenanceMap.begin(); infoit != ProvenanceMap.end(); ++infoit)
             {
                 v = new TiXmlElement( (infoit->first).c_str() );
                 v->LinkEndChild(new TiXmlText((infoit->second).c_str()));
                 provTag->LinkEndChild(v);
             }
 
             //---------------------------------------------
             // write field info section
             if(fieldmetadatamap != NullFieldMetaDataMap)
             {
                 for(infoit = fieldmetadatamap.begin(); infoit != fieldmetadatamap.end(); ++infoit)
                 {
                     v = new TiXmlElement( (infoit->first).c_str() );
                     v->LinkEndChild(new TiXmlText((infoit->second).c_str()));
                     infoTag->LinkEndChild(v);
                 }
             }
         }

int Nektar::LibUtilities::FieldIO::CheckFieldDefinition ( const FieldDefinitionsSharedPtr & fielddefs )

protected

Definition at line 1352 of file FieldIO.cpp.

Referenced by ImportFieldData(), and Write().

         {
             int i;
 
             if(fielddefs->m_elementIDs.size() == 0) // empty partition
             {
                 return 0;
             }
             //ASSERTL0(fielddefs->m_elementIDs.size() > 0, "Fielddefs vector must contain at least one element of data .");
 
             unsigned int numbasis = 0;
 
             // Determine nummodes vector lists are correct length
             switch(fielddefs->m_shapeType)
             {
             case eSegment:
                 numbasis = 1;
                 if(fielddefs->m_numHomogeneousDir)
                 {
                     numbasis += fielddefs->m_numHomogeneousDir;
                 }
 
                 break;
             case eTriangle:
             case eQuadrilateral:
                 if(fielddefs->m_numHomogeneousDir)
                 {
                     numbasis = 3;
                 }
                 else
                 {
                     numbasis = 2;
                 }
                 break;
             case eTetrahedron:
             case ePyramid:
             case ePrism:
             case eHexahedron:
                 numbasis = 3;
                 break;
             default:
                 ASSERTL0(false, "Unsupported shape type.");
                 break;
             }
 
             unsigned int datasize = 0;
 
             ASSERTL0(fielddefs->m_basis.size() == numbasis, "Length of basis vector is incorrect");
 
             if(fielddefs->m_uniOrder == true)
             {
                 unsigned int cnt = 0;
                 // calculate datasize
                 switch(fielddefs->m_shapeType)
                 {
                 case eSegment:
                 {
                     int l = fielddefs->m_numModes[cnt++];
                     if(fielddefs->m_numHomogeneousDir == 1)
                     {
                         datasize += l*fielddefs->m_numModes[cnt++];
                     }
                     else if(fielddefs->m_numHomogeneousDir == 2)
                     {
                         int m = fielddefs->m_numModes[cnt++];
                         datasize += l*m*fielddefs->m_numModes[cnt++];
                     }
                     else
                     {
                         datasize += l;
                     }
                 }
                 break;
                 case eTriangle:
                 {
                     int l = fielddefs->m_numModes[cnt++];
                     int m = fielddefs->m_numModes[cnt++];
 
                     if(fielddefs->m_numHomogeneousDir == 1)
                     {
                         datasize += StdTriData::getNumberOfCoefficients(l,m)*
                                     fielddefs->m_homogeneousZIDs.size();
                     }
                     else
                     {
                         datasize += StdTriData::getNumberOfCoefficients(l,m);
                     }
                 }
                 break;
                 case eQuadrilateral:
                     {
                         int l = fielddefs->m_numModes[cnt++];
                         int m = fielddefs->m_numModes[cnt++];
                         if(fielddefs->m_numHomogeneousDir == 1)
                         {
                             datasize += l*m*fielddefs->m_homogeneousZIDs.size();
                         }
                         else
                         {
                             datasize += l*m;
                         }
                     }
                     break;
                 case eTetrahedron:
                     {
                         int l = fielddefs->m_numModes[cnt++];
                         int m = fielddefs->m_numModes[cnt++];
                         int n = fielddefs->m_numModes[cnt++];
                         datasize += StdTetData::getNumberOfCoefficients(l,m,n);
                     }
                     break;
                 case ePyramid:
                     {
                         int l = fielddefs->m_numModes[cnt++];
                         int m = fielddefs->m_numModes[cnt++];
                         int n = fielddefs->m_numModes[cnt++];
                         datasize += StdPyrData::getNumberOfCoefficients(l,m,n);
                     }
                     break;
                 case  ePrism:
                     {
                         int l = fielddefs->m_numModes[cnt++];
                         int m = fielddefs->m_numModes[cnt++];
                         int n = fielddefs->m_numModes[cnt++];
                         datasize += StdPrismData::getNumberOfCoefficients(l,m,n);
                     }
                     break;
                 case eHexahedron:
                     {
                         int l = fielddefs->m_numModes[cnt++];
                         int m = fielddefs->m_numModes[cnt++];
                         int n = fielddefs->m_numModes[cnt++];
                         datasize += l*m*n;
                     }
                     break;
                 default:
                     ASSERTL0(false, "Unsupported shape type.");
                     break;
                 }
 
                 datasize *= fielddefs->m_elementIDs.size();
             }
             else
             {
                 unsigned int cnt = 0;
                 // calculate data length
                 for(i = 0; i < fielddefs->m_elementIDs.size(); ++i)
                 {
                     switch(fielddefs->m_shapeType)
                     {
                     case eSegment:
                         {
                             int l = fielddefs->m_numModes[cnt++];
                             if(fielddefs->m_numHomogeneousDir == 1)
                             {
                                 datasize += l*fielddefs->m_numModes[cnt++];
                             }
                             else if(fielddefs->m_numHomogeneousDir == 2)
                             {
                                 int m = fielddefs->m_numModes[cnt++];
                                 datasize += l*m*fielddefs->m_numModes[cnt++];
                             }
                             else
                             {
                                 datasize += l;
                             }
                         }
                         break;
                     case eTriangle:
                         {
                             int l = fielddefs->m_numModes[cnt++];
                             int m = fielddefs->m_numModes[cnt++];
                             if(fielddefs->m_numHomogeneousDir == 1)
                             {
                                 datasize += StdTriData::getNumberOfCoefficients(l,m)*
                                             fielddefs->m_homogeneousZIDs.size();
                                 cnt++;
                             }
                             else
                             {
                                 datasize += StdTriData::getNumberOfCoefficients(l,m);
                             }
                         }
                         break;
                     case eQuadrilateral:
                         {
                             int l = fielddefs->m_numModes[cnt++];
                             int m = fielddefs->m_numModes[cnt++];
                             if(fielddefs->m_numHomogeneousDir == 1)
                             {
                                 datasize += l*m*fielddefs->
                                                     m_homogeneousZIDs.size();
                                 cnt++;
                             }
                             else
                             {
                                 datasize += l*m;
                             }
                         }
                         break;
                     case eTetrahedron:
                         {
                             int l = fielddefs->m_numModes[cnt++];
                             int m = fielddefs->m_numModes[cnt++];
                             int n = fielddefs->m_numModes[cnt++];
                             datasize += StdTetData::getNumberOfCoefficients(l,m,n);
                         }
                         break;
                     case ePyramid:
                         {
                             int l = fielddefs->m_numModes[cnt++];
                             int m = fielddefs->m_numModes[cnt++];
                             int n = fielddefs->m_numModes[cnt++];
                             datasize += StdPyrData::getNumberOfCoefficients(l,m,n);
                         }
                         break;
                     case  ePrism:
                         {
                             int l = fielddefs->m_numModes[cnt++];
                             int m = fielddefs->m_numModes[cnt++];
                             int n = fielddefs->m_numModes[cnt++];
                             datasize += StdPrismData::getNumberOfCoefficients(l,m,n);
                         }
                         break;
                     case eHexahedron:
                         {
                             int l = fielddefs->m_numModes[cnt++];
                             int m = fielddefs->m_numModes[cnt++];
                             int n = fielddefs->m_numModes[cnt++];
                             datasize += l*m*n;
                         }
                         break;
                     default:
                         ASSERTL0(false, "Unsupported shape type.");
                         break;
                     }
                 }
             }
 
             return datasize;
         }

void Nektar::LibUtilities::FieldIO::GenerateSeqString	(	const std::vector< unsigned int > &	elmtids,
		std::string &	idString
	)

protected

Definition at line 1143 of file FieldIO.cpp.

Referenced by Write(), and WriteMultiFldFileIDs().

         {
             std::stringstream idStringStream;
             bool setdash = true;
             unsigned int endval;
 
             idStringStream << elmtids[0];
             for (int i = 1; i < elmtids.size(); ++i)
             {
                 if(elmtids[i] == elmtids[i-1]+1)
                 {
                     if(setdash)
                     {
                         idStringStream << "-";
                         setdash = false;
                     }
 
                     if(i == elmtids.size()-1) // last element
                     {
                         idStringStream << elmtids[i];
                     }
                     else
                     {
                         endval = elmtids[i];
                     }
                 }
                 else
                 {
                     if(setdash == false) // finish off previous dash sequence
                     {
                         idStringStream << endval;
                         setdash = true;
                     }
 
 
                     idStringStream << "," << elmtids[i];
                 }
             }
             idString = idStringStream.str();
         }

virtual std::string Nektar::LibUtilities::FieldIO::GetFileEnding ( ) const

inlineprotectedvirtual

Reimplemented in Nektar::LibUtilities::PtsIO.

Definition at line 218 of file FieldIO.h.

Referenced by SetUpFieldMetaData(), and SetUpOutput().

     {
         return "fld";
     };

void Nektar::LibUtilities::FieldIO::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`
	)

Imports an FLD file.

Definition at line 406 of file FieldIO.cpp.

References ASSERTL0, ImportFieldData(), ImportFieldDefs(), ImportFieldMetaData(), ImportMultiFldFileIDs(), Nektar::iterator, Nektar::NullInt1DArray, Nektar::LibUtilities::NullVectorNekDoubleVector, and Nektar::LibUtilities::PortablePath().

Referenced by Nektar::MultiRegions::ExpList::ExtractFileBCs(), and Nektar::LibUtilities::Import().

         {
 
             std::string infile = infilename;
 
             fs::path pinfilename(infilename);
 
             if(fs::is_directory(pinfilename)) // check to see that infile is a directory
             {
                 fs::path infofile("Info.xml");
                 fs::path fullpath = pinfilename / infofile;
                 infile = PortablePath(fullpath);
 
                 std::vector<std::string> filenames;
                 std::vector<std::vector<unsigned int> > elementIDs_OnPartitions;
 
 
                 ImportMultiFldFileIDs(infile,filenames, elementIDs_OnPartitions,
                                       fieldmetadatamap);
 
                 // Load metadata
                 ImportFieldMetaData(infile,fieldmetadatamap);
 
                 if(ElementIDs == NullInt1DArray) //load all fields
                 {
                     for(int i = 0; i < filenames.size(); ++i)
                     {
                         fs::path pfilename(filenames[i]);
                         fullpath = pinfilename / pfilename;
                         string fname = PortablePath(fullpath);
 
                         TiXmlDocument doc1(fname);
                         bool loadOkay1 = doc1.LoadFile();
 
                         std::stringstream errstr;
                         errstr << "Unable to load file: " << fname << std::endl;
                         errstr << "Reason: " << doc1.ErrorDesc() << std::endl;
                         errstr << "Position: Line " << doc1.ErrorRow() << ", Column " << doc1.ErrorCol() << std::endl;
                         ASSERTL0(loadOkay1, errstr.str());
 
                         ImportFieldDefs(doc1, fielddefs, false);
                         if(fielddata != NullVectorNekDoubleVector)
                         {
                             ImportFieldData(doc1, fielddefs, fielddata);
                         }
                     }
 
                 }
                 else // only load relevant partitions
                 {
                     int i,j;
                     map<int,vector<int> > FileIDs;
                     map<int,vector<int> >::iterator it;
                     set<int> LoadFile;
 
                     for(i = 0; i < elementIDs_OnPartitions.size(); ++i)
                     {
                         for(j = 0; j < elementIDs_OnPartitions[i].size(); ++j)
                         {
                             FileIDs[elementIDs_OnPartitions[i][j]].push_back(i);
                         }
                     }
 
                     for(i = 0; i < ElementIDs.num_elements(); ++i)
                     {
                         it = FileIDs.find(ElementIDs[i]);
                         if (it != FileIDs.end())
                         {
                             for (j = 0; j < it->second.size(); ++j)
                             {
                                 LoadFile.insert(it->second[j]);
                             }
                         }
                     }
 
                     set<int>::iterator iter;
                     for(iter = LoadFile.begin(); iter != LoadFile.end(); ++iter)
                     {
                         fs::path pfilename(filenames[*iter]);
                         fullpath = pinfilename / pfilename;
                         string fname = PortablePath(fullpath);
                         TiXmlDocument doc1(fname);
                         bool loadOkay1 = doc1.LoadFile();
 
                         std::stringstream errstr;
                         errstr << "Unable to load file: " << fname << std::endl;
                         errstr << "Reason: " << doc1.ErrorDesc() << std::endl;
                         errstr << "Position: Line " << doc1.ErrorRow() << ", Column " << doc1.ErrorCol() << std::endl;
                         ASSERTL0(loadOkay1, errstr.str());
 
                         ImportFieldDefs(doc1, fielddefs, false);
                         if(fielddata != NullVectorNekDoubleVector)
                         {
                             ImportFieldData(doc1, fielddefs, fielddata);
                         }
                     }
                 }
             }
             else // serial format case
             {
 
                 TiXmlDocument doc(infile);
                 bool loadOkay = doc.LoadFile();
 
                 std::stringstream errstr;
                 errstr << "Unable to load file: " << infile << std::endl;
                 errstr << "Reason: " << doc.ErrorDesc() << std::endl;
                 errstr << "Position: Line " << doc.ErrorRow() << ", Column " <<
                     doc.ErrorCol() << std::endl;
                 ASSERTL0(loadOkay, errstr.str());
 
                 ImportFieldMetaData(doc,fieldmetadatamap);
                 ImportFieldDefs(doc, fielddefs, false);
                 if(fielddata != NullVectorNekDoubleVector)
                 {
                     ImportFieldData(doc, fielddefs, fielddata);
                 }
             }
         }

void Nektar::LibUtilities::FieldIO::ImportFieldData	(	TiXmlDocument &	doc,
		const std::vector< FieldDefinitionsSharedPtr > &	fielddefs,
		std::vector< std::vector< NekDouble > > &	fielddata
	)

Imports the data fileds.

Definition at line 1015 of file FieldIO.cpp.

References ASSERTL0, CheckFieldDefinition(), Nektar::LibUtilities::CompressData::GetCompressString(), WARNINGL0, and Nektar::LibUtilities::CompressData::ZlibDecodeFromBase64Str().

Referenced by Import().

         {
             int cntdumps = 0;
 
             TiXmlHandle docHandle(&doc);
             TiXmlElement* master = NULL;    // Master tag within which all data is contained.
 
             master = doc.FirstChildElement("NEKTAR");
             ASSERTL0(master, "Unable to find NEKTAR tag in file.");
 
             // Loop through all nektar tags, finding all of the element tags.
             while (master)
             {
                 TiXmlElement* element = master->FirstChildElement("ELEMENTS");
                 ASSERTL0(element, "Unable to find ELEMENTS tag within nektar tag.");
                 while (element)
                 {
                     // Extract the body, which the "data".
                     TiXmlNode* elementChild = element->FirstChild();
                     ASSERTL0(elementChild, "Unable to extract the data from the element tag.");
                     std::string elementStr;
                     while(elementChild)
                     {
                         if (elementChild->Type() == TiXmlNode::TINYXML_TEXT)
                         {
                             elementStr += elementChild->ToText()->ValueStr();
                         }
                         elementChild = elementChild->NextSibling();
                     }
 
                     std::vector<NekDouble> elementFieldData;
                     // Convert from base64 to binary.
 
                     const char *CompressStr = element->Attribute("COMPRESSED");
                     if(CompressStr)
                     {
                         if(!boost::iequals(CompressStr,
                                            CompressData::GetCompressString()))
                         {
                             WARNINGL0(false, "Compressed formats do not match. "
                                       "Expected: "
                                       + CompressData::GetCompressString()
                                       + " but got "+ string(CompressStr));
                         }
                     }
 
                     ASSERTL0(Z_OK == CompressData::ZlibDecodeFromBase64Str(
                                                         elementStr,
                                                         elementFieldData),
                              "Failed to decompress field data.");
 
 
                     fielddata.push_back(elementFieldData);
 
                     int datasize = CheckFieldDefinition(fielddefs[cntdumps]);
                     ASSERTL0(fielddata[cntdumps].size() == datasize*fielddefs[cntdumps]->m_fields.size(),"Input data is not the same length as header infoarmation");
 
                     cntdumps++;
 
                     element = element->NextSiblingElement("ELEMENTS");
                 }
                 master = master->NextSiblingElement("NEKTAR");
             }
         }

void Nektar::LibUtilities::FieldIO::ImportFieldDefs	(	TiXmlDocument &	doc,
		std::vector< FieldDefinitionsSharedPtr > &	fielddefs,
		bool	expChild
	)

Imports the definition of the fields.

The bool decides if the FieldDefs are in <EXPANSIONS> or in <NEKTAR>.

Definition at line 723 of file FieldIO.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, ASSERTL1, Nektar::LibUtilities::BasisTypeMap, Nektar::ParseUtils::GenerateOrderedStringVector(), Nektar::ParseUtils::GenerateOrderedVector(), Nektar::ParseUtils::GenerateSeqVector(), Nektar::ParseUtils::GenerateUnOrderedVector(), Nektar::LibUtilities::CompressData::GetCompressString(), Nektar::LibUtilities::kPointsTypeStr, Nektar::LibUtilities::ShapeTypeMap, Nektar::LibUtilities::SIZE_BasisType, Nektar::LibUtilities::SIZE_PointsType, Nektar::LibUtilities::SIZE_ShapeType, and WARNINGL0.

Referenced by Import(), and Nektar::SpatialDomains::MeshGraph::ReadExpansions().

         {
             TiXmlHandle docHandle(&doc);
             TiXmlElement* master = NULL;    // Master tag within which all data is contained.
 
             master = doc.FirstChildElement("NEKTAR");
             ASSERTL0(master, "Unable to find NEKTAR tag in file.");
             std::string strLoop = "NEKTAR";
             TiXmlElement* loopXml = master;
 
             TiXmlElement *expansionTypes;
             if(expChild)
             {
                 expansionTypes = master->FirstChildElement("EXPANSIONS");
                 ASSERTL0(expansionTypes, "Unable to find EXPANSIONS tag in file.");
                 loopXml = expansionTypes;
                 strLoop = "EXPANSIONS";
             }
 
             // Loop through all nektar tags, finding all of the element tags.
             while (loopXml)
             {
                 TiXmlElement* element = loopXml->FirstChildElement("ELEMENTS");
                 ASSERTL0(element, "Unable to find ELEMENTS tag within nektar tag.");
 
                 while (element)
                 {
                     // Extract the attributes.
                     std::string idString;
                     std::string shapeString;
                     std::string basisString;
                     std::string homoLengthsString;
                     std::string homoSIDsString;
                     std::string homoZIDsString;
                     std::string homoYIDsString;
                     std::string numModesString;
                     std::string numPointsString;
                     std::string fieldsString;
                     std::string pointsString;
                     bool pointDef = false;
                     bool numPointDef = false;
                     TiXmlAttribute *attr = element->FirstAttribute();
                     while (attr)
                     {
                         std::string attrName(attr->Name());
                         if (attrName == "FIELDS")
                         {
                             fieldsString.insert(0, attr->Value());
                         }
                         else if (attrName == "SHAPE")
                         {
                             shapeString.insert(0, attr->Value());
                         }
                         else if (attrName == "BASIS")
                         {
                             basisString.insert(0, attr->Value());
                         }
                         else if (attrName == "HOMOGENEOUSLENGTHS")
                         {
                             homoLengthsString.insert(0,attr->Value());
                         }
                         else if (attrName == "HOMOGENEOUSSIDS")
                         {
                             homoSIDsString.insert(0,attr->Value());
                         }
                         else if (attrName == "HOMOGENEOUSZIDS")
                         {
                             homoZIDsString.insert(0,attr->Value());
                         }
                         else if (attrName == "HOMOGENEOUSYIDS")
                         {
                             homoYIDsString.insert(0,attr->Value());
                         }
                         else if (attrName == "NUMMODESPERDIR")
                         {
                             numModesString.insert(0, attr->Value());
                         }
                         else if (attrName == "ID")
                         {
                             idString.insert(0, attr->Value());
                         }
                         else if (attrName == "POINTSTYPE")
                         {
                             pointsString.insert(0, attr->Value());
                             pointDef = true;
                         }
                         else if (attrName == "NUMPOINTSPERDIR")
                         {
                             numPointsString.insert(0, attr->Value());
                             numPointDef = true;
                         }
                         else if (attrName == "COMPRESSED")
                         {
                             if(!boost::iequals(attr->Value(),
                                             CompressData::GetCompressString()))
                             {
                                 WARNINGL0(false, "Compressed formats do not "
                                           "match. Expected: "
                                           + CompressData::GetCompressString()
                                           + " but got "+ string(attr->Value()));
                             }
                         }
                         else if (attrName =="BITSIZE")
                         {
                             // This information is for future
                             // compatibility issues, for exmaple in
                             // case we end up using a 128 bit machine.
                             // Currently just do nothing
                         }
                         else
                         {
                             std::string errstr("Unknown attribute: ");
                             errstr += attrName;
                             ASSERTL1(false, errstr.c_str());
                         }
 
                         // Get the next attribute.
                         attr = attr->Next();
                     }
 
 
                     // Check to see if using strips formulation
                     bool strips = false;
                     if(shapeString.find("Strips")!=string::npos)
                     {
                         strips = true;
                     }
 
                     // Check to see if homogeneous expansion and if so
                     // strip down the shapeString definition
                     int numHomoDir = 0;
                     size_t loc;
                     //---> This finds the first location of  'n'!
                     if((loc = shapeString.find_first_of("-"))!=string::npos)
                     {
                         if(shapeString.find("Exp1D")!=string::npos)
                         {
                             numHomoDir = 1;
                         }
                         else // HomogeneousExp1D
                         {
                             numHomoDir = 2;
                         }
 
                         shapeString.erase(loc,shapeString.length());
                     }
 
                     // Reconstruct the fielddefs.
                     std::vector<unsigned int> elementIds;
                     {
                         bool valid = ParseUtils::GenerateSeqVector(idString.c_str(), elementIds);
                         ASSERTL0(valid, "Unable to correctly parse the element ids.");
                     }
 
                     // Get the geometrical shape
                     ShapeType shape;
                     bool valid = false;
                     for (unsigned int j = 0; j < SIZE_ShapeType; j++)
                     {
                         if (ShapeTypeMap[j] == shapeString)
                         {
                             shape = (ShapeType) j;
                             valid = true;
                             break;
                         }
                     }
 
                     ASSERTL0(valid, std::string("Unable to correctly parse the shape type: ").append(shapeString).c_str());
 
                     // Get the basis
                     std::vector<std::string> basisStrings;
                     std::vector<BasisType> basis;
                     valid = ParseUtils::GenerateOrderedStringVector(basisString.c_str(), basisStrings);
                     ASSERTL0(valid, "Unable to correctly parse the basis types.");
                     for (std::vector<std::string>::size_type i = 0; i < basisStrings.size(); i++)
                     {
                         valid = false;
                         for (unsigned int j = 0; j < SIZE_BasisType; j++)
                         {
                             if (BasisTypeMap[j] == basisStrings[i])
                             {
                                 basis.push_back((BasisType) j);
                                 valid = true;
                                 break;
                             }
                         }
                         ASSERTL0(valid, std::string("Unable to correctly parse the basis type: ").append(basisStrings[i]).c_str());
                     }
 
                     // Get homoLengths
                     std::vector<NekDouble> homoLengths;
                     if(numHomoDir)
                     {
                         valid = ParseUtils::GenerateUnOrderedVector(homoLengthsString.c_str(), homoLengths);
                         ASSERTL0(valid, "Unable to correctly parse the number of homogeneous lengths.");
                     }
 
                     // Get Homogeneous strips IDs
                     std::vector<unsigned int> homoSIDs;
                     if(strips)
                     {
                         valid = ParseUtils::GenerateSeqVector(homoSIDsString.c_str(), homoSIDs);
                         ASSERTL0(valid, "Unable to correctly parse homogeneous strips IDs.");
                     }
                     // Get Homogeneous points IDs
                     std::vector<unsigned int> homoZIDs;
                     std::vector<unsigned int> homoYIDs;
 
                     if(numHomoDir == 1)
                     {
                         valid = ParseUtils::GenerateSeqVector(homoZIDsString.c_str(), homoZIDs);
                         ASSERTL0(valid, "Unable to correctly parse homogeneous planes IDs.");
                     }
 
                     if(numHomoDir == 2)
                     {
                         valid = ParseUtils::GenerateSeqVector(homoZIDsString.c_str(), homoZIDs);
                         ASSERTL0(valid, "Unable to correctly parse homogeneous lines IDs in z-direction.");
                         valid = ParseUtils::GenerateSeqVector(homoYIDsString.c_str(), homoYIDs);
                         ASSERTL0(valid, "Unable to correctly parse homogeneous lines IDs in y-direction.");
                     }
 
 
                     // Get points type
                     std::vector<PointsType> points;
 
                     if(pointDef)
                     {
                         std::vector<std::string> pointsStrings;
                         valid = ParseUtils::GenerateOrderedStringVector(pointsString.c_str(), pointsStrings);
                         ASSERTL0(valid, "Unable to correctly parse the points types.");
                         for (std::vector<std::string>::size_type i = 0; i < pointsStrings.size(); i++)
                         {
                             valid = false;
                             for (unsigned int j = 0; j < SIZE_PointsType; j++)
                             {
                                 if (kPointsTypeStr[j] == pointsStrings[i])
                                 {
                                     points.push_back((PointsType) j);
                                     valid = true;
                                     break;
                                 }
                             }
 
                             ASSERTL0(valid, std::string("Unable to correctly parse the points type: ").append(pointsStrings[i]).c_str());
                         }
                     }
 
                     // Get numModes
                     std::vector<unsigned int> numModes;
                     bool UniOrder = false;
 
                     if(strstr(numModesString.c_str(),"UNIORDER:"))
                     {
                         UniOrder  = true;
                     }
 
                     valid = ParseUtils::GenerateOrderedVector(numModesString.c_str()+9, numModes);
                     ASSERTL0(valid, "Unable to correctly parse the number of modes.");
 
                     // Get numPoints
                     std::vector<unsigned int> numPoints;
                     if(numPointDef)
                     {
                         valid = ParseUtils::GenerateOrderedVector(numPointsString.c_str(), numPoints);
                         ASSERTL0(valid, "Unable to correctly parse the number of points.");
                     }
 
                     // Get fields names
                     std::vector<std::string> Fields;
                     valid = ParseUtils::GenerateOrderedStringVector(fieldsString.c_str(), Fields);
                     ASSERTL0(valid, "Unable to correctly parse the number of fields.");
 
                     FieldDefinitionsSharedPtr fielddef  = 
                             MemoryManager<FieldDefinitions>::AllocateSharedPtr(shape, 
                             elementIds, basis, UniOrder, numModes, Fields, numHomoDir, 
                             homoLengths, strips, homoSIDs, homoZIDs, homoYIDs, 
                             points, pointDef, numPoints, numPointDef);
 
                     fielddefs.push_back(fielddef);
 
                     element = element->NextSiblingElement("ELEMENTS");
                 }
                 loopXml = loopXml->NextSiblingElement(strLoop);
             }
         }

void Nektar::LibUtilities::FieldIO::ImportFieldMetaData	(	std::string	filename,
		FieldMetaDataMap &	fieldmetadatamap
	)

Imports the definition of the meta data.

Definition at line 634 of file FieldIO.cpp.

References ASSERTL0.

Referenced by Nektar::LibUtilities::PtsIO::Import(), and Import().

         {
             TiXmlDocument doc(filename);
             bool loadOkay = doc.LoadFile();
 
             std::stringstream errstr;
             errstr << "Unable to load file: " << filename << std::endl;
             errstr << "Reason: " << doc.ErrorDesc() << std::endl;
             errstr << "Position: Line " << doc.ErrorRow() << ", Column " << doc.ErrorCol() << std::endl;
             ASSERTL0(loadOkay, errstr.str());
 
             ImportFieldMetaData(doc,fieldmetadatamap);
         }

void Nektar::LibUtilities::FieldIO::ImportFieldMetaData	(	TiXmlDocument &	doc,
		FieldMetaDataMap &	fieldmetadatamap
	)

Imports the definition of the meta data.

Definition at line 650 of file FieldIO.cpp.

References ASSERTL0.

         {
 
             TiXmlHandle docHandle(&doc);
             TiXmlElement* master = 0;    // Master tag within which all data is contained.
             TiXmlElement* metadata = 0;
 
             master = doc.FirstChildElement("NEKTAR");
             ASSERTL0(master, "Unable to find NEKTAR tag in file.");
             std::string strLoop = "NEKTAR";
 
             // Retain original metadata structure for backwards compatibility
             // TODO: Remove old metadata format
             metadata = master->FirstChildElement("FIELDMETADATA");
             if(metadata)
             {
                 TiXmlElement *param = metadata->FirstChildElement("P");
 
                 while (param)
                 {
                     TiXmlAttribute *paramAttr = param->FirstAttribute();
                     std::string attrName(paramAttr->Name());
                     std::string paramString;
 
                     if(attrName == "PARAM")
                     {
                         paramString.insert(0,paramAttr->Value());
                     }
                     else
                     {
                         ASSERTL0(false,"PARAM not provided as an attribute in FIELDMETADATA section");
                     }
 
                     // Now read body of param
                     std::string paramBodyStr;
 
                     TiXmlNode *paramBody = param->FirstChild();
 
                     paramBodyStr += paramBody->ToText()->Value();
 
                     fieldmetadatamap[paramString] = paramBodyStr;
                     param = param->NextSiblingElement("P");
                 }
             }
 
             // New metadata format
             metadata = master->FirstChildElement("Metadata");
             if(metadata)
             {
                 TiXmlElement *param = metadata->FirstChildElement();
 
                 while (param)
                 {
                     std::string paramString = param->Value();
                     if (paramString != "Provenance")
                     {
                         // Now read body of param
                         TiXmlNode *paramBody = param->FirstChild();
                         std::string paramBodyStr = paramBody->ToText()->Value();
 
                         fieldmetadatamap[paramString] = paramBodyStr;
                     }
                     param = param->NextSiblingElement();
                 }
             }
 
         }

void Nektar::LibUtilities::FieldIO::ImportMultiFldFileIDs	(	const std::string &	inFile,
		std::vector< std::string > &	fileNames,
		std::vector< std::vector< unsigned int > > &	elementList,
		FieldMetaDataMap &	fieldmetadatamap
	)

protected

Definition at line 574 of file FieldIO.cpp.

References ASSERTL0, and Nektar::ParseUtils::GenerateSeqVector().

Referenced by Nektar::LibUtilities::PtsIO::Import(), and Import().

          {
              TiXmlDocument doc(inFile);
              bool loadOkay = doc.LoadFile();
 
 
              std::stringstream errstr;
              errstr << "Unable to load file: " << inFile<< std::endl;
              errstr << "Reason: " << doc.ErrorDesc() << std::endl;
              errstr << "Position: Line " << doc.ErrorRow() << ", Column " << doc.ErrorCol() << std::endl;
              ASSERTL0(loadOkay, errstr.str());
 
              // Handle on XML document
              TiXmlHandle docHandle(&doc);
 
              // Retrieve main NEKTAR tag - XML specification states one
              // top-level element tag per file.
              TiXmlElement* master = doc.FirstChildElement("NEKTAR");
              ASSERTL0(master, "Unable to find NEKTAR tag in file.");
 
              // Partition element tag name
              std::string strPartition = "Partition";
 
              // First attempt to get the first Partition element
              TiXmlElement* fldfileIDs = master->FirstChildElement(strPartition.c_str());
              if (!fldfileIDs)
              {
                  // If this files try previous name
                  strPartition = "MultipleFldFiles";
                  fldfileIDs = master->FirstChildElement("MultipleFldFiles");
              }
              ASSERTL0(fldfileIDs,
                       "Unable to find 'Partition' or 'MultipleFldFiles' tag "
                       "within nektar tag.");
 
              while (fldfileIDs)
              {
                 // Read file name of partition file
                 const char *attr = fldfileIDs->Attribute("FileName");
                 ASSERTL0(attr, "'FileName' not provided as an attribute of '"
                                 + strPartition + "' tag.");
                 fileNames.push_back(std::string(attr));
 
                 const char* elementIDs = fldfileIDs->GetText();
                 ASSERTL0(elementIDs, "Element IDs not specified.");
 
                 std::string elementIDsStr(elementIDs);
 
                 std::vector<unsigned int> idvec;
                 ParseUtils::GenerateSeqVector(elementIDsStr.c_str(),idvec);
 
                 elementList.push_back(idvec);
 
                 fldfileIDs = fldfileIDs->NextSiblingElement(strPartition.c_str());
              }
          }

void Nektar::LibUtilities::FieldIO::SetUpFieldMetaData	(	const std::string	outname,
		const std::vector< FieldDefinitionsSharedPtr > &	fielddefs,
		const FieldMetaDataMap &	fieldmetadatamap
	)

protected

Definition at line 1282 of file FieldIO.cpp.

References ASSERTL0, GetFileEnding(), m_comm, Nektar::LibUtilities::PortablePath(), Nektar::LibUtilities::ReduceMax, and WriteMultiFldFileIDs().

Referenced by Write().

         {
             ASSERTL0(!outname.empty(), "Empty path given to SetUpFieldMetaData()");
 
             int nprocs = m_comm->GetSize();
             int rank   = m_comm->GetRank();
 
             fs::path specPath (outname);
 
             // Compute number of elements on this process and share with other
             // processes. Also construct list of elements on this process from
             // available vector of field definitions.
             std::vector<unsigned int> elmtnums(nprocs,0);
             std::vector<unsigned int> idlist;
             int i;
             for (i = 0; i < fielddefs.size(); ++i)
             {
                 elmtnums[rank] += fielddefs[i]->m_elementIDs.size();
                 idlist.insert(idlist.end(), fielddefs[i]->m_elementIDs.begin(),
                                             fielddefs[i]->m_elementIDs.end());
             }
             m_comm->AllReduce(elmtnums,LibUtilities::ReduceMax);
 
             // Collate per-process element lists on root process to generate
             // the info file.
             if (rank == 0)
             {
                 std::vector<std::vector<unsigned int> > ElementIDs(nprocs);
 
                 // Populate the list of element ID lists from all processes
                 ElementIDs[0] = idlist;
                 for (i = 1; i < nprocs; ++i)
                 {
                     std::vector<unsigned int> tmp(elmtnums[i]);
                     m_comm->Recv(i, tmp);
                     ElementIDs[i] = tmp;
                 }
 
                 // Set up output names
                 std::vector<std::string> filenames;
                 for(int i = 0; i < nprocs; ++i)
                 {
                     boost::format pad("P%1$07d.%2$s");
                     pad % i % GetFileEnding();
                     filenames.push_back(pad.str());
                 }
 
                 // Write the Info.xml file
                 string infofile = LibUtilities::PortablePath(
                                             specPath / fs::path("Info.xml"));
 
                 cout << "Writing: " << specPath << endl;
                 WriteMultiFldFileIDs(infofile, filenames, ElementIDs,
                                      fieldmetadatamap);
             }
             else
             {
                 // Send this process's ID list to the root process
                 m_comm->Send(0, idlist);
             }
 
         }

std::string Nektar::LibUtilities::FieldIO::SetUpOutput ( const std::string outname )

protected

Definition at line 1189 of file FieldIO.cpp.

References ASSERTL0, GetFileEnding(), m_comm, m_sharedFilesystem, and Nektar::LibUtilities::PortablePath().

Referenced by Nektar::LibUtilities::PtsIO::Write(), and Write().

         {
             ASSERTL0(!outname.empty(), "Empty path given to SetUpOutput()");
 
             int nprocs = m_comm->GetSize();
             int rank   = m_comm->GetRank();
 
             // Path to output: will be directory if parallel, normal file if
             // serial.
             fs::path specPath (outname);
             fs::path fulloutname;
 
             if (nprocs == 1)
             {
                 fulloutname = specPath;
             }
             else
             {
                 // Guess at filename that might belong to this process.
                 boost::format pad("P%1$07d.%2$s");
                 pad % m_comm->GetRank() % GetFileEnding();
 
                 // Generate full path name
                 fs::path poutfile(pad.str());
                 fulloutname = specPath / poutfile;
             }
 
             // Remove any existing file which is in the way
             if (m_comm->RemoveExistingFiles())
             {
                 if (m_sharedFilesystem)
                 {
                     // First, each process clears up its .fld file. This might
                     // or might not be there (we might have changed numbers of
                     // processors between runs, for example), but we can try
                     // anyway.
                     try
                     {
                         fs::remove_all(fulloutname);
                     }
                     catch (fs::filesystem_error& e)
                     {
                         ASSERTL0(e.code().value() == berrc::no_such_file_or_directory,
                                  "Filesystem error: " + string(e.what()));
                     }
                 }
 
                 m_comm->Block();
 
                 // Now get rank 0 processor to tidy everything else up.
                 if (rank == 0 || !m_sharedFilesystem)
                 {
                     try
                     {
                         fs::remove_all(specPath);
                     }
                     catch (fs::filesystem_error& e)
                     {
                         ASSERTL0(e.code().value() == berrc::no_such_file_or_directory,
                                  "Filesystem error: " + string(e.what()));
                     }
                 }
 
                 m_comm->Block();
             }
 
             // serial processing just add ending.
             if(nprocs == 1)
             {
                 cout << "Writing: " << specPath << endl;
                 return LibUtilities::PortablePath(specPath);
             }
 
             // Create the destination directory
             try
             {
                 if (rank == 0 || !m_sharedFilesystem)
                 {
                     fs::create_directory(specPath);
                 }
             }
             catch (fs::filesystem_error& e)
             {
                 ASSERTL0(false, "Filesystem error: " + string(e.what()));
             }
 
             m_comm->Block();
 
             // Return the full path to the partition for this process
             return LibUtilities::PortablePath(fulloutname);
         }

void Nektar::LibUtilities::FieldIO::Write	(	const std::string &	outFile,
		std::vector< FieldDefinitionsSharedPtr > &	fielddefs,
		std::vector< std::vector< NekDouble > > &	fielddata,
		const FieldMetaDataMap &	fieldinfomap = `NullFieldMetaDataMap`
	)

Write data in FLD format.

Definition at line 160 of file FieldIO.cpp.

References AddInfoTag(), ASSERTL0, ASSERTL1, Nektar::LibUtilities::BasisTypeMap, CheckFieldDefinition(), GenerateSeqString(), Nektar::LibUtilities::CompressData::GetBitSizeStr(), Nektar::LibUtilities::CompressData::GetCompressString(), SetUpFieldMetaData(), SetUpOutput(), Nektar::LibUtilities::ShapeTypeMap, and Nektar::LibUtilities::CompressData::ZlibEncodeToBase64Str().

Referenced by main(), and Nektar::LibUtilities::Write().

         {
             // Check everything seems sensible
             ASSERTL1(fielddefs.size() == fielddata.size(),
                       "Length of fielddefs and fielddata incompatible");
             for (int f = 0; f < fielddefs.size(); ++f)
             {
                 ASSERTL1(fielddata[f].size() > 0,
                         "Fielddata vector must contain at least one value.");
 
                 ASSERTL1(fielddata[f].size() ==
                              fielddefs[f]->m_fields.size() *
                              CheckFieldDefinition(fielddefs[f]),
                          "Invalid size of fielddata vector.");
             }
 
             // Prepare to write out data. In parallel, we must create directory
             // and determine the full pathname to the file to write out.
             // Any existing file/directory which is in the way is removed.
             std::string filename = SetUpOutput(outFile);
             SetUpFieldMetaData(outFile, fielddefs, fieldmetadatamap);
 
             // Create the file (partition)
             TiXmlDocument doc;
             TiXmlDeclaration * decl = new TiXmlDeclaration("1.0", "utf-8", "");
             doc.LinkEndChild(decl);
 
             TiXmlElement * root = new TiXmlElement("NEKTAR");
             doc.LinkEndChild(root);
 
             AddInfoTag(root,fieldmetadatamap);
 
             for (int f = 0; f < fielddefs.size(); ++f)
             {
                 //---------------------------------------------
                 // Write ELEMENTS
                 TiXmlElement * elemTag = new TiXmlElement("ELEMENTS");
                 root->LinkEndChild(elemTag);
 
                 // Write FIELDS
                 std::string fieldsString;
                 {
                     std::stringstream fieldsStringStream;
                     bool first = true;
                     for (std::vector<int>::size_type i = 0; i
                     < fielddefs[f]->m_fields.size(); i++)
                     {
                         if (!first)
                             fieldsStringStream << ",";
                         fieldsStringStream << fielddefs[f]->m_fields[i];
                         first = false;
                     }
                     fieldsString = fieldsStringStream.str();
                 }
                 elemTag->SetAttribute("FIELDS", fieldsString);
 
                 // Write SHAPE
                 std::string shapeString;
                 {
                     std::stringstream shapeStringStream;
                     shapeStringStream << ShapeTypeMap[fielddefs[f]->m_shapeType];
                     if(fielddefs[f]->m_numHomogeneousDir == 1)
                     {
                         shapeStringStream << "-HomogenousExp1D";
                     }
                     else if (fielddefs[f]->m_numHomogeneousDir == 2)
                     {
                         shapeStringStream << "-HomogenousExp2D";
                     }
 
                     if (fielddefs[f]->m_homoStrips)
                     {
                         shapeStringStream << "-Strips";
                     }
 
                     shapeString = shapeStringStream.str();
                 }
                 elemTag->SetAttribute("SHAPE", shapeString);
 
                 // Write BASIS
                 std::string basisString;
                 {
                     std::stringstream basisStringStream;
                     bool first = true;
                     for (std::vector<BasisType>::size_type i = 0; i < fielddefs[f]->m_basis.size(); i++)
                     {
                         if (!first)
                             basisStringStream << ",";
                         basisStringStream
                         << BasisTypeMap[fielddefs[f]->m_basis[i]];
                         first = false;
                     }
                     basisString = basisStringStream.str();
                 }
                 elemTag->SetAttribute("BASIS", basisString);
 
                 // Write homogeneuous length details
                 if(fielddefs[f]->m_numHomogeneousDir)
                 {
                     std::string homoLenString;
                     {
                         std::stringstream homoLenStringStream;
                         bool first = true;
                         for (int i = 0; i < fielddefs[f]->m_numHomogeneousDir; ++i)
                         {
                             if (!first)
                                 homoLenStringStream << ",";
                             homoLenStringStream
                             << fielddefs[f]->m_homogeneousLengths[i];
                             first = false;
                         }
                         homoLenString = homoLenStringStream.str();
                     }
                     elemTag->SetAttribute("HOMOGENEOUSLENGTHS", homoLenString);
                 }
 
                 // Write homogeneuous planes/lines details
                 if(fielddefs[f]->m_numHomogeneousDir)
                 {
                     if(fielddefs[f]->m_homogeneousYIDs.size() > 0)
                     {
                         std::string homoYIDsString;
                         {
                             std::stringstream homoYIDsStringStream;
                             bool first = true;
                             for(int i = 0; i < fielddefs[f]->m_homogeneousYIDs.size(); i++)
                             {
                                 if (!first)
                                     homoYIDsStringStream << ",";
                                 homoYIDsStringStream << fielddefs[f]->m_homogeneousYIDs[i];
                                 first = false;
                             }
                             homoYIDsString = homoYIDsStringStream.str();
                         }
                         elemTag->SetAttribute("HOMOGENEOUSYIDS", homoYIDsString);
                     }
 
                     if(fielddefs[f]->m_homogeneousZIDs.size() > 0)
                     {
                         std::string homoZIDsString;
                         {
                             std::stringstream homoZIDsStringStream;
                             bool first = true;
                             for(int i = 0; i < fielddefs[f]->m_homogeneousZIDs.size(); i++)
                             {
                                 if (!first)
                                     homoZIDsStringStream << ",";
                                 homoZIDsStringStream << fielddefs[f]->m_homogeneousZIDs[i];
                                 first = false;
                             }
                             homoZIDsString = homoZIDsStringStream.str();
                         }
                         elemTag->SetAttribute("HOMOGENEOUSZIDS", homoZIDsString);
                     }
                     
                     if(fielddefs[f]->m_homogeneousSIDs.size() > 0)
                     {
                         std::string homoSIDsString;
                         {
                             std::stringstream homoSIDsStringStream;
                             bool first = true;
                             for(int i = 0; i < fielddefs[f]->m_homogeneousSIDs.size(); i++)
                             {
                                 if (!first)
                                     homoSIDsStringStream << ",";
                                 homoSIDsStringStream << fielddefs[f]->m_homogeneousSIDs[i];
                                 first = false;
                             }
                             homoSIDsString = homoSIDsStringStream.str();
                         }
                         elemTag->SetAttribute("HOMOGENEOUSSIDS", homoSIDsString);
                     }
                 }
 
                 // Write NUMMODESPERDIR
                 std::string numModesString;
                 {
                     std::stringstream numModesStringStream;
 
                     if (fielddefs[f]->m_uniOrder)
                     {
                         numModesStringStream << "UNIORDER:";
                         // Just dump single definition
                         bool first = true;
                         for (std::vector<int>::size_type i = 0; i
                                  < fielddefs[f]->m_basis.size(); i++)
                         {
                             if (!first)
                                 numModesStringStream << ",";
                             numModesStringStream << fielddefs[f]->m_numModes[i];
                             first = false;
                         }
                     }
                     else
                     {
                         numModesStringStream << "MIXORDER:";
                         bool first = true;
                         for (std::vector<int>::size_type i = 0; i
                                  < fielddefs[f]->m_numModes.size(); i++)
                         {
                             if (!first)
                                 numModesStringStream << ",";
                             numModesStringStream << fielddefs[f]->m_numModes[i];
                             first = false;
                         }
                     }
 
                     numModesString = numModesStringStream.str();
                 }
                 elemTag->SetAttribute("NUMMODESPERDIR", numModesString);
 
                 // Write ID
                 // Should ideally look at ways of compressing this stream
                 // if just sequential;
                 std::string idString;
                 {
                     std::stringstream idStringStream;
                     GenerateSeqString(fielddefs[f]->m_elementIDs,idString);
                 }
                 elemTag->SetAttribute("ID", idString);
                 elemTag->SetAttribute("COMPRESSED",
                               LibUtilities::CompressData::GetCompressString());
 
                 // Add this information for future compatibility
                 // issues, for exmaple in case we end up using a 128
                 // bit machine.
                 elemTag->SetAttribute("BITSIZE",
                               LibUtilities::CompressData::GetBitSizeStr());
                 std::string base64string;
                 ASSERTL0(Z_OK == CompressData::ZlibEncodeToBase64Str(
                                                 fielddata[f], base64string),
                          "Failed to compress field data.");
 
                 elemTag->LinkEndChild(new TiXmlText(base64string));
 
             }
             doc.SaveFile(filename);
         }

void Nektar::LibUtilities::FieldIO::WriteMultiFldFileIDs	(	const std::string &	outfile,
		const std::vector< std::string >	fileNames,
		std::vector< std::vector< unsigned int > > &	elementList,
		const FieldMetaDataMap &	fieldinfomap = `NullFieldMetaDataMap`
	)

Definition at line 534 of file FieldIO.cpp.

References AddInfoTag(), ASSERTL0, and GenerateSeqString().

Referenced by Nektar::LibUtilities::PtsIO::SetUpFieldMetaData(), and SetUpFieldMetaData().

         {
             TiXmlDocument doc;
             TiXmlDeclaration * decl = new TiXmlDeclaration("1.0", "utf-8", "");
             doc.LinkEndChild(decl);
 
             ASSERTL0(fileNames.size() == elementList.size(),"Outfile names and list of elements ids does not match");
 
             TiXmlElement * root = new TiXmlElement("NEKTAR");
             doc.LinkEndChild(root);
 
             AddInfoTag(root,fieldmetadatamap);
 
             for (int t = 0; t < fileNames.size(); ++t)
             {
                 if(elementList[t].size())
                 {
                     TiXmlElement * elemIDs = new TiXmlElement("Partition");
                     root->LinkEndChild(elemIDs);
 
                     elemIDs->SetAttribute("FileName",fileNames[t]);
 
                     string IDstring;
 
                     GenerateSeqString(elementList[t],IDstring);
 
                     elemIDs->LinkEndChild(new TiXmlText(IDstring));
                 }
             }
 
             doc.SaveFile(outFile);
         }

Member Data Documentation

LibUtilities::CommSharedPtr Nektar::LibUtilities::FieldIO::m_comm

protected

Communicator to use when writing parallel format.

Definition at line 191 of file FieldIO.h.

Referenced by Nektar::LibUtilities::PtsIO::Import(), Nektar::LibUtilities::PtsIO::SetUpFieldMetaData(), SetUpFieldMetaData(), and SetUpOutput().

bool Nektar::LibUtilities::FieldIO::m_sharedFilesystem

protected

True if same filesystem accessible by all processes.

Definition at line 194 of file FieldIO.h.

Referenced by SetUpOutput().

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation