robinmodel.hh

#ifndef __DUNE_ACFEM_MODELS_MODULES_ROBINMODEL_HH__
#define __DUNE_ACFEM_MODELS_MODULES_ROBINMODEL_HH__
 
#include "../indicators/boundaryindicator.hh"
#include "../modelbase.hh"
#include "../expressiontraits.hh"
 
namespace Dune {
 
  namespace ACFem::PDEModel {
 
    template<class FunctionSpace, class Indicator = EntireBoundaryIndicator>
    class RobinBoundaryModel
      : public ModelBase<FunctionSpace>
      , public Expressions::SelfExpression<RobinBoundaryModel<FunctionSpace, Indicator> >
      , public MPL::UniqueTags<ConditionalType<ExpressionTraits<Indicator>::isVolatile, VolatileExpression, void>,
                               ConditionalType<IsConstantExprArg<Indicator>::value, ConstantExpression, void>,
                               ConditionalType<IsTypedValue<Indicator>::value, TypedValueExpression, void>,
                               PositiveExpression,
                               SymmetricModel>
    {
      using ThisType = RobinBoundaryModel;
      using BaseType = ModelBase<FunctionSpace>;
     public:
      typedef Indicator IndicatorType;
 
      using typename BaseType::DomainType;
      using typename BaseType::RangeType;
      using typename BaseType::BoundaryConditionsType;
      using BaseType::dimRange;
 
      template<class IndicatorArg,
               std::enable_if_t<(std::is_constructible<Indicator, IndicatorArg>::value
                                 && std::is_default_constructible<IndicatorArg>::value
        ), int> = 0>
      RobinBoundaryModel(IndicatorArg&& indicator = IndicatorArg(), const std::string& name = "")
        : indicator_(std::forward<IndicatorArg>(indicator)),
          supported_(false, std::bitset<dimRange>()),
          name_(name == "" ? "Robin(1)" : name)
      {}
 
      template<class IndicatorArg,
               std::enable_if_t<(std::is_constructible<Indicator, IndicatorArg>::value
                                 && !std::is_default_constructible<IndicatorArg>::value
        ), int> = 0>
      RobinBoundaryModel(IndicatorArg&& indicator, const std::string& name = "")
        : indicator_(std::forward<IndicatorArg>(indicator)),
          supported_(false, std::bitset<dimRange>()),
          name_(name == "" ? "Robin(1)" : name)
      {}
 
      std::string name() const
      {
        return name_;
      }
 
     protected:
      enum {
        emptySupport = IndicatorTraits<IndicatorType>::emptySupport,
        globalSupport = IndicatorTraits<IndicatorType>::globalSupport
      };
 
     public:
      template<class Intersection>
      auto classifyBoundary(const Intersection& intersection)
      {
        supported_.first = IndicatorTraits<IndicatorType>::globalSupport || indicator_.applies(intersection);
        return supported_;
      }
 
      auto linearizedRobinFlux(const DomainType& unitOuterNormal,
                               const RangeType& value) const
      {
        if constexpr (globalSupport) {
          return value;
        } else if constexpr (emptySupport) {
          return zero(value);
        } else {
          return supported_.first ? value : RangeType(0.);
        }
      }
 
     protected:
      IndicatorType indicator_;
      BoundaryConditionsType supported_;
      std::string name_;
    };
 
 
    template<class Object, class Indicator = EntireBoundaryIndicator>
    constexpr  auto
    robinZeroModel(const Object& object,
                   Indicator&& where = Indicator{},
                   const std::string& name = "")
    {
      typedef RobinBoundaryModel<typename Object::FunctionSpaceType, Indicator> ModelType;
      return expressionClosure(ModelType(std::forward<Indicator>(where), name));
    }
 
    template<class Object, class Indicator, std::enable_if_t<ExpressionTraits<Indicator>::isZero, int> = 0>
    constexpr  auto
    robinZeroModel(const Object& object, Indicator&& where, const std::string& name = "")
    {
      return zeroModel(object);
    }
 
    template<class GridFunction, class Indicator = EntireBoundaryIndicator>
    constexpr auto
    robinBoundaryModel(GridFunction&& values,
                       Indicator&& where = Indicator(),
                       const std::string& name = "")
    {
      return
        robinZeroModel(
          std::forward<GridFunction>(values), std::forward<Indicator>(where), name)
        +
        neumannBoundaryModel(
          std::forward<GridFunction>(values), std::forward<Indicator>(where), name);
    }
 
 
 
 
  } // namespace ACFem::PDEModel::
 
  namespace ACFem {
 
    using PDEModel::robinBoundaryModel;
    using PDEModel::robinZeroModel;
 
  }
 
}  //Namespace Dune
 
 
#endif // __DUNE_ACFEM_MODELS_MODULES_ROBINMODEL_HH__