HDF5Table.h

Go to the documentation of this file.

#ifndef HDF5TABLE_H
#define HDF5TABLE_H

#include <vector>
#include <set>
#include <string>
#include <map>

#include "tabular_props/H5IO.h"

namespace sierra {
namespace nalu {

// Forward declarations
//class Realm;
class Converter;
class H5IO;
class BSpline;

struct ClipEvent {
  double severity;
  std::vector<double> values;
};

template <class T>
class ClipEventSortCriterion {
 public:
  bool operator() ( const T & v1,
                    const T & v2 ) const {
    // Sort based on the severity only, in decreasing order
    return v1.severity > v2.severity;
  }
};

typedef std::set<ClipEvent, ClipEventSortCriterion<ClipEvent> > ClipEventLog;

class HDF5Table
{
  
 public:
  
  typedef std::map<std::string, std::string> Attributes;
  
  HDF5Table();
  HDF5Table(
    H5IO *fileIO,
    std::string tablePropName,
    std::vector<std::string> &indVarNameVec,
    std::vector<std::string> &indVarTableNameVec);

  virtual ~HDF5Table();

  void add_converter( const Converter * converter );

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

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

  /* Get the number of inputs required by the query() function */
  unsigned int dimension() const { return dimension_; }

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

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

  void set_clipping_log_size( unsigned int size ) ;

  unsigned int num_clipping_events() const;

  const ClipEventLog & clipping_event_log() const;

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

  const std::vector<double> & clipping_event_min_bounds() const;

  const std::vector<double> & clipping_event_max_bounds() const;

  void clear_clipping_log() ;

  unsigned int num_converters() const { return converters_.size(); }

  bool has_attribute( const std::string & name ) const;

  const std::string & attribute( const std::string & name ) const;

  void read_hdf5_property( );

  void read_hdf5_table( H5IO & io );

 private:

  // Add the current values to the clipping event log
  void log_clip_event( const std::vector<double> & values ) const;

  void update_input_mapping();

  int findix( const std::vector<std::string> & nameVector,
          const std::string & name );

  //HDF5 file pointer
  H5IO *fileIO_;

  // name of dependent variable as given in the table
  std::string tablePropName_;

  // names of independent variables as given in the table
  std::vector<std::string> indVarTableNameVec_;

  // number of independent variables
  const size_t indVarSize_;

  // Number of inputs required by the query() function
  unsigned int dimension_;

  // Name of the variable returned by calls to query()
  std::string name_;

  // Names of the inputs required by the query() function
  std::vector<std::string> inputNames_;

  // List of optional input converters for the table
  std::vector<const Converter *> converters_;

  // Table and Converter input and output index mapping data
  std::vector<unsigned int> directInputIndex_;
  std::vector<unsigned int> convTableIndex_;
  std::vector<std::vector<unsigned int> > convInputIndex_;
  // used to map between input ordered by indVarTableNameVec_
  // and input required by ordering of inputNames_
  std::vector<unsigned int> indexIndVar_;
  


  // FROM Atab_Table.h

  // Status of internal log scale use for each independent variable
  std::vector<unsigned int> inputLogScale_;

  // Minimum and maximum values for the independent variables
  std::vector<double> meshMin_;
  std::vector<double> meshMax_;

  // Minimum and maximum clipping values and clipping status for the
  // independent variables
  std::vector<double> inputMin_;
  std::vector<double> inputMax_;


  // Independent variable mesh points used to build the interpolator
  std::vector<std::vector<double> > mesh_;

  // Minimum and maximum interpolated variable value
  double valueMin_;
  double valueMax_;

  // Arbitrary metadata
  Attributes attributes_;

  // Internal interpolator used to perform table lookups
  BSpline * spline_;

  // Buffers for storing clipping diagnostic information
  mutable unsigned int clipEventLogSize_;
  mutable unsigned int numClipped_;
  mutable ClipEventLog clipEventLog_;

  // delete this and use lookupBuf_ instead
  //  double * tableBuf_;
  //  Scratch space for conversions
  mutable std::vector<double> converterBuf_;

  // Scratch space for doing log scale conversions, etc. on the input variables
  mutable std::vector<double> lookupBuffer_;
  // Scratch space for doing bounds clipping on lookupBuffer_
  mutable std::vector<double> lookupBufferChecked_;

};

//typedef SharedPtr<const HDF5Table> ConstHDF5TablePtr;

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

#endif