onedgrid.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
// -*- 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,
        Communication<No_Comm>,
        OneDGridLevelGridViewTraits,
        OneDGridLeafGridViewTraits,
        OneDGridEntitySeed,
        OneDGridGeometry,
        unsigned int,
        std::array<GeometryType,1> >
    Traits;
  };

  //**********************************************************************
  //
  // --OneDGrid
  //
  //**********************************************************************

  class OneDGrid : public GridDefaultImplementation <1, 1,typename OneDGridGeometry<0,1,OneDGrid>::ctype, OneDGridFamily>
  {
    // Grid and world dimension are hardwired in this grid
    constexpr static int dim = 1;
    constexpr static int 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 Communication &comm () const
    {
      return ccobj;
    }


    template <class DataHandle>
    void communicate (DataHandle& /*handle*/, InterfaceType /*iftype*/,
                      CommunicationDirection /*dir*/, int /*level*/) const
    {
      DUNE_THROW(Dune::NotImplemented, "communicate() for OneDGrid not implemented");
    }

    template <class DataHandle>
    void communicate (DataHandle& /*handle*/, InterfaceType /*iftype*/,
                      CommunicationDirection /*dir*/) const
    {
      DUNE_THROW(Dune::NotImplemented, "communicate() for OneDGrid not implemented");
    }


  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]);
    }

    Communication 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 = true;
    };

    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