localfiniteelementvariantcache.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_COMMON_LOCALFINITEELEMENTVARIANTCACHE_HH
#define DUNE_LOCALFUNCTIONS_COMMON_LOCALFINITEELEMENTVARIANTCACHE_HH
 
#include <limits>
#include <vector>
#include <tuple>
#include <utility>
#include <type_traits>
 
#include <dune/common/std/type_traits.hh>
#include <dune/common/exceptions.hh>
#include <dune/common/typelist.hh>
#include <dune/common/hybridutilities.hh>
 
#include <dune/geometry/type.hh>
#include <dune/geometry/typeindex.hh>
 
#include <dune/localfunctions/common/localfiniteelementvariant.hh>
 
 
namespace Dune {
 
namespace Impl {
 
  // This class provides the index method of LocalGeometryTypeIndex
  // but throws a Dune::RangeError if the dimension does not match.
  // This can be helpful to catch errors in a LocalFiniteElementVariantCache
  // instance based on dimension specific GeometryType indices.
  template<std::size_t dim>
  struct FixedDimLocalGeometryTypeIndex {
    inline static std::size_t index(const GeometryType &gt)
    {
      if (gt.dim() != dim)
        DUNE_THROW(Dune::RangeError, "Asking for dim=" << dim << " specific index of GeometryType with dimension " << gt.dim());
      return LocalGeometryTypeIndex::index(gt);
    }
  };
 
} // end namespace Impl
 
template<class Base>
class LocalFiniteElementVariantCache : Base
{
 
  template<class LFEImplTuple>
  struct GenerateLFEVariant;
 
  template<class Index, class... LFEImpl>
  struct GenerateLFEVariant<std::tuple<std::pair<Index, LFEImpl>...>>
  {
    using type = UniqueTypes_t<LocalFiniteElementVariant, decltype(std::declval<LFEImpl>()())...>;
  };
 
  using Base::getImplementations;
  using Base::index;
  using Implementations = decltype(std::declval<Base>().getImplementations());
 
public:
 
  using FiniteElementType = typename GenerateLFEVariant<Implementations>::type;
 
  template<class... Args>
  LocalFiniteElementVariantCache(Args&&... args) :
    Base(std::forward<Args>(args)...)
  {
    Dune::Hybrid::forEach(getImplementations(), [&,this](auto feImpl) {
      auto implIndex = feImpl.first;
      constexpr auto unusedIndex = std::numeric_limits<decltype(implIndex)>::max();
      if (implIndex == unusedIndex)
        return;
      if (cache_.size() < implIndex+1)
        cache_.resize(implIndex+1);
      cache_[implIndex] = feImpl.second();
    });
  }
 
  LocalFiniteElementVariantCache(const LocalFiniteElementVariantCache& other) = default;
 
  LocalFiniteElementVariantCache(LocalFiniteElementVariantCache&& other) = default;
 
  LocalFiniteElementVariantCache& operator= (const LocalFiniteElementVariantCache& other) = default;
 
  LocalFiniteElementVariantCache& operator= (LocalFiniteElementVariantCache&& other) = default;
 
  template<class... Key>
  const auto& get(const Key&... key) const
  {
    auto implIndex = index(key...);
    if (implIndex >= cache_.size())
      DUNE_THROW(Dune::RangeError,"There is no LocalFiniteElement of the requested type.");
    if (not(cache_[implIndex]))
      DUNE_THROW(Dune::RangeError,"There is no LocalFiniteElement of the requested type.");
    return cache_[implIndex];
  }
 
private:
  std::vector<FiniteElementType> cache_;
};
 
 
 
} // namespace Dune
 
 
 
 
#endif // DUNE_LOCALFUNCTIONS_COMMON_LOCALFINITEELEMENTVARIANT_HH