x2010.h

Go to the documentation of this file.

#pragma once

#include "xode.h"
#include "xmodel.h"
#include "xphysics.h"

namespace nmx::apps::x2010 {

using namespace gravitation;

class X2010 : public XModel
{
private:
    //Endgeschwindigkeit
    double vTerminal = 0;
    //Steigzeit und Steighöhe
    double tMax = 0, yMax = 0;
    double gvt = 0, vt2g = 0;

public:
    // Eingabeparameter
    //Masse, Reibungskoeffizient
    const double mass, gamma;
    //Anfangsbedingungen
    const double y0, v0;

public:
    inline X2010(double m, double gm, double y0in, double v0in)
        : XModel(__func__)
        , mass{ m }
        , gamma{ gm }
        , y0{ y0in }
        , v0{ v0in } {
        //teste Eingabewerte
        Check::all(nmx_msg, { m > 0, gamma > 0, y0 >= 0, v0 > 0 });

        //Endgeschwindigkeit
        vTerminal = sqrt((mass) *Earth::g / (gamma));

        //Werte werden wiederverwendet
        gvt = Earth::g / vTerminal;
        vt2g = pow(vTerminal, 2) / Earth::g;
        tMax = vTerminal / Earth::g * atan((v0) / vTerminal);
        const double term0 = 0.5 * pow(vTerminal, 2) / Earth::g;
        yMax = term0 * log(1 + pow((v0) / vTerminal, 2));
    }

    inline double time4ymax() const { return tMax; }

    inline double ymax() const { return yMax; }

    inline double terminal_velocity() const { return vTerminal; }

    inline double a(double t) const {
        return -Earth::g * (1 + (gamma) / ((mass) *Earth::g) * v(t) * abs(v(t)));
    }

    inline double v(double t) const {
        if (t <= tMax) {
            return vTerminal * tan(gvt * (tMax - t));
        }
        return -vTerminal * tanh(gvt * (t - tMax));
    }

    inline double y(double t) const {
        if (t <= tMax) {
            return vt2g * log(cos(gvt * (tMax - t)) / cos(gvt * tMax));
        }
        return yMax - vt2g * log(cosh(gvt * (t - tMax)));
    }
}; //X2010

class C2010 : public X2010
{
public:
    using Ode = gsl::Odeiv2<2>;
    friend Ode;
    using Data = Data<8>;

    using X2010::X2010; //erbe Konstruktoren von der Basisklasse

private:
    Data _data; //Zahlentabelle zur Speicherung der Ergebnisse

    inline int odefn(double t, const double fin[], double fout[]) {
        (void) t;
        fout[0] = fin[1];
        fout[1] = -Earth::g * (1 + gamma / (mass * Earth::g) * fin[1] * abs(fin[1]));
        return GSL_SUCCESS;
    }

public:
    inline void exec() {
        Ode myOde{ *this, 1e-2, 1e-9, 0 };
        myOde.set_init_conditions(0, { y0, v0 });

        //löse Bewegungsgleichung
        double t = 0, dt = 0.01;
        do {
            _data += { t, myOde[0], myOde[1] };
            t += dt;
            myOde.solve(t);
        } while (myOde[0] > 0);

        //füge Gesamtenergie und exakt berechnete Daten hinzu
        for (auto &crow : _data.data()) {
            const double t = crow[0];
            crow[3] = Mechanics::kinetic_energy(mass, crow[2]);
            crow[4] = Mechanics::potential_energy(mass, crow[1]);
            crow[5] = crow[3] + crow[4]; //Gesamtenergie
            crow[6] = y(t); //exakter Wert für Höhe
            crow[7] = v(t); //exakter Wert für Geschwindigkeit
        }
    }

    inline void save_data() {
        save(_data, Output::plot, gamma);
        //ändere Formatierung der Daten für die LaTeX-Tabelle
        std::ofstream ofs = get_output_stream(Output::latex, gamma);
        ofs << std::fixed << std::setprecision(4);
        _data.select_total_rows(5).save(ofs, Output::latex);
    }
}; //C2010

inline void run() {
    const double mass = 1.0;
    const double y0 = 0.0;
    const double v0 = 30.0;

    for (const auto gamma : { 1.3, 1.6, 2.0 }) {
        //Rechenmodell
        C2010 cobj{ mass, gamma, y0, v0 };
        cobj.exec();
        cobj.save_data();
    }
}

} // namespace nmx::apps::x2010