incompressibleselftransportmodel.hh

#ifndef __DUNE_ACFEM_MODELS_MODULES_INCOMPRESSIBLESELFTRANSPORTMODEL_HH__
#define __DUNE_ACFEM_MODELS_MODULES_INCOMPRESSIBLESELFTRANSPORTMODEL_HH__
 
#include "../../expressions/terminal.hh"
 
#include "../modelbase.hh"
 
namespace Dune {
 
  namespace ACFem::PDEModel {
 
    template<class FunctionSpace>
    class IncompressibleSelfTransportModel
      : public ModelBase<FunctionSpace>
      , public Expressions::SelfExpression<IncompressibleSelfTransportModel<FunctionSpace> >
      , public TypedValueExpression
    {
      using ThisType = IncompressibleSelfTransportModel;
      using BaseType = ModelBase<FunctionSpace>;
     public:
      using typename BaseType::RangeType;
      using typename BaseType::JacobianRangeType;
      using BaseType::dimDomain;
      using BaseType::dimRange;
 
      static constexpr int dimWorld = dimDomain;
 
      static_assert(dimDomain == dimRange && dimDomain == dimWorld,
                    "This is meant for dimensionworld vector-fields, "
                    "like fluids, deformations etc.");
 
      // Interface methods that need to be reimplemented
 
      IncompressibleSelfTransportModel(const std::string& name = "")
        : name_(name == "" ? "U_iD_iU_j" : name)
      {}
 
      std::string name() const
      {
        return name_;
      }
 
      auto source(const RangeType& value,
                  const JacobianRangeType& jacobian) const
      {
        RangeType result;
        jacobian.mv(value, result);
        return result;
      }
 
      auto linearizedSource(const RangeType& uBar,
                            const JacobianRangeType& DuBar,
                            const RangeType& value,
                            const JacobianRangeType& jacobian) const
      {
        RangeType result;
        DuBar.mv(value, result);
        jacobian.umv(uBar, result);
        return result;
      }
 
     protected:
      std::string name_;
    };
 
 
    template<class Object>
    static inline auto
    incompressibleSelfTransportModel(const Object& object, const std::string& name = "")
    {
      return expressionClosure(IncompressibleSelfTransportModel<typename Object::FunctionSpaceType>(name));
    }
 
 
 
 
  } // namespace ACFem::PDEModel
 
  namespace ACFem {
 
    using PDEModel::incompressibleSelfTransportModel;
 
  }
 
}  //Namespace Dune
 
 
#endif // __DUNE_ACFEM_MODELS_MODULES_INCOMPRESSIBLESELFTRANSPORTMODEL_HH__