integratedboundarylinearform.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-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_FORMS_INTEGRATEDBOUNDARYLINEARFORM_HH
#define DUNE_FUFEM_FORMS_INTEGRATEDBOUNDARYLINEARFORM_HH
 
#include <cstddef>
#include <type_traits>
#include <utility>
 
#include <dune/common/indices.hh>
#include <dune/common/rangeutilities.hh>
 
#include <dune/fufem/forms/shapefunctioncache.hh>
#include <dune/fufem/forms/baseclass.hh>
#include <dune/fufem/forms/tensors.hh>
#include <dune/fufem/forms/localsumassembler.hh>
#include <dune/fufem/forms/quadraturehints.hh>
 
 
 
namespace Dune::Fufem::Forms {
 
 
 
  template<class LinearOperator, class Domain, class QuadratureHint=Dune::Fufem::Forms::QuadratureHints::KeepOrder>
  class IntegratedBoundaryLinearForm
  {
    using TestRootBasis = std::decay_t<decltype(std::get<0>(std::declval<LinearOperator>().basis()))>;
    using TestRootLocalView = typename TestRootBasis::LocalView;
    using TestRootTree = typename TestRootLocalView::Tree;
 
    using LocalOperator = decltype(localOperator(std::declval<LinearOperator>()));
 
    using FacetKey = typename MultipleQuadratureCacheManager<double, LinearOperator::Element::dimension>::FacetKey;
 
  public:
 
    using Element = typename LocalOperator::Element;
    using Intersection = typename LocalOperator::Intersection;
 
    IntegratedBoundaryLinearForm(const LinearOperator& sumOperator, const Domain& domain, QuadratureHint quadratureHint)
      : sumOperator_(sumOperator)
      , sumLocalOperator_(localOperator(sumOperator_))
      , domain_(domain)
      , quadratureHint_(quadratureHint)
    {}
 
    IntegratedBoundaryLinearForm(const LinearOperator& sumOperator, const Domain& domain)
    requires (std::is_default_constructible_v<QuadratureHint>)
      : IntegratedBoundaryLinearForm(sumOperator, domain, QuadratureHint{})
    {}
 
    const LinearOperator& integrandOperator() const
    {
      return sumOperator_;
    }
 
    // Dune::Assembler interface
 
    void bindLocalView(const TestRootLocalView& testLocalView)
    {
      cacheManager_.clear();
      sumLocalOperator_.registerLocalViews(testLocalView.rootLocalView());
      sumLocalOperator_.registerCaches(cacheManager_.prototype());
      insidePtr_ = &testLocalView.element();
    }
 
    void bindElement (const Element& element)
    {}
 
    template<class LocalVector>
    void assembleBoundaryIntersectionVector(const Intersection& intersection, LocalVector& localVector)
    {
      using namespace Dune::Indices;
      using namespace Dune::Fufem::Forms::Impl::Tensor;
 
      if (not domain_.contains(intersection))
        return;
 
      sumLocalOperator_.bind(intersection, *insidePtr_, *insidePtr_);
 
      auto facet = intersection.indexInInside();
 
      const auto& geometry = intersection.geometry();
 
      Impl::forEachTupleEntry(sumLocalOperator_.operators(), [&](auto& op) {
        cacheManager_[FacetKey(quadratureHint_(op.quadratureRuleKey()), facet)].invalidate();
      });
 
      // Lift rank by 1 to prepend zero index for inside
      auto localTensor = LiftRank(TensorView(localVector, _1), _1);
 
      Impl::forEachTupleEntry(sumLocalOperator_.operators(), [&](auto& op) {
        auto& cacheForRule = cacheManager_[FacetKey(quadratureHint_(op.quadratureRuleKey()), facet)];
        op.bindToCaches(cacheForRule);
        const auto& quadRule = cacheForRule.rule();
        for (auto k : Dune::range(quadRule.size()))
        {
          const auto& quadPoint = quadRule[k];
          auto quadPointPositionInFacet = intersection.geometryInInside().local(quadPoint.position());
          const auto integrationWeight = quadPoint.weight() * geometry.integrationElement(quadPointPositionInFacet);
          axpy(integrationWeight, op(k), localTensor);
        }
      });
    }
 
    // Dune::Fufem interface
 
    template<class TestLocalView>
    void preprocess(const TestLocalView& testLocalView)
    {
      cacheManager_.clear();
      sumLocalOperator_.registerLocalViews(testLocalView.rootLocalView());
      sumLocalOperator_.registerCaches(cacheManager_.prototype());
      insidePtr_ = &testLocalView.element();
    }
 
    template<class LocalVector, class TestLocalView>
    void operator()(const Element& element, LocalVector& localVector, const TestLocalView& testSubspaceLocalView)
    {
      bool processElement = true;
      if constexpr (requires{domain_.containsFaceOf(element);})
        processElement = domain_.containsFaceOf(element);
      if (processElement)
      {
        bindElement(element);
        const auto& gridView = testSubspaceLocalView.globalBasis().rootBasis().gridView();
        for(const auto& intersection : intersections(gridView, element))
          if (intersection.boundary() && !intersection.neighbor())
            assembleBoundaryIntersectionVector(intersection, localVector);
      }
    }
 
  private:
    const LinearOperator sumOperator_;
    LocalOperator sumLocalOperator_;
    const Element* insidePtr_ = nullptr;
    MultipleQuadratureCacheManager<double, Element::dimension> cacheManager_;
    const Domain& domain_;
    QuadratureHint quadratureHint_;
  };
 
  template<class LinearOperator, class Domain>
  IntegratedBoundaryLinearForm(const LinearOperator&, const Domain&) -> IntegratedBoundaryLinearForm<LinearOperator, Domain>;
 
 
 
  template<class LinearOperator, class Domain, class QuadratureHint>
  struct IsLocalAssembler<IntegratedBoundaryLinearForm<LinearOperator, Domain, QuadratureHint>> : public std::true_type {};
 
 
 
} // namespace Dune::Fufem::Forms
 
 
#endif // DUNE_FUFEM_FORMS_INTEGRATEDBOUNDARYLINEARFORM_HH