PlasCom2  1.0
XPACC Multi-physics simluation application
PC2IO.H
Go to the documentation of this file.
1 #ifndef __PC2_IO_H__
2 #define __PC2_IO_H__
3 
4 #include "PlasCom2.H"
5 #include "PCPPCommUtil.H"
6 #include "PCPPIO.H"
7 #include "PCPPReport.H"
8 #include "PCPPIntervalUtils.H"
9 
10 namespace plascom2 {
11  namespace io {
12 
13 #ifdef ENABLE_HDF5
14  namespace hdf5 {
15 
16  template<typename GridType,typename StateType,typename ConfigType>
17  int OutputSingle(const std::string &fileName,
18  const std::string &domainName,
19  const std::string &geometryName,
20  const std::string &gridName,
21  GridType &inGrid,
22  StateType &inState,
23  StateType &paramState,
24  ConfigType &simConfig,
25  std::ostream &outStream,
26  int iStep = 0){
27 
28  pcpp::CommunicatorType &gridComm(inGrid.Communicator());
29 
30  // Begin PlasCom2 output
31  if(ix::sys::FILEEXISTS(fileName))
32  ix::sys::Remove(fileName);
33 
34  int numDomains = 1;
35 
36  int myRank = gridComm.Rank();
37 
38  pcpp::io::hdf5::base pc2File(fileName,gridComm);
39  pc2File.SetMessageStream(outStream);
40  pc2File.CreateGroup("/PlasCom2");
41  pc2File.CreateGroup("/PlasCom2/Configuration");
42  std::ostringstream configStream;
43  configStream << simConfig;
44  std::string configString(configStream.str());
45  if(!configString.empty())
46  pc2File.CreateAttribute("/PlasCom2/Configuration/Parameters",configString);
47 
48  int numGeometries = 1;
49  pc2File.CreateGroup("/PlasCom2/Geometry");
50  std::vector<size_t> attSize(1,1);
51  pc2File.CreateAttribute("/PlasCom2/Geometry/numGeometries",attSize,&numGeometries);
52  pc2File.CreateAttribute("/PlasCom2/Geometry/geometryNames",geometryName);
53  std::string geomGroupName(std::string("/PlasCom2/Geometry/")+geometryName);
54  pc2File.CreateGroup(geomGroupName);
55  int numGrids = 1;
56  pc2File.CreateAttribute(geomGroupName+"/numGrids",attSize,&numGrids);
57  pc2File.CreateAttribute(geomGroupName+"/gridNames",gridName);
58  pcpp::io::hdf5::WriteGrid(inGrid,gridName,geomGroupName,pc2File);
59  std::string geomGridGroupName(geomGroupName+"/"+gridName);
60 
61 
62  pc2File.CreateGroup("/PlasCom2/Simulation");
63  pc2File.CreateAttribute("/PlasCom2/Simulation/numDomains",attSize,&numDomains);
64  pc2File.CreateAttribute("/PlasCom2/Simulation/domainNames",domainName);
65  std::string domainGroupName(std::string("/PlasCom2/Simulation/")+domainName);
66  pc2File.CreateGroup(domainGroupName);
67 
68  // Simulation-global parameter and state data
69  pcpp::field::metadataset parameterDictionary(paramState.Dictionary('s'));
70  pcpp::field::metadataset simulationStateDictionary(inState.Dictionary('s'));
71 
72  if(!parameterDictionary.empty()){
73  std::ostringstream dictionaryOut;
74  dictionaryOut << parameterDictionary;
75  std::string dictionaryString(dictionaryOut.str());
76  pc2File.CreateAttribute("/PlasCom2/Simulation/paramDictionary",dictionaryString);
77  }
78 
79  if(!simulationStateDictionary.empty()){
80  std::ostringstream dictionaryOut;
81  dictionaryOut << simulationStateDictionary;
82  std::string dictionaryString(dictionaryOut.str());
83  pc2File.CreateAttribute("/PlasCom2/Simulation/stateDictionary",dictionaryString);
84  }
85 
86 
87  pcpp::io::hdf5::WriteStateAttributes(inState,'s',"/PlasCom2/Simulation",pc2File);
88  pcpp::io::hdf5::WriteStateAttributes(paramState,'s',"/PlasCom2/Simulation",pc2File);
89 
90  pc2File.CreateAttribute("/PlasCom2/Simulation/stepNumber",attSize,&iStep);
91 
92  // pc2File.CreateGroup(domainGroupName+"/Configuration");
93  // std::ostringstream domainConfigStream;
94  // domainConfigStream << domainConfig;
95  // pc2File.CreateAttribute(domainGroupName+"/Configuration/Parameters",domainConfigStream.str());
96  int numDomainGrids = 1;
97  std::string domainFullGridName(geometryName+":"+gridName);
98  std::string domainGridName("grid1");
99  pc2File.CreateAttribute(domainGroupName+"/numGrids",attSize,&numDomainGrids);
100  pc2File.CreateAttribute(domainGroupName+"/gridNames",domainGridName);
101 
102  pcpp::field::metadataset domainParameterDictionary(paramState.Dictionary('d'));
103  pcpp::field::metadataset gridParameterDictionary(paramState.Dictionary('m'));
104  pcpp::field::metadataset domainStateDictionary(inState.Dictionary('d'));
105  pcpp::field::metadataset gridStateDictionary(inState.Dictionary('m'));
106  pcpp::field::metadataset nodeStateDictionary(inState.Dictionary('n'));
107  pcpp::field::metadataset cellStateDictionary(inState.Dictionary('c'));
108 
109  domainParameterDictionary.Append(gridParameterDictionary);
110  domainStateDictionary.Append(gridStateDictionary);
111  domainStateDictionary.Append(nodeStateDictionary);
112  domainStateDictionary.Append(cellStateDictionary);
113 
114  if(!domainParameterDictionary.empty()){
115  std::ostringstream dictionaryOut;
116  dictionaryOut << domainParameterDictionary;
117  std::string dictionaryString(dictionaryOut.str());
118  pc2File.CreateAttribute(domainGroupName+"/paramDictionary",dictionaryString);
119  }
120  if(!domainStateDictionary.empty()){
121  std::ostringstream dictionaryOut;
122  dictionaryOut << domainStateDictionary;
123  std::string dictionaryString(dictionaryOut.str());
124  pc2File.CreateAttribute(domainGroupName+"/stateDictionary",dictionaryString);
125  }
126  pcpp::io::hdf5::WriteStateAttributes(inState,'d',domainGroupName,pc2File);
127  pcpp::io::hdf5::WriteStateAttributes(paramState,'d',domainGroupName,pc2File);
128 
129  std::string gridGroupName(domainGroupName+"/"+domainGridName);
130  pc2File.CreateGroup(gridGroupName);
131  pc2File.CreateAttribute(gridGroupName+"/gridPath",domainFullGridName);
132  pcpp::io::hdf5::WriteStateAttributes(paramState,'m',gridGroupName,pc2File);
133  pcpp::io::hdf5::WriteStateAttributes(inState,'m',gridGroupName,pc2File);
134 
135  pcpp::IndexIntervalType partInterval(inGrid.PartitionInterval());
136  pcpp::IndexIntervalType partitionBufferInterval(inGrid.PartitionBufferInterval());
137  std::vector<size_t> partitionSizes(partInterval.Sizes());
138  std::vector<size_t> partitionStarts(partInterval.Starts());
139  std::vector<size_t> partitionBufferStarts(partitionBufferInterval.Starts());
140  std::vector<size_t> gridSizes(inGrid.GridSizes());
141  std::vector<size_t> bufferSizes(inGrid.BufferSizes());
142 
143  pcpp::io::hdf5::WriteStateNodeData(inState,gridSizes,partitionSizes,partitionStarts,
144  bufferSizes,partitionBufferStarts,gridGroupName,pc2File);
145 
146  pc2File.Close();
147 
148 
149  if(myRank == 0){
150  pcpp::io::xdmf::WriteSimulationFile(fileName,gridName,geomGridGroupName,
151  gridGroupName,inGrid,inState);
152  }
153 
154  return(0);
155  }
156 
157  template<typename DomainType,typename ConfigType>
158  int WriteSingleDomain(const std::string &fileName,
159  DomainType &inDomain,
160  ConfigType &simConfig,
161  std::ostream &outStream)
162  {
163 
164  pcpp::CommunicatorType &domainCommunicator(inDomain.Communicator());
165  int domainRank = domainCommunicator.Rank();
166 
167 
168  int numDomains = 1;
169 
170  int numDomainGrids = inDomain.NumberOfGrids();
171  const std::vector<std::string> &domainGridNames(inDomain.GridNames());
172  const std::vector<std::string> &domainGeometryNames(inDomain.GeometryNames());
173  int numGeometries = domainGeometryNames.size();
174  const std::string &domainName(inDomain.Name());
175  std::vector<std::string> uniqueGeometryNames(domainGeometryNames);
176  std::sort(uniqueGeometryNames.begin(),uniqueGeometryNames.end());
177  uniqueGeometryNames.erase(std::unique(uniqueGeometryNames.begin(),uniqueGeometryNames.end()),
178  uniqueGeometryNames.end());
179  int numUniqueGeometries = uniqueGeometryNames.size();
180  std::vector<std::string> uniqueGridNames(domainGridNames);
181  std::sort(uniqueGridNames.begin(),uniqueGridNames.end());
182  uniqueGridNames.erase(std::unique(uniqueGridNames.begin(),uniqueGridNames.end()),
183  uniqueGridNames.end());
184  int numUniqueGrids = uniqueGridNames.size();
185  std::string domainGroupName(std::string("/PlasCom2/Simulation/")+domainName);
186  std::vector<size_t> attSize1(1,1);
187  bool writeGeometry = true;
188  if(simConfig.IsSet("PlasCom2:WriteGeometry"))
189  writeGeometry = simConfig.GetFlagValue("PlasCom2:WriteGeometry");
190  int iStep = inDomain.Step();
191 
192  if(domainRank == 0){
193 
194  // Begin PlasCom2 output
195  if(ix::sys::FILEEXISTS(fileName))
196  ix::sys::Remove(fileName);
197 
198  pcpp::io::hdf5::base pc2File(fileName);
199  pc2File.SetMessageStream(outStream);
200  pc2File.CreateGroup("/PlasCom2");
201  pc2File.CreateGroup("/PlasCom2/Configuration");
202 
203  std::ostringstream configStream;
204  configStream << simConfig;
205  std::string configString(configStream.str());
206  if(!configString.empty())
207  pc2File.CreateAttribute("/PlasCom2/Configuration/Parameters",configString);
208 
209  if(writeGeometry){
210 
211  pc2File.CreateGroup("/PlasCom2/Geometry");
212  pc2File.CreateAttribute("/PlasCom2/Geometry/numGeometries",attSize1,&numUniqueGeometries);
213  std::ostringstream geometryNameStream;
214  for(int iGeom = 0;iGeom < numUniqueGeometries;iGeom++){
215  geometryNameStream << uniqueGeometryNames[iGeom];
216  if(iGeom != (numUniqueGeometries-1))
217  geometryNameStream << " ";
218  }
219 
220  std::map<std::string,int> numGeometryGrids;
221  std::string allGeometryNames(geometryNameStream.str());
222  pc2File.CreateAttribute("/PlasCom2/Geometry/geometryNames",allGeometryNames);
223  for(int iGeom = 0;iGeom < numUniqueGeometries;iGeom++){
224  const std::string &geometryName(uniqueGeometryNames[iGeom]);
225  const std::string geomGroupName(std::string("/PlasCom2/Geometry/")+geometryName);
226  pc2File.CreateGroup(geomGroupName);
227  numGeometryGrids.insert(std::make_pair(geometryName,0));
228  }
229 
230  typedef std::multimap<std::string,std::string> namesmap;
231  namesmap geometryGridNames;
232  for(int iGrid = 0;iGrid < numUniqueGrids;iGrid++){
233  const std::string &domainGridName(uniqueGridNames[iGrid]);
234  std::string::size_type x = domainGridName.find_last_of(":");
235  const std::string gridGeometryName(domainGridName.substr(0,x));
236  const std::string gridOnlyName(domainGridName.substr(x+1));
237  const std::string gridPath(std::string("/PlasCom2/Geometry/")+
238  gridGeometryName+"/"+gridOnlyName);
239  numGeometryGrids[gridGeometryName]++;
240  geometryGridNames.insert(std::make_pair(gridGeometryName,gridOnlyName));
241  }
242 
243  for(int iGeom = 0;iGeom < numUniqueGeometries;iGeom++){
244  const std::string &geometryName(uniqueGeometryNames[iGeom]);
245  const std::string geomGroupName(std::string("/PlasCom2/Geometry/")+geometryName);
246  int numGeomGrids = numGeometryGrids[geometryName];
247  pc2File.CreateAttribute(geomGroupName+"/numGrids",attSize1,&numGeomGrids);
248  std::pair<namesmap::iterator,namesmap::iterator> gridsOfGeometry;
249  gridsOfGeometry = geometryGridNames.equal_range(geometryName);
250  namesmap::iterator gnIt = gridsOfGeometry.first;
251  std::ostringstream allGridNamesStream;
252  while(gnIt != gridsOfGeometry.second){
253  allGridNamesStream << gnIt->second;
254  gnIt++;
255  if(gnIt != gridsOfGeometry.second)
256  allGridNamesStream << " ";
257  }
258  const std::string allGridNames(allGridNamesStream.str());
259  pc2File.CreateAttribute(geomGroupName+"/gridNames",allGridNames);
260  }
261  }
262 
263  pc2File.CreateGroup("/PlasCom2/Simulation");
264  pc2File.CreateAttribute("/PlasCom2/Simulation/numDomains",attSize1,&numDomains);
265  pc2File.CreateAttribute("/PlasCom2/Simulation/domainNames",domainName);
266  pc2File.CreateGroup(domainGroupName);
267 
268  // Simulation-global parameter and state dictionaries
269  pcpp::field::metadataset &parameterDictionary(inDomain.ParamDictionary());
270  pcpp::field::metadataset &stateDictionary(inDomain.StateDictionary());
271 
272  pcpp::field::metadataset simulationParamDict(pcpp::util::ExtractDictionary(parameterDictionary,'s'));
273  pcpp::field::metadataset simulationStateDict(pcpp::util::ExtractDictionary(stateDictionary,'s'));
274 
275  if(!simulationParamDict.empty()){
276  std::ostringstream dictionaryOut;
277  dictionaryOut << simulationParamDict;
278  std::string dictionaryString(dictionaryOut.str());
279  pc2File.CreateAttribute("/PlasCom2/Simulation/paramDictionary",dictionaryString);
280  }
281 
282  if(!simulationStateDict.empty()){
283  std::ostringstream dictionaryOut;
284  dictionaryOut << simulationStateDict;
285  std::string dictionaryString(dictionaryOut.str());
286  pc2File.CreateAttribute("/PlasCom2/Simulation/stateDictionary",dictionaryString);
287  }
288 
289 
290  std::ostringstream gridNamesStream;
291  std::vector<std::string> gridNames;
292  for(int iGrid = 1;iGrid <= numDomainGrids;iGrid++){
293  std::ostringstream gridNameStream;
294  gridNameStream << "grid" << iGrid;
295  gridNames.push_back(gridNameStream.str());
296  gridNamesStream << gridNames[iGrid-1];
297  if(iGrid != numDomainGrids)
298  gridNamesStream << " ";
299  }
300 
301  const std::string allGridNames(gridNamesStream.str());
302  pc2File.CreateAttribute(domainGroupName+"/numGrids",attSize1,&numDomainGrids);
303  pc2File.CreateAttribute(domainGroupName+"/gridNames",allGridNames);
304 
305  pcpp::field::metadataset domainParamDict(pcpp::util::ExtractDictionary(parameterDictionary,'d'));
306  pcpp::field::metadataset domainStateDict(pcpp::util::ExtractDictionary(stateDictionary,'d'));
307  pcpp::field::metadataset meshParamDictionary(pcpp::util::ExtractDictionary(parameterDictionary,'m'));
308  pcpp::field::metadataset meshStateDictionary(pcpp::util::ExtractDictionary(stateDictionary,'m'));
309  pcpp::field::metadataset nodeStateDictionary(pcpp::util::ExtractDictionary(stateDictionary,'n'));
310  pcpp::field::metadataset cellStateDictionary(pcpp::util::ExtractDictionary(stateDictionary,'c'));
311 
312  domainParamDict.Append(meshParamDictionary);
313  domainStateDict.Append(meshStateDictionary);
314  domainStateDict.Append(nodeStateDictionary);
315  domainStateDict.Append(cellStateDictionary);
316 
317  if(!domainParamDict.empty()){
318  std::ostringstream dictionaryOut;
319  dictionaryOut << domainParamDict;
320  std::string dictionaryString(dictionaryOut.str());
321  pc2File.CreateAttribute(domainGroupName+"/paramDictionary",dictionaryString);
322  }
323 
324  if(!domainStateDict.empty()){
325  std::ostringstream dictionaryOut;
326  dictionaryOut << domainStateDict;
327  std::string dictionaryString(dictionaryOut.str());
328  pc2File.CreateAttribute(domainGroupName+"/stateDictionary",dictionaryString);
329  }
330 
331  for(int iGrid = 0;iGrid < numDomainGrids;iGrid++){
332  std::string gridGroupName(domainGroupName+"/"+gridNames[iGrid]);
333  const std::string &domainFullGridName(domainGridNames[iGrid]);
334  pc2File.CreateGroup(gridGroupName);
335  pc2File.CreateAttribute(gridGroupName+"/gridPath",domainFullGridName);
336  }
337  pc2File.Close();
338  }
339 
340  domainCommunicator.Barrier();
341 
342  const std::vector<int> &localGridIndices(inDomain.LocalGridIndices());
343 
344  std::map<std::string,bool> gridHasBeenWritten;
345  for(int iGrid = 0;iGrid < numDomainGrids;iGrid++)
346  gridHasBeenWritten.insert(std::make_pair(domainGridNames[iGrid],false));
347  bool simStateWritten = false;
348  bool domainStateWritten = false;
349  for(int iGrid = 0;iGrid < numDomainGrids;iGrid++){
350  const std::string &fullGridName(domainGridNames[iGrid]);
351  typename DomainType::GridType &currentGrid(inDomain.Grid(iGrid));
352  int numDim = currentGrid.Dimension();
353  const std::vector<size_t> &currentGridSizes(currentGrid.GridSizes());
354  std::vector<int>::const_iterator localGridIt = std::find(localGridIndices.begin(),
355  localGridIndices.end(),
356  iGrid);
357  if(localGridIt != localGridIndices.end()){ // This processor has a piece of the grid
358  pcpp::CommunicatorType &gridCommunicator(currentGrid.Communicator());
359  std::string::size_type x = fullGridName.find_last_of(":");
360  const std::string geometryName(fullGridName.substr(0,x));
361  const std::string gridName(fullGridName.substr(x+1));
362  const std::string geometryPath(std::string("/PlasCom2/Geometry/")+geometryName);
363  pcpp::io::hdf5::base pc2File(fileName,gridCommunicator);
364  pc2File.SetMessageStream(outStream);
365  if(!gridHasBeenWritten[fullGridName]){
366  pcpp::io::hdf5::WriteGrid(currentGrid,gridName,geometryPath,pc2File);
367  gridHasBeenWritten[fullGridName] = true;
368  }
369  std::ostringstream simGridNameStream;
370  simGridNameStream << "grid" << iGrid+1;
371  const std::string simGridName(simGridNameStream.str());
372  typename DomainType::StateType &inState(inDomain.State(iGrid));
373  typename DomainType::StateType &paramState(inDomain.Param(iGrid));
374  if(!simStateWritten){
375  pcpp::io::hdf5::WriteStateAttributes(inState,'s',"/PlasCom2/Simulation",pc2File);
376  pcpp::io::hdf5::WriteStateAttributes(paramState,'s',"/PlasCom2/Simulation",pc2File);
377  int iStep = inDomain.Step();
378  // double simTime = inDomain.Time();
379  pc2File.CreateAttribute("/PlasCom2/Simulation/stepNumber",attSize1,&iStep);
380  // pc2File.CreateAttribute("/PlasCom2/Simulation/simTime",attSize1,&simTime);
381  simStateWritten = true;
382  }
383  if(!domainStateWritten){
384  pcpp::io::hdf5::WriteStateAttributes(inState,'d',domainGroupName,pc2File);
385  pcpp::io::hdf5::WriteStateAttributes(paramState,'d',domainGroupName,pc2File);
386  pc2File.CreateAttribute(domainGroupName+"/stepNumber",attSize1,&iStep);
387  domainStateWritten = true;
388  }
389 
390  const std::string simGridGroupName(domainGroupName+"/"+simGridName);
391 
392  std::vector<size_t> sizeAtt(1,numDim);
393  pc2File.CreateAttribute(simGridGroupName+"/gridSize",sizeAtt,&currentGridSizes[0]);
394  pcpp::io::hdf5::WriteStateAttributes(paramState,'m',simGridGroupName,pc2File);
395  pcpp::io::hdf5::WriteStateAttributes(inState,'m',simGridGroupName,pc2File);
396  pcpp::IndexIntervalType partInterval(currentGrid.PartitionInterval());
397  pcpp::IndexIntervalType partitionBufferInterval(currentGrid.PartitionBufferInterval());
398  std::vector<size_t> partitionSizes(partInterval.Sizes());
399  std::vector<size_t> partitionStarts(partInterval.Starts());
400  std::vector<size_t> partitionBufferStarts(partitionBufferInterval.Starts());
401  std::vector<size_t> gridSizes(currentGrid.GridSizes());
402  std::vector<size_t> bufferSizes(currentGrid.BufferSizes());
403 
404  if(pcpp::io::hdf5::WriteStateNodeData(inState,gridSizes,partitionSizes,partitionStarts,
405  bufferSizes,partitionBufferStarts,simGridGroupName,pc2File)){
406  outStream << "ERROR! Failed to write state node data for " << simGridGroupName << std::endl;
407  return(1);
408  }
409  pc2File.Close();
410  }
411  domainCommunicator.Barrier();
412  }
413 
414  if(domainRank == 0){
415  pcpp::io::xdmf::WriteDomainFile(fileName,inDomain);
416  }
417 
418  domainCommunicator.Barrier();
419 
420  return(0);
421  };
422 
423 
424  template<typename GridType,typename StateType,typename ConfigType>
425  int InputSingle(const std::string &fileName,
426  const std::string &domainName,
427  const std::string &geometryName,
428  const std::string &gridName,
429  GridType &inGrid,
430  StateType &inState,
431  StateType &paramState,
432  ConfigType &simConfig,
433  std::ostream &outStream){
434 
435  pcpp::CommunicatorType &gridComm(inGrid.Communicator());
436 
437  // Begin PlasCom2 input
438  if(!ix::sys::FILEEXISTS(fileName))
439  return(1);
440 
441  int numDomains = 1;
442 
443  int myRank = gridComm.Rank();
444 
445  pcpp::io::hdf5::base pc2File(fileName,gridComm);
446  pc2File.SetMessageStream(outStream);
447 
448  std::string configString;
449  pc2File.ReadAttribute("/PlasCom2/Configuration/Parameters",configString);
450  std::istringstream configStream(configString);
451  configStream >> simConfig;
452 
453 
454  std::string geomGroupName(std::string("/PlasCom2/Geometry/")+geometryName);
455  std::string geomGridGroupName(geomGroupName+"/"+gridName);
456  pcpp::io::hdf5::ReadGrid(inGrid,geomGridGroupName,pc2File);
457 
458 
459  pcpp::io::hdf5::ReadStateAttributes(inState,'s',"/PlasCom2/Simulation",pc2File);
460  pcpp::io::hdf5::ReadStateAttributes(paramState,'s',"/PlasCom2/Simulation",pc2File);
461  std::string domainGroupName(std::string("/PlasCom2/Simulation/")+domainName);
462 
463  std::string domainGridName(gridName);
464  pcpp::io::hdf5::ReadStateAttributes(inState,'d',domainGroupName,pc2File);
465  pcpp::io::hdf5::ReadStateAttributes(paramState,'d',domainGroupName,pc2File);
466  std::string gridGroupName(domainGroupName+"/"+domainGridName);
467 
468  pcpp::IndexIntervalType partInterval(inGrid.PartitionInterval());
469  pcpp::IndexIntervalType partitionBufferInterval(inGrid.PartitionBufferInterval());
470  std::vector<size_t> partitionSizes(partInterval.Sizes());
471  std::vector<size_t> partitionStarts(partInterval.Starts());
472  std::vector<size_t> partitionBufferStarts(partitionBufferInterval.Starts());
473  std::vector<size_t> gridSizes(inGrid.GridSizes());
474  std::vector<size_t> bufferSizes(inGrid.BufferSizes());
475 
476  pcpp::io::hdf5::ReadStateNodeData(inState,gridSizes,partitionSizes,partitionStarts,
477  bufferSizes,partitionBufferStarts,gridGroupName,pc2File);
478  pc2File.Close();
479 
480  return(0);
481  }
482 
483  template<typename GridType,typename StateType,typename ConfigType>
484  int InputSingle(const std::string &fileName,
485  const std::string &domainName,
486  const std::string &geometryName,
487  const std::string &gridName,
488  GridType &inGrid,
489  StateType &inState,
490  StateType &paramState,
491  ConfigType &simConfig,
492  std::ostream &outStream,
493  int &iStep){
494 
495  pcpp::CommunicatorType &gridComm(inGrid.Communicator());
496 
497  // Begin PlasCom2 input
498  if(!ix::sys::FILEEXISTS(fileName))
499  return(1);
500 
501  int numDomains = 1;
502 
503  int myRank = gridComm.Rank();
504 
505  pcpp::io::hdf5::base pc2File(fileName,gridComm);
506  pc2File.SetMessageStream(outStream);
507 
508  std::string configString;
509  pc2File.ReadAttribute("/PlasCom2/Configuration/Parameters",configString);
510  std::istringstream configStream(configString);
511  configStream >> simConfig;
512 
513 
514  std::string geomGroupName(std::string("/PlasCom2/Geometry/")+geometryName);
515  std::string geomGridGroupName(geomGroupName+"/"+gridName);
516  pcpp::io::hdf5::ReadGrid(inGrid,geomGridGroupName,pc2File);
517 
518 
519  pcpp::io::hdf5::ReadStateAttributes(inState,'s',"/PlasCom2/Simulation",pc2File);
520  pcpp::io::hdf5::ReadStateAttributes(paramState,'s',"/PlasCom2/Simulation",pc2File);
521  pc2File.ReadAttribute("/PlasCom2/Simulation/stepNumber",&iStep);
522 
523  std::string domainGroupName(std::string("/PlasCom2/Simulation/")+domainName);
524 
525  std::string domainGridName(gridName);
526  pcpp::io::hdf5::ReadStateAttributes(inState,'d',domainGroupName,pc2File);
527  pcpp::io::hdf5::ReadStateAttributes(paramState,'d',domainGroupName,pc2File);
528  std::string gridGroupName(domainGroupName+"/"+domainGridName);
529 
530  pcpp::IndexIntervalType partInterval(inGrid.PartitionInterval());
531  pcpp::IndexIntervalType partitionBufferInterval(inGrid.PartitionBufferInterval());
532  std::vector<size_t> partitionSizes(partInterval.Sizes());
533  std::vector<size_t> partitionStarts(partInterval.Starts());
534  std::vector<size_t> partitionBufferStarts(partitionBufferInterval.Starts());
535  std::vector<size_t> gridSizes(inGrid.GridSizes());
536  std::vector<size_t> bufferSizes(inGrid.BufferSizes());
537 
538  pcpp::io::hdf5::ReadStateNodeData(inState,gridSizes,partitionSizes,partitionStarts,
539  bufferSizes,partitionBufferStarts,gridGroupName,pc2File);
540  pc2File.Close();
541 
542  return(0);
543  }
544 
545  template<typename ConfigType>
546  int FileInfo(const std::string &fileName,
547  pcpp::io::simfileinfo &fileInfo,
548  ConfigType &simConfig,
549  std::ostream &outStream,
550  pcpp::CommunicatorType *commPtr = NULL){
551 
552 
553 
554  // Begin PlasCom2 output
555  if(!ix::sys::FILEEXISTS(fileName))
556  return(1);
557 
558  int myRank = 0;
559 
560  if(commPtr)
561  myRank = commPtr->Rank();
562 
563  pcpp::io::hdf5::base pc2File;
564  if(commPtr)
565  pc2File.Open(fileName,commPtr);
566  else
567  pc2File.Open(fileName);
568 
569  pc2File.SetMessageStream(outStream);
570 
571  std::string configString;
572  pc2File.ReadAttribute("/PlasCom2/Configuration/Parameters",configString);
573  std::istringstream configStream(configString);
574  configStream >> simConfig;
575 
576  if(pcpp::io::hdf5::PlasCom2FileInfo(pc2File,fileInfo,outStream))
577  return(1);
578 
579  pc2File.Close();
580  return(0);
581  }
582 
583  int ReadSingle(const pcpp::io::simfileinfo &fileInfo,
584  plascom2::grid_t &inGrid,
585  plascom2::state_t &inState,
586  std::ostream &infoStream);
587 
588  int ReadSingle(const pcpp::io::simfileinfo &fileInfo, int gridIndex,
589  plascom2::grid_t &inGrid,
590  plascom2::state_t &inState,
591  std::ostream &infoStream);
592 
593  // Collective call, everyone in the grid communicator must call
594  int ReadSingleState(const std::string &fileName,
595  plascom2::grid_t &inGrid,
596  plascom2::state_t &inState,
597  std::ostream &infoStream);
598 
599  }
600 #endif // hdf5
601  }
602 }
603 
604 #endif
pcpp::field::metadataset::Append
void Append(const metadataset &inMetaData)
Definition: PCPPFieldData.H:290
plascom2::io::hdf5::ReadSingle
int ReadSingle(const pcpp::io::simfileinfo &fileInfo, plascom2::grid_t &inGrid, plascom2::state_t &inState, std::ostream &infoStream)
Definition: PC2IO.C:9
ix::sys::Remove
int Remove(const std::string &fname)
Definition: UnixUtils.C:141
pcpp::io::hdf5::base::ReadAttribute
int ReadAttribute(const std::string &inName, int *inBuf)
Definition: PCPPHDF5.C:1029
plascom2::io::hdf5::ReadSingleState
int ReadSingleState(const std::string &fileName, plascom2::grid_t &inGrid, plascom2::state_t &inState, std::ostream &infoStream)
Definition: PC2IO.C:240
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
pcpp::util::ExtractDictionary
pcpp::field::metadataset ExtractDictionary(const pcpp::field::metadataset &dataDictionary, const char loc)
Definition: PCPPUtil.C:9
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
plascom2
Definition: PC2IO.H:10
pcpp::io::hdf5::base::SetMessageStream
void SetMessageStream(std::ostream &outStream)
Definition: PCPPHDF5.H:233
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
plascom2::io::hdf5::OutputSingle
int OutputSingle(const std::string &fileName, const GridType &inGrid, const StateType &inState, const ConfigType &simConfig, const ConfigType &gridConfig, const ConfigType &stateConfig)
Definition: PlasCom2IO.C:12
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::hdf5::PlasCom2FileInfo
int PlasCom2FileInfo(pcpp::io::hdf5::base &hdf5File, simfileinfo &fileInfo, std::ostream &messageStream)
Definition: PCPPHDF5.C:276
apptools::parameters::GetFlagValue
bool GetFlagValue(const std::string &key) const
Definition: AppTools.H:171
pcpp::io::hdf5::base::CreateGroup
int CreateGroup(const std::string &inName)
Definition: PCPPHDF5.C:2353
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
bufferSizes
void const size_t const size_t * bufferSizes
Definition: MetricKernels.H:19
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::CreateAttribute
int CreateAttribute(const std::string &inName, const std::vector< size_t > &spaceDimensions, size_t sizeInBytes=8)
Definition: PCPPHDF5.C:2482
simulation::grid::parallel_blockstructured
Definition: Grid.H:387
apptools::parameters::IsSet
bool IsSet(const std::string &Key) const
Definition: AppTools.H:336
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