geometry.h

Go to the documentation of this file.

#ifndef __GEOMETRY__
#define __GEOMETRY__

#ifndef NULL
#define NULL 0
#endif

class Manifold;

extern Manifold* gManifold;

class vector4
{
    double v[4];    
public:

    vector4();

    vector4(double v1, double v2, double v3, double v4);
    ~vector4();
    
    vector4& operator=(const vector4&);
    vector4 operator+(const vector4);
    vector4 operator+=(const vector4);
    vector4 operator-(const vector4);
    vector4 operator-=(const vector4);
    vector4 operator*(const double);
    vector4 operator*=(const double);
    vector4 operator/(const double);
    vector4 operator/=(const double);
    friend vector4 operator*(const double, const vector4);
    

    double& operator[](int i);
};

class Point
{
    double x[4];
    int coordSystem;
    static Manifold* m; 
public:
    Point();

    Point(int cS, double x0=0.0, double x1=0.0, double x2=0.0, double x3=0.0);

    Point(int cS, double tx[]);

    Point(int cS, vector4 v);
    Point(const Point&);
    ~Point();
    

    double& operator[](int i);
    /* \return The number of the coordinate system in use
     */
    int getCoordSystem();
    /* \return A vector4 with components equal to the coordinates of the point
     */
    vector4 toVector4();
    
    bool operator==(Point);
    bool operator!=(Point);
    
    /* This method sets the manifold being used in the whole program
     * \param _m The pointer to the manifold object
     */
    static void setGlobalManifold(Manifold* _m);
};

class CoordinateConversion
{
public:
    CoordinateConversion();
    virtual ~CoordinateConversion();
    

    virtual Point convertPoint(Point p) = 0;

    virtual double jacobian(int i, int j, Point p) = 0;

    virtual double inv_jacobian(int i, int j, Point p) = 0;
};

class IdentityConversion : public CoordinateConversion
{
public:
    IdentityConversion();
    ~IdentityConversion();
    

    Point convertPoint(Point p);

    double jacobian(int i, int j, Point);

    double inv_jacobian(int i, int j, Point);
};

class Metric
{
    Point gCachePoints[4][4];
    Point invgCachePoints[4][4];
    Point gammaCachePoints[4][4][4];
    
    double gCache[4][4];
    double invgCache[4][4];
    double gammaCache[4][4][4];
protected:
    int coordSystem;

    double dg(int i, int j, int k, Point p);
    

    virtual double _g(int i, int j, Point p) = 0;

    virtual double _invg(int i, int j, Point p) = 0;

    virtual double _christoffel(int i, int j, int k, Point p) = 0;
public:

    Metric(int cS);
    virtual ~Metric();
    

    double g(int i, int j, Point p);

    double invg(int i, int j, Point p);

    double christoffel(int i, int j, int k, Point p);
    

    double g(vector4 u, vector4 v, Point p);
    

    vector4 christoffel(vector4 u, vector4 v, Point p);
};

class Manifold
{
protected:
    int nCoordSystems;
    CoordinateConversion*** conversions;
    Metric** metrics;
public:
    Manifold();
    virtual ~Manifold();
    

    CoordinateConversion* getConversion(int i, int j);  //returns conversion from i to j

    Metric* getMetric(int i);

    Point convertPointTo(Point p, int system);  //convert point to coordinates

    vector4 convertVectorTo(vector4 v, Point p, int system);    //convert vector to coordinates
    

    virtual int recommendCoordSystem(Point p);
};

#endif