Program Listing for File splinefunctions.h

↰ Return to documentation for file (include/amici/splinefunctions.h)

#ifndef AMICI_SPLINEFUNCTIONS_H
#define AMICI_SPLINEFUNCTIONS_H

#include "amici/defines.h"

#include <vector>

#include <gsl/gsl-lite.hpp>

namespace amici {

class Model;
class AbstractSpline {
  public:
    AbstractSpline() = default;

    AbstractSpline(
        std::vector<realtype> nodes, std::vector<realtype> node_values,
        bool equidistant_spacing, bool logarithmic_parametrization
    );

    virtual ~AbstractSpline() = default;

    virtual void compute_coefficients() = 0;

    virtual void compute_coefficients_sensi(
        int nplist, int spline_offset, gsl::span<realtype> dvaluesdp,
        gsl::span<realtype> dslopesdp
    ) = 0;

    realtype get_value(realtype const t) const;

    virtual realtype get_value_scaled(realtype const t) const = 0;

    realtype get_node_value(int const i) const;

    realtype get_node_value_scaled(int const i) const;

    realtype get_sensitivity(realtype const t, int const ip) const;

    realtype
    get_sensitivity(realtype const t, int const ip, realtype const value) const;

    virtual realtype
    get_sensitivity_scaled(realtype const t, int const ip) const
        = 0;

    virtual void compute_final_value() = 0;

    virtual void compute_final_sensitivity(
        int nplist, int spline_offset, gsl::span<realtype> dspline_valuesdp,
        gsl::span<realtype> dspline_slopesdp
    ) = 0;

    realtype get_final_value() const;

    realtype get_final_value_scaled() const;

    realtype get_final_sensitivity(int const ip) const;

    realtype get_final_sensitivity_scaled(int const ip) const;

    bool get_equidistant_spacing() const;

    bool get_logarithmic_parametrization() const;

    int n_nodes() const { return static_cast<int>(nodes_.size()); }

  protected:
    std::vector<realtype> nodes_;

    std::vector<realtype> node_values_;

    std::vector<realtype> coefficients;

    std::vector<realtype> coefficients_extrapolate;

    std::vector<realtype> coefficients_sensi;

    std::vector<realtype> coefficients_extrapolate_sensi;

    void set_final_value_scaled(realtype finalValue);

    void set_final_sensitivity_scaled(std::vector<realtype> finalSensitivity);

  private:
    realtype final_value_scaled_;

    std::vector<realtype> final_sensitivity_scaled_;

    bool equidistant_spacing_ = false;

    bool logarithmic_parametrization_ = false;

}; // class SplineFunction

class HermiteSpline : public AbstractSpline {
  public:
    HermiteSpline() = default;

    HermiteSpline(
        std::vector<realtype> nodes, std::vector<realtype> node_values,
        std::vector<realtype> node_values_derivative,
        SplineBoundaryCondition firstNodeBC, SplineBoundaryCondition lastNodeBC,
        SplineExtrapolation firstNodeExtrapol,
        SplineExtrapolation lastNodeExtrapol, bool node_derivative_by_FD,
        bool equidistant_spacing, bool logarithmic_parametrization
    );

    void compute_coefficients() override;

    void compute_coefficients_sensi(
        int nplist, int spline_offset, gsl::span<realtype> dvaluesdp,
        gsl::span<realtype> dslopesdp
    ) override;

    void compute_final_value() override;

    void compute_final_sensitivity(
        int nplist, int spline_offset, gsl::span<realtype> dspline_valuesdp,
        gsl::span<realtype> dspline_slopesdp
    ) override;

    realtype get_value_scaled(realtype const t) const override;

    realtype get_node_derivative(int const i) const;

    realtype get_node_derivative_scaled(int const i) const;

    realtype
    get_sensitivity_scaled(realtype const t, int const ip) const override;

    bool get_node_derivative_by_fd() const { return node_derivative_by_FD_; }

  private:
    void compute_slope_sensitivities_by_fd(
        int nplist, int spline_offset, int ip, gsl::span<realtype> dvaluesdp,
        gsl::span<realtype> dslopesdp
    );

    void get_coeffs_sensi_lowlevel(
        int ip, int i_node, int nplist, int n_spline_coefficients,
        int spline_offset, realtype len, gsl::span<realtype> dnodesdp,
        gsl::span<realtype> dslopesdp, gsl::span<realtype> coeffs
    ) const;

    void handle_inner_derivatives();

    void handle_boundary_conditions();

    void compute_coefficients_extrapolation();

    void compute_coefficients_extrapolation_sensi(
        int nplist, int spline_offset, gsl::span<realtype> dspline_valuesdp,
        gsl::span<realtype> dspline_slopesdp
    );

    std::vector<realtype> node_values_derivative_;

    SplineBoundaryCondition first_node_bc_ = SplineBoundaryCondition::given;

    SplineBoundaryCondition last_node_bc_ = SplineBoundaryCondition::given;

    SplineExtrapolation first_node_ep_ = SplineExtrapolation::linear;

    SplineExtrapolation last_node_ep_ = SplineExtrapolation::linear;

    bool node_derivative_by_FD_ = false;

}; // class HermiteSpline

} // namespace amici

#endif /* AMICI_SPLINEFUNCTIONS_H */