x1500.h

Go to the documentation of this file.

#pragma once

#include "xode.h"
#include "xmath.h"
#include "xmodel.h"
#include "xphysics.h"
#include <array>

namespace nmx::apps::x1500 {

enum class Damping {
    over = 0, //starke Dämpfung (0)
    critical = 1, //aperiodischer Grenzfall (1)
    under = 2 //schwache Dämpfung (2)
};

class X1500 : public XModel
{
public:
    using IValues = std::array<double, 2>;

    const double mass, k;
    const double omega0, period0, frequency0;
    const double beta, gamma;
    const double x0, v0;

public:
    inline X1500(double mass, double k, double beta, IValues initc)
        : XModel{ __func__ }
        , mass{ mass }
        , k{ k }
        , omega0{ sqrt(k / mass) }
        , period0(2 * Math::PI / omega0)
        , frequency0(1 / period0)
        , beta{ beta }
        , gamma{ 0.5 * beta / mass }
        , x0{ initc[0] }
        , v0{ initc[1] } {}

    inline double expfactor(double t) const { return exp(-gamma * t); }

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

    inline Damping type() const { return type(gamma, omega0); }

    inline static Damping type(double gm, double omg0) {
        double gamma2 = pow(gm, 2);
        double omega02 = pow(omg0, 2);
        Damping result;
        // entscheide über den Typ der gedämpften Schwingung
        if (gamma2 > omega02) {
            result = Damping::over;
        } else if (std::abs(gamma2 - omega02) < 1e-6) {
            result = Damping::critical;
        } else {
            result = Damping::under;
        }

        return result;
    }
}; //X1500

class Overdamped : public X1500
{
private:
    double _omega = 0;

public:
    inline Overdamped(double mass, double k, double beta, IValues initc)
        : X1500{ mass, k, beta, initc } {
        Check::error_if_not(nmx_msg, type() == Damping::over);
        _omega = sqrt(pow(gamma, 2) - pow(omega0, 2));
    }

    inline double x(double t) const {
        const double phs = omega() * t;
        const double fac = (x0 / omega());
        const double trm0 = (omega() * cosh(phs) + gamma * sinh(phs));
        const double term = fac * trm0;
        return expfactor(t) * term;
    }

    inline double v(double t) const {
        const double phase = omega() * t;
        const double trm0 = (x0 / omega()) * sinh(phase);
        return -pow(omega0, 2) * expfactor(t) * trm0;
    }

    inline double omega() const { return _omega; }
}; //Overdamped

class Critical : public X1500
{
public:
    inline Critical(double mass, double k, double beta, IValues initc)
        : X1500{ mass, k, beta, initc } {
        Check::error_if_not(nmx_msg, type() == Damping::critical);
    }

    inline double x(double t) const { //
        return x0 * expfactor(t) * (1 + gamma * t);
    }

    inline double v(double t) const { //
        return -x0 * t * expfactor(t) * pow(gamma, 2);
    }
}; //Critical

class Underdamped : public X1500
{
private:
    double _phi0, _C, _omega;

public:
    inline Underdamped(double mass, double k, double beta, IValues initc)
        : X1500{ mass, k, beta, initc } {
        Check::error_if_not(nmx_msg, type() == Damping::under);
        _omega = sqrt(pow(omega0, 2) - pow(gamma, 2));
        _phi0 = atan2(omega(), gamma);
        _C = omega0 * x0 / _omega;
    }
    inline double x(double t) const { //
        return _C * expfactor(t) * sin(omega() * t + _phi0);
    }

    inline double v(double t) const {
        const double phase = omega() * t + _phi0;
        const double part1 = -gamma * x(t);
        const double part2 = _C * expfactor(t) * omega() * cos(phase);
        return part1 + part2;
    }

    inline double omega() const { return _omega; }
}; //Underdamped

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

    using X1500::X1500;

private:
    Data _data;

public:
    inline int odefn(double t, const double fin[], double fout[]) {
        (void) t;
        fout[0] = fin[1];
        fout[1] = acceleration(fin[0], fin[1]);
        return GSL_SUCCESS;
    }

    void solve_ode() {
        Ode ode{ *this, 1e-2, 1e-9, 0 };
        ode.set_init_conditions(0, { x0, v0 });
        double t = 0, tmax = 2 * period0, dt = tmax / 100; //Schrittweite
        while (t < tmax) {
            _data += { t, ode[0], ode[1] };
            t += dt;
            ode.solve(t);
        }
    }

    inline void exec() {
        //Lösung der Bewegungsgleichung
        solve_ode();
        //Hinzufügen der Gesamtenergie
        for (auto &crow : _data.data()) {
            const double ekin = Mechanics::kinetic_energy(mass, crow[2]);
            const double epot = 0.5 * k * pow(crow[1], 2);
            crow[3] = ekin + epot;
        }
        // exakte Werte von x und v
        auto exactFn = [this](auto cobj) {
            for (auto &crow : _data.data()) {
                const double t = crow[0];
                crow[4] = cobj.x(t);
                crow[5] = cobj.v(t);
            }
        };
        //rufe das zuständige Rechenmodell auf
        if (type() == Damping::over) {
            exactFn(Overdamped(mass, k, beta, { x0, v0 }));
        } else if (type() == Damping::under) {
            exactFn(Underdamped(mass, k, beta, { x0, v0 }));
        } else if (type() == Damping::critical) {
            exactFn(Critical(mass, k, beta, { x0, v0 }));
        }
    }

    void save_data() {
        save(_data, Output::plot, static_cast<int>(type()));
        save(_data.select_total_rows(6), //
             Output::latex,
             static_cast<int>(type()));
    }
}; //C1500

inline void run() {
    //gemeinsame Programmparameter
    const double mass = 1.0;
    const double x0 = 30.0_mm;
    const double v0 = 0.0;

    //starke Dämpfung
    double beta = 15;
    double k = 9.0;
    C1500 cobj0{ mass, k, beta, { x0, v0 } };
    cobj0.exec();
    cobj0.save_data();

    //schwache Dämpfung
    beta = 1;
    k = 36.0;
    C1500 cobj1{ mass, k, beta, { x0, v0 } };
    cobj1.exec();
    cobj1.save_data();

    //aperiodischer Grenzfall
    beta = 6;
    k = 9.0;
    C1500 cobj2{ mass, k, beta, { x0, v0 } };
    cobj2.exec();
    cobj2.save_data();
}

} // namespace nmx::apps::x1500