entity.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_ALBERTA_ENTITY_HH
#define DUNE_ALBERTA_ENTITY_HH
 
#include <dune/grid/common/entity.hh>
 
#include <dune/grid/albertagrid/elementinfo.hh>
#include <dune/grid/albertagrid/entityseed.hh>
#include <dune/grid/albertagrid/geometry.hh>
 
#if HAVE_ALBERTA
 
namespace Dune
{
 
  // Forward Declarations
  // --------------------
 
  template< int codim, class Grid >
  class AlbertaGridEntityPointer;
 
  template< int codim, class Grid, bool leafIterator >
  class AlbertaGridTreeIterator;
 
  template< class Grid >
  class AlbertaGridHierarchicIterator;
 
  template< class Grid >
  class AlbertaGridLeafIntersection;
 
  template< class Grid >
  class AlbertaGridLeafIntersectionIterator;
 
 
 
  // AlbertaGridEntity
  // -----------------
 
  template< int codim, int dim, class Grid >
  class AlbertaGridEntity
    : public EntityDefaultImplementation< codim, dim, Grid, AlbertaGridEntity >
  {
    typedef AlbertaGridEntity< codim, dim, Grid > This;
 
    enum { dimworld = Grid::dimensionworld };
    friend class AlbertaGrid< dim, dimworld >;
    friend class AlbertaGridEntity< 0, dim, Grid >;
 
    template< int, class, bool > friend class AlbertaGridTreeIterator;
    friend class AlbertaGridEntityPointer< codim, Grid >;
 
  public:
    static const int dimension = dim;
    static const int codimension = codim;
    static const int mydimension = dimension - codimension;
 
    template< int cd >
    struct Codim
    {
      typedef typename Grid::template Codim< cd >::EntityPointer EntityPointer;
    };
 
    typedef typename Grid::template Codim< codim >::Entity Entity;
    typedef typename Grid::template Codim< codim >::EntitySeed EntitySeed;
    typedef typename Grid::template Codim< codim >::Geometry Geometry;
 
    typedef Alberta::ElementInfo< dimension > ElementInfo;
 
  private:
    typedef typename Grid::Traits::template Codim< codim >::GeometryImpl GeometryImpl;
 
  public:
    explicit AlbertaGridEntity ( const Grid &grid );
 
    AlbertaGridEntity ();
 
    AlbertaGridEntity ( const Grid &grid, const ElementInfo &elementInfo, int subEntity );
 
    int level () const;
 
    PartitionType partitionType() const;
 
    Geometry geometry () const;
 
    GeometryType type () const;
 
    EntitySeed seed () const { return EntitySeed( AlbertaGridEntitySeed< codim, Grid >( elementInfo(), subEntity() ) ); }
 
    //***********************************************
    // end of interface methods
    //***********************************************
 
    ALBERTA EL_INFO *getElInfo () const;
 
    const ElementInfo &elementInfo () const { return elementInfo_; }
 
    bool equals ( const This &other ) const;
 
    void clearElement ();
    void setElement ( const ElementInfo &elementInfo, int subEntity );
 
    // same as setElInfo just with a entity given
    void setEntity ( const This &other );
 
    const Grid &grid () const
    {
      return *grid_;
    }
 
    int subEntity () const
    {
      return subEntity_;
    }
 
    int twist () const
    {
      return elementInfo().template twist< codimension >( subEntity() );
    }
 
  private:
    // grid this entity belong to
    const Grid *grid_;
 
    // ALBERTA element info
    ElementInfo elementInfo_;
 
    // number of the subentity within the element (in ALBERTA numbering)
    int subEntity_;
  };
 
 
 
  // AlbertaGridEntity for codimension 0
  // -----------------------------------
 
  template< int dim, class Grid >
  class AlbertaGridEntity< 0, dim, Grid >
    : public EntityDefaultImplementation< 0, dim, Grid, AlbertaGridEntity >
  {
    typedef AlbertaGridEntity< 0, dim, Grid > This;
 
    static const int dimworld = Grid::dimensionworld;
 
    friend class AlbertaGrid< dim, dimworld >;
    friend class AlbertaGridLeafIntersection< Grid >;
    friend class AlbertaGridHierarchicIterator< Grid >;
    template< int, class, bool > friend class AlbertaGridTreeIterator;
    friend class AlbertaGridEntityPointer< 0, Grid >;
 
  public:
    static const int dimension = dim;
    static const int codimension = 0;
    static const int mydimension = dimension - codimension;
 
    template< int codim >
    struct Codim
    {
      typedef typename Grid::template Codim< codim >::EntityPointer
      EntityPointer;
      typedef typename Grid::template Codim< codim >::Entity
      Entity;
    };
 
    typedef typename Grid::template Codim< 0 >::Entity Entity;
    typedef typename Grid::template Codim< 0 >::EntitySeed EntitySeed;
    typedef typename Grid::template Codim< 0 >::Geometry Geometry;
    typedef typename Grid::template Codim< 0 >::LocalGeometry LocalGeometry;
    typedef typename Grid::Traits::template Codim< 0 >::GeometryImpl GeometryImpl;
 
    typedef typename Grid::HierarchicIterator HierarchicIterator;
    typedef typename Grid::template Codim< 0 >::EntityPointer EntityPointer;
 
    typedef Dune::AlbertaGridLeafIntersectionIterator< Grid > AlbertaGridLeafIntersectionIterator;
    typedef AlbertaGridLeafIntersectionIterator AlbertaGridLevelIntersectionIterator;
 
    typedef Alberta::ElementInfo< dimension > ElementInfo;
 
    explicit AlbertaGridEntity ( const Grid &grid );
 
    AlbertaGridEntity ();
 
    AlbertaGridEntity ( const Grid &grid, const ElementInfo &elementInfo, int subEntity );
 
    int level () const;
 
    int boundaryId () const;
 
    Geometry geometry () const;
 
    GeometryType type () const;
 
    EntitySeed seed () const { return EntitySeed( AlbertaGridEntitySeed< 0, Grid >(elementInfo() )); }
 
    template< int codim >
    int count () const
    {
      return Alberta::NumSubEntities< dimension, codim >::value;
    }
 
    unsigned int subEntities (unsigned int codim) const
    {
      int n = dimension+1;
      int k = dimension-codim+1;
 
      // binomial: n over k
      int binomial=1;
      for (int i=n-k+1; i<=n; i++)
        binomial *= i;
      for (long i=2; i<=k; i++)
        binomial /= i;
 
      return binomial;
    }
 
    template< int codim >
    typename Grid::template Codim< codim >::Entity subEntity ( int i ) const;
 
    AlbertaGridLeafIntersectionIterator ileafbegin () const;
 
    AlbertaGridLeafIntersectionIterator ileafend () const;
 
    AlbertaGridLevelIntersectionIterator ilevelbegin () const
    {
      if( grid().maxLevel() == 0 )
        return ileafbegin();
      else
      {
        DUNE_THROW( NotImplemented, "method ilevelbegin not implemented for AlbertaGrid." );
        return ileafend();
      }
    }
 
    AlbertaGridLevelIntersectionIterator ilevelend () const
    {
      return ileafend();
    }
 
    bool isLeaf () const;
 
    Entity father () const;
    bool hasFather () const
    {
      return (this->level()>0);
    }
 
    LocalGeometry geometryInFather () const;
 
    HierarchicIterator hbegin (int maxlevel) const;
 
    HierarchicIterator hend (int maxlevel) const;
 
    bool isNew () const;
 
    bool mightVanish () const;
 
    bool hasBoundaryIntersections () const ;
 
    PartitionType partitionType() const;
 
    bool equals ( const This &i ) const;
 
    // needed for LevelIterator to compare
    ALBERTA EL_INFO *getElInfo () const;
 
    const ElementInfo &elementInfo () const
    {
      return elementInfo_;
    }
 
    void clearElement ();
    void setElement ( const ElementInfo &elementInfo, int subEntity );
 
    // same as setElInfo just with a entity given
    void setEntity ( const This &other );
 
    const Grid &grid () const
    {
      return *grid_;
    }
 
    int subEntity () const
    {
      return 0;
    }
 
    int twist () const
    {
      return elementInfo().template twist< codimension >( subEntity() );
    }
 
    template< int codim >
    int twist ( int i ) const
    {
      return elementInfo().template twist< codim >( grid().generic2alberta( codim, i ) );
    }
 
  private:
    int nChild () const;
 
    const Grid *grid_;
 
    // Alberta element info
    ElementInfo elementInfo_;
  };
 
} // namespace Dune
 
#endif // #if HAVE_ALBERTA
 
#endif // #ifndef DUNE_ALBERTA_ENTITY_HH