x2000.h

Go to the documentation of this file.

#pragma once

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

namespace nmx::apps::x2000 {

using namespace gravitation;

class X2000 : public XModel
{
private:
    double _mOverBeta; // m/b
    double _vTerminal; //Endgeschwindigkeit

public:
    //Eingabeparameter
    //Masse,Koeffizient (Reibung)
    const double mass, beta;
    // Anfangsbedingungen
    const double y0, v0;

public:
    X2000(double m, double b, double y0, double v0)
        : XModel(__func__)
        , mass{ m }
        , beta{ b }
        , y0{ y0 }
        , v0{ v0 } {
        Check::all(nmx_msg, { mass > 0, beta >= 0 });
        _mOverBeta = (mass) / (beta);
        _vTerminal = -_mOverBeta * gravitation::Earth::g;
    }

    inline double terminal_velocity() const { return _vTerminal; }

    inline double v(double t) const {
        return _vTerminal + (v0 - _vTerminal) * exp(-t / _mOverBeta);
    }

    inline double y(double t) const {
        const double term1 = (v0 - _vTerminal);
        const double term2 = (1 - exp(-t / _mOverBeta));
        return _vTerminal * t + _mOverBeta * term1 * term2;
    }

    inline double time4ymax() const { //
        return _mOverBeta * log((_vTerminal - v0) / _vTerminal);
    }

    inline double ymax() const { return y(time4ymax()); }
}; //X2000

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

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

public:
    // benutze Konstruktoren der Basisklasse
    using X2000::X2000;

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

    inline void exec() {
        Ode myOde{ *this, 1e-2, 1e-9, 0 };
        myOde.set_init_conditions(0, { y0, v0 });
        double t = 0, dt = 0.01;
        do {
            _data += { t, myOde[0], myOde[1] };
            t += dt;
            myOde.solve(t);
        } while (myOde[0] >= 0); //stop wenn Kugel den Boden erreicht

        //Energien und exakte Werte werden hinzugefügt
        for (auto &crow : _data.data()) {
            const double t = crow[0];
            const double yval = crow[1];
            const double vval = crow[2];
            crow[3] = Mechanics::kinetic_energy(mass, vval);
            crow[4] = Mechanics::potential_energy(mass, yval);
            crow[5] = crow[3] + crow[4]; //Gesamtenergie
            crow[6] = y(t);
            crow[7] = v(t);
        }
    }

    void save_data() {
        save(_data, Output::plot, beta);
        std::ofstream ofs = get_output_stream(Output::latex, beta);

        //ändere Formatierung der Zahlen für die LaTeX-Tabelle
        ofs << std::fixed << std::setprecision(4);

        //speichere insgesamt 7 Reihen (5 + erste + letzte)
        _data.select_total_rows(4).save(ofs, Output::latex);
    }
}; //C2000

inline void run() {
    const double y0 = 0.0, v0 = 10.0; //Anfangsbedingungen
    const double mass = 1.0;

    for (const auto beta : { 3.0, 6.0, 9.0 }) {
        C2000 cobj{ mass, beta, y0, v0 }; //Rechenmodell
        cobj.exec();
        cobj.save_data();
    }
}

} // namespace nmx::apps::x2000