unaryexpression.hh

#ifndef __DUNE_ACFEM_MODELS_UNARYEXPRESSION_HH__
#define __DUNE_ACFEM_MODELS_UNARYEXPRESSION_HH__
 
#include "../expressions/operationtraits.hh"
#include "../expressions/storage.hh"
#include "../expressions/interface.hh"
#include "../expressions/signutil.hh"
#include "../common/literals.hh"
#include "../tensors/tensor.hh"
 
#include "modeltraits.hh"
#include "expressionoperations.hh"
 
namespace Dune
{
 
  namespace ACFem
  {
 
    namespace PDEModel {
 
      using namespace Literals;
 
      using namespace ModelIntrospection;
 
      template<class Model, class Quadrature = PointWrapperQuadrature<typename Model::DomainType> >
      using AllArgs = typename Traits<Model>::template AllArguments<Quadrature>;
 
      template<class Model, class ReturnValueFunctor, std::size_t tag,
               class LinArgSeq, class OuterArgSeq, class InnerArgSeq,
               class Enable = void>
      class ModelMethod;
 
      template<class Model,
               std::size_t tag,
               std::size_t signature = Get<tag, typename ModelIntrospection::Traits<Model>::MethodCallSignatures>::value,
               class F = OperationTraits<IdentityOperation> >
      using TaggedModelMethod = ModelMethod<
        Model, F, tag,
        MaskSequence<ArgumentMask<signature>::linearizationSignature()>,
        MaskSequence<ArgumentMask<signature>::signature()>,
        MaskSequence<CondensedMask<signature, Get<tag, typename ModelIntrospection::Traits<Model>::MethodCallSignatures>::value>::value>
        >;
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, flux,
                        IndexSequence<>,
                        IndexSequence<pointIndex, OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<Traits<Model>::template HasMethod<flux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::flux;
 
        ModelMethod(const Model& model, const F& f = F())
          : model_(model), f_(f)
        {}
 
        template<class Quadrature>
        auto flux(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return f_(model_.flux(std::get<InnerArgsIdx>(std::forward_as_tuple(x, args...))...));
        }
 
        template<class Quadrature>
        auto operator()(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return flux(x, args...);
        }
 
       private:
        const Model& model_;
        const F& f_;
      };
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, flux,
                        IndexSequence<>,
                        IndexSequence<OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<Traits<Model>::template HasMethod<flux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::flux;
 
        ModelMethod(const Model& model, const F& f = F())
          : model_(model), f_(f)
        {}
 
        auto flux(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return f_(model_.flux(std::get<InnerArgsIdx>(std::forward_as_tuple(args...))...));
        }
 
        auto operator()(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return flux(args...);
        }
 
       private:
        const Model& model_;
        const F& f_;
      };
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, flux,
                        IndexSequence<>,
                        IndexSequence<pointIndex, OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<!Traits<Model>::template HasMethod<flux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::flux;
 
        ModelMethod(const Model& model, const F& f = F())
          : l_(model, f)
        {}
 
        template<class Quadrature>
        auto flux(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return l_(x, args...);
        }
 
        template<class Quadrature>
        auto operator()(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return l_(x, args...);
        }
 
       private:
        const TaggedModelMethod<Model, LinearizedTag<tag>::value, SequenceMask<pointIndex, OuterArgsIdx...>::value, F> l_;
      };
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, flux,
                        IndexSequence<>,
                        IndexSequence<OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<!Traits<Model>::template HasMethod<flux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::flux;
 
        ModelMethod(const Model& model, const F& f = F())
          : l_(model, f)
        {}
 
        auto flux(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return l_(args...);
        }
 
        auto operator()(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return l_(args...);
        }
 
       private:
        const TaggedModelMethod<Model, LinearizedTag<tag>::value, SequenceMask<OuterArgsIdx...>::value, F> l_;
      };
 
      template<class Model, class F, std::size_t... LinArgsIdx, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, linearizedFlux,
                        IndexSequence<LinArgsIdx...>,
                        IndexSequence<pointIndex, OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<Traits<Model>::template HasMethod<linearizedFlux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::linearizedFlux;
 
        ModelMethod(const Model& model, const F& f = F())
          : model_(model), f_(f)
        {}
 
        template<class Quadrature>
        auto linearizedFlux(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                            const QuadraturePoint<Quadrature>& x,
                            const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return f_(model_.linearizedFlux(std::get<InnerArgsIdx>(std::forward_as_tuple(linArgs..., x, args...))...));
        }
 
        template<class Quadrature>
        auto operator()(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                        const QuadraturePoint<Quadrature>& x,
                        const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return linearizedFlux(linArgs..., x, args...);
        }
 
       private:
        const Model& model_;
        const F& f_;
      };
 
      template<class Model, class F, std::size_t... LinArgsIdx, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, linearizedFlux,
                        IndexSequence<LinArgsIdx...>,
                        IndexSequence<OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<Traits<Model>::template HasMethod<linearizedFlux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::linearizedFlux;
 
        ModelMethod(const Model& model, const F& f = F())
          : model_(model), f_(f)
        {}
 
        auto linearizedFlux(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                            const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return f_(model_.linearizedFlux(std::get<InnerArgsIdx>(std::forward_as_tuple(linArgs..., args...))...));
        }
 
        auto operator()(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                        const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return linearizedFlux(linArgs..., args...);
        }
 
       private:
        const Model& model_;
        const F& f_;
      };
 
      template<class Model, class F, std::size_t... LinArgsIdx, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, linearizedFlux,
                        IndexSequence<LinArgsIdx...>,
                        IndexSequence<pointIndex, OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<!Traits<Model>::template HasMethod<linearizedFlux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::linearizedFlux;
 
        ModelMethod(const Model& model, const F& f = F())
        {}
 
        template<class Quadrature>
        auto linearizedFlux(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                            const QuadraturePoint<Quadrature>& x,
                            const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
 
        template<class Quadrature>
        auto operator()(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                        const QuadraturePoint<Quadrature>& x,
                        const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
      };
 
      template<class Model, class F, std::size_t... LinArgsIdx, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, linearizedFlux,
                        IndexSequence<LinArgsIdx...>,
                        IndexSequence<OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<!Traits<Model>::template HasMethod<linearizedFlux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::linearizedFlux;
 
        ModelMethod(const Model& model, const F& f = F())
        {}
 
        auto linearizedFlux(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                            const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
 
        auto operator()(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                        const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
      };
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, source,
                        IndexSequence<>,
                        IndexSequence<pointIndex, OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<Traits<Model>::template HasMethod<source>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::source;
 
        ModelMethod(const Model& model, const F& f = F())
          : model_(model), f_(f)
        {}
 
        template<class Quadrature>
        auto source(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return f_(model_.source(std::get<InnerArgsIdx>(std::forward_as_tuple(x, args...))...));
        }
 
        template<class Quadrature>
        auto operator()(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return source(x, args...);
        }
 
       private:
        const Model& model_;
        const F& f_;
      };
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, source,
                        IndexSequence<>,
                        IndexSequence<OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<Traits<Model>::template HasMethod<source>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::source;
 
        ModelMethod(const Model& model, const F& f = F())
          : model_(model), f_(f)
        {}
 
        auto source(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return f_(model_.source(std::get<InnerArgsIdx>(std::forward_as_tuple(args...))...));
        }
 
        auto operator()(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return source(args...);
        }
 
       private:
        const Model& model_;
        const F& f_;
      };
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, source,
                        IndexSequence<>,
                        IndexSequence<pointIndex, OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<!Traits<Model>::template HasMethod<source>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::source;
 
        ModelMethod(const Model& model, const F& f = F())
          : l_(model, f)
        {}
 
        template<class Quadrature>
        auto source(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return l_(x, args...);
        }
 
        template<class Quadrature>
        auto operator()(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return l_(x, args...);
        }
 
       private:
        const TaggedModelMethod<Model, LinearizedTag<tag>::value, SequenceMask<pointIndex, OuterArgsIdx...>::value, F> l_;
      };
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, source,
                        IndexSequence<>,
                        IndexSequence<OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<!Traits<Model>::template HasMethod<source>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::source;
 
        ModelMethod(const Model& model, const F& f = F())
          : l_(model, f)
        {}
 
        auto source(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return l_(args...);
        }
 
        auto operator()(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return l_(args...);
        }
 
       private:
        const TaggedModelMethod<Model, LinearizedTag<tag>::value, SequenceMask<OuterArgsIdx...>::value, F> l_;
      };
 
      template<class Model, class F, std::size_t... LinArgsIdx, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, linearizedSource,
                        IndexSequence<LinArgsIdx...>,
                        IndexSequence<pointIndex, OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<Traits<Model>::template HasMethod<linearizedSource>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::linearizedSource;
 
        ModelMethod(const Model& model, const F& f = F())
          : model_(model), f_(f)
        {}
 
        template<class Quadrature>
        auto linearizedSource(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                              const QuadraturePoint<Quadrature>& x,
                              const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return f_(model_.linearizedSource(std::get<InnerArgsIdx>(std::forward_as_tuple(linArgs..., x, args...))...));
        }
 
        template<class Quadrature>
        auto operator()(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                        const QuadraturePoint<Quadrature>& x,
                        const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return linearizedSource(linArgs..., x, args...);
        }
 
       private:
        const Model& model_;
        const F& f_;
      };
 
      template<class Model, class F, std::size_t... LinArgsIdx, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, linearizedSource,
                        IndexSequence<LinArgsIdx...>,
                        IndexSequence<OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<Traits<Model>::template HasMethod<linearizedSource>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::linearizedSource;
 
        ModelMethod(const Model& model, const F& f = F())
          : model_(model), f_(f)
        {}
 
        auto linearizedSource(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                              const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return f_(model_.linearizedSource(std::get<InnerArgsIdx>(std::forward_as_tuple(linArgs..., args...))...));
        }
 
        auto operator()(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                        const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return linearizedSource(linArgs..., args...);
        }
 
       private:
        const Model& model_;
        const F& f_;
      };
 
      template<class Model, class F, std::size_t... LinArgsIdx, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, linearizedSource,
                        IndexSequence<LinArgsIdx...>,
                        IndexSequence<pointIndex, OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<!Traits<Model>::template HasMethod<linearizedSource>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::linearizedSource;
 
        ModelMethod(const Model& model, const F& f = F())
        {}
 
        template<class Quadrature>
        auto linearizedSource(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                              const QuadraturePoint<Quadrature>& x,
                              const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
 
        template<class Quadrature>
        auto operator()(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                        const QuadraturePoint<Quadrature>& x,
                        const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
      };
 
      template<class Model, class F, std::size_t... LinArgsIdx, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, linearizedSource,
                        IndexSequence<LinArgsIdx...>,
                        IndexSequence<OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<!Traits<Model>::template HasMethod<linearizedSource>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::linearizedSource;
 
        ModelMethod(const Model& model, const F& f = F())
        {}
 
        auto linearizedSource(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                              const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
 
        auto operator()(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                        const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
      };
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, robinFlux,
                        IndexSequence<>,
                        IndexSequence<pointIndex, OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<Traits<Model>::template HasMethod<robinFlux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::robinFlux;
 
        ModelMethod(const Model& model, const F& f = F())
          : model_(model), f_(f)
        {}
 
        template<class Quadrature>
        auto robinFlux(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return f_(model_.robinFlux(std::get<InnerArgsIdx>(std::forward_as_tuple(x, args...))...));
        }
 
        template<class Quadrature>
        auto operator()(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return robinFlux(x, args...);
        }
 
       private:
        const Model& model_;
        const F& f_;
      };
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, robinFlux,
                        IndexSequence<>,
                        IndexSequence<OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<Traits<Model>::template HasMethod<robinFlux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::robinFlux;
 
        ModelMethod(const Model& model, const F& f = F())
          : model_(model), f_(f)
        {}
 
        auto robinFlux(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return f_(model_.robinFlux(std::get<InnerArgsIdx>(std::forward_as_tuple(args...))...));
        }
 
        auto operator()(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return robinFlux(args...);
        }
 
       private:
        const Model& model_;
        const F& f_;
      };
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, robinFlux,
                        IndexSequence<>,
                        IndexSequence<pointIndex, OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<!Traits<Model>::template HasMethod<robinFlux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::robinFlux;
 
        ModelMethod(const Model& model, const F& f = F())
          : l_(model, f)
        {}
 
        template<class Quadrature>
        auto robinFlux(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return l_(x, args...);
        }
 
        template<class Quadrature>
        auto operator()(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return l_(x, args...);
        }
 
       private:
        const TaggedModelMethod<Model, LinearizedTag<tag>::value, SequenceMask<pointIndex, OuterArgsIdx...>::value, F> l_;
      };
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, robinFlux,
                        IndexSequence<>,
                        IndexSequence<OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<!Traits<Model>::template HasMethod<robinFlux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::robinFlux;
 
        ModelMethod(const Model& model, const F& f = F())
          : l_(model, f)
        {}
 
        auto robinFlux(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return l_(args...);
        }
 
        auto operator()(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return l_(args...);
        }
 
       private:
        const TaggedModelMethod<Model, LinearizedTag<tag>::value, SequenceMask<OuterArgsIdx...>::value, F> l_;
      };
 
      template<class Model, class F, std::size_t... LinArgsIdx, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, linearizedRobinFlux,
                        IndexSequence<LinArgsIdx...>,
                        IndexSequence<pointIndex, OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<Traits<Model>::template HasMethod<linearizedRobinFlux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::linearizedRobinFlux;
 
        ModelMethod(const Model& model, const F& f = F())
          : model_(model), f_(f)
        {}
 
        template<class Quadrature>
        auto linearizedRobinFlux(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                                 const QuadraturePoint<Quadrature>& x,
                                 const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return f_(model_.linearizedRobinFlux(std::get<InnerArgsIdx>(std::forward_as_tuple(linArgs..., x, args...))...));
        }
 
        template<class Quadrature>
        auto operator()(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                        const QuadraturePoint<Quadrature>& x,
                        const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return linearizedRobinFlux(linArgs..., x, args...);
        }
 
       private:
        const Model& model_;
        const F& f_;
      };
 
      template<class Model, class F, std::size_t... LinArgsIdx, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, linearizedRobinFlux,
                        IndexSequence<LinArgsIdx...>,
                        IndexSequence<OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<Traits<Model>::template HasMethod<linearizedRobinFlux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::linearizedRobinFlux;
 
        ModelMethod(const Model& model, const F& f = F())
          : model_(model), f_(f)
        {}
 
        auto linearizedRobinFlux(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                                 const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return f_(model_.linearizedRobinFlux(std::get<InnerArgsIdx>(std::forward_as_tuple(linArgs..., args...))...));
        }
 
        auto operator()(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                        const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return linearizedRobinFlux(linArgs..., args...);
        }
 
       private:
        const Model& model_;
        const F& f_;
      };
 
      template<class Model, class F, std::size_t... LinArgsIdx, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, linearizedRobinFlux,
                        IndexSequence<LinArgsIdx...>,
                        IndexSequence<pointIndex, OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<!Traits<Model>::template HasMethod<linearizedRobinFlux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::linearizedRobinFlux;
 
        ModelMethod(const Model& model, const F& f = F())
        {}
 
        template<class Quadrature>
        auto linearizedRobinFlux(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                                 const QuadraturePoint<Quadrature>& x,
                                 const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
 
        template<class Quadrature>
        auto operator()(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                        const QuadraturePoint<Quadrature>& x,
                        const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
      };
 
      template<class Model, class F, std::size_t... LinArgsIdx, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, linearizedRobinFlux,
                        IndexSequence<LinArgsIdx...>,
                        IndexSequence<OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<!Traits<Model>::template HasMethod<linearizedRobinFlux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::linearizedRobinFlux;
 
        ModelMethod(const Model& model, const F& f = F())
        {}
 
        auto linearizedRobinFlux(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                                 const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
 
        auto operator()(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                        const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
      };
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, singularFlux,
                        IndexSequence<>,
                        IndexSequence<pointIndex, OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<Traits<Model>::template HasMethod<singularFlux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::singularFlux;
 
        ModelMethod(const Model& model, const F& f = F())
          : model_(model), f_(f)
        {}
 
        template<class Quadrature>
        auto singularFlux(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return f_(model_.singularFlux(std::get<InnerArgsIdx>(std::forward_as_tuple(x, args...))...));
        }
 
        template<class Quadrature>
        auto operator()(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return singularFlux(x, args...);
        }
 
       private:
        const Model& model_;
        const F& f_;
      };
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, singularFlux,
                        IndexSequence<>,
                        IndexSequence<OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<Traits<Model>::template HasMethod<singularFlux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::singularFlux;
 
        ModelMethod(const Model& model, const F& f = F())
          : model_(model), f_(f)
        {}
 
        auto singularFlux(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return f_(model_.singularFlux(std::get<InnerArgsIdx>(std::forward_as_tuple(args...))...));
        }
 
        auto operator()(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return singularFlux(args...);
        }
 
       private:
        const Model& model_;
        const F& f_;
      };
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, singularFlux,
                        IndexSequence<>,
                        IndexSequence<pointIndex, OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<!Traits<Model>::template HasMethod<singularFlux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::singularFlux;
 
        ModelMethod(const Model& model, const F& f = F())
          : l_(model, f)
        {}
 
        template<class Quadrature>
        auto singularFlux(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return l_(x, args...);
        }
 
        template<class Quadrature>
        auto operator()(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return l_(x, args...);
        }
 
       private:
        const TaggedModelMethod<Model, LinearizedTag<tag>::value, SequenceMask<pointIndex, OuterArgsIdx...>::value, F> l_;
      };
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, singularFlux,
                        IndexSequence<>,
                        IndexSequence<OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<!Traits<Model>::template HasMethod<singularFlux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::singularFlux;
 
        ModelMethod(const Model& model, const F& f = F())
          : l_(model, f)
        {}
 
        auto singularFlux(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return l_(args...);
        }
 
        auto operator()(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return l_(args...);
        }
 
       private:
        const TaggedModelMethod<Model, LinearizedTag<tag>::value, SequenceMask<OuterArgsIdx...>::value, F> l_;
      };
 
      template<class Model, class F, std::size_t... LinArgsIdx, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, linearizedSingularFlux,
                        IndexSequence<LinArgsIdx...>,
                        IndexSequence<pointIndex, OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<Traits<Model>::template HasMethod<linearizedSingularFlux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::linearizedSingularFlux;
 
        ModelMethod(const Model& model, const F& f = F())
          : model_(model), f_(f)
        {}
 
        template<class Quadrature>
        auto linearizedSingularFlux(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                                    const QuadraturePoint<Quadrature>& x,
                                    const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return f_(model_.linearizedSingularFlux(std::get<InnerArgsIdx>(std::forward_as_tuple(linArgs..., x, args...))...));
        }
 
        template<class Quadrature>
        auto operator()(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                        const QuadraturePoint<Quadrature>& x,
                        const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return linearizedSingularFlux(linArgs..., x, args...);
        }
 
       private:
        const Model& model_;
        const F& f_;
      };
 
      template<class Model, class F, std::size_t... LinArgsIdx, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, linearizedSingularFlux,
                        IndexSequence<LinArgsIdx...>,
                        IndexSequence<OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<Traits<Model>::template HasMethod<linearizedSingularFlux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::linearizedSingularFlux;
 
        ModelMethod(const Model& model, const F& f = F())
          : model_(model), f_(f)
        {}
 
        auto linearizedSingularFlux(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                                    const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return f_(model_.linearizedSingularFlux(std::get<InnerArgsIdx>(std::forward_as_tuple(linArgs..., args...))...));
        }
 
        auto operator()(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                        const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return linearizedSingularFlux(linArgs..., args...);
        }
 
       private:
        const Model& model_;
        const F& f_;
      };
 
      template<class Model, class F, std::size_t... LinArgsIdx, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, linearizedSingularFlux,
                        IndexSequence<LinArgsIdx...>,
                        IndexSequence<pointIndex, OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<!Traits<Model>::template HasMethod<linearizedSingularFlux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::linearizedSingularFlux;
 
        ModelMethod(const Model& model, const F& f = F())
        {}
 
        template<class Quadrature>
        auto linearizedSingularFlux(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                                    const QuadraturePoint<Quadrature>& x,
                                    const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
 
        template<class Quadrature>
        auto operator()(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                        const QuadraturePoint<Quadrature>& x,
                        const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
      };
 
      template<class Model, class F, std::size_t... LinArgsIdx, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, linearizedSingularFlux,
                        IndexSequence<LinArgsIdx...>,
                        IndexSequence<OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<!Traits<Model>::template HasMethod<linearizedSingularFlux>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::linearizedSingularFlux;
 
        ModelMethod(const Model& model, const F& f = F())
        {}
 
        auto linearizedSingularFlux(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                                    const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
 
        auto operator()(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                        const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
      };
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, ModelIntrospection::dirichlet,
                        IndexSequence<>,
                        IndexSequence<pointIndex, OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<Traits<Model>::template HasMethod<ModelIntrospection::dirichlet>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::dirichlet;
 
        ModelMethod(const Model& model, const F& f = F())
          : model_(model), f_(f)
        {}
 
        template<class Quadrature>
        auto dirichlet(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return f_(model_.dirichlet(std::get<InnerArgsIdx>(std::forward_as_tuple(x, args...))...));
        }
 
        template<class Quadrature>
        auto operator()(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return dirichlet(x, args...);
        }
 
       private:
        const Model& model_;
        const F& f_;
      };
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, ModelIntrospection::dirichlet,
                        IndexSequence<>,
                        IndexSequence<OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<Traits<Model>::template HasMethod<ModelIntrospection::dirichlet>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::dirichlet;
 
        ModelMethod(const Model& model, const F& f = F())
          : model_(model), f_(f)
        {}
 
        auto dirichlet(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return f_(model_.dirichlet(std::get<InnerArgsIdx>(std::forward_as_tuple(args...))...));
        }
 
        auto operator()(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return dirichlet(args...);
        }
 
       private:
        const Model& model_;
        const F& f_;
      };
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, ModelIntrospection::dirichlet,
                        IndexSequence<>,
                        IndexSequence<pointIndex, OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<!Traits<Model>::template HasMethod<ModelIntrospection::dirichlet>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::dirichlet;
 
        ModelMethod(const Model& model, const F& f = F())
          : l_(model, f)
        {}
 
        template<class Quadrature>
        auto dirichlet(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return l_(x, args...);
        }
 
        template<class Quadrature>
        auto operator()(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return l_(x, args...);
        }
 
       private:
        const TaggedModelMethod<Model, LinearizedTag<tag>::value, SequenceMask<pointIndex, OuterArgsIdx...>::value, F> l_;
      };
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, ModelIntrospection::dirichlet,
                        IndexSequence<>,
                        IndexSequence<OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<!Traits<Model>::template HasMethod<ModelIntrospection::dirichlet>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::dirichlet;
 
        ModelMethod(const Model& model, const F& f = F())
          : l_(model, f)
        {}
 
        auto dirichlet(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return l_(args...);
        }
 
        auto operator()(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return l_(args...);
        }
 
       private:
        const TaggedModelMethod<Model, LinearizedTag<tag>::value, SequenceMask<OuterArgsIdx...>::value, F> l_;
      };
 
      template<class Model, class F, std::size_t... LinArgsIdx, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, linearizedDirichlet,
                        IndexSequence<LinArgsIdx...>,
                        IndexSequence<pointIndex, OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<Traits<Model>::template HasMethod<linearizedDirichlet>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::linearizedDirichlet;
 
        ModelMethod(const Model& model, const F& f = F())
          : model_(model), f_(f)
        {}
 
        template<class Quadrature>
        auto linearizedDirichlet(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                                 const QuadraturePoint<Quadrature>& x,
                                 const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return f_(model_.linearizedDirichlet(std::get<InnerArgsIdx>(std::forward_as_tuple(linArgs..., x, args...))...));
        }
 
        template<class Quadrature>
        auto operator()(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                        const QuadraturePoint<Quadrature>& x,
                        const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return linearizedDirichlet(linArgs..., x, args...);
        }
 
       private:
        const Model& model_;
        const F& f_;
      };
 
      template<class Model, class F, std::size_t... LinArgsIdx, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, linearizedDirichlet,
                        IndexSequence<LinArgsIdx...>,
                        IndexSequence<OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<Traits<Model>::template HasMethod<linearizedDirichlet>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::linearizedDirichlet;
 
        ModelMethod(const Model& model, const F& f = F())
          : model_(model), f_(f)
        {}
 
        auto linearizedDirichlet(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                                 const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return f_(model_.linearizedDirichlet(std::get<InnerArgsIdx>(std::forward_as_tuple(linArgs..., args...))...));
        }
 
        auto operator()(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                        const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return linearizedDirichlet(linArgs..., args...);
        }
 
       private:
        const Model& model_;
        const F& f_;
      };
 
      template<class Model, class F, std::size_t... LinArgsIdx, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, linearizedDirichlet,
                        IndexSequence<LinArgsIdx...>,
                        IndexSequence<pointIndex, OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<!Traits<Model>::template HasMethod<linearizedDirichlet>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::linearizedDirichlet;
 
        ModelMethod(const Model& model, const F& f = F())
        {}
 
        template<class Quadrature>
        auto linearizedDirichlet(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                                 const QuadraturePoint<Quadrature>& x,
                                 const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
 
        template<class Quadrature>
        auto operator()(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                        const QuadraturePoint<Quadrature>& x,
                        const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
      };
 
      template<class Model, class F, std::size_t... LinArgsIdx, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, linearizedDirichlet,
                        IndexSequence<LinArgsIdx...>,
                        IndexSequence<OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<!Traits<Model>::template HasMethod<linearizedDirichlet>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::linearizedDirichlet;
 
        ModelMethod(const Model& model, const F& f = F())
        {}
 
        auto linearizedDirichlet(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                                 const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
 
        auto operator()(const TupleElement<LinArgsIdx, AllArgs<Model> >&... linArgs,
                        const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
      };
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, fluxDivergence,
                        IndexSequence<>,
                        IndexSequence<pointIndex, OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<Traits<Model>::template HasMethod<fluxDivergence>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::fluxDivergence;
 
        ModelMethod(const Model& model, const F& f = F())
          : model_(model), f_(f)
        {}
 
        template<class Quadrature>
        auto fluxDivergence(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return f_(model_.fluxDivergence(std::get<InnerArgsIdx>(std::forward_as_tuple(x, args...))...));
        }
 
        template<class Quadrature>
        auto operator()(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return fluxDivergence(x, args...);
        }
 
       private:
        const Model& model_;
        const F& f_;
      };
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, fluxDivergence,
                        IndexSequence<>,
                        IndexSequence<OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<Traits<Model>::template HasMethod<fluxDivergence>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::fluxDivergence;
 
        ModelMethod(const Model& model, const F& f = F())
          : model_(model), f_(f)
        {}
 
        auto fluxDivergence(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return f_(model_.fluxDivergence(std::get<InnerArgsIdx>(std::forward_as_tuple(args...))...));
        }
 
        auto operator()(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return fluxDivergence(args...);
        }
 
       private:
        const Model& model_;
        const F& f_;
      };
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, fluxDivergence,
                        IndexSequence<>,
                        IndexSequence<pointIndex, OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<!Traits<Model>::template HasMethod<fluxDivergence>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::fluxDivergence;
 
        ModelMethod(const Model& model, const F& f = F())
        {}
 
        template<class Quadrature>
        auto fluxDivergence(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
 
        template<class Quadrature>
        auto operator()(const QuadraturePoint<Quadrature>& x, const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
      };
 
      template<class Model, class F, std::size_t... OuterArgsIdx, std::size_t... InnerArgsIdx>
      class ModelMethod<Model, F, fluxDivergence,
                        IndexSequence<>,
                        IndexSequence<OuterArgsIdx...>,
                        IndexSequence<InnerArgsIdx...>,
                        std::enable_if_t<!Traits<Model>::template HasMethod<fluxDivergence>::value> >
      {
       public:
        static constexpr MethodTag tag = ModelIntrospection::fluxDivergence;
 
        ModelMethod(const Model& model, const F& f = F())
        {}
 
        auto fluxDivergence(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
 
        auto operator()(const TupleElement<OuterArgsIdx, AllArgs<Model> >&... args) const
        {
          return typename Traits<Model>::template ReturnType<tag>(0);
        }
      };
 
      template<class ReturnValueFunctor,
               class Model,
               class Methods = typename ModelTraits<Model>::Methods,
               class Signatures = typename ModelTraits<Model>::MethodCallSignatures>
      class UnaryModelExpression;
 
      template<class F, class Model, std::size_t... tag, class Signatures>
      class UnaryModelExpression<F, Model, IndexSequence<tag...>, Signatures>
        : public ModelBase<typename std::decay_t<Model>::DomainFunctionSpaceType,
                           typename std::decay_t<Model>::RangeFunctionSpaceType>
        , public Expressions::Storage<F, Model>
        // Expressions model rvalues. We are constant if the
        // underlying expression claims to be so or if we store a copy
        // and the underlying expression is "independent"
        // (i.e. determined at runtime only by the contained data), or
        // if the value of the expression is just a compile-time
        // constant.
        , public MPL::UniqueTags<
            typename AssumeTraits<F>::Properties,
            ConditionalType<(IsConstantExprArg<Model>::value
                             && !FunctorHas<IsIndeterminateOperation, F>::value
                             && !FunctorHas<IsPlaceholderOperation, F>::value
              ), ConstantExpression, void>,
            ConditionalType<(IsTypedValue<Model>::value
                             && !FunctorHas<IsDynamicOperation, F>::value
                             && !FunctorHas<IsIndeterminateOperation, F>::value
                             && !FunctorHas<IsPlaceholderOperation, F>::value
              ), TypedValueExpression, void> >
        // end of tag promotion
        , public TaggedModelMethod<std::decay_t<Model>, tag, Get<tag, Signatures>::value, F>...
      {
        using StorageType = Expressions::Storage<F, Model>;
       protected:
        using StorageType::t0_;
       public:
        using StorageType::operand;
        using StorageType::operation;
        using typename StorageType::OperationType;
        using typename StorageType::FunctorType;
        using TraitsType = ModelTraits<Model>;
        using UnaryOperationType = typename F::OperationType;
        using ModelType = Model;
        using ModelDecay = std::decay_t<Model>;
 
        /* Models need to be captured by value as the entire
         * expression must be copyable in a way that bind(otherEntity)
         * does not affect the original copy.
         */
        static_assert(std::is_same<ModelType, ModelDecay>::value,
                      "Models need to be captured by value.");
 
        template<class ModelArg, class FArg, std::enable_if_t<std::is_constructible<StorageType, FArg, ModelArg>::value, int> = 0>
        UnaryModelExpression(ModelArg&& model, FArg&& f)
          : StorageType(std::forward<FArg>(f), std::forward<ModelArg>(model))
          , TaggedModelMethod<ModelDecay, tag, Get<tag, Signatures>::value, F>(this->model(), operation())...
        {}
 
        template<class ModelArg, std::enable_if_t<std::is_constructible<StorageType, F, ModelArg>::value, int> = 0>
        UnaryModelExpression(ModelArg&& model)
          : UnaryModelExpression(std::forward<ModelArg>(model), F{})
        {}
 
        UnaryModelExpression(const UnaryModelExpression& other)
          : StorageType(other)
          , TaggedModelMethod<ModelDecay, tag, Get<tag, Signatures>::value, F>(model(), operation())...
        {}
 
        UnaryModelExpression(UnaryModelExpression&& other)
          : StorageType(std::move(other))
          , TaggedModelMethod<ModelDecay, tag, Get<tag, Signatures>::value, F>(model(), operation())...
        {}
 
        UnaryModelExpression& operator=(const UnaryModelExpression& other)
        {
          static_cast<StorageType>(*this) = other;
          return *this;
        }
 
        UnaryModelExpression& operator=(UnaryModelExpression&& other)
        {
          static_cast<StorageType>(*this) = std::move(other);
          return *this;
        }
 
        template<class T,
                 std::enable_if_t<(Expressions::EmitByValueV<T>
                                   && std::is_same<T, ModelDecay>::value
                                   && (IsIdentityOperation<OperationType>::value
                                       ||
                                       IsClosureOperation<OperationType>::value)
          ), int> = 0>
        operator T () const { return operand(0_c); }
 
        template<class T,
                 std::enable_if_t<(!Expressions::EmitByValueV<T>
                                   && std::is_same<T, ModelDecay>::value
                                   && (IsIdentityOperation<OperationType>::value
                                       ||
                                       IsClosureOperation<OperationType>::value)
          ), int> = 0>
        operator T () && { return operand(0_c); }
 
        template<class T,
                 std::enable_if_t<(!Expressions::EmitByValueV<T>
                                   && std::is_same<T, ModelDecay>::value
                                   && (IsIdentityOperation<OperationType>::value
                                       ||
                                       IsClosureOperation<OperationType>::value)
          ), int> = 0>
        operator T& () & { return operand(0_c); }
 
        template<class T,
                 std::enable_if_t<(!Expressions::EmitByValueV<T>
                                   && std::is_same<T, ModelDecay>::value
                                   && (IsIdentityOperation<OperationType>::value
                                       ||
                                       IsClosureOperation<OperationType>::value)
          ), int> = 0>
        operator const T& () const& { return operand(0_c); }
 
        template<class Entity>
        void bind(const Entity& entity)
        {
          model().bind(entity);
        }
 
        void unbind()
        {
          model().unbind();
        }
 
        template<class Intersection>
        auto classifyBoundary(const Intersection& intersection)
        {
          return model().classifyBoundary(intersection);
        }
 
        std::string name() const
        {
          return operationName(operation(), model().name());
        }
 
       protected:
        constexpr auto&& model() && { return t0_; }
        constexpr auto& model() & { return t0_; }
        constexpr const auto& model() const& { return t0_; }
      };
 
      template<class F, class T, std::enable_if_t<IsPDEModel<T>::value, int> = 0>
      constexpr auto operate(Expressions::DontOptimize, F, const T& t)
      {
        DUNE_ACFEM_RECORD_OPTIMIZATION;
 
        return UnaryModelExpression<F, T>(t, F{});
      }
 
    } // PDEModel
 
    template<class Model,
             std::size_t tag,
             std::size_t signature = Get<tag, typename ModelTraits<Model>::MethodCallSignatures>::value>
    using ModelMethod = PDEModel::TaggedModelMethod<Model, tag, signature>;
 
    template<class Model, std::size_t tag>
    using ModelClosureMethod = PDEModel::TaggedModelMethod<
      Model, tag, ModelIntrospection::MethodSignatureClosure<tag>::value>;
 
    template<class F, class Model>
    using UnaryModelExpression = PDEModel::UnaryModelExpression<F, Model>;
 
 
 
  } // namespace ACFem
 
} // namespace Dune
 
 
#endif //  __DUNE_ACFEM_MODELES_UNARYEXPRESSION_HH__