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