x036.h

Go to the documentation of this file.

#pragma once

#include "xdata.h"
#include "xode.h"
#include "xoutput.h"
#include "xphysics.h"
#include <cmath>
#include <gsl/gsl_errno.h>
#include <gsl/gsl_matrix.h>
#include <gsl/gsl_odeiv2.h>
#include <iostream>
#include <stdio.h>

namespace nmx::apps::x036 {

int func(double x, const double yin[], double yout[], void *params) {
    (void) params;
    yout[0] = yin[0] - 2 * x / yin[0];
    return GSL_SUCCESS;
}

double fexact(double x) {
    return std::sqrt(2 * x + 1);
}

inline void ex1() {
    //Teil 1: Definition des Dgl-Systems
    gsl_odeiv2_system sys = {
        func, // rechte Seite des Dgl-Systems
        nullptr, //Jacobi-Matrix
        1, //Anzahl der Gleichungen des Dgl-Systems
        nullptr //zusätzliche Parameter
    };
    //Teil2: Name des Lösungsalgorithmus
    const gsl_odeiv2_step_type *type = gsl_odeiv2_step_rk4;
    //Initialisierung des Lösungsalgorithmus
    gsl_odeiv2_driver *d = //
        gsl_odeiv2_driver_alloc_y_new(&sys, // Dgl-System
                                      type, // Lösungsalgorithmus
                                      1e-6, // Schrittweite (Start)
                                      1e-6, // absoluter Fehler
                                      0.0); // relativer Fehler
    //Teil 3: Berechnung der Lösung
    double x = 0;
    double y[] = { 1.0 };
    for (double xi = 0; xi < 2; xi += 0.25) {
        int status = gsl_odeiv2_driver_apply(d, &x, xi, y);
        if (status != GSL_SUCCESS) {
            printf("error, return value=%d\n", status);
            break;
        }

        printf("%.5e %.5e %.5e\n", x, y[0], fexact(x));
    }
    //Teil 4: Ressourcen werden freigegeben
    gsl_odeiv2_driver_free(d);
}

inline auto get_output_stream(const char *name, Format fmt) {
    return Output::get_stream("x036", fmt, name);
}

inline void ode1() {
    //eindimensionale Gleichung, kein ()-Operator
    //zweiter Template -Parameter false
    using ODESolver = gsl::Odeiv2<1, false>;
    using Data = Data<4>;
    //Datenobjekt
    Data data;

    //die DGL mit Schnittstelle zur gsl
    struct MyODE {
        int odefn(double t, const double fin[], double fout[]) {
            fout[0] = fin[0] - 2 * t / fin[0];
            return GSL_SUCCESS;
        }
    } myObj;

    //analytisch hergeleitete Lösung
    auto exactSolutionFn = [](double t) { return sqrt(2 * t + 1); };

    //numerische Lösung der DGL
    ODESolver ode{ myObj, 1e-2, 1e-9, 0 };
    ode.set_init_conditions(0, { 1 });
    double t = 0, dt = 0.25;
    while (t < 2.5) {
        const double numSolution = ode[0];
        const double exactSolution = exactSolutionFn(t);
        const double absError = abs(numSolution - exactSolution);
        data += { t, numSolution, exactSolution, absError };
        t += dt;
        //nächste Lösung
        ode.solve(t);
    }

    std::ofstream mystable = get_output_stream(__func__, Output::latex);
    data.save(mystable, Output::latex);
}

inline void ode2() {
    // zweiter Template-Parameter true
    // die Implementierung des DGL-Systems erfordert
    // einen () -Operator
    using ODESolver = gsl::Odeiv2<2, true>;
    using Data = nmx::Data<7>;

    const double acceleration = 2;
    const double x0 = 0, v0 = 0;

    Data data;
    //Implementierung des DGL-Systems
    auto obj = [](double t, const double fin[], double fout[]) {
        (void) t;
        fout[0] = fin[1];
        fout[1] = 2;
        return GSL_SUCCESS;
    };

    //exakte Lösung
    auto v = [&acceleration](double t) { //
        return acceleration * t;
    };
    auto x = [&acceleration](double t) { //
        return 0.5 * acceleration * pow(t, 2);
    };

    //numerische Lösung
    ODESolver myOde{ obj, 1e-2, 1e-9, 0 };
    myOde.set_init_conditions(0, { x0, v0 });
    double t = 0, dt = 0.5;
    while (t < 5) {
        const double xnum = myOde[0];
        const double xexact = x(t);
        const double vnum = myOde[1];
        const double vexact = v(t);
        const double verror = abs(vnum - vexact);
        const double xerror = abs(xnum - xexact);

        //registriere Daten
        data += { t, xnum, xexact, xerror, vnum, vexact, verror };
        t += dt;
        //berechne Lösung für den nächsten Schritt
        myOde.solve(t);
    }
    //Ausgabe
    std::ofstream mystable = get_output_stream(__func__, Output::latex);
    data.save(mystable, Output::latex);
}

void ode3() {
    // Daten der Aufgabe
    const double mass = 40.0;
    const double mu = 0.4;
    const double force = 200.0;
    const double s = 5.0;
    const double g = gravitation::Earth::g;
    //Anfangsbedingungen
    const double x0 = 0, v0 = 0;

    //**-----------------------------------------------
    //Lösungen über den Arbeitssatz zum Vergleich
    const double a = force / mass - mu * g;
    const double vs = std::sqrt(2 * a * s);
    const double tval = vs / a;
    std::cout << std::setw(3) << tval << "," //
              << std::setw(3) << vs << std::endl;

    //**---------------------------------------------
    //das Differenzialgleichungssystem, durch das =
    // in der Erfassungsliste, können alle Aufgabendaten
    //innerhalb der lambda-Funktion genutzt werden.
    auto acceleration = [=](double t, //
                            const double fin[],
                            double fout[]) {
        (void) t;
        fout[0] = fin[1];
        fout[1] = a;
        return GSL_SUCCESS;
    };

    //**----------------------------------------------
    //lege Dgl fest, der zweite Template-Parameter muss true sein,
    // da das System als lambda implementiert ist.
    using Ode = gsl::Odeiv2<2, true>;
    using Data = nmx::Data<4>;
    Data data;
    Ode ode{ acceleration, 1e-2, 1e-9, 0 };
    ode.set_init_conditions(0, { x0, v0 });
    double t = 0, dt = 0.01;
    //berechne solange Lösungen bis die Strecke s ist
    while (ode[0] < s) {
        data += { t, ode[0], ode[1], 0.5 * mass * pow(ode[1], 2) };
        t += dt;
        ode.solve(t);
    }

    //**---------------------------------------------
    //Ausgabe
    std::ofstream mystable = get_output_stream(__func__, Output::latex);
    data.select_total_rows(5).save(mystable, Output::latex);
    std::ofstream mysplot = get_output_stream(__func__, Output::plot);
    data.save(mysplot, Output::plot);
}

} // namespace nmx::apps::x036