domains/boundarypatch.hh

Go to the documentation of this file.

// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set ts=8 sw=2 et sts=2:
 
// SPDX-FileCopyrightText: Copyright © DUNE-FUFEM Project contributors, see file AUTHORS.md
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception OR LGPL-3.0-or-later
 
#ifndef DUNE_FUFEM_DOMAINS_BOUNDARYPATCH_HH
#define DUNE_FUFEM_DOMAINS_BOUNDARYPATCH_HH
 
#include <cstddef>
#include <optional>
 
#include <dune/common/bitsetvector.hh>
#include <dune/common/rangeutilities.hh>
 
#include <dune/geometry/referenceelements.hh>
 
#include <dune/grid/common/mcmgmapper.hh>
 
#include <dune/fufem/domains/intersectionsetiterator.hh>
 
 
 
namespace Dune::Fufem {
 
 
 
template <class GV>
class BoundaryPatch
{
protected:
 
  static const int dim = GV::dimension;
 
  using Element = typename GV::template Codim<0>::Entity;
  using Intersection = typename GV::Intersection;
  using Mapper = typename Dune::MultipleCodimMultipleGeomTypeMapper<GV>;
 
public:
 
  using GridView = GV;
 
  using iterator = Dune::Fufem::IntersectionSetIterator<BoundaryPatch>;
 
  BoundaryPatch (const GridView& gridView)
  {
    setGridView(gridView);
  }
 
  BoundaryPatch () = default;
 
  BoundaryPatch (const BoundaryPatch&) = default;
 
  BoundaryPatch (BoundaryPatch&&) = default;
 
  BoundaryPatch& operator= (const BoundaryPatch&) = default;
 
  BoundaryPatch& operator= (BoundaryPatch&&) = default;
 
  void setGridView (const GridView& gridView)
  {
    gridView_ = gridView;
    mapper_ = Mapper(this->gridView(), Dune::mcmgLayout(Dune::Codim<1>()));
    faces_.resize(mapper_->size());
    faces_.unsetAll();
  }
 
  void clear ()
  {
    faces_.unsetAll();
  }
 
  void insertFace (const Element& element, int faceIndex)
  {
    this->faces_[mapper_->subIndex(element, faceIndex, 1)] = true;
  }
 
  void insertFace (const Intersection& intersection)
  {
    insertFace(intersection.inside(), intersection.indexInInside());
  }
 
  iterator begin () const
  {
    return iterator(*this, gridView().template begin<0>());
  }
 
  iterator end () const
  {
    return iterator(*this, gridView().template end<0>());
  }
 
  std::size_t size () const
  {
    return faces_.count();
  }
 
  bool contains (const Element& element, int faceIndex) const
  {
    return this->faces_[mapper_->subIndex(element, faceIndex, 1)][0];
  }
 
  template <class IntersectionType>
  bool contains (const IntersectionType& intersection) const
  {
    return contains(intersection.inside(), intersection.indexInInside());
  }
 
  bool contains (const Element& element, int subEntity, int codim) const
  {
    if (codim==0)      // disregard element dofs
      return false;
    if (codim==1)
      return contains(element, subEntity);
    const auto& referenceElement = Dune::referenceElement(element);
    for (int faceIndex : Dune::range(element.subEntities(1)))
      if (contains(element, faceIndex))
        for (int k : referenceElement.subEntities(faceIndex, 1, codim))
          if (k == subEntity)
            return true;
    return false;
  }
 
  bool containsFaceOf (const Element& e) const
  {
    if (gridView().contains(e))
      for (int faceIndex : Dune::range(e.subEntities(1)))
        if (contains(e, faceIndex))
          return true;
    return false;
  }
 
  const GridView& gridView () const
  {
    return *gridView_;
  }
 
  bool isInitialized () const
  {
    return gridView_.has_value();
  }
 
  bool operator== (const BoundaryPatch& other) const
  {
    // There is no BitSetVector::operator==
    if (faces_.size() != other.faces_.size())
      return false;
    for (auto i : Dune::range(faces_.size()))
      if (faces_[i] != other.faces_[i])
        return false;
    return true;
  }
 
protected:
 
  Dune::BitSetVector<1> faces_;
  std::optional<GridView> gridView_;
  std::optional<Mapper> mapper_;
};
 
} // namespace Dune::Fufem
 
 
 
#endif // DUNE_FUFEM_DOMAINS_BOUNDARYPATCH_HH