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 <vector>
#include <list>
 
#include <dune/common/deprecated.hh>
#include <dune/common/parallel/collectivecommunication.hh>
#include <dune/common/tuples.hh>
 
#include <dune/grid/common/capabilities.hh>
#include <dune/grid/common/grid.hh>
#include <dune/grid/common/gridfactory.hh>
 
#include <dune/geometry/genericgeometry/topologytypes.hh>
 
#include "onedgrid/onedgridlist.hh"
#include "onedgrid/nulliteratorfactory.hh"
#include "onedgrid/onedgridentity.hh"
#include "onedgrid/onedgridentitypointer.hh"
#include "onedgrid/onedgridentityseed.hh"
#include "onedgrid/onedgridgeometry.hh"
#include "onedgrid/onedgridintersections.hh"
#include "onedgrid/onedgridintersectioniterators.hh"
#include "onedgrid/onedgridleveliterator.hh"
#include "onedgrid/onedgridleafiterator.hh"
#include "onedgrid/onedgridhieriterator.hh"
#include "onedgrid/onedgridindexsets.hh"
 
namespace Dune {
 
  class OneDGrid;
 
  template<int dim, int dimw>
  struct OneDGridFamily
  {
    typedef GridTraits<dim,dimw,Dune::OneDGrid,
        OneDGridGeometry,
        OneDGridEntity,
        OneDGridEntityPointer,
        OneDGridLevelIterator,
        OneDGridLeafIntersection,
        OneDGridLevelIntersection,
        OneDGridLeafIntersectionIterator,
        OneDGridLevelIntersectionIterator,
        OneDGridHierarchicIterator,
        OneDGridLeafIterator,
        OneDGridLevelIndexSet<const OneDGrid>,
        OneDGridLeafIndexSet<const OneDGrid>,
        OneDGridIdSet<const OneDGrid>,
        unsigned int,
        OneDGridIdSet<const OneDGrid>,
        unsigned int,
        CollectiveCommunication<Dune::OneDGrid>,
        DefaultLevelGridViewTraits,
        DefaultLeafGridViewTraits,
        OneDGridEntitySeed>
    Traits;
  };
 
  //**********************************************************************
  //
  // --OneDGrid
  //
  //**********************************************************************
 
  class OneDGrid : public GridDefaultImplementation <1, 1,double,OneDGridFamily<1,1> >
  {
    // Grid and world dimension are hardwired in this grid
    enum {dim = 1};
    enum {dimworld = 1};
 
    template <int, class >
    friend class OneDGridEntityPointer;
 
    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;
 
    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 double ctype;
 
    typedef OneDGridFamily<dim,dimworld> GridFamily;
 
    //Provides the standard grid types
    typedef OneDGridFamily<dim,dimworld>::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<int codim>
    typename Traits::template Codim<codim>::LevelIterator lbegin (int level) const;
 
    template<int codim>
    typename Traits::template Codim<codim>::LevelIterator lend (int level) const;
 
    template<int codim, PartitionIteratorType PiType>
    typename Traits::template Codim<codim>::template Partition<PiType>::LevelIterator lbegin (int level) const;
 
    template<int codim, PartitionIteratorType PiType>
    typename Traits::template Codim<codim>::template Partition<PiType>::LevelIterator lend (int level) const;
 
    template<int codim>
    typename Traits::template Codim<codim>::LeafIterator leafbegin () const;
 
    template<int codim>
    typename Traits::template Codim<codim>::LeafIterator leafend () const;
 
    template<int codim, PartitionIteratorType PiType>
    typename Traits::template Codim<codim>::template Partition<PiType>::LeafIterator leafbegin() const;
 
    template<int codim, PartitionIteratorType PiType>
    typename Traits::template Codim<codim>::template Partition<PiType>::LeafIterator leafend() const;
 
    template <typename Seed>
    static typename Traits::template Codim<Seed::codimension>::EntityPointer
    entityPointer(const Seed& seed)
    {
      enum {codim = Seed::codimension};
      return typename Traits::template Codim<codim>::EntityPointer(OneDGridEntityPointer<codim,const OneDGrid>(OneDGrid::getRealImplementation(seed).target()));
    }
 
    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>(OneDGrid::getRealImplementation(seed).target()));
    }
 
 
    int size (int level, int codim) const {
      if (codim<0 || codim>1)
        DUNE_THROW(GridError, "There are no codim " << codim << " entities in a OneDGrid!");
 
      if (codim==0)
        return elements(level).size();
 
      return vertices(level).size();
    }
 
 
 
    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;
    }
 
    int overlapSize(int codim) const {
      return 0;
    }
 
    int ghostSize(int codim) const {
      return 0;
    }
 
    int overlapSize(int level, int codim) const {
      return 0;
    }
 
    int ghostSize(int level, int codim) const {
      return 0;
    }
 
    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
 
    template<class DataHandle>
    void communicate (DataHandle& data, InterfaceType iftype, CommunicationDirection dir, int level) const
    {}
 
    template<class DataHandle>
    void communicate (DataHandle& data, InterfaceType iftype, CommunicationDirection dir) const
    {}
 
    const CollectiveCommunication &comm () const
    {
      return ccobj;
    }
 
 
  private:
 
    OneDGridList<OneDEntityImp<0> >& vertices(int level) {
      return Dune::get<0>(entityImps_[level]);
    }
 
    const OneDGridList<OneDEntityImp<0> >& vertices(int level) const {
      return Dune::get<0>(entityImps_[level]);
    }
 
    OneDGridList<OneDEntityImp<1> >& elements(int level) {
      return Dune::get<1>(entityImps_[level]);
    }
 
    const OneDGridList<OneDEntityImp<1> >& elements(int level) const {
      return Dune::get<1>(entityImps_[level]);
    }
 
    CollectiveCommunication ccobj;
 
    void setIndices();
 
    unsigned int getNextFreeId(int codim) {
      return (codim==0) ? freeElementIdCounter_++ : freeVertexIdCounter_++;
    }
 
    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<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_;
 
    unsigned int freeVertexIdCounter_;
 
    unsigned int freeElementIdCounter_;
 
    bool reversedBoundarySegmentNumbering_;
 
  }; // end Class OneDGrid
 
  namespace Capabilities
  {
    template< >
    struct hasSingleGeometryType< OneDGrid >
    {
      static const bool v = true;
      static const unsigned int topologyId = GenericGeometry :: CubeTopology< 1 > :: type :: id ;
    };
 
 
    template<int cdim>
    struct hasEntity< OneDGrid, cdim >
    {
      static const bool v = true;
    };
 
    template<>
    struct
#ifndef DUNE_AVOID_CAPABILITIES_IS_PARALLEL_DEPRECATION_WARNING
    DUNE_DEPRECATED_MSG("Capabilities::isParallel will be removed after dune-grid-2.4.")
#endif
    isParallel< OneDGrid >
    {
      static const bool
#ifndef DUNE_AVOID_CAPABILITIES_IS_PARALLEL_DEPRECATION_WARNING
      DUNE_DEPRECATED_MSG("Capabilities::isParallel will be removed after dune-grid-2.4.")
#endif
      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