foamgridvertex.hh

// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set ts=8 sw=4 et sts=4:
#ifndef DUNE_FOAMGRID_VERTEX_HH
#define DUNE_FOAMGRID_VERTEX_HH
 
#include <dune/common/fvector.hh>
#include <dune/geometry/type.hh>
#include <dune/grid/common/gridenums.hh>
#include <dune/grid/common/exceptions.hh>
 
 
namespace Dune {
 
    class FoamGridEntityBase
    {
    public:
        FoamGridEntityBase(int level, unsigned int id)
            : level_(level), id_(id), willVanish_()
        {}
 
        int level() const {
            return level_;
        }
 
        int level_;
 
        unsigned int levelIndex_;
 
        unsigned int leafIndex_;
 
        unsigned int id_;
        bool willVanish_;
    };
 
    template <int dimentity, int dimgrid, int dimworld, class ctype>
    class FoamGridEntityImp {};
 
    template <int dimgrid, int dimworld, class ctype>
    class FoamGridEntityImp<0, dimgrid, dimworld, ctype>
        : public FoamGridEntityBase
    {
    public:
 
        FoamGridEntityImp(int level, const FieldVector<ctype, dimworld>& pos, unsigned int id)
            : FoamGridEntityBase(level, id), pos_(pos), nSons_(0)
            , elements_(), vertex_{{this}}, father_(nullptr), isNew_(false)
            , growthInsertionIndex_(-1)
        {
            sons_[0] = nullptr;
        }
 
        bool isLeaf() const {
            return sons_[0]==nullptr;
        }
 
        GeometryType type() const {
            return GeometryTypes::vertex;
        }
 
        bool hasFather() const
        {
            return father_!=nullptr;
        }
 
        unsigned int boundarySegmentIndex() const {
            return boundarySegmentIndex_;
        }
 
        unsigned int boundaryId() const {
            return boundaryId_;
        }
 
        int corners() const {
            return 1;
        }
 
        FieldVector<ctype, dimworld> corner(int i) const {
            assert(i<this->corners());
            return pos_;
        }
 
        PartitionType partitionType() const {
            return InteriorEntity;
        }
 
        int subLevelIndex (int i, unsigned int codim) const {
            assert(codim==dimgrid);
            return this->levelIndex_;
            DUNE_THROW(GridError, "Non-existing codimension requested!");
        }
 
        int subLeafIndex (int i, unsigned int codim) const {
            assert(codim==dimgrid);
            return this->leafIndex_;
            DUNE_THROW(GridError, "Non-existing codimension requested!");
        }
 
        FieldVector<ctype, dimworld> pos_;
 
        unsigned int nSons_;
 
        std::vector<const FoamGridEntityImp<dimgrid, dimgrid ,dimworld, ctype>*> elements_;
 
        std::array<const FoamGridEntityImp<0, dimgrid ,dimworld, ctype>*, 1> vertex_;
 
        //  only used if the vertex is a boundary vertex
        unsigned int boundarySegmentIndex_;
        unsigned int boundaryId_;
 
        FoamGridEntityImp<0, dimgrid, dimworld, ctype>* father_;
 
        std::array<FoamGridEntityImp<0, dimgrid, dimworld, ctype>*, 1> sons_;
 
        bool isNew_;
 
        int growthInsertionIndex_;
    };
 
}
 
#endif