integratedlinearform.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_INTEGRATEDLINEARFORM_HH
#define DUNE_FUFEM_FORMS_INTEGRATEDLINEARFORM_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/domains.hh>
#include <dune/fufem/forms/localsumassembler.hh>
#include <dune/fufem/forms/quadraturehints.hh>
 
 
 
namespace Dune::Fufem::Forms {
 
 
 
  template<class LinearOperator, class Domain=Dune::Fufem::Forms::Bulk, class QuadratureHint=Dune::Fufem::Forms::QuadratureHints::KeepOrder>
  class IntegratedLinearForm
  {
    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>()));
 
  public:
    using Element = typename LinearOperator::Element;
 
    IntegratedLinearForm(const LinearOperator& sumOperator, const Domain& domain, QuadratureHint quadratureHint)
      : sumOperator_(sumOperator)
      , sumLocalOperator_(localOperator(sumOperator_))
      , domain_(domain)
      , quadratureHint_(quadratureHint)
    {}
 
    IntegratedLinearForm(const LinearOperator& sumOperator, const Domain& domain)
    requires (std::is_default_constructible_v<QuadratureHint>)
      : IntegratedLinearForm(sumOperator, domain, QuadratureHint{})
    {}
 
    IntegratedLinearForm(const LinearOperator& sumOperator, QuadratureHint quadratureHint)
    requires std::is_same_v<Domain, Dune::Fufem::Forms::Bulk>
      : IntegratedLinearForm(sumOperator, Dune::Fufem::Forms::bulk, quadratureHint)
    {}
 
    IntegratedLinearForm(const LinearOperator& sumOperator)
    requires (std::is_same_v<Domain, Dune::Fufem::Forms::Bulk> and std::is_default_constructible_v<QuadratureHint>)
      : IntegratedLinearForm(sumOperator, Dune::Fufem::Forms::bulk, 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());
    }
 
    void bindElement (const Element& element)
    {}
 
    template <class LocalVector>
    void assembleElementVector (const Element& element, LocalVector& localVector)
    {
      using namespace Dune::Indices;
      using namespace Dune::Fufem::Forms::Impl::Tensor;
 
      if (not domain_.contains(element))
        return;
      sumLocalOperator_.bind(element);
 
      const auto& geometry = element.geometry();
 
      Impl::forEachTupleEntry(sumLocalOperator_.operators(), [&](auto& op) {
        cacheManager_[op.quadratureRuleKey()].invalidate();
        cacheManager_[quadratureHint_(op.quadratureRuleKey())].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_[quadratureHint_(op.quadratureRuleKey())];
        op.bindToCaches(cacheForRule);
        const auto& quadRule = cacheForRule.rule();
        for (auto k : Dune::range(quadRule.size()))
        {
          const auto& quadPoint = quadRule[k];
          const auto integrationWeight = quadPoint.weight() * geometry.integrationElement(quadPoint.position());
          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());
    }
 
    template<class LocalVector, class TestLocalView>
    void operator()(const Element& element, LocalVector& localVector, const TestLocalView& testSubspaceLocalView)
    {
      bindElement(element);
      assembleElementVector(element, localVector);
    }
 
  private:
    const LinearOperator sumOperator_;
    LocalOperator sumLocalOperator_;
    MultipleQuadratureCacheManager<double, Element::dimension> cacheManager_;
    const Domain& domain_;
    QuadratureHint quadratureHint_;
  };
 
  template<class LinearOperator, class Domain>
  IntegratedLinearForm(const LinearOperator&, const Domain&) -> IntegratedLinearForm<LinearOperator, Domain>;
 
 
 
  template<class LinearOperator, class Domain, class QuadratureHint>
  struct IsLocalAssembler<IntegratedLinearForm<LinearOperator, Domain, QuadratureHint>> : public std::true_type {};
 
 
 
} // namespace Dune::Fufem::Forms
 
 
#endif // DUNE_FUFEM_FORMS_INTEGRATEDLINEARFORM_HH