PCPPUtil.C

Go to the documentation of this file.

#include "PCPPUtil.H"
#include "PCPPHDF5.H"

namespace pcpp { 

  namespace util {
    

    pcpp::field::metadataset ExtractDictionary(const pcpp::field::metadataset &dataDictionary,
                                               const char loc)
    {
      pcpp::field::metadataset returnMeta;
      pcpp::field::metadataset::const_iterator mdIt = dataDictionary.begin();
      while(mdIt != dataDictionary.end()){
        const pcpp::field::metadata &fieldMetaData(*mdIt++); 
        if(fieldMetaData.loc == loc)
          returnMeta.push_back(fieldMetaData);
      }
      return(returnMeta);
    };


    int ErrorMetrics(int numDim,size_t numPoints,double *dataBuffer,
                     double *normData,size_t &maxErrLocation)
    {
      
      normData[0]      = -1.0*std::numeric_limits<double>::max();
      normData[1]      = 0.0;
      normData[2]      = 0.0;
      normData[3]      = 0.0;
      maxErrLocation   = 0;
      
      double &infNorm(normData[0]);
      double &oneNorm(normData[1]);
      double &twoNorm(normData[2]);
      double &errSum(normData[3]);
      
      for(size_t iPoint = 0;iPoint < numPoints;iPoint++){
        double dataVal = dataBuffer[iPoint];
        double absVal  = std::abs(dataVal);
        double absVal2 = absVal*absVal;
        errSum  += dataVal;
        oneNorm += absVal;
        twoNorm += absVal2;
        if(absVal > infNorm){
          infNorm = absVal;
          maxErrLocation = iPoint;
        }    
      }
      
      twoNorm = std::sqrt(twoNorm);
      
      return(0);
      
    };

    std::string GetConfigName(const std::string &configKey,int nameDepth=0){
      
      std::string::size_type xLast = std::string::npos;
      while(nameDepth-- >= 0){
        std::string::size_type x = configKey.find(":");
        if(x != std::string::npos)
          xLast = x;
      }
      if(xLast == std::string::npos)
        return(configKey);
      return(configKey.substr(0,xLast));
    }

    pcpp::ConfigType ExtractConfigParams(const fixtures::ConfigurationType &inConfig,
                                         const std::string       &configName)
    {
      pcpp::ConfigType subConfig;
      pcpp::ConfigType::const_iterator configIt = inConfig.begin();
      while(configIt != inConfig.end()){
        std::string::size_type x = (configIt->Key()).find(configName);
        if(x != std::string::npos)
          subConfig.push_back(*configIt);
        configIt++;
      }
      if(!subConfig.empty()){
        pcpp::ConfigType::ParamType nameParam;
        nameParam.first  = "ConfigName";
        nameParam.second = configName;
        subConfig.push_back(nameParam);
      }
      return(subConfig);
    };

    pcpp::ConfigType GetSubConfig(const std::string &subConfigName,const pcpp::ConfigType &inConfig)
    {
      pcpp::ConfigType returnConfig;
      const std::string subKey(subConfigName+":");
      int numChar = subKey.size();
      pcpp::ConfigType::const_iterator configIt = inConfig.begin();
      while(configIt != inConfig.end()){
        pcpp::ConfigType::ParamType configParam(*configIt++);
        std::string::size_type x = configParam.first.find(subKey);
        if(x == 0){
          configParam.first.erase(x,numChar);
          returnConfig.push_back(configParam);
        }
      }
      if(!returnConfig.empty()){
        pcpp::ConfigType::ParamType configParam;
        configParam.first = "ConfigName";
        configParam.second = subConfigName;
        returnConfig.push_back(configParam);
      }
      return(returnConfig);
    };

    void GetFieldMetaFromTokens(pcpp::field::metadata &metaData,
                                std::vector<std::string> &inTokens)
    {
      if(inTokens.empty())
        return;
      std::vector<std::string>::iterator tokIt = inTokens.begin();
      std::ostringstream Ostr;
      while(tokIt != inTokens.end())
        Ostr << *tokIt++ << " ";
      std::istringstream Istr(Ostr.str());
      Istr >> metaData.ncomp >> metaData.loc >> metaData.dsize;
      if(inTokens.size() == 4)
        Istr >> metaData.unit;
      return;
    };
                               
    int ConfigureDataDictionary(pcpp::ConfigType &inConfig,
                                const std::string &dictName,
                                pcpp::field::metadataset &dataDictionary,
                                std::ostream &messageStream)
    {
      std::string configName(inConfig.GetValue("ConfigName"));
      std::string solutionKey;
      std::string stateFields(dictName+std::string(":Fields"));
      if(!configName.empty())
        solutionKey = configName+std::string(":")+stateFields;
      else
        solutionKey = stateFields;
      std::vector<std::string> fieldNames;
      fieldNames = inConfig.GetValueVector<std::string>(solutionKey);
      //      std::cout << "Number of field names: " << fieldNames.size() << std::endl;
      if(fieldNames.empty()){
        messageStream << "ConfigureMeta: Warning: No data fields configured for config("
                      << configName << ")." << std::endl;
        return(0);
      }
      std::string fieldKey;
      if(!configName.empty()){
        fieldKey = configName+std::string(":");
      }
      fieldKey += std::string("Field:");
      std::vector<std::string>::iterator fieldIt = fieldNames.begin();
      while(fieldIt != fieldNames.end()){
        std::string fieldName(*fieldIt++);
        //        std::cout << fieldName << std::endl;
        std::string metaKey(fieldKey+fieldName+std::string(":Meta"));
        //        std::cout << "metaKey = " << metaKey << std::endl;
        if(!inConfig.IsSet(metaKey)){
          messageStream << "ConfigureMeta: Warning: no metadata for field ("
                        << fieldName << ")." << std::endl;
        } else {
          std::vector<std::string> metaTokens(inConfig.GetValueVector<std::string>(metaKey));
          pcpp::field::metadata fieldMetaData;
          GetFieldMetaFromTokens(fieldMetaData,metaTokens);
          if(fieldMetaData.dsize <= 0 || fieldMetaData.dsize > 8){
            messageStream << "ConfigureMeta:Warning: invalid data size for "
                          << fieldName << ", defaulting to double(8)." << std::endl;
            fieldMetaData.dsize = 8; // default to double data
          }
          if(fieldMetaData.ncomp <= 0){
            messageStream << "ConfigureMeta:Warning: invalid number of components for "
                          << fieldName << ", defaulting to scalar(1)." << std::endl;
            fieldMetaData.ncomp = 1; // default to scalar field
          }
          fieldMetaData.loc = std::tolower(fieldMetaData.loc);
          if(fieldMetaData.loc != 'n' && fieldMetaData.loc != 'c' &&
             fieldMetaData.loc != 'm' && fieldMetaData.loc != 's' &&
             fieldMetaData.loc != 'g' && fieldMetaData.loc != 'd'){
            messageStream << "ConfigureMeta:Warning: invalid solution location for "
                          << fieldName << ", defaulting to nodes." << std::endl;
            fieldMetaData.loc = 'n';
          }
          dataDictionary.AddField(fieldName,fieldMetaData);
        }
      }
      return(0);
    };
    
    std::string ConfigKey(const std::string &configName,
                          const std::string &keyName)
    {
      if(!configName.empty()){
        std::ostringstream Ostr;
        Ostr << configName << ":" << keyName;
        return(Ostr.str());
      } else {
        return(keyName);
      }
    };
    
    int RecursiveReadConfiguration(const std::string &rootPath,
                                   std::istream &inStream,pcpp::ConfigType &plascomConfig,
                                   std::ostream &messageStream,const std::string inName)
    {
      int returnValue = 0;

      // Process the parent config
      inStream >> plascomConfig;
      if(!inName.empty()){
        pcpp::ConfigType::iterator configIt = plascomConfig.begin();
        while(configIt != plascomConfig.end()){
          pcpp::ParamType &configParam(*configIt++);
          std::string &paramKey(configParam.Key());
          paramKey = inName+":"+paramKey;
        }
      }

      // Parse through config and identify any child configurations
      // that have been specified
      pcpp::ConfigType childFileConfig;
      pcpp::ConfigType::iterator configIt = plascomConfig.begin();
      while(configIt != plascomConfig.end()){
        pcpp::ParamType &configParam(*configIt++);
        std::string paramKey(configParam.Key());
        std::string::size_type x = paramKey.find("ConfigFile");
        if(x != std::string::npos){
          messageStream << "Child configuration specified: (" << configParam.Key()
                        << " = " << configParam.Value() << ")" << std::endl;
          childFileConfig.push_back(configParam);
        }
      }

      // Process all child configs recursively next
      configIt = childFileConfig.begin();
      while(configIt != childFileConfig.end()){
        pcpp::ParamType &configParam(*configIt++);
        std::string parentParamKey(configParam.Key());
        bool isSubConfig = (parentParamKey.find("SubConfigFile") 
                            != std::string::npos);
        std::string childConfigFileName(configParam.Value());
        std::string parentConfigName(GetConfigName(parentParamKey));
        if(isSubConfig){
          messageStream << "Found sub-config (parentKey,parentName,fileName) = ("
                        << parentParamKey << "," << parentConfigName << ","
                        << childConfigFileName << ")" << std::endl;
        }
        std::ifstream inFile;
        if(!ix::sys::FILEEXISTS(childConfigFileName))
          childConfigFileName = rootPath + "/" + childConfigFileName;
        inFile.open(childConfigFileName.c_str());
        if(!inFile){
          returnValue++;
          messageStream << "Unable to open child config file: "
                        << childConfigFileName << "." << std::endl;
        } else {
          std::string recursiveName;
          if(isSubConfig)
            recursiveName = parentConfigName;
          pcpp::ConfigType childConfig;
          if(RecursiveReadConfiguration(rootPath,inFile,childConfig,messageStream,recursiveName)){
            returnValue++;
            messageStream << "Errors in processing child configuration: ("
                          << configParam.Key() << "," << configParam.Value()
                          << ")" << std::endl;
          } else {
            if(isSubConfig){
              pcpp::ConfigType::iterator childConfigIt = childConfig.begin();
              while(childConfigIt != childConfig.end()){
                pcpp::ParamType &childParam(*childConfigIt++);
                std::string &childConfigKey(childParam.Key());
                std::string childConfigName(GetConfigName(childConfigKey));
                if(childConfigName != parentConfigName){
                  std::ostringstream Ostr;
                  Ostr << parentConfigName << ":" << childConfigKey;
                  childConfigKey = Ostr.str();
                }
              }
            }
            plascomConfig.insert(plascomConfig.end(),childConfig.begin(),childConfig.end());
          }
          inFile.close();
        }
      }

      // Now allow child params to overwrite parent params
      configIt = plascomConfig.begin();
      std::map<std::string,std::string> configMap;
      while(configIt != plascomConfig.end()){
        std::string configValue(configMap[configIt->first]);
        if(!configValue.empty()){
          messageStream << "Parameter override for (" << configIt->first 
                        << "): (" << configValue << ")=>(" 
                        << configIt->second << ")" << std::endl;
        }
        configMap[configIt->first] = configIt->second;
        configIt++;
      }
      plascomConfig.resize(0);
      std::map<std::string,std::string>::iterator configMapIt = configMap.begin();
      while(configMapIt != configMap.end()){
        pcpp::ParamType configParam(configMapIt->first,configMapIt->second);
        plascomConfig.push_back(configParam);
        configMapIt++;
      }
      return(returnValue);
    };
    
    
    int ProcessConfigurationFile(const std::string &configFileName,
                                 pcpp::ConfigType &plascomConfig,
                                 pcpp::CommunicatorType &globalCommunicator,
                                 std::ostream &messageStream)
    {
      int nParams = 0;
      int error = 0;
      int myRank = globalCommunicator.Rank();

      if(myRank == 0){
        std::string fileRootPath;
        std::string::size_type x = configFileName.find_last_of("/");
        if(x != std::string::npos)
          fileRootPath = configFileName.substr(0,x);
        std::ifstream configFile;
        configFile.open(configFileName.c_str());
        if(!configFile){
          messageStream << "Could not open configuration file (" 
                        << configFileName << "). Aborting." << std::endl;
          globalCommunicator.SetExit(1);
        } else {
          std::ostringstream Ostr;
          if(RecursiveReadConfiguration(fileRootPath,configFile,plascomConfig,Ostr)){
            messageStream << "Errors processing configuration:" << std::endl
                          << Ostr.str() << "Aborting." << std::endl;
            globalCommunicator.SetExit(1);
          } else {
            std::string configMessages(Ostr.str());
            if(!configMessages.empty()){
              messageStream << Ostr.str();
              pcpp::io::RenewStream(Ostr);
            }
            configFile.close();
            nParams = plascomConfig.size();
            Ostr << "Read " << nParams << " configuration parameters "
                 << "from " << configFileName << "." << std::endl;
            messageStream << Ostr.str();
          }
        }
      }
      if(globalCommunicator.Check())
        error = 1;
      if(!error){
        if(myRank != 0){
          plascomConfig.resize(0);
        };
        globalCommunicator.BroadCast(&plascomConfig,0);
        std::ostringstream Ostr;
        Ostr << "Configuration Parameters:" << std::endl
             << plascomConfig << std::endl;
        messageStream << Ostr.str();
      }
      return(error);
    };    


    int ProcessConfigurationRestart(const std::string      &restartFileName,
                                    pcpp::ConfigType       &inConfig,
                                    pcpp::CommunicatorType &configCommunicator,
                                    std::ostream           &messageStream)
    {
      int nParams = inConfig.size();
      int error = 0;
      int myRank = configCommunicator.Rank();

      if(myRank == 0){
        pcpp::io::hdf5::base hdf5File;
        if(!ix::sys::FILEEXISTS(restartFileName)){
          messageStream << "Error: Could not file restart file ("
                        << restartFileName << ")." << std::endl;
          configCommunicator.SetErr(1);
        } else {
          if(hdf5File.Open(restartFileName,true)){
            messageStream << "Error: Failed to open file ("
                          << restartFileName << ")." << std::endl;
            configCommunicator.SetErr(1);
          } else {
            if(!hdf5File.AttributeExists("/PlasCom2/Configuration/Parameters")){
              configCommunicator.SetErr(1);
            } else {
              std::string configString;
              hdf5File.ReadAttribute("/PlasCom2/Configuration/Parameters",configString);
              hdf5File.Close();
              std::istringstream configStream(configString);
              inConfig.ReadFromStream(configStream);
              nParams = inConfig.size() - nParams;
              messageStream << "Read " << nParams << " parameters from restart file ("
                            << restartFileName << ")." << std::endl;
            }
          }
        }
      }
      if(configCommunicator.Check())
        error = 1;
      if(!error){
        if(myRank != 0){
          inConfig.resize(0);
        };
        configCommunicator.BroadCast(&inConfig,0);
        std::ostringstream Ostr;
        Ostr << "Configuration Parameters:" << std::endl
             << inConfig << std::endl;
        messageStream << Ostr.str();
      }
      return(error);
    };   
  }
}