onedgrid.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_ONE_D_GRID_HH
#define DUNE_ONE_D_GRID_HH
 
#include <tuple>
#include <vector>
#include <list>
 
#include <dune/common/parallel/communication.hh>
 
#include <dune/grid/common/capabilities.hh>
#include <dune/grid/common/grid.hh>
#include <dune/grid/common/gridfactory.hh>
 
#include <dune/geometry/axisalignedcubegeometry.hh>
#include <dune/geometry/type.hh>
 
#include "onedgrid/onedgridlist.hh"
#include "onedgrid/nulliteratorfactory.hh"
#include "onedgrid/onedgridentity.hh"
#include "onedgrid/onedgridentityseed.hh"
#include "onedgrid/onedgridintersections.hh"
#include "onedgrid/onedgridintersectioniterators.hh"
#include "onedgrid/onedgridleafiterator.hh"
#include "onedgrid/onedgridviews.hh"
#include "onedgrid/onedgridleveliterator.hh"
#include "onedgrid/onedgridhieriterator.hh"
#include "onedgrid/onedgridindexsets.hh"
 
namespace Dune {
 
  class OneDGrid;
 
  template <int mydim, int coorddim, class GridImp>
  using OneDGridGeometry = AxisAlignedCubeGeometry<double, mydim, coorddim>;
 
  struct OneDGridFamily
  {
    typedef GridTraits<1,   // Grid dimension
                       1,   // Dimension of the physical space
                       Dune::OneDGrid,
        OneDGridGeometry,
        OneDGridEntity,
        OneDGridLevelIterator,
        OneDGridLeafIntersection,
        OneDGridLevelIntersection,
        OneDGridLeafIntersectionIterator,
        OneDGridLevelIntersectionIterator,
        OneDGridHierarchicIterator,
        OneDGridLeafIterator,
        OneDGridLevelIndexSet<const OneDGrid>,
        OneDGridLeafIndexSet<const OneDGrid>,
        OneDGridIdSet<const OneDGrid>,
        unsigned int,
        OneDGridIdSet<const OneDGrid>,
        unsigned int,
        CollectiveCommunication<No_Comm>,
        OneDGridLevelGridViewTraits,
        OneDGridLeafGridViewTraits,
        OneDGridEntitySeed>
    Traits;
  };
 
  //**********************************************************************
  //
  // --OneDGrid
  //
  //**********************************************************************
 
  class OneDGrid : public GridDefaultImplementation <1, 1,typename OneDGridGeometry<0,1,OneDGrid>::ctype, OneDGridFamily>
  {
    // Grid and world dimension are hardwired in this grid
    enum {dim = 1};
    enum {dimworld = 1};
 
    template <int , PartitionIteratorType, class >
    friend class OneDGridLevelIterator;
 
    friend class OneDGridHierarchicIterator<const OneDGrid>;
 
    template <int codim_, int dim_, class GridImp_>
    friend class OneDGridEntity;
    friend class OneDGridHierarchicIterator<OneDGrid>;
    friend class OneDGridLeafIntersection<const OneDGrid>;
    friend class OneDGridLevelIntersection<const OneDGrid>;
    friend class OneDGridLeafIntersectionIterator<const OneDGrid>;
    friend class OneDGridLevelIntersectionIterator<const OneDGrid>;
 
    friend class OneDGridLevelIndexSet<const OneDGrid>;
    friend class OneDGridLeafIndexSet<const OneDGrid>;
    friend class OneDGridIdSet<const OneDGrid>;
 
    template <int codim_, PartitionIteratorType PiType_, class GridImp_>
    friend class OneDGridLeafIterator;
 
    friend class OneDGridLeafGridView<const OneDGrid>;
    friend class OneDGridLevelGridView<const OneDGrid>;
 
    template <class GridType_>
    friend class GridFactory;
 
    template<int codim_, int dim_, class GridImp_, template<int,int,class> class EntityImp_>
    friend class Entity;
 
    OneDGrid();
 
    // **********************************************************
    // The Interface Methods
    // **********************************************************
 
  public:
 
    typedef typename OneDGridGeometry<0,1,OneDGrid>::ctype ctype;
 
    typedef OneDGridFamily GridFamily;
 
    //Provides the standard grid types
    typedef OneDGridFamily::Traits Traits;
 
    OneDGrid(const std::vector<ctype>& coords);
 
    OneDGrid(int numElements, const ctype& leftBoundary, const ctype& rightBoundary);
 
    ~OneDGrid();
 
    int maxLevel() const {return entityImps_.size()-1;}
 
    template <typename Seed>
    static typename Traits::template Codim<Seed::codimension>::Entity
    entity(const Seed& seed)
    {
      const int codim = Seed::codimension;
      return typename Traits::template Codim<codim>::Entity(OneDGridEntity<codim,dim,const OneDGrid>(seed.impl().target()));
    }
 
 
    int size (int level, int codim) const {
      switch (codim)
      {
        case 0:
          return elements(level).size();
        case 1:
          return vertices(level).size();
        default:
          return 0;
      }
    }
 
 
 
    int size (int codim) const
    {
      return leafIndexSet().size(codim);
    }
 
    int size (int level, GeometryType type) const
    {
      // There is only one type for each codim
      return size(level,1-type.dim());
    }
 
    int size (GeometryType type) const
    {
      return leafIndexSet().size(type);
    }
 
    size_t numBoundarySegments() const
    {
      return 2;
    }
 
    const Traits::GlobalIdSet& globalIdSet() const
    {
      return idSet_;
    }
 
    const Traits::LocalIdSet& localIdSet() const
    {
      return idSet_;
    }
 
    const Traits::LevelIndexSet& levelIndexSet(int level) const
    {
      if (! levelIndexSets_[level]) {
        levelIndexSets_[level] =
          new OneDGridLevelIndexSet<const OneDGrid>(*this, level);
        levelIndexSets_[level]->update();
      }
 
      return * levelIndexSets_[level];
    }
 
    const Traits::LeafIndexSet& leafIndexSet() const
    {
      return leafIndexSet_;
    }
 
 
    bool mark(int refCount, const Traits::Codim<0>::Entity& e );
 
    int getMark(const Traits::Codim<0>::Entity& e ) const;
 
    bool preAdapt();
 
    bool adapt();
 
    void postAdapt();
 
    // **********************************************************
    // End of Interface Methods
    // **********************************************************
 
    enum RefinementType {
      LOCAL,
      COPY
    };
 
    void setRefinementType(RefinementType type) {
      refinementType_ = type;
    }
 
    void globalRefine(int refCount);
 
    // dummy parallel functions
 
    const CollectiveCommunication &comm () const
    {
      return ccobj;
    }
 
 
  private:
 
    OneDGridList<OneDEntityImp<0> >& vertices(int level) {
      return std::get<0>(entityImps_[level]);
    }
 
    const OneDGridList<OneDEntityImp<0> >& vertices(int level) const {
      return std::get<0>(entityImps_[level]);
    }
 
    OneDGridList<OneDEntityImp<1> >& elements(int level) {
      return std::get<1>(entityImps_[level]);
    }
 
    const OneDGridList<OneDEntityImp<1> >& elements(int level) const {
      return std::get<1>(entityImps_[level]);
    }
 
    CollectiveCommunication ccobj;
 
    void setIndices();
 
    unsigned int getNextFreeId()
    {
      return freeIdCounter_++;
    }
 
    RefinementType refinementType_;
 
    OneDGridList<OneDEntityImp<0> >::iterator getLeftUpperVertex(const OneDEntityImp<1>* eIt);
 
    OneDGridList<OneDEntityImp<0> >::iterator getRightUpperVertex(const OneDEntityImp<1>* eIt);
 
    OneDGridList<OneDEntityImp<1> >::iterator getLeftNeighborWithSon(OneDGridList<OneDEntityImp<1> >::iterator eIt);
 
    // The vertices and elements of the grid hierarchy
    std::vector<std::tuple<OneDGridList<OneDEntityImp<0> >,
            OneDGridList<OneDEntityImp<1> > > > entityImps_;
 
    // Our set of level indices
    mutable std::vector<OneDGridLevelIndexSet<const OneDGrid>* > levelIndexSets_;
 
    OneDGridLeafIndexSet<const OneDGrid> leafIndexSet_;
 
    OneDGridIdSet<const OneDGrid> idSet_;
 
    // Every entity gets a unique id, unless it is a copy of an entity on a coarser level.
    // This is the counter that we use to create the unique id.
    unsigned int freeIdCounter_;
 
    bool reversedBoundarySegmentNumbering_;
 
  }; // end Class OneDGrid
 
  namespace Capabilities
  {
    template< >
    struct hasSingleGeometryType< OneDGrid >
    {
      static const bool v = true;
      static const unsigned int topologyId = GeometryTypes::cube(1).id();
    };
 
 
    template<int cdim>
    struct hasEntity< OneDGrid, cdim >
    {
      static const bool v = true;
    };
 
    template<int codim>
    struct hasEntityIterator<OneDGrid, codim>
    {
      static const bool v = false;
    };
 
    template<>
    struct isLevelwiseConforming< OneDGrid >
    {
      static const bool v = true;
    };
 
    template<>
    struct isLeafwiseConforming< OneDGrid >
    {
      static const bool v = true;
    };
 
  }
 
} // namespace Dune
 
// Include the GridFactory specialization for OneDGrid, so everybody
// who includes the grid also gets the factory.  Since OneDGrid is
// not a template class, it needs to be a complete type before
// GridFactory<OneDGrid> can be defined.  This is why the #include-
// directive is at _the end_ of this file.
#include <dune/grid/onedgrid/onedgridfactory.hh>
 
 
#endif