sumoperator.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_SUMOPERATOR_HH
#define DUNE_FUFEM_FORMS_SUMOPERATOR_HH
 
#include <cstddef>
#include <type_traits>
#include <tuple>
#include <utility>
 
#include <dune/fufem/quadraturerules/quadraturerulecache.hh>
 
#include <dune/fufem/forms/baseclass.hh>
#include <dune/fufem/forms/tensors.hh>
#include <dune/fufem/forms/localfunctionadaptor.hh>
#include <dune/fufem/forms/localoperators.hh>
 
 
 
namespace Dune::Fufem::Forms {
 
 
 
  template<class Operator0, class... Operators>
  class SumOperator
  {
    static_assert(
      std::is_invocable_v<LocalOperators::SumOp, typename Operator0::Range, typename Operators::Range...>,
      "Trying do build sum of operators with non-interoperable ranges.");
 
  public:
    static constexpr std::size_t arity = Operator0::arity;
 
    using Element = typename Operator0::Element;
    using Range = std::invoke_result_t<LocalOperators::SumOp, typename Operator0::Range, typename Operators::Range...>;
 
    SumOperator(Operator0 operator0, Operators... operators) :
      operators_(operator0, operators...)
    {}
 
    class LocalOperator
    {
    public:
 
      using Element = typename SumOperator::Element;
      using Intersection = typename Operator0::LocalOperator::Intersection;
      using CacheManager = typename Operator0::LocalOperator::CacheManager;
      using Range = typename SumOperator::Range;
 
      LocalOperator(const typename Operator0::LocalOperator& localOperator0, const typename Operators::LocalOperator&... localOperators) :
        localOperators_(localOperator0, localOperators...)
      {}
 
      auto quadratureRuleKey() const
      {
        auto  quadKey = QuadratureRuleKey();
        Impl::forEachTupleEntry(localOperators_, [&](const auto& localOperator) {
          quadKey = localOperator.quadratureRuleKey().sum(quadKey);
        });
        return quadKey;
      }
 
      void bind(const Element& element)
      {
        Impl::forEachTupleEntry(localOperators_, [&](auto& localOperator) {
          localOperator.bind(element);
        });
      }
 
      void bind(const Intersection& intersection, const Element& element, const Element& otherElement)
      {
        Impl::forEachTupleEntry(localOperators_, [&](auto& localOperator) {
          localOperator.bind(intersection, element, otherElement);
        });
      }
 
      void unbind()
      {
        Impl::forEachTupleEntry(localOperators_, [&](auto& localOperator) {
          localOperator.unbind();
        });
      }
 
      auto operator()(std::size_t index) const
      requires(arity==0)
      {
        Range y;
        y = 0;
        Impl::forEachTupleEntry(localOperators_, [&](auto& localOperator) {
          Dune::Fufem::Forms::LocalOperators::SumOp::addTo(y, localOperator(index)());
        });
        return Impl::Tensor::RankZeroTensor(y);
      }
 
      template<class... LocalViews>
      void registerLocalViews(const LocalViews&... localViews)
      {
        Impl::forEachTupleEntry(localOperators_, [&](auto& localOperator) {
          localOperator.registerLocalViews(localViews...);
        });
      }
 
      template<class... LocalViews>
      void registerOutsideLocalViews(const LocalViews&... localViews)
      {
        Impl::forEachTupleEntry(localOperators_, [&](auto& localOperator) {
          localOperator.registerOutsideLocalViews(localViews...);
        });
      }
 
      void registerCaches(CacheManager& cacheManager)
      {
        Impl::forEachTupleEntry(localOperators_, [&](auto& localOperator) {
          localOperator.registerCaches(cacheManager);
        });
      }
 
      void registerOutsideCaches(CacheManager& cacheManager)
      {
        Impl::forEachTupleEntry(localOperators_, [&](auto& localOperator) {
          localOperator.registerOutsideCaches(cacheManager);
        });
      }
 
      template<class... OutsideCacheManager>
      void bindToCaches(CacheManager& cacheManager, OutsideCacheManager&... outsideCacheManager)
      {
        Impl::forEachTupleEntry(localOperators_, [&](auto& localOperator) {
          localOperator.bindToCaches(cacheManager, outsideCacheManager...);
        });
      }
 
      auto& operators()
      {
        return localOperators_;
      }
 
      const auto& operators() const
      {
        return localOperators_;
      }
 
    private:
      std::tuple<typename Operator0::LocalOperator, typename Operators::LocalOperator...> localOperators_;
    };
 
    friend LocalOperator localOperator(const SumOperator& sumOperator)
    {
      return std::apply([&](const auto&... op) {
        return LocalOperator(localOperator(op)...);
      }, sumOperator.operators());
    }
 
    template<bool dummy=true, std::enable_if_t<dummy and (SumOperator::arity==0), int> = 0>
    friend LocalFunctionAdaptor<LocalOperator> localFunction(const SumOperator& sumOperator)
    {
      return LocalFunctionAdaptor<LocalOperator>(localOperator(sumOperator));
    }
 
    auto& operators()
    {
      return operators_;
    }
 
    const auto& operators() const
    {
      return operators_;
    }
 
    auto basis() const
    {
      return std::get<0>(operators_).basis();
    }
 
  private:
    std::tuple<Operator0, Operators...> operators_;
  };
 
 
 
} // namespace Dune::Fufem::Forms
 
 
#endif // DUNE_FUFEM_FORMS_SUMOPERATOR_HH