143                               const SubControlVolume& scv,
 
  144                               const VolumeVariables& volVars)
 const 
  146       NumEqVector storage(0.0);
 
  149        for (
int phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx)
 
  151            for (
int compIdx = 0; compIdx < numComponents; ++compIdx)
 
  153                 auto eqIdx = conti0EqIdx + phaseIdx*numComponents + compIdx;
 
  154                 storage[eqIdx] += volVars.porosity()
 
  155                                   * volVars.saturation(phaseIdx)
 
  156                                   * volVars.molarDensity(phaseIdx)
 
  157                                   * volVars.moleFraction(phaseIdx, compIdx);
 
  160            EnergyLocalResidual::fluidPhaseStorage(storage, problem, scv, volVars, phaseIdx);
 
  163        EnergyLocalResidual::solidPhaseStorage(storage, scv, volVars);
 
 
  178                            const Element& element,
 
  179                            const FVElementGeometry& fvGeometry,
 
  180                            const ElementVolumeVariables& elemVolVars,
 
  181                            const SubControlVolumeFace& scvf,
 
  182                            const ElementFluxVariablesCache& elemFluxVarsCache)
 const 
  184        FluxVariables fluxVars;
 
  185        fluxVars.init(problem, element, fvGeometry, elemVolVars, scvf, elemFluxVarsCache);
 
  186        NumEqVector flux(0.0);
 
  189        for (
int phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx)
 
  191            const auto diffusiveFluxes = fluxVars.molecularDiffusionFlux(phaseIdx);
 
  192            for (
int compIdx = 0; compIdx < numComponents; ++compIdx)
 
  195                const auto eqIdx = conti0EqIdx + phaseIdx*numComponents + compIdx;
 
  198                const auto upwindTerm = [phaseIdx, compIdx] (
const auto& volVars)
 
  199                { 
return volVars.molarDensity(phaseIdx)*volVars.moleFraction(phaseIdx, compIdx)*volVars.mobility(phaseIdx); };
 
  201                flux[eqIdx] += fluxVars.advectiveFlux(phaseIdx, upwindTerm);
 
  204                if (compIdx == phaseIdx)
 
  208                    flux[eqIdx] += diffusiveFluxes[compIdx]/FluidSystem::molarMass(compIdx);
 
  210                    flux[eqIdx] += diffusiveFluxes[compIdx];
 
  213            EnergyLocalResidual::heatConvectionFlux(flux, fluxVars, phaseIdx);
 
  217        EnergyLocalResidual::heatConductionFlux(flux, fluxVars);
 
 
  232                              const Element& element,
 
  233                              const FVElementGeometry& fvGeometry,
 
  234                              const ElementVolumeVariables& elemVolVars,
 
  235                              const SubControlVolume &scv)
 const 
  237        NumEqVector source(0.0);
 
  241        const auto& volVars = elemVolVars[scv];
 
  242        std::array<std::array<Scalar, numComponents>, numPhases> componentIntoPhaseMassTransfer = {{{0.0},{0.0}}};
 
  245        const Scalar characteristicLength   = volVars.characteristicLength()  ;
 
  246        const Scalar factorMassTransfer     = volVars.factorMassTransfer()  ;
 
  248        const Scalar awn = volVars.interfacialArea(phase0Idx, phase1Idx);
 
  250        for(
int phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx)
 
  252            const Scalar sherwoodNumber = volVars.sherwoodNumber(phaseIdx);
 
  254            for (
int compIdx = 0; compIdx < numComponents; ++compIdx)
 
  256                if (compIdx <= numPhases)
 
  259                    if (phaseIdx == compIdx)
 
  262                    const Scalar xNonEquil = volVars.moleFraction(phaseIdx, compIdx);
 
  265                    const Scalar xEquil = volVars.xEquil(phaseIdx, compIdx);
 
  267                    const Scalar diffCoeff = volVars.diffusionCoefficient(phaseIdx, FluidSystem::getMainComponent(phaseIdx), compIdx);
 
  270                    const Scalar compFluxIntoOtherPhase = factorMassTransfer * (xEquil-xNonEquil)/characteristicLength * awn * volVars.molarDensity(phaseIdx) * diffCoeff * sherwoodNumber;
 
  272                    componentIntoPhaseMassTransfer[phaseIdx][compIdx] += compFluxIntoOtherPhase;
 
  273                    componentIntoPhaseMassTransfer[compIdx][compIdx] -= compFluxIntoOtherPhase;
 
  280        for (
int phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx)
 
  282            for (
int compIdx = 0; compIdx < numComponents; ++compIdx)
 
  284                const unsigned int eqIdx = conti0EqIdx + compIdx + phaseIdx*numComponents;
 
  285                source[eqIdx] += componentIntoPhaseMassTransfer[phaseIdx][compIdx];
 
  288                if (!isfinite(source[eqIdx]))
 
  293        if constexpr (ModelTraits::enableThermalNonEquilibrium())
 
  297            EnergyLocalResidual::computeSourceEnergy(source,
 
  305        source += problem.source(element, fvGeometry, elemVolVars, scv);
 
  308        source += problem.scvPointSources(element, fvGeometry, elemVolVars, scv);