PC2Util.H

Go to the documentation of this file.

#ifndef __PC2_UTIL_H__
#define __PC2_UTIL_H__

#include "PlasCom2.H"
#include "PC2IO.H"
#include "EulerUtil.H"
#include "Geometry.H"

namespace plascom2 {
  namespace util {
    
    struct legacybc {
      legacybc() : gridID(-1), bcType(-1), bcDir(-1) {};
      int gridID;
      int bcType;
      int bcDir;
      int bcInterval[6];
    };

    std::ostream &operator<<(std::ostream &outStream,const legacybc &bcDat);
    std::istream &operator>>(std::istream &inStream,legacybc &bcDat);
    bool operator==(const legacybc &lhs,const legacybc &rhs);
    bool operator!=(const legacybc &lhs,const legacybc &rhs);

    int ReadLegacyBCDat(const std::string &bcFileName,std::vector<legacybc> &bcDat,
                        fixtures::CommunicatorType &inCommunicator,std::ostream &messageStream);
    
    int ConvertLegacyConfiguration(fixtures::ConfigurationType &inConfig,
                                   fixtures::CommunicatorType &inCommunicator,
                                   std::ostream &messageStream);

    //     int SplitDomains(const ConfigurationType &inConfig,
    //                      CommunicatorType &inCommunicator, 
    //                      simulation::DomainInfoType &domainPartitionInfo,
    //                      std::vector<simulation::DomainType> &localDomains,
    //                      std::ostream &messageStream);
    
    int PC2Compare(const std::string &redFileName,const std::string &blueFileName,
                   double errTolerance,std::ostream &outStream);


    template<typename GridType>
    int ConfigureGridSubRegions(const fixtures::ConfigurationType &inConfig,
                                const std::string &gridName,
                                GridType &inGrid,std::ostream &messageStream)
    {
      messageStream << "Configuring subregions of " << gridName << "." << std::endl;

      std::vector<simulation::grid::subregion> &gridSubRegions(inGrid.SubRegions());
      const std::string subRegionKey(ConfigKey(gridName,"RegionNames"));
      messageStream << "sub-Region Key: " << subRegionKey << std::endl;
      std::vector<std::string> subRegionNames(inConfig.GetValueVector<std::string>(ConfigKey(gridName,"RegionNames")));
      messageStream << "Found " << subRegionNames.size() << " sub-regions." << std::endl;
      if(subRegionNames.empty())
        return(0);

      std::vector<size_t> &gridSizes(inGrid.GridSizes()); // note grid sizes, *not* bufferSizes
      if(gridSizes.empty()){
        messageStream << "ERROR: Grid sizes not specified." << std::endl;
        return(1);
      } else {
        size_t numPointsGrid = 1;
        std::vector<size_t>::iterator gsIt = gridSizes.begin();
        while(gsIt != gridSizes.end())
          numPointsGrid *= *gsIt++;
        if(numPointsGrid == 0){
          messageStream << "ERROR: Grid sizes mis-configured, found zero points." << std::endl;
          return(1);
        }
      }
      
      std::vector<std::string>::iterator regionNameIt = subRegionNames.begin();
      
      while(regionNameIt != subRegionNames.end()){

        simulation::grid::subregion subRegion;
        std::string &regionName(*regionNameIt++);
        messageStream << "Configuring sub-region [" << regionName << "]" << std::endl;

        std::string configKey(ConfigKey(gridName,regionName));
        std::string configValue(inConfig.GetValue(configKey));
        std::string configString(regionName+" "+configValue);

        messageStream << "ConfigKey: " << configKey       << std::endl
                      << "ConfigValue: " << configValue   << std::endl
                      << "ConfigString: " << configString << std::endl;

        if(simulation::grid::InitSubRegionFromString(configString,gridSizes,subRegion))
          return(1);

        gridSubRegions.push_back(subRegion);
      
      } // while

      return(0);

    };


    template<typename GridType>
    int ConfigureGrid(const fixtures::ConfigurationType &inConfig,
                      const std::string &gridName,
                      GridType &inGrid,
                      std::ostream &messageStream)
    {
      messageStream << "Configuring grid [" << gridName << "]" << std::endl;
      std::vector<size_t> gridSizes(inConfig.GetValueVector<size_t>(ConfigKey(gridName,"NumPoints")));
      int numDim = gridSizes.size();
      int gridType = simulation::grid::UNIRECT;
      std::string defaultGridTypeName("Uniform-rectangular");
      if(inConfig.IsSet(ConfigKey(gridName,"Type"))){
        std::string typeName(inConfig.GetValue(ConfigKey(gridName,"Type")));
        if(typeName == "Uniform") typeName = defaultGridTypeName;
        int gType = simulation::grid::ResolveTopoName(typeName);
        if(gType >= 0 && gType < simulation::grid::NUMTOPOTYPE)
          gridType = gType;
        else
          messageStream << "Warning: Invalid grid type specified (" << typeName 
                        << "). Defaulting to grid type (" << defaultGridTypeName
                        << ")." << std::endl;
      }
      std::string typeName(simulation::grid::ResolveTopoType(gridType));
      messageStream << "Grid (" << gridName << ") Type: " << typeName << std::endl;
      inGrid.SetGridSizes(gridSizes);
      inGrid.SetType(gridType);
      if(inConfig.IsSet(ConfigKey(gridName,"PhysicalExtent"))){
        std::vector<double> physicalExtent(inConfig.GetValueVector<double>(ConfigKey(gridName,"PhysicalExtent")));
        inGrid.SetPhysicalExtent(physicalExtent);
      }
      if(inConfig.IsSet(ConfigKey(gridName,"DecompDirs"))){
        std::vector<int> decompDirs(inConfig.GetValueVector<int>(ConfigKey(gridName,"DecompDirs")));
        inGrid.SetDecompDirs(decompDirs);
      }
      if(inConfig.IsSet(ConfigKey(gridName,"DecompSizes"))){
        std::vector<int> decompSizes(inConfig.GetValueVector<int>(ConfigKey(gridName,"DecompSizes")));
        inGrid.SetDecompSizes(decompSizes);
      }
      if(inConfig.IsSet(ConfigKey(gridName,"ThreadDecompDirs"))){
        std::vector<int> threadDecompDirs(inConfig.GetValueVector<int>(ConfigKey(gridName,"ThreadDecompDirs")));
        inGrid.SetThreadDecompDirs(threadDecompDirs);
      }
      if(inConfig.IsSet(ConfigKey(gridName,"PeriodicDirs"))){
        std::vector<bool> periodicDirs(inConfig.GetValueVector<bool>(ConfigKey(gridName,"PeriodicDirs")));
        inGrid.SetPeriodicDirs(periodicDirs);
      }
      if(inConfig.IsSet(ConfigKey(gridName,"PeriodicLengths"))){
        std::vector<double> periodicLengths(inConfig.GetValueVector<double>(ConfigKey(gridName,"PeriodicLengths")));
        inGrid.SetPeriodicLengths(periodicLengths);
      }
      return(ConfigureGridSubRegions(inConfig,gridName,inGrid,messageStream));
    };

    int ConfigureGridInfo(const fixtures::ConfigurationType &inConfig,
                          const std::string &gridName,
                          simulation::geometry::gridinfo &gridInfo,
                          std::ostream &messageStream);

  }
}
#endif