DMDc.h

 
// Description: Computes the DMDc algorithm on the given snapshot matrix and control matrix. The
//              implemented dynamic mode decomposition with control algorithm is derived from
//              Proctor et. al's paper "Dynamic mode decomposition with control":
//              https://arxiv.org/abs/1409.6358
 
#ifndef included_DMDc_h
#define included_DMDc_h
 
#include "ParametricDMDc.h"
#include <vector>
#include <complex>
 
namespace CAROM {
 
class Matrix;
class Vector;
class ComplexEigenPair;
 
class DMDc
{
public:
 
    DMDc(int dim, int dim_c, double dt,
         std::shared_ptr<Vector> state_offset = nullptr);
 
    DMDc(std::string base_file_name);
 
    virtual ~DMDc() {};
 
    virtual void setOffset(std::shared_ptr<Vector> & offset_vector);
 
    virtual void takeSample(double* u_in, double t, double* f_in,
                            bool last_step = false);
 
    virtual void train(double energy_fraction, const Matrix* B = NULL);
 
    virtual void train(int k, const Matrix* B = NULL);
 
    void project(const Vector & init, const Matrix & controls,
                 double t_offset = -1.0);
 
    std::unique_ptr<Vector> predict(double t);
 
    double getTimeOffset() const;
 
    int getNumSamples() const
    {
        return d_snapshots.size();
    }
 
    int getDimension() const
    {
        return d_k;
    }
 
    std::unique_ptr<const Matrix> getSnapshotMatrix();
 
    virtual void load(std::string base_file_name);
 
    void load(const char* base_file_name);
 
    virtual void save(std::string base_file_name);
 
    void save(const char* base_file_name);
 
    void summary(std::string base_file_name);
 
protected:
    friend void getParametricDMDc<DMDc>(std::unique_ptr<DMDc>& parametric_dmdc,
                                        const std::vector<Vector>& parameter_points,
                                        std::vector<DMDc*>& dmdcs,
                                        std::vector<std::shared_ptr<Matrix>> & controls,
                                        std::shared_ptr<Matrix> & controls_interpolated,
                                        const Vector & desired_point,
                                        std::string rbf,
                                        std::string interp_method,
                                        double closest_rbf_val,
                                        bool reorthogonalize_W);
 
    DMDc(int dim, int dim_c, std::shared_ptr<Vector> state_offset = nullptr);
 
    DMDc(std::vector<std::complex<double>> & eigs,
         std::shared_ptr<Matrix> & phi_real,
         std::shared_ptr<Matrix> & phi_imaginary,
         std::shared_ptr<Matrix> & B_tilde,
         int k, double dt, double t_offset,
         std::shared_ptr<Vector> & state_offset,
         std::shared_ptr<Matrix> & basis);
 
    DMDc();
 
    DMDc(const DMDc& other);
 
    DMDc&
    operator = (
        const DMDc& rhs);
 
    std::pair<std::shared_ptr<Matrix>,std::shared_ptr<Matrix>>
            phiMultEigs(double t);
 
    void constructDMDc(const Matrix & f_snapshots,
                       const Matrix & f_controls,
                       int rank,
                       int num_procs,
                       const Matrix* B);
 
    virtual std::pair<Matrix*, Matrix*> computeDMDcSnapshotPair(
        const Matrix & snapshots, const Matrix & controls, const Matrix* B);
 
    virtual std::complex<double> computeEigExp(std::complex<double> eig, double t);
 
    virtual void addOffset(Vector & result);
 
    std::unique_ptr<const Matrix>
    createSnapshotMatrix(const std::vector<std::shared_ptr<Vector>> & snapshots);
 
    int d_rank;
 
    int d_num_procs;
 
    int d_dim;
 
    int d_dim_c;
 
    double d_dt = -1.0;
 
    double d_t_offset;
 
    std::vector<std::shared_ptr<Vector>> d_snapshots;
 
    std::vector<std::shared_ptr<Vector>> d_controls;
 
    std::vector<double> d_sampled_times;
 
    std::shared_ptr<Vector> d_state_offset;
 
    bool d_trained;
 
    bool d_init_projected;
 
    int d_num_singular_vectors;
 
    std::vector<double> d_sv;
 
    double d_energy_fraction;
 
    int d_k;
 
    std::shared_ptr<Matrix> d_basis;
 
    std::shared_ptr<Matrix> d_A_tilde;
 
    std::shared_ptr<Matrix> d_B_tilde;
 
    std::shared_ptr<Matrix> d_phi_real;
 
    std::shared_ptr<Matrix> d_phi_imaginary;
 
    std::shared_ptr<Matrix> d_phi_real_squared_inverse;
 
    std::shared_ptr<Matrix> d_phi_imaginary_squared_inverse;
 
    std::shared_ptr<Vector> d_projected_init_real;
 
    std::shared_ptr<Vector> d_projected_init_imaginary;
 
    std::unique_ptr<Matrix> d_projected_controls_real;
 
    std::unique_ptr<Matrix> d_projected_controls_imaginary;
 
    std::vector<std::complex<double>> d_eigs;
 
};
 
}
 
#endif