modelfacade.hh

#ifndef __DUNE_ACFEM_MODELS_MODELFACADE_HH__
#define __DUNE_ACFEM_MODELS_MODELFACADE_HH__
 
#include "expressions.hh"
 
namespace Dune {
 
  namespace ACFem::PDEModel {
 
    template<class Model, std::enable_if_t<IsPDEModel<Model>::value, int> = 0>
    auto modelFacade(Model&& m)
    {
      return closure(std::forward<Model>(m), PDEModel::AllMethodTags{});
    }
 
#ifndef DOXYGEN
    template<class Model>
    using ModelFacade = decltype(modelFacade(std::declval<Model>()));
#else
    template<class ModelImpl>
    class ModelFacade
    {
      typedef ModelBase<typename ModelImpl::DomainFunctionSpaceType,
                        typename ModelImpl::RangeFunctionSpaceType> ModelBaseType;
      typedef ModelFacade ThisType;
      typedef OperationTraits<IdentityOperation> FunctorType;
      typedef
      PDEModel::UnaryModelExpression<FunctorType, ModelImpl,
                                     ModelIntrospection::AllMethodTags,
                                     ModelIntrospection::MethodSignaturesClosureType>
      MethodProvider;
     public:
      typedef ModelImpl ModelType;
      typedef ModelIntrospection::Traits<ModelType> TraitsType;
 
      typedef typename ModelType::DomainType DomainType;
 
      typedef typename ModelType::FunctionSpaceType FunctionSpaceType;
      typedef typename ModelType::DomainFunctionSpaceType DomainFunctionSpaceType;
      typedef typename ModelType::RangeFunctionSpaceType RangeFunctionSpaceType;
 
      typedef typename ModelType::RangeType RangeType;
      typedef typename ModelType::JacobianRangeType JacobianRangeType;
      typedef typename ModelType::HessianRangeType HessianRangeType;
 
      typedef typename ModelType::RangeRangeType RangeRangeType;
      typedef typename ModelType::RangeJacobianRangeType RangeJacobianRangeType;
      typedef typename ModelType::RangeHessianRangeType RangeHessianRangeType;
 
      typedef typename ModelType::DomainRangeType DomainRangeType;
      typedef typename ModelType::DomainJacobianRangeType DomainJacobianRangeType;
      typedef typename ModelType::DomainHessianRangeType DomainHessianRangeType;
 
      typedef typename ModelType::BoundaryConditionsType BoundaryConditionsType;
 
      static_assert(std::is_base_of<ModelBaseType, ModelType>::value,
                    "A PDE-model is required to derive from class ModelBase");
 
      ModelFacade(const ModelType& model)
        : methodProvider_(model)
      {}
 
      ModelFacade(const ModelFacade& other)
        : methodProvider_(other.methodProvider_)
      {}
 
      ModelFacade(ModelFacade&& other)
        : methodProvider_(std::move(other.methodProvider_))
      {}
 
      operator const ModelType&() const { return methodProvider_.model(); }
 
      operator ModelType&() { return methodProvider_.model(); }
 
      ModelType& model()
      {
        return methodProvider_.model();
      }
 
      const ModelType& model() const
      {
        return methodProvider_.model();
      }
 
      template<class Entity>
      void bind(const Entity& entity)
      {
        model().bind(entity);
      }
 
      void unbind()
      {
        model().unbind();
      }
 
      template<class Intersection>
      BoundaryConditionsType classifyBoundary(const Intersection& intersection)
      {
        return model().classifyBoundary(intersection);
      }
 
      std::string name() const
      {
        return model().name();
      }
 
      template<class Quadrature>
      auto flux(const QuadraturePoint<Quadrature>& x,
                const DomainRangeType& value,
                const DomainJacobianRangeType& jacobian) const
      {
        return methodProvider_.flux(x, value, jacobian);
      }
 
      template<class Quadrature>
      auto linearizedFlux(const DomainRangeType& uBar,
                          const DomainJacobianRangeType& DuBar,
                          const QuadraturePoint<Quadrature>& x,
                          const DomainRangeType& value,
                          const DomainJacobianRangeType& jacobian) const
      {
        return methodProvider_.linearizedFlux(uBar, DuBar, x, value, jacobian);
      }
 
      template<class Quadrature>
      auto source(const QuadraturePoint<Quadrature>& x,
                  const DomainRangeType& value,
                  const DomainJacobianRangeType& jacobian) const
      {
        return methodProvider_.source(x, value, jacobian);
      }
 
      template<class Quadrature>
      auto linearizedSource(const DomainRangeType& uBar,
                            const DomainJacobianRangeType& DuBar,
                            const QuadraturePoint<Quadrature>& x,
                            const DomainRangeType& value,
                            const DomainJacobianRangeType& jacobian) const
      {
        return methodProvider_.linearizedSource(uBar, DuBar, x, value, jacobian);
      }
 
      template<class Quadrature>
      auto robinFlux(const QuadraturePoint<Quadrature>& x,
                     const DomainType& unitOuterNormal,
                     const DomainRangeType& value,
                     const DomainJacobianRangeType& jacobian) const
      {
        return methodProvider_.robinFlux(x, unitOuterNormal, value, jacobian);
      }
 
      template<class Quadrature>
      auto linearizedRobinFlux(const DomainRangeType& uBar,
                               const DomainJacobianRangeType& DuBar,
                               const QuadraturePoint<Quadrature>& x,
                               const DomainType& unitOuterNormal,
                               const DomainRangeType& value,
                               const DomainJacobianRangeType& jacobian) const
      {
        return methodProvider_.linearizedRobinFlux(uBar, DuBar, x, unitOuterNormal, value, jacobian);
      }
 
      template<class Quadrature>
      auto singularFlux(const QuadraturePoint<Quadrature>& x,
                        const DomainType& unitOuterNormal,
                        const DomainRangeType& value,
                        const DomainJacobianRangeType& jacobian) const
      {
        return methodProvider_.singularFlux(x, unitOuterNormal, value, jacobian);
      }
 
      template<class Quadrature>
      auto linearizedSingularFlux(const DomainRangeType& uBar,
                                  const DomainJacobianRangeType& DuBar,
                                  const QuadraturePoint<Quadrature>& x,
                                  const DomainType& unitOuterNormal,
                                  const DomainRangeType& value,
                                  const DomainJacobianRangeType& jacobian) const
      {
        return methodProvider_.linearizedSingularFlux(uBar, DuBar, x, unitOuterNormal, value, jacobian);
      }
 
      template<class Quadrature>
      auto fluxDivergence(const QuadraturePoint<Quadrature>& x,
                          const DomainRangeType& value,
                          const DomainJacobianRangeType& jacobian,
                          const DomainHessianRangeType& hessian) const
      {
        return methodProvider_.fluxDivergence(x, value, jacobian, hessian);
      }
 
      template<class Quadrature>
      auto dirichlet(const QuadraturePoint<Quadrature>& x,
                     const DomainRangeType& value) const
      {
        return methodProvider_.dirichlet(x, value);
      }
 
      template<class Quadrature>
      auto linearizedDirichlet(const DomainRangeType& uBar,
                               const QuadraturePoint<Quadrature>& x,
                               const DomainRangeType& value) const
      {
        return methodProvider_.linearizedDirichlet(uBar, x, value);
      }
 
      friend std::ostream& operator<<(std::ostream& out, const ThisType& arg)
      {
        return out << arg.model();
      }
 
     private:
      MethodProvider methodProvider_;
    };
#endif
 
 
 
  } // namespace ACFem::PDEModel::
 
  namespace ACFem {
 
    using PDEModel::modelFacade;
    using PDEModel::ModelFacade;
 
  }
 
}  //Namespace Dune
 
#endif  // __DUNE_ACFEM_MODELS_MODELFACADE_HH__