127        using GridView = 
typename IV::Traits::GridView;
 
  128        static constexpr int dim = GridView::dimension;
 
  129        static constexpr int dimWorld = GridView::dimensionworld;
 
  130        static constexpr bool isSurfaceGrid = dim < dimWorld;
 
  133        auto& g = handle.g();
 
  134        auto& deltaG = handle.deltaG();
 
  135        auto& outsideG = handle.gOutside();
 
  145        using Scalar = 
typename IV::Traits::MatVecTraits::TMatrix::value_type;
 
  146        using LocalIndexType = 
typename IV::Traits::IndexSet::LocalIndexType;
 
  148        for (LocalIndexType faceIdx = 0; faceIdx < iv.numFaces(); ++faceIdx)
 
  151            const auto& curLocalScvf = iv.localScvf(faceIdx);
 
  152            const auto& curGlobalScvf = 
fvGeometry().scvf(curLocalScvf.gridScvfIndex());
 
  153            const auto& gravity = 
problem().spatialParams().gravity(curGlobalScvf.ipGlobal());
 
  156            const auto& neighborScvIndices = curLocalScvf.neighboringLocalScvIndices();
 
  157            const auto& posGlobalScv = 
fvGeometry().scv(iv.localScv(neighborScvIndices[0]).gridScvIndex());
 
  158            const auto& posVolVars = 
elemVolVars()[posGlobalScv];
 
  159            const auto alpha_inside = posVolVars.extrusionFactor()*
vtmv(curGlobalScvf.unitOuterNormal(),
 
  160                                                                        posVolVars.permeability(),
 
  163            const auto numOutsideFaces = !curGlobalScvf.boundary() ? curGlobalScvf.numOutsideScvs() : 0;
 
  164            using OutsideAlphaStorage = std::conditional_t< isSurfaceGrid,
 
  166                                                            Dune::ReservedVector<Scalar, 1> >;
 
  167            OutsideAlphaStorage alpha_outside; alpha_outside.resize(numOutsideFaces);
 
  168            std::fill(alpha_outside.begin(), alpha_outside.end(), 0.0);
 
  174            if (!curLocalScvf.isDirichlet())
 
  176                const auto localDofIdx = curLocalScvf.localDofIndex();
 
  178                rho = getRho(posVolVars);
 
  179                deltaG[localDofIdx] = 0.0;
 
  181                if (!curGlobalScvf.boundary())
 
  183                    for (
unsigned int idxInOutside = 0; idxInOutside < curGlobalScvf.numOutsideScvs(); ++idxInOutside)
 
  186                        const auto negLocalScvIdx = neighborScvIndices[idxInOutside+1];
 
  187                        const auto& negGlobalScv = 
fvGeometry().scv(iv.localScv(negLocalScvIdx).gridScvIndex());
 
  188                        const auto& negVolVars = 
elemVolVars()[negGlobalScv];
 
  189                        const auto& flipScvf = !isSurfaceGrid ? curGlobalScvf
 
  190                                                              : 
fvGeometry().flipScvf(curGlobalScvf.index(), idxInOutside);
 
  192                        alpha_outside[idxInOutside] = negVolVars.extrusionFactor()*
vtmv(flipScvf.unitOuterNormal(),
 
  193                                                                                        negVolVars.permeability(),
 
  196                            alpha_outside[idxInOutside] *= -1.0;
 
  198                        rho += getRho(negVolVars);
 
  199                        deltaG[localDofIdx] += alpha_outside[idxInOutside];
 
  203                rho /= numOutsideFaces + 1;
 
  204                deltaG[localDofIdx] -= alpha_inside;
 
  205                deltaG[localDofIdx] *= rho*Extrusion::area(
fvGeometry(), curGlobalScvf);
 
  209                rho = getRho(
elemVolVars()[curGlobalScvf.outsideScvIdx()]);
 
  212            g[faceIdx] = alpha_inside*rho*Extrusion::area(
fvGeometry(), curGlobalScvf);
 
  217                for (
const auto& alpha : alpha_outside)
 
  218                    outsideG[faceIdx][i++] = alpha*rho*Extrusion::area(
fvGeometry(), curGlobalScvf);
 
  223        handle.CA().umv(deltaG, g);
 
  226            using FaceVector = 
typename IV::Traits::MatVecTraits::FaceVector;
 
  229            handle.A().mv(deltaG, AG);
 
  232            for (
const auto& localFaceData : iv.localFaceData())
 
  235                if (!localFaceData.isOutsideFace())
 
  238                const auto localScvIdx = localFaceData.ivLocalInsideScvIndex();
 
  239                const auto localScvfIdx = localFaceData.ivLocalScvfIndex();
 
  240                const auto idxInOutside = localFaceData.scvfLocalOutsideScvfIndex();
 
  241                const auto& posLocalScv = iv.localScv(localScvIdx);
 
  242                const auto& wijk = handle.omegas()[localScvfIdx][idxInOutside+1];
 
  245                for (LocalIndexType localDir = 0; localDir < dim; localDir++)
 
  248                    const auto& curLocalScvf = iv.localScvf(posLocalScv.localScvfIndex(localDir));
 
  249                    if (!curLocalScvf.isDirichlet())
 
  250                        outsideG[localScvfIdx][idxInOutside] -= wijk[localDir]*AG[curLocalScvf.localDofIndex()];