#include <PtsIO.h>

Inheritance diagram for Nektar::LibUtilities::PtsIO:

Public Member Functions
	PtsIO (LibUtilities::CommSharedPtr pComm, bool sharedFilesystem=false)

virtual	~PtsIO ()

void	Import (const std::string &inFile, PtsFieldSharedPtr &ptsField, FieldMetaDataMap &fieldmetadatamap=NullFieldMetaDataMap, DomainRangeShPtr &Range=NullDomainRangeShPtr)
	Import a pts field from file. More...

void	Write (const std::string &outFile, const PtsFieldSharedPtr &ptsField, const bool backup=false)
	Save a pts field to a file. More...

void	ImportFieldData (const std::string inFile, PtsFieldSharedPtr &ptsField, DomainRangeShPtr &Range=NullDomainRangeShPtr)

Public Member Functions inherited from Nektar::LibUtilities::FieldIOXml
	FieldIOXml (LibUtilities::CommSharedPtr pComm, bool sharedFilesystem)
	Default constructor. More...

virtual	~FieldIOXml ()

void	ImportFieldDefs (DataSourceSharedPtr dataSource, std::vector< FieldDefinitionsSharedPtr > &fielddefs, bool expChild)
	Import field definitions from the target file. More...

void	ImportFieldData (DataSourceSharedPtr dataSource, const std::vector< FieldDefinitionsSharedPtr > &fielddefs, std::vector< std::vector< NekDouble > > &fielddata)
	Import field data from a target file. More...

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. More...

void	SetUpFieldMetaData (const std::string &outname, const std::vector< FieldDefinitionsSharedPtr > &fielddefs, const FieldMetaDataMap &fieldmetadatamap)
	Set up field meta data map. More...

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. More...

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. More...

virtual const std::string &	GetClassName () const
	Returns the class name. More...

Public Member Functions inherited from Nektar::LibUtilities::FieldIO
	FieldIO (LibUtilities::CommSharedPtr pComm, bool sharedFilesystem)
	Constructor for FieldIO base class. More...

virtual	~FieldIO ()

void	Write (const std::string &outFile, std::vector< FieldDefinitionsSharedPtr > &fielddefs, std::vector< std::vector< NekDouble > > &fielddata, const FieldMetaDataMap &fieldinfomap=NullFieldMetaDataMap, const bool backup=false)
	Write out the field information to the file `outFile`. 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)
	Read field information from the file `infilename`. More...

DataSourceSharedPtr	ImportFieldMetaData (const std::string &filename, FieldMetaDataMap &fieldmetadatamap)
	Import the metadata from a field file. More...

Protected Member Functions
virtual void	v_ImportFieldData (const std::string inFile, PtsFieldSharedPtr &ptsField, DomainRangeShPtr &Range=NullDomainRangeShPtr)

void	SetUpFieldMetaData (const std::string outname)

virtual std::string	GetFileEnding () const
	Helper function that determines default file extension. More...

Protected Member Functions inherited from Nektar::LibUtilities::FieldIO
int	CheckFieldDefinition (const FieldDefinitionsSharedPtr &fielddefs)
	Check field definitions for correctness and return storage size. More...

std::string	SetUpOutput (const std::string outname, bool perRank, bool backup=false)
	Set up the filesystem ready for output. More...

Additional Inherited Members
Static Public Member Functions inherited from Nektar::LibUtilities::FieldIOXml
static FieldIOSharedPtr	create (LibUtilities::CommSharedPtr pComm, bool sharedFilesystem)
	Creates an instance of this class. More...

Static Public Member Functions inherited from Nektar::LibUtilities::FieldIO
static const std::string	GetFileType (const std::string &filename, CommSharedPtr comm)
	Determine file type of given input file. More...

static std::shared_ptr< FieldIO >	CreateDefault (const LibUtilities::SessionReaderSharedPtr session)
	Returns an object for the default FieldIO method. More...

static std::shared_ptr< FieldIO >	CreateForFile (const LibUtilities::SessionReaderSharedPtr session, const std::string &filename)
	Construct a FieldIO object for a given input filename. More...

static void	AddInfoTag (TagWriterSharedPtr root, const FieldMetaDataMap &fieldmetadatamap)
	Add provenance information to the field metadata map. More...

Static Public Attributes inherited from Nektar::LibUtilities::FieldIOXml
static std::string	className
	Name of class. More...

Protected Attributes inherited from Nektar::LibUtilities::FieldIO
LibUtilities::CommSharedPtr	m_comm
	Communicator to use when writing parallel format. More...

bool	m_sharedFilesystem
	Boolean dictating whether we are on a shared filesystem. More...

Detailed Description

Definition at line 62 of file PtsIO.h.

Constructor & Destructor Documentation

◆ PtsIO()

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

Definition at line 60 of file PtsIO.cpp.

     : FieldIOXml(pComm, sharedFilesystem)
 {
 }

◆ ~PtsIO()

virtual Nektar::LibUtilities::PtsIO::~PtsIO ( )

inlinevirtual

Definition at line 68 of file PtsIO.h.

69 {

70 }

Member Function Documentation

◆ GetFileEnding()

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

inlineprotectedvirtual

Helper function that determines default file extension.

Reimplemented from Nektar::LibUtilities::FieldIO.

Reimplemented in Nektar::LibUtilities::CsvIO.

Definition at line 95 of file PtsIO.h.

     {
         return "pts";
     };

Referenced by Import(), and SetUpFieldMetaData().

◆ Import()

void Nektar::LibUtilities::PtsIO::Import	(	const std::string &	inFile,
		PtsFieldSharedPtr &	ptsField,
		FieldMetaDataMap &	fieldmetadatamap = `NullFieldMetaDataMap`,
		DomainRangeShPtr &	Range = `NullDomainRangeShPtr`
	)

Import a pts field from file.

Parameters

inFile	filename of the file to read
ptsField	the resulting pts field.

Definition at line 71 of file PtsIO.cpp.

 {
     std::string infile = inFile;
  
     fs::path pinfilename(infile);
  
     // check to see that infile is a directory
     if (fs::is_directory(pinfilename))
     {
         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 (filenames.size() == m_comm->GetSize())
         {
         // only load the file that matches this rank
             filenames.clear();
             boost::format pad("P%1$07d.%2$s");
             pad % m_comm->GetRank() % GetFileEnding();
             filenames.push_back(pad.str());
         }
  
         for (int i = 0; i < filenames.size(); ++i)
         {
             fs::path pfilename(filenames[i]);
             fullpath = pinfilename / pfilename;
             string fname = PortablePath(fullpath);
  
             if (i == 0)
             {
                 ImportFieldData(fname, ptsField, Range);
             }
             else
             {
                 LibUtilities::PtsFieldSharedPtr newPtsField;
                 ImportFieldData(fname, newPtsField, Range);
                 Array<OneD, Array<OneD, NekDouble> > pts;
                 newPtsField->GetPts(pts);
                 ptsField->AddPoints(pts);
             }
  
         }
     }
     else
     {
         ImportFieldData(infile, ptsField, Range);
     }
 }

References CellMLToNektar.pycml::format, GetFileEnding(), ImportFieldData(), Nektar::LibUtilities::FieldIO::ImportFieldMetaData(), Nektar::LibUtilities::FieldIOXml::ImportMultiFldFileIDs(), Nektar::LibUtilities::FieldIO::m_comm, and Nektar::LibUtilities::PortablePath().

Referenced by Nektar::SolverUtils::SessionFunction::EvaluatePts().

◆ ImportFieldData()

void Nektar::LibUtilities::PtsIO::ImportFieldData	(	const std::string	inFile,
		PtsFieldSharedPtr &	ptsField,
		DomainRangeShPtr &	Range = `NullDomainRangeShPtr`
	)

Definition at line 214 of file PtsIO.cpp.

 {
     v_ImportFieldData(inFile, ptsField, Range);
 }

References v_ImportFieldData().

Referenced by Import().

◆ SetUpFieldMetaData()

void Nektar::LibUtilities::PtsIO::SetUpFieldMetaData ( const std::string outname )

protected

Definition at line 311 of file PtsIO.cpp.

 {
     ASSERTL0(!outname.empty(), "Empty path given to SetUpFieldMetaData()");
  
     int nprocs = m_comm->GetSize();
     int rank = m_comm->GetRank();
  
     fs::path specPath(outname);
  
     // Collate per-process element lists on root process to generate
     // the info file.
     if (rank == 0)
     {
         // Set up output names
         std::vector<std::string> filenames;
         std::vector<std::vector<unsigned int> > ElementIDs;
         for (int i = 0; i < nprocs; ++i)
         {
             boost::format pad("P%1$07d.%2$s");
             pad % i % GetFileEnding();
             filenames.push_back(pad.str());
  
             std::vector<unsigned int> tmp;
             tmp.push_back(0);
             ElementIDs.push_back(tmp);
         }
  
         // Write the Info.xml file
         string infofile =
             LibUtilities::PortablePath(specPath / fs::path("Info.xml"));
  
         cout << "Writing: " << specPath << endl;
  
         const FieldMetaDataMap fieldmetadatamap;
         WriteMultiFldFileIDs(infofile, filenames, ElementIDs, fieldmetadatamap);
     }
 }

References ASSERTL0, CellMLToNektar.pycml::format, GetFileEnding(), Nektar::LibUtilities::FieldIO::m_comm, Nektar::LibUtilities::PortablePath(), and Nektar::LibUtilities::FieldIOXml::WriteMultiFldFileIDs().

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

◆ v_ImportFieldData()

void Nektar::LibUtilities::PtsIO::v_ImportFieldData	(	const std::string	inFile,
		PtsFieldSharedPtr &	ptsField,
		DomainRangeShPtr &	Range = `NullDomainRangeShPtr`
	)

protectedvirtual

Reimplemented in Nektar::LibUtilities::CsvIO.

Definition at line 220 of file PtsIO.cpp.

 {
     boost::ignore_unused(Range);
     TiXmlDocument docInput(inFile);
     bool loadOkay1 = docInput.LoadFile();
  
     std::stringstream errstr;
     errstr << "Unable to load file: " << inFile << std::endl;
     errstr << "Reason: " << docInput.ErrorDesc() << std::endl;
     errstr << "Position: Line " << docInput.ErrorRow() << ", Column "
         << docInput.ErrorCol() << std::endl;
     ASSERTL0(loadOkay1, errstr.str());
  
     TiXmlElement *nektar = docInput.FirstChildElement("NEKTAR");
     TiXmlElement *points = nektar->FirstChildElement("POINTS");
     int dim;
     int err = points->QueryIntAttribute("DIM", &dim);
  
     ASSERTL0(err == TIXML_SUCCESS, "Unable to read attribute DIM.");
  
     std::string fields = points->Attribute("FIELDS");
  
     vector<string> fieldNames;
     if (!fields.empty())
     {
         bool valid =
             ParseUtils::GenerateVector(fields, fieldNames);
         ASSERTL0(
             valid,
             "Unable to process list of field variable in  FIELDS attribute:  " +
                 fields);
     }
  
     map<PtsInfo,int>  ptsInfo = NullPtsInfoMap;
  
     const char *ptinfo = points->Attribute("PTSINFO");
     if(ptinfo&&boost::iequals(ptinfo,"EquiSpaced"))
     {
         ptsInfo[eIsEquiSpacedData] = 1;
     }
  
     int np;
     err = points->QueryIntAttribute("PTSPERELMTEDGE",&np);
     if(err == TIXML_SUCCESS)
     {
         ptsInfo[ePtsPerElmtEdge] = np; 
     }
  
     size_t nfields = fieldNames.size();
     size_t totvars = dim + nfields;
  
     TiXmlNode *pointsBody = points->FirstChild();
  
     std::istringstream pointsDataStrm(pointsBody->ToText()->Value());
  
     vector<NekDouble> ptsSerial;
     Array<OneD, Array<OneD, NekDouble> > pts(totvars);
  
     try
     {
         NekDouble ptsStream;
         while (!pointsDataStrm.fail())
         {
             pointsDataStrm >> ptsStream;
  
             ptsSerial.push_back(ptsStream);
         }
     }
     catch (...)
     {
         NEKERROR(ErrorUtil::efatal, "Unable to read Points data.");
     }
  
     size_t npts = ptsSerial.size() / totvars;
  
     for (size_t i = 0; i < totvars; ++i)
     {
         pts[i] = Array<OneD, NekDouble>(npts);
     }
  
     for (size_t i = 0; i < npts; ++i)
     {
         for (size_t j = 0; j < totvars; ++j)
         {
             pts[j][i] = ptsSerial[i * totvars + j];
         }
     }
  
     ptsField = MemoryManager<PtsField>::AllocateSharedPtr(dim, fieldNames, pts, ptsInfo);
 }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::ErrorUtil::efatal, Nektar::LibUtilities::eIsEquiSpacedData, Nektar::LibUtilities::ePtsPerElmtEdge, Nektar::ParseUtils::GenerateVector(), NEKERROR, and Nektar::LibUtilities::NullPtsInfoMap.

Referenced by ImportFieldData().

◆ Write()

void Nektar::LibUtilities::PtsIO::Write	(	const std::string &	outFile,
		const PtsFieldSharedPtr &	ptsField,
		const bool	backup = `false`
	)

Save a pts field to a file.

Parameters

outFile	filename of the file
ptsField	the pts field

Definition at line 138 of file PtsIO.cpp.

 {
     size_t nTotvars = ptsField->GetNFields() + ptsField->GetDim();
     size_t np       = ptsField->GetNpoints();
  
     std::string filename = SetUpOutput(outFile, true, backup);
     SetUpFieldMetaData(outFile);
  
     // until tinyxml gains support for line break, write the xml manually
     std::ofstream ptsFile;
     ptsFile.open(filename.c_str());
  
     ptsFile << "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" << endl;
     ptsFile << "<NEKTAR>" << endl;
     ptsFile << "  <POINTS ";
     ptsFile << "DIM=\"" << ptsField->GetDim() << "\" ";
     string fn = boost::algorithm::join(ptsField->GetFieldNames(), ",");
     ptsFile << "FIELDS=\"" << fn << "\" ";
     ptsFile << ">" << endl;
  
     Array<OneD, Array<OneD, NekDouble> > pts;
     ptsField->GetPts(pts);
     for (size_t i = 0; i < np; ++i)
     {
         ptsFile << "    ";
         ptsFile << pts[0][i];
         for (size_t j = 1; j < nTotvars; ++j)
         {
             ptsFile << " " << pts[j][i];
         }
         ptsFile << endl;
     }
     ptsFile << "  </POINTS>" << endl;
     ptsFile << "</NEKTAR>" << endl;
  
     ptsFile.close();
  
     // this is what the above cpart would read if tinyxml
     // supported line breaks
     /*
     // 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);
  
     TiXmlElement *pointsTag = new TiXmlElement("POINTS");
     root->LinkEndChild(pointsTag);
  
     pointsTag->SetAttribute("DIM", ptsField->GetDim());
  
     string fn = boost::algorithm::join(ptsField->GetFieldNames(), ",");
     pointsTag->SetAttribute("FIELDS", fn);
  
     Array <OneD, Array <OneD, NekDouble > > pts;
     ptsField->GetPts(pts);
     ostringstream os;
     for (int i = 0; i < np; ++i)
     {
         os << pts[0][i];
         for (int j = 1; j < nTotvars; ++j)
         {
             os << " " << pts[j][i];
         }
         os << " ";
     }
  
     pointsTag->LinkEndChild(new TiXmlText(os.str()));
  
     doc.SaveFile(filename);
     */
 }

References SetUpFieldMetaData(), and Nektar::LibUtilities::FieldIO::SetUpOutput().

Referenced by Nektar::FieldUtils::OutputPts::OutputFromPts(), and Nektar::SolverUtils::CouplingFile::v_Send().

Public Member Functions

Protected Member Functions

Additional Inherited Members