x900.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::x900 {

class X900 : public XModel
{
private:
    double _omega0, _phi0, _amplitude;

public:
    //Eingabeparameter
    const double mass;
    const double k;
    //Anfangsbedingungen
    const double x0, v0;

    inline X900(double m, double k, double x0, double v0)
        : XModel(__func__)
        , mass{ m }
        , k{ k }
        , x0{ x0 }
        , v0{ v0 } {
        Check::all(nmx_msg, { m > 0, k > 0 });

        _omega0 = sqrt(k / mass);
        _amplitude = sqrt(pow(x0, 2) + pow(v0 / _omega0, 2));
        _phi0 = atan2(_omega0 * x0, v0);
    }

    inline double omega0() const { return _omega0; }

    inline double phi0() const { return _phi0; }

    inline double amplitude() const { return _amplitude; }

    inline double phase(double t) const { return omega0() * t + _phi0; }

    inline double x(double t) const { return _amplitude * sin(phase(t)); }

    inline double v(double t) const { //
        return _amplitude * omega0() * cos(phase(t));
    }

    inline double a(double t) const { //
        return -_amplitude * pow(omega0(), 2) * sin(phase(t));
    }

    inline double force(double x) const { return -k * x; }
}; //X900

class C900 : public X900
{
public:
    using Ode = gsl::Odeiv2<2>;
    friend Ode;
    using Data = Data<7>;

    using X900::X900; //erbe Konstruktor von der Basisklasse

private:
    Data _data;

public:
    int odefn(double t, const double yin[], double yout[]) {
        (void) t; // compiler warning vermeiden
        yout[0] = yin[1];
        yout[1] = force(yin[0]) / mass;
        return GSL_SUCCESS;
    }

    inline void exec() {
        Ode ode{ *this, 1e-2, 1e-9, 0 };
        ode.set_init_conditions(0, { x0, v0 });
        const double _period = 2 * Math::PI / omega0();

        //löse Bewegungsgleichung
        double t = 0.0, dt = 0.01;
        while (t <= 1.5 * _period) {
            _data += { t, ode[0], ode[1], force(ode[0]) };
            t += dt;
            ode.solve(t);
        }

        //füge Energien hinzu
        for (auto &crow : _data.data()) {
            const auto x = crow[1];
            const auto v = crow[2];
            crow[4] = Mechanics::kinetic_energy(mass, v);
            crow[5] = 0.5 * k * pow(x, 2);
            crow[6] = crow[4] + crow[5];
        }
    }

    inline void save_data() {
        //erzeuge id damit  jede Datei einen eindeutigen Namen hat
        std::stringstream id;
        id << std::setprecision(3) << omega0() << "-" << phi0();

        //speichere Daten
        save(_data, Output::plot, id.str());
        save(_data.select_total_rows(10), Output::latex, id.str());
    }
}; //C900

inline void run() {
    //Modellparameter
    const double mass = 1.0, k = 100.0;
    //Anfangsbedingungen
    const double x0 = 1.0, v0 = 0.0;
    //Rechenmodell
    C900 cobj{ mass, k, x0, v0 };
    cobj.exec();
    cobj.save_data();
}

} // namespace nmx::apps::x900