x1200.h

Go to the documentation of this file.

#pragma once

#include "xode.h"
#include "xmodel.h"
#include "xphysics.h"
#include <optional>

namespace nmx::apps::x1200 {

using namespace gravitation;

class X1200 : public XModel
{
private:
    //Brennschluss: Zeit, Geschwindigkeit, Höhe
    double _zB, _vB, _tB;

public:
    //Anfangswerte
    using IValues = std::array<double, 2>;

    //Eingabewerte
    const double mass0; // Masse der Rakete plus Treibstoff t=0
    const double massRocket; // Masse der Rakete ohne Treibstoff
    const double lambda; // Brennrate
    const double vRelative; // Relativgeschwindigkeit
    const double z0, v0; // Anfangsbedingungen

public:
    inline X1200(double minit,
                 double mrocket, //
                 double l,
                 double vrocket,
                 IValues ivals)
        : XModel(__func__)
        , mass0{ minit }
        , massRocket{ mrocket }
        , lambda{ l }
        , vRelative{ vrocket }
        , z0{ ivals[0] }
        , v0{ ivals[1] } {
        Check::all(nmx_msg,
                   { mass0 > 0,
                     massRocket > 0, //
                     lambda > 0,
                     vRelative > 0,
                     z0 >= 0,
                     v0 >= 0 });
        _tB = (mass0 - massRocket) / lambda;
        _vB = vRelative * log(mass0 / massRocket) - Earth::g * _tB;
        _zB = vRelative / lambda * (mass0 - massRocket + massRocket * log(massRocket / mass0))
              - 0.5 * Earth::g * pow(_tB, 2);
    }

    inline bool is_propellant(double t) const { return t <= _tB; }

    inline double mass(double t) const { //
        if (is_propellant(t)) {
            return mass0 - lambda * t;
        }
        return massRocket;
    }

    inline double acceleration(double t) const { //
        return lambda / mass(t) * vRelative - Earth::g;
    }

    inline double height(double t) const {
        const double term0 = mass(t) / mass0;
        const double term1 = term0 * log(term0) * vRelative;
        const double term2 = 0.5 * Earth::g * pow(t, 2);
        return vRelative * t + (mass0 / lambda) * term1 - term2;
    }

    inline double velocity(double t) const {
        const double term = mass0 / mass(t);
        return vRelative * log(term) - Earth::g * t;
    }

    inline double time() const { return _tB; }

    inline double velocity() const { return _vB; }

    inline double height() const { return _zB; }
}; //X1200

class C1200 : public X1200
{
public:
    using Ode = gsl::Odeiv2<3>;
    using Data = Data<7>;
    friend Ode;

protected:
    Data _data; //speichere numerisch berechnete und exakte Werte

public:
    using X1200::X1200; //erbe Konstruktoren der Modellklasse

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

    void exec(double t0 = 0, double tstep = 1) {
        //Instanz zur Lösung der Differenzialgleichung
        Ode myOde{ *this, 1e-2, 1e-6, 0 };
        myOde.set_init_conditions(0, { mass0, z0, v0 });
        double t = t0, dt = tstep;

        //rechne bis der Treibstoff verbraucht ist
        while (myOde[0] > massRocket) {
            _data += {
                t,
                myOde[0], //Masse
                myOde[1], // Höhe
                myOde[2] // Geschwindigkeit
            };
            t += dt;
            myOde.solve(t);
        }

        //exakte Werte
        for (auto &crow : _data.data()) {
            const double t = crow[0];
            crow[4] = mass(t);
            crow[5] = height(t);
            crow[6] = velocity(t);
        }
    }

    inline void save_data() {
        save(_data, Output::plot);
        save(_data.select_total_rows(8), Output::latex);
    }
}; //C1200

inline void run() {
    //Programmparameter
    const double m0 = 2.85e6;
    const double M = 0.27 * m0;
    const double lambda = 13.84e3;

    //Umrechnung in m/s (benutzerdefinierte Literale)
    const double vR = 2.46_km; // km/s
    const double z0 = 0.0;
    const double v0 = 0.0;

    //Rechenmodell
    C1200 cobj{ m0, M, lambda, vR, { z0, v0 } };
    cobj.exec();
    cobj.save_data();
}

} // namespace nmx::apps::x1200