coefficient.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_COEFFICIENT_HH
#define DUNE_FUFEM_FORMS_COEFFICIENT_HH
 
#include <type_traits>
#include <utility>
 
#include <dune/common/typetraits.hh>
 
#include <dune/istl/matrix.hh>
#include <dune/istl/matrixindexset.hh>
 
#include <dune/fufem/forms/baseclass.hh>
#include <dune/fufem/forms/tensors.hh>
#include <dune/fufem/forms/shapefunctioncache.hh>
 
 
 
 
namespace Dune::Fufem::Forms {
 
 
 
  template<class F>
  class Coefficient : public F, public MultilinearOperator<0>
  {
    using LocalFunction = std::decay_t<decltype(localFunction(std::declval<F&>()))>;
    using LocalDomain = typename F::EntitySet::Element::Geometry::LocalCoordinate;
 
  public:
 
    using Element = typename F::EntitySet::Element;
    using Range = decltype(std::declval<LocalFunction>()(std::declval<LocalDomain>()));
 
    Coefficient(const F& f) :
      F(f),
      order_(0)
    {}
 
    Coefficient(const F& f, std::size_t order) :
      F(f),
      order_(order)
    {}
 
    class LocalOperator : public LocalFunction
    {
    public:
 
      using Element = typename Coefficient::Element;
      using Intersection = typename F::EntitySet::GridView::Intersection;
      using CacheManager = Dune::Fufem::Forms::CacheManager<typename Element::Geometry::ctype, Element::Geometry::mydimension>;
      using QuadratureRule = typename CacheManager::QuadratureRule;
      using Range = typename Coefficient::Range;
 
      LocalOperator(LocalFunction&& fLocal, std::size_t order) :
        LocalFunction(std::move(fLocal)),
        order_(order)
      {}
 
      auto quadratureRuleKey() const
      {
        return QuadratureRuleKey(LocalFunction::localContext().type(), order_);
      }
 
      template<class... LV>
      void registerLocalViews(const LV&... lvs)
      {}
 
      template<class... LV>
      void registerOutsideLocalViews(const LV&... lvs)
      {}
 
      void registerCaches(CacheManager& cacheManager)
      {}
 
      void registerOutsideCaches(CacheManager& cacheManager)
      {}
 
      using LocalFunction::bind;
 
      void bind(const Intersection& intersection, const Element& element, const Element& otherElement)
      {
        LocalFunction::bind(element);
      }
 
      template<class... OutsideCacheManager>
      void bindToCaches(CacheManager& cacheManager, OutsideCacheManager&... outsideCacheManager)
      {
        rule_ = &cacheManager.rule();
      }
 
      auto operator()(std::size_t index) const
      {
        return Impl::Tensor::RankZeroTensor(LocalFunction::operator()((*rule_)[index].position()));
      }
 
    private:
      std::size_t order_;
      const QuadratureRule* rule_ = nullptr;
    };
 
    friend LocalOperator localOperator(const Coefficient& coefficient)
    {
      return LocalOperator(localFunction(coefficient), coefficient.order_);
    }
 
    auto basis() const
    {
      return std::tuple<>();
    }
 
    auto treePath() const
    {
      return std::tuple<>();
    }
 
  private:
    std::size_t order_;
  };
 
 
 
} // namespace Dune::Fufem::Forms
 
 
 
#endif // DUNE_FUFEM_FORMS_COEFFICIENT_HH