PhysikEngine.cpp

gehe zur Dokumentation dieser Datei

/*
Autor: $Author: kunkel $ State: $State: Exp $
Datum: $Date: 2005/05/30 12:35:25 $
Version: $Revision: 1.1 $
*/

#include "PhysikEngine.h"
#include "Integrator.h"
#include "Configuration.h"
#include "ObjectManager.h"
#include "CollisionsManager.h"
#include "Opengl.h"

void PhysikEngine::simulateGravity(double time) {
    objectList * objects = ourObjectManager.getObjectList();

    // waehle aktuellen Integrator aus
    Integrator *integrator=ourConfiguration.integrator;

    // hole die Integrator-interne Zeit
    double t=integrator->getTime();

    // uebergebe dem Integrator die Objektliste
    integrator->setObjects(objects);

    // aktualisiere time
    time += t;

    // starte Integration
    while(t<time-(1e-10)) {

        // falls beim Integrieren Fehler auftritt, gebe entsprechende
        // Nachricht aus
        try {
            t=integrator->integrate(time-t);
        } catch (Integrator::Error Ierror) {
            Opengl::setAnimation(false);
            Ierror.print();
            return;
        }

        // falls Kollisionen stattgefunden haben, erzeuge
        // eine Kollisionsmanager und fuehre Kollisionen durch
        if(integrator->getCollisionslist()->empty() == false) {
            CollisionsManager CM(integrator->getCollisionslist(),
                                 objects);
            CM.collide();
        }
    }
}

/* Die folgende Ephemeriden-Funktion wurde aus datentechnischen
     Gruenden nie getestet/fertiggestellt, koennte aber als Geruest fuer
     ein ephemeridenbasiertes Koordinatensystem verwendet werden.*/
//      Vector PhysikEngine::getPositionFromEphemeris(double acc, double a, double epsilon, double i, double Omega, double omega, double M,bool grad)
//      {
//              if(acc==0.0) acc=1e-12;
//
//              if(grad) {
//                      i=i/360*2*Pi;
//                      Omega=Omega/360*2*Pi;
//                      omega=omega/360*2*Pi;
//                      M=M/360*2*Pi;
//              }
//
//              double E = rtnewt(-10.0, 10.0, acc, M, epsilon); // Ränder evtl. noch verändern
//              if(E==0.0) return Vector(0.0,0.0,0.0);
//
//              double ny = atan(sqrt((1.0+epsilon)/(1.0-epsilon))*tan(E/2));
//
//              Vector rorbit(cos(ny),sin(ny),0.0);
//              Vector rhelio(0.0,0.0,0.0);
//              Matrix D1i(1.0,0.0,0.0, 0.0,cos(i),-sin(i), 0.0,sin(i),cos(i));
//              Matrix D3O(cos(Omega),-sin(Omega),0.0, sin(Omega),cos(Omega),0.0, 0.0,0.0,1);
//              Matrix D3o(cos(omega),-sin(omega),0.0, sin(omega),cos(omega),0.0, 0.0,0.0,1);
//
//              rhelio = D3O*D1i*D3o*rorbit;
//              rhelio *= a*(1-epsilon*epsilon)/(1+epsilon*cos(ny));
//              return rhelio;
//      }

// diese Funktiont wird fuer die Ephemeriden-Funktion unten benoetigt
// double PhysikEngine::rtnewt(double x1, double x2, double xacc, double M, double epsilon)
// /* Using the Newton-Raphson method, find the root of a function known to lie in the interval [x1, x2]. The root rtnewt will be refined until its accuracy is known within ±xacc. funcd is a user-supplied routine that returns both the function value and the first derivative of the function at the point x. */
// {
//      int j;
//      double df,dx,dx_abs,f,rtn;
//      rtn=0.5*(x1+x2);
//      for (j=1;j<=20;j++) {
//              f = M + epsilon*sin(rtn) - rtn;
//              df = epsilon*cos(rtn) - 1.0;
//              dx=f/df;
//              rtn -= dx;
//              if ((x1-rtn)*(rtn-x2) < 0.0)
//                      Error("Jumped out of brackets in rtnewt");
//              if (dx < 0) dx_abs=-dx;
//              else dx_abs=dx;
//              if (dx_abs < xacc) return rtn;
//      }
//      Error("maximum number of iterations exceeded in rtnewt");
//      return 0.0;
// }

---