Symulacja spadku prędkości obiektu.

Question

Witam, od dwóch tygodni męczę się z pewnym problemem, mianowicie chcę za symulować ruch obiektu...

Wypuszczony obiekt jak kula do kręgli czy cokolwiek co się samo nie napędza, ma spadek prędkości oraz inne cechy.

Chcę za symulować spadek prędkości na 1ms, żeby w dowolnym momencie symulacji znać położenie obiektu, dane pobieram za pomocą stopera.

Dana są nastepujące(jednostki są wirtualne):

Prędkość początkowa: 108.029

Prędkość końcowa: 75.5102

Spadek prędkości: 0.0331826 (Na 1ms)

Czas ruchu: 980Ms

Pokonany dystans (To był obiekt na torze, 1 pętla) 74000

I teraz zaczyna się kompletny bałagan, od dawna widziałem że coś jest nie tak, napisałem prosty program żeby to sprawdzić i co się okazuje, że owszem czas ruchu jest równy 980, a prędkość 75.5102 od 108.029 przy spadku prędkości 0.0331826/Ms, jest osiągana od w 980Ms, tylko że pokonany dystans wynosi 89950 z kawałkiem zamiast 74000.

Nie mam bladego pojęcia jak za symulować ruch obiektu, aby otrzymać nawet podobne dane, do tego co oczekuję.

Tutaj macie sam program do testu, program w którym pobieram dane i robię symulację, nie będę wklejać, gdyż ma on więcej niż kilka tysięcy linii kodu, i robi różne rzeczy, więc nie ma to sensu. Same obliczenia zdają się niepoprawne.

Pisałem to w QT c++, ale można to spokojnie przerobić na cout i wypisać dane.

Dane spadku prędkości pobierałem wzorem prędkość_początkowa - prędkość_końcowa / czas_ruchu.
Konieczni jest mi potrzebna pomoc, jestem w stanie nawet zapłacić, jest mi to potrzebne.

Ma ktoś może jakiś pomysł jak to wykonać? Myślałem, żeby dać to do działu fizyka/matematyka/logika, ale jednak dałem to tutaj.

#include <QCoreApplication>
#include <QDebug>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    double distance = 0;
    double speed = 108.029;
    double target_speed = 75.5102;
    double deceleration = -0.0331826;
    int time = 0;

    while(speed > target_speed)
    {
        distance += speed;
        speed += deceleration;
        time++;
    }
    qDebug() << "Time: " << time;
    qDebug() << "Distance: " << distance;

    return a.exec();
}

 

Comments

* zasymulować

Answer 1

Przy metodzie stało-krokowej (którą masz), błędy obliczeń zmiennoprzecinkowych kumulują ci się. Wystarczy że zapytasz wyszukiwarkę o metody stało i zmienno-krokowe. Pierwsze z brzegu poglądowo: https://fulmanski.pl/zajecia/tippgk/zajecia_20162017/fixed_step/fixed_step.pdf

Jeszcze lepiej obliczać pozycję z uwzględnieniem czasu monotonicznego. Czyli pytanie "gdzie jest obiekt w 10 sek. a gdzie w 11". Przy tym prostym modelu który masz, jest to swobodnie możliwe.

Comments

Będąc szczerym nie mam już siły się tym zajmować, musiał bym też zrozumieć o co chodzi z tymi metodami. Jeśli wiesz jak to poprawnie zrobić, bardzo chętnie zapłacę za sam algorytm.

---

http://fizyka.pisz.pl/strona/9.html jeśli nie chcesz symulacji a jedynie obliczyć..

---

To raczej nie pomoże, bo ów dane są znane po samym obliczeni, ale przed tym, znana jest jedyni prędkość początkowa i spadek prędkości. Ja podałem wszystkie dane po obliczeniu tylko po to, żeby sprawdzić, czy te dane pasują do rzeczywistych, na samym początku jak mówiłem, znana jest jedynie prędkość początkowa i spadek prędkości, który i tak się nieustannie zmienia w zależności od prędkości.

Answer 2

Witam,

jeśli używasz Qt to możesz skorzystać z jego możliwości aby zasymulować tą akcje. Qt posiada klasę QTimer, która umożliwia wysłanie sygnału w określonym czasie. Tak na szybko sklecone, oczywiście można to ulepszyć.

Plik *h

#ifndef SIMULATION_H
#define SIMULATION_H
#include <QTimer>
#include <QObject>


class Simulation : public QObject
{
    Q_OBJECT
public:
    Simulation();
    void startSimulation();
    void stopSimulation();
private:
    double distance = 0;
    double speed = 108.029;
    double target_speed = 75.5102;
    double deceleration = -0.0331826;
    int time = 0;

    QTimer *myTimer;
private slots:
    void stepWorld();

};

#endif // SIMULATION_H

Plik cpp

#include "simulation.h"
#include <QDebug>

Simulation::Simulation() : QObject()
{
    myTimer = new QTimer(this);
    connect(myTimer, &QTimer::timeout, this, &Simulation::stepWorld);
}

void Simulation::stepWorld()
{
    if(speed > target_speed)
    {
        distance += speed;
        speed += deceleration;
        ++time;
    }
    else{
        qDebug() << "STOP!";
        stopSimulation();
    }
    qDebug() << "Time: " << time << " [ms]";
    qDebug() << "Distance " << distance;
}


void Simulation::startSimulation()
{
    myTimer->start(1); //1ms jako krok
}

void Simulation::stopSimulation()
{
    myTimer->stop();
}

oraz plik main.cpp

#include <QCoreApplication>
#include "simulation.h"


int main (int argc, char **argv) {
    QCoreApplication app(argc, argv);
    Simulation simulation;
    simulation.startSimulation();


    return app.exec();
}

W powyższej symulacji wyszło mi że pokonany dystans to: 89950.4 natomiast czas to 980[ms].

PS

Piszę się Qt nie QT:

https://pl.wikipedia.org/wiki/Qt

A co do jednostek to z tego co wiem to duża litera M oznacza przedrostek mego więc powinieneś pisać m z małej co oznacza mili np. ms nie Ms.

https://pl.wikipedia.org/wiki/Przedrostek_SI

Comments

Wiem, że można użyć timera, tylko że jest mi to jest potrzebne, zanim coś się wydarzy.
Jak zdarzenie ma powiedzmy 30 sekund, to jak odpalę timer, to samego wyniku nie otrzymam przed faktycznym zakończeniem, a na końcu jak się ono zakończy.

Mogę i tak spróbować, natomiast jak algorytm jest ten sam, z tą różnicą, że licznikiem jest timer, a nie pętla, to nie spodziewam się innych wyników poza tym, że timer za symuluje mniej więcej czas rzeczywisty.

Piszę się Qt nie QT:

Ps. Serio? Mam już za dużo lat żeby przejmować się czy pisze się MS, mS, ms, czy m.s, nie wiele mnie interesują również dziadkowie, którzy zebrali się lata temu i coś sobie po nazywali, z kontekstu każdy się domyśli. Bez urazy, ale naprawdę ta wiedza czy pisze się qt, czy inaczej, nie jest potrzebna.

Tak czy inaczej, znalazłem przyczynę problemu, najprawdopodobniej napiszę wątek w dziale fizyka.