140                       const Problem& problem,
 
  141                       const Element& element,
 
  142                       const FVElementGeometry& fvGeometry,
 
  143                       const ElementVolumeVariables& curElemVolVars,
 
  144                       const ElementFluxVariablesCache& elemFluxVarsCache,
 
  145                       const SubControlVolumeFace& scvf)
 const 
  147        static_assert(!FluidSystem::isCompressible(0),
 
  148                      "2p/incompressiblelocalresidual.hh: Only incompressible fluids are allowed!");
 
  149        static_assert(!FluidSystem::isCompressible(1),
 
  150                      "2p/incompressiblelocalresidual.hh: Only incompressible fluids are allowed!");
 
  151        static_assert(FluidSystem::viscosityIsConstant(0),
 
  152                      "2p/incompressiblelocalresidual.hh: Only fluids with constant viscosities are allowed!");
 
  153        static_assert(FluidSystem::viscosityIsConstant(1),
 
  154                      "2p/incompressiblelocalresidual.hh: Only fluids with constant viscosities are allowed!");
 
  155        static_assert(ModelTraits::numFluidPhases() == 2,
 
  156                      "2p/incompressiblelocalresidual.hh: Only two-phase models are allowed!");
 
  158                      "2p/incompressiblelocalresidual.hh: Analytic differentiation has to be checked for p1-s0 formulation!");
 
  164        const auto flux_w = AdvectionType::flux(problem, element, fvGeometry, curElemVolVars, scvf, 0, elemFluxVarsCache);
 
  165        const auto flux_n = AdvectionType::flux(problem, element, fvGeometry, curElemVolVars, scvf, 1, elemFluxVarsCache);
 
  166        const auto insideWeight_w = std::signbit(flux_w) ? (1.0 - upwindWeight) : upwindWeight;
 
  167        const auto outsideWeight_w = 1.0 - insideWeight_w;
 
  168        const auto insideWeight_n = std::signbit(flux_n) ? (1.0 - upwindWeight) : upwindWeight;
 
  169        const auto outsideWeight_n = 1.0 - insideWeight_n;
 
  172        const auto insideScvIdx = scvf.insideScvIdx();
 
  173        const auto outsideScvIdx = scvf.outsideScvIdx();
 
  174        const auto outsideElement = fvGeometry.gridGeometry().element(outsideScvIdx);
 
  175        const auto& insideScv = fvGeometry.scv(insideScvIdx);
 
  176        const auto& outsideScv = fvGeometry.scv(outsideScvIdx);
 
  177        const auto& insideVolVars = curElemVolVars[insideScvIdx];
 
  178        const auto& outsideVolVars = curElemVolVars[outsideScvIdx];
 
  180        const auto insidefluidMatrixInteraction = problem.spatialParams().fluidMatrixInteraction(
 
  183        const auto outsidefluidMatrixInteraction = problem.spatialParams().fluidMatrixInteraction(
 
  188        auto& dI_dI = derivativeMatrices[insideScvIdx];
 
  189        auto& dI_dJ = derivativeMatrices[outsideScvIdx];
 
  192        static const auto rho_w = insideVolVars.density(0);
 
  193        static const auto rho_n = insideVolVars.density(1);
 
  194        static const auto rhow_muw = rho_w/insideVolVars.viscosity(0);
 
  195        static const auto rhon_mun = rho_n/insideVolVars.viscosity(1);
 
  196        const auto rhowKrw_muw_inside = rho_w*insideVolVars.mobility(0);
 
  197        const auto rhonKrn_mun_inside = rho_n*insideVolVars.mobility(1);
 
  198        const auto rhowKrw_muw_outside = rho_w*outsideVolVars.mobility(0);
 
  199        const auto rhonKrn_mun_outside = rho_n*outsideVolVars.mobility(1);
 
  202        const auto insideSw = insideVolVars.saturation(0);
 
  203        const auto outsideSw = outsideVolVars.saturation(0);
 
  204        const auto dKrw_dSn_inside = -1.0*insidefluidMatrixInteraction.dkrw_dsw(insideSw);
 
  205        const auto dKrw_dSn_outside = -1.0*outsidefluidMatrixInteraction.dkrw_dsw(outsideSw);
 
  206        const auto dKrn_dSn_inside = -1.0*insidefluidMatrixInteraction.dkrn_dsw(insideSw);
 
  207        const auto dKrn_dSn_outside = -1.0*outsidefluidMatrixInteraction.dkrn_dsw(outsideSw);
 
  208        const auto dpc_dSn_inside = -1.0*insidefluidMatrixInteraction.dpc_dsw(insideSw);
 
  209        const auto dpc_dSn_outside = -1.0*outsidefluidMatrixInteraction.dpc_dsw(outsideSw);
 
  211        const auto tij = elemFluxVarsCache[scvf].advectionTij();
 
  214        const auto up_w = rhowKrw_muw_inside*insideWeight_w + rhowKrw_muw_outside*outsideWeight_w;
 
  215        const auto up_n = rhonKrn_mun_inside*insideWeight_n + rhonKrn_mun_outside*outsideWeight_n;
 
  216        const auto rho_mu_flux_w = rhow_muw*flux_w;
 
  217        const auto rho_mu_flux_n = rhon_mun*flux_n;
 
  218        const auto tij_up_w = tij*up_w;
 
  219        const auto tij_up_n = tij*up_n;
 
  222        dI_dI[conti0EqIdx+0][pressureIdx] += tij_up_w;
 
  223        dI_dJ[conti0EqIdx+0][pressureIdx] -= tij_up_w;
 
  226        dI_dI[conti0EqIdx+0][saturationIdx] += rho_mu_flux_w*dKrw_dSn_inside*insideWeight_w;
 
  227        dI_dJ[conti0EqIdx+0][saturationIdx] += rho_mu_flux_w*dKrw_dSn_outside*outsideWeight_w;
 
  230        dI_dI[conti0EqIdx+1][pressureIdx] += tij_up_n;
 
  231        dI_dJ[conti0EqIdx+1][pressureIdx] -= tij_up_n;
 
  234        dI_dI[conti0EqIdx+1][saturationIdx] += rho_mu_flux_n*dKrn_dSn_inside*insideWeight_n;
 
  235        dI_dJ[conti0EqIdx+1][saturationIdx] += rho_mu_flux_n*dKrn_dSn_outside*outsideWeight_n;
 
  238        dI_dI[conti0EqIdx+1][saturationIdx] += tij_up_n*dpc_dSn_inside;
 
  239        dI_dJ[conti0EqIdx+1][saturationIdx] -= tij_up_n*dpc_dSn_outside;
 
 
  259                       const Problem& problem,
 
  260                       const Element& element,
 
  261                       const FVElementGeometry& fvGeometry,
 
  262                       const ElementVolumeVariables& curElemVolVars,
 
  263                       const ElementFluxVariablesCache& elemFluxVarsCache,
 
  264                       const SubControlVolumeFace& scvf)
 const 
  266        static_assert(!FluidSystem::isCompressible(0),
 
  267                      "2p/incompressiblelocalresidual.hh: Only incompressible fluids are allowed!");
 
  268        static_assert(!FluidSystem::isCompressible(1),
 
  269                      "2p/incompressiblelocalresidual.hh: Only incompressible fluids are allowed!");
 
  270        static_assert(FluidSystem::viscosityIsConstant(0),
 
  271                      "2p/incompressiblelocalresidual.hh: Only fluids with constant viscosities are allowed!");
 
  272        static_assert(FluidSystem::viscosityIsConstant(1),
 
  273                      "2p/incompressiblelocalresidual.hh: Only fluids with constant viscosities are allowed!");
 
  274        static_assert(ModelTraits::numFluidPhases() == 2,
 
  275                      "2p/incompressiblelocalresidual.hh: Only two-phase models are allowed!");
 
  277                      "2p/incompressiblelocalresidual.hh: Analytic differentiation has to be checked for p0-s1 formulation!");
 
  283        const auto flux_w = AdvectionType::flux(problem, element, fvGeometry, curElemVolVars, scvf, 0, elemFluxVarsCache);
 
  284        const auto flux_n = AdvectionType::flux(problem, element, fvGeometry, curElemVolVars, scvf, 1, elemFluxVarsCache);
 
  285        const auto insideWeight_w = std::signbit(flux_w) ? (1.0 - upwindWeight) : upwindWeight;
 
  286        const auto outsideWeight_w = 1.0 - insideWeight_w;
 
  287        const auto insideWeight_n = std::signbit(flux_n) ? (1.0 - upwindWeight) : upwindWeight;
 
  288        const auto outsideWeight_n = 1.0 - insideWeight_n;
 
  291        const auto insideScvIdx = scvf.insideScvIdx();
 
  292        const auto outsideScvIdx = scvf.outsideScvIdx();
 
  293        const auto& insideScv = fvGeometry.scv(insideScvIdx);
 
  294        const auto& outsideScv = fvGeometry.scv(outsideScvIdx);
 
  295        const auto& insideVolVars = curElemVolVars[insideScv];
 
  296        const auto& outsideVolVars = curElemVolVars[outsideScv];
 
  298        const auto elemSol = 
elementSolution(element, curElemVolVars, fvGeometry);
 
  300        const auto insidefluidMatrixInteraction
 
  301            = problem.spatialParams().fluidMatrixInteraction(element, insideScv, elemSol);
 
  302        const auto outsidefluidMatrixInteraction
 
  303            = problem.spatialParams().fluidMatrixInteraction(element, outsideScv, elemSol);
 
  306        static const auto rho_w = insideVolVars.density(0);
 
  307        static const auto rho_n = insideVolVars.density(1);
 
  308        static const auto rhow_muw = rho_w/insideVolVars.viscosity(0);
 
  309        static const auto rhon_mun = rho_n/insideVolVars.viscosity(1);
 
  310        const auto rhowKrw_muw_inside = rho_w*insideVolVars.mobility(0);
 
  311        const auto rhonKrn_mun_inside = rho_n*insideVolVars.mobility(1);
 
  312        const auto rhowKrw_muw_outside = rho_w*outsideVolVars.mobility(0);
 
  313        const auto rhonKrn_mun_outside = rho_n*outsideVolVars.mobility(1);
 
  316        const auto ti = AdvectionType::calculateTransmissibilities(problem,
 
  321                                                                   elemFluxVarsCache[scvf]);
 
  324        auto& dI_dJ_inside = A[insideScv.dofIndex()];
 
  325        auto& dI_dJ_outside = A[outsideScv.dofIndex()];
 
  328        const auto up_w = rhowKrw_muw_inside*insideWeight_w + rhowKrw_muw_outside*outsideWeight_w;
 
  329        const auto up_n = rhonKrn_mun_inside*insideWeight_n + rhonKrn_mun_outside*outsideWeight_n;
 
  330        const auto rho_mu_flux_w = rhow_muw*flux_w;
 
  331        const auto rho_mu_flux_n = rhon_mun*flux_n;
 
  334        for (
const auto& scvJ : scvs(fvGeometry))
 
  336            const auto globalJ = scvJ.dofIndex();
 
  337            const auto localJ = scvJ.indexInElement();
 
  340            const auto tj = ti[localJ];
 
  343            const auto tj_up_w = tj*up_w;
 
  344            dI_dJ_inside[globalJ][conti0EqIdx+0][pressureIdx] += tj_up_w;
 
  345            dI_dJ_outside[globalJ][conti0EqIdx+0][pressureIdx] -= tj_up_w;
 
  348            const auto tj_up_n = tj*up_n;
 
  349            dI_dJ_inside[globalJ][conti0EqIdx+1][pressureIdx] += tj_up_n;
 
  350            dI_dJ_outside[globalJ][conti0EqIdx+1][pressureIdx] -= tj_up_n;
 
  354            if (localJ == insideScvIdx)
 
  357                const auto insideSw = insideVolVars.saturation(0);
 
  358                const auto dKrw_dSn_inside = -1.0*insidefluidMatrixInteraction.dkrw_dsw(insideSw);
 
  359                const auto dFluxW_dSnJ = rho_mu_flux_w*dKrw_dSn_inside*insideWeight_w;
 
  360                dI_dJ_inside[globalJ][conti0EqIdx+0][saturationIdx] += dFluxW_dSnJ;
 
  361                dI_dJ_outside[globalJ][conti0EqIdx+0][saturationIdx] -= dFluxW_dSnJ;
 
  364                const auto dKrn_dSn_inside = -1.0*insidefluidMatrixInteraction.dkrn_dsw(insideSw);
 
  365                const auto dFluxN_dSnJ_krn = rho_mu_flux_n*dKrn_dSn_inside*insideWeight_n;
 
  366                dI_dJ_inside[globalJ][conti0EqIdx+1][saturationIdx] += dFluxN_dSnJ_krn;
 
  367                dI_dJ_outside[globalJ][conti0EqIdx+1][saturationIdx] -= dFluxN_dSnJ_krn;
 
  370                const auto dFluxN_dSnJ_pc = -1.0*tj_up_n*insidefluidMatrixInteraction.dpc_dsw(insideSw);
 
  371                dI_dJ_inside[globalJ][conti0EqIdx+1][saturationIdx] += dFluxN_dSnJ_pc;
 
  372                dI_dJ_outside[globalJ][conti0EqIdx+1][saturationIdx] -= dFluxN_dSnJ_pc;
 
  374            else if (localJ == outsideScvIdx)
 
  377                const auto outsideSw = outsideVolVars.saturation(0);
 
  378                const auto dKrw_dSn_outside = -1.0*outsidefluidMatrixInteraction.dkrw_dsw(outsideSw);
 
  379                const auto dFluxW_dSnJ = rho_mu_flux_w*dKrw_dSn_outside*outsideWeight_w;
 
  380                dI_dJ_inside[globalJ][conti0EqIdx+0][saturationIdx] += dFluxW_dSnJ;
 
  381                dI_dJ_outside[globalJ][conti0EqIdx+0][saturationIdx] -= dFluxW_dSnJ;
 
  383                const auto dKrn_dSn_outside = -1.0*outsidefluidMatrixInteraction.dkrn_dsw(outsideSw);
 
  384                const auto dFluxN_dSnJ_krn = rho_mu_flux_n*dKrn_dSn_outside*outsideWeight_n;
 
  385                dI_dJ_inside[globalJ][conti0EqIdx+1][saturationIdx] += dFluxN_dSnJ_krn;
 
  386                dI_dJ_outside[globalJ][conti0EqIdx+1][saturationIdx] -= dFluxN_dSnJ_krn;
 
  388                const auto dFluxN_dSnJ_pc = -1.0*tj_up_n*outsidefluidMatrixInteraction.dpc_dsw(outsideSw);
 
  389                dI_dJ_inside[globalJ][conti0EqIdx+1][saturationIdx] += dFluxN_dSnJ_pc;
 
  390                dI_dJ_outside[globalJ][conti0EqIdx+1][saturationIdx] -= dFluxN_dSnJ_pc;
 
  394                const auto& fluidMatrixInteractionJ
 
  395                    = problem.spatialParams().fluidMatrixInteraction(element, scvJ, elemSol);
 
  397                const auto swJ = curElemVolVars[scvJ].saturation(0);
 
  398                const auto dFluxN_dSnJ_pc = tj_up_n*fluidMatrixInteractionJ.dpc_dsw(swJ);
 
  399                dI_dJ_inside[globalJ][conti0EqIdx+1][saturationIdx] -= dFluxN_dSnJ_pc;
 
  400                dI_dJ_outside[globalJ][conti0EqIdx+1][saturationIdx] += dFluxN_dSnJ_pc;
 
 
  421                                       const Problem& problem,
 
  422                                       const Element& element,
 
  423                                       const FVElementGeometry& fvGeometry,
 
  424                                       const ElementVolumeVariables& curElemVolVars,
 
  425                                       const ElementFluxVariablesCache& elemFluxVarsCache,
 
  426                                       const SubControlVolumeFace& scvf)
 const 
  432        const auto flux_w = AdvectionType::flux(problem, element, fvGeometry, curElemVolVars, scvf, 0, elemFluxVarsCache);
 
  433        const auto flux_n = AdvectionType::flux(problem, element, fvGeometry, curElemVolVars, scvf, 1, elemFluxVarsCache);
 
  434        const auto insideWeight_w = std::signbit(flux_w) ? (1.0 - upwindWeight) : upwindWeight;
 
  435        const auto outsideWeight_w = 1.0 - insideWeight_w;
 
  436        const auto insideWeight_n = std::signbit(flux_n) ? (1.0 - upwindWeight) : upwindWeight;
 
  437        const auto outsideWeight_n = 1.0 - insideWeight_n;
 
  440        const auto insideScvIdx = scvf.insideScvIdx();
 
  441        const auto& insideScv = fvGeometry.scv(insideScvIdx);
 
  442        const auto& insideVolVars = curElemVolVars[insideScvIdx];
 
  443        const auto& outsideVolVars = curElemVolVars[scvf.outsideScvIdx()];
 
  445        const auto insidefluidMatrixInteraction = problem.spatialParams().fluidMatrixInteraction(
 
  450        static const auto rho_w = insideVolVars.density(0);
 
  451        static const auto rho_n = insideVolVars.density(1);
 
  452        static const auto rhow_muw = rho_w/insideVolVars.viscosity(0);
 
  453        static const auto rhon_mun = rho_n/insideVolVars.viscosity(1);
 
  454        const auto rhowKrw_muw_inside = rho_w*insideVolVars.mobility(0);
 
  455        const auto rhonKrn_mun_inside = rho_n*insideVolVars.mobility(1);
 
  456        const auto rhowKrw_muw_outside = rho_w*outsideVolVars.mobility(0);
 
  457        const auto rhonKrn_mun_outside = rho_n*outsideVolVars.mobility(1);
 
  460        auto& dI_dI = derivativeMatrices[insideScvIdx];
 
  463        const auto insideSw = insideVolVars.saturation(0);
 
  464        const auto dKrw_dSn_inside = -1.0*insidefluidMatrixInteraction.dkrw_dsw(insideSw);
 
  465        const auto dKrn_dSn_inside = -1.0*insidefluidMatrixInteraction.dkrn_dsw(insideSw);
 
  466        const auto dpc_dSn_inside = -1.0*insidefluidMatrixInteraction.dpc_dsw(insideSw);
 
  468        const auto tij = elemFluxVarsCache[scvf].advectionTij();
 
  470        const auto up_w = rhowKrw_muw_inside*insideWeight_w + rhowKrw_muw_outside*outsideWeight_w;
 
  471        dI_dI[conti0EqIdx+0][pressureIdx] += tij*up_w;
 
  474        dI_dI[conti0EqIdx+0][saturationIdx] += rhow_muw*flux_w*dKrw_dSn_inside*insideWeight_w;
 
  477        const auto up_n = rhonKrn_mun_inside*insideWeight_n + rhonKrn_mun_outside*outsideWeight_n;
 
  478        dI_dI[conti0EqIdx+1][pressureIdx] += tij*up_n;
 
  481        dI_dI[conti0EqIdx+1][saturationIdx] += rhon_mun*flux_n*dKrn_dSn_inside*insideWeight_n;
 
  484        dI_dI[conti0EqIdx+1][saturationIdx] += tij*dpc_dSn_inside*up_n;