90    static ComponentFluxVector 
flux(
const Problem& problem,
 
   91                                    const Element& element,
 
   92                                    const FVElementGeometry& fvGeometry,
 
   93                                    const ElementVolumeVariables& elemVolVars,
 
   94                                    const SubControlVolumeFace& scvf,
 
   96                                    const ElementFluxVariablesCache& elemFluxVarsCache)
 
  100        ComponentFluxVector componentFlux(0.0);
 
  101        ReducedComponentVector moleFracInside(0.0);
 
  102        ReducedComponentVector moleFracOutside(0.0);
 
  103        ReducedComponentVector reducedFlux(0.0);
 
  104        ReducedComponentMatrix reducedDiffusionMatrixInside(0.0);
 
  105        ReducedComponentMatrix reducedDiffusionMatrixOutside(0.0);
 
  108        const auto& insideVolVars = elemVolVars[scvf.insideScvIdx()];
 
  109        const auto& outsideVolVars = elemVolVars[scvf.outsideScvIdx()];
 
  110        const auto rhoInside = insideVolVars.density(phaseIdx);
 
  111        const auto rhoOutside = outsideVolVars.density(phaseIdx);
 
  113        for (
int compIdx = 0; compIdx < numComponents-1; compIdx++)
 
  116            const auto xInside = insideVolVars.moleFraction(phaseIdx, compIdx);
 
  118            const auto xOutside = outsideVolVars.moleFraction(phaseIdx, compIdx);
 
  120            moleFracInside[compIdx] = xInside;
 
  121            moleFracOutside[compIdx] = xOutside;
 
  125        if(!(Dune::FloatCmp::eq<Scalar>(insideVolVars.saturation(phaseIdx), 0) || Dune::FloatCmp::eq<Scalar>(outsideVolVars.saturation(phaseIdx), 0)))
 
  127            const auto insideScvIdx = scvf.insideScvIdx();
 
  128            const auto& insideScv = fvGeometry.scv(insideScvIdx);
 
  129            const Scalar omegai = calculateOmega_(scvf,
 
  131                                                  insideVolVars.extrusionFactor());
 
  134            reducedDiffusionMatrixInside = setupMSMatrix_(problem, element, fvGeometry, insideVolVars, insideScv, phaseIdx);
 
  137            if (scvf.boundary() || scvf.numOutsideScvs() > 1)
 
  139                moleFracOutside -= moleFracInside;
 
  140                reducedDiffusionMatrixInside.solve(reducedFlux, moleFracOutside);
 
  141                reducedFlux *= omegai*rhoInside;
 
  146                const auto outsideScvIdx = scvf.outsideScvIdx();
 
  147                const auto& outsideScv = fvGeometry.scv(outsideScvIdx);
 
  149                reducedDiffusionMatrixOutside = setupMSMatrix_(problem, element, fvGeometry, outsideVolVars, outsideScv, phaseIdx);
 
  153                    omegaj = -1.0*calculateOmega_(scvf,
 
  155                                                  outsideVolVars.extrusionFactor());
 
  157                    omegaj = calculateOmega_(fvGeometry.flipScvf(scvf.index()),
 
  159                                             outsideVolVars.extrusionFactor());
 
  161                reducedDiffusionMatrixInside.invert();
 
  162                reducedDiffusionMatrixOutside.invert();
 
  163                reducedDiffusionMatrixInside *= omegai*rhoInside;
 
  164                reducedDiffusionMatrixOutside *= omegaj*rhoOutside;
 
  167                ReducedComponentVector helperVector(0.0);
 
  168                ReducedComponentVector gradientVectori(0.0);
 
  169                ReducedComponentVector gradientVectorj(0.0);
 
  171                reducedDiffusionMatrixInside.mv(moleFracInside, gradientVectori);
 
  172                reducedDiffusionMatrixOutside.mv(moleFracOutside, gradientVectorj);
 
  174                auto gradientVectorij = (gradientVectori + gradientVectorj);
 
  177                reducedDiffusionMatrixOutside += reducedDiffusionMatrixInside;
 
  179                reducedDiffusionMatrixOutside.solve(helperVector, gradientVectorij);
 
  182                helperVector -=moleFracInside;
 
  183                reducedDiffusionMatrixInside.mv(helperVector, reducedFlux);
 
  186            reducedFlux *= -Extrusion::area(fvGeometry, scvf);
 
  187            for (
int compIdx = 0; compIdx < numComponents-1; compIdx++)
 
  189                componentFlux[compIdx] = reducedFlux[compIdx];
 
  190                componentFlux[numComponents-1] -=reducedFlux[compIdx];
 
  193        return componentFlux ;