xode.h

Go to the documentation of this file.

#pragma once

#include "xerror.h"
#include "xvector.h"
#include <array>
#include <gsl/gsl_errno.h>
#include <gsl/gsl_odeiv2.h>
#include <vector>

namespace nmx::gsl {

template<size_t N, bool HASCALLOP = false, bool JACOBIAN = false>
class Odeiv2
{
public:
    //Synonym für den Lösungsvektor
    using Array = std::array<double, N>;
    //Synonym für Anzahl der Differenzialgleichungen
    static constexpr size_t DIM = N;

private:
    int _status; //Status gsl-Meldung

    //gsl-Strukturen zur Definition des DGL-Systems
    gsl_odeiv2_system odeSystem;
    //zur Wahl und Anpassung der Schrittweite
    gsl_odeiv2_driver *odeDriver;
    //unabhängige Variable z.B. die Zeit
    double currentTime;
    //Lösungsvektor
    Array currentState;

    template<class T>
    Odeiv2(T &p)
        : odeSystem{ nullptr, nullptr, N, static_cast<void *>(&p) }
        , odeDriver{ nullptr } {
        if constexpr (!HASCALLOP) {
            //DGL-System wird  über eine Schnittstelle odefn aufgerufen
            //gsl ruft diese Funktion auf
            odeSystem.function = [](double t, //
                                    const double y[],
                                    double f[],
                                    void *params) -> int {
                T *myObj = static_cast<T *>(params);
                //Objekt muss diese Funktion definieren
                return myObj->odefn(t, y, f);
            };
        } else {
            //DGL-System wird über ()-Operator aufgerufen
            //gsl ruft diese Funktion auf
            odeSystem.function = [](double t, //
                                    const double y[],
                                    double f[],
                                    void *params) -> int {
                T *myObj = static_cast<T *>(params);
                //Objekt muss diesen ()-Operator definieren
                return (*myObj)(t, y, f);
            };
        }

        //Lösung benötigt JACOBI-Matrix
        if constexpr (JACOBIAN == true) {
            odeSystem.jacobian = [](double t, //
                                    const double y[],
                                    double *dfdy,
                                    double dfdt[],
                                    void *params) {
                T *myObj = static_cast<T *>(params);
                return myObj->getJacobian(t, y, *dfdy, dfdt);
            };
        }
    }

    inline void init(double initstepsize,
                     double abserr,
                     double relerr,
                     const gsl_odeiv2_step_type *steptype = gsl_odeiv2_step_rkf45) {
        odeDriver = gsl_odeiv2_driver_alloc_y_new(&odeSystem, steptype, initstepsize, abserr, relerr);
    }

public:
    template<class T>
    Odeiv2(T &obj,
           double istepsize,
           double abserror,
           double relerror,
           const gsl_odeiv2_step_type *steptype = gsl_odeiv2_step_rkf45)
        : Odeiv2(obj) {
        init(istepsize, abserror, relerror, steptype);
    }

    inline ~Odeiv2() {
        if (odeDriver != nullptr) {
            gsl_odeiv2_driver_free(odeDriver);
        }
    }

    inline void set_init_conditions(double t, const Array &y) {
        currentTime = t;
        currentState = y;
    }

    inline void solve(double t) {
        _status = gsl_odeiv2_driver_apply(odeDriver, &currentTime, t, &currentState[0]);

        if (_status != GSL_SUCCESS) {
            throw std::runtime_error(nmx_msgx(std::to_string(_status)));
        }
    }

    inline double operator[](size_t idx) const {
        if (idx < 0 || idx >= N) {
            throw std::range_error(nmx_msgx(std::to_string(idx)));
        }
        return currentState[idx];
    }

    inline constexpr size_t size() const { return N; }
};
} // namespace nmx::gsl