gridglue.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:
// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-GPL-2.0-only-with-dune-grid-glue-exception
#ifndef DUNE_GRIDGLUE_GRIDGLUE_HH
#define DUNE_GRIDGLUE_GRIDGLUE_HH
 
#include <memory>
#include <tuple>
#include <type_traits>
 
#include <dune/common/deprecated.hh>
#include <dune/common/exceptions.hh>
#include <dune/common/iteratorfacades.hh>
#include <dune/common/promotiontraits.hh>
#include <dune/common/shared_ptr.hh>
#include <dune/common/stdstreams.hh>
 
#include "adapter/gridgluecommunicate.hh"
#include <dune/grid-glue/merging/merger.hh>
 
#include <dune/common/parallel/mpitraits.hh>
#include <dune/common/parallel/mpicommunication.hh>
#include <dune/common/parallel/indexset.hh>
#include <dune/common/parallel/plocalindex.hh>
#include <dune/common/parallel/remoteindices.hh>
#include <dune/common/parallel/communicator.hh>
#include <dune/common/parallel/interface.hh>
 
namespace Dune {
namespace GridGlue {
 
// forward declarations
template<typename P0, typename P1>
class GridGlue;
 
template<typename P0, typename P1>
class IntersectionData;
 
template<typename P0, typename P1, int inside, int outside>
class Intersection;
 
template<typename P0, typename P1, int inside, int outside>
class IntersectionIterator;
 
template<typename P0, typename P1>
class IntersectionIndexSet;
 
template<typename P0, typename P1>
class GridGlue
{
private:
 
  /*   F R I E N D S   */
 
  friend class IntersectionData<P0,P1>;
  friend class Intersection<P0,P1,0,1>;
  friend class Intersection<P0,P1,1,0>;
  friend class IntersectionIterator<P0,P1,0,1>;
  friend class IntersectionIterator<P0,P1,1,0>;
  friend class IntersectionIndexSet<P0,P1>;
 
  /*   P R I V A T E   T Y P E S   */
 
  typedef ::Dune::GridGlue::GlobalId GlobalId;
 
  typedef Dune::ParallelLocalIndex <Dune::PartitionType> LocalIndex;
 
  typedef Dune::ParallelIndexSet <GlobalId, LocalIndex> PIndexSet;
 
public:
 
  /*   P U B L I C   T Y P E S   A N D   C O N S T A N T S   */
 
  template<int side>
  using GridPatch = std::conditional_t<side == 0, P0, std::conditional_t<side == 1, P1, void>>;
 
  template<int side>
  using GridView = typename GridPatch<side>::GridView;
 
  template<int side>
  using Grid = typename GridView<side>::Grid;
 
  using Grid0View [[deprecated("please use GridView<0> instead")]] = GridView<0>;
 
  using Grid0 [[deprecated("please use Grid<0> instead")]] = Grid<0>;
 
  using Grid0Patch [[deprecated("please use GridPatch<0> instead")]] = GridPatch<0>;
 
  template<int side>
  static constexpr auto griddim()
    { return GridPatch<side>::dim; }
 
  template<int side>
  static constexpr auto griddimworld()
    { return GridPatch<side>::dimworld; }
 
  [[deprecated("please use griddim<0>() instead")]]
  static constexpr auto grid0dim = griddim<0>();
 
  [[deprecated("please use griddim<0>() instead")]]
  static constexpr auto domdim = griddim<0>();
 
  [[deprecated("please use griddimworld<0>() instead")]]
  static constexpr auto grid0dimworld = griddimworld<0>();
 
  [[deprecated("please use griddimworld<0>() instead")]]
  static constexpr auto domdimworld = griddimworld<0>();
 
  using Grid1View [[deprecated("please use GridView<0> instead")]] = GridView<1>;
 
  using Grid1 [[deprecated("please use Grid<1> instead")]] = Grid<1>;
 
  using Grid1Patch [[deprecated("please use GridPatch<1> instead")]] = GridPatch<1>;
 
  typedef unsigned int IndexType;
 
  [[deprecated("please use griddim<1>() instead")]]
  static constexpr auto grid1dim = griddim<1>();
 
  [[deprecated("please use griddim<1>() instead")]]
  static constexpr auto tardim = griddim<1>();
 
  [[deprecated("please use griddimworld<1>() instead")]]
  static constexpr auto grid1dimworld = griddimworld<1>();
 
  [[deprecated("please use griddimworld<1>() instead")]]
  static constexpr auto tardimworld = griddimworld<1>();
 
  static constexpr int dimworld = (int)griddimworld<0>() > (int)griddimworld<1>() ? (int)griddimworld<0>() : (int)griddimworld<1>();
 
  typedef typename PromotionTraits<typename GridView<0>::ctype,
                                   typename GridView<1>::ctype>::PromotedType ctype;
 
  typedef Dune::FieldVector<ctype, dimworld>                   Coords;
 
  template<int side>
  using GridElement = typename GridView<side>::Traits::template Codim<0>::Entity;
 
  template<int side>
  using GridVertex = typename GridView<side>::Traits::template Codim<Grid<side>::dimension>::Entity;
 
  using Grid0Element [[deprecated("please use GridElement<0> instead")]] = GridElement<0>;
 
  using Grid0Vertex [[deprecated("please use GridVertex<0> instead")]] = GridVertex<0>;
 
  using Grid1Element [[deprecated("please use GridElement<1> instead")]] = GridElement<1>;
 
  using Grid1Vertex [[deprecated("please use GridVertex<1> instead")]] = GridVertex<1>;
 
  typedef Dune::GridGlue::Merger<ctype,
      Grid<0>::dimension - GridPatch<0>::codim,
      Grid<1>::dimension - GridPatch<1>::codim,
      dimworld> Merger;
 
  typedef Dune::GridGlue::Intersection<P0,P1,0,1> Intersection;
 
  typedef Dune::GridGlue::IntersectionIndexSet<P0,P1> IndexSet;
 
  template<int side>
  using IntersectionIterator = Dune::GridGlue::IntersectionIterator<P0, P1, side, (side+1) % 2>;
 
  using Grid0IntersectionIterator [[deprecated("please use IntersectionIterator<0> instead")]] = IntersectionIterator<0>;
 
  using Grid1IntersectionIterator [[deprecated("please use IntersectionIterator<1> instead")]] = IntersectionIterator<1>;
 
private:
 
  /*   M E M B E R   V A R I A B L E S   */
 
  using GridPatches = std::tuple<
      const std::shared_ptr< const GridPatch<0> >,
      const std::shared_ptr< const GridPatch<1> >
    >;
 
  const GridPatches patches_;
 
  const std::shared_ptr<Merger> merger_;
 
  IndexType index__sz = 0;
 
#if HAVE_MPI
  MPI_Comm mpicomm_;
 
  PIndexSet patch0_is_;
 
  PIndexSet patch1_is_;
 
  Dune::RemoteIndices<PIndexSet> remoteIndices_;
#endif // HAVE_MPI
 
  typedef Dune::GridGlue::IntersectionData<P0,P1> IntersectionData;
 
  mutable std::vector<IntersectionData>   intersections_;
 
protected:
 
  void mergePatches(const std::vector<Dune::FieldVector<ctype,dimworld> >& patch0coords,
                    const std::vector<unsigned int>& patch0entities,
                    const std::vector<Dune::GeometryType>& patch0types,
                    const int patch0rank,
                    const std::vector<Dune::FieldVector<ctype,dimworld> >& patch1coords,
                    const std::vector<unsigned int>& patch1entities,
                    const std::vector<Dune::GeometryType>& patch1types,
                    const int patch1rank);
 
 
  template<typename Extractor>
  void extractGrid (const Extractor & extractor,
                    std::vector<Dune::FieldVector<ctype, dimworld> > & coords,
                    std::vector<unsigned int> & faces,
                    std::vector<Dune::GeometryType>& geometryTypes) const;
 
public:
 
  /*   C O N S T R U C T O R S   A N D   D E S T R U C T O R S   */
 
  GridGlue(const std::shared_ptr< const GridPatch<0> >& gp0, const std::shared_ptr< const GridPatch<1> >& gp1, const std::shared_ptr<Merger>& merger);
 
  /*   G E T T E R S   */
 
  template<int P>
  const GridPatch<P>& patch() const
  {
    return *std::get<P>(patches_);
  }
 
  template<int P>
  const GridView<P>& gridView() const
  {
    return std::get<P>(patches_)->gridView();
  }
 
 
  /*   F U N C T I O N A L I T Y   */
 
  void build();
 
  /*   I N T E R S E C T I O N S   A N D   I N T E R S E C T I O N   I T E R A T O R S   */
 
  template<int I = 0>
  IntersectionIterator<I> ibegin() const
  {
    return {this, 0};
  }
 
 
  template<int I = 0>
  IntersectionIterator<I> iend() const
  {
    return {this, index__sz};
  }
 
 
  template<class DataHandleImp, class DataTypeImp>
  void communicate (Dune::GridGlue::CommDataHandle<DataHandleImp,DataTypeImp> & data,
                    Dune::InterfaceType iftype, Dune::CommunicationDirection dir) const;
 
  /*
   * @brief return an IndexSet mapping from Intersection to IndexType
   */
  IndexSet indexSet() const
  {
    return IndexSet(this);
  }
 
#if QUICKHACK_INDEX
  // indexset size
  size_t indexSet_size() const
  {
    return index__sz;
  }
 
#endif
 
  Intersection getIntersection(int i) const
  {
    return Intersection(this, & intersections_[i]);
  }
 
  size_t size() const
  {
    return index__sz;
  }
 
};
 
} // end namespace GridGlue
} // end namespace Dune
 
#include "adapter/rangegenerators.hh"
 
#include "adapter/gridglue.cc"
 
#include "adapter/intersection.hh"
#include "adapter/intersectioniterator.hh"
#include "adapter/intersectionindexset.hh"
 
#endif // DUNE_GRIDGLUE_GRIDGLUE_HH