cache.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-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
#ifndef DUNE_LOCALFUNCTIONS_LAGRANGE_CACHE_HH
#define DUNE_LOCALFUNCTIONS_LAGRANGE_CACHE_HH
 
#include <map>
#include <optional>
#include <type_traits>
 
#include <dune/geometry/type.hh>
#include <dune/geometry/typeindex.hh>
 
#include <dune/localfunctions/lagrange.hh>
#include <dune/localfunctions/lagrange/equidistantpoints.hh>
#include <dune/localfunctions/lagrange/lagrangecube.hh>
#include <dune/localfunctions/lagrange/lagrangelfecache.hh>
#include <dune/localfunctions/lagrange/lagrangeprism.hh>
#include <dune/localfunctions/lagrange/lagrangepyramid.hh>
#include <dune/localfunctions/lagrange/lagrangesimplex.hh>
 
 
namespace Dune {

template <class Domain, class Range, int dim,
          class SF=Range, class CF=Range>
class DynamicLagrangeLocalFiniteElementCache
{
public:
  using FiniteElementType = LagrangeLocalFiniteElement<EquidistantPointSet, dim, Domain, Range, SF, CF>;

  explicit DynamicLagrangeLocalFiniteElementCache (unsigned int order)
    : order_(order)
    , data_()
  {}

  const FiniteElementType& get (GeometryType type) const
  {
    auto [it,_] = data_.try_emplace(type,type,order_);
    return it->second;
  }
 
private:
  unsigned int order_;
  mutable std::map<GeometryType, FiniteElementType> data_;
};
 

template <GeometryType::Id id, class Domain, class Range, std::size_t dim, std::size_t order>
class StaticLagrangeLocalFiniteElementCache
{
  struct UnknownToplogy {};
 
  static constexpr bool isSimplex = GeometryType(id).isSimplex();
  static constexpr bool isCube = GeometryType(id).isCube();
  static constexpr bool isPrism = GeometryType(id).isPrism();
  static constexpr bool isPyramid = GeometryType(id).isPyramid();
 
public:
  using FiniteElementType
    = std::conditional_t<isSimplex, LagrangeSimplexLocalFiniteElement<Domain,Range,dim,order>,
      std::conditional_t<isCube,    LagrangeCubeLocalFiniteElement<Domain,Range,dim,order>,
      std::conditional_t<isPrism,   LagrangePrismLocalFiniteElement<Domain,Range,order>,
      std::conditional_t<isPyramid, LagrangePyramidLocalFiniteElement<Domain,Range,order>, UnknownToplogy> > > >;

  //! Construct the local-finite element for the order specified as template parameter.
  explicit StaticLagrangeLocalFiniteElementCache (std::integral_constant<std::size_t,order> = {})
  {
    lfe_.emplace();
  }

  //! Obtain the cached local finite-element.
  const FiniteElementType& get ([[maybe_unused]] GeometryType type) const
  {
    assert(GeometryType::Id(type) == id);
    assert(!!lfe_);
    return *lfe_;
  }
 
private:
  std::optional<FiniteElementType> lfe_{};
};
 

template <class Domain, class Range, std::size_t dim, std::size_t order>
class StaticLagrangeLocalFiniteElementCache<GeometryType::Id(~0u), Domain, Range, dim, order>
    : public LagrangeLocalFiniteElementCache<Domain,Range,dim,order>
{
  using Base = LagrangeLocalFiniteElementCache<Domain,Range,dim,order>;
public:
  using Base::Base;
};
 
} // namespace Dune
 
#endif // DUNE_LOCALFUNCTIONS_LAGRANGE_CACHE_HH