EvalChristoffel.hpp

//
// $Id: EvalChristoffel.hpp,v 1.4 2004/08/12 16:21:34 werner Exp $
//
// $Log: EvalChristoffel.hpp,v $
// Revision 1.4  2004/08/12 16:21:34  werner
// Integration of numerical geodesics now compiles. Working is not yet satisfying.
//
// Revision 1.3  2004/05/14 10:01:47  werner
// removed comment.
//
// Revision 1.2  2004/05/13 16:43:43  werner
// Remove debug code.
//
// Revision 1.1  2004/05/13 12:19:16  werner
// Interfacing the DiffMe library.
//
// Revision 1.7  2004/05/11 18:05:10  werner
//
// Revision 1.6  2004/05/06 22:42:16  werner
// Towards a specification of a spacetime via the Acceleration structure.
//
// Revision 1.5  2004/05/03 13:33:33  werner
// integration improved
//
// Revision 1.4  2004/03/30 13:16:35  werner
// little more
//
// Revision 1.3  2004/03/29 11:51:02  werner
// Common interface among simple integrators, DiffMe and Vecal, and preliminiary work on integrating dop853.
//
// Revision 1.2  2004/03/24 13:23:02  werner
// Experimental DiffMe interface
//
// 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 __EvalChristoffel_HPP
#define __EvalChristoffel_HPP "Created 27.02.2001 21:42:27 by werner"

#include <diffme/Tensor.hpp>
#include <diffme/Variable.hpp>
#include <diffme/Power.hpp>
#include <vecal/Christoffel.hpp>

namespace Traum
{
        using namespace DiffMe;
        using VecAl::Christoffel;

template <int i, int j, int k, template <int,int> class g>
struct  EvalChristoffelElement
{
        typedef g<i,j> g_ij;
        typedef typename Coordinate<g_ij>::result coord_t;

        enum { dims = coord_t::dims };

        typedef typename ChristoffelSymbols<i,j, g, k>::result Gk_ij;

        //      C['x'] = 3.0;

template <class dstvalue, class srcvalue>
static  void eval(Context<srcvalue>&C, Christoffel<dims, dstvalue>&Gamma)
        {
                Gamma(k,i,j) = Eval<Gk_ij>::eval(C);
        }
};


template <int I, int J, int K, template <int,int> class g, int dims>
struct  EvalChristoffelIJK
{

template <class dstvalue, class srcvalue>
static  void eval(Context<srcvalue>&C, Christoffel<dims, dstvalue>&Gamma)
        {
                EvalChristoffelElement<I, J, K   ,g>::eval(C, Gamma);
                EvalChristoffelIJK    <I, J, K-1 ,g, dims>::eval(C, Gamma);
        }
};

template <int I, int J, template <int,int> class g, int dims>
struct  EvalChristoffelIJK<I,J, 0, g, dims>
{

template <class dstvalue, class srcvalue>
static  void eval(Context<srcvalue>&C, Christoffel<dims, dstvalue>&Gamma)
        {
                EvalChristoffelElement<I, J, 0   ,g>::eval(C, Gamma);
        }
};


template <int I, int J, template <int,int> class g, int dims>
struct  EvalChristoffelIJ
{

template <class dstvalue, class srcvalue>
static  void eval(Context<srcvalue>&C, Christoffel<dims, dstvalue>&Gamma)
        {
                EvalChristoffelIJK<I, J  , dims-1, g, dims>::eval(C, Gamma);
                EvalChristoffelIJ <I, J-1,         g, dims>::eval(C, Gamma);
        }
};

template <int I, template <int,int> class g, int dims>
struct  EvalChristoffelIJ<I, 0, g, dims>
{

template <class dstvalue, class srcvalue>
static  void eval(Context<srcvalue>&C, Christoffel<dims, dstvalue>&Gamma)
        {
                EvalChristoffelIJK<I,0, dims-1, g, dims>::eval(C, Gamma);               
        }
};




template <int I, template <int,int> class g, int dims>
struct  EvalChristoffelI
{

template <class dstvalue, class srcvalue>
static  void eval(Context<srcvalue>&C, Christoffel<dims, dstvalue>&Gamma)
        {
                EvalChristoffelIJ<I  , dims-1, g, dims>::eval(C, Gamma);
                EvalChristoffelI <I-1,         g, dims>::eval(C, Gamma);
        }
};

template <template <int,int> class g, int dims>
struct  EvalChristoffelI<0, g, dims>
{

template <class dstvalue, class srcvalue>
static  void eval(Context<srcvalue>&C, Christoffel<dims, dstvalue>&Gamma)
        {
                EvalChristoffelIJ<0, dims-1, g, dims>::eval(C, Gamma);          
        }
};



template <template <int,int> class g>
struct  EvalChristoffel
{
        typedef typename Coordinate<g<0,0> >::result coord_t;
        enum { dims = coord_t::dims };

template <class dstvalue, class srcvalue>
static  void eval(Context<srcvalue>&C, Christoffel<dims, dstvalue>&Gamma)
        {
                EvalChristoffelI <dims-1, g, dims>::eval(C, Gamma);
        }
};

} /* namespace Traum */ 

#endif /* __Christoffel_HPP */