VectorInterpolator.h

 
// Description: Computes the VectorInterpolator algorithm on the given snapshot matrix.
 
#ifndef included_VectorInterpolator_h
#define included_VectorInterpolator_h
 
#include "Interpolator.h"
#include <memory>
#include <vector>
#include <string>
 
namespace CAROM {
 
class Matrix;
class Vector;
 
class VectorInterpolator : public Interpolator
{
public:
 
    VectorInterpolator(const std::vector<Vector> & parameter_points,
                       const std::vector<std::shared_ptr<Matrix>> & rotation_matrices,
                       const std::vector<std::shared_ptr<Vector>> & reduced_vectors,
                       int ref_point,
                       std::string rbf = "G",
                       std::string interp_method = "LS",
                       double closest_rbf_val = 0.9,
                       bool compute_gradients = false);
 
    std::shared_ptr<Vector> interpolate(const Vector & point);
 
    std::vector<std::shared_ptr<Vector>> getGradient() {
        return d_interpolation_gradient;
    }
 
private:
 
    VectorInterpolator();
 
    VectorInterpolator(
        const VectorInterpolator& other);
 
    VectorInterpolator&
    operator = (
        const VectorInterpolator& rhs);
 
    void obtainLambda();
 
    std::unique_ptr<Vector> obtainLogInterpolatedVector(std::vector<double>& rbf);
 
    std::vector<std::shared_ptr<Vector>> d_rotated_reduced_vectors;
 
    std::vector<std::shared_ptr<Vector>> d_gammas;
 
    std::vector<std::shared_ptr<Vector>> d_interpolation_gradient;
};
 
std::unique_ptr<Vector> obtainInterpolatedVector(
    const std::vector<std::shared_ptr<Vector>> & data,
    const Matrix & f_T, std::string interp_method,
    std::vector<double>& rbf);
std::unique_ptr<Matrix> solveLinearSystem(
    const std::vector<Vector> & parameter_points,
    const std::vector<std::shared_ptr<Vector>> & data,
    const std::string & interp_method,
    const std::string & rbf, double epsilon);
}
 
#endif