x130.h

Go to the documentation of this file.

#pragma once

#include "xmodel.h"
#include "xphysics.h"
#include "xvector.h"
#include <iostream>

namespace nmx::apps::x130 {

class X130 : public XModel
{
    using Data = Data<4>;
    using Vector = gsl::Vector;

private:
    // G m1 m3 and G m2 m3
    double _factor1, _factor2;
    //Koordinaten der  Massen m1 und m2
    Vector _d1, _d2;
    //Datenobjekt
    Data _data;

public:
    //Eingabeparameter
    const double m1, m2, m3;
    const double d, dx, dy;
    const double xlim, ylim;

public:
    // clang-format off
    X130(double m1, double m2, double d, double m3 = 1,
         double xlim = 5, double dx = 1,
         double ylim = 5, double dy = 1): XModel (__func__)
        , m1{ m1 } , m2{ m2 }, m3{ m3 }
        , d{ 0.5*d }, dx{ dx } , dy{ dy }
        , xlim{ xlim }, ylim{ ylim }  {}
    // clang-format on

    inline auto force1(const Vector &v) const {
        auto r = v - _d1; //Vektor von m1 zur Probemasse
        const double norm = nrm2(r);
        Check::error_if(nmx_msg, norm == 0.0);

        //berechne Kraft
        double den = pow(norm, 3);
        auto fResult = (_factor1 / den) * r;
        return fResult;
    }

    inline auto force2(const Vector &v) const {
        auto r = v - _d2; //Vektor von m2 zur Probemasse
        const double norm = nrm2(r);
        Check::error_if(nmx_msg, norm == 0.0);

        //berechne Kraft
        double den = pow(norm, 3);
        auto fResult = (_factor2 / den) * r;
        return fResult;
    }

    inline void exec() {
        using namespace gravitation;
        Check::all(nmx_msg, { m1 > 0, m2 > 0, d > 0, m3 > 0 });

        //konstante Faktoren der Kräfte von m1 und m2 auf die Probemasse
        _factor1 = -Astronomy::G * m1 * m3;
        _factor2 = -Astronomy::G * m2 * m3;

        //Ortsvektorten von m1 und m2
        _d1 = { -d, 0.0 };
        _d2 = -_d1;

        //Berechne normierte Gesamtkraft für jeden Punkt (x,y)
        for (double _x = -xlim; _x < xlim; _x += dx) {
            for (double _y = -ylim; _y < ylim; _y += dy) {
                Vector r{ _x, _y };
                try {
                    //Kräfte von m1 und m2 auf Probemasse
                    auto f1 = force1(r), f2 = force2(r);
                    auto f = normalize(f1 + f2);
                    //speichere Daten in Tabelle
                    _data += { _x, _y, f[0], f[1] };
                } catch (const std::exception &err) {
                    std::cout << _x << "," << _y << std::endl;
                    std::cout << err.what() << std::endl;
                }
            }
        }
    }

    inline void save_data() const {
        std::ofstream mysplot = get_output_stream(Output::plot, m1);
        mysplot << std::scientific << std::setprecision(2);

        //Formatierung kompatibel zu TiKZ (erste Zeile)
        mysplot << "x y u v\n";

        //Formatierung kompatibel zu TiKZ (Daten)
        const auto sep = " ", lend = "\n";
        for (const auto &crow : _data.data()) {
            mysplot << crow[0] //
                    << sep << crow[1] //
                    << sep << crow[2] //
                    << sep << crow[3] << lend;
        }
    }
}; //X130

inline void run() {
    //Probemasse
    const double m3 = 1.0;
    //Erzeugt zusammen mit m1 das Feld
    const double m2 = 1e4;
    //Abstand zwischen m1 und m2
    const double d = 10.0;
    //Bereich in dem die Vektoren gezeichnet werden
    const double xlim = 10, dx = 1.5;
    const double ylim = 10, dy = 1.5;

    // setze m1 = m2
    double m1 = 1e4;
    X130 xobj0{ m1, m2, d, m3, xlim, dx, ylim, dy };
    xobj0.exec();
    xobj0.save_data();

    // m1 ist ein Vielfaches von m2
    m1 = 16e4;
    X130 xobj1{ m1, m2, d, m3, xlim, dx, ylim, dy };
    xobj1.exec();
    xobj1.save_data();
}

} // namespace nmx::apps::x130