MatrixInterpolator.h

 
// Description: Computes the MatrixInterpolator algorithm on the given snapshot matrix.
 
#ifndef included_MatrixInterpolator_h
#define included_MatrixInterpolator_h
 
#include "Interpolator.h"
#include <vector>
#include <string>
 
namespace CAROM {
 
class Matrix;
class Vector;
 
class MatrixInterpolator : public Interpolator
{
public:
 
    MatrixInterpolator(const std::vector<Vector> & parameter_points,
                       const std::vector<std::shared_ptr<Matrix>> & rotation_matrices,
                       const std::vector<std::shared_ptr<Matrix>> & reduced_matrices,
                       int ref_point,
                       std::string matrix_type,
                       std::string rbf = "G",
                       std::string interp_method = "LS",
                       double closest_rbf_val = 0.9,
                       bool compute_gradients = false);
 
    std::shared_ptr<Matrix> interpolate(const Vector & point,
                                        bool orthogonalize = false);
 
    std::vector<std::shared_ptr<Matrix>> getGradient() {
        return d_interpolation_gradient;
    }
 
private:
 
    MatrixInterpolator();
 
    MatrixInterpolator(
        const MatrixInterpolator& other);
 
    MatrixInterpolator&
    operator = (
        const MatrixInterpolator& rhs);
 
    void obtainLambda();
 
    std::unique_ptr<Matrix> obtainLogInterpolatedMatrix(std::vector<double>& rbf);
 
    std::shared_ptr<Matrix> interpolateSPDMatrix(const Vector & point);
 
    std::shared_ptr<Matrix> interpolateNonSingularMatrix(const Vector & point);
 
    std::shared_ptr<Matrix> interpolateMatrix(const Vector & point);
 
    std::string d_matrix_type;
 
    std::vector<std::shared_ptr<Matrix>> d_rotated_reduced_matrices;
 
    std::vector<std::shared_ptr<Matrix>> d_gammas;
 
    std::shared_ptr<Matrix> d_x_half_power;
 
    std::vector<std::shared_ptr<Matrix>> d_interpolation_gradient;
};
 
}
 
#endif