divergencemodel.hh

#ifndef __DUNE_ACFEM_MODELS_MODULES_DIVERGENCEMODEL_HH__
#define __DUNE_ACFEM_MODELS_MODULES_DIVERGENCEMODEL_HH__
 
#include <dune/fem/gridpart/common/gridpart.hh>
 
#include "../../common/gridfunctionspace.hh"
#include "../../expressions/terminal.hh"
#include "../modelbase.hh"
#include "../expressiontraits.hh"
 
namespace Dune {
 
  namespace ACFem::PDEModel {
 
    template<class FunctionSpace>
    class DivergenceModel
      : public ModelBase<FunctionSpace, typename FunctionSpace::ScalarFunctionSpaceType>
      , public Expressions::SelfExpression<DivergenceModel<FunctionSpace> >
      , public TypedValueExpression
    {
      static_assert(FunctionSpace::dimRange == FunctionSpace::dimDomain,
                    "DomainFunctionSpace must be a vector field with dimRange == dimDomain");
      using ThisType = DivergenceModel;
      using BaseType = ModelBase<FunctionSpace, typename FunctionSpace::ScalarFunctionSpaceType>;
     public:
      using typename BaseType::DomainJacobianRangeType;
      using typename BaseType::RangeRangeType;
      using BaseType::domainDimRange;
 
      DivergenceModel(const std::string& name)
        : name_(name == "" ? "(div U)" : name)
      {}
 
      std::string name() const
      {
        return name_;
      }
 
      RangeRangeType linearizedSource(const DomainJacobianRangeType& jacobian) const
      {
        RangeRangeType result(jacobian[0][0]);
        for (int i = 0; i < domainDimRange; ++i) {
          result += jacobian[i][i];
        }
        return result;
      }
 
    protected:
      const std::string name_;
    };
 
 
 
    template<class Object,
             std::enable_if_t<Object::FunctionSpaceType::ScalarFunctionSpaceType::dimRange == 1, int> = 0>
    static inline auto
    divergenceModel(const Object& object, const std::string& name = "")
    {
      using FunctionSpace = typename Object::FunctionSpaceType;
      return expressionClosure(DivergenceModel<typename Fem::ToNewDimRangeFunctionSpace<FunctionSpace, FunctionSpace::dimDomain>::Type>(name));
    }
 
    template<class GridPartTraits>
    static inline auto
    divergenceModel(const Fem::GridPartInterface<GridPartTraits>& gridPart,
                    const std::string& name = "")
    {
      using GridPartType = typename Fem::GridPartInterface<GridPartTraits>::GridPartType;
      return divergenceModel(GridFunctionSpace<GridPartType>{}, name);
    }
 
 
 
 
  } // namespace ACFem::PDEModel
 
  namespace ACFem {
 
    using PDEModel::divergenceModel;
 
  }
 
}  //Namespace Dune
 
 
#endif // __DUNE_ACFEM_MODELS_MODULES_DIVERGENCEMODEL_HH__