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 */