StaticSVD.h

 
// Description: A class implementing interface of SVD for the static SVD
//              algorithm.
 
#ifndef included_StaticSVD_h
#define included_StaticSVD_h
 
#include "SVD.h"
#include "linalg/Options.h"
#include "linalg/scalapack_wrapper.h"
 
#include <limits>
#include <memory>
#include <vector>
 
namespace CAROM {
 
class StaticSVD : public SVD
{
public:
    ~StaticSVD();
 
    virtual
    bool
    takeSample(
        double* u_in,
        bool add_without_increase = false);
 
    virtual
    const Matrix*
    getSpatialBasis();
 
    virtual
    const Matrix*
    getTemporalBasis();
 
    virtual
    const Vector*
    getSingularValues();
 
    virtual
    const Matrix*
    getSnapshotMatrix();
 
protected:
 
    StaticSVD(
        Options options
    );
 
    virtual void
    computeSVD();
 
    bool
    isBasisCurrent()
    {
        return d_basis_is_current;
    }
 
    std::unique_ptr<SLPK_Matrix> d_samples;
 
    std::unique_ptr<SVDManager> d_factorizer;
 
    bool d_basis_is_current;
 
    int d_rank;
 
    int d_num_procs;
 
    std::vector<int> d_istarts;
 
    std::vector<int> d_dims;
 
    int d_total_dim;
 
    int d_nprow;
 
    int d_npcol;
 
    int d_blocksize;
 
    void get_global_info();
 
    int d_max_basis_dimension;
 
    double d_singular_value_tol;
 
    void delete_samples();
    void delete_factorizer();
 
    void broadcast_sample(const double* u_in);
 
private:
 
    friend class BasisGenerator;
 
    StaticSVD();
 
    StaticSVD(
        const StaticSVD& other);
 
    StaticSVD&
    operator = (
        const StaticSVD& rhs);
 
    bool d_preserve_snapshot;
};
 
}
 
#endif