librom_interface.h

Go to the documentation of this file.

#ifdef with_librom

#ifndef _LIBROM_INTERFACE_H_
#define _LIBROM_INTERFACE_H_

#define _ROM_MODE_NONE_ "none"

#define _ROM_MODE_TRAIN_ "train"

#define _ROM_MODE_PREDICT_ "predict"

#define _ROM_MODE_INITIAL_GUESS_ "initial_guess"

#define _ROM_COMP_MODE_MONOLITHIC_ "monolithic"

#define _ROM_COMP_MODE_COMPONENTWISE_ "component-wise"

#include <string>
#include <vector>
#include <sys/time.h>

#include <linalg/Vector.h>
#include <rom_object.h>

class libROMInterface
{
  public:

    libROMInterface()
    {
      m_is_defined = false;
      m_rank = -1;
      m_nproc = -1;
      m_nsims = -1;
      m_vec_size.clear();
      m_rdim = -1;
      m_sampling_freq = 1;
      m_mode = _ROM_MODE_TRAIN_;
      m_comp_mode = "monolithic";
      m_ncomps.clear();
      m_rom.clear();
      m_U.clear();
      m_train_wctime = 0;
      m_predict_wctime = 0;
      m_save_ROM = true;
    }

    libROMInterface(  void*   a_s, 
                      int     a_nsims, 
                      int     a_rank,  
                      int     a_nproc, 
                      double  a_dt      )
    {
      define( a_s, a_nsims, a_rank, a_nproc, a_dt );
    }

    void define( void*, int, int, int, double);

    ~libROMInterface()
    {
      for (int i = 0; i < m_rom.size(); i++) delete m_rom[i];
      m_rom.clear();
      for (int i = 0; i < m_U.size(); i++) delete m_U[i];
      m_U.clear();
    }

    inline int samplingFrequency() const { return m_sampling_freq; }
    inline const std::string& mode() const { return m_mode; }
    inline const std::string& componentMode() const { return m_comp_mode; }
    inline const std::string& type() const { return m_rom_type; }
    inline double trainWallclockTime() const { return m_train_wctime; }
    inline double predictWallclockTime() const { return m_predict_wctime; }

    void takeSample( void* a_s, const double a_t );

    void projectInitialSolution( void* a_s );

    void train();

    void predict(void*  a_s, const double a_t) const;

    void saveROM(const std::string& a_fname_root="") const;

    void loadROM(const std::string& a_fname_root="");

    void copyFromHyPar( std::vector<CAROM::Vector*>&, void* );

    void copyToHyPar( const CAROM::Vector&, void*, int ) const;

    void copyToHyPar( const CAROM::Vector&, void*, int, int ) const;

  protected:

    bool m_is_defined;  
    int m_rank;   
    int m_nproc;  
    int m_nsims;  
    std::vector<int> m_vec_size; 
    int m_rdim; 
    int m_sampling_freq; 
    std::string m_mode; 
    std::string m_comp_mode; 
    std::string m_rom_type; 
    std::vector<int> m_ncomps; 
    std::vector<ROMObject*> m_rom; 
    std::vector<CAROM::Vector*> m_U; 
    mutable struct timeval m_train_start; /*<! Training start time */
    mutable struct timeval m_train_end; /*<! Training end time */
    mutable struct timeval m_predict_start; /*<! Prediction start time */
    mutable struct timeval m_predict_end; /*<! Prediction end time */
    mutable double m_train_wctime; 
    mutable double m_predict_wctime; 
    bool m_save_ROM; 
  private:

};

#endif

#endif