x710.h

Go to the documentation of this file.

#pragma once

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

namespace nmx::apps::x710 {

using namespace gravitation;

class X710 : public XModel
{
protected:
    //Komponenten der Anfangsgeschwindigkeit
    double _v0y = 0, _v0x = 0;

public:
    // Eingabeparameter: Masse
    const double mass;
    //Anfangsbedingungen : Anfangshöhe,
    //Geschwindigkeit, Winkel
    const double H, v0, theta0;

    inline X710(double m, double yinit, double vinit, double angle)
        : XModel{ __func__ }
        , mass{ m }
        , H{ yinit }
        , v0{ vinit }
        , theta0{ angle } {
        //teste Eingabeparameter
        Check::all(nmx_msg, { mass > 0, H > 0, v0 > 0, theta0 > 0 });
        //berechne und speichere Anfangsbedingungen
        _v0x = v0 * std::cos(theta0);
        _v0y = v0 * std::sin(theta0);
    }

    inline double xmax() const {
        double term0 = pow(v0, 2) / Earth::g * cos(theta0);
        double term1 = pow(sin(theta0), 2) + (2 * Earth::g * H) / pow(v0, 2);
        return term0 * (sin(theta0) + sqrt(term1));
    }

    inline double ymax() const { //
        return H + 0.5 * pow(_v0y, 2) / Earth::g;
    }

    inline double t4xmax() const {
        const double _tmp = _v0y + sqrt(pow(_v0y, 2) + 2 * Earth::g * H);
        return (_tmp) / Earth::g;
    }

    inline double t4ymax() const { return _v0y / Earth::g; }

    inline double xmax_angle() const { //
        return asin(v0 / sqrt(2 * pow(v0, 2) + 2 * Earth::g * H));
    }

    inline double vx(double t) const {
        (void) t;
        return _v0x;
    }

    inline double vy(double t) const { //
        return v0 * sin(theta0) - Earth::g * t;
    }

    inline double x(double t) const { return _v0x * t; }

    inline double y(double t) const { //
        return H + vy(t) * t - 0.5 * Earth::g * pow(t, 2);
    }
}; //X710

class C710 : public X710
{
public:
    using Ode = gsl::Odeiv2<4>;
    friend Ode;
    using Data = Data<9>;

private:
    //Speicher für die berechneten Daten
    Data _data;

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

public:
    //Konstruktoren der Modellklasse werden geerbt
    using X710::X710;

    inline void exec() {
        //Anfangsbedingungen Ort
        double x0 = 0.0, y0 = H;
        //Anfangsbedingungen Geschwindigkeit
        double vx0 = _v0x, vy0 = _v0y;

        //numerische Lösung der Bewegungsgleichungen, die Instanz des
        // Rechenmodells wird der Lösungsroutine übergeben.
        Ode myOde{ *this, 1e-2, 1e-9, 0 };
        myOde.set_init_conditions(0, { x0, y0, vx0, vy0 });
        double t = 0, dt = 0.1;
        do {
            _data += { t, myOde[0], myOde[1], myOde[2], myOde[3] };
            t += dt;
            myOde.solve(t);
            if (myOde[1] < 2) {
                //wenn sich das Teilchen dem Boden nähert
                dt = 0.001;
            }
        } while (myOde[1] >= 0);

        //Einfügen von Energien und Geschwindigkeitsbetrag
        for (auto &crow : _data.data()) {
            const double _velocity = sqrt(pow(crow[3], 2) + pow(crow[4], 2));
            crow[5] = _velocity;
            crow[6] = Mechanics::kinetic_energy(mass, _velocity);
            crow[7] = Mechanics::potential_energy(mass, crow[2]);
            crow[8] = crow[6] + crow[7];
        }
    }

    inline void save_data() {
        const auto id = Math::to_degrees(theta0);
        save(_data, Output::plot, id);

        auto view = _data.select_total_rows(5);
        std::stringstream sstr1;
        sstr1 << id << "-v";
        auto ofslatex1 = get_output_stream(Output::latex, sstr1.str());
        view.save(ofslatex1, Output::latex, [](const auto &row) {
            return std::array{ row[0], row[1], row[2], row[3], row[4], row[5] };
        });

        std::stringstream sstr2;
        sstr2 << id << "-e";
        auto ofslatex2 = get_output_stream(Output::latex, sstr2.str());
        view.save(ofslatex2, Output::latex, [](const auto &row) {
            return std::array{ row[0], row[1], row[2], row[6], row[7], row[8] };
        });
    }
}; //C710

inline void run() {
    const double H = 10.0;
    const double mass = 1.0;
    const double v0 = 10.0;
    for (double angle : { 10.0, 30.0, 45.0, 60.0 }) {
        const double theta0 = Math::to_radians(angle);
        C710 cobj{ mass, H, v0, theta0 };
        cobj.exec();
        cobj.save_data();
    }
}
} // namespace nmx::apps::x710