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

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

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

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

◆ ~FieldIO()

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

inlinevirtual

Definition at line 225 of file FieldIO.h.

226 {

227 }

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 345 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(), 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 585 of file FieldIO.cpp.

 {
     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:
             NEKERROR(ErrorUtil::efatal, "Unsupported shape type.");
             break;
     }
  
     size_t 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:
                 NEKERROR(ErrorUtil::efatal, "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:
                     NEKERROR(ErrorUtil::efatal, "Unsupported shape type.");
                     break;
             }
         }
     }
  
     return (int)datasize;
 }

Referenced by Nektar::LibUtilities::FieldIOXml::ImportFieldData(), Nektar::LibUtilities::FieldIOHdf5::ImportFieldData(), 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 198 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 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().

◆ 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 227 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::ForcingMovingReferenceFrame::CheckForRestartTheta(), Nektar::SolverUtils::UnsteadySystem::CheckForRestartTime(), Nektar::SolverUtils::SessionFunction::EvaluateFld(), Nektar::GlobalMapping::Mapping::EvaluateFunction(), ExpList_LoadField(), Nektar::SolverUtils::EquationSystem::ImportFld(), Nektar::LinearisedAdvection::ImportFldBase(), Nektar::SmoothedProfileMethod::ReadPhi(), and Nektar::SolverUtils::FilterFieldConvert::v_Initialise().

◆ GetClassName()

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

pure virtual

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

◆ GetFileEnding()

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

inlineprotectedvirtual

Helper function that determines default file extension.

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

Definition at line 271 of file FieldIO.h.

     {
         return "fld";
     }

Referenced by Nektar::LibUtilities::FieldIOXml::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 97 of file FieldIO.cpp.

 {
     FieldIOType ioType = eXML;
     int size           = comm->GetSize();
     bool root          = comm->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;
             boost::regex expr("P\\d{7}.fld");
             boost::smatch what;
  
             bool found = false;
             for (auto &f : fs::directory_iterator(d))
             {
                 if (boost::regex_match(f.path().filename().string(), 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->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::ErrorUtil::efatal, Nektar::LibUtilities::eHDF5, Nektar::LibUtilities::eXML, NEKERROR, and Nektar::LibUtilities::PortablePath().

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

◆ 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 334 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 350 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 407 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->AllReduce(file_id_max, ReduceMax);
     m_comm->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->GetSize();
     bool root  = m_comm->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 += 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().value() == berrc::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->Block();
         int exists = 1;
         while (exists && perRank)
         {
             exists = fs::exists(specPath);
             m_comm->AllReduce(exists, ReduceMax);
         }
     }
  
     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() && !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().value() == berrc::no_such_file_or_directory,
                          "Filesystem error: " + std::string(e.what()));
             }
         }
  
         m_comm->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().value() == berrc::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->Block();
         int exists = 1;
         while (exists && perRank)
         {
             exists = fs::exists(specPath);
             m_comm->AllReduce(exists, ReduceMax);
         }
     }
  
     if (root)
     {
         std::cout << "Writing: " << specPath;
     }
  
     // 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->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);
 }

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

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

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

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

Referenced by Nektar::LibUtilities::PtsIO::Import(), Nektar::LibUtilities::FieldIOHdf5::ImportFieldData(), 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 263 of file FieldIO.h.

Referenced by SetUpOutput().

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ FieldIO()

◆ ~FieldIO()

Member Function Documentation

◆ AddInfoTag()

◆ CheckFieldDefinition()

◆ CreateDefault()

◆ CreateForFile()

◆ GetClassName()

◆ GetFileEnding()

◆ GetFileType()

◆ Import()

◆ ImportFieldMetaData()

◆ SetUpOutput()

◆ v_Import()

◆ v_ImportFieldMetaData()

◆ v_Write()

◆ Write()

Member Data Documentation

◆ m_comm

◆ m_sharedFilesystem