x410.h

Go to the documentation of this file.

#pragma once

#include "xlu.h"
#include "xode.h"
#include "xmodel.h"
#include "xphysics.h"

namespace nmx::apps::x410 {

using namespace gravitation;

enum class Idx { x1ddot, x2ddot, N1, N2 };

class X410 : public XModel, public CResult<4, Idx>
{
public:
    // Eingabeparameter
    const double m1, m2;
    const double theta;
    const double mu;

    X410(double m1, double m2, double theta, double mu)
        : XModel(__func__)
        , m1{ m1 }
        , m2{ m2 }
        , theta{ theta }
        , mu{ mu } {
        //sind alle Eingaben gültig?
        Check::all(nmx_msg, { m1 > 0, m2 > 0, theta > 0, mu > 0 });
    }
}; //X410

class CModel1 : public X410
{
private:
    double _cTheta, _sTheta;
    double _m12, _trm1, _den;

    double N1() const { //
        return m1 * Earth::g * _cTheta / (1 - _m12 * _sTheta * _trm1);
    }

    double N2() const { //
        return m2 * Earth::g - N1() * (mu * _sTheta + _cTheta);
    }

    double x1_ddot() const {
        double num = Earth::g * _cTheta * (_m12 * _cTheta * _trm1 + mu);
        double den = (1 - _m12 * _sTheta * _trm1);
        return -Earth::g * _sTheta + (num / den);
    }

    double x2_ddot() const {
        return -_m12 * Earth::g * _cTheta * _trm1 / (1 - _m12 * _sTheta * _trm1);
    }

public:
    //erbe Konstruktoren von der Basisklasse
    using X410::X410;

    inline void apply() {
        _cTheta = cos(theta);
        _sTheta = sin(theta);
        _trm1 = mu * _cTheta - _sTheta;
        _den = 1 - _m12 * _sTheta * _trm1;
        _m12 = m1 / m2;
        //speichere Ergebnisse
        set_result({ x1_ddot(), x2_ddot(), N1(), N2() });
    }
}; //CModel1

struct CModel2 : public X410 {
    //erbe Konstruktoren von der Basisklasse
    using X410::X410;

    //Berechnung und Speicherung der Normalkräfte und
    //der Beschleunigungen durch direktes Lösen des
    //Gleichungssystems
    inline void apply() {
        using LU = gsl::LU_Decomposition;
        const double cosTheta = cos(theta);
        const double sinTheta = sin(theta);
        LU::Matrix _left({
            { cosTheta, 1.0, (sinTheta - mu * cosTheta) / (m1), 0 },
            { sinTheta, 0, -(cosTheta + mu * sinTheta) / (m1), 0 },
            { 0, 1, -(sinTheta - mu * cosTheta) / (m2), 0 },
            { 0, 0, (cosTheta + mu * sinTheta), 1 } //
        });
        LU::Vector _right({ 0.0, -Earth::g, 0, m2 * Earth::g });
        LU lusolver{ _left, _right };
        lusolver.solve();
        //speichere Ergebnisse
        set_result(lusolver.solution());
    }
}; //CModel2

inline void run() {
    //Masse gleitet auf schiefe Ebene
    const double m1 = 1.0;
    //Neigungswinkel der schiefen Ebene
    const double theta = 30._deg;
    //Datenobjekt speichert berechnete Daten
    Data<8> data;
    //variiere lambda und Gleitreibungskoeffizienten
    for (double lambda : { 10, 100, 1000 }) {
        for (double mu : { 0., 0.1, 0.2 }) {
            const double m2 = lambda * m1;
            //Modellklasse und Rechenmodelle
            CModel1 cobj1{ m1, m2, theta, mu };
            CModel2 cobj2{ m1, m2, theta, mu };
            cobj1.apply();
            cobj2.apply();
            data += { lambda,
                      mu,
                      cobj1(Idx::x1ddot),
                      cobj1(Idx::x2ddot),
                      cobj1(Idx::N1),
                      cobj1(Idx::N2),
                      cobj2(Idx::x1ddot),
                      cobj2(Idx::x2ddot) };
        }
    }
    //Daten werden in Dateien geschrieben
    auto ofs1 = X410::get_output_stream(Output::latex);
    ofs1 << std::setprecision(2);
    data.save(ofs1, Output::latex);
}
} // namespace nmx::apps::x410