PCPPIO.C

Go to the documentation of this file.

#include <string>
#include <map>
#include <vector>
#include <iomanip>

#include "PCPPIO.H"

namespace pcpp { 
  
  namespace io {


    bool Compatible(const pcpp::io::simfileinfo& fileInfo1,
                    const pcpp::io::simfileinfo& fileInfo2,
                    std::ostream&                infoStream)
    {
      
      if(fileInfo1.gridSizes != fileInfo2.gridSizes){
        infoStream << "Grids in two files do not have the same size." << std::endl;
        return(false);
      }
      if(fileInfo1.formatBits.test(pcpp::io::HASGRID) != fileInfo2.formatBits.test(pcpp::io::HASGRID))
        infoStream << "Warning: grid presence is not consistent between files." << std::endl;
      if(fileInfo1.formatBits.test(pcpp::io::HASSTATE) != fileInfo2.formatBits.test(pcpp::io::HASSTATE))
        infoStream << "Warning: state presence is not consistent between files." << std::endl;
      
      return(true);
    };

    std::string StepStamp(size_t inStep)
    {
      std::ostringstream Ostr;
      Ostr << std::setfill('0') << std::setw(9) << inStep;
      return(Ostr.str());
    };

//     void Everybody(const std::string &outString,std::ostream &outStream,
//                    pcpp::CommunicatorType &comm){

//       int myRank  = comm.Rank();
//       int numProc = comm.Size();

//       for(int iRank = 0;iRank < numProc;iRank++){
//         if(iRank == myRank){
//           outStream << outString << std::endl;
//         }
//         comm.Barrier();
//       }
//     };

    void Everyone(const std::string &outString,std::ostream &outStream,
                   pcpp::CommunicatorType &comm){

      int myRank  = comm.Rank();
      int numProc = comm.Size();

      for(int iRank = 0;iRank < numProc;iRank++){
        if(iRank == myRank){
          outStream << outString << std::endl;
        }
        comm.Barrier();
      }
    };

    void InitializeFileTypes(){
      std::vector<std::string> hdfFileExtensions;
      hdfFileExtensions.push_back("h5");
      hdfFileExtensions.push_back("hdf5");
      hdfFileExtensions.push_back("he5");
      hdfFileExtensions.push_back("hdf");
      fileTypeExtensions["HDF"] = hdfFileExtensions;
    };
    
    bool FileType(const std::string &inFileName,const std::string &fileType)
    {
      if(pcpp::io::fileTypeExtensions.empty()){
        pcpp::io::InitializeFileTypes();
      }
      std::string::size_type lastDot = inFileName.find_last_of(".");
      if(lastDot == std::string::npos)
        return(false);
      std::string fileExtension(inFileName.substr(lastDot+1));
      std::vector<std::string> &fileTypeExtensions(pcpp::io::fileTypeExtensions[fileType]);
      std::vector<std::string>::iterator extensionsIt = fileTypeExtensions.begin();
      while(extensionsIt != fileTypeExtensions.end()){
        if(fileExtension == *extensionsIt++)
          return(true);
      }
      return(false);
    };


    bool operator==(const simfileinfo &lhs,const simfileinfo &rhs)
    {
      
      if(lhs.numGrids      != rhs.numGrids      ||
         lhs.numAuxVars    != rhs.numAuxVars    ||
         lhs.numGeometries != rhs.numGeometries ||
         lhs.numDomains    != rhs.numDomains    ||
         lhs.simStep       != rhs.simStep       ||
         lhs.fileName      != rhs.fileName      ||
         lhs.formatBits    != rhs.formatBits    ||
         lhs.gridNames     != rhs.gridNames)
        return(false);
      
      if(lhs.gridNumDimensions != rhs.gridNumDimensions)
        return(false);
      
      
      int numGrids = lhs.gridSizes.size();
      if(rhs.gridSizes.size() != numGrids)
        return(false);
      
      for(int iGrid = 0;iGrid < numGrids;iGrid++){
        if(lhs.gridSizes[iGrid] != rhs.gridSizes[iGrid])
          return(false);
      }
      
      int numGeom = lhs.geometryNames.size();
      if(rhs.geometryNames.size() != numGeom)
        return(false);
      if(lhs.geometryNames != rhs.geometryNames)
        return(false);
      for(int iGeom = 0;iGeom < numGeom;iGeom++){
        int numGeomGrids = lhs.geometryGridNames[iGeom].size();
        if(rhs.geometryGridNames[iGeom].size() != numGeomGrids)
          return(false);
        if(rhs.geometryGridNames[iGeom] != lhs.geometryGridNames[iGeom])
          return(false);
        const std::vector<std::vector<size_t> > &lgridSizes(lhs.geometryGridSizes[iGeom]);
        const std::vector<std::vector<size_t> > &rgridSizes(rhs.geometryGridSizes[iGeom]);
        if(lgridSizes.size() != rgridSizes.size())
          return(false);
        for(int iGeomGrid = 0;iGeomGrid < numGeomGrids;iGeomGrid++)
          if(lgridSizes[iGeomGrid] != rgridSizes[iGeomGrid])
            return(false);
      }
      
      if(lhs.simulationParamDictionary != rhs.simulationParamDictionary)
        return(false);
      if(lhs.simulationStateDictionary != rhs.simulationStateDictionary)
        return(false);

      int numDomains = lhs.domainNames.size();
      if(rhs.domainNames.size() != numDomains)
        return(false);
      for(int iDomain = 0;iDomain < numDomains;iDomain++){
        if(rhs.domainNames[iDomain] != lhs.domainNames[iDomain])
          return(false);
        if(rhs.domainParamDictionaries[iDomain] != lhs.domainParamDictionaries[iDomain])
          return(false);       
        int numDomainGrids = lhs.domainGridNames[iDomain].size();
        if(rhs.domainGridNames[iDomain].size() != numDomainGrids)
          return(false);
        for(int iGrid = 0;iGrid < numDomainGrids;iGrid++){
          if(lhs.domainGridNames[iDomain][iGrid] != rhs.domainGridNames[iDomain][iGrid])
            return(false);
        }
      }
      return(true);
    };
    
    std::istream &operator>>(std::istream &inStream,simfileinfo &fileInfo)
    {
      inStream >> fileInfo.fileName >> fileInfo.formatBits;

      if(fileInfo.fileName == "[NULL]")
        fileInfo.fileName.erase();

      int numGrids = 0;
      inStream >> numGrids;
      fileInfo.numGrids = numGrids;

      int numGeometries = 0;
      inStream >> numGeometries;
      fileInfo.numGeometries = numGeometries;

      int numDomains = 0;
      inStream >> numDomains;
      fileInfo.numDomains = numDomains;

      if(numGrids <= 0)
        return(inStream);

      int numAuxVars = 0;
      inStream >> numAuxVars;
      fileInfo.numAuxVars = numAuxVars;

      int simStep = 0;
      inStream >> simStep;
      fileInfo.simStep = simStep;

      double simTime = 0;
      inStream >> simTime;
      fileInfo.simTime = simTime;
      
      int numLegacyHeader = 0;
      inStream >> numLegacyHeader;
      fileInfo.legacyHeader.resize(numLegacyHeader);
      for(int iLeg = 0;iLeg < numLegacyHeader;iLeg++)
        inStream >> fileInfo.legacyHeader[iLeg];
      
      int paramDictSize = 0;
      int stateDictSize = 0;
      
      inStream >> paramDictSize;
      if(paramDictSize > 0){
        inStream >> fileInfo.simulationParamDictionary;
      }

      inStream >> stateDictSize;
      if(stateDictSize > 0)
        inStream >> fileInfo.simulationStateDictionary;

      std::vector<std::string> &gridNames(fileInfo.gridNames);
      std::vector<int> &gridNumDimensions(fileInfo.gridNumDimensions);
      std::vector<std::string> &geometryNames(fileInfo.geometryNames);
      std::vector<std::vector<std::string> > &geometryGridNames(fileInfo.geometryGridNames);
      std::vector<std::vector<std::vector<size_t> > > &geometryGridSizes(fileInfo.geometryGridSizes);


      gridNames.resize(numGrids);
      gridNumDimensions.resize(numGrids);
      fileInfo.gridSizes.resize(0);

      for(int iGrid = 0;iGrid < numGrids;iGrid++){
        int geomIndex = 0;
        inStream >> gridNames[iGrid];
        int numDim = 0;
        inStream >> numDim;
        gridNumDimensions[iGrid] = numDim;
        std::vector<size_t> mySize;
        if(numDim > 0){
          mySize.resize(numDim,0);
          for(int iDim = 0;iDim < numDim;iDim++){
            inStream >> mySize[iDim];
          }
          fileInfo.gridSizes.push_back(mySize);
        }

        std::string &gridName(gridNames[iGrid]);
        if(gridName == "[NULL]"){
          gridName.erase();
        }
      }

      if(geometryNames.size() != numGeometries)
        geometryNames.resize(numGeometries);
      if(geometryGridNames.size() != numGeometries)
        geometryGridNames.resize(numGeometries);
      if(geometryGridSizes.size() != numGeometries)
        geometryGridSizes.resize(numGeometries);

      for(int iGeom = 0;iGeom < numGeometries;iGeom++){
        inStream >> geometryNames[iGeom];
        if(geometryNames[iGeom] == "[NULL]")
          geometryNames[iGeom].erase();
        int numGeomGrid = 0;
        inStream >> numGeomGrid;
        std::vector<std::string> &geomGridNames(geometryGridNames[iGeom]);
        std::vector<std::vector<size_t> > &geomGridSizes(geometryGridSizes[iGeom]);
        geomGridNames.resize(numGeomGrid);
        geomGridSizes.resize(numGeomGrid);
        for(int iGeomGrid = 0;iGeomGrid < numGeomGrid;iGeomGrid++){
          int geomGridDimension = 0;
          std::string geomGridName;
          std::vector<size_t> &geomGridSize(geomGridSizes[iGeomGrid]);
          inStream >> geomGridName >> geomGridDimension;
          if(geomGridName != "[NULL]")
            geomGridNames[iGeomGrid] = geomGridName;
          for(int iDim = 0;iDim < geomGridDimension;iDim++){
            int dimSize = 0;
            inStream >> dimSize;
            geomGridSize.push_back(dimSize);
          }
        }
      }

      std::vector<std::string> &domainNames(fileInfo.domainNames);
      numDomains = 0;
      inStream >> numDomains;
      if(numDomains >= 0){
        domainNames.resize(numDomains);
        for(int iDomain = 0;iDomain < numDomains;iDomain++)
          inStream >> domainNames[iDomain];
      }


      std::vector<std::vector<std::string> > &domainGridNames(fileInfo.domainGridNames);
      int numDomainGridNames = 0;
      inStream >> numDomainGridNames;
      if(numDomainGridNames >= 0){
        domainGridNames.resize(numDomainGridNames);
        for(int iDomain = 0;iDomain < numDomainGridNames;iDomain++){
          std::vector<std::string> &domGridNames(domainGridNames[iDomain]);
          int numGridNames = 0;
          inStream >> numGridNames;
          if(numGridNames > 0){
            domGridNames.resize(numGridNames);
            for(int iName = 0;iName < numGridNames;iName++)
              inStream >> domGridNames[iName];
          }
        }
      }

      std::vector<std::vector<std::string> > &domainGridPaths(fileInfo.domainGridPaths);
      int numDomainGridPaths = 0;
      inStream >> numDomainGridPaths;
      if(numDomainGridPaths >= 0){
        domainGridPaths.resize(numDomainGridPaths);
        for(int iDomain = 0;iDomain < numDomainGridPaths;iDomain++){
          std::vector<std::string> &domGridPaths(domainGridPaths[iDomain]);
          int numGridPaths = 0;
          inStream >> numGridPaths;
          if(numGridPaths > 0){
            domGridPaths.resize(numGridPaths);
            for(int iPath = 0;iPath < numGridPaths;iPath++)
              inStream >> domGridPaths[iPath];
          }
        }
      }
      
      std::vector<pcpp::field::metadataset>  &domainParamDictionaries(fileInfo.domainParamDictionaries);
      int numDomainParamDict = 0;
      inStream >> numDomainParamDict;
      if(numDomainParamDict >= 0){
        domainParamDictionaries.resize(numDomainParamDict);
        for(int iDict = 0;iDict < numDomainParamDict;iDict++){
          pcpp::field::metadataset &paramDict(domainParamDictionaries[iDict]);
          int dictionarySize = 0;
          inStream >> dictionarySize;
          if(dictionarySize > 0){
            inStream >> paramDict;
          }
        }
      }

      std::vector<pcpp::field::metadataset>  &domainStateDictionaries(fileInfo.domainStateDictionaries);
      int numDomainStateDict = 0;
      inStream >> numDomainStateDict;
      if(numDomainStateDict >= 0){
        domainStateDictionaries.resize(numDomainStateDict);
        for(int iDict = 0;iDict < numDomainStateDict;iDict++){
          pcpp::field::metadataset &stateDict(domainStateDictionaries[iDict]);
          int dictionarySize = 0;
          inStream >> dictionarySize;
          if(dictionarySize > 0){
            inStream >> stateDict;
          }
        }
      }

      return(inStream);
    };



    std::ostream &operator<<(std::ostream &outStream,const simfileinfo &fileInfo)
    {

      std::string fileName(fileInfo.fileName);
      if(fileName.empty())
        fileName = "[NULL]";

      outStream << fileName << " ";

      const std::bitset<NUMFORMATBITS> &formatBits(fileInfo.formatBits);
      outStream << formatBits << " ";

      int numGrids = fileInfo.numGrids;
      outStream << numGrids << " ";
//       if(numGrids == 0){
//         return(outStream);
//       }

      int numGeometries = fileInfo.numGeometries;
      outStream << numGeometries << " ";
      
      int numDomains = fileInfo.numDomains;
      outStream << numDomains << " ";

      int numAuxVar = fileInfo.numAuxVars;
      outStream << numAuxVar << " ";

      int simStep = fileInfo.simStep;
      outStream << simStep << " ";

      double simTime = fileInfo.simTime;
      outStream << simTime << " ";
      
      int numLegacyHeader = fileInfo.legacyHeader.size();
      outStream << numLegacyHeader << " ";
      for(int iLeg = 0;iLeg < numLegacyHeader;iLeg++)
        outStream << fileInfo.legacyHeader[iLeg] << " ";
      
      int paramDictSize = fileInfo.simulationParamDictionary.size();
      outStream << paramDictSize << " ";
      if(paramDictSize > 0){
        outStream << std::endl << fileInfo.simulationParamDictionary << std::endl;
      }
      int stateDictSize = fileInfo.simulationStateDictionary.size();
      outStream << stateDictSize << " ";
      if(stateDictSize > 0){
        outStream << std::endl << fileInfo.simulationStateDictionary << std::endl;
      }

      std::vector<std::string> gridNames(fileInfo.gridNames);
      if(gridNames.size() != numGrids){
        gridNames.resize(numGrids,"[NULL]");
      }

      std::vector<int> gridNumDim(fileInfo.gridNumDimensions);
      if(gridNumDim.size() != numGrids){
        gridNumDim.resize(numGrids,0);
      }
      
      std::vector<std::vector<size_t> > gridSizes(fileInfo.gridSizes);
      if(gridSizes.size() != numGrids){
        std::vector<size_t> gSize(3,0);
        gridSizes.resize(numGrids,gSize);
      }
      
      for(int iGrid = 0;iGrid < numGrids;iGrid++){
        outStream << gridNames[iGrid] << " " 
                  << gridNumDim[iGrid] << " ";
        std::vector<size_t> &gridSize(gridSizes[iGrid]);
        for(int iDim = 0;iDim < gridNumDim[iGrid];iDim++){
          outStream << gridSize[iDim] << " ";
        } 
      }

      std::vector<std::string> geometryNames(fileInfo.geometryNames);
      std::vector<std::vector<std::string> > geometryGridNames(fileInfo.geometryGridNames);
      std::vector<std::vector<std::vector<size_t> > > geometryGridSizes(fileInfo.geometryGridSizes);

      if(geometryNames.size() != numGeometries)
        geometryNames.resize(numGeometries,"[NULL]");
      if(geometryGridNames.size() != numGeometries)
        geometryGridNames.resize(numGeometries);
      if(geometryGridSizes.size() != numGeometries)
        geometryGridSizes.resize(numGeometries);

      for(int iGeom = 0;iGeom < numGeometries;iGeom++){
        outStream << geometryNames[iGeom] << " ";
        int numGeomGrid = geometryGridNames[iGeom].size();
        outStream << numGeomGrid << " ";
        std::vector<std::string> &geomGridNames(geometryGridNames[iGeom]);
        if(geomGridNames.size() != numGeomGrid)
          geomGridNames.resize(numGeomGrid,"[NULL]");
        std::vector<std::vector<size_t> > &geomGridSizes(geometryGridSizes[iGeom]);
        if(geomGridSizes.size() != numGeomGrid)
          geomGridSizes.resize(numGeomGrid);
        for(int iGeomGrid = 0;iGeomGrid < numGeomGrid;iGeomGrid++){
          int geomGridDimension = geomGridSizes[iGeomGrid].size();
          outStream << geomGridNames[iGeomGrid] << " " << geomGridDimension << " ";
          for(int iDim = 0;iDim < geomGridDimension;iDim++)
            outStream << geomGridSizes[iGeomGrid][iDim] << " ";
        }
      }
      
      const std::vector<std::string> &domainNames(fileInfo.domainNames);
      numDomains = domainNames.size();
      outStream << numDomains << " ";
      if(numDomains > 0){
        std::vector<std::string>::const_iterator dnIt = domainNames.begin();
        while(dnIt != domainNames.end()){
          outStream << *dnIt++ << " ";
        }
      }
      
      const std::vector<std::vector<std::string> > &domainGridNames(fileInfo.domainGridNames);
      int numDomainGridNames = domainGridNames.size();
      outStream << numDomainGridNames << " ";
      if(numDomainGridNames > 0){
        for(int iDomain = 0;iDomain < numDomainGridNames;iDomain++){
          const std::vector<std::string> &domGridNames(domainGridNames[iDomain]);
          int numGridNames = domGridNames.size();
          outStream << numGridNames << " ";
          if(numGridNames > 0){
            std::vector<std::string>::const_iterator dnIt = domGridNames.begin();
            while(dnIt != domGridNames.end()){
              outStream << *dnIt++ << " ";
            }
          }
        }
      }

      const std::vector<std::vector<std::string> > &domainGridPaths(fileInfo.domainGridPaths);      
      int numDomainGridPaths = domainGridPaths.size();
      outStream << numDomainGridPaths << " ";
      if(numDomainGridPaths > 0){
        for(int iDomain = 0;iDomain < numDomainGridPaths;iDomain++){
          const std::vector<std::string> &domGridPaths(domainGridPaths[iDomain]);
          int numGridPaths = domGridPaths.size();
          outStream << numGridPaths << " ";
          if(numGridPaths > 0){
            std::vector<std::string>::const_iterator dnIt = domGridPaths.begin();
            while(dnIt != domGridPaths.end()){
              outStream << *dnIt++ << " ";
            }
          }
        }
      }

      const std::vector<pcpp::field::metadataset>  &domainParamDictionaries(fileInfo.domainParamDictionaries);
      int numDomainParamDict = domainParamDictionaries.size();
      outStream << numDomainParamDict << " ";
      if(numDomainParamDict > 0){
        for(int iDict = 0;iDict < numDomainParamDict;iDict++){
          const pcpp::field::metadataset &paramDict(domainParamDictionaries[iDict]);
          int dictionarySize = paramDict.size();
          outStream << dictionarySize << " ";
          if(dictionarySize > 0){
            outStream << std::endl << paramDict;
          }
        }
      }

      const std::vector<pcpp::field::metadataset>  &domainStateDictionaries(fileInfo.domainStateDictionaries);
      int numDomainStateDict = domainStateDictionaries.size();
      outStream << numDomainStateDict << " ";
      if(numDomainStateDict > 0){
        for(int iDict = 0;iDict < numDomainStateDict;iDict++){
          const pcpp::field::metadataset &stateDict(domainStateDictionaries[iDict]);
          int dictionarySize = stateDict.size();
          outStream << dictionarySize << " ";
          if(dictionarySize > 0){
            outStream << std::endl << stateDict;
          }
        }
      }

      return(outStream);
    };


//     struct simfileinfo {


//       // Detailed geometry description

//       std::vector<std::string>               domainNames;
//       std::vector<std::vector<std::string> > domainGridNames;
//       std::vector<std::vector<std::string> > domainGridPaths;
//       std::vector<pcpp::field::metadataset>  domainParamDictionaries;
//       std::vector<pcpp::field::metadataset>  domainStateDictionaries;

//     };




  }
}