entity.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_ALU2DGRIDENTITY_HH
#define DUNE_ALU2DGRIDENTITY_HH
 
// System includes
 
// Dune includes
#include <dune/grid/common/entity.hh>
//#include <dune/grid/common/intersectioniteratorwrapper.hh>
 
// Local includes
#include <dune/grid/alugrid/2d/intersection.hh>
#include <dune/grid/alugrid/2d/iterator.hh>
#include <dune/grid/alugrid/2d/entityseed.hh>
 
namespace Dune {
  // Forward declarations
  template<int cd, int dim, class GridImp>
  class ALU2dGridEntity;
  template<int cd, PartitionIteratorType pitype, class GridImp >
  class ALU2dGridLevelIterator;
  template< int codim, class GridImp >
  class ALU2dGridEntityPointer;
  template<int mydim, int coorddim, class GridImp>
  class ALU2dGridGeometry;
  template<class GridImp>
  class ALU2dGridHierarchicIterator;
  template<class GridImp>
  class ALU2dGridLevelIntersectionIterator;
  template<class GridImp>
  class ALU2dGridLeafIntersectionIterator;
  template<class GridImp>
  class ALU2dGridIntersectionIterator;
  template<int codim, PartitionIteratorType, class GridImp>
  class ALU2dGridLeafIterator;
  template< int dim, int dimworld, ALU2DSPACE ElementType eltype >
  class ALU2dGrid;
 
  //**********************************************************************
  //
  // --ALU2dGridEntity
  // --Entity
  //
  //**********************************************************************
  template<int cd, int dim, class GridImp>
  class ALU2dGridEntity :
    public EntityDefaultImplementation <cd,dim,GridImp,ALU2dGridEntity>
  {
    static const int dimworld = GridImp::dimensionworld;
    static const ALU2DSPACE ElementType eltype = GridImp::elementType;
 
    friend class ALU2dGrid< dim, dimworld, eltype >;
    friend class ALU2dGridIntersectionIterator < GridImp >;
    friend class ALU2dGridIntersectionIterator < const GridImp >;
    friend class ALU2dGridLevelIntersectionIterator < GridImp >;
    friend class ALU2dGridLevelIntersectionIterator < const GridImp >;
    friend class ALU2dGridLeafIntersectionIterator < GridImp >;
    friend class ALU2dGridLeafIntersectionIterator < const GridImp >;
    friend class ALU2dGridHierarchicIterator   < const GridImp >;
    friend class ALU2dGridHierarchicIterator   < GridImp >;
    friend class ALU2dGridLevelIterator <0,All_Partition,GridImp>;
    friend class ALU2dGridLevelIterator <1,All_Partition,GridImp>;
    friend class ALU2dGridLevelIterator <2,All_Partition,GridImp>;
    friend class ALU2dGridLeafIterator <0, All_Partition,GridImp>;
    friend class ALU2dGridLeafIterator <1, All_Partition,GridImp>;
    friend class ALU2dGridLeafIterator <2, All_Partition,GridImp>;
    friend class ALU2dGridMakeableEntity<0,dim,GridImp>;
 
    friend class ALU2dGridHierarchicIndexSet<dim,dimworld,eltype>;
 
    typedef typename ALU2dImplTraits< dimworld, eltype >::HElementType HElementType ;
 
    typedef typename GridImp::Traits::template Codim< cd >::GeometryImpl GeometryImpl;
 
  public:
    typedef typename GridImp :: GridObjectFactoryType FactoryType;
 
    typedef typename Dune::ALU2dImplTraits< dimworld, eltype >::template Codim<cd>::InterfaceType ElementType;
    typedef typename Dune::ALU2dImplTraits< dimworld, eltype >::template Codim<2>::InterfaceType VertexType;
 
    typedef typename GridImp::template Codim<cd>::Entity Entity;
    typedef typename GridImp::template Codim<cd>::Geometry Geometry;
 
    typedef typename GridImp::template Codim<cd>::EntitySeed EntitySeed;
 
    typedef typename GridImp::template Codim<0>::EntityPointer EntityPointer;
 
    int level () const;
 
    ALU2dGridEntity(const FactoryType& factory, int level);
 
    ALU2dGridEntity(const ALU2dGridEntity & org);
 
    Geometry geometry () const;
 
    GeometryType type() const ;
 
    void removeElement();
 
    void setElement(const ElementType &element, int face=-1, int level = -1) const;
    void setElement(const EntitySeed& seed ) const;
    void setElement(const HElementType & el, const VertexType & vx);
    void setElement(const ALU2dGridEntity & org) const
    {
      setElement(*(org.item_), org.face_);
    }
 
    bool equals ( const ALU2dGridEntity<cd,dim,GridImp> & org ) const;
 
    PartitionType partitionType() const { return InteriorEntity; }
 
    int boundaryId () const;
 
    EntityPointer ownersFather () const;
 
    FieldVector<alu2d_ctype, dim>& positionInOwnersFather () const;
 
    const GridImp& grid() const { return factory_.grid(); }
 
    const FactoryType& factory() const { return factory_; }
 
    ElementType& getItem() const
    {
      assert( item_ );
      return *item_;
    }
 
    EntitySeed seed() const
    {
      return EntitySeed( getItem(), level(), getFace() );
    }
 
    // return internal face
    int getFace() const { return face_; }
 
    int getIndex () const;
 
  private:
    const FactoryType& factory_;
 
    mutable ElementType * item_;
 
    mutable GeometryImpl geoObj_;
 
    mutable int level_;
    mutable int face_;
  };
 
  //***********************
  //
  //  --ALU2dGridEntity
  //  --0Entity
  //
  //***********************
  template<int dim, class GridImp>
  class ALU2dGridEntity<0,dim,GridImp>
    : public EntityDefaultImplementation<0,dim,GridImp,ALU2dGridEntity>
  {
    static const int dimworld = GridImp::dimensionworld;
    static const ALU2DSPACE ElementType eltype = GridImp::elementType;
 
    friend class ALU2dGrid< dim, dimworld, eltype >;
    friend class ALU2dGridIntersectionIterator < GridImp >;
    friend class ALU2dGridIntersectionIterator < const GridImp >;
    friend class ALU2dGridLevelIntersectionIterator < GridImp >;
    friend class ALU2dGridLevelIntersectionIterator < const GridImp >;
    friend class ALU2dGridLeafIntersectionIterator < GridImp >;
    friend class ALU2dGridLeafIntersectionIterator < const GridImp >;
    friend class ALU2dGridHierarchicIterator   < const GridImp >;
    friend class ALU2dGridHierarchicIterator   < GridImp >;
    friend class ALU2dGridLevelIterator <0,All_Partition,GridImp>;
    friend class ALU2dGridLevelIterator <1,All_Partition,GridImp>;
    friend class ALU2dGridLevelIterator <2,All_Partition,GridImp>;
    friend class ALU2dGridLeafIterator <0, All_Partition,GridImp>;
    friend class ALU2dGridLeafIterator <1, All_Partition,GridImp>;
    friend class ALU2dGridLeafIterator <2, All_Partition,GridImp>;
    friend class ALU2dGridMakeableEntity<0,dim,GridImp>;
 
    friend class ALU2dGridHierarchicIndexSet<dim,dimworld,eltype>;
 
    typedef typename ALU2dImplTraits< dimworld, eltype >::HElementType HElementType ;
 
    typedef typename GridImp::Traits::template Codim< 0 >::GeometryImpl GeometryImpl;
    typedef typename GridImp::Traits::template Codim< 0 >::LocalGeometryImpl LocalGeometryImpl;
 
  public:
    typedef typename GridImp :: GridObjectFactoryType FactoryType;
 
    typedef typename GridImp::template Codim<0>::Geometry Geometry;
    typedef typename GridImp::template Codim<0>::LocalGeometry LocalGeometry;
 
    typedef typename GridImp::template Codim<0>::EntitySeed EntitySeed;
 
    typedef LeafIntersectionIteratorWrapper< GridImp > ALU2dGridLeafIntersectionIteratorType;
    typedef LevelIntersectionIteratorWrapper< GridImp > ALU2dGridLevelIntersectionIteratorType;
    typedef ALU2dGridLeafIntersectionIteratorType ALU2dGridIntersectionIteratorType;
 
    typedef typename GridImp::template Codim<0>::Entity Entity;
    //typedef typename GridImp::template Codim<0>::EntityPointer EntityPointer;
    typedef ALU2dGridEntityPointer<0,GridImp> EntityPointer;
 
    template <int cd>
    struct Codim
    {
      typedef typename GridImp::template Codim<cd>::EntityPointer EntityPointer;
    };
 
    ALU2dGridEntity(const FactoryType& factory, int level);
 
    ALU2dGridEntity(const ALU2dGridEntity & org);
 
    int level () const ;
 
    Geometry geometry () const;
 
    GeometryType type() const ;
 
    template<int cc>
    int count () const
    {
      assert( item_ );
      return (cc==0) ? 1 : item_->numvertices();
    }
 
    unsigned int subEntities (unsigned int codim) const
    {
      assert( item_ );
      return (codim==0) ? 1 : item_->numvertices();
    }
 
    int boundaryId () const {
      // elements are always inside of our Domain
      return 0;
    }
 
    // As ibegin() and iend() are deprecated these methods will deliver a LeafIntersectionIterator
    ALU2dGridIntersectionIteratorType ibegin () const
    DUNE_DEPRECATED_MSG("Use ileafbegin() instead.")
    {
      return ileafbegin();
    }
    ALU2dGridIntersectionIteratorType iend () const
    DUNE_DEPRECATED_MSG("Use ileafend() instead.")
    {
      return ileafend();
    }
 
    ALU2dGridLevelIntersectionIteratorType ilevelbegin () const
    {
      return ALU2dGridLevelIntersectionIteratorType( *this, this->level(),false);
    }
    ALU2dGridLevelIntersectionIteratorType ilevelend () const
    {
      return ALU2dGridLevelIntersectionIteratorType( *this, this->level(),true);
    }
    ALU2dGridLeafIntersectionIteratorType ileafbegin () const
    {
      return ALU2dGridLeafIntersectionIteratorType( *this, this->level(), false);
    }
    ALU2dGridLeafIntersectionIteratorType ileafend () const
    {
      return ALU2dGridLeafIntersectionIteratorType( *this, this->level(),true);
    }
 
    bool isLeaf () const;
 
    EntityPointer father () const;
 
    bool hasFather () const
    {
      return (this->level()>0);
    }
 
    ALU2dGridHierarchicIterator<GridImp> hbegin (int maxLevel) const
    {
      return ALU2dGridHierarchicIterator<GridImp> (factory(), *item_ , maxLevel,false);
    }
 
    ALU2dGridHierarchicIterator<GridImp> hend (int maxLevel) const
    {
      return ALU2dGridHierarchicIterator<GridImp> (factory(), *item_, maxLevel,true);
    }
 
    template <int cc>
    typename Codim<cc>::EntityPointer entity (int i) const;
 
    template< int codim >
    typename Codim< codim >::EntityPointer subEntity ( int i ) const
    {
      int j = i;
      // apply mapping for codim 1
      // dune to alu
      if( codim == 1 )
      {
        if( item_->numvertices() == 3 )
          j = 2 - i;
        else
          switch (i) { case 0 : j=2;break;
                     case 1 : j=0;break;
                     case 2 : j=3;break;
                     case 3 : j=1;break;}
      }
      else if ( codim == 2 )
      {
        if( item_->numvertices() == 4 )
        {
          switch (i) { case 0 : j=0;break;
                     case 1 : j=1;break;
                     case 2 : j=3;break;
                     case 3 : j=2;break;}
        }
      }
      return entity< codim >( j );
    }
 
    PartitionType partitionType() const
    {
#if ALU2DGRID_PARALLEL
      return grid().rankManager().partitionType( item_->getIndex() );
#else
      return InteriorEntity;
#endif
    }
 
    template <int cc>
    int subBoundaryId  ( int i ) const;
 
 
    LocalGeometry geometryInFather () const;
 
    bool mightVanish () const
    {
      return ((item_->is(ALU2DSPACE Refco::crs))==1);
    }
 
    bool isNew () const
    {
      return ((item_->wasRefined())==1);
    }
 
    //***************************************************************
    //  Interface for Adaptation
    //***************************************************************
 
  public:
    bool mark(int refCount) const;
 
    int getMark() const;
 
    void setElement(const HElementType &element, int face=-1, int level = -1) const;
    void setElement(const EntitySeed& seed ) const;
 
    void setElement(const ALU2dGridEntity & org) const {
      setElement(*(org.item_));
    }
 
    void reset ( int l );
 
    void removeElement();
 
    bool equals ( const ALU2dGridEntity<0,dim,GridImp> & org ) const;
 
    // return reference to HElement (needed by IntersectionIterator)
    HElementType & getItem() const
    {
      assert( item_ );
      return *item_;
    }
 
    EntitySeed seed() const
    {
      return EntitySeed( getItem() );
    }
 
    const GridImp& grid() const { return factory_.grid(); }
 
    const FactoryType& factory() const { return factory_; }
 
    // return internal face
    int getFace() const { return -1; }
 
    int getIndex () const;
 
  private:
    int nChild () const;
 
    template<int cc> int getSubIndex (int i) const;
 
    int subIndex (int i, unsigned int codim) const;
 
    const FactoryType& factory_;
 
    mutable HElementType *item_;
 
    mutable GeometryImpl geoObj_;
 
    mutable bool isLeaf_;
 
  }; // end of ALU2dGridEntity codim = 0
 
 
  //**********************************************************************
  //
  // --ALU2dGridEntityPointer
  // --EntityPointer
  // --EnPointer
  //**********************************************************************
  template< int codim, class GridImp >
  class ALU2dGridEntityPointer
  {
    // type of this class
    typedef ALU2dGridEntityPointer< codim, GridImp > ThisType;
 
    static const int dim = GridImp::dimension;
    static const int dimworld = GridImp::dimensionworld;
    static const ALU2DSPACE ElementType eltype = GridImp::elementType;
 
    typedef typename Dune::ALU2dImplTraits< dimworld, eltype >::template Codim<codim>::InterfaceType ElementType;
 
  public:
    typedef typename GridImp :: GridObjectFactoryType FactoryType;
 
    enum { codimension = codim };
 
    typedef typename GridImp::template Codim<codimension>::Entity Entity;
 
    typedef typename GridImp::template Codim<codimension>::EntitySeed EntitySeed;
    typedef ALU2dGridEntity<codimension,dim,GridImp> EntityImp;
    typedef MakeableInterfaceObject<Entity> EntityObj;
 
    typedef ALU2dGridEntityPointer<codimension,GridImp> EntityPointerImp;
 
    ALU2dGridEntityPointer ( const FactoryType& factory,
                             const ElementType &item,
                             int face = -1,
                             int level = -1
                             );
 
    ALU2dGridEntityPointer(const FactoryType& factory, const EntitySeed& seed) ;
 
    ALU2dGridEntityPointer(const EntityImp& entity) ;
 
    ALU2dGridEntityPointer(const FactoryType& factory) ;
 
    ALU2dGridEntityPointer(const ThisType & org) ;
 
    ~ALU2dGridEntityPointer();
 
    // this may have to be changed!
    bool equals (const ThisType & i) const;
 
    Entity & dereference() const ;
 
    int level () const;
 
    ThisType & operator = (const ThisType & org);
 
    const GridImp& grid() const { return factory_.grid(); }
 
  protected:
    EntityImp & entityImp();
    const EntityImp & entityImp() const;
 
    void done ();
 
    void updateEntityPointer( ElementType * item, int face=-1, int level=-1 );
 
    const FactoryType& factory_;
 
    EntitySeed seed_ ;
 
    mutable EntityObj * entity_;
  };
 
} // end namespace Dune
 
#include "entity_imp.cc"
#endif