PlasCom2  1.0
XPACC Multi-physics simluation application
PCPPHDF5.H
Go to the documentation of this file.
1 #ifndef __PCPP_HDF5_H__
2 #define __PCPP_HDF5_H__
3 
4 #include "PCPPTypes.H"
5 #include "PCPPFieldData.H"
6 #include "PCPPIO.H"
7 #include "hdf5.h"
8 
9 namespace pcpp
10 {
11  namespace io
12  {
13  namespace xdmf
14  {
15  void OpenFileTag(std::ostream &outStream);
16  void CloseFileTag(std::ostream &outStream);
17  void OpenGridTag(const std::string &gridName,const std::string &gridType,
18  double inTime,std::ostream &outStream);
19  void CloseGridTag(std::ostream &outStream);
20 
21  // deprecated - do not use
22  int WriteGridSection(const std::string &topoType,const std::string &geomType,
23  const std::string &fileName,const std::string &gridPath,
24  const std::vector<size_t> &gridSize,std::ostream &outStream);
25 
26  int WriteGridSection(const std::string &topoType,
27  const std::string &fileName,
28  const std::string &gridPath,
29  const std::vector<size_t> &gridSize,
30  std::ostream &outStream);
31 
32  int WriteGridData(const std::string &fileName,const std::string &dataName,unsigned int dataSize,
33  const std::string &dataPath,const std::vector<size_t> &gridSize,std::ostream &outStream);
34 
35 
36 
37  template<typename GridType,typename StateType>
38  void WriteSimulationFile(const std::string &h5FileName,
39  const std::string &gridName,
40  const std::string &gridPath,
41  const std::string &dataPath,
42  const GridType &inGrid,
43  const StateType &inState)
44  {
45 
46  std::string xdmfFileName(h5FileName.substr(0,h5FileName.find_last_of(".")));
47  xdmfFileName += ".xdmf";
48 
49  std::string h5RelativeName = h5FileName.substr(h5FileName.find_last_of("/")+1);
50 
51  std::ofstream xdmfStream;
52  xdmfStream.open(xdmfFileName.c_str());
53 
54  pcpp::io::xdmf::OpenFileTag(xdmfStream);
55  double simTime = 0.0;
56  int timeHandle = inState.GetDataIndex("simTime");
57  if(timeHandle >= 0){
58  const double *timePtr = inState.template GetFieldBuffer<double>("simTime");
59  simTime = *timePtr;
60  }
61  int numDim = inGrid.Dimension();
62  pcpp::io::xdmf::OpenGridTag(gridName,"Uniform",simTime,xdmfStream);
63  std::ostringstream topoTypeStream;
64  topoTypeStream << numDim << "DSMesh";
65  std::vector<size_t> rGridSizes(inGrid.GridSizes());
66  std::reverse(rGridSizes.begin(),rGridSizes.end());
67  pcpp::io::xdmf::WriteGridSection(topoTypeStream.str(),h5RelativeName,gridPath,
68  rGridSizes,xdmfStream);
69 
70  const pcpp::field::metadataset &stateMetaData(inState.Meta());
71  pcpp::field::metadataset::const_iterator mdIt = stateMetaData.begin();
72  while(mdIt != stateMetaData.end()){
73  const pcpp::field::metadata &fieldMetaData(*mdIt++);
74  if(fieldMetaData.loc == 'n'){
75  const std::string &fieldName(fieldMetaData.name);
76  const std::string attributeName(dataPath+"/"+fieldName);
77  size_t numData = fieldMetaData.ncomp;
78  std::vector<size_t> attributeSize(1,numData);
79 
80  for(int iComp = 0;iComp < numData;iComp++){
81  std::ostringstream Ostr;
82  Ostr << fieldName;
83  if(numData > 1)
84  Ostr << "-" << iComp+1;
85  std::string componentName(Ostr.str());
86  std::string fieldPath(dataPath+"/"+componentName);
87  pcpp::io::xdmf::WriteGridData(h5RelativeName,componentName,fieldMetaData.dsize,
88  fieldPath,rGridSizes,xdmfStream);
89  }
90  }
91  }
92  pcpp::io::xdmf::CloseGridTag(xdmfStream);
93  pcpp::io::xdmf::CloseFileTag(xdmfStream);
94  xdmfStream.close();
95  };
96 
98  template<typename DomainType>
99  void WriteDomainFile(const std::string &h5FileName,
100  DomainType &inDomain)
101  {
102 
103  std::string xdmfFileName(h5FileName.substr(0,h5FileName.find_last_of(".")));
104  xdmfFileName += ".xdmf";
105 
106  std::string h5RelativeName = h5FileName.substr(h5FileName.find_last_of("/")+1);
107 
108  std::ofstream xdmfStream;
109  xdmfStream.open(xdmfFileName.c_str());
110 
111  pcpp::io::xdmf::OpenFileTag(xdmfStream);
112  double simTime = inDomain.Time();
113  int numGrids = inDomain.NumberOfGrids();
114  const std::string domainName(inDomain.Name());
115  const std::vector<std::string> scalarNames(inDomain.ScalarNames());
116 
117  for(int iGrid = 0;iGrid < numGrids;iGrid++){
118  std::ostringstream gridNameStream;
119  gridNameStream << "grid" << iGrid+1;
120  std::string gridName(gridNameStream.str());
121  typename DomainType::GridType &currentGrid(inDomain.Grid(iGrid));
122  typename DomainType::StateType &currentState(inDomain.State(iGrid));
123  int numDim = currentGrid.Dimension();
124  const std::string fullGridName(inDomain.GridName(iGrid));
125  std::string::size_type x = fullGridName.find_last_of(":");
126  const std::string geometryName(fullGridName.substr(0,x));
127  const std::string geomGridName(fullGridName.substr(x+1));
128  const std::string gridPath("/PlasCom2/Geometry/"+geometryName+"/"+geomGridName);
129  const std::string dataPath("/PlasCom2/Simulation/"+domainName+"/"+gridName);
130  pcpp::io::xdmf::OpenGridTag(gridName,"Uniform",simTime,xdmfStream);
131  std::ostringstream topoTypeStream;
132  topoTypeStream << numDim << "DSMesh";
133  std::vector<size_t> rGridSizes(currentGrid.GridSizes());
134  std::reverse(rGridSizes.begin(),rGridSizes.end());
135  pcpp::io::xdmf::WriteGridSection(topoTypeStream.str(),h5RelativeName,gridPath,
136  rGridSizes,xdmfStream);
137 
138  const pcpp::field::metadataset &stateMetaData(currentState.Meta());
139  pcpp::field::metadataset::const_iterator mdIt = stateMetaData.begin();
140  while(mdIt != stateMetaData.end()){
141  const pcpp::field::metadata &fieldMetaData(*mdIt++);
142  if(fieldMetaData.loc == 'n'){
143  const std::string &fieldName(fieldMetaData.name);
144  const std::string attributeName(dataPath+"/"+fieldName);
145  size_t numData = fieldMetaData.ncomp;
146  std::vector<size_t> attributeSize(1,numData);
147  bool renameField = false;
148  std::vector<std::string> renameNames;
149  if(fieldName == "scalarVars"){
150  if(scalarNames.size() == numData)
151  renameField = true;
152  renameNames = scalarNames;
153  }
154  for(int iComp = 0;iComp < numData;iComp++){
155  std::ostringstream Ostr;
156  Ostr << fieldName;
157  if(numData > 1)
158  Ostr << "-" << iComp+1;
159  std::string componentName(Ostr.str());
160  std::string fieldPath(dataPath+"/"+componentName);
161  if(renameField){
162  componentName = renameNames[iComp];
163  }
164  pcpp::io::xdmf::WriteGridData(h5RelativeName,componentName,fieldMetaData.dsize,
165  fieldPath,rGridSizes,xdmfStream);
166  }
167  }
168  }
169  pcpp::io::xdmf::CloseGridTag(xdmfStream);
170  }
171  pcpp::io::xdmf::CloseFileTag(xdmfStream);
172  xdmfStream.close();
173  };
174  }
175 
176  namespace hdf5 {
177 
178  class base {
179 
180  public:
181 
182  base() : commPtr(NULL), dataTransferProperties(-1), globalSlab(-1),
183  localSlab(-1), collectiveMode(false)
184  {
185  messageStreamPtr = &messageStream;
186  };
187 
188  base(fixtures::CommunicatorType &inComm) : commPtr(&inComm), dataTransferProperties(-1),
189  globalSlab(-1), localSlab(-1), collectiveMode(true)
190  {
191  messageStreamPtr = &messageStream;
192  };
193 
194  base(const std::string &inName) : commPtr(NULL),dataTransferProperties(-1),
195  globalSlab(-1), localSlab(-1),
196  fileName(inName), collectiveMode(false)
197  {
198  messageStreamPtr = &messageStream;
199  if(ix::sys::FILEEXISTS(inName)){
200  Open(inName);
201  } else {
202  Create(inName,true);
203  }
204  };
205 
206  base(const std::string &inName,bool readOnly) : commPtr(NULL),dataTransferProperties(-1),
207  globalSlab(-1), localSlab(-1),
208  fileName(inName), collectiveMode(false)
209  {
210  messageStreamPtr = &messageStream;
211  if(ix::sys::FILEEXISTS(inName)){
212  Open(inName,readOnly);
213  } else if (!readOnly) {
214  Create(inName,true);
215  }
216  };
217 
218  base(const std::string &inName,fixtures::CommunicatorType &inComm) :
219  commPtr(&inComm),dataTransferProperties(-1),
220  globalSlab(-1), localSlab(-1),
221  fileName(inName), collectiveMode(true)
222  {
223  messageStreamPtr = &messageStream;
224  if(ix::sys::FILEEXISTS(inName)){
225  Open(inName);
226  } else {
227  Create(inName,true);
228  }
229  };
230 
231  std::string Name() { return(fileName); };
232 
233  void SetMessageStream(std::ostream &outStream)
234  {
235  messageStreamPtr = &outStream;
236  };
237  std::string Messages()
238  {
239  return(messageStream.str());
240  }
241  void ClearMessages(){
242  pcpp::io::RenewStream(messageStream);
243  }
244  void SetCollectiveMode(bool yesNo = true)
245  {
246 
247  collectiveMode = yesNo;
248  // if(H5Pset_dxpl_mpio(dataTransferProperties, H5FD_MPIO_COLLECTIVE) < 0){
249  // *messageStreamPtr << "Unable to set HDF5 to COLLECTIVE mode."
250  // << std::endl;
251  // return(1);
252  // }
253  // return(0);
254  };
255 
256  void SetCommunicator(fixtures::CommunicatorType &inCommunicator)
257  {
258  commPtr = &inCommunicator;
259  };
260 
261  int Create(const std::string &inFileName,fixtures::CommunicatorType &inComm,
262  bool force = false)
263  {
264  Close();
265  SetCommunicator(inComm);
266  return(Create(inFileName,force));
267  };
268 
269  int Create(const std::string &inFileName,bool force=false);
270 
271  hid_t OpenAttribute(const std::string &inName);
272 
273  hid_t OpenDataSet(const std::string &inName);
274 
275  int Open(const std::string &inFileName,fixtures::CommunicatorType &inComm,bool readOnly = false)
276  {
277  Close();
278  SetCommunicator(inComm);
279  return(Open(inFileName,readOnly));
280  };
281 
282  int Open(const std::string &inFileName,bool readOnly = false);
283 
284  int Close();
285 
286  int OpenGroup(const std::string &groupName);
287 
288  int CloseGroup()
289  {
290  H5Gclose(hdfScope.back());
291  hdfScope.pop_back();
292  return(0);
293  };
294 
295  bool AttributeExists(const std::string &inName);
296 
297  bool Exists(const std::string &linkName);
298 
299  int ResolveName(const std::string &inName,std::string &attLocation,
300  std::string &attName,hid_t &parentId);
301 
302  int ReadAttribute(const std::string &inName,int *inBuf);
303 
304  int ReadAttribute(const std::string &inName,size_t *inBuf);
305 
306  int ReadAttribute(const std::string &inName,double *inBuf);
307 
308  int ReadAttribute(const std::string &inName,char *inBuf);
309  int ReadAttribute(const std::string &inName,std::string &inString);
310 
311  template<typename DataType>
312  int ReadAttribute(const std::string &inName,std::vector<DataType> &inData)
313  {
314  std::ostream &messageStream(*messageStreamPtr);
315  hid_t attID = OpenAttribute(inName);
316  if(attID < 0)
317  return(-1);
318  hid_t attSpace = H5Aget_space(attID);
319  if(attSpace < 0){
320  H5Aclose(attID);
321  return(-1);
322  }
323  int numSpaceDim = H5Sget_simple_extent_ndims(attSpace);
324  if(numSpaceDim <= 0){
325  H5Sclose(attSpace);
326  H5Aclose(attID);
327  return(-1);
328  }
329  std::vector<hsize_t> spaceDims(numSpaceDim,0);
330  herr_t h5Status = H5Sget_simple_extent_dims(attSpace,&spaceDims[0],NULL);
331  if(h5Status < 0){
332  H5Sclose(attSpace);
333  H5Aclose(attID);
334  return(-1);
335  }
336  size_t numPoints = 1;
337  for(size_t iDim = 0;iDim < numSpaceDim;iDim++)
338  numPoints *= spaceDims[iDim];
339  inData.resize(numPoints);
340  H5Sclose(attSpace);
341  H5Aclose(attID);
342  return(ReadAttribute(inName,&inData[0]));
343  };
344 
345  hid_t DataSpace(const std::string &inName);
346  std::vector<size_t> DataDimensions(const std::string &inName);
347  std::vector<size_t> AttributeDimensions(const std::string &inName);
348 
349  int InitializeHyperSlab(std::vector<size_t> &inGlobalSize,
350  std::vector<size_t> &inLocalSize,
351  std::vector<size_t> &inLocalStart);
352 
353  int WriteHyperSlab(const std::string &inName,
354  const std::vector<size_t> &globalSize,
355  const std::vector<size_t> &localStart,
356  const std::vector<size_t> &localSize,
357  std::vector<double> &inDataVec);
358 
359  int WriteHyperSlab(const std::string &inName,
360  const std::vector<size_t> &globalSize,
361  const std::vector<size_t> &localStart,
362  const std::vector<size_t> &localSize,
363  const double *inDataPtr);
364 
365  int WriteHyperSlab(const std::string &inName,
366  const std::vector<size_t> &globalSize,
367  const std::vector<size_t> &localStart,
368  const std::vector<size_t> &localSize,
369  const std::vector<size_t> &bufferStart,
370  const std::vector<size_t> &bufferSize,
371  const int *inDataPtr);
372 
373  int WriteHyperSlab(const std::string &inName,
374  const std::vector<size_t> &globalSize,
375  const std::vector<size_t> &localStart,
376  const std::vector<size_t> &localSize,
377  const std::vector<size_t> &bufferStart,
378  const std::vector<size_t> &bufferSize,
379  const char *inDataPtr);
380 
381  int WriteHyperSlab(const std::string &inName,
382  const std::vector<size_t> &globalSize,
383  const std::vector<size_t> &localStart,
384  const std::vector<size_t> &localSize,
385  const std::vector<size_t> &bufferStart,
386  const std::vector<size_t> &bufferSize,
387  const double *inDataPtr);
388 
389  int WriteHyperSlab(const std::string &inName,
390  const std::vector<size_t> &globalSize,
391  const std::vector<size_t> &localStart,
392  const std::vector<size_t> &localSize,
393  std::vector<int> &inDataVec);
394 
395  int WriteHyperSlab(const std::string &inName,
396  const std::vector<size_t> &globalSize,
397  const std::vector<size_t> &localStart,
398  const std::vector<size_t> &localSize,
399  std::vector<size_t> &inDataVec);
400 
401  int WriteHyperSlab(const std::string &inName,
402  const std::vector<size_t> &globalSize,
403  const std::vector<size_t> &localStart,
404  const std::vector<size_t> &localSize,
405  std::vector<char> &inDataVec);
406 
407  int WriteHyperSlab(const std::string &inName,
408  const std::vector<size_t> &localStart,
409  const std::vector<size_t> &localSize,
410  std::vector<double> &inDataVec);
411 
412  int WriteHyperSlab(const std::string &inName,
413  const std::vector<size_t> &localStart,
414  const std::vector<size_t> &localSize,
415  std::vector<int> &inDataVec);
416 
417  int WriteHyperSlab(const std::string &inName,
418  const std::vector<size_t> &localStart,
419  const std::vector<size_t> &localSize,
420  std::vector<size_t> &inDataVec);
421 
422  int WriteHyperSlab(const std::string &inName,
423  const std::vector<size_t> &localStart,
424  const std::vector<size_t> &localSize,
425  std::vector<char> &inDataVec);
426 
427  int ReadDataSet(const std::string &inName,int *inBuf);
428  int ReadDataSet(const std::string &inName,double *inBuf);
429  int ReadDataSet(const std::string &inName,size_t *inBuf);
430  int ReadDataSet(const std::string &inName,char *inBuf);
431  // int ReadDataSet(const std::string &inName,std::string &inString);
432  int ReadHyperSlab(hid_t dataID,hid_t dataSpace,
433  hid_t hyperSlab,hid_t xferProperties,
434  double *dataBuffer)
435  {
436  return(H5Dread(dataID,H5T_NATIVE_DOUBLE,hyperSlab,
437  dataSpace,xferProperties,dataBuffer));
438  };
439  int ReadHyperSlab(hid_t dataID,hid_t dataSpace,
440  hid_t hyperSlab,hid_t xferProperties,
441  int *dataBuffer)
442  {
443  return(H5Dread(dataID,H5T_NATIVE_INT,hyperSlab,
444  dataSpace,xferProperties,dataBuffer));
445  };
446  int ReadHyperSlab(hid_t dataID,hid_t dataSpace,
447  hid_t hyperSlab,hid_t xferProperties,
448  size_t *dataBuffer)
449  {
450  return(H5Dread(dataID,H5T_NATIVE_HSIZE,hyperSlab,
451  dataSpace,xferProperties,dataBuffer));
452  };
453  int ReadHyperSlab(hid_t dataID,hid_t dataSpace,
454  hid_t hyperSlab,hid_t xferProperties,
455  char *dataBuffer)
456  {
457  return(H5Dread(dataID,H5T_NATIVE_CHAR,hyperSlab,
458  dataSpace,xferProperties,dataBuffer));
459  };
460 
461  template<typename DataType>
462  int ReadHyperSlab(const std::string &inName,
463  const std::vector<size_t> &localStart,
464  const std::vector<size_t> &localSize,
465  std::vector<DataType> &inDataVec)
466  {
467  std::ostream &messageStream(*messageStreamPtr);
468 
469  hid_t dataID = OpenDataSet(inName);
470  if(dataID < 0)
471  return(-1);
472 
473  size_t numDim = localStart.size();
474  if(localSize.size() != numDim){
475  H5Dclose(dataID);
476  return(-1);
477  }
478 
479  hid_t dataSpace = H5Dget_space(dataID);
480  if(dataSpace < 0){
481  H5Dclose(dataID);
482  return(-1);
483  }
484 
485  int numSpaceDim = H5Sget_simple_extent_ndims(dataSpace);
486  if(numSpaceDim != numDim){
487  H5Dclose(dataID);
488  return(-1);
489  }
490 
491  if(numSpaceDim <= 0){
492  H5Sclose(dataSpace);
493  H5Dclose(dataID);
494  return(-1);
495  }
496 
497  std::vector<hsize_t> h5LocalStart(localStart.begin(),localStart.end());
498  std::vector<hsize_t> h5LocalSize(localSize.begin(),localSize.end());
499  herr_t h5Status = H5Sselect_hyperslab(dataSpace,H5S_SELECT_SET,&h5LocalStart[0],
500  NULL,&h5LocalSize[0],NULL);
501  if(h5Status < 0){
502  H5Sclose(dataSpace);
503  H5Dclose(dataID);
504  return(-1);
505  }
506 
507  hid_t localMemSpace = H5Screate_simple(numDim,&h5LocalSize[0],NULL);
508  if(localMemSpace < 0){
509  H5Sclose(dataSpace);
510  H5Dclose(dataID);
511  return(-1);
512  }
513 
514  size_t numLocalPoints = 1;
515  for(size_t iDim = 0;iDim < numSpaceDim;iDim++)
516  numLocalPoints *= localSize[iDim];
517  inDataVec.resize(numLocalPoints,0);
518 
519  hid_t xferProperties = H5Pcreate(H5P_DATASET_XFER);
520  if(collectiveMode && (commPtr != NULL)){
521  H5Pset_dxpl_mpio(xferProperties,H5FD_MPIO_COLLECTIVE);
522  }
523 
524  h5Status = ReadHyperSlab(dataID,dataSpace,localMemSpace,xferProperties,&inDataVec[0]);
525 
526  H5Sclose(dataSpace);
527  H5Sclose(localMemSpace);
528  H5Pclose(xferProperties);
529  H5Dclose(dataID);
530 
531  if(h5Status < 0)
532  return(-1);
533 
534  return(0);
535  };
536 
537 
538  template<typename DataType>
539  int ReadHyperSlab(const std::string &inName,
540  const std::vector<size_t> &localStart,
541  const std::vector<size_t> &localSize,
542  const std::vector<size_t> &bufferStart,
543  const std::vector<size_t> &bufferSize,
544  std::vector<DataType> &inDataVec)
545  {
546  std::ostream &messageStream(*messageStreamPtr);
547 
548  hid_t dataID = OpenDataSet(inName);
549  if(dataID < 0)
550  return(-1);
551 
552  size_t numDim = localStart.size();
553  if(localSize.size() != numDim){
554  H5Dclose(dataID);
555  return(-1);
556  }
557 
558  hid_t dataSpace = H5Dget_space(dataID);
559  if(dataSpace < 0){
560  H5Dclose(dataID);
561  return(-1);
562  }
563 
564  int numSpaceDim = H5Sget_simple_extent_ndims(dataSpace);
565  if(numSpaceDim != numDim){
566  H5Dclose(dataID);
567  return(-1);
568  }
569 
570  if(numSpaceDim <= 0){
571  H5Sclose(dataSpace);
572  H5Dclose(dataID);
573  return(-1);
574  }
575 
576  std::vector<hsize_t> h5LocalStart(localStart.begin(),localStart.end());
577  std::vector<hsize_t> h5LocalSize(localSize.begin(),localSize.end());
578  herr_t h5Status = H5Sselect_hyperslab(dataSpace,H5S_SELECT_SET,&h5LocalStart[0],
579  NULL,&h5LocalSize[0],NULL);
580  if(h5Status < 0){
581  H5Sclose(dataSpace);
582  H5Dclose(dataID);
583  return(-1);
584  }
585 
586  std::vector<hsize_t> h5BufferStart(bufferStart.begin(),bufferStart.end());
587  std::vector<hsize_t> h5BufferSize(bufferSize.begin(),bufferSize.end());
588  hid_t localMemSpace = H5Screate_simple(numDim,&h5BufferSize[0],NULL);
589  if(localMemSpace < 0){
590  H5Sclose(dataSpace);
591  H5Dclose(dataID);
592  return(-1);
593  }
594 
595  h5Status = H5Sselect_hyperslab(localMemSpace,H5S_SELECT_SET,&h5BufferStart[0],
596  NULL,&h5BufferSize[0],NULL);
597  if(h5Status < 0){
598  H5Sclose(localMemSpace);
599  H5Sclose(dataSpace);
600  H5Dclose(dataID);
601  return(-1);
602  }
603 
604  size_t numLocalPoints = 1;
605  for(size_t iDim = 0;iDim < numSpaceDim;iDim++)
606  numLocalPoints *= localSize[iDim];
607  inDataVec.resize(numLocalPoints,0);
608 
609  hid_t xferProperties = H5Pcreate(H5P_DATASET_XFER);
610  if(collectiveMode && (commPtr != NULL)){
611  H5Pset_dxpl_mpio(xferProperties,H5FD_MPIO_COLLECTIVE);
612  }
613 
614  h5Status = ReadHyperSlab(dataID,dataSpace,localMemSpace,xferProperties,&inDataVec[0]);
615 
616  H5Sclose(dataSpace);
617  H5Sclose(localMemSpace);
618  H5Pclose(xferProperties);
619  H5Dclose(dataID);
620 
621  if(h5Status < 0)
622  return(-1);
623 
624  return(0);
625  };
626 
627  template<typename DataType>
628  int ReadHyperSlab(const std::string &inName,
629  const std::vector<size_t> &localStart,
630  const std::vector<size_t> &localSize,
631  const std::vector<size_t> &bufferStart,
632  const std::vector<size_t> &bufferSize,
633  DataType *readBuffer)
634  {
635 
636 // std::cout << "READ INTO HYPERSLAB" << std::endl;
637 
638 // std::cout << "Local Size: (";
639 // pcpp::io::DumpContents(std::cout,localSize,",");
640 // std::cout << ")" << std::endl;
641 
642 // std::cout << "Local Starts: (";
643 // pcpp::io::DumpContents(std::cout,localStart,",");
644 // std::cout << ")" << std::endl;
645 
646 // std::cout << "Buffer Size: (";
647 // pcpp::io::DumpContents(std::cout,bufferSize,",");
648 // std::cout << ")" << std::endl;
649 
650 // std::cout << "Buffer Starts: (";
651 // pcpp::io::DumpContents(std::cout,bufferStart,",");
652 // std::cout << ")" << std::endl;
653 
654  std::ostream &messageStream(*messageStreamPtr);
655 
656  hid_t dataID = OpenDataSet(inName);
657  if(dataID < 0)
658  return(-1);
659 
660  size_t numDim = localStart.size();
661  if(localSize.size() != numDim){
662  H5Dclose(dataID);
663  return(-1);
664  }
665 
666  hid_t dataSpace = H5Dget_space(dataID);
667  if(dataSpace < 0){
668  H5Dclose(dataID);
669  return(-1);
670  }
671 
672  int numSpaceDim = H5Sget_simple_extent_ndims(dataSpace);
673  if(numSpaceDim != numDim){
674  H5Dclose(dataID);
675  return(-1);
676  }
677 
678  if(numSpaceDim <= 0){
679  H5Sclose(dataSpace);
680  H5Dclose(dataID);
681  return(-1);
682  }
683 
684  std::vector<hsize_t> h5LocalStart(localStart.begin(),localStart.end());
685  std::vector<hsize_t> h5LocalSize(localSize.begin(),localSize.end());
686 // std::cout << "Selecting file hyperslab: (";
687 // pcpp::io::DumpContents(std::cout,h5LocalStart,",");
688 // std::cout << ") + (";
689 // pcpp::io::DumpContents(std::cout,h5LocalSize,",");
690 // std::cout << ")" << std::endl;
691 
692  herr_t h5Status = H5Sselect_hyperslab(dataSpace,H5S_SELECT_SET,&h5LocalStart[0],
693  NULL,&h5LocalSize[0],NULL);
694  if(h5Status < 0){
695  H5Sclose(dataSpace);
696  H5Dclose(dataID);
697  return(-1);
698  }
699 
700  std::vector<hsize_t> h5BufferStart(bufferStart.begin(),bufferStart.end());
701  std::vector<hsize_t> h5BufferSize(bufferSize.begin(),bufferSize.end());
702  hid_t localMemSpace = H5Screate_simple(numDim,&h5BufferSize[0],NULL);
703 
704  if(localMemSpace < 0){
705  H5Sclose(dataSpace);
706  H5Dclose(dataID);
707  return(-1);
708  }
709 
710 // std::cout << "Selecting memory hyperslab: (";
711 // pcpp::io::DumpContents(std::cout,h5BufferStart,",");
712 // std::cout << ") + (";
713 // pcpp::io::DumpContents(std::cout,h5BufferSize,",");
714 // std::cout << ")" << std::endl;
715  h5Status = H5Sselect_hyperslab(localMemSpace,H5S_SELECT_SET,&h5BufferStart[0],
716  NULL,&h5LocalSize[0],NULL);
717  if(h5Status < 0){
718  H5Sclose(localMemSpace);
719  H5Sclose(dataSpace);
720  H5Dclose(dataID);
721  return(-1);
722  }
723 
724  hid_t xferProperties = H5Pcreate(H5P_DATASET_XFER);
725  if(collectiveMode && (commPtr != NULL)){
726  H5Pset_dxpl_mpio(xferProperties,H5FD_MPIO_COLLECTIVE);
727  }
728 
729  h5Status = ReadHyperSlab(dataID,dataSpace,localMemSpace,xferProperties,readBuffer);
730 
731  H5Sclose(dataSpace);
732  H5Sclose(localMemSpace);
733  H5Pclose(xferProperties);
734  H5Dclose(dataID);
735 
736  if(h5Status < 0)
737  return(-1);
738 
739  return(0);
740  };
741 
742  template<typename DataType>
743  int ReadHyperSlab(const std::string &inName,
744  const std::vector<size_t> &localStart,
745  const std::vector<size_t> &localSize,
746  DataType *readBuffer)
747  {
748 
749  std::ostream &messageStream(*messageStreamPtr);
750 
751  hid_t dataID = OpenDataSet(inName);
752  if(dataID < 0)
753  return(-1);
754 
755  size_t numDim = localStart.size();
756  if(localSize.size() != numDim){
757  H5Dclose(dataID);
758  return(-1);
759  }
760 
761  hid_t dataSpace = H5Dget_space(dataID);
762  if(dataSpace < 0){
763  H5Dclose(dataID);
764  return(-1);
765  }
766 
767  int numSpaceDim = H5Sget_simple_extent_ndims(dataSpace);
768  if(numSpaceDim != numDim){
769  H5Dclose(dataID);
770  return(-1);
771  }
772 
773  if(numSpaceDim <= 0){
774  H5Sclose(dataSpace);
775  H5Dclose(dataID);
776  return(-1);
777  }
778 
779  std::vector<hsize_t> h5LocalStart(localStart.begin(),localStart.end());
780  std::vector<hsize_t> h5LocalSize(localSize.begin(),localSize.end());
781  herr_t h5Status = H5Sselect_hyperslab(dataSpace,H5S_SELECT_SET,&h5LocalStart[0],
782  NULL,&h5LocalSize[0],NULL);
783  if(h5Status < 0){
784  H5Sclose(dataSpace);
785  H5Dclose(dataID);
786  return(-1);
787  }
788 
789  hid_t localMemSpace = H5Screate_simple(numDim,&h5LocalSize[0],NULL);
790  if(localMemSpace < 0){
791  H5Sclose(dataSpace);
792  H5Dclose(dataID);
793  return(-1);
794  }
795 
796  hid_t xferProperties = H5Pcreate(H5P_DATASET_XFER);
797  if(collectiveMode && (commPtr != NULL)){
798  H5Pset_dxpl_mpio(xferProperties,H5FD_MPIO_COLLECTIVE);
799  }
800 
801  h5Status = ReadHyperSlab(dataID,dataSpace,localMemSpace,xferProperties,readBuffer);
802 
803  H5Sclose(dataSpace);
804  H5Sclose(localMemSpace);
805  H5Pclose(xferProperties);
806  H5Dclose(dataID);
807 
808  if(h5Status < 0)
809  return(-1);
810 
811  return(0);
812  };
813 
814  template<typename DataType>
815  int ReadDataSet(const std::string &inName,std::vector<DataType> &inDataVec)
816  {
817  std::ostream &messageStream(*messageStreamPtr);
818  hid_t dataID = OpenDataSet(inName);
819  if(dataID < 0)
820  return(-1);
821 
822  hid_t dataSpace = H5Dget_space(dataID);
823  if(dataSpace < 0){
824  H5Dclose(dataID);
825  return(-1);
826  }
827  int numSpaceDim = H5Sget_simple_extent_ndims(dataSpace);
828  if(numSpaceDim <= 0){
829  H5Sclose(dataSpace);
830  H5Dclose(dataID);
831  return(-1);
832  }
833  std::vector<hsize_t> spaceDims(numSpaceDim,0);
834  herr_t h5Status = H5Sget_simple_extent_dims(dataSpace,&spaceDims[0],NULL);
835  if(h5Status < 0){
836  H5Sclose(dataSpace);
837  H5Dclose(dataID);
838  return(-1);
839  }
840  size_t numPoints = 1;
841  for(size_t iDim = 0;iDim < numSpaceDim;iDim++)
842  numPoints *= spaceDims[iDim];
843  inDataVec.resize(numPoints);
844  H5Sclose(dataSpace);
845  H5Dclose(dataID);
846  return(ReadDataSet(inName,&inDataVec[0]));
847  };
848 
849  int CreateGroup(const std::string &inName);
850 
851  hid_t CreateDataSpace(const std::vector<size_t> &spaceDimensions);
852 
853  int CreateDataSet(const std::string &inName,
854  const std::vector<size_t> &spaceDimensions,
855  size_t sizeInBytes=8);
856 
857  int CreateDataSet(const std::string &inName,
858  const std::vector<size_t> &spaceDimensions,
859  std::vector<double> &inData);
860 
861  int CreateDataSet(const std::string &inName,
862  const std::vector<size_t> &spaceDimensions,
863  std::vector<int> &inData);
864 
865  int CreateAttribute(const std::string &inName,
866  const std::vector<size_t> &spaceDimensions,
867  size_t sizeInBytes=8);
868 
869 
870  int CreateAttribute(const std::string &inName,
871  const std::vector<size_t> &spaceDimensions,
872  const int *inBuf);
873 
874  int CreateAttribute(const std::string &inName,
875  const std::vector<size_t> &spaceDimensions,
876  const std::vector<int> &inData);
877 
878  int CreateAttribute(const std::string &inName,
879  const std::vector<size_t> &spaceDimensions,
880  const double *inBuf);
881 
882  int CreateAttribute(const std::string &inName,
883  const std::vector<size_t> &spaceDimensions,
884  const std::vector<double> &inData);
885 
886  int CreateAttribute(const std::string &inName,
887  const std::vector<size_t> &spaceDimensions,
888  const size_t *inBuf);
889 
890  int CreateAttribute(const std::string &inName,
891  const std::vector<size_t> &spaceDimensions,
892  const std::vector<size_t> &inData);
893 
894  int CreateAttribute(const std::string &inName,
895  const std::vector<size_t> &spaceDimensions,
896  const char *inBuf);
897 
898  int CreateAttribute(const std::string &inName,const std::string &inData);
899  // int OpenDataSet(const std::string &dataSetName)
900  ~base() { Close(); };
901  protected:
902  std::string fileName;
903  std::vector<hid_t> hdfScope;
904  std::vector<hid_t> hdfAPL;
905 
906  hid_t dataTransferProperties;
907  hid_t globalSlab;
908  hid_t localSlab;
909  // hid_t dataSpace;
910  // hid_t dataSet;
911 
912  std::ostream *messageStreamPtr;
913  std::ostringstream messageStream;
914  fixtures::CommunicatorType *commPtr;
915  bool collectiveMode;
916  };
917 
918  struct configuration {
919  int collectiveMode;
920  };
921 
922  int FileInfo(const std::string &hdfFileName,pcpp::io::simfileinfo &fileInfo,std::ostream &messageStream);
923  int FileInfo(const std::string &hdfFileName,pcpp::io::simfileinfo &fileInfo,
924  fixtures::CommunicatorType &inComm,std::ostream &messageStream);
925 
926  template<typename GridType>
927  int ReadGrid(hid_t parentGroupID,
928  const configuration &hdfConfig,
929  const std::string &gridName,
930  GridType &gridData,
931  fixtures::CommunicatorType &inComm,
932  std::ostream &messageStream)
933  {
934 
935 
936  // pcpp::geometry::domaininfo &domainInfo(plascomDomain.Info());
937  // std::vector<std::string> &hdfGrids(domainInfo.gridsInFile[hdfFileName]);
938  // std::vector<std::string>::iterator hdfGridIt = hdfGrids.begin();
939  // while(hdfGridIt != hdfGrids.end()){
940  // std::string hdfGeometryName(*hdfGridIt++);
941  // pcpp::geometry::grid &currentGrid(plascomDomain.Grid(hdfGeometryName));
942  std::string hdfGroupName(gridName);
943 
944  // currentGrid.AllocateCoordinateData();
945 
946  // FunctionEntry("HDFGroupOpen");
947 
948  if(H5Lexists(parentGroupID,hdfGroupName.c_str(),H5P_DEFAULT) <= 0){
949  messageStream << "Grid group (" << hdfGroupName << ") does not exist in parent."
950  << std::endl;
951  return(1);
952  }
953 
954  hid_t hdfGroupID = H5Gopen(parentGroupID,hdfGroupName.c_str(),H5P_DEFAULT);
955  if(hdfGroupID < 0){
956  messageStream << "Unable to open group: " << hdfGroupName << std::endl;
957  return(1);
958  }
959 
960  hsize_t numPoints = gridData.BufferSize();
961  hsize_t numDim = gridData.Dimension();
962  const std::vector<size_t> &gridGlobalSizes(gridData.GridSizes());
963  const std::vector<size_t> &gridPartitionSizes(gridData.PartitionSizes());
964  const pcpp::IndexIntervalType &gridPartitionInterval(gridData.PartitionInterval());
965 
966  std::vector<hsize_t> globalSize(numDim,1);
967  std::vector<hsize_t> localSize(numDim,1);
968  std::vector<hsize_t> localStart(numDim,0);
969 
970  for(int i = 0;i < numDim;i++){
971  globalSize[i] = gridGlobalSizes[i];
972  localSize[i] = gridPartitionSizes[i];
973  localStart[i] = gridPartitionInterval[i].first;
974  }
975 
976  hid_t hdfGlobalGridID = H5Screate_simple(numDim,&globalSize[0],NULL);
977  if(hdfGlobalGridID < 0){
978  messageStream << "Unable to create HDF5 dataspace for global grid."
979  << std::endl;
980  return(1);
981  }
982 
983  hid_t hdfLocalGridID = H5Screate_simple(numDim,&localSize[0],NULL);
984  if(hdfLocalGridID < 0){
985  messageStream << "Unable to create HDF5 dataspace for local grid."
986  << std::endl;
987  return(1);
988  }
989 
990  if(H5Sselect_hyperslab(hdfGlobalGridID,H5S_SELECT_SET,
991  &localStart[0],NULL,&localSize[0],NULL) < 0){
992  messageStream << "Unable to select hyperslab." << std::endl;
993  return(1);
994  }
995 
996  hid_t hdfTransferPropertiesID = H5Pcreate(H5P_DATASET_XFER);
997  if(hdfTransferPropertiesID < 0){
998  messageStream << "Unable to create transfer properties object."
999  << std::endl;
1000  return(1);
1001  }
1002 
1003  if(hdfConfig.collectiveMode > 0){
1004  messageStream << "Setting HDF5 to COLLECTIVE mode." << std::endl;
1005  if(H5Pset_dxpl_mpio(hdfTransferPropertiesID, H5FD_MPIO_COLLECTIVE) < 0){
1006  messageStream << "Unable to set HDF5 to COLLECTIVE mode." << std::endl;
1007  return(1);
1008  }
1009  } else {
1010  messageStream << "Leaving HDF5 in ASYNCHRONOUS mode." << std::endl;
1011  }
1012 
1013  std::vector<std::string> coordinateLabels(4);
1014  coordinateLabels[0] = "X";
1015  coordinateLabels[1] = "Y";
1016  coordinateLabels[2] = "Z";
1017  coordinateLabels[3] = "XYZ";
1018  hid_t h5aplProperty = H5Pcreate(H5P_LINK_ACCESS);
1019  for(int iLabel = 0;iLabel < 4;iLabel++){
1020  if(H5Lexists(hdfGroupID,coordinateLabels[iLabel].c_str(),h5aplProperty) > 0){
1021  std::string &coordinateLabel(coordinateLabels[iLabel]);
1022  std::ostringstream rdOut;
1023  messageStream << rdOut.str() << std::endl;
1024  double *coordinateData = NULL;
1025  if(coordinateLabel == "X")
1026  coordinateData = gridData.CoordinateData(0);
1027  else if (coordinateLabel == "Y")
1028  coordinateData = gridData.CoordinateData(1);
1029  else if(coordinateLabel == "Z")
1030  coordinateData = gridData.CoordinateData(2);
1031  else if (coordinateLabel == "XYZ")
1032  coordinateData = new double [numDim*numPoints];
1033  // std::vector<double> &coordinateData(currentGrid.CoordinateData(iLabel+1));
1034  // if(iLabel == 4){
1035  // currentGrid.AllocateContiguousCoordinates();
1036  // }
1037  hid_t hdfCoordinateDataID = H5Dopen1(hdfGroupID,coordinateLabel.c_str());
1038  if(hdfCoordinateDataID < 0){
1039  messageStream << "Unable to open dataset for coordinate "
1040  << coordinateLabel << "." << std::endl;
1041  return(1);
1042  }
1043  if(H5Dread(hdfCoordinateDataID,H5T_NATIVE_DOUBLE,hdfLocalGridID,
1044  hdfGlobalGridID,hdfTransferPropertiesID,coordinateData) < 0){
1045  messageStream << "Read of data failed for coordinate " << coordinateLabel
1046  << "." << std::endl;
1047 
1048  return(1);
1049  }
1050  H5Dclose(hdfCoordinateDataID);
1051  if(coordinateLabel == "XYZ"){
1052  for(int iDim = 0;iDim < numDim;iDim++){
1053  double *coordData(gridData.CoordinateData(iDim));
1054  for(int iPoint = 0;iPoint < numPoints;iPoint++){
1055  coordData[iPoint] = coordinateData[numDim*iPoint+iDim];
1056  }
1057  }
1058  delete [] coordinateData;
1059  }
1060  }
1061  }
1062  std::string iblankLabel("IBLANK");
1063  if(H5Lexists(hdfGroupID,iblankLabel.c_str(),h5aplProperty) > 0){
1064  messageStream << "Reading IBLANK." << std::endl;
1065  std::vector<int> &flagData(gridData.FlagData());
1066  // flagData.resize(numPoints,0);
1067  hid_t hdfIBLANKDataID = H5Dopen1(hdfGroupID,iblankLabel.c_str());
1068  if(hdfIBLANKDataID < 0){
1069  messageStream << "Unable to open dataset for IBLANK." << std::endl;
1070  return(1);
1071  }
1072  if(H5Dread(hdfIBLANKDataID,H5T_NATIVE_INT,hdfLocalGridID,
1073  hdfGlobalGridID,hdfTransferPropertiesID,&flagData[0]) < 0){
1074  messageStream << "Reading IBLANK data failed." << std::endl;
1075  return(1);
1076 
1077  }
1078  H5Dclose(hdfIBLANKDataID);
1079  }
1080  H5Pclose(h5aplProperty);
1081  H5Pclose(hdfTransferPropertiesID);
1082  H5Sclose(hdfLocalGridID);
1083  H5Sclose(hdfGlobalGridID);
1084  H5Gclose(hdfGroupID);
1085  return(0);
1086  }
1087 
1088  template<typename GridType>
1089  int ParallelReadBlockStructuredGrid(const std::string &gridName,
1090  const std::string &parentGroupName,
1091  GridType &gridData,
1092  configuration &hdfConfig,
1093  const std::string &hdfFileName,
1094  fixtures::CommunicatorType &gridComm,
1095  std::ostream &messageStream)
1096  {
1097  hid_t propertyListID = H5Pcreate(H5P_FILE_ACCESS);
1098  if(propertyListID < 0){
1099  messageStream << "H5Pcreate failed." << std::endl;
1100  return(1);
1101  }
1102  if(H5Pset_fapl_mpio(propertyListID,gridComm.Comm(),MPI_INFO_NULL) < 0){
1103  messageStream << "H5Pset_fapl_mpio failed." << std::endl;
1104  return(1);
1105  }
1106  hid_t hdfFileID = H5Fopen(hdfFileName.c_str(),H5F_ACC_RDONLY,propertyListID);
1107  if(hdfFileID < 0){
1108  std::ostringstream Ostr;
1109  Ostr << "Could not open HDF5 file: " << hdfFileName << std::endl;
1110  messageStream << Ostr.str();
1111  return(1);
1112  }
1113  if(H5Pclose(propertyListID) < 0){
1114  messageStream << "Unable to close HDF5 property list." << std::endl;
1115  return(1);
1116  }
1117  hid_t parentGroupID = hdfFileID;
1118  if(!parentGroupName.empty()){
1119  std::ostringstream Ostr;
1120  Ostr << "/" << parentGroupName;
1121  parentGroupID = H5Gopen(hdfFileID,Ostr.str().c_str(),H5P_DEFAULT);
1122  if(parentGroupID < 0){
1123  messageStream << "Could not open parent group for grid." << std::endl;
1124  return(1);
1125  }
1126  }
1127  return(ReadGrid<GridType>(parentGroupID,hdfConfig,gridName,gridData,gridComm,messageStream));
1128  }
1129 
1130  template<typename GridType>
1131  int WriteGrid(const GridType &inGrid,const std::string &gridName,
1132  const std::string &parentPath,base &hdfFile)
1133  {
1134 
1135  if(!parentPath.empty())
1136  if(!hdfFile.Exists(parentPath))
1137  return(1);
1138 
1139  std::ostringstream Ostr;
1140  Ostr << parentPath << "/" << gridName;
1141  std::string fullPath(Ostr.str());
1142  Ostr.clear();
1143  Ostr.str("");
1144 
1145  hdfFile.CreateGroup(fullPath);
1146 
1147 
1148  const std::vector<size_t> &gridSize(inGrid.GridSizes());
1149  const std::vector<size_t> &partitionSize(inGrid.PartitionSizes());
1150 
1151  const std::vector<size_t> &bufferSize(inGrid.BufferSizes());
1152  const pcpp::IndexIntervalType &partitionBufferInterval(inGrid.PartitionBufferInterval());
1153 
1154 
1155  int numDim = gridSize.size();
1156 
1157  std::vector<size_t> rGridSize(gridSize);
1158  // std::vector<size_t> rPartSize(partitionSize);
1159  std::reverse(rGridSize.begin(),rGridSize.end());
1160  // std::reverse(rPartSize.begin(),rPartSize.end());
1161 
1162 
1163  std::vector<size_t> sizeAtt(1,numDim);
1164  std::vector<size_t> singleValueSize(1,1);
1165 
1166  Ostr << fullPath << "/numDim";
1167  hdfFile.CreateAttribute(Ostr.str(),singleValueSize,&numDim);
1168  Ostr.clear();
1169  Ostr.str("");
1170  Ostr << fullPath << "/gridSize";
1171  hdfFile.CreateAttribute(Ostr.str(),sizeAtt,&rGridSize[0]);
1172  Ostr.clear();
1173  Ostr.str("");
1174 
1175  const pcpp::IndexIntervalType &partitionExtent(inGrid.PartitionInterval());
1176  // const std::vector<size_t> &gridSizes(inGrid.GridSizes());
1177  pcpp::IndexIntervalType globalExtent;
1178  globalExtent.InitSimple(gridSize);
1179 
1180  // std::cout << "Grid global extent: ";
1181  // globalExtent.PrettyPrint(std::cout);
1182  // std::cout << "." << std::endl
1183  // << "Grid local extent: ";
1184  // partitionExtent.PrettyPrint(std::cout);
1185  // std::cout << "." << std::endl;
1186 
1187  int numLocalPoints = partitionExtent.NNodes();
1188 
1189  std::vector<size_t> localStart(partitionExtent.Starts());
1190  std::vector<size_t> rlocalStart(localStart);
1191  std::reverse(rlocalStart.begin(),rlocalStart.end());
1192  std::vector<size_t> localSize(partitionExtent.Sizes());
1193  std::vector<size_t> rlocalSize(localSize);
1194  std::reverse(rlocalSize.begin(),rlocalSize.end());
1195  std::vector<size_t> rBufferSize(bufferSize);
1196  std::reverse(rBufferSize.begin(),rBufferSize.end());
1197  std::vector<size_t> rBufferStart;
1198  if(!bufferSize.empty() && !partitionBufferInterval.empty())
1199  for(int iDim = numDim-1;iDim >= 0;iDim--)
1200  rBufferStart.push_back(partitionBufferInterval[iDim].first);
1201 
1202  for(int iDim = 0;iDim < numDim;iDim++){
1203  const double *coordinateData = inGrid.CoordinateData(iDim);
1204  Ostr.clear();
1205  Ostr.str("");
1206  Ostr << fullPath;
1207  if(iDim == 0) {
1208  Ostr << "/X";
1209  } else if (iDim == 1) {
1210  Ostr << "/Y";
1211  } else if (iDim == 2) {
1212  Ostr << "/Z";
1213  }
1214 
1215  // std::cout << "Writing hyperslab..." << iDim << std::endl;
1216  // std::cout << "Buffer Size: (";
1217  // pcpp::io::DumpContents(std::cout,rBufferSize,",");
1218  // std::cout << ")" << std::endl;
1219  // std::cout << "Buffer Start: (";
1220  // pcpp::io::DumpContents(std::cout,rBufferStart,",");
1221  // std::cout << ")" << std::endl;
1222  // std::cout << "Grid Size: (";
1223  // pcpp::io::DumpContents(std::cout,rGridSize,",");
1224  // std::cout << ")" << std::endl;
1225  // std::cout << "Partition Start: (";
1226  // pcpp::io::DumpContents(std::cout,rlocalStart,",");
1227  // std::cout << ")" << std::endl;
1228  // std::cout << "Partition Size: (";
1229  // pcpp::io::DumpContents(std::cout,rlocalSize,",");
1230  // std::cout << ")" << std::endl;
1231 
1232  if(!rBufferStart.empty())
1233  hdfFile.WriteHyperSlab(Ostr.str(),rGridSize,rlocalStart,rlocalSize,rBufferStart,rBufferSize,coordinateData);
1234  else
1235  hdfFile.WriteHyperSlab(Ostr.str(),rGridSize,rlocalStart,rlocalSize,coordinateData);
1236  }
1237  return 0;
1238  }
1239 
1240 // template<typename ConfigurableObjectType>
1241 // int Configure(ConfigurableObjectType &inObject,const std::string &configPath,base &hdfFile)
1242 // {
1243 // if(!hdfFile.Exists(configPath))
1244 // return(1);
1245 // pcpp::ConfigType objectConfig;
1246 // std::string configString2;
1247 // hdfFile.ReadAttribute(configPath,configString2);
1248 // std::istringstream configStream(configString2);
1249 // configStream >> objectConfig;
1250 // return(inObject.Configure(objectConfig));
1251 // };
1252 
1253 
1254  template<typename GridType>
1255  int ReadGrid(GridType &inGrid, const std::string &gridPath, base &hdfFile,bool reverseRead=true)
1256  {
1257 
1258  if(!hdfFile.Exists(gridPath))
1259  return(1);
1260 
1261  fixtures::CommunicatorType &gridComm(inGrid.Communicator());
1262  int myRank = 0;
1263  if(gridComm.Good())
1264  myRank = gridComm.Rank();
1265 
1266  std::ostringstream Ostr;
1267 
1268  // Configure the grid iff it has not yet been
1269  // if(!inGrid.Configured()){
1270  // if(hdfFile.Exists(gridPath+"/Configuration/Parameters")){
1271  // if(Configure<GridType>(inGrid,gridPath+"/Configuration/Parameters",hdfFile))
1272  // return(1);
1273  // } else {
1274  // int numDim = 0;
1275  // if(hdfFile.ReadAttribute(gridPath+"/numDim",&numDim))
1276  // return(1);
1277  // std::vector<size_t> rGridSize;
1278  // if(hdfFile.ReadAttribute(gridPath+"/gridSize",rGridSize))
1279  // return(1);
1280  // }
1281  // }
1282 
1283  int numDim = inGrid.NumDim();
1284 
1285  const std::vector<size_t> &gridSize(inGrid.GridSizes());
1286  const std::vector<size_t> &partitionSize(inGrid.PartitionSizes());
1287  const std::vector<size_t> &bufferSize(inGrid.BufferSizes());
1288  const pcpp::IndexIntervalType &partitionInterval(inGrid.PartitionInterval());
1289  const pcpp::IndexIntervalType &partitionBufferInterval(inGrid.PartitionBufferInterval());
1290  std::vector<size_t> bufferStarts(partitionBufferInterval.Starts());
1291  std::vector<size_t> partitionStarts(partitionInterval.Starts());
1292 
1293  bool useSimple = false;
1294  if(bufferStarts.empty() || bufferSize.empty() ||
1295  (partitionSize == bufferSize)){
1296  std::cout << "switching to use simple" << std::endl;
1297  useSimple = true;
1298  }
1299 
1300  std::vector<size_t> rGridSize(gridSize);
1301  std::vector<size_t> rPartSize(partitionSize);
1302  std::vector<size_t> rPartStart(partitionStarts);
1303  std::vector<size_t> rBufferSize(bufferSize);
1304  std::vector<size_t> rBufferStart(bufferStarts);
1305 
1306  // if(reverseRead){
1307  // std::cout << "reversing read order" << std::endl;
1308  std::reverse(rBufferStart.begin(),rBufferStart.end());
1309  std::reverse(rGridSize.begin(),rGridSize.end());
1310  std::reverse(rBufferSize.begin(),rBufferSize.end());
1311  std::reverse(rPartStart.begin(),rPartStart.end());
1312  std::reverse(rPartSize.begin(),rPartSize.end());
1313  // }
1314 
1315  // std::vector<size_t> sizeAtt(1,numDim);
1316  // std::vector<size_t> singleValueSize(1,1);
1317 
1318  // int fileNumDim = 0;
1319  // Ostr << gridPath << "/numDim";
1320  // if(hdfFile.ReadAttribute(Ostr.str(),&fileNumDim) < 0)
1321  // return(-1);
1322  // if(fileNumDim != numDim){
1323  // std::cout << "Number of dimensions in " << Ostr.str()
1324  // << " does not match requested grid ("
1325  // << numDim << ")." << std::endl;
1326  // return(2);
1327  // }
1328  // Ostr.clear();
1329  // Ostr.str("");
1330 
1331  std::vector<size_t> fileGridSize(numDim,0);
1332  Ostr << gridPath << "/gridSize";
1333  hdfFile.ReadAttribute(Ostr.str(),&fileGridSize[0]);
1334  if(rGridSize != fileGridSize){
1335  if(myRank == 0){
1336  std::cout << "WARNING: Grid dimensions (";
1337  pcpp::io::DumpContents(std::cout,fileGridSize,",");
1338  std::cout << ") in file path " << Ostr.str()
1339  << " does not match requested grid (";
1340  pcpp::io::DumpContents(std::cout,rGridSize,",");
1341  std::cout << ")" << std::endl;
1342  }
1343  // return(3);
1344  }
1345 
1346  // const pcpp::IndexIntervalType &partitionExtent(inGrid.LocalExtent());
1347  // pcpp::IndexIntervalType globalExtent;
1348  // globalExtent.InitSimple(gridSize);
1349 
1350  // int numLocalPoints = partitionInterval.NNodes();
1351 
1352  inGrid.AllocateCoordinateData();
1353 
1354  for(int iDim = 0;iDim < numDim;iDim++){
1355  double *coordinateData = inGrid.CoordinateData(iDim);
1356  Ostr.clear();
1357  Ostr.str("");
1358  Ostr << gridPath;
1359  if(iDim == 0) {
1360  Ostr << "/X";
1361  } else if (iDim == 1) {
1362  Ostr << "/Y";
1363  } else if (iDim == 2) {
1364  Ostr << "/Z";
1365  }
1366 
1367  if(useSimple){
1368 // std::cout << "Simply reading " << Ostr.str() << " with rPartStart:(";
1369 // pcpp::io::DumpContents(std::cout,rPartStart,",");
1370 // std::cout << ") rPartSize(";
1371 // pcpp::io::DumpContents(std::cout,rPartSize,",");
1372 // std::cout << ")" << std::endl;
1373  hdfFile.ReadHyperSlab(Ostr.str(),rPartStart,rPartSize,coordinateData);
1374  } else {
1375 // std::cout << "Reading slab " << Ostr.str() << " with rPartStart:(";
1376 // pcpp::io::DumpContents(std::cout,rPartStart,",");
1377 // std::cout << ") rPartSize(";
1378 // pcpp::io::DumpContents(std::cout,rPartSize,",");
1379 // std::cout << ") rBufferStart(";
1380 // pcpp::io::DumpContents(std::cout,rBufferStart,",");
1381 // std::cout << ") rBufferSize(";
1382 // pcpp::io::DumpContents(std::cout,rBufferSize,",");
1383 // std::cout << ")" << std::endl;
1384  hdfFile.ReadHyperSlab(Ostr.str(),rPartStart,rPartSize,rBufferStart,rBufferSize,coordinateData);
1385  }
1386  }
1387 
1388  Ostr.clear();
1389  Ostr.str("");
1390  Ostr << gridPath << "/IBLANK";
1391  std::string flagPath("IBLANK");
1392  if(!hdfFile.Exists(flagPath))
1393  flagPath = Ostr.str();
1394  if(hdfFile.Exists(flagPath)){
1395  std::vector<int> &flagData(inGrid.FlagData());
1396  int *dataPtr = &flagData[0];
1397  if(useSimple)
1398  hdfFile.ReadHyperSlab(flagPath,rPartStart,rPartSize,dataPtr);
1399  else
1400  hdfFile.ReadHyperSlab(flagPath,rPartStart,rPartSize,rBufferStart,rBufferSize,dataPtr);
1401  }
1402 
1403  return(0);
1404  }
1405 
1410  template<typename StateType>
1411  int WriteStateAttributes(const StateType &inState,const char attributeLocation,
1412  const std::string &filePath, base &hdfFile)
1413  {
1414 
1415  if(!hdfFile.Exists(filePath))
1416  return(1);
1417 
1418  std::ostringstream Ostr;
1419 
1420  const pcpp::field::metadataset &stateMetaData(inState.Meta());
1421  pcpp::field::metadataset::const_iterator mdIt = stateMetaData.begin();
1422  while(mdIt != stateMetaData.end()){
1423  const pcpp::field::metadata &fieldMetaData(*mdIt++);
1424  if(fieldMetaData.loc == attributeLocation){
1425  const std::string &fieldName(fieldMetaData.name);
1426  const std::string attributeName(filePath+"/"+fieldName);
1427  size_t numData = fieldMetaData.ncomp;
1428  std::vector<size_t> attributeSize(1,numData);
1429  const char *stateByteData = NULL;
1430  const int *stateIntData = NULL;
1431  const double *stateRealData = NULL;
1432 
1433  switch(fieldMetaData.dsize){
1434 
1435  case(1):
1436  stateByteData = inState.template GetFieldBuffer<char>(fieldName);
1437  hdfFile.CreateAttribute(attributeName,attributeSize,stateByteData);
1438  break;
1439 
1440  case(4):
1441  stateIntData = inState.template GetFieldBuffer<int>(fieldName);
1442  hdfFile.CreateAttribute(attributeName,attributeSize,stateIntData);
1443  break;
1444 
1445  case(8):
1446  stateRealData = inState.template GetFieldBuffer<double>(fieldName);
1447  hdfFile.CreateAttribute(attributeName,attributeSize,stateRealData);
1448  break;
1449 
1450  default:
1451  return(1);
1452  break;
1453  }
1454  }
1455 
1456  }
1457  return(0);
1458  };
1459 
1465  template<typename StateType>
1466  int ReadStateAttributes(StateType &inState,const char attributeLocation,
1467  const std::string &filePath, base &hdfFile)
1468  {
1469 
1470  if(!hdfFile.Exists(filePath))
1471  return(1);
1472 
1473  std::ostringstream Ostr;
1474 
1475  const pcpp::field::metadataset &stateMetaData(inState.Meta());
1476  pcpp::field::metadataset::const_iterator mdIt = stateMetaData.begin();
1477  while(mdIt != stateMetaData.end()){
1478  const pcpp::field::metadata &fieldMetaData(*mdIt++);
1479  if(fieldMetaData.loc == attributeLocation){
1480  const std::string &fieldName(fieldMetaData.name);
1481  const std::string attributeName(filePath+"/"+fieldName);
1482  size_t numData = fieldMetaData.ncomp;
1483  std::vector<size_t> attributeSize(1,numData);
1484  char *stateByteData = NULL;
1485  int *stateIntData = NULL;
1486  double *stateRealData = NULL;
1488  switch(fieldMetaData.dsize){
1489 
1490  case(1):
1491  stateByteData = inState.template GetFieldBuffer<char>(fieldName);
1492  hdfFile.ReadAttribute(attributeName,stateByteData);
1493  break;
1494 
1495  case(4):
1496  stateIntData = inState.template GetFieldBuffer<int>(fieldName);
1497  hdfFile.ReadAttribute(attributeName,stateIntData);
1498  break;
1499 
1500  case(8):
1501  stateRealData = inState.template GetFieldBuffer<double>(fieldName);
1502  hdfFile.ReadAttribute(attributeName,stateRealData);
1503  break;
1504 
1505  default:
1506  return(1);
1507  break;
1508  }
1509  }
1510 
1511  }
1512  return(0);
1513  };
1514 
1515  template<typename StateType>
1516  int WriteStateNodeData(const StateType &inState,
1517  const std::vector<size_t> &gridSizes,
1518  const std::vector<size_t> &partitionSizes,
1519  const std::vector<size_t> &partitionStarts,
1520  const std::vector<size_t> &bufferSizes,
1521  const std::vector<size_t> &partitionBufferStarts,
1522  const std::string &filePath,base &hdfFile)
1523  {
1524 
1525  if(!hdfFile.Exists(filePath)){
1526  std::cout << "ERROR: path does not exist: " << filePath << std::endl;
1527  return(1);
1528  }
1529 
1530  if(hdfFile.OpenGroup(filePath)){
1531  std::cout << "ERROR: Failed to open existing path: " << filePath << std::endl;
1532  return(1);
1533  }
1534 
1535  std::vector<size_t> rGridSizes(gridSizes);
1536  std::reverse(rGridSizes.begin(),rGridSizes.end());
1537  std::vector<size_t> rPartSizes(partitionSizes);
1538  std::reverse(rPartSizes.begin(),rPartSizes.end());
1539  std::vector<size_t> rPartStarts(partitionStarts);
1540  std::reverse(rPartStarts.begin(),rPartStarts.end());
1541  std::vector<size_t> rBufferSizes(bufferSizes);
1542  std::reverse(rBufferSizes.begin(),rBufferSizes.end());
1543  std::vector<size_t> rBufferStarts(partitionBufferStarts);
1544  std::reverse(rBufferStarts.begin(),rBufferStarts.end());
1545 
1546  size_t numPointsBuffer = 1;
1547  std::vector<size_t>::const_iterator bsIt = bufferSizes.begin();
1548  while(bsIt != bufferSizes.end())
1549  numPointsBuffer *= *bsIt++;
1550 
1551  const pcpp::field::metadataset &stateMetaData(inState.Meta());
1552  pcpp::field::metadataset::const_iterator mdIt = stateMetaData.begin();
1553  while(mdIt != stateMetaData.end()){
1554  const pcpp::field::metadata &fieldMetaData(*mdIt++);
1555  if(fieldMetaData.loc == 'n'){
1556  const std::string &fieldName(fieldMetaData.name);
1557 
1558  const std::string attributeName(filePath+"/"+fieldName);
1559  size_t numData = fieldMetaData.ncomp;
1560  std::vector<size_t> attributeSize(1,numData);
1561  const char *stateByteData = NULL;
1562  const int *stateIntData = NULL;
1563  const double *stateRealData = NULL;
1564  const char *ioByte = NULL;
1565  const int *ioInt = NULL;
1566  const double *ioReal = NULL;
1567 
1568  switch(fieldMetaData.dsize)
1569  {
1570 
1571  case(1):
1572  stateByteData = inState.template GetFieldBuffer<char>(fieldName);
1573  break;
1574 
1575  case(4):
1576  stateIntData = inState.template GetFieldBuffer<int>(fieldName);
1577  break;
1578 
1579  case(8):
1580  stateRealData = inState.template GetFieldBuffer<double>(fieldName);
1581  break;
1582 
1583  default:
1584  return(1);
1585  break;
1586 
1587  }
1588 
1589  for(int iComp = 0;iComp < numData;iComp++){
1590  std::ostringstream Ostr;
1591  Ostr << attributeName;
1592  if(numData > 1)
1593  Ostr << "-" << iComp+1;
1594 
1595  switch(fieldMetaData.dsize)
1596  {
1597 
1598  case(1):
1599  ioByte = &stateByteData[iComp*numPointsBuffer];
1600  hdfFile.WriteHyperSlab(Ostr.str(),rGridSizes,rPartStarts,rPartSizes,
1601  rBufferStarts,rBufferSizes,ioByte);
1602  break;
1603 
1604  case(4):
1605  ioInt = &stateIntData[iComp*numPointsBuffer];
1606  hdfFile.WriteHyperSlab(Ostr.str(),rGridSizes,rPartStarts,rPartSizes,
1607  rBufferStarts,rBufferSizes,ioInt);
1608  break;
1609 
1610  case(8):
1611  ioReal = &stateRealData[iComp*numPointsBuffer];
1612  hdfFile.WriteHyperSlab(Ostr.str(),rGridSizes,rPartStarts,rPartSizes,
1613  rBufferStarts,rBufferSizes,ioReal);
1614  break;
1615 
1616  default:
1617  return(1);
1618  break;
1619 
1620  }
1621  }
1622  }
1623  }
1624  return(0);
1625  };
1626 
1627 
1628  template<typename StateType>
1629  int ReadStateNodeData(StateType &inState,
1630  const std::vector<size_t> &gridSizes,
1631  const std::vector<size_t> &partitionSizes,
1632  const std::vector<size_t> &partitionStarts,
1633  const std::vector<size_t> &bufferSizes,
1634  const std::vector<size_t> &partitionBufferStarts,
1635  const std::string &filePath,base &hdfFile,
1636  bool reverseRead = true)
1637  {
1638 
1639  if(!hdfFile.Exists(filePath))
1640  return(1);
1641 
1642  // hdfFile.OpenGroup(filePath);
1643 
1644  size_t numPointsBuffer = 1;
1645  std::vector<size_t>::const_iterator bsIt = bufferSizes.begin();
1646  while(bsIt != bufferSizes.end())
1647  numPointsBuffer *= *bsIt++;
1648 
1649  std::vector<size_t> rGridSizes(gridSizes);
1650  std::vector<size_t> rPartSizes(partitionSizes);
1651  std::vector<size_t> rPartStarts(partitionStarts);
1652  std::vector<size_t> rBufferSizes(bufferSizes);
1653  std::vector<size_t> rBufferStarts(partitionBufferStarts);
1654 
1655 // if(reverseRead){
1656  std::reverse(rBufferStarts.begin(),rBufferStarts.end());
1657  std::reverse(rGridSizes.begin(),rGridSizes.end());
1658  std::reverse(rBufferSizes.begin(),rBufferSizes.end());
1659  std::reverse(rPartStarts.begin(),rPartStarts.end());
1660  std::reverse(rPartSizes.begin(),rPartSizes.end());
1661 // }
1662 
1663  const pcpp::field::metadataset &stateMetaData(inState.Meta());
1664  pcpp::field::metadataset::const_iterator mdIt = stateMetaData.begin();
1665  while(mdIt != stateMetaData.end()){
1666  const pcpp::field::metadata &fieldMetaData(*mdIt++);
1667  if(fieldMetaData.loc == 'n'){
1668  const std::string &fieldName(fieldMetaData.name);
1669  const std::string attributeName(filePath+"/"+fieldName);
1670  size_t numData = fieldMetaData.ncomp;
1671  std::vector<size_t> attributeSize(1,numData);
1672  char *stateByteData = NULL;
1673  int *stateIntData = NULL;
1674  double *stateRealData = NULL;
1675  char *ioByte = NULL;
1676  int *ioInt = NULL;
1677  double *ioReal = NULL;
1678 
1679  switch(fieldMetaData.dsize)
1680  {
1681 
1682  case(1):
1683  stateByteData = inState.template GetFieldBuffer<char>(fieldName);
1684  break;
1685 
1686  case(4):
1687  stateIntData = inState.template GetFieldBuffer<int>(fieldName);
1688  break;
1689 
1690  case(8):
1691  stateRealData = inState.template GetFieldBuffer<double>(fieldName);
1692  break;
1693 
1694  default:
1695  return(1);
1696  break;
1697 
1698  }
1699 
1700  int readStatus = 0;
1701  for(int iComp = 0;iComp < numData;iComp++){
1702  std::ostringstream Ostr;
1703  Ostr << attributeName;
1704  if(numData > 1)
1705  Ostr << "-" << iComp+1;
1706 
1707  switch(fieldMetaData.dsize)
1708  {
1709 
1710  case(1):
1711  ioByte = &stateByteData[iComp*numPointsBuffer];
1712  readStatus = hdfFile.ReadHyperSlab(Ostr.str(),rPartStarts,rPartSizes,
1713  rBufferStarts,rBufferSizes,ioByte);
1714  break;
1715 
1716  case(4):
1717  ioInt = &stateIntData[iComp*numPointsBuffer];
1718  readStatus = hdfFile.ReadHyperSlab(Ostr.str(),rPartStarts,rPartSizes,
1719  rBufferStarts,rBufferSizes,ioInt);
1720  break;
1721 
1722  case(8):
1723  ioReal = &stateRealData[iComp*numPointsBuffer];
1724  readStatus = hdfFile.ReadHyperSlab(Ostr.str(),rPartStarts,rPartSizes,
1725  rBufferStarts,rBufferSizes,ioReal);
1726  break;
1727 
1728  default:
1729  return(1);
1730  break;
1731 
1732  } // switch/case
1734  // if(readStatus != 0)
1735  // std::cerr << "WARNING: Read of " << Ostr.str() << " failed." << std::endl;
1736 
1737  } // loop over components
1738  } // if(nodal field)
1739  } // loop over fields
1740  return(0);
1741  };
1742 
1743  int PlasCom2FileInfo(pcpp::io::hdf5::base &hdf5File,simfileinfo &fileInfo,std::ostream &messageStream);
1744 
1745  template<typename GridType>
1746  int FetchGridData(GridType &inGrid,
1747  const std::string &gridName,
1748  const std::string &gridFileName,
1749  std::ostream &messageStream)
1750  {
1751  fixtures::CommunicatorType &gridComm(inGrid.Communicator());
1752  int myRank = gridComm.Rank();
1753 
1754  int readMode = 0;
1755  int statusCode = 0;
1756  if(myRank == 0){
1757  std::ostringstream errStream;
1758  pcpp::io::simfileinfo gridFileInfo;
1759  if(pcpp::io::hdf5::FileInfo(gridFileName,gridFileInfo,errStream)){
1760  messageStream << "ERROR: FileInfo failed for " << gridFileName
1761  << ".\nHDF5 messages:"
1762  << errStream.str() << std::endl;
1763  statusCode = 1;
1764  }
1765  const std::bitset<pcpp::io::NUMFORMATBITS> &formatBits(gridFileInfo.formatBits);
1766  if(formatBits.test(pcpp::io::ISLEGACY)){
1767  messageStream << gridFileName << " is a legacy file." << std::endl;
1768  readMode = 1;
1769  } else {
1770  if(!formatBits.test(pcpp::io::HASGEOMETRY)){
1771  messageStream << "Error: specified file (" << gridFileName << ") has "
1772  << "no geometry data." << std::endl;
1773  statusCode = 1;
1774  }
1775  }
1776  }
1777  gridComm.Barrier();
1778  if(statusCode > 0)
1779  return(statusCode);
1780  gridComm.BroadCast(readMode,0);
1781  std::string gridPath;
1782  bool reverseData = true;
1783  std::string geometryName;
1784  std::string geomGridName;
1785  std::string::size_type sepLoc = gridName.find_last_of(":");
1786  if(sepLoc != std::string::npos){
1787  geometryName = gridName.substr(0,sepLoc);
1788  geomGridName = gridName.substr(sepLoc+1);
1789  gridPath = std::string("/PlasCom2/Geometry/")+
1790  geometryName+std::string("/")+geomGridName;
1791  } else {
1792  gridPath = gridName;
1793  geomGridName = gridName;
1794  }
1795  if(readMode != 0) { // process PlasComCM file
1796  reverseData = false;
1797  gridPath = geomGridName;
1798  }
1799  pcpp::io::hdf5::base gridFile;
1800  gridFile.Open(gridFileName,gridComm,true);
1801  if(pcpp::io::hdf5::ReadGrid(inGrid,gridPath,gridFile,reverseData)){
1802  messageStream << "Reading grid from file:path=(" << gridFileName << "):("
1803  << gridPath << ") failed." << std::endl;
1804  statusCode = 1;
1805  } else {
1806  messageStream << "Read grid from file:path=(" << gridFileName << "):("
1807  << gridPath << ")." << std::endl;
1808  }
1809  gridFile.Close();
1810  return(statusCode);
1811  };
1812 
1813 
1814 
1815  template<typename StateType,typename GridType>
1816  int FetchStateData(const std::string &fileName,
1817  const std::string &domainName,
1818  GridType &inGrid,
1819  StateType &inState,
1820  std::ostream &messageStream)
1821  {
1822 
1823  fixtures::CommunicatorType &gridComm(inGrid.Communicator());
1824  int myRank = gridComm.Rank();
1825 
1826  int readMode = 0;
1827  int statusCode = 0;
1828  pcpp::io::simfileinfo gridFileInfo;
1829 
1830  if(myRank == 0){
1831  std::ostringstream errStream;
1832  if(pcpp::io::hdf5::FileInfo(fileName,gridFileInfo,errStream)){
1833  messageStream << "ERROR: FileInfo failed for " << fileName
1834  << ".\nHDF5 messages:"
1835  << errStream.str() << std::endl;
1836  statusCode = 1;
1837  }
1838  const std::bitset<pcpp::io::NUMFORMATBITS> &formatBits(gridFileInfo.formatBits);
1839  if(formatBits.test(pcpp::io::ISLEGACY)){
1840  messageStream << fileName << " is a legacy file." << std::endl;
1841  readMode = 1;
1842  } else {
1843  if(!formatBits.test(pcpp::io::HASSIMULATION)){
1844  messageStream << "Error: specified file (" << fileName << ") has "
1845  << "no simulation data." << std::endl;
1846  statusCode = 1;
1847  }
1848  }
1849  }
1850  gridComm.StreamBroadCast(gridFileInfo);
1851  if(statusCode > 0)
1852  return(statusCode);
1853  gridComm.BroadCast(readMode,0);
1854  bool reverseData = true;
1855  pcpp::io::hdf5::base stateFile;
1856  stateFile.Open(fileName,gridComm,true);
1857  std::string pathToGridData;
1858  if(readMode == 0) { // process PlasCom2 file
1859  const std::string simulationPath("/PlasCom2/Simulation");
1860  const std::string domainPath(simulationPath+std::string("/")+domainName);
1862  // pathToGridData = domainPath+std::string("/grid1");
1863  pathToGridData = domainPath;
1864 
1865  if(!stateFile.Exists(domainPath)){
1866  messageStream << "Error: HDF5 file (" << fileName << ") has no "
1867  << "simulation data for domain (" << domainName << ")."
1868  << std::endl;
1869  statusCode = 1;
1870  }
1871  if(!stateFile.Exists(pathToGridData)){
1872  messageStream << "Error: HDF5 file (" << fileName << ") has no "
1873  << "path to grid data (" << pathToGridData << ")."
1874  << std::endl;
1875  statusCode = 1;
1876  }
1877  if(statusCode == 0){
1878  if(pcpp::io::hdf5::ReadStateAttributes(inState,'s',simulationPath,stateFile)){
1879  messageStream << "Error: Reading simulation-global attributes failed." << std::endl;
1880  statusCode = 1;
1881  }
1882  }
1883  if(statusCode == 0){
1884  if(pcpp::io::hdf5::ReadStateAttributes(inState,'d',domainPath,stateFile)){
1885  messageStream << "Error: Reading domain-global attributes failed." << std::endl;
1886  statusCode = 1;
1887  }
1888  }
1889  if(statusCode == 0){
1890  if(pcpp::io::hdf5::ReadStateAttributes(inState,'m',pathToGridData,stateFile)){
1891  messageStream << "Error: Reading grid-global attributes failed." << std::endl;
1892  statusCode = 1;
1893  }
1894  }
1895  } else {
1896  reverseData = false;
1897  pathToGridData = domainName;
1898  }
1899  if(statusCode == 0) {
1900 
1901 
1902  const pcpp::IndexIntervalType &partInterval(inGrid.PartitionInterval());
1903  const pcpp::IndexIntervalType &partitionBufferInterval(inGrid.PartitionBufferInterval());
1904  const std::vector<size_t> &partitionSizes(partInterval.Sizes());
1905  const std::vector<size_t> &partitionStarts(partInterval.Starts());
1906  const std::vector<size_t> &partitionBufferStarts(partitionBufferInterval.Starts());
1907  const std::vector<size_t> &bufferSizes(inGrid.BufferSizes());
1908  const std::vector<size_t> &gridSizes(inGrid.GridSizes());
1909 
1910  if(pcpp::io::hdf5::ReadStateNodeData(inState,gridSizes,partitionSizes,partitionStarts,
1911  bufferSizes,partitionBufferStarts,pathToGridData,
1912  stateFile,reverseData)){
1913  messageStream << "Error: Failed to read nodal state data attributes at path: "
1914  << pathToGridData << "." << std::endl;
1915  statusCode = 1;
1916  }
1917  if(statusCode == 0 && readMode != 0){
1918  // Convert legacy state
1919  int numDim = bufferSizes.size();
1920  size_t numPoints = 1;
1921  for(int iDim = 0;iDim < numDim;iDim++)
1922  numPoints *= bufferSizes[iDim];
1923  ConvertLegacyState(numDim,numPoints,inState);
1924  }
1925  }
1926  stateFile.Close();
1927  return(statusCode);
1928  };
1929 
1930  }
1931  }
1932 }
1933 
1934 #endif
pcpp::io::hdf5::base::ReadHyperSlab
int ReadHyperSlab(const std::string &inName, const std::vector< size_t > &localStart, const std::vector< size_t > &localSize, std::vector< DataType > &inDataVec)
Definition: PCPPHDF5.H:462
pcpp::io::hdf5::base::Messages
std::string Messages()
Definition: PCPPHDF5.H:237
pcpp::io::xdmf::OpenFileTag
void OpenFileTag(std::ostream &outStream)
Definition: PCPPHDF5.C:12
bufferSize
void size_t int size_t int size_t int int int int double int int double double *void size_t int size_t int int int int int double int size_t size_t size_t double double *void size_t int size_t int size_t size_t int double int double double *void size_t size_t * bufferSize
Definition: OperatorKernels.H:29
pcpp::io::xdmf::CloseFileTag
void CloseFileTag(std::ostream &outStream)
Definition: PCPPHDF5.C:20
pcpp::io::hdf5::base::ReadHyperSlab
int ReadHyperSlab(hid_t dataID, hid_t dataSpace, hid_t hyperSlab, hid_t xferProperties, int *dataBuffer)
Definition: PCPPHDF5.H:439
numPoints
void const size_t * numPoints
Definition: EulerKernels.H:10
pcpp::io::hdf5::base::ReadAttribute
int ReadAttribute(const std::string &inName, int *inBuf)
Definition: PCPPHDF5.C:1029
pcpp::io::hdf5::base::messageStreamPtr
std::ostream * messageStreamPtr
Definition: PCPPHDF5.H:912
pcpp::io::hdf5::base::ReadHyperSlab
int ReadHyperSlab(hid_t dataID, hid_t dataSpace, hid_t hyperSlab, hid_t xferProperties, char *dataBuffer)
Definition: PCPPHDF5.H:453
pcpp::io::hdf5::base::base
base(const std::string &inName)
Definition: PCPPHDF5.H:194
pcpp::io::hdf5::base::hdfScope
std::vector< hid_t > hdfScope
Definition: PCPPHDF5.H:903
simulation::state::ConvertLegacyState
void ConvertLegacyState(int numDim, size_t numPoints, StateType &inState)
Definition: State.H:711
pcpp::io::xdmf::CloseGridTag
void CloseGridTag(std::ostream &outStream)
Definition: PCPPHDF5.C:32
gridSizes
void const size_t const size_t * gridSizes
Definition: EulerKernels.H:10
pcpp::io::hdf5::FileInfo
int FileInfo(const std::string &hdfFileName, pcpp::io::simfileinfo &fileInfo, std::ostream &messageStream)
Definition: PCPPHDF5.C:621
ix::util::RenewStream
void RenewStream(std::ostringstream &outStream)
Definition: primitive_utilities.H:638
pcpp::io::hdf5::base::Exists
bool Exists(const std::string &linkName)
Definition: PCPPHDF5.C:872
pcpp::io::hdf5::WriteStateAttributes
int WriteStateAttributes(const StateType &inState, const char attributeLocation, const std::string &filePath, base &hdfFile)
Writes state data matching attributeLocation into HDF5 attributes at filePath.
Definition: PCPPHDF5.H:1411
gridType
void const size_t const size_t const size_t const int const int * gridType
Definition: EulerKernels.H:10
pcpp::io::hdf5::base::SetMessageStream
void SetMessageStream(std::ostream &outStream)
Definition: PCPPHDF5.H:233
pcpp::io::hdf5::base::Name
std::string Name()
Definition: PCPPHDF5.H:231
pcpp::io::hdf5::FetchGridData
int FetchGridData(GridType &inGrid, const std::string &gridName, const std::string &gridFileName, std::ostream &messageStream)
Definition: PCPPHDF5.H:1746
pcpp::io::xdmf::WriteSimulationFile
void WriteSimulationFile(const std::string &h5FileName, const std::string &gridName, const std::string &gridPath, const std::string &dataPath, const GridType &inGrid, const StateType &inState)
Definition: PCPPHDF5.H:38
pcpp::io::hdf5::base::SetCommunicator
void SetCommunicator(fixtures::CommunicatorType &inCommunicator)
Definition: PCPPHDF5.H:256
pcpp::io::hdf5::base::Create
int Create(const std::string &inFileName, fixtures::CommunicatorType &inComm, bool force=false)
Definition: PCPPHDF5.H:261
pcpp::io::simfileinfo::formatBits
std::bitset< NUMFORMATBITS > formatBits
Definition: PCPPIO.H:42
pcpp::io::xdmf::WriteGridData
int WriteGridData(const std::string &fileName, const std::string &dataName, unsigned int dataSize, const std::string &dataPath, const std::vector< size_t > &gridSize, std::ostream &outStream)
Definition: PCPPHDF5.C:118
pcpp::io::hdf5::base::WriteHyperSlab
int WriteHyperSlab(const std::string &inName, const std::vector< size_t > &globalSize, const std::vector< size_t > &localStart, const std::vector< size_t > &localSize, std::vector< double > &inDataVec)
Definition: PCPPHDF5.C:1253
pcpp::io::hdf5::base::ReadHyperSlab
int ReadHyperSlab(const std::string &inName, const std::vector< size_t > &localStart, const std::vector< size_t > &localSize, const std::vector< size_t > &bufferStart, const std::vector< size_t > &bufferSize, DataType *readBuffer)
Definition: PCPPHDF5.H:628
x
void const size_t const size_t const size_t const double const double * x
Definition: OperatorKernels.H:33
pcpp::io::hdf5::WriteGrid
int WriteGrid(const GridType &inGrid, const std::string &gridName, const std::string &parentPath, base &hdfFile)
Definition: PCPPHDF5.H:1131
pcpp::io::xdmf::OpenGridTag
void OpenGridTag(const std::string &gridName, const std::string &gridType, double inTime, std::ostream &outStream)
Definition: PCPPHDF5.C:26
pcpp::io::hdf5::base::messageStream
std::ostringstream messageStream
Definition: PCPPHDF5.H:913
pcpp::io::hdf5::base::OpenGroup
int OpenGroup(const std::string &groupName)
Definition: PCPPHDF5.C:831
pcpp::io::hdf5::base::SetCollectiveMode
void SetCollectiveMode(bool yesNo=true)
Definition: PCPPHDF5.H:244
pcpp::io::hdf5::FileInfo
int FileInfo(const std::string &hdfFileName, pcpp::io::simfileinfo &fileInfo, fixtures::CommunicatorType &inComm, std::ostream &messageStream)
Definition: PCPPHDF5.C:666
pcpp::io::hdf5::base::ReadHyperSlab
int ReadHyperSlab(hid_t dataID, hid_t dataSpace, hid_t hyperSlab, hid_t xferProperties, double *dataBuffer)
Definition: PCPPHDF5.H:432
pcpp::io::hdf5::PlasCom2FileInfo
int PlasCom2FileInfo(pcpp::io::hdf5::base &hdf5File, simfileinfo &fileInfo, std::ostream &messageStream)
Definition: PCPPHDF5.C:276
pcpp::io::hdf5::base::ReadHyperSlab
int ReadHyperSlab(const std::string &inName, const std::vector< size_t > &localStart, const std::vector< size_t > &localSize, DataType *readBuffer)
Definition: PCPPHDF5.H:743
pcpp::io::hdf5::base::ReadHyperSlab
int ReadHyperSlab(hid_t dataID, hid_t dataSpace, hid_t hyperSlab, hid_t xferProperties, size_t *dataBuffer)
Definition: PCPPHDF5.H:446
pcpp::io::hdf5::base::ReadAttribute
int ReadAttribute(const std::string &inName, std::vector< DataType > &inData)
Definition: PCPPHDF5.H:312
pcpp::io::hdf5::base::CreateGroup
int CreateGroup(const std::string &inName)
Definition: PCPPHDF5.C:2353
pcpp::io::hdf5::base::base
base(fixtures::CommunicatorType &inComm)
Definition: PCPPHDF5.H:188
ix::sys::FILEEXISTS
bool FILEEXISTS(const std::string &fname)
Definition: UnixUtils.C:189
ix::comm::CommunicatorObject
Main encapsulation of MPI.
Definition: COMM.H:62
pcpp::io::hdf5::ReadStateAttributes
int ReadStateAttributes(StateType &inState, const char attributeLocation, const std::string &filePath, base &hdfFile)
Reads state data matching attributeLocation into HDF5 attributes at filePath.
Definition: PCPPHDF5.H:1466
pcpp::io::xdmf::WriteDomainFile
void WriteDomainFile(const std::string &h5FileName, DomainType &inDomain)
Definition: PCPPHDF5.H:99
navierstokes::scalarNames
static const std::string scalarNames("scalarVars")
pcpp::io::hdf5::base::base
base(const std::string &inName, fixtures::CommunicatorType &inComm)
Definition: PCPPHDF5.H:218
apptools::DumpContents
void DumpContents(std::ostream &Ostr, const ContainerType &c, std::string del="\)
Dump container contents.
Definition: AppTools.H:117
pcpp::io::hdf5::base::hdfAPL
std::vector< hid_t > hdfAPL
Definition: PCPPHDF5.H:904
pcpp::io::hdf5::base::commPtr
fixtures::CommunicatorType * commPtr
Definition: PCPPHDF5.H:914
pcpp::io::hdf5::base::base
base(const std::string &inName, bool readOnly)
Definition: PCPPHDF5.H:206
bufferSizes
void const size_t const size_t * bufferSizes
Definition: MetricKernels.H:19
pcpp::io::hdf5::ParallelReadBlockStructuredGrid
int ParallelReadBlockStructuredGrid(const std::string &gridName, const std::string &parentGroupName, GridType &gridData, configuration &hdfConfig, const std::string &hdfFileName, fixtures::CommunicatorType &gridComm, std::ostream &messageStream)
Definition: PCPPHDF5.H:1089
pcpp::io::hdf5::ReadGrid
int ReadGrid(GridType &inGrid, const std::string &gridPath, base &hdfFile, bool reverseRead=true)
Definition: PCPPHDF5.H:1255
pcpp::io::xdmf::WriteGridSection
int WriteGridSection(const std::string &topoType, const std::string &geomType, const std::string &fileName, const std::string &gridPath, const std::vector< size_t > &gridSize, std::ostream &outStream)
Definition: PCPPHDF5.C:38
pcpp::io::hdf5::base::ReadHyperSlab
int ReadHyperSlab(const std::string &inName, const std::vector< size_t > &localStart, const std::vector< size_t > &localSize, const std::vector< size_t > &bufferStart, const std::vector< size_t > &bufferSize, std::vector< DataType > &inDataVec)
Definition: PCPPHDF5.H:539
pcpp::io::hdf5::ReadGrid
int ReadGrid(hid_t parentGroupID, const configuration &hdfConfig, const std::string &gridName, GridType &gridData, fixtures::CommunicatorType &inComm, std::ostream &messageStream)
Definition: PCPPHDF5.H:927
ix::util::sizeextent
Simple Block Structured Mesh object.
Definition: IndexUtil.H:21
pcpp::io::hdf5::ReadStateNodeData
int ReadStateNodeData(StateType &inState, const std::vector< size_t > &gridSizes, const std::vector< size_t > &partitionSizes, const std::vector< size_t > &partitionStarts, const std::vector< size_t > &bufferSizes, const std::vector< size_t > &partitionBufferStarts, const std::string &filePath, base &hdfFile, bool reverseRead=true)
Definition: PCPPHDF5.H:1629
pcpp::io::hdf5::base::Open
int Open(const std::string &inFileName, fixtures::CommunicatorType &inComm, bool readOnly=false)
Definition: PCPPHDF5.H:275
pcpp::io::hdf5::base::ReadDataSet
int ReadDataSet(const std::string &inName, std::vector< DataType > &inDataVec)
Definition: PCPPHDF5.H:815
ix::util::sizeextent::InitSimple
void InitSimple(const ContainerType &inSize)
Definition: IndexUtil.H:169
numPointsBuffer
void const size_t * numPointsBuffer
Definition: MetricKernels.H:19
pcpp::io::hdf5::base::CreateAttribute
int CreateAttribute(const std::string &inName, const std::vector< size_t > &spaceDimensions, size_t sizeInBytes=8)
Definition: PCPPHDF5.C:2482
pcpp::io::hdf5::base::dataTransferProperties
hid_t dataTransferProperties
Definition: PCPPHDF5.H:906
pcpp::io::hdf5::FetchStateData
int FetchStateData(const std::string &fileName, const std::string &domainName, GridType &inGrid, StateType &inState, std::ostream &messageStream)
Definition: PCPPHDF5.H:1816
pcpp::io::hdf5::WriteStateNodeData
int WriteStateNodeData(const StateType &inState, const std::vector< size_t > &gridSizes, const std::vector< size_t > &partitionSizes, const std::vector< size_t > &partitionStarts, const std::vector< size_t > &bufferSizes, const std::vector< size_t > &partitionBufferStarts, const std::string &filePath, base &hdfFile)
Definition: PCPPHDF5.H:1516