NumericalSpacetime.hpp

//
// $Id: NumericalSpacetime.hpp,v 1.1 2004/08/24 09:09:53 werner Exp $
//
// $Log: NumericalSpacetime.hpp,v $
// Revision 1.1  2004/08/24 09:09:53  werner
// Towards VC7
//
// Revision 1.6  2004/05/13 16:44:23  werner
// Formulate Christoffel symbols via direct vectorization.
//
// Revision 1.5  2004/05/11 16:53:47  werner
// Introduction of coordinate systems for improved type-safety.
// Will support easy coordinate transformations soon.
//
// Revision 1.4  2004/05/06 22:42:16  werner
// Towards a specification of a spacetime via the Acceleration structure.
//
// Revision 1.3  2004/05/03 13:33:33  werner
// integration improved
//
// Revision 1.2  2004/03/29 11:51:02  werner
// Common interface among simple integrators, DiffMe and Vecal, and preliminiary work on integrating dop853.
//
// Revision 1.1  2004/03/22 11:55:02  werner
// Schwarzschild geodesic integration.
//
// Revision 1.1  2004/02/13 16:36:21  werner
// Initial preliminiary version of the Vector Algebra Library.
//
#ifndef __NumericalSpacetime_HPP
#define __NumericalSpacetime_HPP "Created 27.02.2001 21:42:27 by werner"

#include <vecal/ipol/ChristoffelField.hpp>

namespace Traum
{

template <class MetricArray, class CoordinateSystem>
struct  NumericalSpacetime : public CoordinateSystem
{
        typedef CoordinateSystem CoordinateSystem_t;

        enum { Dims = MetricArray::Dims };
        typedef typename MetricArray::value_type        metric_type;
        typedef typename MetricArray::Storage_t MetricStorage_t;

        typedef typename CoordinateSystem::Point_t  Point_t;
        typedef typename CoordinateSystem::Scalar_t Scalar_t;
        typedef typename CoordinateSystem::Vector_t Vector_t;
        typedef typename CoordinateSystem::Metric_t Metric_t;

        typedef CubicIpol<metric_type>  MetricInterpol;

        typedef typename Point_t::Vector_t::value_type CoordinateType;

        const MetricArray & g;

        typedef Interpolate<Dims, metric_type, MetricStorage_t, MetricInterpol, CoordinateType> MetricField_t;

        NumericalSpacetime(const MetricArray&metric)
        : g(metric)
        {}

        void getMetric(Metric_t&g_p, const Point_t&P) const
        {
        MetricField_t mf(g,P);
                mf.eval(g_p);
        }

        Vector_t operator()(const Point_t&q, const Vector_t&dot_q) const
        {
        Vector_t a;
        ChristoffelField<MetricArray> Chris(g, q);

                Chris.getCoordinateAcceleration(a, dot_q);
                return a;
        }
};

} /* namespace Traum */ 

#endif /* __NumericalSpacetime_HPP */