modelbase.hh

#ifndef __DUNE_ACFEM_MODELS_MODELBASE_HH__
#define __DUNE_ACFEM_MODELS_MODELBASE_HH__
 
#include <bitset>
#include <dune/fem/space/common/functionspace.hh>
#include <dune/fem/common/explicitfieldvector.hh>
 
#include "../expressions/constantoperations.hh"
#include "../expressions/expressionoperations.hh"
#include "../common/quadraturepoint.hh"
 
namespace Dune {
 
  namespace ACFem {
 
    template<class DomainFunctionSpace, class RangeFunctionSpace = DomainFunctionSpace>
    struct ModelBase
    {
      template<class FunctionSpace>
      using HessianRangeSelector = typename std::conditional<
        std::is_convertible<typename FunctionSpace::RangeType, typename FunctionSpace::HessianRangeType>::value,
        Fem::ExplicitFieldVector<typename FunctionSpace::HessianRangeType::value_type, FunctionSpace::dimRange>,
        typename FunctionSpace::HessianRangeType>::type;
 
      using RangeFunctionSpaceType = RangeFunctionSpace; 
      using DomainFunctionSpaceType = DomainFunctionSpace; 
      using FunctionSpaceType = RangeFunctionSpaceType; 
 
      using DomainType = typename FunctionSpaceType::DomainType; 
      using RangeType = typename FunctionSpaceType::RangeType; 
      using JacobianRangeType = typename FunctionSpaceType::JacobianRangeType; 
      //using HessianRangeType = typename FunctionSpaceType::HessianRangeType; //!
      using HessianRangeType = HessianRangeSelector<FunctionSpaceType>;
      using DomainFieldType = typename FunctionSpaceType::DomainFieldType; 
      using RangeFieldType = typename FunctionSpaceType::RangeFieldType; 
 
      using DomainRangeType = typename DomainFunctionSpaceType::RangeType; 
      using DomainDomainType = typename DomainFunctionSpaceType::DomainType; 
      using DomainJacobianRangeType = typename DomainFunctionSpaceType::JacobianRangeType; 
      //using DomainHessianRangeType = typename DomainFunctionSpaceType::HessianRangeType; //!
      using DomainHessianRangeType = HessianRangeSelector<DomainFunctionSpaceType>;
      using DomainDomainFieldType = typename DomainFunctionSpaceType::DomainFieldType; 
      using DomainRangeFieldType = typename DomainFunctionSpaceType::RangeFieldType; 
 
      using RangeRangeType = typename RangeFunctionSpaceType::RangeType; 
      using RangeDomainType = typename RangeFunctionSpaceType::DomainType; 
      using RangeJacobianRangeType = typename RangeFunctionSpaceType::JacobianRangeType; 
      //using RangeHessianRangeType = typename RangeFunctionSpaceType::HessianRangeType; //!
      using RangeHessianRangeType = HessianRangeSelector<RangeFunctionSpaceType>;
      using RangeDomainFieldType = typename RangeFunctionSpaceType::DomainFieldType; 
      using RangeRangeFieldType = typename RangeFunctionSpaceType::RangeFieldType; 
 
      static constexpr int dimDomain = FunctionSpaceType::dimDomain; 
      static constexpr int dimRange = FunctionSpaceType::dimRange; 
      static constexpr int domainDimDomain = DomainFunctionSpaceType::dimDomain; 
      static constexpr int domainDimRange = DomainFunctionSpaceType::dimRange; 
      static constexpr int rangeDimDomain = RangeFunctionSpaceType::dimDomain; 
      static constexpr int rangeDimRange = RangeFunctionSpaceType::dimRange; 
 
      static_assert(domainDimDomain == rangeDimDomain,
                    "Function-space need to live on the same domain");
 
      using BoundaryConditionsType = std::pair<bool, std::bitset<dimRange> >;
 
      std::string name() const
      {
        return "Hi! I am the base class of all models!";
      }
 
      template<class Entity>
      void bind(const Entity& entity)
      {}
 
      void unbind()
      {}
 
      template<class Intersection>
      auto classifyBoundary(const Intersection& intersection)
      {
        return BoundaryConditionsType();
      }
    };
 
 
 
  } // namespace ACFem
 
}  //Namespace Dune
 
#endif  // __DUNE_ACFEM_MODELS_MODELBASE_HH__