integratedskeletonlinearform.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_INTEGRATEDSKELETONLINEARFORM_HH
#define DUNE_FUFEM_FORMS_INTEGRATEDSKELETONLINEARFORM_HH
 
#include <cstddef>
#include <type_traits>
#include <utility>
 
#include <dune/common/indices.hh>
#include <dune/common/rangeutilities.hh>
#include <dune/common/stringutility.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>
 
 
 
namespace Dune::Fufem::Forms {
 
 
 
  template<class LinearOperator, class Patch>
  class IntegratedSkeletonLinearForm
  {
    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 CacheManager = typename Dune::Fufem::Forms::CacheManager<double,  LinearOperator::Element::dimension>;
    using QuadratureRule = typename CacheManager::QuadratureRule;
    using QuadraturePoint = typename QuadratureRule::value_type;
 
  public:
    using Element = typename LinearOperator::Element;
    using Intersection = typename TestRootBasis::GridView::Intersection;
 
    IntegratedSkeletonLinearForm(const LinearOperator& sumOperator, const Patch& patch) :
      sumOperator_(sumOperator),
      sumLocalOperator_(localOperator(sumOperator_)),
      sumLocalOperatorFlipped_(localOperator(sumOperator_)),
      patch_(patch)
    {}
 
    const LinearOperator& integrandOperator() const
    {
      return sumOperator_;
    }
 
    // Dune::Assembler interface
 
    void bindLocalView (const TestRootLocalView& testLocalView)
    {
      sumLocalOperator_.registerLocalViews(testLocalView.rootLocalView());
      sumLocalOperator_.registerCaches(insideCache_);
      sumLocalOperatorFlipped_.registerOutsideLocalViews(testLocalView.rootLocalView());
      sumLocalOperatorFlipped_.registerOutsideCaches(insideCache_);
      insidePtr_ = &testLocalView.element();
    }
 
    void bindOutsideLocalView (const TestRootLocalView& testLocalView)
    {
      sumLocalOperator_.registerOutsideLocalViews(testLocalView.rootLocalView());
      sumLocalOperator_.registerOutsideCaches(outsideCache_);
      sumLocalOperatorFlipped_.registerLocalViews(testLocalView.rootLocalView());
      sumLocalOperatorFlipped_.registerCaches(outsideCache_);
      outsidePtr_ = &testLocalView.element();
    }
 
    void bindElement (const Element& element)
    {}
 
    template <class LocalVectors>
    void assembleInteriorIntersectionVector (const Intersection& intersection, LocalVectors& localVectors)
    {
      using namespace Dune::Indices;
      using namespace Dune::Fufem::Forms::Impl::Tensor;
 
      if (not patch_.contains(intersection))
        return;
 
      bool isOriented = true;
      if constexpr (requires { patch_.isOriented(intersection); })
        isOriented = patch_.isOriented(intersection);
 
      // LocalVectors only supports localVectors[i][j] and localVectors[i](j).
      // The TensorView provides the unified access via localTensor(i,j).
      auto localTensor = TensorView(localVectors, _2);
 
      if (isOriented)
      {
        sumLocalOperator_.bind(intersection, *insidePtr_, *outsidePtr_);
 
        const auto& geometry = intersection.geometry();
        const auto& geometryInInside = intersection.geometryInInside();
        const auto& geometryInOutside = intersection.geometryInOutside();
 
        // Since we will often have many boundary terms (e.g. for DG)
        // while evaluations are currently not cached across elements,
        // we use a single quadrature rule for all addends despite the
        // fact that a lower order might also be sufficient for some of them.
        auto key = sumLocalOperator_.quadratureRuleKey();
        key.setGeometryType(geometry.type());
        const auto& rule = QuadratureRuleCache<double, Element::dimension-1>::rule(key);
 
        // Notice that we cannot easily cache evaluation by identifying quadrature rules
        // on intersections across different elements. To guarantee that quadrature
        // points match up on inside and outside, we have to compute the element coordinates
        // of intersection quadrature points using the intersection. This has the effect
        // that the e.g. points on face 2 may be different on two elements because the
        // intersections are not oriented consistently. The latter problem could be solved
        // by computing the element coordinates using the reference element embedding, but
        // then inside and outside quadrature points would not match up.
        //
        // Hence we take the intersection approach (which is also robust wrt. non-conforming
        // intersections) and do not cache across different intersections so far.
        // Since the operator expects a cache, we use caches that are reset for any intersection.
        insideRule_.resize(rule.size(), QuadraturePoint(typename QuadraturePoint::Vector(), 0));
        for (auto k : Dune::range(rule.size()))
          insideRule_[k] = QuadraturePoint(geometryInInside.global(rule[k].position()), 0);
        insideCache_.setRule(insideRule_);
 
        outsideRule_.resize(rule.size(), QuadraturePoint(typename QuadraturePoint::Vector(), 0));
        for (auto k : Dune::range(rule.size()))
          outsideRule_[k] = QuadraturePoint(geometryInOutside.global(rule[k].position()), 0);
        outsideCache_.setRule(outsideRule_);
 
        sumLocalOperator_.bindToCaches(insideCache_, outsideCache_);
 
        for (auto k : Dune::range(rule.size()))
        {
          Impl::forEachTupleEntry(sumLocalOperator_.operators(), [&](auto& op) {
            const auto integrationWeight = rule[k].weight() * geometry.integrationElement(rule[k].position());
            axpy(integrationWeight, op(k), localTensor);
          });
        }
      }
      else
      {
        // If the intersection is not oriented, we need to flip the leading index
        auto flippedLocalTensor = FlipIndices(localTensor, _1);
 
        sumLocalOperatorFlipped_.bind(intersection, *outsidePtr_, *insidePtr_);
 
        const auto& geometry = intersection.geometry();
        const auto& geometryInInside = intersection.geometryInInside();
        const auto& geometryInOutside = intersection.geometryInOutside();
 
        // Since we will often have many boundary terms (e.g. for DG)
        // while evaluations are currently not cached across elements,
        // we use a single quadrature rule for all addends despite the
        // fact that a lower order might also be sufficient for some of them.
        auto key = sumLocalOperatorFlipped_.quadratureRuleKey();
        key.setGeometryType(geometry.type());
        const auto& rule = QuadratureRuleCache<double, Element::dimension-1>::rule(key);
 
        // Notice that we cannot easily cache evaluation by identifying quadrature rules
        // on intersections across different elements. To guarantee that quadrature
        // points match up on inside and outside, we have to compute the element coordinates
        // of intersection quadrature points using the intersection. This has the effect
        // that the e.g. points on face 2 may be different on two elements because the
        // intersections are not oriented consistently. The latter problem could be solved
        // by computing the element coordinates using the reference element embedding, but
        // then inside and outside quadrature points would not match up.
        //
        // Hence we take the intersection approach (which is also robust wrt. non-conforming
        // intersections) and do not cache across different intersections so far.
        // Since the operator expects a cache, we use caches that are reset for any intersection.
        insideRule_.resize(rule.size(), QuadraturePoint(typename QuadraturePoint::Vector(), 0));
        for (auto k : Dune::range(rule.size()))
          insideRule_[k] = QuadraturePoint(geometryInInside.global(rule[k].position()), 0);
        insideCache_.setRule(insideRule_);
 
        outsideRule_.resize(rule.size(), QuadraturePoint(typename QuadraturePoint::Vector(), 0));
        for (auto k : Dune::range(rule.size()))
          outsideRule_[k] = QuadraturePoint(geometryInOutside.global(rule[k].position()), 0);
        outsideCache_.setRule(outsideRule_);
 
        sumLocalOperatorFlipped_.bindToCaches(outsideCache_, insideCache_);
 
        for (auto k : Dune::range(rule.size()))
        {
          Impl::forEachTupleEntry(sumLocalOperatorFlipped_.operators(), [&](auto& op) {
            const auto integrationWeight = rule[k].weight() * geometry.integrationElement(rule[k].position());
            axpy(integrationWeight, op(k), flippedLocalTensor);
          });
        }
      }
 
    }
 
  private:
    const LinearOperator sumOperator_;
    mutable LocalOperator sumLocalOperator_;
    mutable LocalOperator sumLocalOperatorFlipped_;
    const Element* insidePtr_ = nullptr;
    const Element* outsidePtr_ = nullptr;
    mutable QuadratureRule insideRule_;
    mutable QuadratureRule outsideRule_;
    CacheManager insideCache_;
    CacheManager outsideCache_;
    const Patch& patch_;
  };
 
 
 
  template<class LinearOperator, class Patch>
  struct IsLocalAssembler<IntegratedSkeletonLinearForm<LinearOperator, Patch>> : public std::true_type {};
 
 
 
} // namespace Dune::Fufem::Forms
 
 
#endif // DUNE_FUFEM_FORMS_INTEGRATEDSKELETONLINEARFORM_HH