x021.h

Go to the documentation of this file.

#pragma once

#include "xdata.h"
#include "xdefs.h"
#include "xmath.h"
#include "xphysics.h"

namespace nmx::apps::x021 {
inline void ex23() {
    using namespace gravitation;
    // Tabelle mit drei Spalten t,z,v
    using Data = Data<3>;
    Data table;

    std::ofstream output = Output::get_stream("x021",
                                              Output::csv, //
                                              __func__);
    output << std::setprecision(3);

    //Anfangsbedingungen
    const double z0 = 0.0, v0 = 20.0;
    const double g = Earth::g;

    //rechne mit kleinen Zeitschritten
    double t = 0, dt = 1e-3, z = z0, v = v0;
    while (z >= 0) {
        table += { t, z, v };
        t += dt;
        z = z0 + v0 * t - 0.5 * g * pow(t, 2);
        v = v0 - g * t;
    }

    //finde Vorzeichenwechsel der Geschwindigkeit
    auto itr = std::adjacent_find(ALL(table.data()), //
                                  [](const auto &x, const auto &y) { //
                                      return x[2] * y[2] < 0;
                                  });

    //addiere gefundene Zeile und nächste sowie die letzte Zeile
    View view = table.view({ itr, itr + 1 }, false, true);

    //Ausgabe
    output << std::setprecision(3);
    output << std::setw(5) << "t" << std::setw(10) << "z" << std::setw(10) << "v" << std::endl;
    output << "-------------------------------" << std::endl;
    view.save(output, Output::csv);
    output << "-------------------------------" << std::endl;
    //die exakten Werte
    Data::Row r1{ v0 / Earth::g, 0.5 * pow(v0, 2) / Earth::g, 0 };
    Data::Row r2{ 2 * v0 / Earth::g, 0, -v0 };
    Output::csv.as_rows(output, r1, r2);
}

inline void ex24() {
    const double mass = 2.0;
    const double force = 10.0;
    Data<7> table;
    const double t = 10.0;
    //für jeden Winkel...
    for (double phi : { 10, 30, 45, 60 }) {
        //... berechne  Daten
        const double phirad = Math::to_radians(phi);
        const double fx = force * cos(phirad);
        const double fy = force * sin(phirad);
        const double ax = fx / mass;
        const double vx = ax * t;
        const double x = 0.5 * ax * pow(t, 2);
        const double work = fx * x;
        //...und füge eine neue Reihe zur Tabelle hinzu
        table += { phi, fx, fy, ax, vx, x, work };
    }
    //speichere Daten in Datei
    std::ofstream csvstream = Output::get_stream("x021", Output::latex, __func__);
    table.save(csvstream, Output::latex);
}

inline void ex25() {
    // Datenobjekt
    using Data = Data<6>;
    Data table;
    //Masse des Geschosses
    const double m = 200.0_g;
    //erzeuge Daten für drei Holzblockmassen und
    //drei Kugelgeschwindigkeiten
    for (auto M : { 1.0, 5.0, 10.0 }) {
        const double factor = m / (m + M);
        for (auto v : { 200.0, 400.0, 600.0 }) {
            const auto vp = factor * v;
            //kinetische Energie vor dem Stoß
            const auto ekinB = 0.5 * m * pow(v, 2);
            //kinetische Energie nach dem Stoß
            const auto ekinA = 0.5 * (M + m) * pow(vp, 2);
            const auto ekinDiff = 100 * abs(ekinA - ekinB) / ekinB;
            //speichere Daten im Datenobjekt
            table += { M, v, vp, ekinB, ekinA, ekinDiff };
        }
    }
    //erzeuge Ausgabestrom und speichere die Daten im LaTeX-Format
    std::ofstream ofs = Output::get_stream("x021", Output::latex, __func__);
    table.save(ofs, Output::latex);
}

void ex26() {
    using namespace gravitation; //für die universelle Gravitationskonstante
    Data<3> table;
    //Abstände xmin = R bis xmax = 2* R...
    const auto xmin = Earth::radius;
    const auto xmax = 2 * xmin;
    //...mit Schrittweite
    const auto dx = 1000.0_km;
    const auto mass = 10.0;
    const auto factor = Astronomy::G * Earth::mass * mass;

    for (double x = xmin; x < xmax; x += dx) {
        const auto force = -factor / pow(x + xmin, 2);
        const auto pEnergy = -factor / (x + xmin);
        //speichere Abstand, Kraft, potenzielle Energie in Zahlentabelle
        table += { x, force, pEnergy };
    }
    //erzeuge Ausgabestrom und speichere die Daten im LaTeX-Format
    std::ofstream ofs = Output::get_stream("x021", Output::latex, __func__);
    table.save(ofs, Output::latex);
}

void ex27() {
    using Data = Data<3>;
    Data data;

    // Tabelle mit {m,x,y}
    data += { 1, 0, 0 }; // Masse 1
    data += { 2, 4, 0 }; // Masse 2
    data += { 3, 2, 3.46 }; //Masse 3

    //Ortvektor und Masse  des Schwerpunktes
    std::array cmPosition{ 0.0, 0.0 };
    double cmMass = 0;

    //Masse und Ortsvektor werden bei jedem Aufruf aktualisiert.
    auto calcCM = [&cmMass, &cmPosition](const Data::Row &row) {
        cmMass += row[0]; // addiere neue Masse hinzu
        cmPosition[0] += row[0] * row[1]; // m_i * x_i
        cmPosition[1] += row[0] * row[2]; // m_i * y_i
    };

    //Wende Funktion auf jede Reihe des Datenobjekts an
    data.apply(calcCM);
    cmPosition[0] /= cmMass; //xcm
    cmPosition[1] /= cmMass; //ycm

    //Gesamtmasse und Schwerpunktskoordinaten in letzte Reihe
    data += { cmMass, cmPosition[0], cmPosition[1] };

    //Ausgabe
    std::ofstream ofs = Output::get_stream("x021", Output::latex, __func__);
    data.save(ofs, Output::latex);
}

} // namespace nmx::apps::x021