expressiontraits.hh

#ifndef __DUNE_ACFEM_MODELS_EXPRESSIONTRAITS_HH__
#define __DUNE_ACFEM_MODELS_EXPRESSIONTRAITS_HH__
 
#include "../expressions/traitsdefault.hh"
#include "../tensors/tensorbase.hh"
#include "../functions/functiontraits.hh"
 
#include "expressionoperations.hh"
#include "modeltraits.hh"
//#include "closuretraits.hh"
#include "definiteness.hh"
#include "symmetry.hh"
 
namespace Dune
{
 
  namespace ACFem
  {
 
    template<class Model>
    struct ExpressionTraits<Model,
                            std::enable_if_t<IsPDEModel<Model>::value>,
                            TraitsPriority::Secondary>
    : ConditionalType<ModelTraits<Model>::isZero,
                      ZeroExpressionTraits<Model>,
                      BaseExpressionTraits<Model> >
    {
      using Definiteness = decltype(definiteness(std::declval<Model>()));
      static constexpr bool isSymmetric = decltype(PDEModel::isSymmetric(std::declval<Model>()))::value;
    };
 
    namespace PDEModel {
 
      template<class Model>
      using EffectiveModel = ConditionalType<IsClosureExpression<Model>::value,
                                             Expressions::Operand<0, Model>,
                                             Model>;
 
      template<class Model>
      using EffectiveModelTraits = ModelTraits<EffectiveModel<Model> >;
 
      template<class T>
      using IsProperPDEModel = BoolConstant<(IsPDEModel<T>::value && !Expressions::IsPromotedTopLevel<T>::value)>;
 
      template<class T>
      using IsProperMultiplicationOperand =
        BoolConstant<(!Expressions::IsPromotedTopLevel<T>::value
                      &&
                      ((IsTensor<T>::value && TensorTraits<T>::rank == 0)
                       || GridFunction::RangeTensorTraits<T>::rank == 0))>;
 
      template<class T, class SFINAE = void>
      struct RangeTensorTraits
        : TensorTraits<typename ModelTraits<T>::RangeType>
      {};
 
      template<class T>
      struct RangeTensorTraits<T, std::enable_if_t<ModelTraits<T>::dimRange == 1> >
        : TensorTraits<typename ModelTraits<T>::RangeFieldType>
      {};
 
      template<class Model>
      using SkeletonSymmetrizeDefault =
        Sign<(ModelMethodExists<EffectiveModel<Model>, ModelIntrospection::flux>::value
              &&
              EffectiveModelTraits<Model>::template IsAffineLinear<ModelIntrospection::flux>::value
              &&
              ExpressionTraits<Model>::isSymmetric)>;
 
    } // PDEModel::
 
 
 
 
  } // namespace ACFem
 
} // namespace Dune
 
#endif // __DUNE_ACFEM_MODELS_EXPRESSIONTRAITS_HH__