Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
Classes | Public Member Functions | Static Public Member Functions | Static Public Attributes | Private Member Functions | List of all members
Nektar::LibUtilities::FieldIOHdf5 Class Reference

#include <FieldIOHdf5.h>

Inheritance diagram for Nektar::LibUtilities::FieldIOHdf5:
Inheritance graph
[legend]
Collaboration diagram for Nektar::LibUtilities::FieldIOHdf5:
Collaboration graph
[legend]

Classes

struct  OffsetHelper
 

Public Member Functions

 FieldIOHdf5 (LibUtilities::CommSharedPtr pComm, bool sharedFilesystem)
 Construct the FieldIO object for HDF5 output. More...
 
virtual ~FieldIOHdf5 ()
 
virtual const std::string & GetClassName () const
 Get class name. More...
 
- Public Member Functions inherited from Nektar::LibUtilities::FieldIO
 FieldIO (LibUtilities::CommSharedPtr pComm, bool sharedFilesystem)
 Constructor for FieldIO base class. More...
 
virtual ~FieldIO ()
 
void Write (const std::string &outFile, std::vector< FieldDefinitionsSharedPtr > &fielddefs, std::vector< std::vector< NekDouble > > &fielddata, const FieldMetaDataMap &fieldinfomap=NullFieldMetaDataMap, const bool backup=false)
 Write out the field information to the file outFile. More...
 
void Import (const std::string &infilename, std::vector< FieldDefinitionsSharedPtr > &fielddefs, std::vector< std::vector< NekDouble > > &fielddata=NullVectorNekDoubleVector, FieldMetaDataMap &fieldinfomap=NullFieldMetaDataMap, const Array< OneD, int > &ElementIDs=NullInt1DArray)
 Read field information from the file infilename. More...
 
DataSourceSharedPtr ImportFieldMetaData (const std::string &filename, FieldMetaDataMap &fieldmetadatamap)
 Import the metadata from a field file. More...
 

Static Public Member Functions

static FieldIOSharedPtr create (LibUtilities::CommSharedPtr pComm, bool sharedFilesystem)
 Creates an instance of this class. More...
 
- Static Public Member Functions inherited from Nektar::LibUtilities::FieldIO
static const std::string GetFileType (const std::string &filename, CommSharedPtr comm)
 Determine file type of given input file. More...
 
static boost::shared_ptr< FieldIOCreateDefault (const LibUtilities::SessionReaderSharedPtr session)
 Returns an object for the default FieldIO method. More...
 
static boost::shared_ptr< FieldIOCreateForFile (const LibUtilities::SessionReaderSharedPtr session, const std::string &filename)
 Construct a FieldIO object for a given input filename. More...
 

Static Public Attributes

static const unsigned int FORMAT_VERSION = 1
 Version of the Nektar++ HDF5 format, which is embedded into the main NEKTAR group as an attribute. More...
 
static const unsigned int ELEM_DCMP_IDX = 0
 A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of elements in decomposition (i.e. field definition). More...
 
static const unsigned int VAL_DCMP_IDX = 1
 A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of data points in decomposition (i.e. field definition). More...
 
static const unsigned int ORDER_DCMP_IDX = 2
 A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of elements multiplied by the dimension of the element, giving number of modes when variable polynomial order is defined. More...
 
static const unsigned int HOMY_DCMP_IDX = 3
 A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of the number of y-planes for homogeneous simulations. More...
 
static const unsigned int HOMZ_DCMP_IDX = 4
 A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of the number of z-planes for homogeneous simulations. More...
 
static const unsigned int HOMS_DCMP_IDX = 5
 A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of the number of strips for homogeneous simulations. More...
 
static const unsigned int HASH_DCMP_IDX = 6
 The hash of the field definition information, which defines the name of the attribute containing the field definition itself. More...
 
static const unsigned int MAX_DCMPS = FieldIOHdf5::HASH_DCMP_IDX + 1
 A helper for FieldIOHdf5::v_Write. Describes the maximum number of items in the decomposition per field definition. More...
 
static const unsigned int ELEM_CNT_IDX = 0
 A helper for FieldIOHdf5::v_Write. Describes the position of the number of elements in the cnt array. More...
 
static const unsigned int VAL_CNT_IDX = 1
 A helper for FieldIOHdf5::v_Write. Describes the position of the number of data points in the cnt array. More...
 
static const unsigned int ORDER_CNT_IDX = 2
 A helper for FieldIOHdf5::v_Write. Describes the position of the number of order points in the cnt array. More...
 
static const unsigned int HOMY_CNT_IDX = 3
 A helper for FieldIOHdf5::v_Write. Describes the position of the number of homogeneous y-planes in the cnt array. More...
 
static const unsigned int HOMZ_CNT_IDX = 4
 A helper for FieldIOHdf5::v_Write. Describes the position of the number of homogeneous z-planes in the cnt array. More...
 
static const unsigned int HOMS_CNT_IDX = 5
 A helper for FieldIOHdf5::v_Write. Describes the position of the number of homogeneous strips in the cnt array. More...
 
static const unsigned int MAX_CNTS = FieldIOHdf5::HOMS_CNT_IDX + 1
 A helper for FieldIOHdf5::v_Write. Describes the maximum number of items in the cnt array per field definition. More...
 
static const unsigned int IDS_IDX_IDX = 0
 A helper for FieldIOHdf5::v_Write. Describes the position of the element IDs within the indexing set. More...
 
static const unsigned int DATA_IDX_IDX = 1
 A helper for FieldIOHdf5::v_Write. Describes the position of the data size within the indexing set. More...
 
static const unsigned int ORDER_IDX_IDX = 2
 A helper for FieldIOHdf5::v_Write. Describes the position of the element order within the indexing set. More...
 
static const unsigned int HOMY_IDX_IDX = 3
 A helper for FieldIOHdf5::v_Write. Describes the position of the number of y-planes within the indexing set. More...
 
static const unsigned int HOMZ_IDX_IDX = 4
 A helper for FieldIOHdf5::v_Write. Describes the position of the number of z-planes within the indexing set. More...
 
static const unsigned int HOMS_IDX_IDX = 5
 A helper for FieldIOHdf5::v_Write. Describes the position of the number of homogeneous strips within the indexing set. More...
 
static const unsigned int MAX_IDXS = FieldIOHdf5::HOMS_IDX_IDX + 1
 A helper for FieldIOHdf5::v_Write. Describes the maximum number of items in the indexing set. More...
 
static std::string className
 Name of class. More...
 

Private Member Functions

virtual void v_Write (const std::string &outFile, std::vector< FieldDefinitionsSharedPtr > &fielddefs, std::vector< std::vector< NekDouble > > &fielddata, const FieldMetaDataMap &fieldinfomap=NullFieldMetaDataMap, const bool backup=false)
 Write a HDF5 file to outFile given the field definitions fielddefs, field data fielddata and metadata fieldmetadatamap. 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)
 Import a HDF5 format file. More...
 
virtual DataSourceSharedPtr v_ImportFieldMetaData (const std::string &filename, FieldMetaDataMap &fieldmetadatamap)
 Import field metadata from filename and return the data source which wraps filename. More...
 
void ImportHDF5FieldMetaData (DataSourceSharedPtr dataSource, FieldMetaDataMap &fieldmetadatamap)
 Import field metadata from dataSource. More...
 
void ImportFieldDef (H5::PListSharedPtr readPL, H5::GroupSharedPtr root, std::vector< uint64_t > &decomps, uint64_t decomp, OffsetHelper offset, std::string group, FieldDefinitionsSharedPtr def)
 Import field definitions from a HDF5 document. More...
 
void ImportFieldData (H5::PListSharedPtr readPL, H5::DataSetSharedPtr data_dset, H5::DataSpaceSharedPtr data_fspace, uint64_t data_i, std::vector< uint64_t > &decomps, uint64_t decomp, const FieldDefinitionsSharedPtr fielddef, std::vector< NekDouble > &fielddata)
 Import the field data from the HDF5 document. More...
 

Additional Inherited Members

- Protected Member Functions inherited from Nektar::LibUtilities::FieldIO
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...
 
- Protected Attributes inherited from Nektar::LibUtilities::FieldIO
LibUtilities::CommSharedPtr m_comm
 Communicator to use when writing parallel format. More...
 
bool m_sharedFilesystem
 Boolean dictating whether we are on a shared filesystem. More...
 

Detailed Description

Definition at line 173 of file FieldIOHdf5.h.

Constructor & Destructor Documentation

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

Construct the FieldIO object for HDF5 output.

Parameters
pCommCommunicator object.
sharedFilesystemTrue if this system has a shared filesystem.

Definition at line 145 of file FieldIOHdf5.cpp.

147  : FieldIO(pComm, sharedFilesystem)
148 {
149 }
FieldIO(LibUtilities::CommSharedPtr pComm, bool sharedFilesystem)
Constructor for FieldIO base class.
Definition: FieldIO.cpp:313
virtual Nektar::LibUtilities::FieldIOHdf5::~FieldIOHdf5 ( )
inlinevirtual

Definition at line 218 of file FieldIOHdf5.h.

219  {
220  }

Member Function Documentation

static FieldIOSharedPtr Nektar::LibUtilities::FieldIOHdf5::create ( LibUtilities::CommSharedPtr  pComm,
bool  sharedFilesystem 
)
inlinestatic

Creates an instance of this class.

Definition at line 204 of file FieldIOHdf5.h.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr().

206  {
208  sharedFilesystem);
209  }
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
virtual const std::string& Nektar::LibUtilities::FieldIOHdf5::GetClassName ( ) const
inlinevirtual

Get class name.

Implements Nektar::LibUtilities::FieldIO.

Definition at line 223 of file FieldIOHdf5.h.

References className.

224  {
225  return className;
226  }
static std::string className
Name of class.
Definition: FieldIOHdf5.h:212
void Nektar::LibUtilities::FieldIOHdf5::ImportFieldData ( H5::PListSharedPtr  readPL,
H5::DataSetSharedPtr  data_dset,
H5::DataSpaceSharedPtr  data_fspace,
uint64_t  data_i,
std::vector< uint64_t > &  decomps,
uint64_t  decomp,
const FieldDefinitionsSharedPtr  fielddef,
std::vector< NekDouble > &  fielddata 
)
private

Import the field data from the HDF5 document.

Parameters
readPLReading parameter list.
data_dsetPointer to the DATA dataset.
data_fspacePointer to the DATA data space.
data_iIndex in the DATA dataset to start reading from.
decompsInformation from the DECOMPOSITION dataset.
decompIndex of the decomposition.
fielddefField definitions for this file
fielddataOn return contains resulting field data.

Definition at line 1261 of file FieldIOHdf5.cpp.

References ASSERTL0, Nektar::LibUtilities::FieldIO::CheckFieldDefinition(), Nektar::LibUtilities::FieldIO::m_comm, MAX_DCMPS, and VAL_DCMP_IDX.

Referenced by v_Import().

1270 {
1271  std::stringstream prfx;
1272  prfx << m_comm->GetRank() << ": FieldIOHdf5::ImportFieldData(): ";
1273 
1274  uint64_t nElemVals = decomps[decomp * MAX_DCMPS + VAL_DCMP_IDX];
1275  uint64_t nFieldVals = nElemVals;
1276 
1277  data_fspace->SelectRange(data_i, nFieldVals);
1278  data_dset->Read(fielddata, data_fspace, readPL);
1279 
1280  int datasize = CheckFieldDefinition(fielddef);
1281  ASSERTL0(
1282  fielddata.size() == datasize * fielddef->m_fields.size(),
1283  prfx.str() +
1284  "input data is not the same length as header information.");
1285 }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:198
static const unsigned int MAX_DCMPS
A helper for FieldIOHdf5::v_Write. Describes the maximum number of items in the decomposition per fie...
Definition: FieldIOHdf5.h:185
int CheckFieldDefinition(const FieldDefinitionsSharedPtr &fielddefs)
Check field definitions for correctness and return storage size.
Definition: FieldIO.cpp:561
static const unsigned int VAL_DCMP_IDX
A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of ...
Definition: FieldIOHdf5.h:179
LibUtilities::CommSharedPtr m_comm
Communicator to use when writing parallel format.
Definition: FieldIO.h:265
void Nektar::LibUtilities::FieldIOHdf5::ImportFieldDef ( H5::PListSharedPtr  readPL,
H5::GroupSharedPtr  root,
std::vector< uint64_t > &  decomps,
uint64_t  decomp,
OffsetHelper  offset,
std::string  group,
FieldDefinitionsSharedPtr  def 
)
private

Import field definitions from a HDF5 document.

Parameters
readPLReading parameter list.
rootRoot group containing field definitions.
groupGroup name to process.
defOn output contains field definitions.

Definition at line 1053 of file FieldIOHdf5.cpp.

References ASSERTL0, ASSERTL1, Nektar::ParseUtils::GenerateOrderedStringVector(), Nektar::ParseUtils::GenerateOrderedVector(), Nektar::LibUtilities::FieldIOHdf5::OffsetHelper::homs, HOMS_DCMP_IDX, Nektar::LibUtilities::FieldIOHdf5::OffsetHelper::homy, HOMY_DCMP_IDX, Nektar::LibUtilities::FieldIOHdf5::OffsetHelper::homz, HOMZ_DCMP_IDX, Nektar::LibUtilities::kPointsTypeStr, Nektar::LibUtilities::FieldIO::m_comm, MAX_DCMPS, Nektar::LibUtilities::FieldIOHdf5::OffsetHelper::order, ORDER_DCMP_IDX, Nektar::LibUtilities::ShapeTypeMap, Nektar::LibUtilities::SIZE_BasisType, Nektar::LibUtilities::SIZE_PointsType, and Nektar::LibUtilities::SIZE_ShapeType.

Referenced by v_Import().

1061 {
1062  std::stringstream prfx;
1063  prfx << m_comm->GetRank() << ": FieldIOHdf5::ImportFieldDefsHdf5(): ";
1064 
1065  H5::GroupSharedPtr field = root->OpenGroup(group);
1066  ASSERTL1(field, prfx.str() + "cannot open field group, " + group + '.');
1067 
1068  def->m_uniOrder = false;
1069 
1070  H5::Group::AttrIterator attrIt = field->attr_begin();
1071  H5::Group::AttrIterator attrEnd = field->attr_end();
1072  for (; attrIt != attrEnd; ++attrIt)
1073  {
1074  const std::string &attrName = *attrIt;
1075  if (attrName == "FIELDS")
1076  {
1077  field->GetAttribute(attrName, def->m_fields);
1078  }
1079  else if (attrName == "SHAPE")
1080  {
1081  std::string shapeString;
1082  field->GetAttribute(attrName, shapeString);
1083 
1084  // check to see if homogeneous expansion and if so
1085  // strip down the shapeString definition
1086  size_t loc;
1087  //---> this finds the first location of 'n'!
1088  if (shapeString.find("Strips") != string::npos)
1089  {
1090  def->m_homoStrips = true;
1091  }
1092 
1093  if ((loc = shapeString.find_first_of("-")) != string::npos)
1094  {
1095  if (shapeString.find("Exp1D") != string::npos)
1096  {
1097  def->m_numHomogeneousDir = 1;
1098  }
1099  else // HomogeneousExp1D
1100  {
1101  def->m_numHomogeneousDir = 2;
1102  }
1103 
1104  shapeString.erase(loc, shapeString.length());
1105  }
1106 
1107  // get the geometrical shape
1108  bool valid = false;
1109  for (unsigned int j = 0; j < SIZE_ShapeType; j++)
1110  {
1111  if (ShapeTypeMap[j] == shapeString)
1112  {
1113  def->m_shapeType = (ShapeType)j;
1114  valid = true;
1115  break;
1116  }
1117  }
1118 
1119  ASSERTL0(valid, prfx.str() + std::string(
1120  "unable to correctly parse the shape type: ")
1121  .append(shapeString).c_str());
1122  }
1123  else if (attrName == "BASIS")
1124  {
1125  field->GetAttribute(attrName, def->m_basis);
1126  // check the basis is in range
1127  std::vector<BasisType>::const_iterator bIt = def->m_basis.begin();
1128  std::vector<BasisType>::const_iterator bEnd = def->m_basis.end();
1129  for (; bIt != bEnd; ++bIt)
1130  {
1131  BasisType bt = *bIt;
1132  ASSERTL0(bt >= 0 && bt < SIZE_BasisType,
1133  prfx.str() +
1134  "unable to correctly parse the basis types.");
1135  }
1136  }
1137  else if (attrName == "HOMOGENEOUSLENGTHS")
1138  {
1139  field->GetAttribute(attrName, def->m_homogeneousLengths);
1140  }
1141  else if (attrName == "NUMMODESPERDIR")
1142  {
1143  std::string numModesPerDir;
1144  field->GetAttribute(attrName, numModesPerDir);
1145 
1146  if (strstr(numModesPerDir.c_str(), "UNIORDER:"))
1147  {
1148  def->m_uniOrder = true;
1149  bool valid = ParseUtils::GenerateOrderedVector(
1150  numModesPerDir.c_str() + 9, def->m_numModes);
1151  ASSERTL0(valid,
1152  prfx.str() +
1153  "unable to correctly parse the number of modes.");
1154  }
1155  }
1156  else if (attrName == "POINTSTYPE")
1157  {
1158  std::string pointsString;
1159  field->GetAttribute(attrName, pointsString);
1160  def->m_pointsDef = true;
1161 
1162  std::vector<std::string> pointsStrings;
1164  pointsString.c_str(), pointsStrings);
1165  ASSERTL0(valid,
1166  prfx.str() +
1167  "unable to correctly parse the points types.");
1168  for (std::vector<std::string>::size_type i = 0;
1169  i < pointsStrings.size();
1170  i++)
1171  {
1172  valid = false;
1173  for (unsigned int j = 0; j < SIZE_PointsType; j++)
1174  {
1175  if (kPointsTypeStr[j] == pointsStrings[i])
1176  {
1177  def->m_points.push_back((PointsType)j);
1178  valid = true;
1179  break;
1180  }
1181  }
1182 
1183  ASSERTL0(
1184  valid,
1185  prfx.str() +
1186  std::string(
1187  "unable to correctly parse the points type: ")
1188  .append(pointsStrings[i])
1189  .c_str());
1190  }
1191  }
1192  else if (attrName == "NUMPOINTSPERDIR")
1193  {
1194  std::string numPointsPerDir;
1195  field->GetAttribute(attrName, numPointsPerDir);
1196  def->m_numPointsDef = true;
1197 
1198  bool valid = ParseUtils::GenerateOrderedVector(
1199  numPointsPerDir.c_str(), def->m_numPoints);
1200  ASSERTL0(valid,
1201  prfx.str() +
1202  "unable to correctly parse the number of points.");
1203  }
1204  else
1205  {
1206  std::string errstr("unknown attribute: ");
1207  errstr += attrName;
1208  ASSERTL1(false, prfx.str() + errstr.c_str());
1209  }
1210  }
1211 
1212  if (def->m_numHomogeneousDir >= 1)
1213  {
1214  H5::DataSetSharedPtr homz_dset = root->OpenDataSet("HOMOGENEOUSZIDS");
1215  H5::DataSpaceSharedPtr homz_fspace = homz_dset->GetSpace();
1216  uint64_t dsize = decomps[decomp * MAX_DCMPS + HOMZ_DCMP_IDX];
1217  homz_fspace->SelectRange(offset.homz, dsize);
1218  homz_dset->Read(def->m_homogeneousZIDs, homz_fspace, readPL);
1219  }
1220 
1221  if (def->m_numHomogeneousDir >= 2)
1222  {
1223  H5::DataSetSharedPtr homy_dset = root->OpenDataSet("HOMOGENEOUSYIDS");
1224  H5::DataSpaceSharedPtr homy_fspace = homy_dset->GetSpace();
1225  uint64_t dsize = decomps[decomp * MAX_DCMPS + HOMY_DCMP_IDX];
1226  homy_fspace->SelectRange(offset.homy, dsize);
1227  homy_dset->Read(def->m_homogeneousYIDs, homy_fspace, readPL);
1228  }
1229 
1230  if (def->m_homoStrips)
1231  {
1232  H5::DataSetSharedPtr homs_dset = root->OpenDataSet("HOMOGENEOUSSIDS");
1233  H5::DataSpaceSharedPtr homs_fspace = homs_dset->GetSpace();
1234  uint64_t dsize = decomps[decomp * MAX_DCMPS + HOMS_DCMP_IDX];
1235  homs_fspace->SelectRange(offset.homs, dsize);
1236  homs_dset->Read(def->m_homogeneousSIDs, homs_fspace, readPL);
1237  }
1238 
1239  if (!def->m_uniOrder)
1240  {
1241  H5::DataSetSharedPtr order_dset = root->OpenDataSet("POLYORDERS");
1242  H5::DataSpaceSharedPtr order_fspace = order_dset->GetSpace();
1243  uint64_t dsize = decomps[decomp * MAX_DCMPS + ORDER_DCMP_IDX];
1244  order_fspace->SelectRange(offset.order, dsize);
1245  order_dset->Read(def->m_numModes, order_fspace, readPL);
1246  }
1247 }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:198
static bool GenerateOrderedStringVector(const char *const str, std::vector< std::string > &vec)
Definition: ParseUtils.hpp:143
boost::shared_ptr< Group > GroupSharedPtr
Definition: FieldIOHdf5.h:50
static bool GenerateOrderedVector(const char *const str, std::vector< unsigned int > &vec)
Definition: ParseUtils.hpp:97
static const unsigned int MAX_DCMPS
A helper for FieldIOHdf5::v_Write. Describes the maximum number of items in the decomposition per fie...
Definition: FieldIOHdf5.h:185
const std::string kPointsTypeStr[]
Definition: Foundations.hpp:69
boost::shared_ptr< DataSet > DataSetSharedPtr
Definition: H5.h:100
const char *const ShapeTypeMap[]
Definition: ShapeType.hpp:66
boost::shared_ptr< DataSpace > DataSpaceSharedPtr
Definition: H5.h:88
LibUtilities::CommSharedPtr m_comm
Communicator to use when writing parallel format.
Definition: FieldIO.h:265
static const unsigned int HOMY_DCMP_IDX
A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of ...
Definition: FieldIOHdf5.h:181
static const unsigned int HOMZ_DCMP_IDX
A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of ...
Definition: FieldIOHdf5.h:182
static const unsigned int HOMS_DCMP_IDX
A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of ...
Definition: FieldIOHdf5.h:183
static const unsigned int ORDER_DCMP_IDX
A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of ...
Definition: FieldIOHdf5.h:180
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
void Nektar::LibUtilities::FieldIOHdf5::ImportHDF5FieldMetaData ( DataSourceSharedPtr  dataSource,
FieldMetaDataMap fieldmetadatamap 
)
private

Import field metadata from dataSource.

Parameters
dataSourceInput datasource, which should be a H5DataSource.
fieldmetadatamapResulting field metadata from dataSource.

Definition at line 1310 of file FieldIOHdf5.cpp.

References Nektar::LibUtilities::H5DataSource::Get().

Referenced by v_ImportFieldMetaData().

1312 {
1313  H5DataSourceSharedPtr hdf =
1314  boost::static_pointer_cast<H5DataSource>(dataSource);
1315 
1316  H5::GroupSharedPtr master = hdf->Get()->OpenGroup("NEKTAR");
1317  // New metadata format only in HDF
1318  H5::GroupSharedPtr metadata = master->OpenGroup("Metadata");
1319 
1320  if (metadata)
1321  {
1322  H5::Group::AttrIterator param = metadata->attr_begin(),
1323  pEnd = metadata->attr_end();
1324  for (; param != pEnd; ++param)
1325  {
1326  std::string paramString = *param;
1327  if (paramString != "Provenance")
1328  {
1329  std::string paramBodyStr;
1330  metadata->GetAttribute(paramString, paramBodyStr);
1331  fieldmetadatamap[paramString] = paramBodyStr;
1332  }
1333  }
1334  }
1335 }
boost::shared_ptr< H5DataSource > H5DataSourceSharedPtr
Definition: FieldIOHdf5.h:89
boost::shared_ptr< Group > GroupSharedPtr
Definition: FieldIOHdf5.h:50
void Nektar::LibUtilities::FieldIOHdf5::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 
)
privatevirtual

Import a HDF5 format file.

Parameters
finfilenameInput filename
fielddefsField definitions of resulting field
fielddataField data of resulting field
fieldinfomapField metadata of resulting field
ElementIDsIf specified, contains the list of element IDs on this rank. The resulting field definitions will only contain data for the element IDs specified in this array.

Implements Nektar::LibUtilities::FieldIO.

Definition at line 855 of file FieldIOHdf5.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, ASSERTL1, Nektar::LibUtilities::H5DataSource::create(), Nektar::LibUtilities::FieldIOHdf5::OffsetHelper::data, Nektar::LibUtilities::H5::PList::DatasetXfer(), Nektar::LibUtilities::H5::PList::Default(), ELEM_DCMP_IDX, Nektar::LibUtilities::H5::PList::FileAccess(), FORMAT_VERSION, HASH_DCMP_IDX, Nektar::LibUtilities::FieldIOHdf5::OffsetHelper::homs, HOMS_DCMP_IDX, Nektar::LibUtilities::FieldIOHdf5::OffsetHelper::homy, HOMY_DCMP_IDX, Nektar::LibUtilities::FieldIOHdf5::OffsetHelper::homz, HOMZ_DCMP_IDX, ImportFieldData(), ImportFieldDef(), Nektar::iterator, Nektar::LibUtilities::FieldIO::m_comm, MAX_DCMPS, Nektar::NullInt1DArray, Nektar::LibUtilities::NullVectorNekDoubleVector, Nektar::LibUtilities::FieldIOHdf5::OffsetHelper::order, ORDER_DCMP_IDX, and VAL_DCMP_IDX.

860 {
861  std::stringstream prfx;
862  int nRanks = m_comm->GetSize();
863 
864  // Set properties for parallel file access (if we're in parallel)
865  H5::PListSharedPtr parallelProps = H5::PList::Default();
867 
868  if (nRanks > 1)
869  {
870  // Use MPI/O to access the file
871  parallelProps = H5::PList::FileAccess();
872  parallelProps->SetMpio(m_comm);
873  // Use collective IO
874  readPL = H5::PList::DatasetXfer();
875  readPL->SetDxMpioCollective();
876  }
877 
879  infilename, parallelProps);
880 
881  // Open the root group of the hdf5 file
883  boost::static_pointer_cast<H5DataSource>(dataSource);
884  ASSERTL1(h5, prfx.str() + "cannot open HDF5 file.");
885  H5::GroupSharedPtr root = h5->Get()->OpenGroup("NEKTAR");
886  ASSERTL1(root, prfx.str() + "cannot open root group.");
887 
888  // Check format version
889  unsigned int formatVersion;
890  H5::Group::AttrIterator attrIt = root->attr_begin();
891  H5::Group::AttrIterator attrEnd = root->attr_end();
892  for (; attrIt != attrEnd; ++attrIt)
893  {
894  if (*attrIt == "FORMAT_VERSION")
895  {
896  break;
897  }
898  }
899 
900  ASSERTL0(attrIt != attrEnd,
901  "Unable to determine Nektar++ HDF5 file version");
902  root->GetAttribute("FORMAT_VERSION", formatVersion);
903 
904  ASSERTL0(formatVersion <= FORMAT_VERSION,
905  "File format if " + infilename + " is higher than supported in "
906  "this version of Nektar++");
907 
908  // Open the datasets
909  H5::DataSetSharedPtr decomps_dset = root->OpenDataSet("DECOMPOSITION");
910  ASSERTL1(decomps_dset, prfx.str() + "cannot open DECOMPOSITION dataset.");
911 
912  H5::DataSetSharedPtr ids_dset = root->OpenDataSet("ELEMENTIDS");
913  ASSERTL1(ids_dset, prfx.str() + "cannot open ELEMENTIDS dataset.");
914 
915  H5::DataSetSharedPtr data_dset = root->OpenDataSet("DATA");
916  ASSERTL1(data_dset, prfx.str() + "cannot open DATA dataset.");
917 
918  // Open the dataset file spaces
919  H5::DataSpaceSharedPtr decomps_fspace = decomps_dset->GetSpace();
920  ASSERTL1(decomps_fspace,
921  prfx.str() + "cannot open DECOMPOSITION filespace.");
922 
923  H5::DataSpaceSharedPtr ids_fspace = ids_dset->GetSpace();
924  ASSERTL1(ids_fspace, prfx.str() + "cannot open ELEMENTIDS filespace.");
925 
926  H5::DataSpaceSharedPtr data_fspace = data_dset->GetSpace();
927  ASSERTL1(data_fspace, prfx.str() + "cannot open DATA filespace.");
928 
929  // Read entire IDS data set to get list of global IDs.
930  std::vector<uint64_t> ids;
931 
932  ids_dset->Read(ids, ids_fspace, readPL);
933 
934  boost::unordered_set<uint64_t> toread;
935  if (ElementIDs != NullInt1DArray)
936  {
937  for (uint64_t i = 0; i < ElementIDs.num_elements(); ++i)
938  {
939  toread.insert(ElementIDs[i]);
940  }
941  }
942 
943  std::vector<uint64_t> decomps;
944  decomps_dset->Read(decomps, decomps_fspace, readPL);
945 
946  size_t nDecomps = decomps.size() / MAX_DCMPS;
947  size_t cnt = 0, cnt2 = 0;
948 
949  // Mapping from each decomposition to offsets in the data array.
950  vector<OffsetHelper> decompsToOffsets (nDecomps);
951 
952  // Mapping from each group's hash to a vector of element IDs. Note this has
953  // to be unsigned int, since that's what we use in FieldDefinitions.
954  map<uint64_t, vector<unsigned int> > groupsToElmts;
955 
956  // Mapping from each group's hash to each of the decompositions.
957  map<uint64_t, set<uint64_t> > groupsToDecomps;
958 
959  // True if we are pulling element IDs from ElementIDs.
960  bool selective = toread.size() > 0;
961 
962  // Counters for data offsets
963  OffsetHelper running;
964 
965  for (size_t i = 0; i < nDecomps; ++i, cnt += MAX_DCMPS)
966  {
967  uint64_t nElmt = decomps[cnt + ELEM_DCMP_IDX];
968  uint64_t groupHash = decomps[cnt + HASH_DCMP_IDX];
969 
970  vector<uint64_t> tmp;
971 
972  if (selective)
973  {
974  for (size_t j = 0; j < nElmt; ++j)
975  {
976  uint64_t elmtId = ids[cnt2 + j];
977  if (toread.find(elmtId) != toread.end())
978  {
979  tmp.push_back(elmtId);
980  }
981  }
982  }
983  else
984  {
985  tmp.insert(
986  tmp.begin(), ids.begin() + cnt2, ids.begin() + cnt2 + nElmt);
987  }
988 
989  vector<unsigned int> tmp2(nElmt);
990  for (size_t j = 0; j < nElmt; ++j)
991  {
992  tmp2[j] = ids[cnt2+j];
993  }
994 
995  cnt2 += nElmt;
996 
997  if (tmp.size() > 0)
998  {
999  groupsToDecomps[groupHash].insert(i);
1000  }
1001 
1002  groupsToElmts[i] = tmp2;
1003  decompsToOffsets[i] = running;
1004 
1005  running.data += decomps[cnt + VAL_DCMP_IDX];
1006  running.order += decomps[cnt + ORDER_DCMP_IDX];
1007  running.homy += decomps[cnt + HOMY_DCMP_IDX];
1008  running.homz += decomps[cnt + HOMZ_DCMP_IDX];
1009  running.homs += decomps[cnt + HOMS_DCMP_IDX];
1010  }
1011 
1012  map<uint64_t, set<uint64_t> >::iterator gIt;
1013  for (gIt = groupsToDecomps.begin(); gIt != groupsToDecomps.end(); ++gIt)
1014  {
1015  // Select region from dataset for this decomposition.
1017  for (sIt = gIt->second.begin(); sIt != gIt->second.end(); ++sIt)
1018  {
1019  std::stringstream fieldNameStream;
1020  fieldNameStream << gIt->first;
1021 
1022  FieldDefinitionsSharedPtr fielddef =
1024  ImportFieldDef(readPL, root, decomps, *sIt, decompsToOffsets[*sIt],
1025  fieldNameStream.str(), fielddef);
1026 
1027  fielddef->m_elementIDs = groupsToElmts[*sIt];
1028  fielddefs.push_back(fielddef);
1029 
1030  if (fielddata != NullVectorNekDoubleVector)
1031  {
1032  std::vector<NekDouble> decompFieldData;
1034  readPL, data_dset, data_fspace,
1035  decompsToOffsets[*sIt].data, decomps, *sIt, fielddef,
1036  decompFieldData);
1037  fielddata.push_back(decompFieldData);
1038  }
1039  }
1040  }
1041 
1042  m_comm->Block();
1043 }
boost::shared_ptr< H5DataSource > H5DataSourceSharedPtr
Definition: FieldIOHdf5.h:89
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:198
boost::shared_ptr< Group > GroupSharedPtr
Definition: FieldIOHdf5.h:50
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
static const unsigned int MAX_DCMPS
A helper for FieldIOHdf5::v_Write. Describes the maximum number of items in the decomposition per fie...
Definition: FieldIOHdf5.h:185
boost::shared_ptr< FieldDefinitions > FieldDefinitionsSharedPtr
Definition: FieldIO.h:181
boost::shared_ptr< DataSet > DataSetSharedPtr
Definition: H5.h:100
boost::shared_ptr< PList > PListSharedPtr
Definition: H5.h:102
boost::shared_ptr< DataSource > DataSourceSharedPtr
Definition: FieldIO.h:81
static const unsigned int HASH_DCMP_IDX
The hash of the field definition information, which defines the name of the attribute containing the ...
Definition: FieldIOHdf5.h:184
static DataSourceSharedPtr create(const std::string &fn, H5::PListSharedPtr parallelProps)
Static constructor for this data source.
Definition: FieldIOHdf5.h:79
void ImportFieldDef(H5::PListSharedPtr readPL, H5::GroupSharedPtr root, std::vector< uint64_t > &decomps, uint64_t decomp, OffsetHelper offset, std::string group, FieldDefinitionsSharedPtr def)
Import field definitions from a HDF5 document.
static const unsigned int FORMAT_VERSION
Version of the Nektar++ HDF5 format, which is embedded into the main NEKTAR group as an attribute...
Definition: FieldIOHdf5.h:176
boost::shared_ptr< DataSpace > DataSpaceSharedPtr
Definition: H5.h:88
static std::vector< std::vector< NekDouble > > NullVectorNekDoubleVector
static PListSharedPtr DatasetXfer()
Properties for raw data transfer.
Definition: H5.cpp:114
static const unsigned int VAL_DCMP_IDX
A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of ...
Definition: FieldIOHdf5.h:179
LibUtilities::CommSharedPtr m_comm
Communicator to use when writing parallel format.
Definition: FieldIO.h:265
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
static const unsigned int HOMY_DCMP_IDX
A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of ...
Definition: FieldIOHdf5.h:181
static const unsigned int HOMZ_DCMP_IDX
A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of ...
Definition: FieldIOHdf5.h:182
static const unsigned int ELEM_DCMP_IDX
A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of ...
Definition: FieldIOHdf5.h:178
void ImportFieldData(H5::PListSharedPtr readPL, H5::DataSetSharedPtr data_dset, H5::DataSpaceSharedPtr data_fspace, uint64_t data_i, std::vector< uint64_t > &decomps, uint64_t decomp, const FieldDefinitionsSharedPtr fielddef, std::vector< NekDouble > &fielddata)
Import the field data from the HDF5 document.
static PListSharedPtr FileAccess()
Properties for file access.
Definition: H5.cpp:96
static const unsigned int HOMS_DCMP_IDX
A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of ...
Definition: FieldIOHdf5.h:183
static Array< OneD, int > NullInt1DArray
static const unsigned int ORDER_DCMP_IDX
A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of ...
Definition: FieldIOHdf5.h:180
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
static PListSharedPtr Default()
Default options.
Definition: H5.cpp:78
DataSourceSharedPtr Nektar::LibUtilities::FieldIOHdf5::v_ImportFieldMetaData ( const std::string &  filename,
FieldMetaDataMap fieldmetadatamap 
)
privatevirtual

Import field metadata from filename and return the data source which wraps filename.

Parameters
filenameInput filename.
fieldmetadatamapResulting field metadata from dataSource.

Implements Nektar::LibUtilities::FieldIO.

Definition at line 1294 of file FieldIOHdf5.cpp.

References Nektar::LibUtilities::H5DataSource::create(), Nektar::LibUtilities::H5::PList::Default(), and ImportHDF5FieldMetaData().

1297 {
1298  H5::PListSharedPtr parallelProps = H5::PList::Default();
1299  DataSourceSharedPtr ans = H5DataSource::create(filename, parallelProps);
1300  ImportHDF5FieldMetaData(ans, fieldmetadatamap);
1301  return ans;
1302 }
void ImportHDF5FieldMetaData(DataSourceSharedPtr dataSource, FieldMetaDataMap &fieldmetadatamap)
Import field metadata from dataSource.
boost::shared_ptr< PList > PListSharedPtr
Definition: H5.h:102
boost::shared_ptr< DataSource > DataSourceSharedPtr
Definition: FieldIO.h:81
static DataSourceSharedPtr create(const std::string &fn, H5::PListSharedPtr parallelProps)
Static constructor for this data source.
Definition: FieldIOHdf5.h:79
static PListSharedPtr Default()
Default options.
Definition: H5.cpp:78
void Nektar::LibUtilities::FieldIOHdf5::v_Write ( const std::string &  outFile,
std::vector< FieldDefinitionsSharedPtr > &  fielddefs,
std::vector< std::vector< NekDouble > > &  fielddata,
const FieldMetaDataMap fieldmetadatamap = NullFieldMetaDataMap,
const bool  backup = false 
)
privatevirtual

Write a HDF5 file to outFile given the field definitions fielddefs, field data fielddata and metadata fieldmetadatamap.

The writing strategy for HDF5 output is as follows:

  • Each rank determines the amount of data needed to be written into each dataset.
  • Each rank communicates its decomposition information to the root process.
  • The root processor initialises the output structure, writes the decomposition dataset and all the field definition information.
  • Other ranks may have field definitions that do not belong to the root process, in which case they open the file and append this (since attributes cannot be written in parallel).
  • Each of the other ranks writes their data contributions to the rest of the set.
Parameters
outFileOutput filename.
fielddefsInput field definitions.
fielddataInput field data.
fieldmetadatamapField metadata.

Implements Nektar::LibUtilities::FieldIO.

Definition at line 173 of file FieldIOHdf5.cpp.

References Nektar::LibUtilities::FieldIO::AddInfoTag(), ASSERTL1, Nektar::LibUtilities::FieldIO::CheckFieldDefinition(), CellMLToNektar.pycml::copy(), Nektar::LibUtilities::H5::File::Create(), DATA_IDX_IDX, Nektar::LibUtilities::H5::PList::DatasetXfer(), Nektar::LibUtilities::H5::PList::Default(), ELEM_CNT_IDX, ELEM_DCMP_IDX, Nektar::LibUtilities::H5::PList::FileAccess(), FORMAT_VERSION, Nektar::StdRegions::GetSize(), HASH_DCMP_IDX, HOMS_CNT_IDX, HOMS_DCMP_IDX, HOMS_IDX_IDX, HOMY_CNT_IDX, HOMY_DCMP_IDX, HOMY_IDX_IDX, HOMZ_CNT_IDX, HOMZ_DCMP_IDX, HOMZ_IDX_IDX, IDS_IDX_IDX, Nektar::iterator, Nektar::LibUtilities::FieldIO::m_comm, MAX_CNTS, MAX_DCMPS, MAX_IDXS, Nektar::LibUtilities::H5::DataType::OfObject(), Nektar::LibUtilities::H5::DataSpace::OneD(), Nektar::LibUtilities::H5::File::Open(), ORDER_CNT_IDX, ORDER_DCMP_IDX, ORDER_IDX_IDX, Nektar::LibUtilities::ReduceMax, Nektar::LibUtilities::ReduceMin, Nektar::LibUtilities::FieldIO::SetUpOutput(), Nektar::LibUtilities::ShapeTypeMap, VAL_CNT_IDX, and VAL_DCMP_IDX.

178 {
179  std::stringstream prfx;
180  prfx << m_comm->GetRank() << ": FieldIOHdf5::v_Write(): ";
181  double tm0 = 0.0, tm1 = 0.0;
182 
183  if (m_comm->GetRank() == 0)
184  {
185  tm0 = m_comm->Wtime();
186  }
187 
188  SetUpOutput(outFile, false, backup);
189 
190  // We make a number of assumptions in this code:
191  // 1. All element ids have the same type: unsigned int
192  // 2. All elements within a given field have the same number of values
193  // 3. All element values have the same type, NekDouble
194 
195  // Determine the root MPI process, i.e., the lowest ranked process handling
196  // nMaxFields fields, that will be responsible for writing our file.
197  ASSERTL1(fielddefs.size() == fielddata.size(),
198  prfx.str() + "fielddefs and fielddata have incompatible lengths.");
199 
200  size_t nFields = fielddefs.size();
201  size_t nMaxFields = nFields;
202  m_comm->AllReduce(nMaxFields, LibUtilities::ReduceMax);
203 
204  int root_rank = -1;
205  bool amRoot = false;
206  LibUtilities::CommSharedPtr max_fields_comm;
207 
208  if (m_comm->GetSize() > 1)
209  {
210  max_fields_comm = m_comm->CommCreateIf((nFields == nMaxFields) ? 1 : 0);
211  }
212  else
213  {
214  max_fields_comm = m_comm;
215  }
216 
217  if (max_fields_comm)
218  {
219  int rank = m_comm->GetRank();
220  root_rank = rank;
221  max_fields_comm->AllReduce(root_rank, LibUtilities::ReduceMin);
222  amRoot = (rank == root_rank);
223  if (!amRoot)
224  {
225  root_rank = -1;
226  }
227  }
228 
229  m_comm->AllReduce(root_rank, LibUtilities::ReduceMax);
230  ASSERTL1(root_rank >= 0 && root_rank < m_comm->GetSize(),
231  prfx.str() + "invalid root rank.");
232 
233  std::vector<uint64_t> decomps(nMaxFields * MAX_DCMPS, 0);
234  std::vector<uint64_t> all_hashes(nMaxFields * m_comm->GetSize(), 0);
235  std::vector<uint64_t> cnts(MAX_CNTS, 0);
236  std::vector<std::string> fieldNames(nFields);
237  std::vector<std::string> shapeStrings(nFields);
238  std::vector<std::vector<NekDouble> > homoLengths(nFields);
239  std::vector<std::vector<unsigned int> > homoSIDs(nFields),
240  homoYIDs(nFields), homoZIDs(nFields);
241  std::vector<std::vector<unsigned int> > numModesPerDirVar(nFields);
242  std::vector<std::string> numModesPerDirUni(nFields);
243 
244  int homDim = -1;
245  int varOrder = 0;
246 
247  for (int f = 0; f < nFields; ++f)
248  {
249  if (!fielddefs[f]->m_uniOrder)
250  {
251  varOrder = 1;
252  break;
253  }
254  }
255 
256  m_comm->AllReduce(varOrder, LibUtilities::ReduceMax);
257 
258  // Calculate the total number of elements handled by this MPI process and
259  // the total number of bytes required to store the elements. Base the name
260  // of each field on the hash of the field definition.
261  for (int f = 0; f < nFields; ++f)
262  {
263  ASSERTL1(fielddata[f].size() > 0,
264  prfx.str() +
265  "fielddata vector must contain at least one value.");
266  ASSERTL1(fielddata[f].size() ==
267  fielddefs[f]->m_fields.size() *
268  CheckFieldDefinition(fielddefs[f]),
269  prfx.str() + "fielddata vector has invalid size.");
270 
271  std::size_t nFieldElems = fielddefs[f]->m_elementIDs.size();
272  std::size_t nElemVals = fielddata[f].size();
273 
274  decomps[f * MAX_DCMPS + ELEM_DCMP_IDX] = nFieldElems;
275  decomps[f * MAX_DCMPS + VAL_DCMP_IDX] = nElemVals;
276 
277  cnts[ELEM_CNT_IDX] += nFieldElems;
278  cnts[VAL_CNT_IDX] += nElemVals;
279 
280  // Hash the field specification
281  std::stringstream hashStream;
282  std::size_t nSubFields = fielddefs[f]->m_fields.size();
283  for (int sf = 0; sf < nSubFields; ++sf)
284  {
285  hashStream << fielddefs[f]->m_fields[sf];
286  }
287 
288  nSubFields = fielddefs[f]->m_basis.size();
289  for (int sf = 0; sf < nSubFields; ++sf)
290  {
291  hashStream << fielddefs[f]->m_basis[sf];
292  }
293 
294  // Determine SHAPE attribute
295  std::stringstream shapeStringStream;
296  shapeStringStream << ShapeTypeMap[fielddefs[f]->m_shapeType];
297 
298  if (fielddefs[f]->m_numHomogeneousDir > 0)
299  {
300  if (homDim == -1)
301  {
302  homDim = fielddefs[f]->m_numHomogeneousDir;
303  }
304 
305  ASSERTL1(homDim == fielddefs[f]->m_numHomogeneousDir,
306  "HDF5 does not support variable homogeneous directions in "
307  "the same file.");
308 
309  shapeStringStream << "-HomogenousExp"
310  << fielddefs[f]->m_numHomogeneousDir << "D";
311  }
312 
313  if (fielddefs[f]->m_homoStrips)
314  {
315  shapeStringStream << "-Strips";
316  }
317 
318  shapeStrings[f] = shapeStringStream.str();
319  hashStream << shapeStringStream.str();
320 
321  // Determine HOMOGENEOUS attributes
322  if (fielddefs[f]->m_numHomogeneousDir)
323  {
324  nSubFields = fielddefs[f]->m_homogeneousLengths.size();
325  homoLengths[f].resize(nSubFields);
326  for (int sf = 0; sf < nSubFields; ++sf)
327  {
328  uint64_t len = fielddefs[f]->m_homogeneousLengths[sf];
329  hashStream << len;
330  homoLengths[f][sf] = len;
331  }
332 
333  nSubFields = fielddefs[f]->m_homogeneousYIDs.size();
334  if (nSubFields > 0)
335  {
336  homoYIDs[f].resize(nSubFields);
337  decomps[f * MAX_DCMPS + HOMY_DCMP_IDX] = nSubFields;
338  cnts[HOMY_CNT_IDX] += nSubFields;
339  for (int sf = 0; sf < nSubFields; ++sf)
340  {
341  homoYIDs[f][sf] = fielddefs[f]->m_homogeneousYIDs[sf];
342  }
343  }
344 
345  nSubFields = fielddefs[f]->m_homogeneousZIDs.size();
346  if (nSubFields > 0)
347  {
348  homoZIDs[f].resize(nSubFields);
349  decomps[f * MAX_DCMPS + HOMZ_DCMP_IDX] = nSubFields;
350  cnts[HOMZ_CNT_IDX] += nSubFields;
351  for (int sf = 0; sf < nSubFields; ++sf)
352  {
353  homoZIDs[f][sf] = fielddefs[f]->m_homogeneousZIDs[sf];
354  }
355  }
356 
357  nSubFields = fielddefs[f]->m_homogeneousSIDs.size();
358  if (nSubFields > 0)
359  {
360  homoSIDs[f].resize(nSubFields);
361  decomps[f * MAX_DCMPS + HOMS_DCMP_IDX] = nSubFields;
362  cnts[HOMS_CNT_IDX] += nSubFields;
363  for (int sf = 0; sf < nSubFields; ++sf)
364  {
365  homoSIDs[f][sf] = fielddefs[f]->m_homogeneousSIDs[sf];
366  }
367  }
368  }
369 
370  if (fielddefs[f]->m_uniOrder)
371  {
372  std::vector<unsigned int> elemModes(fielddefs[f]->m_basis.size());
373 
374  for (std::vector<int>::size_type i = 0;
375  i < fielddefs[f]->m_basis.size(); ++i)
376  {
377  elemModes[i] = fielddefs[f]->m_numModes[i];
378  }
379 
380  if (varOrder)
381  {
382  for (std::vector<int>::size_type i = 0; i < nFieldElems; ++i)
383  {
384  std::copy(elemModes.begin(), elemModes.end(),
385  std::back_inserter(numModesPerDirVar[f]));
386  }
387  decomps[f * MAX_DCMPS + ORDER_DCMP_IDX] =
388  nFieldElems * elemModes.size();
389  cnts[ORDER_CNT_IDX] += nFieldElems * elemModes.size();
390  }
391  else
392  {
393  stringstream numModesStringStream;
394  numModesStringStream << "UNIORDER:";
395  for (std::vector<int>::size_type i = 0;
396  i < elemModes.size(); i++)
397  {
398  if (i > 0)
399  {
400  numModesStringStream << ",";
401  }
402  numModesStringStream << elemModes[i];
403  }
404 
405  numModesPerDirUni[f] = numModesStringStream.str();
406  hashStream << numModesPerDirUni[f];
407  }
408  }
409  else
410  {
411  numModesPerDirVar[f] = fielddefs[f]->m_numModes;
412  decomps[f * MAX_DCMPS + ORDER_DCMP_IDX] =
413  fielddefs[f]->m_numModes.size();
414  cnts[ORDER_CNT_IDX] += fielddefs[f]->m_numModes.size();
415  }
416 
417  boost::hash<std::string> string_hasher;
418  std::stringstream fieldNameStream;
419  uint64_t fieldDefHash = string_hasher(hashStream.str());
420 
421  decomps[f * MAX_DCMPS + HASH_DCMP_IDX] = fieldDefHash;
422  all_hashes[m_comm->GetRank() * nMaxFields + f] = fieldDefHash;
423 
424  fieldNameStream << fieldDefHash;
425  fieldNames[f] = fieldNameStream.str();
426  }
427 
428  // Gather information from all MPI processes
429  std::vector<uint64_t> all_cnts = m_comm->Gather(root_rank, cnts);
430  std::vector<uint64_t> all_idxs(m_comm->GetSize() * MAX_IDXS, 0);
431  std::vector<uint64_t> all_decomps = m_comm->Gather(root_rank, decomps);
432  std::vector<uint64_t> all_dsetsize(MAX_CNTS, 0);
433 
434  // The root rank creates the file layout from scratch
435  if (amRoot)
436  {
437  H5::FileSharedPtr outfile = H5::File::Create(outFile, H5F_ACC_TRUNC);
438  ASSERTL1(outfile, prfx.str() + "cannot create HDF5 file.");
439  H5::GroupSharedPtr root = outfile->CreateGroup("NEKTAR");
440  ASSERTL1(root, prfx.str() + "cannot create root group.");
441  TagWriterSharedPtr info_writer(new H5TagWriter(root));
442  AddInfoTag(info_writer, fieldmetadatamap);
443 
444  // Record file format version as attribute in main group.
445  root->SetAttribute("FORMAT_VERSION", FORMAT_VERSION);
446 
447  // Calculate the indexes to be used by each MPI process when reading the
448  // IDS and DATA datasets
449  std::size_t nTotElems = 0, nTotVals = 0, nTotOrder = 0;
450  std::size_t nTotHomY = 0, nTotHomZ = 0, nTotHomS = 0;
451  int nRanks = m_comm->GetSize();
452  for (int r = 0; r < nRanks; ++r)
453  {
454  all_idxs[r * MAX_IDXS + IDS_IDX_IDX] = nTotElems;
455  all_idxs[r * MAX_IDXS + DATA_IDX_IDX] = nTotVals;
456  all_idxs[r * MAX_IDXS + ORDER_IDX_IDX] = nTotOrder;
457  all_idxs[r * MAX_IDXS + HOMY_IDX_IDX] = nTotHomY;
458  all_idxs[r * MAX_IDXS + HOMZ_IDX_IDX] = nTotHomZ;
459  all_idxs[r * MAX_IDXS + HOMS_IDX_IDX] = nTotHomS;
460 
461  nTotElems += all_cnts[r * MAX_CNTS + ELEM_CNT_IDX];
462  nTotVals += all_cnts[r * MAX_CNTS + VAL_CNT_IDX];
463  nTotOrder += all_cnts[r * MAX_CNTS + ORDER_CNT_IDX];
464  nTotHomY += all_cnts[r * MAX_CNTS + HOMY_CNT_IDX];
465  nTotHomZ += all_cnts[r * MAX_CNTS + HOMZ_CNT_IDX];
466  nTotHomS += all_cnts[r * MAX_CNTS + HOMS_CNT_IDX];
467  }
468 
469  all_dsetsize[ELEM_CNT_IDX ] = nTotElems;
470  all_dsetsize[VAL_CNT_IDX ] = nTotVals;
471  all_dsetsize[ORDER_CNT_IDX] = nTotOrder;
472  all_dsetsize[HOMY_CNT_IDX ] = nTotHomY;
473  all_dsetsize[HOMZ_CNT_IDX ] = nTotHomZ;
474  all_dsetsize[HOMS_CNT_IDX ] = nTotHomS;
475 
476  // Create DECOMPOSITION dataset: basic field info for each MPI process
477  H5::DataTypeSharedPtr decomps_type =
478  H5::DataType::OfObject(all_decomps[0]);
479  H5::DataSpaceSharedPtr decomps_space =
480  H5::DataSpace::OneD(all_decomps.size());
481  H5::DataSetSharedPtr decomps_dset =
482  root->CreateDataSet("DECOMPOSITION", decomps_type, decomps_space);
483  ASSERTL1(decomps_dset,
484  prfx.str() + "cannot create DECOMPOSITION dataset.");
485 
486  // Create IDS dataset: element ids
487  H5::DataTypeSharedPtr ids_type =
488  H5::DataType::OfObject(fielddefs[0]->m_elementIDs[0]);
489  H5::DataSpaceSharedPtr ids_space = H5::DataSpace::OneD(nTotElems);
490  H5::DataSetSharedPtr ids_dset =
491  root->CreateDataSet("ELEMENTIDS", ids_type, ids_space);
492  ASSERTL1(ids_dset, prfx.str() + "cannot create ELEMENTIDS dataset.");
493 
494  // Create DATA dataset: element data
495  H5::DataTypeSharedPtr data_type =
496  H5::DataType::OfObject(fielddata[0][0]);
497  H5::DataSpaceSharedPtr data_space = H5::DataSpace::OneD(nTotVals);
498  H5::DataSetSharedPtr data_dset =
499  root->CreateDataSet("DATA", data_type, data_space);
500  ASSERTL1(data_dset, prfx.str() + "cannot create DATA dataset.");
501 
502  // Create HOMOGENEOUSYIDS dataset: homogeneous y-plane IDs
503  if (nTotHomY > 0)
504  {
505  H5::DataTypeSharedPtr homy_type =
506  H5::DataType::OfObject(homoYIDs[0][0]);
507  H5::DataSpaceSharedPtr homy_space = H5::DataSpace::OneD(nTotHomY);
508  H5::DataSetSharedPtr homy_dset =
509  root->CreateDataSet("HOMOGENEOUSYIDS", homy_type, homy_space);
510  ASSERTL1(homy_dset,
511  prfx.str() + "cannot create HOMOGENEOUSYIDS dataset.");
512  }
513 
514  // Create HOMOGENEOUSYIDS dataset: homogeneous z-plane IDs
515  if (nTotHomZ > 0)
516  {
517  H5::DataTypeSharedPtr homz_type =
518  H5::DataType::OfObject(homoZIDs[0][0]);
519  H5::DataSpaceSharedPtr homz_space = H5::DataSpace::OneD(nTotHomZ);
520  H5::DataSetSharedPtr homz_dset =
521  root->CreateDataSet("HOMOGENEOUSZIDS", homz_type, homz_space);
522  ASSERTL1(data_dset,
523  prfx.str() + "cannot create HOMOGENEOUSZIDS dataset.");
524  }
525 
526  // Create HOMOGENEOUSSIDS dataset: homogeneous strip IDs
527  if (nTotHomS > 0)
528  {
529  H5::DataTypeSharedPtr homs_type =
530  H5::DataType::OfObject(homoSIDs[0][0]);
531  H5::DataSpaceSharedPtr homs_space = H5::DataSpace::OneD(nTotHomS);
532  H5::DataSetSharedPtr homs_dset =
533  root->CreateDataSet("HOMOGENEOUSSIDS", homs_type, homs_space);
534  ASSERTL1(homs_dset,
535  prfx.str() + "cannot create HOMOGENEOUSSIDS dataset.");
536  }
537 
538  // Create POLYORDERS dataset: elemental polynomial orders
539  if (varOrder)
540  {
541  H5::DataTypeSharedPtr order_type =
542  H5::DataType::OfObject(numModesPerDirVar[0][0]);
543  H5::DataSpaceSharedPtr order_space = H5::DataSpace::OneD(nTotOrder);
544  H5::DataSetSharedPtr order_dset =
545  root->CreateDataSet("POLYORDERS", order_type, order_space);
546  ASSERTL1(order_dset,
547  prfx.str() + "cannot create POLYORDERS dataset.");
548  }
549  }
550 
551  m_comm->Bcast(all_dsetsize, root_rank);
552 
553  // Datasets, root group and HDF5 file are all closed automatically since
554  // they are now out of scope. Now we need to determine which process will
555  // write the group representing the field description in the HDF5 file. This
556  // next block of code performs this by finding all unique hashes and then
557  // determining one process that will create (possibly more than one) group
558  // for that hash. An alternative would be to communicate the field
559  // information to the root processor, but this is a bit convoluted.
560 
561  // This set stores the unique hashes.
562  std::set<uint64_t> hashToProc;
563  // This map takes ranks to hashes this process will write.
564  std::map<int, std::vector<uint64_t> > writingProcs;
565 
566  // Gather all field hashes to every processor.
567  m_comm->AllReduce(all_hashes, LibUtilities::ReduceMax);
568 
569  for (int n = 0; n < m_comm->GetSize(); ++n)
570  {
571  for (int i = 0; i < nMaxFields; ++i)
572  {
573  uint64_t hash = all_hashes[n*nMaxFields + i];
574 
575  // Note hash can be zero if, on this process, nFields < nMaxFields.
576  if (hashToProc.find(hash) != hashToProc.end() || hash == 0)
577  {
578  continue;
579  }
580  hashToProc.insert(hash);
581  writingProcs[n].push_back(hash);
582  }
583  }
584 
585  // Having constructed the map, go ahead and write the attributes out.
586  map<int, std::vector<uint64_t> >::iterator sIt;
587  for (sIt = writingProcs.begin(); sIt != writingProcs.end(); sIt++)
588  {
589  int rank = sIt->first;
590 
591  // Write out this rank's groups.
592  if (m_comm->GetRank() == rank)
593  {
594  H5::PListSharedPtr serialProps = H5::PList::Default();
596 
597  // Reopen the file
598  H5::FileSharedPtr outfile =
599  H5::File::Open(outFile, H5F_ACC_RDWR, serialProps);
600  ASSERTL1(outfile, prfx.str() + "cannot open HDF5 file.");
601  H5::GroupSharedPtr root = outfile->OpenGroup("NEKTAR");
602  ASSERTL1(root, prfx.str() + "cannot open root group.");
603 
604  // Write a HDF5 group for each field
605  hashToProc.clear();
606  for (int i = 0; i < sIt->second.size(); ++i)
607  {
608  for (int f = 0; f < nFields; ++f)
609  {
610  if (sIt->second[i] !=
611  all_hashes[m_comm->GetRank() * nMaxFields + f] ||
612  hashToProc.find(sIt->second[i]) != hashToProc.end())
613  {
614  continue;
615  }
616 
617  hashToProc.insert(sIt->second[i]);
618 
619  // Just in case we've already written this
620  H5::GroupSharedPtr field_group =
621  root->CreateGroup(fieldNames[f]);
622  ASSERTL1(field_group,
623  prfx.str() + "cannot create field group.");
624  field_group->SetAttribute("FIELDS", fielddefs[f]->m_fields);
625  field_group->SetAttribute("BASIS", fielddefs[f]->m_basis);
626  field_group->SetAttribute("SHAPE", shapeStrings[f]);
627 
628  if (homoLengths[f].size() > 0)
629  {
630  field_group->SetAttribute("HOMOGENEOUSLENGTHS",
631  homoLengths[f]);
632  }
633 
634  // If the field has only uniform order, we write the order
635  // into the NUMMODESPERDIR attribute. Otherwise, we'll go
636  // ahead and assume everything is mixed and fix this in the
637  // read later if required.
638  if (!varOrder)
639  {
640  field_group->SetAttribute("NUMMODESPERDIR",
641  numModesPerDirUni[f]);
642  }
643  else
644  {
645  std::string numModesPerDir = "MIXORDER";
646  field_group->SetAttribute("NUMMODESPERDIR",
647  numModesPerDir);
648  }
649  }
650  }
651  }
652 
653  // We block to avoid more than one processor opening the file at a time.
654  m_comm->Block();
655  }
656 
657  // Write the DECOMPOSITION dataset
658  if (amRoot)
659  {
660  H5::PListSharedPtr serialProps = H5::PList::Default();
662 
663  // Reopen the file
664  H5::FileSharedPtr outfile =
665  H5::File::Open(outFile, H5F_ACC_RDWR, serialProps);
666  ASSERTL1(outfile, prfx.str() + "cannot open HDF5 file.");
667  H5::GroupSharedPtr root = outfile->OpenGroup("NEKTAR");
668  ASSERTL1(root, prfx.str() + "cannot open root group.");
669 
670  // Write the DECOMPOSITION dataset
671  H5::DataSetSharedPtr decomps_dset = root->OpenDataSet("DECOMPOSITION");
672  ASSERTL1(decomps_dset,
673  prfx.str() + "cannot open DECOMPOSITION dataset.");
674 
675  H5::DataSpaceSharedPtr decomps_fspace = decomps_dset->GetSpace();
676  ASSERTL1(decomps_fspace,
677  prfx.str() + "cannot open DECOMPOSITION filespace.");
678 
679  decomps_fspace->SelectRange(0, all_decomps.size());
680  decomps_dset->Write(all_decomps, decomps_fspace, writeSR);
681  }
682 
683  // Initialise the dataset indexes for all MPI processes
684  std::vector<uint64_t> idx = m_comm->Scatter(root_rank, all_idxs);
685  uint64_t ids_i = idx[IDS_IDX_IDX];
686  uint64_t data_i = idx[DATA_IDX_IDX];
687  uint64_t order_i = idx[ORDER_IDX_IDX];
688  uint64_t homy_i = idx[HOMY_IDX_IDX];
689  uint64_t homz_i = idx[HOMZ_IDX_IDX];
690  uint64_t homs_i = idx[HOMS_IDX_IDX];
691 
692  // Set properties for parallel file access (if we're in parallel)
693  H5::PListSharedPtr parallelProps = H5::PList::Default();
695  if (m_comm->GetSize() > 1)
696  {
697  // Use MPI/O to access the file
698  parallelProps = H5::PList::FileAccess();
699  parallelProps->SetMpio(m_comm);
700  // Use collective IO
701  writePL = H5::PList::DatasetXfer();
702  writePL->SetDxMpioCollective();
703  }
704 
705  // Reopen the file
706  H5::FileSharedPtr outfile =
707  H5::File::Open(outFile, H5F_ACC_RDWR, parallelProps);
708  ASSERTL1(outfile, prfx.str() + "cannot open HDF5 file.");
709  H5::GroupSharedPtr root = outfile->OpenGroup("NEKTAR");
710  ASSERTL1(root, prfx.str() + "cannot open root group.");
711 
712  m_comm->Block();
713 
714  // all HDF5 groups have now been created. Open the IDS dataset and
715  // associated data space
716  H5::DataSetSharedPtr ids_dset = root->OpenDataSet("ELEMENTIDS");
717  ASSERTL1(ids_dset, prfx.str() + "cannot open ELEMENTIDS dataset.");
718  H5::DataSpaceSharedPtr ids_fspace = ids_dset->GetSpace();
719  ASSERTL1(ids_fspace, prfx.str() + "cannot open ELEMENTIDS filespace.");
720 
721  // Open the DATA dataset and associated data space
722  H5::DataSetSharedPtr data_dset = root->OpenDataSet("DATA");
723  ASSERTL1(data_dset, prfx.str() + "cannot open DATA dataset.");
724  H5::DataSpaceSharedPtr data_fspace = data_dset->GetSpace();
725  ASSERTL1(data_fspace, prfx.str() + "cannot open DATA filespace.");
726 
727  // Open the optional datasets and data spaces.
728  H5::DataSetSharedPtr order_dset, homy_dset, homz_dset, homs_dset;
729  H5::DataSpaceSharedPtr order_fspace , homy_fspace, homz_fspace, homs_fspace;
730 
731  if (all_dsetsize[ORDER_CNT_IDX])
732  {
733  order_dset = root->OpenDataSet("POLYORDERS");
734  ASSERTL1(order_dset, prfx.str() + "cannot open POLYORDERS dataset.");
735  order_fspace = order_dset->GetSpace();
736  ASSERTL1(order_fspace, prfx.str() + "cannot open POLYORDERS filespace.");
737  }
738 
739  if (all_dsetsize[HOMY_CNT_IDX])
740  {
741  homy_dset = root->OpenDataSet("HOMOGENEOUSYIDS");
742  ASSERTL1(homy_dset, prfx.str() + "cannot open HOMOGENEOUSYIDS dataset.");
743  homy_fspace = homy_dset->GetSpace();
744  ASSERTL1(homy_fspace, prfx.str() + "cannot open HOMOGENEOUSYIDS filespace.");
745  }
746 
747  if (all_dsetsize[HOMZ_CNT_IDX])
748  {
749  homz_dset = root->OpenDataSet("HOMOGENEOUSZIDS");
750  ASSERTL1(homz_dset, prfx.str() + "cannot open HOMOGENEOUSZIDS dataset.");
751  homz_fspace = homz_dset->GetSpace();
752  ASSERTL1(homz_fspace, prfx.str() + "cannot open HOMOGENEOUSZIDS filespace.");
753  }
754 
755  if (all_dsetsize[HOMS_CNT_IDX])
756  {
757  homs_dset = root->OpenDataSet("HOMOGENEOUSSIDS");
758  ASSERTL1(homs_dset, prfx.str() + "cannot open HOMOGENEOUSSIDS dataset.");
759  homs_fspace = homs_dset->GetSpace();
760  ASSERTL1(homs_fspace, prfx.str() + "cannot open HOMOGENEOUSSIDS filespace.");
761  }
762 
763  // Write the data
764  for (int f = 0; f < nFields; ++f)
765  {
766  // write the element ids
767  std::size_t nFieldElems = fielddefs[f]->m_elementIDs.size();
768  ids_fspace->SelectRange(ids_i, nFieldElems);
769  ids_dset->Write(fielddefs[f]->m_elementIDs, ids_fspace, writePL);
770  ids_i += nFieldElems;
771 
772  // write the element values
773  std::size_t nFieldVals = fielddata[f].size();
774  data_fspace->SelectRange(data_i, nFieldVals);
775  data_dset->Write(fielddata[f], data_fspace, writePL);
776  data_i += nFieldVals;
777  }
778 
779  if (order_dset)
780  {
781  for (int f = 0; f < nFields; ++f)
782  {
783  std::size_t nOrders = numModesPerDirVar[f].size();
784  order_fspace->SelectRange(order_i, nOrders);
785  order_dset->Write(numModesPerDirVar[f], order_fspace, writePL);
786  order_i += nOrders;
787  }
788  }
789 
790  if (homy_dset)
791  {
792  for (int f = 0; f < nFields; ++f)
793  {
794  std::size_t nYIDs = homoYIDs[f].size();
795  homy_fspace->SelectRange(homy_i, nYIDs);
796  homy_dset->Write(homoYIDs[f], homy_fspace, writePL);
797  homy_i += nYIDs;
798  }
799  }
800 
801  if (homz_dset)
802  {
803  for (int f = 0; f < nFields; ++f)
804  {
805  std::size_t nZIDs = homoZIDs[f].size();
806  homz_fspace->SelectRange(homz_i, nZIDs);
807  homz_dset->Write(homoZIDs[f], homz_fspace, writePL);
808  homz_i += nZIDs;
809  }
810  }
811 
812  if (homs_dset)
813  {
814  for (int f = 0; f < nFields; ++f)
815  {
816  std::size_t nSIDs = homoSIDs[f].size();
817  homs_fspace->SelectRange(homs_i, nSIDs);
818  homs_dset->Write(homoSIDs[f], homs_fspace, writePL);
819  homs_i += nSIDs;
820  }
821  }
822 
823  for (int f = nFields; f < nMaxFields; ++f)
824  {
825  // this MPI process is handling fewer than nMaxFields fields
826  // so, since this is a collective operation
827  // just rewrite the element ids and values of the last field
828  ids_dset->Write(
829  fielddefs[nFields - 1]->m_elementIDs, ids_fspace, writePL);
830  data_dset->Write(fielddata[nFields - 1], data_fspace, writePL);
831  }
832 
833  m_comm->Block();
834 
835  // all data has been written
836  if (m_comm->GetRank() == 0)
837  {
838  tm1 = m_comm->Wtime();
839  cout << " (" << tm1 - tm0 << "s, HDF5)" << endl;
840  }
841 }
boost::shared_ptr< Group > GroupSharedPtr
Definition: FieldIOHdf5.h:50
static const unsigned int HOMY_CNT_IDX
A helper for FieldIOHdf5::v_Write. Describes the position of the number of homogeneous y-planes in th...
Definition: FieldIOHdf5.h:190
static FileSharedPtr Create(const std::string &filename, unsigned mode, PListSharedPtr createPL=PList::Default(), PListSharedPtr accessPL=PList::Default())
Definition: H5.cpp:555
static const unsigned int MAX_DCMPS
A helper for FieldIOHdf5::v_Write. Describes the maximum number of items in the decomposition per fie...
Definition: FieldIOHdf5.h:185
static const unsigned int HOMS_IDX_IDX
A helper for FieldIOHdf5::v_Write. Describes the position of the number of homogeneous strips within ...
Definition: FieldIOHdf5.h:200
static DataTypeSharedPtr OfObject(const T &obj)
Definition: H5.h:378
static const unsigned int ORDER_IDX_IDX
A helper for FieldIOHdf5::v_Write. Describes the position of the element order within the indexing se...
Definition: FieldIOHdf5.h:197
boost::shared_ptr< DataSet > DataSetSharedPtr
Definition: H5.h:100
boost::shared_ptr< File > FileSharedPtr
Definition: H5.h:98
boost::shared_ptr< DataType > DataTypeSharedPtr
Definition: H5.h:86
boost::shared_ptr< PList > PListSharedPtr
Definition: H5.h:102
int CheckFieldDefinition(const FieldDefinitionsSharedPtr &fielddefs)
Check field definitions for correctness and return storage size.
Definition: FieldIO.cpp:561
const char *const ShapeTypeMap[]
Definition: ShapeType.hpp:66
static const unsigned int HASH_DCMP_IDX
The hash of the field definition information, which defines the name of the attribute containing the ...
Definition: FieldIOHdf5.h:184
boost::shared_ptr< Comm > CommSharedPtr
Pointer to a Communicator object.
Definition: Comm.h:55
static const unsigned int FORMAT_VERSION
Version of the Nektar++ HDF5 format, which is embedded into the main NEKTAR group as an attribute...
Definition: FieldIOHdf5.h:176
boost::shared_ptr< DataSpace > DataSpaceSharedPtr
Definition: H5.h:88
static DataSpaceSharedPtr OneD(hsize_t size)
Definition: H5.cpp:403
static const unsigned int HOMY_IDX_IDX
A helper for FieldIOHdf5::v_Write. Describes the position of the number of y-planes within the indexi...
Definition: FieldIOHdf5.h:198
static const unsigned int MAX_IDXS
A helper for FieldIOHdf5::v_Write. Describes the maximum number of items in the indexing set...
Definition: FieldIOHdf5.h:201
static FileSharedPtr Open(const std::string &filename, unsigned mode, PListSharedPtr accessPL=PList::Default())
Definition: H5.cpp:563
static PListSharedPtr DatasetXfer()
Properties for raw data transfer.
Definition: H5.cpp:114
int GetSize(const ConstArray< OneD, NekDouble > &x)
Definition: StdExpUtil.cpp:111
static const unsigned int HOMZ_CNT_IDX
A helper for FieldIOHdf5::v_Write. Describes the position of the number of homogeneous z-planes in th...
Definition: FieldIOHdf5.h:191
static const unsigned int VAL_DCMP_IDX
A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of ...
Definition: FieldIOHdf5.h:179
static const unsigned int IDS_IDX_IDX
A helper for FieldIOHdf5::v_Write. Describes the position of the element IDs within the indexing set...
Definition: FieldIOHdf5.h:195
std::string SetUpOutput(const std::string outname, bool perRank, bool backup=false)
Set up the filesystem ready for output.
Definition: FieldIO.cpp:400
LibUtilities::CommSharedPtr m_comm
Communicator to use when writing parallel format.
Definition: FieldIO.h:265
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
static const unsigned int MAX_CNTS
A helper for FieldIOHdf5::v_Write. Describes the maximum number of items in the cnt array per field d...
Definition: FieldIOHdf5.h:193
static const unsigned int ELEM_CNT_IDX
A helper for FieldIOHdf5::v_Write. Describes the position of the number of elements in the cnt array...
Definition: FieldIOHdf5.h:187
static const unsigned int ORDER_CNT_IDX
A helper for FieldIOHdf5::v_Write. Describes the position of the number of order points in the cnt ar...
Definition: FieldIOHdf5.h:189
static const unsigned int HOMY_DCMP_IDX
A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of ...
Definition: FieldIOHdf5.h:181
static const unsigned int DATA_IDX_IDX
A helper for FieldIOHdf5::v_Write. Describes the position of the data size within the indexing set...
Definition: FieldIOHdf5.h:196
static const unsigned int HOMS_CNT_IDX
A helper for FieldIOHdf5::v_Write. Describes the position of the number of homogeneous strips in the ...
Definition: FieldIOHdf5.h:192
static const unsigned int HOMZ_DCMP_IDX
A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of ...
Definition: FieldIOHdf5.h:182
static const unsigned int ELEM_DCMP_IDX
A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of ...
Definition: FieldIOHdf5.h:178
static const unsigned int HOMZ_IDX_IDX
A helper for FieldIOHdf5::v_Write. Describes the position of the number of z-planes within the indexi...
Definition: FieldIOHdf5.h:199
static PListSharedPtr FileAccess()
Properties for file access.
Definition: H5.cpp:96
boost::shared_ptr< TagWriter > TagWriterSharedPtr
Definition: FieldIO.h:71
static const unsigned int HOMS_DCMP_IDX
A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of ...
Definition: FieldIOHdf5.h:183
static const unsigned int ORDER_DCMP_IDX
A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of ...
Definition: FieldIOHdf5.h:180
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
void AddInfoTag(TagWriterSharedPtr root, const FieldMetaDataMap &fieldmetadatamap)
Add provenance information to the field metadata map.
Definition: FieldIO.cpp:334
static const unsigned int VAL_CNT_IDX
A helper for FieldIOHdf5::v_Write. Describes the position of the number of data points in the cnt arr...
Definition: FieldIOHdf5.h:188
static PListSharedPtr Default()
Default options.
Definition: H5.cpp:78

Member Data Documentation

std::string Nektar::LibUtilities::FieldIOHdf5::className
static
Initial value:
=
"Hdf5", FieldIOHdf5::create, "HDF5-based output of field data.")

Name of class.

Definition at line 212 of file FieldIOHdf5.h.

Referenced by GetClassName().

const unsigned int Nektar::LibUtilities::FieldIOHdf5::DATA_IDX_IDX = 1
static

A helper for FieldIOHdf5::v_Write. Describes the position of the data size within the indexing set.

Definition at line 196 of file FieldIOHdf5.h.

Referenced by v_Write().

const unsigned int Nektar::LibUtilities::FieldIOHdf5::ELEM_CNT_IDX = 0
static

A helper for FieldIOHdf5::v_Write. Describes the position of the number of elements in the cnt array.

Definition at line 187 of file FieldIOHdf5.h.

Referenced by v_Write().

const unsigned int Nektar::LibUtilities::FieldIOHdf5::ELEM_DCMP_IDX = 0
static

A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of elements in decomposition (i.e. field definition).

Definition at line 178 of file FieldIOHdf5.h.

Referenced by v_Import(), and v_Write().

const unsigned int Nektar::LibUtilities::FieldIOHdf5::FORMAT_VERSION = 1
static

Version of the Nektar++ HDF5 format, which is embedded into the main NEKTAR group as an attribute.

Definition at line 176 of file FieldIOHdf5.h.

Referenced by v_Import(), and v_Write().

const unsigned int Nektar::LibUtilities::FieldIOHdf5::HASH_DCMP_IDX = 6
static

The hash of the field definition information, which defines the name of the attribute containing the field definition itself.

Definition at line 184 of file FieldIOHdf5.h.

Referenced by v_Import(), and v_Write().

const unsigned int Nektar::LibUtilities::FieldIOHdf5::HOMS_CNT_IDX = 5
static

A helper for FieldIOHdf5::v_Write. Describes the position of the number of homogeneous strips in the cnt array.

Definition at line 192 of file FieldIOHdf5.h.

Referenced by v_Write().

const unsigned int Nektar::LibUtilities::FieldIOHdf5::HOMS_DCMP_IDX = 5
static

A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of the number of strips for homogeneous simulations.

Definition at line 183 of file FieldIOHdf5.h.

Referenced by ImportFieldDef(), v_Import(), and v_Write().

const unsigned int Nektar::LibUtilities::FieldIOHdf5::HOMS_IDX_IDX = 5
static

A helper for FieldIOHdf5::v_Write. Describes the position of the number of homogeneous strips within the indexing set.

Definition at line 200 of file FieldIOHdf5.h.

Referenced by v_Write().

const unsigned int Nektar::LibUtilities::FieldIOHdf5::HOMY_CNT_IDX = 3
static

A helper for FieldIOHdf5::v_Write. Describes the position of the number of homogeneous y-planes in the cnt array.

Definition at line 190 of file FieldIOHdf5.h.

Referenced by v_Write().

const unsigned int Nektar::LibUtilities::FieldIOHdf5::HOMY_DCMP_IDX = 3
static

A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of the number of y-planes for homogeneous simulations.

Definition at line 181 of file FieldIOHdf5.h.

Referenced by ImportFieldDef(), v_Import(), and v_Write().

const unsigned int Nektar::LibUtilities::FieldIOHdf5::HOMY_IDX_IDX = 3
static

A helper for FieldIOHdf5::v_Write. Describes the position of the number of y-planes within the indexing set.

Definition at line 198 of file FieldIOHdf5.h.

Referenced by v_Write().

const unsigned int Nektar::LibUtilities::FieldIOHdf5::HOMZ_CNT_IDX = 4
static

A helper for FieldIOHdf5::v_Write. Describes the position of the number of homogeneous z-planes in the cnt array.

Definition at line 191 of file FieldIOHdf5.h.

Referenced by v_Write().

const unsigned int Nektar::LibUtilities::FieldIOHdf5::HOMZ_DCMP_IDX = 4
static

A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of the number of z-planes for homogeneous simulations.

Definition at line 182 of file FieldIOHdf5.h.

Referenced by ImportFieldDef(), v_Import(), and v_Write().

const unsigned int Nektar::LibUtilities::FieldIOHdf5::HOMZ_IDX_IDX = 4
static

A helper for FieldIOHdf5::v_Write. Describes the position of the number of z-planes within the indexing set.

Definition at line 199 of file FieldIOHdf5.h.

Referenced by v_Write().

const unsigned int Nektar::LibUtilities::FieldIOHdf5::IDS_IDX_IDX = 0
static

A helper for FieldIOHdf5::v_Write. Describes the position of the element IDs within the indexing set.

Definition at line 195 of file FieldIOHdf5.h.

Referenced by v_Write().

const unsigned int Nektar::LibUtilities::FieldIOHdf5::MAX_CNTS = FieldIOHdf5::HOMS_CNT_IDX + 1
static

A helper for FieldIOHdf5::v_Write. Describes the maximum number of items in the cnt array per field definition.

Definition at line 193 of file FieldIOHdf5.h.

Referenced by v_Write().

const unsigned int Nektar::LibUtilities::FieldIOHdf5::MAX_DCMPS = FieldIOHdf5::HASH_DCMP_IDX + 1
static

A helper for FieldIOHdf5::v_Write. Describes the maximum number of items in the decomposition per field definition.

Definition at line 185 of file FieldIOHdf5.h.

Referenced by ImportFieldData(), ImportFieldDef(), v_Import(), and v_Write().

const unsigned int Nektar::LibUtilities::FieldIOHdf5::MAX_IDXS = FieldIOHdf5::HOMS_IDX_IDX + 1
static

A helper for FieldIOHdf5::v_Write. Describes the maximum number of items in the indexing set.

Definition at line 201 of file FieldIOHdf5.h.

Referenced by v_Write().

const unsigned int Nektar::LibUtilities::FieldIOHdf5::ORDER_CNT_IDX = 2
static

A helper for FieldIOHdf5::v_Write. Describes the position of the number of order points in the cnt array.

Definition at line 189 of file FieldIOHdf5.h.

Referenced by v_Write().

const unsigned int Nektar::LibUtilities::FieldIOHdf5::ORDER_DCMP_IDX = 2
static

A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of elements multiplied by the dimension of the element, giving number of modes when variable polynomial order is defined.

Definition at line 180 of file FieldIOHdf5.h.

Referenced by ImportFieldDef(), v_Import(), and v_Write().

const unsigned int Nektar::LibUtilities::FieldIOHdf5::ORDER_IDX_IDX = 2
static

A helper for FieldIOHdf5::v_Write. Describes the position of the element order within the indexing set.

Definition at line 197 of file FieldIOHdf5.h.

Referenced by v_Write().

const unsigned int Nektar::LibUtilities::FieldIOHdf5::VAL_CNT_IDX = 1
static

A helper for FieldIOHdf5::v_Write. Describes the position of the number of data points in the cnt array.

Definition at line 188 of file FieldIOHdf5.h.

Referenced by v_Write().

const unsigned int Nektar::LibUtilities::FieldIOHdf5::VAL_DCMP_IDX = 1
static

A helper for FieldIOHdf5::v_Write and FieldIOHdf5::v_Import. Describes the position of the number of data points in decomposition (i.e. field definition).

Definition at line 179 of file FieldIOHdf5.h.

Referenced by ImportFieldData(), v_Import(), and v_Write().