Interpolator.h

 
// Description: Computes the Interpolator algorithm on the given snapshot matrix.
 
#ifndef included_Interpolator_h
#define included_Interpolator_h
 
#include <vector>
#include <string>
#include <memory>
 
namespace CAROM {
 
class Matrix;
class Vector;
 
class Interpolator
{
protected:
 
    Interpolator(const std::vector<Vector> & parameter_points,
                 const std::vector<std::shared_ptr<Matrix>> & rotation_matrices,
                 int ref_point,
                 std::string rbf,
                 std::string interp_method,
                 double closest_rbf_val = 0.9,
                 bool compute_gradients = false);
 
    int d_rank;
 
    int d_num_procs;
 
    int d_ref_point;
 
    std::string d_rbf;
 
    std::string d_interp_method;
 
    double d_epsilon;
 
    std::vector<Vector> d_parameter_points;
 
    std::vector<std::shared_ptr<Matrix>> d_rotation_matrices;
 
    std::unique_ptr<Matrix> d_lambda_T;
 
    bool d_compute_gradients;
 
    std::vector<std::shared_ptr<Vector>> d_interpolation_gradient;
 
private:
 
    Interpolator();
 
    Interpolator(
        const Interpolator& other);
 
    Interpolator&
    operator = (
        const Interpolator& rhs);
};
 
std::vector<double> obtainRBFToTrainingPoints(
    const std::vector<Vector> & parameter_points,
    const std::string & interp_method, const std::string & rbf, double epsilon,
    const Vector & point);
 
std::vector<double> obtainRBFGradientToTrainingPoints(
    const std::vector<Vector> & parameter_points,
    const std::string & interp_method, const std::string & rbf, double epsilon,
    const Vector & point, const int index);
 
 
double obtainRBFGradient(std::string rbf, double epsilon, const Vector & point1,
                         const Vector & point2, const int index);
 
double rbfWeightedSum(std::vector<double>& rbf);
 
double obtainRBF(std::string rbf, double epsilon, const Vector & point1,
                 const Vector & point2);
 
double convertClosestRBFToEpsilon(const std::vector<Vector> & parameter_points,
                                  const std::string & rbf, double closest_rbf_val);
 
std::vector<std::shared_ptr<Matrix>> obtainRotationMatrices(
                                      const std::vector<Vector> & parameter_points,
                                      const std::vector<std::shared_ptr<Matrix>> & bases,
                                      int ref_point);
 
std::unique_ptr<std::vector<Vector>>
                                  scalarsToVectors(const std::vector<double> & s);
}
#endif