Cell.hpp

#ifndef __FIBER_FIELD_CELL_HPP
#define __FIBER_FIELD_CELL_HPP

#include "FiberType.hpp"
#include <vector/MultiIndex.hpp>
#include <eagle/FixedArray.hpp>


namespace Fiber
{

template <int DIMS, int Elements, class IndexType>
struct  Cell : public Eagle::FixedArray<IndexType, Elements>
{
        enum { Dims = DIMS };

        typedef Eagle::FixedArray<IndexType, Elements> FixedArray_t;

        using FixedArray_t::operator=;
};


template <int Dims, class IndexType>
struct SimplexCell : Cell<Dims, Dims+1, IndexType>
{
        typedef Cell<Dims, Dims+1, IndexType> Base_t;

        using Base_t::operator=;

static  const char*coordinate_name(int i)
        {
        static const char *n[] = 
                {
                "i","j","k","l","m","n","o"
                }; 
                assert(i<7);
                return n[i];
        }
};


template <int Dims, class IndexType>
struct RegularCell : Cell<Dims, (1<<Dims), IndexType>
{
        typedef Cell<Dims, (1<<Dims), IndexType > Base_t;

        using Base_t::operator=;

static  const char*coordinate_name(int i)
        {
static const char*dims0[] = {"00"},
                 *dims1[] = {"i0", "i1"},
                 *dims2[] = {"i00", "i01", "i10", "i11"},
                 *dims3[] = {"i000", "i001", "i010", "i011" ,
                             "i100", "i101", "i110", "i111"},
                 *dims4[] = {"i0000", "i0001", "i0010", "i0011" ,
                             "i0100", "i0101", "i0110", "i0111" , 
                             "i1000", "i1001", "i1010", "i1011" ,
                             "i1100", "i1101", "i1110", "i1111" } 
                 ; 

 static const char**n[] = { dims0, dims1, dims2, dims3, dims4 };

                return n[Dims][i];
        }
};


typedef SimplexCell<1, uint32_t> EdgeCell32;
typedef SimplexCell<2, uint32_t> TriangleCell32;
typedef SimplexCell<3, uint32_t> TetrahedronCell32;

typedef RegularCell<2, uint32_t> QuadCell32;
typedef RegularCell<3, uint32_t> HexahedronCell32;



typedef SimplexCell<1, uint64_t> EdgeCell64;
typedef SimplexCell<2, uint64_t> TriangleCell64;
typedef SimplexCell<3, uint64_t> TetrahedronCell64;

typedef RegularCell<2, uint64_t> QuadCell64;
typedef RegularCell<3, uint64_t> HexahedronCell64;



typedef EdgeCell32              EdgeCell;
typedef TriangleCell32          TriangleCell;
typedef TetrahedronCell32       TetrahedronCell;

typedef QuadCell32              QuadCell;
typedef HexahedronCell32        HexahedronCell;



} // namespace Fiber



namespace Eagle
{

template <int Dims, int Elements, class IndexType>
struct MetaInfo<Fiber::Cell<Dims, Elements, IndexType> >
{
        enum 
        { 
                MULTIPLICITY = Elements,
                RANK = Dims,
                GRADE = 0
        };

        typedef IndexType element_t;

        // An eventually associated coordinate system
        typedef void Chart_t;

static  const element_t&getComponent(const Fiber::Cell<Dims, Elements, IndexType>&t, int i) 
        {
                return t[i];
        }
};


template <int Dims, class IndexType>
struct MetaInfo<Fiber::SimplexCell<Dims,IndexType> > : MetaInfo<typename Fiber::SimplexCell<Dims,IndexType>::Base_t>
{
        typedef Fiber::SimplexCell<Dims,IndexType> Chart_t;
};

template <int Dims, class IndexType>
struct MetaInfo<Fiber::RegularCell<Dims,IndexType> > : MetaInfo<typename Fiber::RegularCell<Dims,IndexType>::Base_t>
{
        typedef Fiber::RegularCell<Dims,IndexType> Chart_t;
};


} // Eagle

#endif // __FIBER_FIELD_CELL_HPP