EOS.H

Go to the documentation of this file.

#ifndef __EOS_H__
#define __EOS_H__

#include "PCPPTypes.H"


namespace eos {
  enum GASMODELS {IDEAL=0,NUM_GAS_MODELS};

  class eos {

  public:
    eos(){Initialize();};

    void Initialize() {
      densityPtr = NULL;
      momentumPtr = NULL;
      internalEnergyPtr = NULL;
      pressurePtr = NULL;
      temperaturePtr = NULL;
      specificVolumePtr = NULL;

      xStart = 0;
      xEnd = 0;
      xSize = 0;
      yStart = 0;
      yEnd = 0;
      ySize = 0;
      zStart = 0;
      zEnd = 0;
      zSize = 0;
    };

    virtual int InitializeMaterialProperties() = 0;

    int ComputePressureBuffer(const pcpp::IndexIntervalType &regionInterval,
                              const std::vector<size_t>     &bufferSizes);

    int ComputeTemperatureBuffer(const pcpp::IndexIntervalType &regionInterval,
                                 const std::vector<size_t>     &bufferSizes);

    virtual void ComputePressure(size_t index) = 0;

    virtual void ComputeTemperature(size_t index) = 0;

    // setup the buffers
    void SetupPressureBuffer(double *const inPtr) {pressurePtr = inPtr;};
    void SetupTemperatureBuffer(double *const inPtr) {temperaturePtr = inPtr;};
    void SetupSpecificVolumeBuffer(double *const inPtr) {specificVolumePtr = inPtr;};
    void SetupDensityBuffer(double *const inPtr) {densityPtr = inPtr;};
    void SetupInternalEnergyBuffer(double *const inPtr) {internalEnergyPtr = inPtr;};

    // virtual functions dealing with material properties
    virtual double GetSpecificGasConstant() = 0;
    virtual double GetHeatCapacityCv() = 0;
    virtual double GetHeatCapacityCp() = 0;
    virtual double GetGamma() = 0;

    virtual void SetSpecificGasConstant(const double &inValue) = 0;
    virtual void SetGamma(const double &inValue) = 0;

  protected:
    int numDim;
    // pointers to buffer indicies
    double *densityPtr;
    double *momentumPtr;
    double *internalEnergyPtr;
    double *totalEnergyPtr;
    double *pressurePtr;
    double *temperaturePtr;
    double *specificVolumePtr; 

    // indicies for accessing the buffers
    size_t xStart;
    size_t xEnd;
    size_t xSize;
    size_t yStart;
    size_t yEnd;
    size_t ySize;
    size_t zStart;
    size_t zEnd;
    size_t zSize;
    size_t numPointsBuffer;

    // function pointers to avoid virtual lookup
    // MJA, is this really a performance bottleneck?
    //void (*ComputePressurePtr)(size_t);
    //void (*ComputeTemperaturePtr)(size_t);


  };

  class perfect_gas : public eos {

  public:
    perfect_gas() : eos()
    {
      gammaPtr = NULL;
      specificGasConstantPtr = NULL;
      
      //ComputePressurePtr = &perfect_gas::ComputePressure;
      //ComputeTemperaturePtr = &perfect_gas::ComputeTemperature;
    };

    ~perfect_gas()
    {
      delete gammaPtr;
      delete specificGasConstantPtr;

      gammaPtr=NULL;
      specificGasConstantPtr=NULL;
    }

    int InitializeMaterialProperties(){

      // check that the required material properties are set (gamma, specificGasConst)
      if(!gammaPtr || !specificGasConstantPtr)
        return 1;

      gamma = *gammaPtr;
      specificGasConstant = *specificGasConstantPtr;

      gammaMinus1 = gamma-1;
      heatCapacityCp = specificGasConstant*gamma/gammaMinus1;
      heatCapacityCv = heatCapacityCp-specificGasConstant;
      inverseCv = 1.0/heatCapacityCv;

      return 0;
    };

    inline double GetSpecificGasConstant(){return *specificGasConstantPtr;};
    inline double GetHeatCapacityCv(){return heatCapacityCv;};
    inline double GetHeatCapacityCp(){return heatCapacityCp;};
    inline double GetGamma(){return *gammaPtr;};

    void SetSpecificGasConstant(const double &inValue){
      if(!specificGasConstantPtr){
        specificGasConstantPtr = new double;
      }
      *specificGasConstantPtr = inValue;
    };

    void SetGamma(const double &inValue){
      if(!gammaPtr){
        gammaPtr = new double;
      }
      *gammaPtr = inValue;
    };

    inline void ComputePressure(size_t index){
      pressurePtr[index] = gammaMinus1*(internalEnergyPtr[index]);
    }

    inline void ComputeTemperature(size_t index){
      temperaturePtr[index] = internalEnergyPtr[index]*inverseCv*specificVolumePtr[index];
    }


    private:

    // required data, pointers to track declaration
    double *specificGasConstantPtr;
    double *gammaPtr;

    // actual data used in computation
    double gamma;
    double specificGasConstant;
    double gammaMinus1;
    double inverseCv;
    double heatCapacityCv;
    double heatCapacityCp;

  }; // class perfect_gas
} // namespace eos

#endif