localsumassembler.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_LOCALSUMASSEMBLER_HH
#define DUNE_FUFEM_FORMS_LOCALSUMASSEMBLER_HH
 
#include <type_traits>
#include <tuple>
#include <utility>
 
#include <dune/common/std/type_traits.hh>
 
#include <dune/assembler/assemblerconcepts.hh>
 
#include <dune/fufem/forms/baseclass.hh>
 
 
namespace Dune::Fufem::Forms {
 
  namespace Impl {
 
    template <class LocalAssembler, class Element>
    concept HasAssembleElementMatrix =
      requires(LocalAssembler la, Element e, Dune::Assembler::Concepts::Archetypes::Matrix& localMatrix, Dune::Assembler::Concepts::Archetypes::LocalMatrixPattern& localPattern)
    {
      la.assembleElementMatrix(e,localMatrix);
      la.assembleElementMatrixPattern(e,localPattern);
    };
 
    template <class LocalAssembler, class Intersection>
    concept HasAssembleBoundaryIntersectionMatrix =
      requires(LocalAssembler la, Intersection is, Dune::Assembler::Concepts::Archetypes::Matrix& localMatrix, Dune::Assembler::Concepts::Archetypes::LocalMatrixPattern& localPattern)
    {
      la.assembleBoundaryIntersectionMatrix(is, localMatrix);
      la.assembleBoundaryIntersectionMatrixPattern(is, localPattern);
    };
 
    template <class LocalAssembler, class Intersection>
    concept HasAssembleInteriorIntersectionMatrix =
      requires(
        LocalAssembler la,
        Intersection is,
        std::array<std::array<Dune::Assembler::Concepts::Archetypes::Matrix, 2>, 2> localMatrix,
        std::array<std::array<Dune::Assembler::Concepts::Archetypes::LocalMatrixPattern, 2>, 2> localPattern
      )
    {
      la.assembleInteriorIntersectionMatrix(is, localMatrix);
      la.assembleInteriorIntersectionMatrixPattern(is, localPattern);
    };
 
    template <class LocalAssembler, class Element>
    concept HasAssembleElementVector =
      requires(LocalAssembler la, Element e, Dune::Assembler::Concepts::Archetypes::Vector& localVector)
    {
      la.assembleElementVector(e, localVector);
    };
 
    template <class LocalAssembler, class Intersection>
    concept HasAssembleBoundaryIntersectionVector =
      requires(LocalAssembler la, Intersection is, Dune::Assembler::Concepts::Archetypes::Vector& localVector)
    {
      la.assembleBoundaryIntersectionVector(is, localVector);
    };
 
    template <class LocalAssembler, class Intersection>
    concept HasAssembleInteriorIntersectionVector =
      requires(LocalAssembler la, Intersection is, Dune::Assembler::Concepts::Archetypes::Vector& localVector)
     {
      la.assembleInteriorIntersectionVector(is, localVector);
     };
 
  }
 
 
 
  template<class T>
  struct IsLocalAssembler : public std::false_type {};
 
 
 
  template<class... LocalAssemblers>
  class LocalSumAssembler
  {
 
    // SFINAE expression check for preprocess() method of local assembler
    template <class LocalAssembler, class TestLocalView, class AnsatzLocalView>
    using LocalAssemblerBinaryPreprocess = decltype(std::declval<LocalAssembler>().preprocess(std::declval<TestLocalView>(), std::declval<AnsatzLocalView>()));
 
    // SFINAE expression check for preprocess() method of local assembler
    template <class LocalAssembler, class TestLocalView>
    using LocalAssemblerUnaryPreprocess = decltype(std::declval<LocalAssembler>().preprocess(std::declval<TestLocalView>()));
 
  public:
 
    LocalSumAssembler(const LocalAssemblers&... localAssemblers) :
      localAssemblers_(localAssemblers...)
    {}
 
    // Dune::Assembler assembler interface
 
    template<class Element>
    void bindElement (const Element& element)
    {
      Impl::forEachTupleEntry(localAssemblers_, [&](auto& localAssembler) {
        localAssembler.bindElement(element);
      });
    }
 
    // Dune::Assembler matrix-assembler interface
 
    template<class TestRootLocalView, class AnsatzRootLocalView>
    void bindLocalViews (const TestRootLocalView& testLocalView, const AnsatzRootLocalView& ansatzLocalView)
      requires (Dune::Assembler::Concepts::BindableToLocalViews<LocalAssemblers, TestRootLocalView, AnsatzRootLocalView> || ...)
    {
      Impl::forEachTupleEntry(localAssemblers_, [&](auto& localAssembler) {
        using LocalAssembler = std::decay_t<decltype(localAssembler)>;
        if constexpr (Dune::Assembler::Concepts::BindableToLocalViews<LocalAssembler, TestRootLocalView, AnsatzRootLocalView>)
          localAssembler.bindLocalViews(testLocalView, ansatzLocalView);
      });
    }
 
    template<class TestRootLocalView, class AnsatzRootLocalView>
    void bindOutsideLocalViews (const TestRootLocalView& testLocalView, const AnsatzRootLocalView& ansatzLocalView)
      requires (Dune::Assembler::Concepts::BindableToOutsideLocalViews<LocalAssemblers, TestRootLocalView, AnsatzRootLocalView> || ...)
    {
      Impl::forEachTupleEntry(localAssemblers_, [&](auto& localAssembler) {
        using LocalAssembler = std::decay_t<decltype(localAssembler)>;
        if constexpr (Dune::Assembler::Concepts::BindableToOutsideLocalViews<LocalAssembler, TestRootLocalView, AnsatzRootLocalView>)
          localAssembler.bindOutsideLocalViews(testLocalView, ansatzLocalView);
      });
    }
 
    template<class Element, class LocalMatrix>
    void assembleElementMatrix (const Element& element, LocalMatrix& localMatrix)
      requires (Impl::HasAssembleElementMatrix<LocalAssemblers, Element> || ...)
    {
      Impl::forEachTupleEntry(localAssemblers_, [&](auto& localAssembler) {
        using LocalAssembler = std::decay_t<decltype(localAssembler)>;
        if constexpr (Impl::HasAssembleElementMatrix<LocalAssembler, Element>)
          localAssembler.assembleElementMatrix(element, localMatrix);
      });
    }
 
    template<class Element, class LocalPattern>
    void assembleElementMatrixPattern(const Element& element, LocalPattern& localPattern)
      requires (Impl::HasAssembleElementMatrix<LocalAssemblers, Element> || ...)
    {
      Impl::forEachTupleEntry(localAssemblers_, [&](auto& localAssembler) {
        using LocalAssembler = std::decay_t<decltype(localAssembler)>;
        if constexpr (Impl::HasAssembleElementMatrix<LocalAssembler, Element>)
          localAssembler.assembleElementMatrixPattern(element, localPattern);
      });
    }
 
    template<class Intersection, class LocalMatrix>
    void assembleBoundaryIntersectionMatrix(const Intersection& intersection, LocalMatrix& localMatrix)
      requires (Impl::HasAssembleBoundaryIntersectionMatrix<LocalAssemblers, Intersection> || ...)
    {
      Impl::forEachTupleEntry(localAssemblers_, [&](auto& localAssembler) {
        using LocalAssembler = std::decay_t<decltype(localAssembler)>;
        if constexpr (Impl::HasAssembleBoundaryIntersectionMatrix<LocalAssembler, Intersection>)
          localAssembler.assembleBoundaryIntersectionMatrix(intersection, localMatrix);
      });
    }
 
    template<class Intersection, class LocalPattern>
    void assembleBoundaryIntersectionMatrixPattern(const Intersection& intersection, LocalPattern& localPattern)
      requires (Impl::HasAssembleBoundaryIntersectionMatrix<LocalAssemblers, Intersection> || ...)
    {
      Impl::forEachTupleEntry(localAssemblers_, [&](auto& localAssembler) {
        using LocalAssembler = std::decay_t<decltype(localAssembler)>;
        if constexpr (Impl::HasAssembleBoundaryIntersectionMatrix<LocalAssembler, Intersection>)
          localAssembler.assembleBoundaryIntersectionMatrixPattern(intersection, localPattern);
      });
    }
 
    template<class Intersection, class LocalMatrix>
    void assembleInteriorIntersectionMatrix(const Intersection& intersection, LocalMatrix& localMatrix)
      requires (Impl::HasAssembleInteriorIntersectionMatrix<LocalAssemblers, Intersection> || ...)
    {
      Impl::forEachTupleEntry(localAssemblers_, [&](auto& localAssembler) {
        using LocalAssembler = std::decay_t<decltype(localAssembler)>;
        if constexpr (Impl::HasAssembleInteriorIntersectionMatrix<LocalAssembler, Intersection>)
          localAssembler.assembleInteriorIntersectionMatrix(intersection, localMatrix);
      });
    }
 
    template<class Intersection, class LocalPattern>
    void assembleInteriorIntersectionMatrixPattern(const Intersection& intersection, LocalPattern& localPattern)
      requires (Impl::HasAssembleInteriorIntersectionMatrix<LocalAssemblers, Intersection> || ...)
    {
      Impl::forEachTupleEntry(localAssemblers_, [&](auto& localAssembler) {
        using LocalAssembler = std::decay_t<decltype(localAssembler)>;
        if constexpr (Impl::HasAssembleInteriorIntersectionMatrix<LocalAssembler, Intersection>)
          localAssembler.assembleInteriorIntersectionMatrixPattern(intersection, localPattern);
      });
    }
 
    // Dune::Assembler vector-assembler interface
 
    template<class TestRootLocalView>
    void bindLocalView (const TestRootLocalView& testLocalView)
      requires (Dune::Assembler::Concepts::BindableToLocalView<LocalAssemblers, TestRootLocalView> || ...)
    {
      Impl::forEachTupleEntry(localAssemblers_, [&](auto& localAssembler) {
        using LocalAssembler = std::decay_t<decltype(localAssembler)>;
        if constexpr (Dune::Assembler::Concepts::BindableToLocalView<LocalAssembler, TestRootLocalView>)
          localAssembler.bindLocalView(testLocalView);
      });
    }
 
    template<class AnsatzRootLocalView>
    void bindOutsideLocalView (const AnsatzRootLocalView& ansatzLocalView)
      requires (Dune::Assembler::Concepts::BindableToOutsideLocalView<LocalAssemblers, AnsatzRootLocalView> || ...)
    {
      Impl::forEachTupleEntry(localAssemblers_, [&](auto& localAssembler) {
        using LocalAssembler = std::decay_t<decltype(localAssembler)>;
        if constexpr (Dune::Assembler::Concepts::BindableToOutsideLocalView<LocalAssembler, AnsatzRootLocalView>)
          localAssembler.bindOutsideLocalView(ansatzLocalView);
      });
    }
 
    template<class Element, class LocalVector>
    void assembleElementVector (const Element& element, LocalVector& localVector)
      requires (Impl::HasAssembleElementVector<LocalAssemblers, Element> || ...)
    {
      Impl::forEachTupleEntry(localAssemblers_, [&](auto& localAssembler) {
        using LocalAssembler = std::decay_t<decltype(localAssembler)>;
        if constexpr (Impl::HasAssembleElementVector<LocalAssembler, Element>)
          localAssembler.assembleElementVector(element, localVector);
      });
    }
 
    template<class Intersection, class LocalVector>
    void assembleBoundaryIntersectionVector(const Intersection& intersection, LocalVector& localVector)
      requires (Impl::HasAssembleBoundaryIntersectionVector<LocalAssemblers, Intersection> || ...)
    {
      Impl::forEachTupleEntry(localAssemblers_, [&](auto& localAssembler) {
        using LocalAssembler = std::decay_t<decltype(localAssembler)>;
        if constexpr (Impl::HasAssembleBoundaryIntersectionVector<LocalAssembler, Intersection>)
          localAssembler.assembleBoundaryIntersectionVector(intersection, localVector);
      });
    }
 
    template <class Intersection, class LocalVector>
    void assembleInteriorIntersectionVector(const Intersection &intersection, LocalVector &localVector)
      requires(Impl::HasAssembleInteriorIntersectionVector<LocalAssemblers, Intersection> || ...)
    {
      Impl::forEachTupleEntry(localAssemblers_, [&](auto& localAssembler) {
        using LocalAssembler = std::decay_t<decltype(localAssembler)>;
        if constexpr (Impl::HasAssembleInteriorIntersectionVector<LocalAssembler, Intersection>)
          localAssembler.assembleInteriorIntersectionVector(intersection, localVector);
      });
    }
 
    // Old Dune::Fufem matrix-assember interface
 
    template<class TestLocalView, class AnsatzLocalView>
    void preprocess(const TestLocalView& testLocalView, const AnsatzLocalView& ansatzLocalView)
    {
      Impl::forEachTupleEntry(localAssemblers_, [&](auto& localAssembler) {
        if constexpr(Dune::Std::is_detected_v<LocalAssemblerBinaryPreprocess, std::decay_t<decltype(localAssembler)>, TestLocalView, AnsatzLocalView>)
          localAssembler.preprocess(testLocalView, ansatzLocalView);
      });
    }
 
    template<class LocalContext, class LocalMatrix, class TestLocalView, class AnsatzLocalView>
    void operator()(const LocalContext& localContext, LocalMatrix& localMatrix, const TestLocalView& testSubspaceLocalView, const AnsatzLocalView& ansatzSubspaceLocalView)
    {
      Impl::forEachTupleEntry(localAssemblers_, [&](auto& localAssembler) {
        localAssembler(localContext, localMatrix, testSubspaceLocalView, ansatzSubspaceLocalView);
      });
    }
 
    // Old Dune::Fufem vector-assember interface
 
    template<class TestLocalView>
    void preprocess(const TestLocalView& testLocalView)
    {
      Impl::forEachTupleEntry(localAssemblers_, [&](auto& localAssembler) {
        if constexpr(Dune::Std::is_detected_v<LocalAssemblerUnaryPreprocess, std::decay_t<decltype(localAssembler)>, TestLocalView>)
          localAssembler.preprocess(testLocalView);
      });
    }
 
    template<class LocalContext, class LocalVector, class TestLocalView>
    void operator()(const LocalContext& localContext, LocalVector& localVector, const TestLocalView& testSubspaceLocalView)
    {
      Impl::forEachTupleEntry(localAssemblers_, [&](auto& localAssembler) {
        localAssembler(localContext, localVector, testSubspaceLocalView);
      });
    }
 
    const auto& assemblers() const
    {
      return localAssemblers_;
    }
 
  private:
    std::tuple<LocalAssemblers...> localAssemblers_;
  };
 
  template<class... LocalAssemblers>
  struct IsLocalAssembler<LocalSumAssembler<LocalAssemblers...>> : public std::true_type {};
 
 
 
} // namespace Dune::Fufem::Forms
 
 
 
namespace Dune::Fufem::Forms::Impl {
 
 
 
  // ************************************************************
  // Implementation of sum(l,r).
  // ************************************************************
 
  template<class L, class R,
    std::enable_if_t<Dune::Fufem::Forms::IsLocalAssembler<L>::value and Dune::Fufem::Forms::IsLocalAssembler<R>::value, int> = 0>
  auto sum(const L& l, const R& r)
  {
    return LocalSumAssembler(l, r);
  }
 
  template<class... L, class R,
    std::enable_if_t<Dune::Fufem::Forms::IsLocalAssembler<R>::value, int> = 0>
  auto sum(const LocalSumAssembler<L...>& l, const R& r)
  {
    return std::apply([&](const auto&... li) {
      return LocalSumAssembler(li..., r);
    }, l.assemblers());
  }
 
  template<class L, class... R,
    std::enable_if_t<Dune::Fufem::Forms::IsLocalAssembler<L>::value, int> = 0>
  auto sum(const L& l, const LocalSumAssembler<R...>& r)
  {
    return std::apply([&](const auto&... ri) {
      return LocalSumAssembler(l, ri...);
    }, r.assemblers());
  }
 
  template<class... L, class... R>
  auto sum(const LocalSumAssembler<L...>& l, const LocalSumAssembler<R...>& r)
  {
    return std::apply([&](const auto&... li) {
      return std::apply([&](const auto&... ri) {
        return LocalSumAssembler(li..., ri...);
      }, r.assemblers());
    }, l.assemblers());
  }
 
 
 
} // Dune::Fufem::Forms::Impl
 
 
 
namespace Dune::Fufem::Forms {
 
 
 
  // If we activate this doxygen documentation, we do not see the other operator+.
 
  /*
   * \brief Create the sum of two local assemblers
   *
   * \ingroup FormsUserInterfaceArithmetic
   */
  template<class L, class R,
    std::enable_if_t<Dune::Fufem::Forms::IsLocalAssembler<L>::value and Dune::Fufem::Forms::IsLocalAssembler<R>::value, int> = 0>
  auto operator+ (const L& l, const R& r)
  {
    return Impl::sum(l, r);
  }
 
 
 
} // namespace Dune::Fufem::Forms
 
 
#endif // DUNE_FUFEM_FORMS_LOCALSUMASSEMBLER_HH