Commit 5a3f950f authored by Steffen Müthing's avatar Steffen Müthing
Browse files

Merge branch 'feature/FS1511-identitygrid' 

This branch ports IdentityGrid to the copyable entities and
intersections, which is a little more involved than for a regular grid:

- All of the iterators / entities / intersections now simply store a
  copy of the corresponding host object - no more weird tricks with
  mutable objects, pointers to host objects in other IdentityGrid
  objects etc.

- The implementation of the EntityPointer is now a little more clever by
  copying the approach taken by GeometryGrid: Each iterator inherits
  from a different type of EntityPointer, but those are made
  interoperable with some casts. This makes it possible to store the
  host iterator for an IdentityGrid iterator inside the IdentityGrid
  iterator, avoiding the overhead of storing a separate host
  EntityPointer and iterator.

- The entity and intersection iterators now return temporary objects.

- As everything is now default-constructible, we can get rid of all the
  Makeable... wrappers

In total, the whole implementation has become a lot more
straightforward (apart from the performance trick for the iterators, but
even that is pretty easy to understand).

* feature/FS1511-identitygrid:
  [IdentityGrid][BugFix] Don't use deprecated typedefs for accessing host intersection iterators
  [test-identitygrid] Use a larger grid, scaled by dimension to keep grid size constant
  [IdentityGrid][11/11] Port to copyable entities and intersections
  [IdentityGrid][10/11] Port to copyable entities and intersections
  [IdentityGrid][9/11] Port to copyable entities and intersections
  [IdentityGrid][8/11] Port to copyable entities and intersections
  [IdentityGrid][7/11] Port to copyable entities and intersections
  [IdentityGrid][6/11] Port to copyable entities and intersections
  [IdentityGrid][5/11] Port to copyable entities and intersections
  [IdentityGrid][4/11] Port to copyable entities and intersections
  [IdentityGrid][3/11] Port to copyable entities and intersections
  [IdentityGrid][2/11] Port to copyable entities and intersections
  [IdentityGrid][1/11] Port to copyable entities and intersections

Conflicts:
	dune/grid/identitygrid/identitygridleveliterator.hh
parents 3e875cfc ebb76680

dune/grid/identitygrid.hh

+89 −7
Original line number Diff line number Diff line
@@ -36,18 +36,37 @@ namespace Dune 
  template< class Grid >

  struct HostGridAccess;



  namespace {



    // This is just a placeholder to stuff into the standard

    // GridTraits, as those expect an EntityPointer implementation

    // with two template parameters, but our EntityPointer uses three.

    template<int,typename>

    struct DummyIdentityGridEntityPointer

    {};



  }





  template<int dim, class HostGrid>

  struct IdentityGridFamily

  {



  private:



    // The type signature of our EntityPointer implementation does not fit into

    // the scheme expected by GridTraits, so we have to provide our own Traits

    // On the other hand, we don't want to retype everything, so we just inherit

    // from the default Traits and just tweak the EntityPointer type in the derived

    // Traits class



    typedef GridTraits<

        dim,

        HostGrid::dimensionworld,

        Dune::IdentityGrid<HostGrid>,

        IdentityGridGeometry,

        IdentityGridEntity,

        IdentityGridEntityPointer,

        DummyIdentityGridEntityPointer, // placeholder

        IdentityGridLevelIterator,

        IdentityGridLeafIntersection,

        IdentityGridLevelIntersection,
@@ -65,7 +84,37 @@ namespace Dune 
        DefaultLevelGridViewTraits,

        DefaultLeafGridViewTraits,

        IdentityGridEntitySeed

        > Traits;

        > BaseTraits;



  public:



    // inherit everyting from the default Traits...

    struct Traits

      : public BaseTraits

    {



      // Except for the Codim struct, which we reimplement, but which

      // again inherits everything from the base class...

      template<int codim>

      struct Codim

        : public BaseTraits::template Codim<codim>

      {



        // ... except for the EntityPointer, which we override with our

        // actual implementation

        typedef Dune::EntityPointer<

          const typename BaseTraits::Grid,

          IdentityGridEntityPointer<

            codim,

            const typename BaseTraits::Grid,

            typename HostGrid::template Codim<codim>::EntityPointer

            >

          > EntityPointer;



      };



    };



  };



  //**********************************************************************
@@ -272,15 +321,41 @@ namespace Dune 
    }





    /** \brief Create EntityPointer from EntitySeed */

    /** \brief Create EntityPointer from EntitySeed

     *

     * \deprecated This method is deprecated and will be removed after the release of

     *             dune-grid 2.4. Please use entity() instead, which will directly return

     *             an Entity object that you can then store for later use. The EntityPointer

     *             concept in general is deprecated and will not be available after

     *             dune-grid 2.4 has been released.

     */

    template < class EntitySeed >

    DUNE_DEPRECATED_MSG("entityPointer() is deprecated and will be removed after the release of dune-grid 2.4. Use entity() instead to directly obtain an Entity object.")

    typename Traits::template Codim<EntitySeed::codimension>::EntityPointer

    entityPointer(const EntitySeed& seed) const

    {

      typedef typename Traits::template Codim<EntitySeed::codimension>::EntityPointer EntityPointer;

      typedef IdentityGridEntityPointer<EntitySeed::codimension, const typename Traits::Grid> EntityPointerImp;

      typedef IdentityGridEntityPointer<

        EntitySeed::codimension,

        const typename Traits::Grid,

        typename HostGrid::template Codim<EntitySeed::codimension>::EntityPointer

        > EntityPointerImp;



      return EntityPointer(EntityPointerImp(this, hostgrid_->entity(this->getRealImplementation(seed).hostEntitySeed())));

    }



      return EntityPointer(EntityPointerImp(this, hostgrid_->entityPointer(this->getRealImplementation(seed).hostEntitySeed())));

    /** \brief Create Entity from EntitySeed */

    template < class EntitySeed >

    typename Traits::template Codim<EntitySeed::codimension>::Entity

    entity(const EntitySeed& seed) const

    {

      typedef IdentityGridEntity<

        EntitySeed::codimension,

        HostGrid::dimension,

        const typename Traits::Grid

        > EntityImp;



      return EntityImp(this, hostgrid_->entity(this->getRealImplementation(seed).hostEntitySeed()));

    }
@@ -308,7 +383,7 @@ namespace Dune 
     */

    bool mark(int refCount, const typename Traits::template Codim<0>::Entity & e)

    {

      return hostgrid_->mark(refCount, *getHostEntityPointer<0>(e));

      return hostgrid_->mark(refCount, getHostEntity<0>(e));

    }



    /** \brief Return refinement mark for entity
@@ -317,7 +392,7 @@ namespace Dune 
     */

    int getMark(const typename Traits::template Codim<0>::Entity & e) const

    {

      return hostgrid_->getMark(*getHostEntityPointer<0>(e));

      return hostgrid_->getMark(getHostEntity<0>(e));

    }



    /** \brief returns true, if at least one entity is marked for adaption */
@@ -421,11 +496,18 @@ namespace Dune 


    //! Returns the hostgrid entity encapsulated in given IdentityGrid entity

    template <int codim>

    DUNE_DEPRECATED_MSG("getHostEntityPointer() is deprecated and will be removed after the release of dune-grid 2.4. Use getHostEntity() instead to obtain a reference to the host entity object.")

    typename HostGrid::Traits::template Codim<codim>::EntityPointer getHostEntityPointer(const typename Traits::template Codim<codim>::Entity& e) const

    {

      return this->getRealImplementation(e).hostEntity_;

    }



    template <int codim>

    const typename HostGrid::Traits::template Codim<codim>::Entity& getHostEntity(const typename Traits::template Codim<codim>::Entity& e) const

    {

      return this->getRealImplementation(e).hostEntity_;

    }



  protected:



    //! The host grid which contains the actual grid hierarchy structure

dune/grid/identitygrid/identitygridentity.hh

+101 −112
Original line number Diff line number Diff line
@@ -17,7 +17,7 @@ namespace Dune { 
  template<int codim, int dim, class GridImp>

  class IdentityGridEntity;



  template<int codim, class GridImp>

  template<int codim, class GridImp, typename HostEntityPointer>

  class IdentityGridEntityPointer;



  template<int codim, PartitionIteratorType pitype, class GridImp>
@@ -38,47 +38,6 @@ namespace Dune { 
  struct HostGridAccess;







  template<int codim, int dim, class GridImp>

  class IdentityGridMakeableEntity :

    public GridImp::template Codim<codim>::Entity

  {

  public:



    // The codimension of this entitypointer wrt the host grid

    enum {CodimInHostGrid = GridImp::HostGridType::dimension - GridImp::dimension + codim};



    // EntityPointer to the equivalent entity in the host grid

    typedef typename GridImp::HostGridType::Traits::template Codim<CodimInHostGrid>::EntityPointer HostGridEntityPointer;





    //! \todo Please doc me !

    template< class HostGridEntityPointer >

    IdentityGridMakeableEntity(const GridImp* identityGrid, const HostGridEntityPointer& hostEntity) :

      GridImp::template Codim<codim>::Entity (IdentityGridEntity<codim, dim, const GridImp>(identityGrid,hostEntity)),

      identityGrid_(identityGrid)

    {}





    //! \todo Please doc me !

    template< class HostGridEntityPointer >

    void setToTarget(const HostGridEntityPointer& hostEntity) {

      this->realEntity.setToTarget(hostEntity);

    }





    //! \todo Please doc me !

    const HostGridEntityPointer& getTarget() {

      return this->realEntity.hostEntity_;

    }





  private:



    const GridImp* identityGrid_;

  };





  //**********************************************************************

  //

  // --IdentityGridEntity
@@ -95,7 +54,6 @@ namespace Dune { 
  class IdentityGridEntity :

    public EntityDefaultImplementation <codim,dim,GridImp,IdentityGridEntity>

  {

    friend class IdentityGridMakeableEntity<codim,dim,GridImp>;



    template <class GridImp_>

    friend class IdentityGridLevelIndexSet;
@@ -109,7 +67,8 @@ namespace Dune { 
    template <class GridImp_>

    friend class IdentityGridGlobalIdSet;



    friend class IdentityGridEntityPointer<codim,GridImp>;

    template<int,typename, typename>

    friend class IdentityGridEntityPointer;



    friend struct HostGridAccess< typename remove_const< GridImp >::type >;
@@ -122,7 +81,7 @@ namespace Dune { 
    enum {CodimInHostGrid = GridImp::HostGridType::dimension - GridImp::dimension + codim};



    // EntityPointer to the equivalent entity in the host grid

    typedef typename GridImp::HostGridType::Traits::template Codim<CodimInHostGrid>::EntityPointer HostGridEntityPointer;

    typedef typename GridImp::HostGridType::Traits::template Codim<CodimInHostGrid>::Entity HostGridEntity;





  public:
@@ -132,20 +91,30 @@ namespace Dune { 
    //! The type of the EntitySeed interface class

    typedef typename GridImp::template Codim<codim>::EntitySeed EntitySeed;



    //! Constructor for an entity in a given grid level

    template< class HostGridEntityPointer >

    IdentityGridEntity(const GridImp* identityGrid, const HostGridEntityPointer& hostEntity) :

      hostEntity_(hostEntity),

      identityGrid_(identityGrid)

    IdentityGridEntity()

      : identityGrid_(nullptr)

    {}



    IdentityGridEntity(const GridImp* identityGrid, const HostGridEntity& hostEntity)

      : hostEntity_(hostEntity)

      , identityGrid_(identityGrid)

    {}



    IdentityGridEntity(const GridImp* identityGrid, HostGridEntity&& hostEntity)

      : hostEntity_(std::move(hostEntity))

      , identityGrid_(identityGrid)

    {}



    //! \todo Please doc me !

    IdentityGridEntity(const IdentityGridEntity& original) :

      hostEntity_(original.hostEntity_),

      identityGrid_(original.identityGrid_)

    IdentityGridEntity(const IdentityGridEntity& original)

      : hostEntity_(original.hostEntity_)

      , identityGrid_(original.identityGrid_)

    {}



    IdentityGridEntity(IdentityGridEntity&& original)

      : hostEntity_(std::move(original.hostEntity_))

      , identityGrid_(original.identityGrid_)

    {}



    //! \todo Please doc me !

    IdentityGridEntity& operator=(const IdentityGridEntity& original)
@@ -158,6 +127,17 @@ namespace Dune { 
      return *this;

    }



    //! \todo Please doc me !

    IdentityGridEntity& operator=(IdentityGridEntity&& original)

    {

      if (this != &original)

      {

        identityGrid_ = original.identityGrid_;

        hostEntity_ = std::move(original.hostEntity_);

      }

      return *this;

    }



    bool equals(const IdentityGridEntity& other) const

    {

      return hostEntity_ == other.hostEntity_;
@@ -165,25 +145,25 @@ namespace Dune { 


    //! returns true if father entity exists

    bool hasFather () const {

      return hostEntity_->hasFather();

      return hostEntity_.hasFather();

    }



    //! Create EntitySeed

    EntitySeed seed () const

    {

      return EntitySeed(*hostEntity_);

      return EntitySeed(hostEntity_);

    }



    //! level of this element

    int level () const {

      return hostEntity_->level();

      return hostEntity_.level();

    }





    /** \brief The partition type for parallel computing

     */

    PartitionType partitionType () const {

      return hostEntity_->partitionType();

      return hostEntity_.partitionType();

    }
@@ -191,33 +171,23 @@ namespace Dune { 
     * with codimension cc.

     */

    template<int cc> int count () const {

      return hostEntity_->template count<cc>();

      return hostEntity_.template count<cc>();

    }





    //! geometry of this entity

    Geometry geometry () const

    {

      return Geometry( hostEntity_->geometry() );

      return Geometry( hostEntity_.geometry() );

    }





    HostGridEntityPointer hostEntity_;



    HostGridEntity hostEntity_;



  private:



    //! \todo Please doc me !

    template< class HostGridEntityPointer >

    void setToTarget(const HostGridEntityPointer& target)

    {

      hostEntity_ = target;

    }





    const GridImp* identityGrid_;



    //! the current geometry

  };
@@ -241,13 +211,16 @@ namespace Dune { 
  {

    friend struct HostGridAccess< typename remove_const< GridImp >::type >;



    template<int,typename, typename>

    friend class IdentityGridEntityPointer;



  public:



    // The codimension of this entitypointer wrt the host grid

    enum {CodimInHostGrid = GridImp::HostGridType::dimension - GridImp::dimension};



    // EntityPointer to the equivalent entity in the host grid

    typedef typename GridImp::HostGridType::Traits::template Codim<CodimInHostGrid>::EntityPointer HostGridEntityPointer;

    typedef typename GridImp::HostGridType::Traits::template Codim<CodimInHostGrid>::Entity HostGridEntity;



    typedef typename GridImp::template Codim<0>::Geometry Geometry;
@@ -265,20 +238,32 @@ namespace Dune { 
    //! The type of the EntitySeed interface class

    typedef typename GridImp::template Codim<0>::EntitySeed EntitySeed;



    //! Constructor for an entity in a given grid level

    template< class HostGridEntityPointer >

    IdentityGridEntity(const GridImp* identityGrid, const HostGridEntityPointer& hostEntity) :

      identityGrid_(identityGrid),

      hostEntity_(hostEntity)





    IdentityGridEntity()

      : identityGrid_(nullptr)

    {}



    IdentityGridEntity(const GridImp* identityGrid, const HostGridEntity& hostEntity)

      : hostEntity_(hostEntity)

      , identityGrid_(identityGrid)

    {}



    IdentityGridEntity(const GridImp* identityGrid, HostGridEntity&& hostEntity)

      : hostEntity_(std::move(hostEntity))

      , identityGrid_(identityGrid)

    {}



    //! \todo Please doc me !

    IdentityGridEntity(const IdentityGridEntity& original) :

      identityGrid_(original.identityGrid_),

      hostEntity_(original.hostEntity_)

    IdentityGridEntity(const IdentityGridEntity& original)

      : hostEntity_(original.hostEntity_)

      , identityGrid_(original.identityGrid_)

    {}



    IdentityGridEntity(IdentityGridEntity&& original)

      : hostEntity_(std::move(original.hostEntity_))

      , identityGrid_(original.identityGrid_)

    {}



    //! \todo Please doc me !

    IdentityGridEntity& operator=(const IdentityGridEntity& original)
@@ -291,6 +276,17 @@ namespace Dune { 
      return *this;

    }



    //! \todo Please doc me !

    IdentityGridEntity& operator=(IdentityGridEntity&& original)

    {

      if (this != &original)

      {

        identityGrid_ = original.identityGrid_;

        hostEntity_ = std::move(original.hostEntity_);

      }

      return *this;

    }



    bool equals(const IdentityGridEntity& other) const

    {

      return hostEntity_ == other.hostEntity_;
@@ -298,32 +294,32 @@ namespace Dune { 


    //! returns true if father entity exists

    bool hasFather () const {

      return hostEntity_->hasFather();

      return hostEntity_.hasFather();

    }



    //! Create EntitySeed

    EntitySeed seed () const

    {

      return EntitySeed(*hostEntity_);

      return EntitySeed(hostEntity_);

    }



    //! Level of this element

    int level () const

    {

      return hostEntity_->level();

      return hostEntity_.level();

    }





    /** \brief The partition type for parallel computing */

    PartitionType partitionType () const {

      return hostEntity_->partitionType();

      return hostEntity_.partitionType();

    }





    //! Geometry of this entity

    Geometry geometry () const

    {

      return Geometry( hostEntity_->geometry() );

      return Geometry( hostEntity_.geometry() );

    }
@@ -332,7 +328,7 @@ namespace Dune { 
    template<int cc>

    int count () const

    {

      return hostEntity_->template count<cc>();

      return hostEntity_.template count<cc>();

    }
@@ -340,7 +336,7 @@ namespace Dune { 
     */

    unsigned int subEntities (unsigned int codim) const

    {

      return hostEntity_->subEntities(codim);

      return hostEntity_.subEntities(codim);

    }
@@ -348,49 +344,53 @@ namespace Dune { 
     *  are numbered 0 ... count<cc>()-1

     */

    template<int cc>

    typename GridImp::template Codim<cc>::EntityPointer subEntity (int i) const {

      return IdentityGridEntityPointer<cc,GridImp>(identityGrid_, hostEntity_->template subEntity<cc>(i));

    typename GridImp::template Codim<cc>::Entity subEntity (int i) const {

      return IdentityGridEntity<cc,dim,GridImp>(identityGrid_, hostEntity_.template subEntity<cc>(i));

    }





    //! First level intersection

    IdentityGridLevelIntersectionIterator<GridImp> ilevelbegin () const {

      return IdentityGridLevelIntersectionIterator<GridImp>(identityGrid_,

                                                            hostEntity_->ilevelbegin());

      return IdentityGridLevelIntersectionIterator<GridImp>(

        identityGrid_,

        identityGrid_->getHostGrid().levelGridView(level()).ibegin(hostEntity_));

    }





    //! Reference to one past the last neighbor

    IdentityGridLevelIntersectionIterator<GridImp> ilevelend () const {

      return IdentityGridLevelIntersectionIterator<GridImp>(identityGrid_,

                                                            hostEntity_->ilevelend());

      return IdentityGridLevelIntersectionIterator<GridImp>(

        identityGrid_,

        identityGrid_->getHostGrid().levelGridView(level()).iend(hostEntity_));

    }





    //! First leaf intersection

    IdentityGridLeafIntersectionIterator<GridImp> ileafbegin () const {

      return IdentityGridLeafIntersectionIterator<GridImp>(identityGrid_,

                                                           hostEntity_->ileafbegin());

      return IdentityGridLeafIntersectionIterator<GridImp>(

        identityGrid_,

        identityGrid_->getHostGrid().leafGridView().ibegin(hostEntity_));

    }





    //! Reference to one past the last leaf intersection

    IdentityGridLeafIntersectionIterator<GridImp> ileafend () const {

      return IdentityGridLeafIntersectionIterator<GridImp>(identityGrid_,

                                                           hostEntity_->ileafend());

      return IdentityGridLeafIntersectionIterator<GridImp>(

        identityGrid_,

        identityGrid_->getHostGrid().leafGridView().iend(hostEntity_));

    }





    //! returns true if Entity has NO children

    bool isLeaf() const {

      return hostEntity_->isLeaf();

      return hostEntity_.isLeaf();

    }





    //! Inter-level access to father element on coarser grid.

    //! Assumes that meshes are nested.

    IdentityGridEntityPointer<0,GridImp> father () const {

      return IdentityGridEntityPointer<0,GridImp>(identityGrid_, hostEntity_->father());

    typename GridImp::template Codim<0>::Entity father () const {

      return IdentityGridEntity(identityGrid_, hostEntity_.father());

    }
@@ -405,7 +405,7 @@ namespace Dune { 
     */

    LocalGeometry geometryInFather () const

    {

      return LocalGeometry( hostEntity_->geometryInFather() );

      return LocalGeometry( hostEntity_.geometryInFather() );

    }
@@ -450,20 +450,9 @@ namespace Dune { 
    // /////////////////////////////////////////





    //! \todo Please doc me !

    template< class HostGridEntityPointer >

    void setToTarget(const HostGridEntityPointer& target)

    {

      hostEntity_ = target;

    }





    HostGridEntity hostEntity_;

    const GridImp* identityGrid_;



    //! \todo Please doc me !

    HostGridEntityPointer hostEntity_;





  private:



    typedef typename GridImp::ctype ctype;

dune/grid/identitygrid/identitygridentitypointer.hh

+44 −17
Original line number Diff line number Diff line
@@ -14,13 +14,16 @@ namespace Dune { 


  /** Acts as a pointer to an  entities of a given codimension.

   */

  template<int codim, class GridImp>

  template<int codim, class GridImp, class HostGridEntityPointer_>

  class IdentityGridEntityPointer

  {

  private:



    enum { dim = GridImp::dimension };



    template<int, typename, typename>

    friend class IdentityGridEntityPointer;





  public:
@@ -33,37 +36,61 @@ namespace Dune { 


    typedef typename GridImp::template Codim<codim>::Entity Entity;



    typedef IdentityGridEntityPointer<codim,GridImp> Base;



    // The codimension of this entitypointer wrt the host grid

    enum {CodimInHostGrid = GridImp::HostGridType::dimension - GridImp::dimension + codim};



    // EntityPointer to the equivalent entity in the host grid

    typedef typename GridImp::HostGridType::Traits::template Codim<CodimInHostGrid>::EntityPointer HostGridEntityPointer;

    typedef HostGridEntityPointer_ HostGridEntityPointer;





    //! constructor

    template< class HostGridEntityPointer >

    IdentityGridEntityPointer (const GridImp* identityGrid, const HostGridEntityPointer& hostEntity_) :

      identityGrid_(identityGrid),

      virtualEntity_(identityGrid, hostEntity_)

    IdentityGridEntityPointer (const GridImp* identityGrid, const HostGridEntityPointer& hostEntityPointer)

      : identityGrid_(identityGrid)

      , hostEntityPointer_(hostEntityPointer)

    {}



    ///! copy constructor from EntityPointer storing different host EntityPointer

    template<typename ForeignHostGridEntityPointer>

    explicit IdentityGridEntityPointer (const IdentityGridEntityPointer<codim,GridImp,ForeignHostGridEntityPointer>& entityPointer)

      : identityGrid_(entityPointer.identityGrid_)

      , hostEntityPointer_(entityPointer.hostEntityPointer_)

    {}



    ///! assignment operator from EntityPointer storing different host EntityPointer

    template<typename ForeignHostGridEntityPointer>

    IdentityGridEntityPointer& operator=(const IdentityGridEntityPointer<codim,GridImp,ForeignHostGridEntityPointer>& entityPointer)

    {

      hostEntityPointer_ = entityPointer.hostEntityPointer_;

      return *this;

    }



    //! Move constructor to avoid copying the host EntityPointer

    IdentityGridEntityPointer (const GridImp* identityGrid, HostGridEntityPointer&& hostEntityPointer)

      : identityGrid_(identityGrid)

      , hostEntityPointer_(std::move(hostEntityPointer))

    {}



    //! Constructor from an IdentityGrid entity

    IdentityGridEntityPointer (const IdentityGridEntity<codim,dim,GridImp>& entity)

      : identityGrid_(entity.identityGrid_),

        virtualEntity_(entity.identityGrid_, entity.hostEntity_)

      : identityGrid_(entity.identityGrid_)

      , hostEntityPointer_(entity.hostEntity_)

    {}



    //! equality

    bool equals(const IdentityGridEntityPointer<codim,GridImp>& i) const {

      return virtualEntity_.getTarget() == i.virtualEntity_.getTarget();

    bool equals(const IdentityGridEntityPointer& i) const {

      return hostEntityPointer_ == i.hostEntityPointer_;

    }



    //! equality with EntityPointer based on different host EntityPointer

    template<typename ForeignHostGridEntityPointer>

    bool equals(const IdentityGridEntityPointer<codim,GridImp,ForeignHostGridEntityPointer>& entityPointer) const

    {

      return  hostEntityPointer_ == entityPointer.hostEntityPointer_;

    }



    //! dereferencing

    Entity& dereference() const {

      return virtualEntity_;

    Entity dereference() const {

      return Entity{{identityGrid_,*hostEntityPointer_}};

    }



    //! Make this pointer as small as possible
@@ -73,7 +100,7 @@ namespace Dune { 


    //! ask for level of entity

    int level () const {

      return virtualEntity_.level();

      return hostEntityPointer_->level();

    }
@@ -81,8 +108,8 @@ namespace Dune { 


    const GridImp* identityGrid_;



    //! virtual entity

    mutable IdentityGridMakeableEntity<codim,dim,GridImp> virtualEntity_;

    //! host EntityPointer

    HostGridEntityPointer hostEntityPointer_;





  };

dune/grid/identitygrid/identitygridhierarchiciterator.hh

+13 −40

File changed.

Preview size limit exceeded, changes collapsed.

dune/grid/identitygrid/identitygridindexsets.hh

+10 −10

File changed.

Preview size limit exceeded, changes collapsed.