Nektar::LibUtilities::FieldIO Class Reference

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

#include <FieldIO.h>

Inheritance diagram for Nektar::LibUtilities::FieldIO:

Collaboration 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...
virtual const std::string &	GetClassName () const =0

Static Public Member Functions
static const std::string	GetFileType (const std::string &filename, CommSharedPtr comm)
	Determine file type of given input file. More...
static boost::shared_ptr< FieldIO >	CreateDefault (const LibUtilities::SessionReaderSharedPtr session)
	Returns an object for the default FieldIO method. More...
static boost::shared_ptr< FieldIO >	CreateForFile (const LibUtilities::SessionReaderSharedPtr session, const std::string &filename)
	Construct a FieldIO object for a given input filename. More...

Protected Member Functions
void	AddInfoTag (TagWriterSharedPtr root, const FieldMetaDataMap &fieldmetadatamap)
	Add provenance information to the field metadata map. More...
int	CheckFieldDefinition (const FieldDefinitionsSharedPtr &fielddefs)
	Check field definitions for correctness and return storage size. More...
virtual std::string	GetFileEnding () const
	Helper function that determines default file extension. 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...

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 224 of file FieldIO.h.

Constructor & Destructor Documentation

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

Constructor for FieldIO base class.

Definition at line 313 of file FieldIO.cpp.

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

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

inlinevirtual

Definition at line 230 of file FieldIO.h.

    {
    }

Member Function Documentation

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

protected

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 334 of file FieldIO.cpp.

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(), and Nektar::LibUtilities::FieldIOXml::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;
    }

    TagWriterSharedPtr infoTag = root->AddChild("Metadata");

    FieldMetaDataMap::const_iterator infoit;

    TagWriterSharedPtr provTag = infoTag->AddChild("Provenance");
    for (infoit = ProvenanceMap.begin(); infoit != ProvenanceMap.end();
         ++infoit)
    {
        provTag->SetAttr(infoit->first, infoit->second);
    }

    //---------------------------------------------
    // write field info section
    if (fieldmetadatamap != NullFieldMetaDataMap)
    {
        for (infoit = fieldmetadatamap.begin();
             infoit != fieldmetadatamap.end();
             ++infoit)
        {
            infoTag->SetAttr(infoit->first, infoit->second);
        }
    }
}

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 545 of file FieldIO.cpp.

References ASSERTL0, Nektar::LibUtilities::eHexahedron, Nektar::LibUtilities::ePrism, Nektar::LibUtilities::ePyramid, Nektar::LibUtilities::eQuadrilateral, Nektar::LibUtilities::eSegment, Nektar::LibUtilities::eTetrahedron, Nektar::LibUtilities::eTriangle, Nektar::LibUtilities::StdTriData::getNumberOfCoefficients(), Nektar::LibUtilities::StdTetData::getNumberOfCoefficients(), Nektar::LibUtilities::StdPyrData::getNumberOfCoefficients(), and Nektar::LibUtilities::StdPrismData::getNumberOfCoefficients().

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

{
    int i;

    if (fielddefs->m_elementIDs.size() == 0) // empty partition
    {
        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:
            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_homogeneousZIDs.size();
                    cnt++;
                }
                else if (fielddefs->m_numHomogeneousDir == 2)
                {
                    datasize += l * fielddefs->m_homogeneousYIDs.size();
                    cnt += 2;
                }
                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_homogeneousZIDs.size();
                        cnt++;
                    }
                    else if (fielddefs->m_numHomogeneousDir == 2)
                    {
                        datasize += l * fielddefs->m_homogeneousYIDs.size();
                        cnt += 2;
                    }
                    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;
}

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 181 of file FieldIO.cpp.

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

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

{
    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());
}

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 212 of file FieldIO.cpp.

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

Referenced by Nektar::SolverUtils::UnsteadySystem::CheckForRestartTime(), Nektar::SolverUtils::Forcing::EvaluateFunction(), Nektar::GlobalMapping::Mapping::EvaluateFunction(), Nektar::SolverUtils::EquationSystem::EvaluateFunctionFld(), Nektar::SolverUtils::EquationSystem::ImportFld(), Nektar::LinearisedAdvection::ImportFldBase(), Nektar::SolverUtils::EquationSystem::ImportFldBase(), Nektar::SpatialDomains::MeshGraph::ReadExpansions(), and Nektar::SolverUtils::FilterFieldConvert::v_Initialise().

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

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

pure virtual

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

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

inlineprotectedvirtual

Helper function that determines default file extension.

Reimplemented in Nektar::LibUtilities::PtsIO.

Definition at line 279 of file FieldIO.h.

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

    {
        return "fld";
    }

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 101 of file FieldIO.cpp.

References ASSERTL0, Nektar::LibUtilities::eHDF5, Nektar::LibUtilities::eXML, and Nektar::LibUtilities::PortablePath().

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

{
    FieldIOType ioType = eXML;
    int size = comm->GetSize();
    int rank = comm->GetRank();

    if (size == 1 || rank == 0)
    {
        std::string datafilename;

        // If input is a directory, check for root processor file.
        if (fs::is_directory(filename))
        {
            fs::path p0file("P0000000.fld");
            fs::path fullpath = filename / p0file;
            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(), ios_base::binary);
        ASSERTL0(datafile.good(), "Unable to open file: " + filename);

        ioType = eHDF5;
        for (unsigned i = 0; i < 8 && datafile.good(); ++i)
        {
            unsigned char byte = datafile.get();
            if (byte != magic[i])
            {
                ioType = eXML;
                break;
            }
        }
    }

    if (size > 1)
    {
        int code = (int)ioType;
        comm->Bcast(code, 0);
        ioType = (FieldIOType)code;
    }

    std::string iofmt;
    if (ioType == eXML)
    {
        iofmt = "Xml";
    }
    else if (ioType == eHDF5)
    {
        iofmt = "Hdf5";
    }
    else
    {
        // Error
        ASSERTL0(false, "Unknown file format");
    }

    return iofmt;
}

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 342 of file FieldIO.h.

References v_Import().

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

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 358 of file FieldIO.h.

References v_ImportFieldMetaData().

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

{
    return v_ImportFieldMetaData(filename, fieldmetadatamap);
}

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 400 of file FieldIO.cpp.

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

Referenced by Nektar::LibUtilities::FieldIOHdf5::v_Write(), Nektar::LibUtilities::FieldIOXml::v_Write(), and Nektar::LibUtilities::PtsIO::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), fulloutname;

    // in case we are rank 0 or not on a shared filesystem, check if the specPath already exists
    if (backup && (rank == 0 || !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 += specPath.stem();
            bakPath += fs::path(".bak" + boost::lexical_cast<std::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().value() == berrc::no_such_file_or_directory,
                        "Filesystem error: " + string(e.what()));
        }
    }
    // wait until rank 0 has backed up the old specPath
    if (backup)
    {
        m_comm->Block();
    }

    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();
    }

    if (rank == 0)
    {
        cout << "Writing: " << specPath;
    }

    // serial processing just add ending.
    if (nprocs == 1)
    {
        return LibUtilities::PortablePath(specPath);
    }

    // Create the destination directory
    if (perRank)
    {
        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();

        // Sit in a loop and make sure target directory has been created
        int created = 0;
        while (!created)
        {
            created = fs::is_directory(specPath);
            m_comm->AllReduce(created, ReduceMin);
        }
    }
    else
    {
        fulloutname = specPath;
    }

    // Return the full path to the partition for this process
    return LibUtilities::PortablePath(fulloutname);
}

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().

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().

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::FieldIOXml, and Nektar::LibUtilities::FieldIOHdf5.

Referenced by 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 320 of file FieldIO.h.

References v_Write().

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

Member Data Documentation

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

protected

Communicator to use when writing parallel format.

Definition at line 265 of file FieldIO.h.

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

bool Nektar::LibUtilities::FieldIO::m_sharedFilesystem

protected

Boolean dictating whether we are on a shared filesystem.

Definition at line 267 of file FieldIO.h.

Referenced by SetUpOutput().