Nektar::LibUtilities::CsvIO Class Reference

#include <CsvIO.h>

Inheritance diagram for Nektar::LibUtilities::CsvIO:

Public Member Functions
	CsvIO (LibUtilities::CommSharedPtr pComm, bool sharedFilesystem=false)
	~CsvIO () override
void	Write (const std::string &outFile, const PtsFieldSharedPtr &ptsField, const bool backup=false)
	Save a pts field to a file.
Public Member Functions inherited from Nektar::LibUtilities::PtsIO
	PtsIO (LibUtilities::CommSharedPtr pComm, bool sharedFilesystem=false)
	~PtsIO () override
void	Import (const std::string &inFile, PtsFieldSharedPtr &ptsField, FieldMetaDataMap &fieldmetadatamap=NullFieldMetaDataMap, DomainRangeShPtr &Range=NullDomainRangeShPtr)
	Import a pts field from file.
void	Write (const std::string &outFile, const PtsFieldSharedPtr &ptsField, const bool backup=false)
	Save a pts field to a file.
Public Member Functions inherited from Nektar::LibUtilities::FieldIOXml
	FieldIOXml (LibUtilities::CommSharedPtr pComm, bool sharedFilesystem)
	Default constructor.
	~FieldIOXml () override
void	ImportFieldDefs (DataSourceSharedPtr dataSource, std::vector< FieldDefinitionsSharedPtr > &fielddefs, bool expChild)
	Import field definitions from the target file.
void	ImportFieldData (DataSourceSharedPtr dataSource, const std::vector< FieldDefinitionsSharedPtr > &fielddefs, std::vector< std::vector< NekDouble > > &fielddata)
	Import field data from a target file.
void	WriteMultiFldFileIDs (const std::string &outfile, const std::vector< std::string > fileNames, std::vector< std::vector< unsigned int > > &elementList, const FieldMetaDataMap &fieldinfomap=NullFieldMetaDataMap)
	Write out a file containing element ID to partition mapping.
void	SetUpFieldMetaData (const std::string &outname, const std::vector< FieldDefinitionsSharedPtr > &fielddefs, const FieldMetaDataMap &fieldmetadatamap)
	Set up field meta data map.
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.
Public Member Functions inherited from Nektar::LibUtilities::FieldIO
	FieldIO (LibUtilities::CommSharedPtr pComm, bool sharedFilesystem)
	Constructor for FieldIO base class.
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.
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.
DataSourceSharedPtr	ImportFieldMetaData (const std::string &filename, FieldMetaDataMap &fieldmetadatamap)
	Import the metadata from a field file.
const std::string &	GetClassName () const
std::string	GetFileEnding () const
	Helper function that determines default file extension.

Protected Member Functions
void	v_ImportPtsFieldData (const std::string inFile, PtsFieldSharedPtr &ptsField, DomainRangeShPtr &Range) override
std::string	v_GetFileEnding () const override
Protected Member Functions inherited from Nektar::LibUtilities::PtsIO
std::string	v_GetFileEnding () const override
void	SetUpFieldMetaData (const std::string outname)
Protected Member Functions inherited from Nektar::LibUtilities::FieldIOXml
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.
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.
DataSourceSharedPtr	v_ImportFieldMetaData (const std::string &filename, FieldMetaDataMap &fieldmetadatamap) override
	Import field metadata from filename and return the data source which wraps filename.
const std::string &	v_GetClassName () const override
	Returns the class name.
Protected Member Functions inherited from Nektar::LibUtilities::FieldIO
int	CheckFieldDefinition (const FieldDefinitionsSharedPtr &fielddefs)
	Check field definitions for correctness and return storage size.
std::vector< unsigned int >	GetNumberOfCoeffsPerElement (const FieldDefinitionsSharedPtr &fielddefs)
	Compute number of data points needed to store expansion inside each element.
std::string	SetUpOutput (const std::string outname, bool perRank, bool backup=false)
	Set up the filesystem ready for output.

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.
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.
static std::shared_ptr< FieldIO >	CreateDefault (const LibUtilities::SessionReaderSharedPtr session)
	Returns an object for the default FieldIO method.
static std::shared_ptr< FieldIO >	CreateForFile (const LibUtilities::SessionReaderSharedPtr session, const std::string &filename)
	Construct a FieldIO object for a given input filename.
static void	AddInfoTag (TagWriterSharedPtr root, const FieldMetaDataMap &fieldmetadatamap)
	Add provenance information to the field metadata map.
Static Public Attributes inherited from Nektar::LibUtilities::FieldIOXml
static std::string	className
	Name of class.
Protected Attributes inherited from Nektar::LibUtilities::FieldIO
LibUtilities::CommSharedPtr	m_comm
	Communicator to use when writing parallel format.
bool	m_sharedFilesystem
	Boolean dictating whether we are on a shared filesystem.

Detailed Description

Definition at line 52 of file CsvIO.h.

Constructor & Destructor Documentation

CsvIO()

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

Definition at line 57 of file CsvIO.cpp.

    : PtsIO(pComm, sharedFilesystem)
{
}

~CsvIO()

Nektar::LibUtilities::CsvIO::~CsvIO ( )

inlineoverride

Definition at line 58 of file CsvIO.h.

    {
    }

Member Function Documentation

v_GetFileEnding()

std::string Nektar::LibUtilities::CsvIO::v_GetFileEnding ( ) const

overrideprotectedvirtual

Reimplemented from Nektar::LibUtilities::FieldIO.

Definition at line 278 of file CsvIO.cpp.

{
    return "csv";
}

v_ImportPtsFieldData()

void Nektar::LibUtilities::CsvIO::v_ImportPtsFieldData ( const std::string  inFile, PtsFieldSharedPtr &  ptsField, DomainRangeShPtr &  Range  )

overrideprotectedvirtual

Reimplemented from Nektar::LibUtilities::PtsIO.

Definition at line 111 of file CsvIO.cpp.

{
    std::stringstream errstr;
    errstr << "Unable to load file: " << inFile << std::endl;
    std::ifstream in(inFile.c_str());
    ASSERTL0(in.is_open(), errstr.str());
 
    std::string line;
    std::getline(in, line);
    boost::erase_first(line, "#");
 
    std::vector<std::string> fieldNames;
    bool valid = ParseUtils::GenerateVector(line, fieldNames);
    ASSERTL0(valid, "Unable to process list of fields from line: " + line);
 
    int dim = 0;
    for (auto &it : fieldNames)
    {
        if (it == "x" || it == "y" || it == "z")
        {
            dim++;
        }
    }
 
    ASSERTL0(dim, "Failed to find a paramater labelled \"x\",\"y\" or \"z\"  "
                  "in file" +
                      inFile + ". Is the coordinated labelled something else?");
 
    size_t totvars                    = fieldNames.size();
    std::vector<std::string> dimNames = {"x", "y", "z"};
    Array<OneD, int> loc_coord(dim);
    for (int i = 0; i < dim; ++i)
    {
        auto p = std::find(fieldNames.begin(), fieldNames.end(), dimNames[i]);
        if (p != fieldNames.end())
        {
            auto j = std::distance(fieldNames.begin(), p);
 
            loc_coord[i] = j;
        }
    }
 
    std::vector<NekDouble> ptsSerial;
    typedef boost::tokenizer<boost::escaped_list_separator<char>> Tokenizer;
    Tokenizer tok(line);
    while (getline(in, line))
    {
        tok.assign(line);
 
        ASSERTL0(std::distance(tok.begin(), tok.end()) ==
                     std::iterator_traits<Tokenizer::iterator>::difference_type(
                         totvars),
                 "wrong number of columns in line: " + line);
 
        bool ReadValue = true;
 
        if (Range != NullDomainRangeShPtr)
        {
            int cnt = 0;
            for (auto &it : tok)
            {
                for (int j = 0; j < dim; ++j)
                {
                    if (cnt == loc_coord[j])
                    {
                        NekDouble CoordVal =
                            std::stod(boost::trim_copy(std::string(it)));
                        switch (j)
                        {
                            case 0:
                            {
                                if ((CoordVal < Range->m_xmin) ||
                                    (CoordVal > Range->m_xmax))
                                {
                                    ReadValue = false;
                                }
                            }
                            break;
                            case 1:
                            {
                                if ((CoordVal < Range->m_ymin) ||
                                    (CoordVal > Range->m_ymax))
                                {
                                    ReadValue = false;
                                }
                            }
                            break;
                            case 2:
                            {
                                if ((CoordVal < Range->m_zmin) ||
                                    (CoordVal > Range->m_zmax))
                                {
                                    ReadValue = false;
                                }
                            }
                        }
                    }
                }
                cnt++;
            }
        }
        if (ReadValue)
        {
            for (auto &it : tok)
            {
                try
                {
                    ptsSerial.push_back(
                        std::stod(boost::trim_copy(std::string(it))));
                }
                catch (...)
                {
                    NEKERROR(ErrorUtil::efatal,
                             "could not convert line: " + line);
                }
            }
        }
    }
 
    size_t npts = ptsSerial.size() / totvars;
 
    Array<OneD, Array<OneD, NekDouble>> pts(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];
        }
    }
 
    // reorder pts to make x,y,z the first columns
    for (int i = 0; i < dim; ++i)
    {
        auto p = std::find(fieldNames.begin(), fieldNames.end(), dimNames[i]);
        if (p != fieldNames.end())
        {
            auto j = std::distance(fieldNames.begin(), p);
 
            if (i == j)
            {
                continue;
            }
 
            Array<OneD, NekDouble> tmp = pts[i];
            pts[i]                     = pts[j];
            pts[j]                     = tmp;
 
            std::string tmp2 = fieldNames[i];
            fieldNames[i]    = fieldNames[j];
            fieldNames[j]    = tmp2;
        }
    }
    fieldNames.erase(fieldNames.begin(), fieldNames.begin() + dim);
 
    ptsField = MemoryManager<PtsField>::AllocateSharedPtr(dim, fieldNames, pts);
}

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

Write()

void Nektar::LibUtilities::CsvIO::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 68 of file CsvIO.cpp.

{
    size_t nTotvars = ptsField->GetNFields() + ptsField->GetDim();
    size_t np       = ptsField->GetNpoints();
 
    std::string filename = SetUpOutput(outFile, true, backup);
    SetUpFieldMetaData(outFile);
 
    std::ofstream ptsFile;
    ptsFile.open(filename.c_str());
 
    std::vector<std::string> xyz;
    xyz.push_back("x");
    xyz.push_back("y");
    xyz.push_back("z");
    xyz.resize(ptsField->GetDim());
 
    std::string fn = boost::algorithm::join(xyz, ",");
    ptsFile << "# " << fn << ",";
    fn = boost::algorithm::join(ptsField->GetFieldNames(), ",");
    ptsFile << fn;
    ptsFile << std::endl;
 
    Array<OneD, Array<OneD, NekDouble>> pts;
    ptsField->GetPts(pts);
    for (size_t i = 0; i < np; ++i)
    {
        ptsFile << pts[0][i];
        for (size_t j = 1; j < nTotvars; ++j)
        {
            ptsFile << "," << pts[j][i];
        }
        ptsFile << std::endl;
    }
 
    ptsFile.close();
}

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

Referenced by Nektar::SolverUtils::CouplingCwipi::DumpRawFields(), and Nektar::FieldUtils::OutputPts::v_OutputFromPts().