Nektar::LibUtilities::PtsIO Class Reference

#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...
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...
const std::string &	GetClassName () const
std::string	GetFileEnding () const
	Helper function that determines default file extension. More...

Protected Member Functions
virtual void	v_ImportFieldData (const std::string inFile, PtsFieldSharedPtr &ptsField, DomainRangeShPtr &Range=NullDomainRangeShPtr)
virtual std::string	v_GetFileEnding () const override
void	SetUpFieldMetaData (const std::string outname)
Protected Member Functions inherited from Nektar::LibUtilities::FieldIOXml
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) override
	Write an XML file to outFile given the field definitions fielddefs, field data fielddata and metadata fieldmetadatamap. 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) override
	Import an XML format file. More...
virtual DataSourceSharedPtr	v_ImportFieldMetaData (const std::string &filename, FieldMetaDataMap &fieldmetadatamap) override
	Import field metadata from filename and return the data source which wraps filename. More...
virtual const std::string &	v_GetClassName () const override
	Returns the class name. 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...
virtual void	v_Write (const std::string &outFile, std::vector< FieldDefinitionsSharedPtr > &fielddefs, std::vector< std::vector< NekDouble > > &fielddata, const FieldMetaDataMap &fieldinfomap, const bool backup=false)=0
	Write out the field information to the file outFile. More...
virtual 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)=0
	Read field information from the file infilename. More...
virtual DataSourceSharedPtr	v_ImportFieldMetaData (const std::string &filename, FieldMetaDataMap &fieldmetadatamap)=0
	Import the metadata from a field file. More...
virtual std::string	v_GetFileEnding () const
virtual const std::string &	v_GetClassName () const =0
bool	ParallelInTime ()
	Check if solver use Parallel-in-Time. 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 61 of file PtsIO.h.

Constructor & Destructor Documentation

PtsIO()

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

Definition at line 57 of file PtsIO.cpp.

    : FieldIOXml(pComm, sharedFilesystem)
{
}

~PtsIO()

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

inlinevirtual

Definition at line 67 of file PtsIO.h.

    {
    }

Member Function Documentation

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 68 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->GetSpaceComm()->GetSize())
        {
            // only load the file that matches this rank
            filenames.clear();
            boost::format pad("P%1$07d.%2$s");
            pad % m_comm->GetSpaceComm()->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, Nektar::LibUtilities::FieldIO::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(), and Nektar::FieldUtils::ProcessPointDataToFld::v_Process().

ImportFieldData()

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

Definition at line 208 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 306 of file PtsIO.cpp.

{
    ASSERTL0(!outname.empty(), "Empty path given to SetUpFieldMetaData()");
 
    int nprocs = m_comm->GetSpaceComm()->GetSize();
    int rank   = m_comm->GetSpaceComm()->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, Nektar::LibUtilities::FieldIO::GetFileEnding(), Nektar::LibUtilities::FieldIO::m_comm, Nektar::LibUtilities::PortablePath(), and Nektar::LibUtilities::FieldIOXml::WriteMultiFldFileIDs().

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

v_GetFileEnding()

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

inlineoverrideprotectedvirtual

Reimplemented from Nektar::LibUtilities::FieldIO.

Reimplemented in Nektar::LibUtilities::CsvIO.

Definition at line 89 of file PtsIO.h.

    {
        return "pts";
    };

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 214 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 132 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::v_OutputFromPts(), and Nektar::SolverUtils::CouplingFile::v_Send().