entity.hh

#ifndef DUNE_ALU3DGRIDENTITY_HH
#define DUNE_ALU3DGRIDENTITY_HH
 
// System includes
#include <type_traits>
 
// Dune includes
#include <dune/grid/common/entity.hh>
#include <dune/alugrid/common/intersectioniteratorwrapper.hh>
#include <dune/alugrid/common/twists.hh>
 
// Local includes
#include "alu3dinclude.hh"
#include "indexsets.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<int dim, int dimworld, 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 dm, 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,dim,dim>
  {
    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::dimension, GridImp::dimensionworld, GridImp::elementType, Comm >;
  friend class ALU3dGridEntity < 0, dim, GridImp >;
  friend class ALU3dGridLevelIterator < cd, All_Partition, GridImp >;
 
  friend class ALU3dGridHierarchicIndexSet< GridImp::dimension, GridImp::dimensionworld, GridImp::elementType, Comm >;
 
  template< class > friend class ALU3dGridFactory;
 
  typedef typename GridImp::Traits::template Codim< cd >::GeometryImpl GeometryImpl;
 
public:
  typedef ALU3dImplTraits< GridImp::elementType, Comm > ImplTraits;
  typedef typename ImplTraits::template Codim<dim, cd>::InterfaceType      HItemType;
  typedef typename ImplTraits::template Codim<dim, 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<cd>::EntitySeed EntitySeed;
 
  ALU3dGridEntity();
 
  ALU3dGridEntity( const EntitySeed& seed );
 
  Geometry geometry () const;
 
  GeometryType type () const { return geo_.type(); }
 
  // set element as normal entity
  void setElement(const HItemType & item);
  void setElement(const HItemType & item, const GridImp& grid );
  void setElement(const HItemType & item, const int level, int twist=0);
 
  /* set entity from seed */
  void setElement(const EntitySeed& seed);
 
  void setGhost(const HBndSegType  &ghost);
 
  void removeElement ()
  {
    seed_.clear();
    geo_.invalidate();
  }
 
  bool equals ( const ALU3dGridEntity<cd,dim,GridImp> & org ) const
  {
    return seed_ == org.seed_;
  }
 
  void setEntity ( const ALU3dGridEntity<cd,dim,GridImp> & org );
 
  int subIndex ( int i, unsigned int codim ) const
  {
    DUNE_THROW( NotImplemented, "Method subIndex for higher codimension not implemented, yet." );
  }
 
  // return reference to internal item
  const ItemType& getItem () const { return *(static_cast<ItemType *> (seed_.item())); }
 
  EntitySeed seed() const { return seed_; }
 
  int level () const { return seed_.level(); }
 
  PartitionType partitionType() const { return this->convertBndId( getItem() ); }
 
protected:
  int getIndex () const { return getItem().getIndex(); }
 
  PartitionType convertBndId(const HItemType & item) const ;
 
  mutable GeometryImpl geo_;
 
  EntitySeed seed_;
};
 
//***********************
//
//  --ALU3dGridEntity
//  --0Entity
//
//***********************
template<int dim, class GridImp>
class ALU3dGridEntity<0,dim,GridImp>
: public EntityDefaultImplementation<0,dim,GridImp,ALU3dGridEntity>
{
  static const int dimworld = std::remove_const< GridImp >::type::dimensionworld;
  static const ALU3dGridElementType elementType = std::remove_const< GridImp >::type::elementType;
 
  typedef typename GridImp::MPICommunicatorType Comm;
 
  typedef ALU3dImplTraits< elementType, Comm > ImplTraits;
  typedef typename ImplTraits::template Codim<dim, 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::RefinementRules::refine_element_t  };
  enum { bisect_element_t  = ImplTraits::RefinementRules::bisect_element_t  };
  enum { coarse_element_t  = ImplTraits::RefinementRules::coarse_element_t  };
  enum { nosplit_element_t = ImplTraits::RefinementRules::nosplit_element_t };
 
  typedef typename ImplTraits::MarkRuleType MarkRuleType;
 
  friend class ALU3dGrid< GridImp::dimension, GridImp::dimensionworld, 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< GridImp::dimension, GridImp::dimensionworld, 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::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;
 
  template <int cd>
  struct Codim
  {
    typedef typename GridImp::Traits::template Codim< cd >::Twists::Twist Twist;
    typedef typename GridImp::template Codim< cd >::Entity Entity;
  };
 
  typedef typename GridImp::template Codim<0>::EntitySeed  EntitySeed;
 
  ALU3dGridEntity();
 
  ALU3dGridEntity( const EntitySeed& seed );
 
  ALU3dGridEntity( const HElementType& element );
 
  ALU3dGridEntity( const HBndSegType& ghost );
 
  int level () const ;
 
  Geometry geometry () const;
 
  GeometryType type () const;
 
  PartitionType partitionType() const;
 
  unsigned int subEntities (unsigned int codim) const;
 
  template< int codim >
  typename Codim< codim >::Entity subEntity ( int i ) const;
 
  template< int codim >
  typename Codim< codim >::Twist twist ( int i ) const;
 
  bool isLeaf () const;
 
  Entity 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( const int refCount, const bool conformingRefinement ) 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
  {
    alugrid_assert ( isGhost() );
    return *ghost_;
  }
 
  bool isGhost () const{ return ImplTraits::isGhost( ghost_ ); }
 
  EntitySeed seed() const
  {
    if( isGhost() )
      return EntitySeed( getGhost () );
    else
      return EntitySeed( getItem() );
  }
 
  int macroId() const
  {
    return (isGhost()) ? getGhost().ldbVertexIndex() : getItem().ldbVertexIndex();
  }
 
  int weight() const
  {
    return (isGhost()) ? 0 : getItem().weight();
  }
 
  int master() const
  {
    return (isGhost()) ? getGhost().master() : getItem().master();
  }
 
protected:
  int getIndex () const;
 
  mutable GeometryImpl geo_;
 
  // the current element of grid
  mutable IMPLElementType* item_;
 
  mutable BNDFaceType*  ghost_;
 
}; // 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::dimension, GridImp::dimensionworld, GridImp::elementType, Comm >;
 
  typedef ALU3dImplTraits< GridImp::elementType, Comm > ImplTraits;
  typedef typename ImplTraits::template Codim<dim, codim>::InterfaceType HElementType;
 
  typedef typename ImplTraits::HBndSegType  HBndSegType;
  typedef typename ImplTraits::BNDFaceType BNDFaceType;
public:
  enum { codimension = codim };
 
  typedef typename GridImp::template Codim<codimension>::Entity Entity;
  typedef Entity  EntityObject;
  typedef ALU3dGridEntity<codimension,dim, GridImp> EntityImp;
 
  typedef ThisType ALU3dGridEntityPointerType;
 
  typedef ALU3dGridEntityPointer<codimension,GridImp> EntityPointerImp;
 
  typedef ALU3dGridEntitySeed<codimension, GridImp> ALU3dGridEntitySeedType;
 
  ALU3dGridEntityPointerBase(const HElementType & item);
 
  ALU3dGridEntityPointerBase(const HBndSegType & ghostFace );
 
  ALU3dGridEntityPointerBase(const ALU3dGridEntitySeedType& seed );
 
  ALU3dGridEntityPointerBase(const ALU3dGridEntityPointerType & org);
 
  bool equals (const ALU3dGridEntityPointerType& i) const;
 
  ThisType & operator = (const ThisType & org);
 
  Entity& dereference () const
  {
    // don't dereference empty entity pointer
    alugrid_assert ( seed_.isValid() );
    alugrid_assert ( seed_.item() == & entityImp().getItem() );
    return entity_;
  }
 
  int level () const { return seed_.level(); }
 
  ALU3dGridEntityPointerBase();
 
protected:
  // clones object
  void clone (const ALU3dGridEntityPointerType & org);
 
  void done ();
 
  // 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 );
 
  // key to gererate entity
  ALU3dGridEntitySeedType seed_;
 
  // entity that this EntityPointer points to
  mutable EntityObject entity_;
 
  // return reference to internal entity implementation
  EntityImp & entityImp () const {
    return entity_.impl();
  }
};
 
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::dimension, GridImp::dimensionworld, GridImp::elementType, Comm >;
 
  typedef ALU3dImplTraits< GridImp::elementType, Comm > ImplTraits;
  typedef typename ImplTraits::template Codim<dim, 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;
public:
  typedef ALU3dGridEntitySeed<cd, GridImp> ALU3dGridEntitySeedType;
 
  typedef typename GridImp::template Codim<cd>::Entity Entity;
 
  typedef ThisType ALU3dGridEntityPointerType;
 
  ALU3dGridEntityPointer(const HElementType & item)
    : ALU3dGridEntityPointerBase<cd,GridImp> ( item )
  {}
 
  ALU3dGridEntityPointer(const HBndSegType & ghostFace )
    : ALU3dGridEntityPointerBase<cd,GridImp> ( ghostFace )
  {}
 
  ALU3dGridEntityPointer(const ALU3dGridEntitySeedType& seed)
    : ALU3dGridEntityPointerBase<cd,GridImp> ( seed )
  {
  }
 
  ALU3dGridEntityPointer(const ALU3dGridEntityType& entity)
    : ALU3dGridEntityPointerBase<cd,GridImp> ( entity.seed() )
  {
  }
 
  ALU3dGridEntityPointer()
    : ALU3dGridEntityPointerBase<cd,GridImp> ()
  {}
};
 
 
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::dimension, GridImp::dimensionworld, GridImp::elementType, Comm >;
 
  typedef ALU3dImplTraits< GridImp::elementType, Comm > ImplTraits;
  typedef typename ImplTraits::template Codim<dim, 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;
 
public:
  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 ALU3dGridEntityType& entity)
    : ALU3dGridEntityPointerBase<cd,GridImp> ( entity.seed() )
  {}
 
  ALU3dGridEntityPointer(const ALU3dGridEntitySeedType& seed)
    : ALU3dGridEntityPointerBase<cd,GridImp> ( seed )
  {}
 
  ALU3dGridEntityPointer()
    : ALU3dGridEntityPointerBase<cd,GridImp> ()
  {}
 
protected:
  void updateEntityPointer( HElementType * item , int level );
};
 
} // end namespace Dune
 
#include "entity_inline.hh"
 
#if COMPILE_ALUGRID_INLINE
  #include "entity_imp.cc"
#endif
#endif