75                                               const Element &element,
 
   76                                               const FVElementGeometry& fvGeometry,
 
   77                                               const ElementVolumeVariables& elemVolVars,
 
   78                                               const ElementFaceVariables& elemFaceVars,
 
   79                                               const SubControlVolumeFace &scvf,
 
   80                                               const FluxVariablesCache& fluxVarsCache)
 
   82        CellCenterPrimaryVariables flux = ParentType::computeMassFlux(problem, element, fvGeometry,
 
   83                                                                      elemVolVars, elemFaceVars, scvf, fluxVarsCache);
 
   86        auto upwindTermK = [](
const auto& volVars)
 
   88            return volVars.turbulentKineticEnergy() * volVars.density();
 
   90        auto upwindTermEpsilon = [](
const auto& volVars)
 
   92            return volVars.dissipationTilde() * volVars.density();
 
   95        flux[turbulentKineticEnergyEqIdx]
 
   96            = ParentType::advectiveFluxForCellCenter(problem, fvGeometry, elemVolVars, elemFaceVars, scvf, upwindTermK);
 
   97        flux[dissipationEqIdx]
 
   98            = ParentType::advectiveFluxForCellCenter(problem, fvGeometry, elemVolVars, elemFaceVars, scvf, upwindTermEpsilon);
 
  101        const auto& insideScv = fvGeometry.scv(scvf.insideScvIdx());
 
  102        const auto& outsideScv = fvGeometry.scv(scvf.outsideScvIdx());
 
  103        const auto& insideVolVars = elemVolVars[scvf.insideScvIdx()];
 
  104        const auto& outsideVolVars = elemVolVars[scvf.outsideScvIdx()];
 
  107        Scalar insideCoeff_k = insideVolVars.viscosity() + insideVolVars.kinematicEddyViscosity()
 
  108                                                         * insideVolVars.density() / insideVolVars.sigmaK();
 
  109        Scalar outsideCoeff_k = outsideVolVars.viscosity() + outsideVolVars.kinematicEddyViscosity()
 
  110                                                           * outsideVolVars.density() / outsideVolVars.sigmaK();
 
  111        Scalar insideCoeff_e = insideVolVars.viscosity() + insideVolVars.kinematicEddyViscosity()
 
  112                                                         * insideVolVars.density() / insideVolVars.sigmaEpsilon();
 
  113        Scalar outsideCoeff_e = outsideVolVars.viscosity() + outsideVolVars.kinematicEddyViscosity()
 
  114                                                           * outsideVolVars.density() / outsideVolVars.sigmaEpsilon();
 
  117        insideCoeff_k *= insideVolVars.extrusionFactor();
 
  118        outsideCoeff_k *= outsideVolVars.extrusionFactor();
 
  119        insideCoeff_e *= insideVolVars.extrusionFactor();
 
  120        outsideCoeff_e *= outsideVolVars.extrusionFactor();
 
  122        Scalar coeff_k = 0.0;
 
  123        Scalar coeff_e = 0.0;
 
  127            coeff_k = insideCoeff_k;
 
  128            coeff_e = insideCoeff_e;
 
  129            distance = (insideScv.dofPosition() - scvf.ipGlobal()).two_norm();
 
  135                                    (outsideScv.dofPosition() - scvf.ipGlobal()).two_norm(),
 
  136                                    (insideScv.dofPosition() - scvf.ipGlobal()).two_norm());
 
  138                                    (outsideScv.dofPosition() - scvf.ipGlobal()).two_norm(),
 
  139                                    (insideScv.dofPosition() - scvf.ipGlobal()).two_norm());
 
  140            distance = (outsideScv.dofPosition() - insideScv.dofPosition()).two_norm();
 
  143        const auto bcTypes = problem.boundaryTypes(element, scvf);
 
  144        if (!(scvf.boundary() && (bcTypes.isOutflow(Indices::turbulentKineticEnergyEqIdx)
 
  145                                  || bcTypes.isSymmetry())))
 
  147            flux[turbulentKineticEnergyEqIdx]
 
  149                   * (insideVolVars.turbulentKineticEnergy() - outsideVolVars.turbulentKineticEnergy())
 
  150                   * Extrusion::area(fvGeometry, scvf);
 
  152        if (!(scvf.boundary() && (bcTypes.isOutflow(Indices::dissipationEqIdx)
 
  153                                  || bcTypes.isSymmetry())))
 
  155            flux[dissipationEqIdx]
 
  157                   * (insideVolVars.dissipationTilde() - outsideVolVars.dissipationTilde())
 
  158                   * Extrusion::area(fvGeometry, scvf);
 
 
  167                                             const Element& element,
 
  168                                             const SubControlVolumeFace& scvf,
 
  169                                             const FVElementGeometry& fvGeometry,
 
  170                                             const ElementVolumeVariables& elemVolVars,
 
  171                                             const ElementFaceVariables& elemFaceVars,
 
  172                                             const GridFluxVariablesCache& gridFluxVarsCache)
 
  174        const auto& insideVolVars = elemVolVars[scvf.insideScvIdx()];
 
  176        return ParentType::computeFrontalMomentumFlux(problem, element, scvf, fvGeometry, elemVolVars, elemFaceVars, gridFluxVarsCache)
 
  177               + ParentType::computeLateralMomentumFlux(problem, element, scvf, fvGeometry, elemVolVars, elemFaceVars, gridFluxVarsCache)
 
  178               + 2.0 / ModelTraits::dim() * insideVolVars.density() * insideVolVars.turbulentKineticEnergy()
 
  179                 * Extrusion::area(fvGeometry, scvf) * scvf.directionSign() * insideVolVars.extrusionFactor();