gridfunctions/common.hh

Go to the documentation of this file.

#pragma once
 
#include <type_traits>
 
#include <dune/common/fvector.hh>
#include <dune/common/dynvector.hh>
#include <dune/functions/common/defaultderivativetraits.hh>
 
namespace Dune::Vtk
{
  struct PointContext {};
 
  struct CellContext {};
 
 
  template <class GridCreator, class Range, class Context>
  struct AssociatedGridFunction
  {
    using type = void;
  };
 
 
  template <class Element, class Range, class Domain>
  struct DummyLocalFunctionDerivative
  {
    using DerivativeRange = typename Functions::DefaultDerivativeTraits<Range(Domain)>::Range;
    void bind (Element const& element) { /* do nothing */ };
    void unbind () { /* do nothing */ }
    DerivativeRange operator() (Domain const& local) const
    {
      DUNE_THROW(Dune::NotImplemented,
        "The derivative is not implemented.");
    }
  };
 
  namespace Impl
  {
    template <class Range>
    struct ConstructRange
    {
      template <class Field>
      static Range apply (int size, Field const& value);
    };
 
 
    template <class Range, class Field>
    Range constructRange (int size, Field const& value)
    {
      return ConstructRange<Range>::apply (size,value);
    }
 
    template <class T, int n>
    struct ConstructRange<Dune::FieldVector<T,n>>
    {
      template <class Field>
      static Dune::FieldVector<T,n> apply ([[maybe_unused]] int size, Field const& value)
      {
        assert(size == n);
        return Dune::FieldVector<T,n>(value);
      }
    };
 
    template <class T>
    struct ConstructRange<Dune::DynamicVector<T>>
    {
      template <class Field>
      static Dune::DynamicVector<T> apply (int size, Field const& value)
      {
        return Dune::DynamicVector<T>(size,T(value));
      }
    };
 
 
    template <class Range, class Wrapper>
    Range unwrapRange (Wrapper const& wrapper)
    {
      if constexpr (std::is_arithmetic_v<Range>)
        return wrapper[0];
      else
        return Range(wrapper);
    }
 
 
    template <class Range>
    struct ResizeRange
    {
      static void apply (Range& range, int size);
    };
 
 
    template <class Range>
    void resizeRange (Range& range, int size)
    {
      ResizeRange<Range>::apply(range,size);
    }
 
    template <class T, int n>
    struct ResizeRange<Dune::FieldVector<T,n>>
    {
      static void apply ([[maybe_unused]] Dune::FieldVector<T,n>& range, [[maybe_unused]] int size)
      {
        assert(n == size);
      }
    };
 
    template <class T>
    struct ResizeRange<Dune::DynamicVector<T>>
    {
      static void apply (Dune::DynamicVector<T>& range, int size)
      {
        range.resize(size);
      }
    };
 
  } // end namespace Impl
 
} // end namespace Dune::Vtk