Abstract_Integrator.hpp

#ifndef DEF_RKMK_ABSTRACT_INTEGRATOR
#define DEF_RKMK_ABSTRACT_INTEGRATOR

namespace RKMK {
namespace Abstract {

class Integrator
{
public:
    virtual void
    setCoeffs (std::vector<double> va, std::vector<double> vb) = 0;

    virtual bool
    integrate () = 0;
};
} // namespace Abstract
} // namespace RKMK

namespace RKMK {

template <typename T_LIE_ALGEBRA,
          int T_N_INTERNAL_STAGES,
          typename T_M = double>
class Integrator : public RKMK::Abstract::Integrator
{
private:
    RKMK::Abstract::Problem<T_LIE_ALGEBRA,T_M>& m_problem;
    RKMK::Abstract::Step<T_LIE_ALGEBRA,T_N_INTERNAL_STAGES,T_M>& m_step;
    
public:
    Integrator<T_LIE_ALGEBRA,T_N_INTERNAL_STAGES,T_M> (RKMK::Abstract::Problem<T_LIE_ALGEBRA,T_M>& problem,
                                                       RKMK::Abstract::Step<T_LIE_ALGEBRA,T_N_INTERNAL_STAGES,T_M>& step)
    : m_problem(problem), m_step(step)
    { }

    ~Integrator<T_LIE_ALGEBRA,T_N_INTERNAL_STAGES,T_M> ()
    { }

    void
    setCoeffs (std::vector<double> va, std::vector<double> vb)
    { m_step.setCoeffs(va,vb); }

    bool
    integrate (void)
    {
        int i;
        bool success = false;
        T_M h;
        int n_steps = m_problem.size();
        NOXVector<T_LIE_ALGEBRA::DOF> Y0, Y1;

        for (i=0; i<n_steps-1; i++) {
            Y0 = m_problem.pos(i);
            h = m_problem.base(i+1)-m_problem.base(i);
            m_step.setData(h,Y0);

            Y1 = m_step.makeStep();
            m_problem.pos(i+1,Y1);
        }

        return success;
    }
}; 
} // namespace RKMK

#endif