PCPPUtil.H

Go to the documentation of this file.

#ifndef __PCPP_UTIL_H__
#define __PCPP_UTIL_H__
#include <iostream>
#include <sstream>
#include <string>

#include "PCPPTypes.H"
#include "PCPPFieldData.H"
#include "PCPPIO.H"

namespace pcpp {

  namespace util {

    int RecursiveReadConfiguration(const std::string &currentPath,
                                   std::istream &inStream,pcpp::ConfigType &plascomConfig,
                                   std::ostream &messageStream,const std::string="");

    int ProcessConfigurationFile(const std::string &configFileName,
                                 pcpp::ConfigType &plascomConfig,
                                 pcpp::CommunicatorType &globalCommunicator,
                                 std::ostream &messageStream);

    int ProcessConfigurationRestart(const std::string      &restartFileName,
                                    pcpp::ConfigType       &inConfig,
                                    pcpp::CommunicatorType &configCommunicator,
                                    std::ostream           &messageStream);

    std::string ConfigKey(const std::string &configName,const std::string &keyName);
    
    pcpp::ConfigType GetSubConfig(const std::string &configName,const pcpp::ConfigType &plascomConfig);

    int ConfigureDataDictionary(pcpp::ConfigType &inConfig,
                                const std::string &dictName,
                                pcpp::field::metadataset &dataDictionary,
                                std::ostream &messageStream);

    pcpp::field::metadataset ExtractDictionary(const pcpp::field::metadataset &dataDictionary,
                                               const char loc);

    pcpp::ConfigType ExtractConfigParams(const fixtures::ConfigurationType &inConfig,
                                         const std::string                 &configName);
    


    template<typename GridType>
    int ConfigureGrid(pcpp::ConfigType &inConfig,const std::string &gridKey,
                      pcpp::CommunicatorType &inCommunicator,GridType &inGrid,
                      std::ostream &messageStream)
    {
      return(0);
    }

    template<typename BufferDataType>
    void ReportBufferStats(std::ostream &outStream,size_t numValues,const BufferDataType *dataBuffer)
    {

      if(numValues == 0)
        return;

      size_t minLocation      = 0;
      size_t maxLocation      = 0;
      double bufferMean       = 0;
      double bufferDev        = 0; 

      BufferDataType minValue = std::numeric_limits<BufferDataType>::max();
      BufferDataType maxValue = -std::numeric_limits<BufferDataType>::max();

      for(size_t iValue = 0;iValue < numValues;iValue++){
        if(dataBuffer[iValue] < minValue){
          minValue = dataBuffer[iValue];
          minLocation = iValue;
        }
        if(dataBuffer[iValue] > maxValue){
          maxValue = dataBuffer[iValue];
          maxLocation = iValue;
        }
        bufferMean += dataBuffer[iValue];
        bufferDev  += dataBuffer[iValue]*dataBuffer[iValue];
      }

      bufferMean /= numValues;
      bufferDev  /= numValues;
      bufferDev  -= (bufferMean*bufferMean);
      bufferDev   = std::sqrt(std::abs(bufferDev));

      outStream << "Min:  " << minValue   << " @ "   << minLocation << std::endl
                << "Max:  " << maxValue   << " @ "   << maxLocation << std::endl
                << "Mean: " << bufferMean << " +/- " << bufferDev   << std::endl;
      return;
    }


    int ErrorMetrics(int numDim,size_t numPoints,double *dataBuffer,
                     double *normData,size_t &maxErrLocation);
  }
}
#endif