Nektar::LibUtilities::FieldIO Class Reference

Class for operating on Nektar++ input/output files. More...

#include <FieldIO.h>

Inheritance diagram for Nektar::LibUtilities::FieldIO:

Public Member Functions
	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...

Static Public Member Functions
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...

Protected Member Functions
int	CheckFieldDefinition (const FieldDefinitionsSharedPtr &fielddefs)
	Check field definitions for correctness and return storage size. More...
std::vector< unsigned int >	GetNumberOfCoeffsPerElement (const FieldDefinitionsSharedPtr &fielddefs)
	Compute number of data points needed to store expansion inside each element. 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

Protected Attributes
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

Class for operating on Nektar++ input/output files.

Nektar++ input/output of field data can be described as follows:

• The FieldDefinitions class defines the metadata that is associated with one or more scalar field variables, and determines the storage length.
• Each scalar field is stored in a single contiguous vector which is written/read by the functions defined in this class.
• Optional metadata can be read/written in a simple key/value pair map FieldMetaDataMap. This can be used to define, e.g. the timestep of the simulation.

This base class represents the minimum functionality that subclasses need to implement in order to implement the above functionality. Each subclass is free to determine its own file structure and parallel behaviour.

Definition at line 226 of file FieldIO.h.

Constructor & Destructor Documentation

FieldIO()

Nektar::LibUtilities::FieldIO::FieldIO	(	LibUtilities::CommSharedPtr	pComm,
		bool	sharedFilesystem
	)

Constructor for FieldIO base class.

Definition at line 321 of file FieldIO.cpp.

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

~FieldIO()

virtual Nektar::LibUtilities::FieldIO::~FieldIO ( )

inlinevirtual

Definition at line 232 of file FieldIO.h.

    {
    }

Member Function Documentation

AddInfoTag()

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

static

Add provenance information to the field metadata map.

This routine adds some basic provenance information to the field metadata to enable better tracking of version information:

• Nektar++ version
• Date and time of simulation
• Hostname of the machine the simulation was performed on
• git SHA1 and branch name, if Nektar++ was compiled from git and not e.g. a tarball.

Parameters

root	Root tag, which is encapsulated using the TagWriter structure to enable multi-file format support.
fieldmetadatamap	Any existing field metadata.

Definition at line 342 of file FieldIO.cpp.

{
    FieldMetaDataMap ProvenanceMap;
 
    // Nektar++ release version from VERSION file
    ProvenanceMap["NektarVersion"] = std::string(NEKTAR_VERSION);
 
    // Date/time stamp
    auto now    = std::chrono::system_clock::now();
    auto now_t  = std::chrono::system_clock::to_time_t(now);
    auto now_tm = *std::localtime(&now_t);
    char buffer[128];
    strftime(buffer, sizeof(buffer), "%d-%b-%Y %H:%M:%S", &now_tm);
    ProvenanceMap["Timestamp"] = buffer;
 
    // 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;
    }
 
    TagWriterSharedPtr infoTag = root->AddChild("Metadata");
 
    TagWriterSharedPtr provTag = infoTag->AddChild("Provenance");
    for (auto &infoit : ProvenanceMap)
    {
        provTag->SetAttr(infoit.first, infoit.second);
    }
 
    //---------------------------------------------
    // write field info section
    if (fieldmetadatamap != NullFieldMetaDataMap)
    {
        for (auto &infoit : fieldmetadatamap)
        {
            infoTag->SetAttr(infoit.first, infoit.second);
        }
    }
}

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

Referenced by Nektar::LibUtilities::FieldIOHdf5::v_Write(), Nektar::LibUtilities::FieldIOXml::v_Write(), Nektar::SpatialDomains::MeshGraphIOXml::v_WriteGeometry(), and Nektar::LibUtilities::FieldIOXml::WriteMultiFldFileIDs().

CheckFieldDefinition()

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

protected

Check field definitions for correctness and return storage size.

Parameters

fielddefs

Field definitions to check.

Definition at line 690 of file FieldIO.cpp.

{
    // Return 0 if this is an empty parition
    if (fielddefs->m_elementIDs.size() == 0)
    {
        return 0;
    }
 
    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:
            NEKERROR(ErrorUtil::efatal, "Unsupported shape type.");
            break;
    }
 
    ASSERTL0(fielddefs->m_basis.size() == numbasis,
             "Length of basis vector is incorrect");
 
    if (fielddefs->m_uniOrder == true)
    {
        // Counter is updated by "GetNumberOfDataPoints()"
        unsigned int cnt = 0;
 
        const int datasize = GetNumberOfDataPoints(fielddefs, cnt);
 
        return datasize * fielddefs->m_elementIDs.size();
    }
    else
    {
        // Counter is updated by "GetNumberOfDataPoints()"
        unsigned int cnt = 0;
 
        int datasize = 0;
 
        for (int i = 0; i < fielddefs->m_elementIDs.size(); ++i)
        {
            datasize += GetNumberOfDataPoints(fielddefs, cnt);
        }
 
        return datasize;
    }
}

References ASSERTL0, Nektar::ErrorUtil::efatal, Nektar::LibUtilities::eHexahedron, Nektar::LibUtilities::ePrism, Nektar::LibUtilities::ePyramid, Nektar::LibUtilities::eQuadrilateral, Nektar::LibUtilities::eSegment, Nektar::LibUtilities::eTetrahedron, Nektar::LibUtilities::eTriangle, Nektar::LibUtilities::GetNumberOfDataPoints(), and NEKERROR.

Referenced by Nektar::LibUtilities::FieldIOXml::ImportFieldData(), Nektar::LibUtilities::FieldIOHdf5::v_Import(), Nektar::LibUtilities::FieldIOHdf5::v_Write(), and Nektar::LibUtilities::FieldIOXml::v_Write().

CreateDefault()

FieldIOSharedPtr Nektar::LibUtilities::FieldIO::CreateDefault ( const LibUtilities::SessionReaderSharedPtr  session )

static

Returns an object for the default FieldIO method.

This function returns a FieldIO class as determined by the hard-coded default (XML), which can be overridden by changing the session reader SOLVERINFO variable FieldIOFormat.

Parameters

session

Session reader

Returns

FieldIO object

Definition at line 195 of file FieldIO.cpp.

{
    std::string iofmt("Xml");
    if (session->DefinesSolverInfo("IOFormat"))
    {
        iofmt = session->GetSolverInfo("IOFormat");
    }
 
    if (session->DefinesCmdLineArgument("io-format"))
    {
        iofmt = session->GetCmdLineArgument<std::string>("io-format");
    }
 
    return GetFieldIOFactory().CreateInstance(iofmt, session->GetComm(),
                                              session->GetSharedFilesystem());
}

References Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), and Nektar::LibUtilities::GetFieldIOFactory().

Referenced by Diffusion::Diffusion(), Nektar::VortexWaveInteraction::FileRelaxation(), Nektar::FilterBenchmark::FilterBenchmark(), Nektar::SolverUtils::FilterCheckpoint::FilterCheckpoint(), Nektar::FilterCheckpointCellModel::FilterCheckpointCellModel(), Nektar::FilterHilbertFFTPhase::FilterHilbertFFTPhase(), Nektar::SolverUtils::FilterModalEnergy::FilterModalEnergy(), Nektar::FilterOffsetPhase::FilterOffsetPhase(), Nektar::SolverUtils::FilterThresholdMax::FilterThresholdMax(), Nektar::SolverUtils::FilterThresholdMin::FilterThresholdMin(), Nektar::GlobalMapping::Mapping::Mapping(), and Nektar::SolverUtils::EquationSystem::v_InitObject().

CreateForFile()

FieldIOSharedPtr Nektar::LibUtilities::FieldIO::CreateForFile ( const LibUtilities::SessionReaderSharedPtr  session, const std::string &  filename  )

static

Construct a FieldIO object for a given input filename.

This is a convenience function that takes an input filename and constructs the appropriate FieldIO subclass, using FieldIO::GetFileType.

Parameters

session	Session reader
filename	Input filename

Returns

FieldIO class reader for filename.

Definition at line 224 of file FieldIO.cpp.

{
    const std::string iofmt =
        FieldIO::GetFileType(filename, session->GetComm());
    return GetFieldIOFactory().CreateInstance(iofmt, session->GetComm(),
                                              session->GetSharedFilesystem());
}

References Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::LibUtilities::GetFieldIOFactory(), and GetFileType().

Referenced by Nektar::SolverUtils::UnsteadySystem::CheckForRestartTime(), Nektar::SolverUtils::SessionFunction::EvaluateFld(), Nektar::GlobalMapping::Mapping::EvaluateFunction(), Nektar::SolverUtils::EquationSystem::ImportFld(), Nektar::LinearisedAdvection::ImportFldBase(), Nektar::SolverUtils::FileFieldInterpolator::ImportFldBase(), Nektar::CellModel::LoadCellModel(), Nektar::SpatialDomains::MeshGraph::ReadExpansionInfo(), Nektar::SmoothedProfileMethod::ReadPhi(), Nektar::SolverUtils::ForcingMovingReferenceFrame::SetInitialConditions(), Nektar::SolverUtils::FilterBodyFittedVelocity::v_Initialise(), and Nektar::SolverUtils::FilterFieldConvert::v_Initialise().

GetClassName()

const std::string & Nektar::LibUtilities::FieldIO::GetClassName ( ) const

inline

Definition at line 257 of file FieldIO.h.

    {
        return v_GetClassName();
    }

References v_GetClassName().

GetFileEnding()

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

inline

Helper function that determines default file extension.

Definition at line 273 of file FieldIO.h.

    {
        return v_GetFileEnding();
    };

References v_GetFileEnding().

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

GetFileType()

const std::string Nektar::LibUtilities::FieldIO::GetFileType ( const std::string &  filename, CommSharedPtr  comm  )

static

Determine file type of given input file.

This method attempts to identify the file type of a given input file filename. It returns a string corresponding to GetFieldIOFactory() or throws an assertion if it cannot be identified.

Parameters

filename	Input filename
comm	Communicator for parallel runs

Returns

FieldIO format of filename.

Definition at line 95 of file FieldIO.cpp.

{
    FieldIOType ioType = eXML;
    int size           = comm->GetSpaceComm()->GetSize();
    bool root          = comm->GetSpaceComm()->TreatAsRankZero();
 
    if (size == 1 || root)
    {
        std::string datafilename;
 
        // If input is a directory, check for root processor file.
        if (fs::is_directory(filename))
        {
            fs::path fullpath = filename;
            fs::path d        = fullpath;
            std::regex expr("P\\d{7}.fld");
            std::smatch what;
 
            bool found = false;
            for (auto &f : fs::directory_iterator(d))
            {
                std::string filename = f.path().filename().string();
                if (std::regex_match(filename, what, expr))
                {
                    found    = true;
                    fullpath = f.path();
                    break;
                }
            }
 
            ASSERTL0(found, std::string("Failed to open a PXXXXXXX.fld file "
                                        "in directory: " +
                                        filename)
                                .c_str());
 
            datafilename = PortablePath(fullpath);
        }
        else
        {
            datafilename = filename;
        }
 
        // Read first 8 bytes. If they correspond with magic bytes below it's an
        // HDF5 file. XML is potentially a nightmare with all the different
        // encodings so we'll just assume it's OK if it's not HDF.
        const unsigned char magic[8] = {0x89, 0x48, 0x44, 0x46,
                                        0x0d, 0x0a, 0x1a, 0x0a};
 
        std::ifstream datafile(datafilename.c_str(), std::ios_base::binary);
        ASSERTL0(datafile.good(), "Unable to open file: " + filename);
 
        ioType = eHDF5;
        for (unsigned i = 0; i < 8 && datafile.good(); ++i)
        {
            int byte = datafile.get();
            if (byte != magic[i])
            {
                ioType = eXML;
                break;
            }
        }
    }
 
    if (size > 1)
    {
        int code = (int)ioType;
        comm->GetSpaceComm()->Bcast(code, 0);
        ioType = (FieldIOType)code;
    }
 
    std::string iofmt;
    if (ioType == eXML)
    {
        iofmt = "Xml";
    }
    else if (ioType == eHDF5)
    {
        iofmt = "Hdf5";
    }
    else
    {
        // Error
        NEKERROR(ErrorUtil::efatal, "Unknown file format");
    }
 
    return iofmt;
}

References ASSERTL0, Nektar::UnitTests::d(), Nektar::ErrorUtil::efatal, Nektar::LibUtilities::eHDF5, Nektar::LibUtilities::eXML, NEKERROR, and Nektar::LibUtilities::PortablePath().

Referenced by CreateForFile(), Nektar::MultiRegions::ExpList::ExtractCoeffsFromFile(), Nektar::FieldUtils::Field::FieldIOForFile(), Nektar::LibUtilities::Import(), and Nektar::SpatialDomains::MeshPartition::ReadExpansions().

GetNumberOfCoeffsPerElement()

std::vector< unsigned int > Nektar::LibUtilities::FieldIO::GetNumberOfCoeffsPerElement ( const FieldDefinitionsSharedPtr &  fielddefs )

protected

Compute number of data points needed to store expansion inside each element.

Parameters

fielddefs

Field definitions.

Definition at line 767 of file FieldIO.cpp.

{
    // Allocate vector with results
    std::vector<unsigned int> coeffsPerElmt;
 
    // Return empty vector if partition is empty
    if (fielddefs->m_elementIDs.size() == 0)
    {
        return coeffsPerElmt;
    }
 
    // Add elements to vector
    coeffsPerElmt.resize(fielddefs->m_elementIDs.size());
 
    if (fielddefs->m_uniOrder == true)
    {
        // Counter is updated by "GetNumberOfDataPoints"
        unsigned int cnt = 0;
 
        const int datasize = GetNumberOfDataPoints(fielddefs, cnt);
 
        for (int i = 0; i < fielddefs->m_elementIDs.size(); ++i)
        {
            coeffsPerElmt[i] = datasize;
        }
    }
    else
    {
        // Counter is updated by "GetNumberOfDataPoints"
        unsigned int cnt = 0;
 
        for (int i = 0; i < fielddefs->m_elementIDs.size(); ++i)
        {
            coeffsPerElmt[i] = GetNumberOfDataPoints(fielddefs, cnt);
        }
    }
 
    return coeffsPerElmt;
}

References Nektar::LibUtilities::GetNumberOfDataPoints().

Referenced by Nektar::LibUtilities::FieldIOHdf5::v_Import().

Import()

void Nektar::LibUtilities::FieldIO::Import ( const std::string &  infilename, std::vector< FieldDefinitionsSharedPtr > &  fielddefs, std::vector< std::vector< NekDouble > > &  fielddata = NullVectorNekDoubleVector, FieldMetaDataMap &  fieldinfo = NullFieldMetaDataMap, const Array< OneD, int > &  ElementIDs = NullInt1DArray  )

inline

Read field information from the file infilename.

Parameters

infilename	Input filename (or directory if parallel format)
fielddefs	On return contains field definitions as read from the input.
fielddata	On return, contains binary field data that stores the input corresponding to fielddefs.
fieldinfo	On returnm, contains the associated field metadata map.
ElementIDs	Element IDs that lie on this processor, which can be optionally supplied to avoid reading the entire file on each processor.

Definition at line 355 of file FieldIO.h.

{
    v_Import(infilename, fielddefs, fielddata, fieldinfo, ElementIDs);
}

References v_Import().

ImportFieldMetaData()

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

inline

Import the metadata from a field file.

Parameters

filename	Input filename.
fieldmetadatamap	On return contains the field metadata map from filename.

Definition at line 371 of file FieldIO.h.

{
    return v_ImportFieldMetaData(filename, fieldmetadatamap);
}

References v_ImportFieldMetaData().

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

SetUpOutput()

std::string Nektar::LibUtilities::FieldIO::SetUpOutput ( const std::string  outname, bool  perRank, bool  backup = false  )

protected

Set up the filesystem ready for output.

This function sets up the output given an output filename outname. This will therefore remove any file or directory with the desired output filename and return the absolute path to the output.

If perRank is set, a new directory will be created to contain one file per process rank.

Parameters

outname	Desired output filename.
perRank	True if one file-per-rank output is required.

Returns

Absolute path to resulting file.

Definition at line 404 of file FieldIO.cpp.

{
    ASSERTL0(!outname.empty(), "Empty path given to SetUpOutput()");
 
    // Create a hash from the filename
    std::size_t file_id = std::hash<std::string>{}(outname);
 
    // Find the minimum and maximum hash for each process
    std::size_t file_id_max{file_id};
    std::size_t file_id_min{file_id};
    m_comm->GetSpaceComm()->AllReduce(file_id_max, ReduceMax);
    m_comm->GetSpaceComm()->AllReduce(file_id_min, ReduceMin);
 
    // Check that each process has the same filename (hash)
    ASSERTL0(file_id_min == file_id_max,
             "All processes do not have the same filename.");
 
    int nprocs = m_comm->GetSpaceComm()->GetSize();
    bool root  = m_comm->GetSpaceComm()->TreatAsRankZero();
 
    // Path to output: will be directory if parallel, normal file if
    // serial.
    fs::path specPath(outname), fulloutname;
 
    // in case we are rank 0 or not on a shared filesystem, check if the
    // specPath already exists
    if (backup && (root || !m_sharedFilesystem) && fs::exists(specPath))
    {
        // rename. foo/bar_123.chk -> foo/bar_123.bak0.chk and in case
        // foo/bar_123.bak0.chk already exists, foo/bar_123.chk ->
        // foo/bar_123.bak1.chk
        fs::path bakPath = specPath;
        int cnt          = 0;
        while (fs::exists(bakPath))
        {
            bakPath = specPath.parent_path();
            bakPath += fs::path(bakPath.extension() == ".pit" ? "/" : "");
            bakPath += specPath.stem();
            bakPath += fs::path(".bak" + std::to_string(cnt++));
            bakPath += specPath.extension();
        }
        std::cout << "renaming " << specPath << " -> " << bakPath << std::endl;
        try
        {
            fs::rename(specPath, bakPath);
        }
        catch (fs::filesystem_error &e)
        {
            ASSERTL0(e.code() == std::errc::no_such_file_or_directory,
                     "Filesystem error: " + std::string(e.what()));
        }
    }
 
    // wait until rank 0 has moved the old specPath and the changes
    // have propagated through the filesystem
    if (backup)
    {
        m_comm->GetSpaceComm()->Block();
        int exists = 1;
        while (exists && perRank)
        {
            exists = fs::exists(specPath);
            m_comm->GetSpaceComm()->AllReduce(exists, ReduceMax);
        }
    }
 
    if (nprocs == 1)
    {
        fulloutname = specPath;
    }
    else
    {
        // Guess the filename that might belong to this process.
        boost::format pad("P%1$07d.%2$s");
        pad % m_comm->GetSpaceComm()->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->GetSpaceComm()->RemoveExistingFiles() && !backup)
    {
        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() == std::errc::no_such_file_or_directory,
                         "Filesystem error: " + std::string(e.what()));
            }
        }
 
        m_comm->GetSpaceComm()->Block();
 
        // Now get rank 0 processor to tidy everything else up.
        if (root || !m_sharedFilesystem)
        {
            try
            {
                fs::remove_all(specPath);
            }
            catch (fs::filesystem_error &e)
            {
                ASSERTL0(e.code() == std::errc::no_such_file_or_directory,
                         "Filesystem error: " + std::string(e.what()));
            }
        }
 
        // wait until rank 0 has removed specPath and the changes
        // have propagated through the filesystem
        m_comm->GetSpaceComm()->Block();
        int exists = 1;
        while (exists && perRank)
        {
            exists = fs::exists(specPath);
            m_comm->GetSpaceComm()->AllReduce(exists, ReduceMax);
        }
    }
 
    if (root)
    {
        std::cout << "Writing: \"" + specPath.string() +
                         (m_comm->IsParallelInTime() ? "\"\n" : "\"");
    }
 
    // serial processing just add ending.
    if (nprocs == 1)
    {
        return LibUtilities::PortablePath(specPath);
    }
 
    // Create the destination directory
    if (perRank)
    {
        try
        {
            if (root || !m_sharedFilesystem)
            {
                fs::create_directory(specPath);
            }
        }
        catch (fs::filesystem_error &e)
        {
            NEKERROR(ErrorUtil::efatal,
                     "Filesystem error: " + std::string(e.what()));
        }
 
        m_comm->GetSpaceComm()->Block();
 
        // Sit in a loop and make sure target directory has been created
        int created = 0;
        while (!created)
        {
            created = fs::is_directory(specPath);
            m_comm->GetSpaceComm()->AllReduce(created, ReduceMin);
        }
    }
    else
    {
        fulloutname = specPath;
    }
 
    // Return the full path to the partition for this process
    return LibUtilities::PortablePath(fulloutname);
}

References ASSERTL0, Nektar::ErrorUtil::efatal, CellMLToNektar.pycml::format, GetFileEnding(), m_comm, m_sharedFilesystem, NEKERROR, Nektar::LibUtilities::PortablePath(), Nektar::LibUtilities::ReduceMax, and Nektar::LibUtilities::ReduceMin.

Referenced by Nektar::LibUtilities::FieldIOHdf5::v_Write(), Nektar::LibUtilities::FieldIOXml::v_Write(), Nektar::LibUtilities::CsvIO::Write(), and Nektar::LibUtilities::PtsIO::Write().

v_GetClassName()

virtual const std::string & Nektar::LibUtilities::FieldIO::v_GetClassName ( ) const

protectedpure virtual

Implemented in Nektar::LibUtilities::FieldIOHdf5, and Nektar::LibUtilities::FieldIOXml.

Referenced by GetClassName().

v_GetFileEnding()

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

inlineprotectedvirtual

Reimplemented in Nektar::LibUtilities::CsvIO, and Nektar::LibUtilities::PtsIO.

Definition at line 314 of file FieldIO.h.

    {
        return "fld";
    }

Referenced by GetFileEnding().

v_Import()

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

protectedpure virtual

Read field information from the file infilename.

Parameters

infilename	Input filename (or directory if parallel format)
fielddefs	On return contains field definitions as read from the input.
fielddata	On return, contains binary field data that stores the input corresponding to fielddefs.
fieldinfo	On returnm, contains the associated field metadata map.
ElementIDs	Element IDs that lie on this processor, which can be optionally supplied to avoid reading the entire file on each processor.

Implemented in Nektar::LibUtilities::FieldIOHdf5, and Nektar::LibUtilities::FieldIOXml.

Referenced by Import().

v_ImportFieldMetaData()

virtual DataSourceSharedPtr Nektar::LibUtilities::FieldIO::v_ImportFieldMetaData ( const std::string &  filename, FieldMetaDataMap &  fieldmetadatamap  )

protectedpure virtual

Import the metadata from a field file.

Parameters

filename	Input filename.
fieldmetadatamap	On return contains the field metadata map from filename.

Implemented in Nektar::LibUtilities::FieldIOHdf5, and Nektar::LibUtilities::FieldIOXml.

Referenced by ImportFieldMetaData().

v_Write()

virtual void Nektar::LibUtilities::FieldIO::v_Write ( const std::string &  outFile, std::vector< FieldDefinitionsSharedPtr > &  fielddefs, std::vector< std::vector< NekDouble > > &  fielddata, const FieldMetaDataMap &  fieldinfomap, const bool  backup = false  )

protectedpure virtual

Write out the field information to the file outFile.

Parameters

outFile	Output filename
fielddefs	Field definitions that define the output
fielddata	Binary field data that stores the output corresponding to fielddefs.
fieldinfomap	Associated field metadata map.

Implemented in Nektar::LibUtilities::FieldIOHdf5, and Nektar::LibUtilities::FieldIOXml.

Referenced by Write().

Write()

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

inline

Write out the field information to the file outFile.

Parameters

outFile	Output filename
fielddefs	Field definitions that define the output
fielddata	Binary field data that stores the output corresponding to fielddefs.
fieldinfomap	Associated field metadata map.

Definition at line 333 of file FieldIO.h.

{
    v_Write(outFile, fielddefs, fielddata, fieldinfomap, backup);
}

References v_Write().

Member Data Documentation

m_comm

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

protected

Communicator to use when writing parallel format.

Definition at line 280 of file FieldIO.h.

Referenced by Nektar::LibUtilities::PtsIO::Import(), Nektar::LibUtilities::FieldIOHdf5::ImportFieldDef(), Nektar::LibUtilities::FieldIOXml::SetUpFieldMetaData(), Nektar::LibUtilities::PtsIO::SetUpFieldMetaData(), SetUpOutput(), Nektar::LibUtilities::FieldIOHdf5::v_Import(), Nektar::LibUtilities::FieldIOHdf5::v_Write(), and Nektar::LibUtilities::FieldIOXml::v_Write().

m_sharedFilesystem

bool Nektar::LibUtilities::FieldIO::m_sharedFilesystem

protected

Boolean dictating whether we are on a shared filesystem.

Definition at line 282 of file FieldIO.h.

Referenced by SetUpOutput().