foamgridentity.hh

Go to the documentation of this file.

// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set ts=8 sw=4 et sts=4:
#ifndef DUNE_FOAMGRID_ENTITY_HH
#define DUNE_FOAMGRID_ENTITY_HH
 
#include <memory>
#include <array>
 
#include <dune/common/version.hh>
 
#include <dune/geometry/type.hh>
#include <dune/grid/common/gridenums.hh>
#include <dune/grid/common/grid.hh>
 
#include <dune/foamgrid/foamgrid/foamgridvertex.hh>
#include <dune/foamgrid/foamgrid/foamgridgeometry.hh>
 
namespace Dune {
 
 
// Forward declarations
 
template<int codim, int dimentity, class GridImp>
class FoamGridEntity;
 
template<int codim, PartitionIteratorType pitype, class GridImp>
class FoamGridLevelIterator;
 
template<class GridImp>
class FoamGridLevelIntersectionIterator;
 
template<class GridImp>
class FoamGridLeafIntersectionIterator;
 
template<class GridImp>
class FoamGridHierarchicIterator;
 
 
template<int codim, int dimgrid, class GridImp>
class FoamGridEntity :
    public EntityDefaultImplementation <codim, dimgrid, GridImp, FoamGridEntity>
{
    template <class GridImp_>
    friend class FoamGridLevelIndexSet;
 
    template <class GridImp_>
    friend class FoamGridLeafIndexSet;
 
    template <class GridImp_>
    friend class FoamGridLocalIdSet;
 
    template <class GridImp_>
    friend class FoamGridGlobalIdSet;
 
    private:
 
        typedef typename GridImp::ctype ctype;
 
        enum{dimworld = GridImp::dimensionworld};
 
    public:
 
        typedef typename GridImp::template Codim<codim>::Geometry Geometry;
 
        typedef typename GridImp::template Codim<codim>::EntitySeed EntitySeed;
 
 
 
        explicit FoamGridEntity(const FoamGridEntityImp<dimgrid-codim, dimgrid, dimworld, ctype>* target) :
            target_(target)
        {}
 
        FoamGridEntity(const FoamGridEntity& original) :
            target_(original.target_)
        {}
 
        FoamGridEntity() :
            target_(nullptr)
        {}
 
 
        FoamGridEntity& operator=(const FoamGridEntity& original)
        {
            if (this != &original)
            {
                target_ = original.target_;
            }
            return *this;
        }
 
 
        int level () const {
            return target_->level();
        }
 
 
        PartitionType partitionType () const {
            return target_->partitionType();
        }
 
 
        template<int cc> int count () const{
            return target_->template count<cc>();
        }
 
 
        Geometry geometry () const
        {
            // we currently only support simplices
            std::array<FieldVector<ctype, dimworld>, dimgrid-codim+1> coordinates;
            assert(dimgrid-codim+1 == target_->corners() && "Target entity is not a simplex!");
            for (int i=0; i<target_->corners(); i++)
                coordinates[i] = target_->corner(i);
 
            return Geometry(FoamGridGeometry<dimgrid-codim, dimworld, GridImp>(target_->type(), coordinates));
        }
 
        EntitySeed seed () const
        {
            return EntitySeed(*this);
        }
 
        const FoamGridEntityImp<dimgrid-codim, dimgrid, dimworld, ctype>* target_;
 
 
        void setToTarget(const FoamGridEntityImp<dimgrid-codim, dimgrid, dimworld, ctype>* target)
        {
            target_ = target;
        }
 
        bool equals(const Dune::FoamGridEntity<codim, dimgrid, GridImp>& other) const
        {
            return target_ == other.target_;
        }
 
        GeometryType type () const { return target_->type(); }
};
 
 
 
 
template<class GridImp>
class FoamGridEntity<0, 2, GridImp> :
    public EntityDefaultImplementation<0, 2, GridImp, FoamGridEntity>
{
 
        enum {dimworld = GridImp::dimensionworld};
        enum {dimgrid = GridImp::dimension};
 
    private:
 
        typedef typename GridImp::ctype ctype;
 
    public:
 
        typedef typename GridImp::template Codim<0>::Geometry Geometry;
 
        typedef typename GridImp::template Codim<0>::LocalGeometry LocalGeometry;
 
        typedef FoamGridLevelIntersectionIterator<GridImp> LevelIntersectionIterator;
 
        typedef FoamGridLeafIntersectionIterator<GridImp> LeafIntersectionIterator;
 
        typedef FoamGridHierarchicIterator<GridImp> HierarchicIterator;
 
        typedef typename GridImp::template Codim<0>::EntitySeed EntitySeed;
 
        template<int codim>
        struct Codim
        {
          typedef typename GridImp::Traits::template Codim<codim>::Entity Entity;
        };
 
        typedef typename GridImp::Traits::template Codim<0>::Entity Entity;
 
 
        explicit FoamGridEntity(const FoamGridEntityImp<dimgrid, dimgrid, dimworld, ctype>* hostEntity) :
            target_(hostEntity)
        {}
 
 
        FoamGridEntity(const FoamGridEntity& original) :
            target_(original.target_)
        {}
 
        FoamGridEntity() :
            target_(nullptr)
        {}
 
        FoamGridEntity& operator=(const FoamGridEntity& original)
        {
            if (this != &original)
            {
                target_ = original.target_;
            }
            return *this;
        }
 
 
        int level () const
        {
            return target_->level_;
        }
 
 
        PartitionType partitionType () const {
            return InteriorEntity;
        }
 
 
        Geometry geometry () const
        {
            // we currently only support simplices
            std::array<FieldVector<ctype, dimworld>, dimgrid+1> coordinates;
            assert(dimgrid+1 == target_->corners() && "Target entity is not a simplex!");
            for (int i=0; i<target_->corners(); i++)
                coordinates[i] = target_->vertex_[i]->pos_;
 
            return Geometry(FoamGridGeometry<dimgrid, dimworld, const GridImp>(target_->type(), coordinates));
        }
 
        EntitySeed seed () const
        {
            return EntitySeed(*this);
        }
 
 
        template<int cc>
        int count () const
        {
            static_assert(0<=cc && cc<=2, "Only codimensions with 0 <= cc <= 2 are valid!");
            return (cc==0) ? 1 : 3;
        }
 
        unsigned int count (unsigned int codim) const
        {
            assert(codim<=2);
            return (codim==0) ? 1 : 3;
        }
 
        unsigned int subEntities (unsigned int codim) const
        {
            assert(codim<=2);
            return (codim==0) ? 1 : 3;
        }
 
        int subId (int i, unsigned int codim) const {
            assert(codim<=dimgrid);
            switch (codim) {
            case 0:
                return target_->id_;
            case 1:
                return target_->facet_[i]->id_;
            case 2:
                return target_->vertex_[i]->id_;
            }
            DUNE_THROW(GridError, "Non-existing codimension requested!");
        }
 
        template<int codim>
        typename std::enable_if<codim==0, typename Codim<0>::Entity>::type
        subEntity (int i) const
        {
          assert(i==0);
          return typename Codim<0>::Entity(FoamGridEntity<0, dimgrid, GridImp>(this->target_));
        }
 
        template<int codim>
        typename std::enable_if<codim==1, typename Codim<1>::Entity>::type
        subEntity (int i) const
        {
          assert(i==0 || i==1 || i==2);
          return typename Codim<1>::Entity(FoamGridEntity<1, dimgrid, GridImp>(this->target_->facet_[i]));
        }
 
        template<int codim>
        typename std::enable_if<codim==2, typename Codim<2>::Entity>::type
        subEntity (int i) const
        {
          assert(i==0 || i==1 || i==2);
          return typename Codim<2>::Entity(FoamGridEntity<2, dimgrid, GridImp>(this->target_->vertex_[i]));
        }
 
        FoamGridLevelIntersectionIterator<GridImp> ilevelbegin () const{
            return FoamGridLevelIntersectionIterator<GridImp>(target_, 0);
        }
 
 
        FoamGridLevelIntersectionIterator<GridImp> ilevelend () const{
            return FoamGridLevelIntersectionIterator<GridImp>(target_);
        }
 
 
        FoamGridLeafIntersectionIterator<GridImp> ileafbegin () const{
            if(isLeaf())
                return FoamGridLeafIntersectionIterator<GridImp>(target_,0);
            else
                return FoamGridLeafIntersectionIterator<GridImp>(target_);
        }
 
 
        FoamGridLeafIntersectionIterator<GridImp> ileafend () const{
            return FoamGridLeafIntersectionIterator<GridImp>(target_);
        }
 
 
        bool isLeaf() const {
            return target_->isLeaf();
        }
 
        bool hasFather() const {
            return level()>0;
        }
 
        bool isNew() const
        {
            return target_->isNew();
        }
 
        bool mightVanish() const
        {
            return target_->mightVanish();
        }
 
        Entity father () const {
            return Entity(FoamGridEntity<0, dimgrid, GridImp>(target_->father_));
        }
 
        LocalGeometry geometryInFather () const {
            FoamGridEntityImp<dimgrid, dimgrid, dimworld, ctype>* father = target_->father_;
            // Check whether there really is a father
            if(father==nullptr)
                DUNE_THROW(GridError, "There is no father Element.");
 
            // Sanity check
            if(target_->type().isTriangle()){
                // Lookup the coordinates within the father
                // As in the refinement routine the children
                // are number as follows:
                // First come the ones located in the corner
                // ascending with the corner index.
                // Their first corner (origin in the reference simplex)
                // is always the corner that is also a corner of the father.
                // For the element with all corners on the edge midpoints of
                // the father, the corner are numbered according to the edge indices
                // of the father.
                ctype mapping[4][3][2] ={
                    { {0.0,0.0}, {0.5,0.0}, {0.0,0.5} },
                    { {1.0,0.0}, {0.5,0.5}, {0.5,0.0} },
                    { {0.0,1.0}, {0.0,0.5}, {0.5,0.5} },
                    { {0.5,0.0}, {0.5,0.5}, {0.0,0.5} }
                };
 
                std::array<FieldVector<ctype, dimgrid>, 3> coordinates;
 
                for(int corner=0; corner <3; ++corner)
                    for(int entry=0; entry <2; ++entry)
                        coordinates[corner][entry]=
                            mapping[target_->refinementIndex_][corner][entry];
 
                // return LocalGeomety by value
                return LocalGeometry(FoamGridGeometry<dimgrid, dimgrid, const GridImp>(target_->type(),
                                                                        coordinates));
            }else{
                DUNE_THROW(NotImplemented, "geometryInFather only supported for triangles!");
            }
 
        }
 
 
        FoamGridHierarchicIterator<GridImp> hbegin (int maxLevel) const
        { return { target_, maxLevel }; }
 
 
        FoamGridHierarchicIterator<GridImp> hend (int maxLevel) const
        { return { maxLevel }; }
 
 
        // /////////////////////////////////////////
        //   Internal stuff
        // /////////////////////////////////////////
 
 
        void setToTarget(const FoamGridEntityImp<dimgrid, dimgrid, dimworld, ctype>* target)
        {
            target_ = target;
        }
 
        bool equals(const Dune::FoamGridEntity<0, dimgrid, GridImp>& other) const
        {
            return target_ == other.target_;
        }
 
        GeometryType type () const { return target_->type(); }
 
        const FoamGridEntityImp<dimgrid, dimgrid ,dimworld, ctype>* target_;
 
}; // end of FoamGridEntity codim = 0, dimgrid = 2
 
 
template<class GridImp>
class FoamGridEntity<0, 1, GridImp> :
    public EntityDefaultImplementation<0, 1, GridImp, FoamGridEntity>
{
 
        enum {dimworld = GridImp::dimensionworld};
        enum {dimgrid = GridImp::dimension};
 
    private:
 
        typedef typename GridImp::ctype ctype;
 
    public:
 
        typedef typename GridImp::template Codim<0>::Geometry Geometry;
 
        typedef typename GridImp::template Codim<0>::LocalGeometry LocalGeometry;
 
        typedef FoamGridLevelIntersectionIterator<GridImp> LevelIntersectionIterator;
 
        typedef FoamGridLeafIntersectionIterator<GridImp> LeafIntersectionIterator;
 
        typedef FoamGridHierarchicIterator<GridImp> HierarchicIterator;
 
        typedef typename GridImp::template Codim<0>::EntitySeed EntitySeed;
 
        template<int codim>
        struct Codim
        {
          typedef typename GridImp::Traits::template Codim<codim>::Entity Entity;
        };
 
        typedef typename GridImp::Traits::template Codim<0>::Entity Entity;
 
        explicit FoamGridEntity(const FoamGridEntityImp<dimgrid, dimgrid, dimworld, ctype>* hostEntity) :
            target_(hostEntity)
        {}
 
 
        FoamGridEntity(const FoamGridEntity& original) :
            target_(original.target_)
        {}
 
        FoamGridEntity() :
            target_(nullptr)
        {}
 
        FoamGridEntity& operator=(const FoamGridEntity& original)
        {
            if (this != &original)
            {
                target_ = original.target_;
            }
            return *this;
        }
 
 
        int level () const
        {
            return target_->level_;
        }
 
 
        PartitionType partitionType () const {
            return InteriorEntity;
        }
 
 
        Geometry geometry () const
        {
            // we currently only support simplices
            std::array<FieldVector<ctype, dimworld>, dimgrid+1> coordinates;
            assert(dimgrid+1 == target_->corners() && "Target entity is not a simplex!");
            for (int i=0; i<target_->corners(); i++)
                coordinates[i] = target_->corner(i);
 
            return Geometry(FoamGridGeometry<dimgrid, dimworld, const GridImp>(target_->type(), coordinates));
        }
 
        EntitySeed seed () const
        {
            return EntitySeed(*this);
        }
 
 
        template<int cc>
        int count () const
        {
            static_assert(0<=cc && cc<=1, "Only codimensions with 0 <= cc <= 1 are valid!");
            return (cc==0) ? 1 : 2;
        }
 
        unsigned int count (unsigned int codim) const
        {
            assert(codim<=1);
            return (codim==0) ? 1 : 2;
        }
 
        unsigned int subEntities (unsigned int codim) const
        {
            assert(codim<=1);
            return (codim==0) ? 1 : 2;
        }
 
        int subId (int i,unsigned int codim) const {
            assert(codim<=1);
            switch (codim) {
            case 0:
                return target_->id_;
            case 1:
                return target_->vertex_[i]->id_;
            }
            DUNE_THROW(GridError, "Non-existing codimension requested!");
        }
 
        template<int codim>
        typename std::enable_if<codim==0, typename Codim<0>::Entity>::type
        subEntity (int i) const
        {
          assert(i==0);
          return typename Codim<0>::Entity(FoamGridEntity<0, dimgrid, GridImp>(this->target_));
        }
 
        template<int codim>
        typename std::enable_if<codim==1, typename Codim<1>::Entity>::type
        subEntity (int i) const
        {
          assert(i==0 || i==1);
          return typename Codim<1>::Entity(FoamGridEntity<1, dimgrid, GridImp>(this->target_->vertex_[i]));
        }
 
        FoamGridLevelIntersectionIterator<GridImp> ilevelbegin () const{
            return FoamGridLevelIntersectionIterator<GridImp>(target_, 0);
        }
 
 
        FoamGridLevelIntersectionIterator<GridImp> ilevelend () const{
            return FoamGridLevelIntersectionIterator<GridImp>(target_);
        }
 
 
        FoamGridLeafIntersectionIterator<GridImp> ileafbegin () const{
            if(isLeaf())
                return FoamGridLeafIntersectionIterator<GridImp>(target_,0);
            else
                return FoamGridLeafIntersectionIterator<GridImp>(target_);
        }
 
 
        FoamGridLeafIntersectionIterator<GridImp> ileafend () const{
            return FoamGridLeafIntersectionIterator<GridImp>(target_);
        }
 
 
        bool isLeaf() const {
            return target_->isLeaf();
        }
 
        bool hasFather() const {
            return level()>0;
        }
 
        bool isNew() const
        {
            return target_->isNew();
        }
 
        bool mightVanish() const
        {
            return target_->mightVanish();
        }
 
        Entity father () const {
            return Entity(FoamGridEntity<0, dimgrid, GridImp>(target_->father_));
        }
 
        LocalGeometry geometryInFather () const {
            FoamGridEntityImp<dimgrid, dimgrid, dimworld, ctype>* father = target_->father_;
            // Check whether there really is a father
            if(father==nullptr)
                DUNE_THROW(GridError, "There is no father Element.");
 
            // Sanity check
            if(target_->type().isLine()){
                // Lookup the coordinates within the father
                // As in the refinement routine the children
                // are number as follows:
                // First come the ones located in the corner
                // ascending with the corner index.
                // Their first corner (origin in the reference simplex)
                // is always the corner that is also a corner of the father.
                // For the element with all corners on the edge midpoints of
                // the father, the corner are numbered according to the edge indices
                // of the father.
                ctype mapping[2][2] = {{0.0, 0.5}, {0.5, 1.0}};
 
                std::array<FieldVector<ctype, dimgrid>, 2> coordinates;
 
                for(int corner=0; corner <2; ++corner)
                    coordinates[corner][0] = mapping[target_->refinementIndex_][corner];
 
                // return LocalGeomety by value
                return LocalGeometry(FoamGridGeometry<dimgrid, dimgrid, const GridImp>(target_->type(), coordinates));
            }
            else
            {
                DUNE_THROW(NotImplemented, "geometryInFather only supported for lines!");
            }
        }
 
 
        FoamGridHierarchicIterator<GridImp> hbegin (int maxLevel) const
        { return { target_, maxLevel }; }
 
 
        FoamGridHierarchicIterator<GridImp> hend (int maxLevel) const
        { return { maxLevel }; }
 
 
        // /////////////////////////////////////////
        //   Internal stuff
        // /////////////////////////////////////////
 
 
        void setToTarget(const FoamGridEntityImp<dimgrid, dimgrid, dimworld, ctype>* target)
        {
            target_ = target;
        }
 
        bool equals(const Dune::FoamGridEntity<0, dimgrid, GridImp>& other) const
        {
            return target_ == other.target_;
        }
 
        GeometryType type () const { return target_->type(); }
 
        const FoamGridEntityImp<dimgrid, dimgrid ,dimworld, ctype>* target_;
 
}; // end of FoamGridEntity codim = 0, dimgrid = 1
 
} // namespace Dune
 
 
#endif