entity.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_ALU3DGRIDENTITY_HH
#define DUNE_ALU3DGRIDENTITY_HH
 
// System includes
 
// Dune includes
#include <dune/grid/common/entity.hh>
#include <dune/grid/alugrid/common/intersectioniteratorwrapper.hh>
 
// Local includes
#include "alu3dinclude.hh"
#include "iterator.hh"
#include "entityseed.hh"
 
namespace Dune
{
 
  // Forward declarations
  template<int cd, int dim, class GridImp>
  class ALU3dGridEntity;
  template<int cd, PartitionIteratorType pitype, class GridImp >
  class ALU3dGridLevelIterator;
  template<int cd, class GridImp >
  class ALU3dGridEntityPointer;
  template<int mydim, int coorddim, class GridImp>
  class ALU3dGridGeometry;
  template<class GridImp>
  class ALU3dGridHierarchicIterator;
  template<class GridImp>
  class ALU3dGridIntersectionIterator;
  template<int codim, PartitionIteratorType, class GridImp>
  class ALU3dGridLeafIterator;
  template< ALU3dGridElementType, class >
  class ALU3dGrid;
 
  template<int cd, int dim, class GridImp>
  class ALU3dGridEntity :
    public EntityDefaultImplementation <cd,dim,GridImp,ALU3dGridEntity>
  {
    // default just returns level
    template <class GridType, int cdim>
    struct GetLevel
    {
      template <class ItemType>
      static int getLevel(const GridType & grid, const ItemType & item )
      {
        return item.level();
      }
    };
 
    // for leaf vertices the level is somewhat difficult to obtain, because
    // this the maximum of levels of elements that have this vertex as sub
    // entity
    template <class GridType>
    struct GetLevel<GridType,3>
    {
      template <class ItemType>
      static int getLevel(const GridType & grid, const ItemType & item)
      {
        return (item.isLeafEntity()) ? grid.getLevelOfLeafVertex(item) : item.level();
      }
    };
 
    enum { dimworld = GridImp::dimensionworld };
 
    typedef typename GridImp::MPICommunicatorType Comm;
 
    friend class ALU3dGrid< GridImp::elementType, Comm >;
    friend class ALU3dGridEntity < 0, dim, GridImp >;
    friend class ALU3dGridLevelIterator < cd, All_Partition, GridImp >;
 
    friend class ALU3dGridHierarchicIndexSet< GridImp::elementType, Comm >;
 
    template< class > friend class ALU3dGridFactory;
 
    typedef typename GridImp::Traits::template Codim< cd >::GeometryImpl GeometryImpl;
 
  public:
    typedef typename GridImp::GridObjectFactoryType FactoryType;
 
    typedef ALU3dImplTraits< GridImp::elementType, Comm > ImplTraits;
    typedef typename ImplTraits::template Codim<cd>::InterfaceType HItemType;
    typedef typename ImplTraits::template Codim<cd>::ImplementationType ItemType;
    typedef typename ImplTraits::VertexType VertexType;
    typedef typename ImplTraits::HBndSegType HBndSegType;
 
    typedef typename GridImp::template Codim<cd>::Entity Entity;
    typedef typename GridImp::template Codim<cd>::Geometry Geometry;
 
    typedef typename GridImp::template Codim<0>::EntityPointer EntityPointer;
 
    typedef typename GridImp::template Codim<cd>::EntitySeed EntitySeed;
 
    int level () const;
 
    PartitionType partitionType() const;
 
    ALU3dGridEntity(const FactoryType &factory, int level);
 
    ALU3dGridEntity(const ALU3dGridEntity & org);
 
    Geometry geometry () const;
 
    GeometryType type () const;
 
    // set element as normal entity
    void setElement(const HItemType & item);
    void setElement(const HItemType & item, const int level, int twist=0, int face = -1);
 
    /* set entity from seed */
    void setElement(const EntitySeed& seed);
 
    void setGhost(const HBndSegType  &ghost);
 
    void removeElement ();
 
    void reset ( int l );
 
    bool equals ( const ALU3dGridEntity<cd,dim,GridImp> & org ) const;
 
    void setEntity ( const ALU3dGridEntity<cd,dim,GridImp> & org );
 
    // return reference to internal item
    const ItemType & getItem () const { return *item_; }
 
    const GridImp& grid() const { return factory_.grid(); }
 
    const FactoryType& factory() const { return factory_; }
 
    EntitySeed seed() const
    {
      return EntitySeed( getItem(), level(), twist_, face_ );
    }
 
  private:
    int getIndex () const;
 
    PartitionType convertBndId(const HItemType & item) const ;
 
    mutable GeometryImpl geo_;
 
    // the factory that created this entity
    const FactoryType& factory_;
 
    // corresponding ALU3dGrid item, here face, edge, or vertex
    const ItemType * item_;
 
    int level_; 
    int gIndex_; 
    int twist_; 
    int face_; 
 
    mutable PartitionType partitionType_; 
  };
 
  //***********************
  //
  //  --ALU3dGridEntity
  //  --0Entity
  //
  //***********************
  template<int dim, class GridImp>
  class ALU3dGridEntity<0,dim,GridImp>
    : public EntityDefaultImplementation<0,dim,GridImp,ALU3dGridEntity>
  {
    static const int dimworld = remove_const< GridImp >::type::dimensionworld;
    static const ALU3dGridElementType elementType = remove_const< GridImp >::type::elementType;
 
    typedef typename GridImp::MPICommunicatorType Comm;
 
    typedef ALU3dImplTraits< elementType, Comm > ImplTraits;
    typedef typename ImplTraits::template Codim<0>::InterfaceType HElementType;
 
    typedef typename ImplTraits::GEOElementType GEOElementType;
    typedef typename ImplTraits::BNDFaceType BNDFaceType;
    typedef typename ImplTraits::IMPLElementType IMPLElementType;
    typedef typename ImplTraits::HBndSegType HBndSegType;
 
    enum { refine_element_t  = ImplTraits::refine_element_t  };
    enum { bisect_element_t  = ImplTraits::bisect_element_t  };
    enum { coarse_element_t  = ImplTraits::coarse_element_t  };
    enum { nosplit_element_t = ImplTraits::nosplit_element_t };
 
    typedef typename ImplTraits::MarkRuleType MarkRuleType;
 
    friend class ALU3dGrid< elementType, Comm >;
    friend class ALU3dGridIntersectionIterator < GridImp >;
    friend class ALU3dGridIntersectionIterator < const GridImp >;
    friend class ALU3dGridHierarchicIterator   < const GridImp >;
    friend class ALU3dGridHierarchicIterator   < GridImp >;
    friend class ALU3dGridLevelIterator <0,All_Partition,GridImp>;
    friend class ALU3dGridLevelIterator <1,All_Partition,GridImp>;
    friend class ALU3dGridLevelIterator <2,All_Partition,GridImp>;
    friend class ALU3dGridLevelIterator <3,All_Partition,GridImp>;
    friend class ALU3dGridLeafIterator <0, All_Partition,GridImp>;
    friend class ALU3dGridLeafIterator <1, All_Partition,GridImp>;
    friend class ALU3dGridLeafIterator <2, All_Partition,GridImp>;
    friend class ALU3dGridLeafIterator <3, All_Partition,GridImp>;
 
    friend class ALU3dGridHierarchicIndexSet< elementType, Comm >;
 
    template< class > friend class ALU3dGridFactory;
 
    // type of reference element
    typedef typename GridImp :: ReferenceElementType ReferenceElementType;
 
    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 ALU3dGridIntersectionIterator<GridImp> IntersectionIteratorImp;
 
    typedef LeafIntersectionIteratorWrapper <GridImp>  ALU3dGridIntersectionIteratorType;
    typedef LeafIntersectionIteratorWrapper <GridImp>  ALU3dGridLeafIntersectionIteratorType;
    typedef LevelIntersectionIteratorWrapper<GridImp>  ALU3dGridLevelIntersectionIteratorType;
 
    typedef typename GridImp::template Codim<0>::Entity Entity;
    typedef typename GridImp::template Codim<0>::EntityPointer EntityPointer;
 
    template <int cd>
    struct Codim
    {
      typedef typename GridImp::template Codim<cd>::EntityPointer EntityPointer;
    };
 
    typedef typename GridImp::template Codim<0>::EntitySeed EntitySeed;
 
    ALU3dGridEntity(const FactoryType& factory, int level);
 
    ALU3dGridEntity(const ALU3dGridEntity & org);
 
    int level () const ;
 
    Geometry geometry () const;
 
    GeometryType type () const;
 
    PartitionType partitionType() const;
 
    template<int cc> int count () const ;
 
    template< int codim >
    typename Codim< codim >::EntityPointer subEntity ( int i ) const;
 
    ALU3dGridLeafIntersectionIteratorType ileafbegin () const;
 
    ALU3dGridLeafIntersectionIteratorType ileafend () const;
 
    ALU3dGridLevelIntersectionIteratorType ilevelbegin () const;
 
    ALU3dGridLevelIntersectionIteratorType ilevelend () const;
 
    bool isLeaf () const;
 
    EntityPointer father () const;
    bool hasFather () const
    {
      return (this->level()>0);
    }
 
    LocalGeometry geometryInFather () const;
 
    ALU3dGridHierarchicIterator<GridImp> hbegin (int maxlevel) const;
 
    ALU3dGridHierarchicIterator<GridImp> hend (int maxlevel) const;
 
    //***************************************************************
    //  Interface for Adaptation
    //***************************************************************
 
    bool isNew () const;
 
    bool mightVanish () const;
 
    bool hasBoundaryIntersections () const;
 
    // private method
    bool mark( int refCount ) const;
 
    int getMark() const;
 
    void setElement(HElementType &element);
 
    /* set entity from seed */
    void setElement(const EntitySeed& seed);
 
    void setGhost(HBndSegType & ghost);
 
    void reset ( int l );
 
    void removeElement();
 
    bool equals ( const ALU3dGridEntity<0,dim,GridImp> & org ) const;
 
    void setEntity ( const ALU3dGridEntity<0,dim,GridImp> & org );
 
    template<int cc> int getSubIndex (int i) const;
 
    int subIndex(int i, unsigned int codim) const;
 
    // return reference to internal item
    const IMPLElementType& getItem () const { return *item_; }
 
    // return reference to internal item
    const BNDFaceType& getGhost () const
    {
      assert( isGhost() );
      return *ghost_;
    }
 
    const GridImp& grid() const { return factory_.grid(); }
 
    const FactoryType& factory() const { return factory_; }
 
    bool isGhost () const { return ImplTraits::isGhost( ghost_ ); }
 
    EntitySeed seed() const
    {
      if( isGhost() )
        return EntitySeed( getGhost () );
      else
        return EntitySeed( getItem() );
    }
 
  private:
    int getIndex () const;
 
    mutable GeometryImpl geo_;
 
    // corresponding factory
    const FactoryType& factory_;
 
    // the current element of grid
    mutable IMPLElementType* item_;
 
    mutable BNDFaceType*  ghost_;
 
    int level_;  
    bool isLeaf_; 
 
  }; // end of ALU3dGridEntity codim = 0
     //**********************************************************************
     //
     // --ALU3dGridEntityPointer
     // --EntityPointer
     // --EnPointer
  template< int codim, class GridImp >
  class ALU3dGridEntityPointerBase
  {
    typedef ALU3dGridEntityPointerBase< codim, GridImp > ThisType;
    enum { dim       = GridImp::dimension };
    enum { dimworld  = GridImp::dimensionworld };
 
    typedef typename GridImp::MPICommunicatorType Comm;
 
    friend class ALU3dGridEntity<codim,dim,GridImp>;
    friend class ALU3dGridEntity< 0,dim,GridImp>;
    friend class ALU3dGrid < GridImp::elementType, Comm >;
 
    typedef ALU3dImplTraits<GridImp::elementType, Comm > ImplTraits;
    typedef typename ImplTraits::template Codim<codim>::InterfaceType HElementType;
 
    typedef typename ImplTraits::HBndSegType HBndSegType;
    typedef typename ImplTraits::BNDFaceType BNDFaceType;
  public:
    typedef typename GridImp::GridObjectFactoryType FactoryType;
 
    enum { codimension = codim };
 
    typedef typename GridImp::template Codim<codimension>::Entity Entity;
    typedef MakeableInterfaceObject<Entity> EntityObject;
    typedef typename EntityObject :: ImplementationType EntityImp;
 
    typedef ThisType ALU3dGridEntityPointerType;
 
    typedef ALU3dGridEntityPointer<codimension,GridImp> EntityPointerImp;
 
    typedef ALU3dGridEntitySeed<codimension, GridImp> ALU3dGridEntitySeedType;
 
    ALU3dGridEntityPointerBase(const FactoryType& factory,
                               const HElementType & item);
 
    ALU3dGridEntityPointerBase(const FactoryType& factory,
                               const HElementType & item,
                               const int level,
                               const int twist,
                               const int duneFace
                               );
 
    ALU3dGridEntityPointerBase(const FactoryType& factory,
                               const HBndSegType & ghostFace );
 
    ALU3dGridEntityPointerBase(const FactoryType& factory,
                               const ALU3dGridEntitySeedType& seed );
 
    ALU3dGridEntityPointerBase(const ALU3dGridEntityPointerType & org);
 
    ~ALU3dGridEntityPointerBase();
 
    bool equals (const ALU3dGridEntityPointerType& i) const;
 
    ThisType & operator = (const ThisType & org);
 
    Entity & dereference () const ;
 
    int level () const ;
 
  protected:
    // clones object
    void clone (const ALU3dGridEntityPointerType & org);
 
    // get entity and assign from org.entity
    void getEntity (const ALU3dGridEntityPointerType & org);
 
    void done ();
 
    void freeEntity ();
 
    const GridImp& grid () const { return factory_.grid(); }
 
    ALU3dGridEntityPointerBase(const FactoryType& factory, int level );
 
    // update underlying item pointer and set ghost entity
    void updateGhostPointer( HBndSegType & ghostFace );
    // update underlying item pointer and set entity
    void updateEntityPointer( HElementType * item , int level = -1 );
 
    // reference to factory
    const FactoryType& factory_;
 
    // key to gererate entity
    ALU3dGridEntitySeedType seed_;
 
    // entity that this EntityPointer points to
    mutable EntityObject * entity_;
 
    // return reference to internal entity implementation
    EntityImp & entityImp () const {
      assert( entity_ );
      return GridImp :: getRealImplementation(*entity_);
    }
  };
 
  template<class GridImp>
  class ALU3dGridEntityPointer<0,GridImp> :
    public ALU3dGridEntityPointerBase<0,GridImp>
  {
  protected:
    typedef ALU3dGridEntityPointerBase<0,GridImp> BaseType;
 
    enum { cd = 0 };
    typedef ALU3dGridEntityPointer <cd,GridImp> ThisType;
    enum { dim       = GridImp::dimension };
    enum { dimworld  = GridImp::dimensionworld };
 
    typedef typename GridImp::MPICommunicatorType Comm;
 
    friend class ALU3dGridEntity<cd,dim,GridImp>;
    friend class ALU3dGridEntity< 0,dim,GridImp>;
    friend class ALU3dGrid < GridImp::elementType, Comm >;
 
    typedef ALU3dImplTraits<GridImp::elementType, Comm > ImplTraits;
    typedef typename ImplTraits::template Codim<cd>::InterfaceType HElementType;
 
    typedef typename ImplTraits::HBndSegType HBndSegType;
    typedef typename ImplTraits::BNDFaceType BNDFaceType;
 
    typedef ALU3dGridEntity< 0,dim,GridImp> ALU3dGridEntityType ;
 
    using BaseType :: seed_;
    using BaseType :: entity_;
    using BaseType :: entityImp;
    using BaseType :: factory_;
  public:
    typedef typename GridImp::GridObjectFactoryType FactoryType;
 
    typedef ALU3dGridEntitySeed<cd, GridImp> ALU3dGridEntitySeedType;
 
    typedef typename GridImp::template Codim<cd>::Entity Entity;
 
    typedef ThisType ALU3dGridEntityPointerType;
 
    ALU3dGridEntityPointer(const FactoryType& factory,
                           const HElementType & item)
      : ALU3dGridEntityPointerBase<cd,GridImp> (factory,item) {}
 
    ALU3dGridEntityPointer(const FactoryType& factory,
                           const HBndSegType & ghostFace )
      : ALU3dGridEntityPointerBase<cd,GridImp> (factory,ghostFace) {}
 
    ALU3dGridEntityPointer(const FactoryType& factory, const ALU3dGridEntitySeedType& seed)
      : ALU3dGridEntityPointerBase<cd,GridImp> (factory, seed)
    {
      // for ghost entities we have to copy right away
      if( seed.isGhost() )
      {
        assert( entity_ == 0 );
        entity_ = factory_.template getNewEntity<0> ();
        assert( entity_ );
        entityImp().setGhost( *seed.ghost() );
      }
    }
 
    ALU3dGridEntityPointer(const ALU3dGridEntityType& entity)
      : ALU3dGridEntityPointerBase<cd,GridImp> (entity.factory(),
                                                entity.seed() )
    {
      // for ghost entities we have to copy right away
      if( entity.isGhost() )
      {
        assert( entity_ == 0 );
        entity_ = factory_.template getNewEntity<0> ();
        assert( entity_ );
        entityImp().setEntity( entity );
      }
    }
 
    ALU3dGridEntityPointer(const ALU3dGridEntityPointerType & org)
      : ALU3dGridEntityPointerBase<cd,GridImp> (org)
    {}
 
  protected:
    ALU3dGridEntityPointer(const FactoryType& factory, int level )
      : ALU3dGridEntityPointerBase<cd,GridImp> (factory,level) {}
  };
 
 
  template<int cd, class GridImp>
  class ALU3dGridEntityPointer :
    public ALU3dGridEntityPointerBase<cd,GridImp>
  {
  protected:
    typedef ALU3dGridEntityPointerBase<cd,GridImp> BaseType ;
    typedef ALU3dGridEntityPointer <cd,GridImp> ThisType;
    enum { dim       = GridImp::dimension };
    enum { dimworld  = GridImp::dimensionworld };
 
    typedef typename GridImp::MPICommunicatorType Comm;
 
    friend class ALU3dGridEntity<cd,dim,GridImp>;
    friend class ALU3dGridEntity< 0,dim,GridImp>;
    friend class ALU3dGrid < GridImp::elementType, Comm >;
 
    typedef ALU3dImplTraits< GridImp::elementType, Comm > ImplTraits;
    typedef typename ImplTraits::template Codim<cd>::InterfaceType HElementType;
 
    typedef typename ImplTraits::HBndSegType HBndSegType;
    typedef typename ImplTraits::BNDFaceType BNDFaceType;
    typedef ALU3dGridEntity<cd,dim,GridImp> ALU3dGridEntityType;
 
    using BaseType :: seed_;
    using BaseType :: entity_;
    using BaseType :: entityImp;
    using BaseType :: factory_;
    using BaseType :: getEntity;
 
  public:
    typedef typename GridImp::GridObjectFactoryType FactoryType;
 
    typedef ALU3dGridEntitySeed<cd, GridImp> ALU3dGridEntitySeedType;
 
    typedef typename GridImp::template Codim<cd>::Entity Entity;
 
    typedef ALU3dGridEntityPointer<cd,GridImp> ALU3dGridEntityPointerType;
 
  protected:
    static const int defaultValue = -665; //ALU3dGridEntityPointerType :: defaultValue;
 
  public:
    ALU3dGridEntityPointer(const FactoryType& factory,
                           const int level,
                           const HElementType & item,
                           const int twist = defaultValue,
                           const int duneFace = defaultValue
                           );
 
    ALU3dGridEntityPointer(const ALU3dGridEntityType& entity)
      : ALU3dGridEntityPointerBase<cd,GridImp> (entity.factory(),
                                                entity.seed())
    {}
 
    ALU3dGridEntityPointer(const FactoryType& factory, const ALU3dGridEntitySeedType& seed)
      : ALU3dGridEntityPointerBase<cd,GridImp> ( factory, seed )
    {}
 
    ALU3dGridEntityPointer(const ALU3dGridEntityPointerType & org);
 
    Entity & dereference () const ;
 
    ThisType & operator = (const ThisType & org);
 
    int level () const ;
 
  protected:
    // clones object
    void clone (const ALU3dGridEntityPointerType & org);
 
    void updateEntityPointer( HElementType * item , int level );
 
    ALU3dGridEntityPointer(const FactoryType& factory, int level )
      : ALU3dGridEntityPointerBase<cd,GridImp> (factory,level)
    {}
  };
 
} // end namespace Dune
 
#include "entity_inline.hh"
 
#if COMPILE_ALUGRID_INLINE
  #include "entity_imp.cc"
#endif
 
#endif