Converter.h

Go to the documentation of this file.

#ifndef CONVERTER_H
#define CONVERTER_H

#include <tabular_props/HDF5Table.h>
#include <vector>
#include <string>

namespace sierra {
namespace nalu {

// Forward declarations
class H5IO;
class Converter;

//============================================================================
class ConverterFactory
{
 public:
  ConverterFactory() {};
  ~ConverterFactory() {};

  Converter * create( const std::string & converterType ) const;
};

//============================================================================
class Converter {

 public:

  explicit Converter( const std::string & converterType );

  virtual ~Converter() { };

  const std::string & name() const{ return name_; }

  const std::vector<std::string> & input_names() const {
    return inputNames_;
  }

  /* Get the number of input variables for this Converter */
  unsigned int dimension() const { return dimension_; }

  virtual double query( const std::vector<double> &inputs ) const = 0;

  void print_summary() const;

  virtual void read_hdf5( H5IO & io );

 protected:

  // Name of the variable returned by this Converter
  std::string name_;

  // Names of the input variables, in the order they are required
  std::vector<std::string> inputNames_;

  // Number of input variables
  unsigned int dimension_;

 private:

  // No copying.  (Assignment not possible with abstract class.)
  Converter( const Converter & );

  const std::string converterType_;

};

//============================================================================
class NameConverter : public Converter {

 public:

  NameConverter();
  NameConverter( const std::string & outputName,
                 const std::string & inputName );

  virtual double query( const std::vector<double>  &inputs ) const;

 private:
  NameConverter operator=( const NameConverter & );  // No assignment
};

//============================================================================
class ChiConverter : public Converter {

 public:

  ChiConverter();
  /* This version is used in Atab_ConverterBuilder.C */
  /*
  ChiConverter( const std::string & outputName,
                const std::string & inputZMeanName,
                const std::string & inputZScaledVarianceMeanName,
                const std::string & inputChiMeanName,
                const double zStoich,
                const HDF5Table * fChiMeanTable );
  */

  virtual ~ChiConverter();

  virtual double query( const std::vector<double>  &inputs ) const;

  virtual void read_hdf5( H5IO & io );

 private:
  ChiConverter operator=( const ChiConverter & );  // No assignment

  double zStoich_;
  const HDF5Table * fChiMeanTable_;
};

//============================================================================
class DeltaChiConverter : public Converter {

 public:

  DeltaChiConverter();
  /* This version is used in Atab_ConverterBuilder.C */
  /*
  DeltaChiConverter( const std::string & outputName,
                     const std::string & inputZMeanName,
                     const std::string & inputChiMeanName,
                     const double zStoich );
  */

  virtual ~DeltaChiConverter();

  virtual double query( const std::vector<double>  &inputs ) const;

  virtual void read_hdf5( H5IO & io );

 private:
  DeltaChiConverter operator=( const DeltaChiConverter & ); // No assignment

  double zStoich_;
};

//============================================================================
class GammaConverter : public Converter {

 public:

  GammaConverter();
  /* This version is used in Atab_ConverterBuilder.C */
  /*
  GammaConverter( const std::string & outputName,
                  const std::vector<std::string> & inputZMeanNames,
                  const std::string & inputZScaledVarianceMeanName,
                  const std::string & inputGammaMeanName,
                  const HDF5Table * fGammaMeanTable );
  */

  virtual ~GammaConverter();

  virtual double query( const std::vector<double>  &inputs ) const;

  virtual void read_hdf5( H5IO & io );

 private:
  GammaConverter operator=( const GammaConverter & );  // No assignment

  unsigned int numTableInputs_;
  const HDF5Table * fGammaMeanTable_;
};

//============================================================================
class DeltaGammaConverter : public Converter {

 public:

  DeltaGammaConverter();
  /* This version is used in Atab_ConverterBuilder.C */
  /*
  DeltaGammaConverter( const std::string & outputName,
                       const std::vector<std::string> & inputZMeanName,
                       const std::string & inputGammaMeanName,
                       const std::vector<std::vector<double> > & zStoich,
                       const std::vector<double> & gammaMaxStoich );
  */

  virtual ~DeltaGammaConverter();

  virtual double query( const std::vector<double>  &inputs ) const;

  virtual void read_hdf5( H5IO & io );

 private:
  DeltaGammaConverter operator=( const DeltaGammaConverter & ); // No assignment

  unsigned int numMixFrac_;
  std::vector<std::vector<double> > zStoich_;
  std::vector<double> gammaMaxStoich_;
  mutable std::vector<double> zMean_;
};

//============================================================================
class HStarConverter : public Converter {

 public:

  explicit HStarConverter( const bool isDelta = false );

  /* This version is used in Atab_ConverterBuilder.C */
  /*
  HStarConverter( const std::string & outputName,
                  const std::vector<std::string> & inputZMeanNames,
                  const std::string & inputHStarMeanName,
                  const double hStar_ref_min,
                  const std::vector<double> & hStar_stream_min,
                  const std::vector<double> & a,
                  const bool isDelta = false );
  */

  virtual ~HStarConverter();

  virtual double query( const std::vector<double>  &inputs ) const;

  virtual void read_hdf5( H5IO & io );

 private:
  HStarConverter operator=( const HStarConverter & );  // No assignment

  void augmented_mixfrac( const std::vector<double> &mixFrac,
                          std::vector<double> & mixFracAug ) const;

  double mixture_property( const std::vector<double> & mixFracAug,
                           const std::vector<double> & streamProp ) const;

  unsigned int numMixFrac_;
  mutable std::vector<double> zAug_;  // Augmented mixture fraction buffer space

  double hStar_ref_min_;
  std::vector<double> hStar_stream_min_;
  std::vector<double> a_;

};

//============================================================================

} // end nalu namespace
} // end sierra namespace

#endif