x910.h

Go to the documentation of this file.

#pragma once
#include "xode.h"
#include "xmath.h"
#include "xmodel.h"
#include "xphysics.h"

namespace nmx::apps::x910 {

using namespace gravitation;

class X910 : public XModel
{
public:
    // Eingabeparameter
    const double m1, m2;
    const double k;
    const double y0, v0;
    const double omega0;
    const double period;

public:
    inline X910(double m1, double m2, double k, double y0, double v0)
        : XModel(__func__)
        , m1{ m1 }
        , m2{ m2 }
        , k{ k }
        , y0{ y0 }
        , v0{ v0 }
        , omega0{ sqrt(k / (m1 + m2)) }
        , period{ 2 * Math::PI / omega0 } {}

    inline double acceleration(double x) const { //
        return -pow(omega0, 2) * x;
    }

    inline double normal_force2(double t) const {
        return m2 * Earth::g * (1 + y0 * pow(omega0, 2) / Earth::g * cos(omega0 * t));
    }
}; //X910

class C910 : public X910
{
public:
    using Ode = gsl::Odeiv2<2>;
    friend Ode;
    using Data = Data<6>;

    //benutze Konstruktoren der Basisklasse
    using X910::X910;

private:
    double _normalForce2;
    //Zahlentabelle zum Speichern der Ergebnisse
    Data _data;

    int odefn(double t, const double yin[], double yout[]) {
        (void) t;
        yout[0] = yin[1];
        yout[1] = acceleration(yin[0]);
        return GSL_SUCCESS;
    }

public:
    void exec() {
        //Objekt zur numerischen Lösung der Differenzialgleichung
        Ode ode{ *this, 1e-2, 1e-9, 0 };
        ode.set_init_conditions(0, { y0, v0 });
        double t = 0, dt = 0.001;

        //rechne solange die Geschwindigkeit negativ ist.
        while (ode[1] <= 0) {
            _normalForce2 = m2 * (-acceleration(ode[0]) + Earth::g);

            //Abbruchkriterium
            if (_normalForce2 < 0) {
                break; // m2 hat sich gelöst
            }

            //schreibe Daten in Zahlentabelle
            _data += {
                t,
                t / period,
                ode[0],
                ode[1],
                _normalForce2, // numerisch
                normal_force2(t) //exakt
            };

            t += dt;
            ode.solve(t);
        }
    }

    inline void save_data() const { //
        //erzeuge id (für jede maximale Auslenkung wird eine sepparate
        //Datei erzeugt)
        std::stringstream sid;
        sid << std::setprecision(2) << abs(y0);
        const auto id = sid.str();

        save(_data, Output::plot, id);
        save(_data.select_total_rows(5), Output::latex, id);
    }
}; //C910

inline void run() {
    //Bewegungsparameter
    const double m1 = 1.5, m2 = .5, k = 200.0;

    //Anfangsbedingungen
    const double y0max = Earth::g / (k / (m1 + m2)), v0 = 0.0;

    //Berechnung der Daten
    for (const auto y0 : { 1.5 * y0max, y0max }) {
        //Rechenmodell
        C910 cobj{ m1, m2, k, y0, v0 };
        cobj.exec();
        cobj.save_data();
    }
}

} // namespace nmx::apps::x910