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
{
 
struct  IJ_CellNamingConvention
{
static  const char*ComponentName(int i)
        {
        static  const char IJ[2][2] = { "i", "j" };
                return IJ[i];
        }
};
 
 
template <Eagle::dimension_t DIMS, Eagle::dimension_t Elements, class IndexType>
struct  Cell : public Eagle::FixedArray<IndexType, Elements>
{
        enum { Dims = DIMS };
 
        typedef Eagle::FixedArray<IndexType, Elements> FixedArray_t;
        typedef Eagle::FixedArray<IndexType, Elements> Base_t;
 
//      using FixedArray_t::operator=;
 
        Cell()
        {}
 
        Cell(const Cell&C)
        : Eagle::FixedArray<IndexType, Elements>(C)
        {}
 
        Cell(const std::initializer_list<IndexType>&Init)
        : Eagle::FixedArray<IndexType, Elements>(Init)
        {}
};
 
 
template <Eagle::dimension_t Dims, class IndexType, class NamingConvention = IJ_CellNamingConvention>
struct SimplexCell : Cell<Dims, Dims+1, IndexType>
{
        typedef Cell<Dims, Dims+1, IndexType> Base_t;
 
//      using Base_t::operator=;
 
        SimplexCell()
        {}
 
        SimplexCell(const SimplexCell&SC)
        : Base_t(SC)
        {}
 
        SimplexCell(const std::initializer_list<IndexType>&Init)
        : Base_t(Init)
        {}
 
 
static  std::string coordinate_name(int i)
        {
                return  ( (i<=Dims-1)? NamingConvention::ComponentName(0) : NamingConvention::ComponentName(1) )
                        +
                        SimplexCell<Dims-1, IndexType>::coordinate_name(i);
 
        }
};
 
template <class IndexType>
struct SimplexCell<0, IndexType> : Cell<0, 1, IndexType>
{
        typedef Cell<0,1, IndexType> Base_t;
 
        SimplexCell()
        {}
 
        SimplexCell(const SimplexCell&SC)
        : Base_t(SC)
        {}
 
        SimplexCell(const std::initializer_list<IndexType>&Init)
        : Base_t(Init)
        {}
 
 
static  std::string coordinate_name(int i)
        {
                return "";
        }
};
 
 
template <int Dims, class IndexType, class NamingConvention = IJ_CellNamingConvention>
struct RegularCell : Cell<Dims, (1<<Dims), IndexType>
{
        typedef Cell<Dims, (1<<Dims), IndexType > Base_t;
 
//      using Base_t::operator=;
 
        RegularCell()
        {}
 
        RegularCell(const RegularCell&RC)
        : Base_t(RC)
        {}
 
        RegularCell(const std::initializer_list<IndexType>&Init)
        : Base_t(Init)
        {}
 
 
static  std::string coordinate_name(int i)
        {
                return RegularCell<Dims-1, IndexType>::coordinate_name(i>>1) +
                     NamingConvention::ComponentName( i & 1 );
        }
};
 
template <class IndexType, class NamingConvention>
struct RegularCell<0, IndexType, NamingConvention>
{
static  std::string coordinate_name(int i)
        {
                return "";
        }
};
 
 
 
template <class IndexType>
union   uEdge
{
        SimplexCell<1,IndexType>        Cell;
 
        struct NamedEdge
        {
                IndexType       i,j;
        }
                Named;
};
 
 
template <class IndexType>
union   uTriangle
{
        SimplexCell<2,IndexType>        Cell;
 
        struct NamedTriangle
        {
                IndexType       ii,ij,jj;
        }
                Named;
 
        struct  ijkTriangle
        {
        IndexType       i,j,k;
 
        }
                ijk;
};
 
template <class IndexType>
union   uTetrahedron
{
        SimplexCell<3,IndexType>        Cell;
 
        struct NamedTetrahedron
        {
                IndexType iii,iij,ijj,jjj;
        }
                Named;
};
 
 
template <class IndexType>
union   uQuad
{
        RegularCell<2, IndexType>       Cell;
 
        struct NamedQuad
        {
                IndexType ii,ij,ji,jj;
        }
                Named;
 
};
 
 
template <class IndexType>
union   uHexaHedron
{
        RegularCell<3, IndexType>       Cell;
 
        struct NamedHexaHedron
        {
                IndexType iii,iij,iji,ijj,jii,jij,jji,jjj;
        }
                Named;
};
 
 
template<class IndexType, class NamingConvention = IJ_CellNamingConvention>
struct DihedralCell : Cell< 1, 4, IndexType>
{
        typedef Cell<1, 4, IndexType> Base_t;
 
        DihedralCell(){}
 
        DihedralCell(const DihedralCell&SC)
        : Base_t(SC)
        {}
 
        DihedralCell(const std::initializer_list<IndexType>&Init)
        : Base_t(Init)
        {}
 
 
static  std::string coordinate_name(int i)
        {
                if( i == 0 )      return "i";
                else if( i == 1 ) return "j";
                else if( i == 2 ) return "k";
                else if( i == 3 ) return "l";
        }
 
        // Flip dihedral values if first index is not lower than the last
        void unify()
        {
                if( (*this)[0] > (*this)[3] )
                {
                IndexType tmp = (*this)[0];
                        (*this)[0] = (*this)[3];
                        (*this)[3] = tmp;
 
                        tmp = (*this)[1];
                        (*this)[1] = (*this)[2];
                        (*this)[2] = tmp;
                }
        }
 
        bool operator == (DihedralCell const& rhs) const
        {
                for( unsigned i = 0; i < 4; ++i)
                        if( (*this)[i] != rhs[i] )
                                return false;
                return true;
        }
};
 
 
template <class IndexType>
union   uDihedral
{
        DihedralCell<IndexType> Cell;
 
        struct Name
        {
                IndexType iii, iij, ijj, jjj;
        } Named;
 
        struct  ijklName
        {
                IndexType       i,j,k,l;
        } ijkl;
};
 
//typedef DihedralCell<uint32_t> Dihedral32;
//typedef DihedralCell<uint64_t> Dihedral64;
 
 
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;
 
//typedef Dihedral32            Dihedral;
 
 
typedef SimplexCell<1, uint32_t> EdgeCell32_t;
 
typedef SimplexCell<2, uint32_t> TriangleCell32_t;
 
typedef SimplexCell<3, uint32_t> TetrahedronCell32_t;
 
typedef RegularCell<2, uint32_t> QuadCell32_t;
typedef RegularCell<3, uint32_t> HexahedronCell32_t;
 
 
 
typedef SimplexCell<1, uint64_t> EdgeCell64_t;
typedef SimplexCell<2, uint64_t> TriangleCell64_t;
typedef SimplexCell<3, uint64_t> TetrahedronCell64_t;
 
typedef RegularCell<2, uint64_t> QuadCell64_t;
typedef RegularCell<3, uint64_t> HexahedronCell64_t;
 
 
typedef DihedralCell<uint32_t> Dihedral32_t;
typedef DihedralCell<uint64_t> Dihedral64_t;
 
typedef EdgeCell32_t            EdgeCell_t;
typedef TriangleCell32_t        TriangleCell_t;
typedef TetrahedronCell32_t     TetrahedronCell_t;
 
typedef QuadCell32_t            QuadCell_t;
typedef HexahedronCell32_t      HexahedronCell_t;
 
typedef Dihedral32_t    Dihedral_t;
 
} // namespace Fiber
 
 
 
namespace Eagle
{
 
template <Eagle::dimension_t Dims, int Elements, class IndexType>
struct MetaInfo<Fiber::Cell<Dims, Elements, IndexType> >
{
        enum
        {
                MULTIPLICITY = Elements,
/*12.12.14
  Was: RANK = Dims
  But rank should be 0 to indicate that these
  cell types are point-types, not vectorial types.
 */
                RANK = 0,
                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 <Eagle::dimension_t Dims, class IndexType, class NamingConvention>
struct MetaInfo<Fiber::SimplexCell<Dims,IndexType,NamingConvention> > : MetaInfo<typename Fiber::SimplexCell<Dims,IndexType,NamingConvention>::Base_t>
{
        typedef Fiber::SimplexCell<Dims,IndexType> Chart_t;
};
 
template <int Dims, class IndexType, class NamingConvention>
struct MetaInfo<Fiber::RegularCell<Dims,IndexType,NamingConvention> > : MetaInfo<typename Fiber::RegularCell<Dims,IndexType,NamingConvention>::Base_t>
{
        typedef Fiber::RegularCell<Dims,IndexType,NamingConvention> Chart_t;
};
 
} // Eagle
 
 
 
namespace META
{
 
template <Eagle::dimension_t DIMS, int Elements, class IndexType>
struct  BaseClass<Fiber::Cell<DIMS, Elements, IndexType> >
{
//      typedef Fiber::FixedArray<IndexType, Elements> result;
        typedef typename Fiber::Cell<DIMS, Elements, IndexType>::Base_t result;
};
 
template <Eagle::dimension_t Dims, class IndexType, class NamingConvention>
struct BaseClass<Fiber::SimplexCell<Dims, IndexType, NamingConvention> >
{
//      typedef Fiber::Cell<Dims, Dims+1, IndexType> result;
 
        typedef typename Fiber::SimplexCell<Dims, IndexType, NamingConvention>::Base_t result;
};
 
template <Eagle::dimension_t Dims, class IndexType, class NamingConvention>
struct BaseClass<Fiber::RegularCell<Dims, IndexType, NamingConvention> >
{
//      typedef Fiber::Cell<Dims, (1<<Dims), IndexType> result;
 
        typedef typename Fiber::RegularCell<Dims, IndexType, NamingConvention>::Base_t result;
};
 
 
} // namespace META
 
 
 
namespace std
{
 
template <Eagle::dimension_t Dims, class IndexType, class NamingConvention>
inline string to_string(const Fiber::SimplexCell<Dims, IndexType, NamingConvention>&C,
                        const char*OpenBrace = "<", const char*CloseBrace = ">",
                        const char*Separator = ",")
{
        return std::to_string( C.getFixedArray(), OpenBrace, CloseBrace, Separator);
}
 
template <Eagle::dimension_t Dims, class IndexType, class NamingConvention>
inline string to_string(const Fiber::RegularCell<Dims, IndexType, NamingConvention>&C, const char*OpenBrace = "",
                        const char*CloseBrace = "", const char*Separator = "x")
{
        return to_string( C.getFixedArray(), OpenBrace, CloseBrace, Separator);
}
 
} // namespace
 
namespace std
{
        string to_string( const Fiber::Dihedral_t& dihedral );
 
        template <> struct hash<Fiber::Dihedral32_t>
        {
                size_t operator()(const Fiber::Dihedral32_t & x) const
                {
#if     1
                constexpr uint32_t dim_max = 512;
#else
                // should be like this, but sqrt() is not a compile-time function, so can't be used in a constexpr.
                constexpr uint32_t dim_max = static_cast<uint32_t>( sqrt( sqrt( std::numeric_limits<uint32_t>::max() ) ) );
#endif
                const Fiber::MultiIndex<4> max_size = { dim_max, dim_max, dim_max, dim_max };
                Fiber::MultiIndex<4> tmp { x[0], x[1], x[2], x[3] };
                        return tmp.linear( max_size );
                }
        };
} /* namespace std */
 
#endif // __FIBER_FIELD_CELL_HPP