12#ifndef DUMUX_NAVIERSTOKES_MOMENTUM_FLUXVARIABLES_HH 
   13#define DUMUX_NAVIERSTOKES_MOMENTUM_FLUXVARIABLES_HH 
   35template<
class TypeTag>
 
   40    using GridVolumeVariables = 
typename GridVariables::GridVolumeVariables;
 
   41    using ElementVolumeVariables = 
typename GridVolumeVariables::LocalView;
 
   42    using VolumeVariables = 
typename GridVolumeVariables::VolumeVariables;
 
   44    using GridFluxVariablesCache = 
typename GridVariables::GridFluxVariablesCache;
 
   45    using ElementFluxVariablesCache = 
typename GridFluxVariablesCache::LocalView;
 
   46    using FluxVariablesCache = 
typename GridFluxVariablesCache::FluxVariablesCache;
 
   48    using GridGeometry = 
typename GridVariables::GridGeometry;
 
   49    using FVElementGeometry = 
typename GridGeometry::LocalView;
 
   50    using SubControlVolume = 
typename FVElementGeometry::SubControlVolume;
 
   51    using SubControlVolumeFace = 
typename FVElementGeometry::SubControlVolumeFace;
 
   56    using GridView = 
typename GridGeometry::GridView;
 
   57    using Element = 
typename GridView::template Codim<0>::Entity;
 
   60    using Indices = 
typename ModelTraits::Indices;
 
   63    using GlobalPosition = 
typename Element::Geometry::GlobalCoordinate;
 
   73                                      const SubControlVolumeFace& 
scvFace,
 
   87                == 
static_cast<std::size_t
>(GridView::dimension),
 
   88            "Expects problem.dirichlet to return an array with as many entries as dimensions." 
 
   93    { 
return *problemPtr_; }
 
 
   96    { 
return *elementPtr_; }
 
 
   98    const SubControlVolumeFace& 
scvFace()
 const 
   99    { 
return *scvFacePtr_; }
 
 
  102    { 
return *fvGeometryPtr_; }
 
 
  105    { 
return *elemVolVarsPtr_; }
 
 
  108    { 
return *elemFluxVarsCachePtr_; }
 
 
  111    { 
return *elemBcTypesPtr_; }
 
 
  118        if (!this->
problem().enableInertiaTerms())
 
  119            return NumEqVector(0.0);
 
  121        if (this->
scvFace().isFrontal())
 
 
  132        if (this->
scvFace().isFrontal())
 
 
  158        const auto& scvf = this->
scvFace();
 
  159        assert(scvf.isFrontal());
 
  161        NumEqVector result(0.0);
 
  171        static const bool enableUnsymmetrizedVelocityGradient
 
  173        static const Scalar factor = enableUnsymmetrizedVelocityGradient ? 1.0 : 2.0;
 
  176        result -= factor * mu * velGradII * Extrusion::area(
fvGeometry, scvf) * 
elemVolVars[scvf.insideScvIdx()].extrusionFactor() * scvf.directionSign();
 
  179        if (enableDilatationTerm)
 
  181            Scalar divergence = velGradII;
 
  184                const auto otherFrontalScvf = *(scvfs(
fvGeometry, scv).begin());
 
  185                assert(otherFrontalScvf.isFrontal() && !otherFrontalScvf.boundary());
 
  186                if (otherFrontalScvf.index() != scvf.index())
 
  190            result += 2.0/3.0 * mu * divergence * scvf.directionSign() * Extrusion::area(
fvGeometry, scvf) * 
elemVolVars[scvf.insideScvIdx()].extrusionFactor();
 
 
  220        const auto& scvf = this->
scvFace();
 
  221        assert(scvf.isLateral());
 
  223        NumEqVector result(0.0);
 
  227        const auto& scv = 
fvGeometry.scv(scvf.insideScvIdx());
 
  229        static const bool enableUnsymmetrizedVelocityGradient
 
  238        GlobalPosition gradVn(0.0);
 
  239        gradV.mv(scvf.unitOuterNormal(), gradVn);
 
  240        const Scalar velocityGrad_ij = gradVn[scv.dofAxis()];
 
  241        result -= mu * velocityGrad_ij;
 
  244        if (!enableUnsymmetrizedVelocityGradient)
 
  246            GlobalPosition gradVTransposedN(0.0);
 
  247            gradV.mtv(scvf.unitOuterNormal(), gradVTransposedN);
 
  248            const Scalar velocityGrad_ji = gradVTransposedN[scv.dofAxis()];
 
  249            result -= mu * velocityGrad_ji;
 
  253        return result * Extrusion::area(
fvGeometry, scvf) * 
elemVolVars[scvf.insideScvIdx()].extrusionFactor();
 
 
  274        NumEqVector result(0.0);
 
  275        const auto& scvf = this->
scvFace();
 
  276        if (scvf.isLateral() || scvf.boundary())
 
  281        result = pressure*Extrusion::area(this->
fvGeometry(), scvf)*this->
elemVolVars()[scvf.insideScvIdx()].extrusionFactor();
 
  292        result -= referencePressure*scvf.area();
 
  295        result *= scvf.directionSign();
 
 
  319        const auto& scvf = this->
scvFace();
 
  320        assert(scvf.isFrontal());
 
  324        const auto velocitySelf = 
elemVolVars[scvf.insideScvIdx()].velocity();
 
  325        const auto velocityOpposite = 
elemVolVars[scvf.outsideScvIdx()].velocity();
 
  328        const Scalar transportingVelocity = (velocitySelf + velocityOpposite) * 0.5;
 
  330        const bool selfIsUpstream = scvf.directionSign() == 
sign(transportingVelocity);
 
  334        const Scalar transportedMomentum = selfIsUpstream ? (upwindWeight * velocitySelf + (1.0 - upwindWeight) * velocityOpposite) * density
 
  335                                                          : (upwindWeight * velocityOpposite + (1.0 - upwindWeight) * velocitySelf) * density;
 
  337        return  transportingVelocity * transportedMomentum * scvf.directionSign() * Extrusion::area(this->
fvGeometry(), scvf) * extrusionFactor_(
elemVolVars, scvf);
 
 
  364        const auto& scvf = this->
scvFace();
 
  365        assert(scvf.isLateral());
 
  372        const Scalar transportingVelocity = [&]()
 
  374            const auto& orthogonalScvf = 
fvGeometry.lateralOrthogonalScvf(scvf);
 
  375            const Scalar innerTransportingVelocity = 
elemVolVars[orthogonalScvf.insideScvIdx()].velocity();
 
  377            static const bool useOldScheme = 
getParam<bool>(
"FreeFlow.UseOldTransportingVelocity", 
true); 
 
  381                if (scvf.boundary() && 
fvGeometry.scv(scvf.insideScvIdx()).boundary())
 
  383                    if (this->
elemBcTypes()[scvf.localIndex()].isDirichlet(scvf.normalAxis()))
 
  384                        return problem.dirichlet(this->
element(), scvf)[scvf.normalAxis()];
 
  387                    return innerTransportingVelocity;
 
  393                if (this->
elemBcTypes()[scvf.localIndex()].isDirichlet(scvf.normalAxis()))
 
  394                    return 0.5*(
problem.dirichlet(this->
element(), scvf)[scvf.normalAxis()] + innerTransportingVelocity);
 
  397            if (orthogonalScvf.boundary())
 
  399                if (this->
elemBcTypes()[orthogonalScvf.localIndex()].isDirichlet(scvf.normalAxis()))
 
  400                    return 0.5*(
problem.dirichlet(this->
element(), scvf)[scvf.normalAxis()] + innerTransportingVelocity);
 
  402                    return innerTransportingVelocity; 
 
  406            const auto insideVolume = 
fvGeometry.scv(orthogonalScvf.insideScvIdx()).volume();
 
  407            const auto outsideVolume = 
fvGeometry.scv(orthogonalScvf.outsideScvIdx()).volume();
 
  408            const auto outerTransportingVelocity = 
elemVolVars[orthogonalScvf.outsideScvIdx()].velocity();
 
  409            return (insideVolume*innerTransportingVelocity + outsideVolume*outerTransportingVelocity) / (insideVolume + outsideVolume);
 
  412        const Scalar transportedMomentum = [&]()
 
  414            const auto& insideScv = 
fvGeometry.scv(scvf.insideScvIdx());
 
  416            auto getDirichletMomentumFlux = [&]()
 
  424                if (!this->
elemBcTypes()[scvf.localIndex()].isDirichlet(insideScv.dofAxis()))
 
  425                    DUNE_THROW(Dune::InvalidStateException, 
"Neither Dirichlet nor Neumann BC set at " << scvf.ipGlobal());
 
  427                return getDirichletMomentumFlux();
 
  431                if (
fvGeometry.scvfIntegrationPointInConcaveCorner(scvf))
 
  434                    const auto& outsideScvfWithSameIntegrationPoint = 
fvGeometry.outsideScvfWithSameIntegrationPoint(scvf);
 
  435                    if (!this->
problem().boundaryTypes(this->
element(), outsideScvfWithSameIntegrationPoint).isDirichlet(insideScv.dofAxis()))
 
  436                        DUNE_THROW(Dune::InvalidStateException, 
"Neither Dirichlet nor Neumann BC set at " << outsideScvfWithSameIntegrationPoint.ipGlobal());
 
  438                    return getDirichletMomentumFlux();
 
  442            const bool selfIsUpstream = scvf.directionSign() == 
sign(transportingVelocity);
 
  444            const auto innerVelocity = 
elemVolVars[scvf.insideScvIdx()].velocity();
 
  445            const auto outerVelocity = 
elemVolVars[scvf.outsideScvIdx()].velocity();
 
  449            const auto insideMomentum = innerVelocity * rho.first;
 
  450            const auto outsideMomentum = outerVelocity * rho.second;
 
  455            return selfIsUpstream ? (upwindWeight * insideMomentum + (1.0 - upwindWeight) * outsideMomentum)
 
  456                                  : (upwindWeight * outsideMomentum + (1.0 - upwindWeight) * insideMomentum);
 
  459        return  transportingVelocity * transportedMomentum * scvf.directionSign() * Extrusion::area(
fvGeometry, scvf) * extrusionFactor_(
elemVolVars, scvf);
 
 
  464    template<
class ElementVolumeVariables, 
class SubControlVolumeFace>
 
  465    Scalar extrusionFactor_(
const ElementVolumeVariables& 
elemVolVars, 
const SubControlVolumeFace& scvf)
 const 
  467        const auto& insideVolVars = 
elemVolVars[scvf.insideScvIdx()];
 
  468        const auto& outsideVolVars = 
elemVolVars[scvf.outsideScvIdx()];
 
  469        return harmonicMean(insideVolVars.extrusionFactor(), outsideVolVars.extrusionFactor());
 
  473    const Problem* problemPtr_;                             
 
  474    const Element* elementPtr_;                             
 
  475    const FVElementGeometry* fvGeometryPtr_;                
 
  476    const SubControlVolumeFace* scvFacePtr_;                
 
  477    const ElementVolumeVariables* elemVolVarsPtr_;          
 
  478    const ElementFluxVariablesCache* elemFluxVarsCachePtr_; 
 
  479    const ElementBoundaryTypes* elemBcTypesPtr_; 
 
 
NumEqVector pressureContribution() const
Returns the frontal pressure contribution.
Definition freeflow/navierstokes/momentum/fluxvariables.hh:272
NumEqVector diffusiveMomentumFlux() const
Returns the diffusive momentum flux due to viscous forces.
Definition freeflow/navierstokes/momentum/fluxvariables.hh:130
NumEqVector frontalAdvectiveMomentumFlux() const
Returns the frontal part of the momentum flux. This treats the flux over the staggered face at the ce...
Definition freeflow/navierstokes/momentum/fluxvariables.hh:317
NumEqVector lateralAdvectiveMomentumFlux() const
Returns the advective momentum flux over the staggered face perpendicular to the scvf where the veloc...
Definition freeflow/navierstokes/momentum/fluxvariables.hh:362
NumEqVector frontalDiffusiveMomentumFlux() const
Returns the frontal part of the momentum flux. This treats the flux over the staggered face at the ce...
Definition freeflow/navierstokes/momentum/fluxvariables.hh:156
const ElementBoundaryTypes & elemBcTypes() const
Definition freeflow/navierstokes/momentum/fluxvariables.hh:110
const Problem & problem() const
Definition freeflow/navierstokes/momentum/fluxvariables.hh:92
const SubControlVolumeFace & scvFace() const
Definition freeflow/navierstokes/momentum/fluxvariables.hh:98
const FVElementGeometry & fvGeometry() const
Definition freeflow/navierstokes/momentum/fluxvariables.hh:101
NumEqVector advectiveMomentumFlux() const
Returns the diffusive momentum flux due to viscous forces.
Definition freeflow/navierstokes/momentum/fluxvariables.hh:116
NavierStokesMomentumFluxVariables(const Problem &problem, const Element &element, const FVElementGeometry &fvGeometry, const SubControlVolumeFace &scvFace, const ElementVolumeVariables &elemVolVars, const ElementFluxVariablesCache &elemFluxVarsCache, const ElementBoundaryTypes &elemBcTypes)
Definition freeflow/navierstokes/momentum/fluxvariables.hh:70
const ElementVolumeVariables & elemVolVars() const
Definition freeflow/navierstokes/momentum/fluxvariables.hh:104
const ElementFluxVariablesCache & elemFluxVarsCache() const
Definition freeflow/navierstokes/momentum/fluxvariables.hh:107
const Element & element() const
Definition freeflow/navierstokes/momentum/fluxvariables.hh:95
NumEqVector lateralDiffusiveMomentumFlux() const
Returns the diffusive momentum flux over the staggered face perpendicular to the scvf where the veloc...
Definition freeflow/navierstokes/momentum/fluxvariables.hh:218
Helper class for calculating the velocity gradients for the Navier-Stokes model using the staggered g...
Definition momentum/velocitygradients.hh:30
static auto velocityGradient(const FVElementGeometry &fvGeometry, const typename FVElementGeometry::SubControlVolumeFace &scvf, const ElemVolVars &elemVolVars, bool fullGradient=false)
Definition momentum/velocitygradients.hh:34
static auto velocityGradII(const FVElementGeometry &fvGeometry, const typename FVElementGeometry::SubControlVolumeFace &scvf, const ElemVolVars &elemVolVars)
Returns the in-axis velocity gradient.
Definition momentum/velocitygradients.hh:130
Defines all properties used in Dumux.
Some exceptions thrown in DuMux
Helper classes to compute the integration elements.
constexpr Scalar harmonicMean(Scalar x, Scalar y, Scalar wx=1.0, Scalar wy=1.0) noexcept
Calculate the (weighted) harmonic mean of two scalar values.
Definition math.hh:57
typename NumEqVectorTraits< PrimaryVariables >::type NumEqVector
A vector with the same size as numbers of equations This is the default implementation and has to be ...
Definition numeqvector.hh:34
constexpr int sign(const ValueType &value) noexcept
Sign or signum function.
Definition math.hh:658
T getParamFromGroup(Args &&... args)
A free function to get a parameter from the parameter tree singleton with a model group.
Definition parameters.hh:149
T getParam(Args &&... args)
A free function to get a parameter from the parameter tree singleton.
Definition parameters.hh:139
typename GetProp< TypeTag, Property >::type GetPropType
get the type alias defined in the property
Definition propertysystem.hh:296
Define some often used mathematical functions.
The available discretization methods in Dumux.
Helper class for calculating the velocity gradients for the Navier-Stokes model using the staggered g...
typename Extrusion< T >::type Extrusion_t
Convenience alias for obtaining the extrusion type.
Definition extrusion.hh:166
A helper to deduce a vector with the same size as numbers of equations.
The infrastructure to retrieve run-time parameters from Dune::ParameterTrees.