rom_object_dmd.h

Go to the documentation of this file.

#ifdef with_librom

#ifndef _ROM_OBJECT_DMD_H_
#define _ROM_OBJECT_DMD_H_

#define _ROM_TYPE_DMD_ "DMD"

#include <climits>
#include <vector>
#include <utility>
#include <linalg/Matrix.h>
#include <algo/DMD.h>
#include <rom_object.h>

#ifndef serial
#include <mpi.h>
#endif

typedef std::pair<double,double> Interval;

class DMDROMObject : public ROMObject
{
  public:

    DMDROMObject( const int, 
                  const double, 
                  const int, 
                  const int, 
                  const int,
                  const int,
                  const int a_var_idx = -1);

    virtual ~DMDROMObject()
    {
      for (int i = 0; i < m_dmd.size(); i++) delete m_dmd[i];
      m_dmd.clear();
      m_intervals.clear();
      m_dmd_is_trained.clear();
    }

    virtual void projectInitialSolution(  CAROM::Vector& a_U  )
    {
      if (m_dmd.size() == 0) {
        if (!m_rank) {
          printf("ERROR in DMDROMObject::projectInitialSolution() - m_dmd is a vector of size 0.\n");
        }
        return;
      }

      m_dmd[0]->projectInitialCondition( &a_U );
      for (int i = 1; i < m_dmd.size(); i++) {
        m_dmd[i]->projectInitialCondition( m_dmd[i-1]->predict(m_intervals[i].first) );
      }
      return;
    }

    virtual void takeSample( const CAROM::Vector&, const double );

    virtual void train();

    virtual 
    const CAROM::Vector* const predict(const double a_t  ) const
    {
      for (int i = 0; i < m_dmd.size(); i++) {
        if (   (a_t >= m_intervals[i].first) 
            && (  (a_t < m_intervals[i].second) || (m_intervals[i].second < 0)  ) ){
          return m_dmd[i]->predict(a_t);
        }
      }
      printf("ERROR in DMDROMObject::predict(): m_dmd is of size zero or interval not found!");
      return nullptr;
    }

    virtual void save(const std::string& a_fname_root ) const;

    virtual void load(const std::string& a_fname_root );

  protected:

    std::vector<CAROM::DMD*> m_dmd; 
    std::vector<bool> m_dmd_is_trained; 
    std::vector<Interval> m_intervals; 
    int m_rank;   
    int m_nproc;  
    int     m_vec_size; 
    double  m_dt;       
    double  m_t_final;  
    int     m_rdim;     
    int m_num_window_samples; 
    int m_tic; 
    int m_curr_win; 
    int m_sim_idx; 
    int m_var_idx; 
    bool m_write_snapshot_mat;  
    std::string m_dirname; 
  private:
};

#endif

#endif