PhysikEngine.h

gehe zur Dokumentation dieser Datei

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

#ifndef PHYSIKENGINE_H
#define PHYSIKENGINE_H

#include <math.h>
#include "Vector.h"

/*
**
* Matrix-Klasse, mit einigen Matrixoperationen. Wurde in unserer Implementierung
* letztendlich nicht benoetigt.
 
class Matrix {
public:
    double x1, x2, x3, y1, y2, y3, z1, z2, z3;
    inline  Matrix(double x1_, double x2_, double x3_, double y1_, double y2_,
     double y3_, double z1_, double z2_, double z3_) {
        x1=x1_;
        x2=x2_;
        x3=x3_;
        y1=y1_;
        y2=y2_;
        y3=y3_;
        z1=z1_;
        z2=z2_;
        z3=z3_;
    }
    inline Matrix() {}
 
    inline Matrix operator*(const Matrix & a) {
        return Matrix(  x1 * a.x1 + x2 * a.y1 + x3 * a.z1,
                        x1 * a.x2 + x2 * a.y2 + x3 * a.z2,
                        x1 * a.x3 + x2 * a.y3 + x3 * a.z3,
                        y1 * a.x1 + y2 * a.y1 + y3 * a.z1,
                        y1 * a.x2 + y2 * a.y2 + y3 * a.z2,
                        y1 * a.x3 + y2 * a.y3 + y3 * a.z3,
                        z1 * a.x1 + z2 * a.y1 + z3 * a.z1,
                        z1 * a.x2 + z2 * a.y2 + z3 * a.z2,
                        z1 * a.x3 + z2 * a.y3 + z3 * a.z3
                        );
    }
    
    inline Vector operator*(const vector & a) {
        return Vector(x1 * a.x + x2 * a.y + x3 * a.z, y1 * a.x + y2 * a.y + y3 *
         a.z, z1 * a.x + z2 * a.y + z3 * a.z);
    }
    
    
};
 
inline ostream & operator<<(ostream &out_, const matrix & v_){
        out_ << " X1: " << v_.x1
                << " X2: " << v_.x2
                << " X3: " << v_.x3
                << " Y1: " << v_.y1
                << " Y2: " << v_.y2
                << " Y3: " << v_.y3
                << " Z1: " << v_.z1
                << " Z2: " << v_.z2
                << " Z3: " << v_.z3;
        return out_;
}
*/

class PhysikEngine {
    /*private:
        // diese Funktiont wird fuer die Ephemeriden-Funktion unten benoetigt
        static double rtnewt(double x1, double x2, double xacc, double M,
    double epsilon);*/

public:
    static void simulateGravity(double time);

    /* Die folgende Ephemeriden-Funktion wurde aus datentechnischen
     Gruenden nie getestet/fertiggestellt, koennte aber als Geruest fuer
     ein ephemeridenbasiertes Koordinatensystem verwendet werden.*/
    //  static Vector getPositionFromEphemeris(double acc_, double a_,
    //   double epsilon_, double i, double Omega, double omega, double M_,
    //   bool grad);

    Vector getSpeed();

    class Error {
    private:
        string message;

    public:
        Error(const string & msg) {
            message = msg;
        }

        void print() {
            cerr << message << endl;
        }
    };
};

#endif

---