80                               const SubControlVolume& scv,
 
   81                               const VolumeVariables& volVars)
 const 
   83        NumEqVector storage(0.0);
 
   85        const auto massOrMoleDensity = [](
const auto& volVars, 
const int phaseIdx)
 
   86        { 
return useMoles ? volVars.molarDensity(phaseIdx) : volVars.density(phaseIdx); };
 
   88        const auto massOrMoleFraction= [](
const auto& volVars, 
const int phaseIdx, 
const int compIdx)
 
   89        { 
return useMoles ? volVars.moleFraction(phaseIdx, compIdx) : volVars.massFraction(phaseIdx, compIdx); };
 
   92        for (
int phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx)
 
   94            for (
int compIdx = 0; compIdx < numComponents; ++compIdx)
 
   96                auto eqIdx = conti0EqIdx + compIdx;
 
   97                if (eqIdx != replaceCompEqIdx)
 
   98                    storage[eqIdx] += volVars.porosity()
 
   99                                      * volVars.saturation(phaseIdx)
 
  100                                      * massOrMoleDensity(volVars, phaseIdx)
 
  105            if (useTotalMoleOrMassBalance)
 
  106                storage[replaceCompEqIdx] += massOrMoleDensity(volVars, phaseIdx)
 
  108                                             * volVars.saturation(phaseIdx);
 
  111            EnergyLocalResidual::fluidPhaseStorage(storage, problem, scv, volVars, phaseIdx);
 
  115        EnergyLocalResidual::solidPhaseStorage(storage, scv, volVars);
 
 
  132                            const Element& element,
 
  133                            const FVElementGeometry& fvGeometry,
 
  134                            const ElementVolumeVariables& elemVolVars,
 
  135                            const SubControlVolumeFace& scvf,
 
  136                            const ElementFluxVariablesCache& elemFluxVarsCache)
 const 
  138        FluxVariables fluxVars;
 
  139        fluxVars.init(problem, element, fvGeometry, elemVolVars, scvf, elemFluxVarsCache);
 
  140        static constexpr auto referenceSystemFormulationDiffusion = FluxVariables::MolecularDiffusionType::referenceSystemFormulation();
 
  142        NumEqVector flux(0.0);
 
  144        const auto massOrMoleDensity = [](
const auto& volVars, 
const int phaseIdx)
 
  145        { 
return useMoles ? volVars.molarDensity(phaseIdx) : volVars.density(phaseIdx); };
 
  147        const auto massOrMoleFraction = [](
const auto& volVars, 
const int phaseIdx, 
const int compIdx)
 
  148        { 
return useMoles ? volVars.moleFraction(phaseIdx, compIdx) : volVars.massFraction(phaseIdx, compIdx); };
 
  151        const auto adaptFluxUnits = [](
const Scalar referenceFlux, 
const Scalar molarMass,
 
  155                return useMoles ? referenceFlux/molarMass
 
  158                return useMoles ? referenceFlux
 
  159                                : referenceFlux*molarMass;
 
  161                DUNE_THROW(Dune::NotImplemented, 
"other reference systems than mass and molar averaged are not implemented");
 
  164        for (
int phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx)
 
  166            const auto diffusiveFluxes = fluxVars.molecularDiffusionFlux(phaseIdx);
 
  167            auto dispersiveFluxes = 
decltype(diffusiveFluxes)(0.0);
 
  168            if constexpr (ModelTraits::enableCompositionalDispersion())
 
  169                dispersiveFluxes = fluxVars.compositionalDispersionFlux(phaseIdx);
 
  171            for (
int compIdx = 0; compIdx < numComponents; ++compIdx)
 
  174                const auto eqIdx = conti0EqIdx + compIdx;
 
  177                const auto upwindTerm = [&massOrMoleDensity, &
massOrMoleFraction, phaseIdx, compIdx] (
const auto& volVars)
 
  178                { 
return massOrMoleDensity(volVars, phaseIdx)*
massOrMoleFraction(volVars, phaseIdx, compIdx)*volVars.mobility(phaseIdx); };
 
  181                if (eqIdx != replaceCompEqIdx)
 
  182                    flux[eqIdx] += fluxVars.advectiveFlux(phaseIdx, upwindTerm);
 
  185                auto diffusiveAndDispersiveFluxes = adaptFluxUnits(diffusiveFluxes[compIdx],
 
  186                                                                   FluidSystem::molarMass(compIdx),
 
  187                                                                   referenceSystemFormulationDiffusion);
 
  188                if constexpr (ModelTraits::enableCompositionalDispersion())
 
  190                    static constexpr auto referenceSystemFormulationDispersion =
 
  191                        FluxVariables::DispersionFluxType::referenceSystemFormulation();
 
  192                    diffusiveAndDispersiveFluxes += adaptFluxUnits(dispersiveFluxes[compIdx],
 
  193                                                                   FluidSystem::molarMass(compIdx),
 
  194                                                                   referenceSystemFormulationDispersion);
 
  196                if(eqIdx != replaceCompEqIdx)
 
  197                    flux[eqIdx] += diffusiveAndDispersiveFluxes;
 
  198                if (useTotalMoleOrMassBalance)
 
  199                    flux[replaceCompEqIdx] += diffusiveAndDispersiveFluxes;
 
  203            if (useTotalMoleOrMassBalance)
 
  206                const auto upwindTerm = [&massOrMoleDensity, phaseIdx] (
const auto& volVars)
 
  207                { 
return massOrMoleDensity(volVars, phaseIdx)*volVars.mobility(phaseIdx); };
 
  209                flux[replaceCompEqIdx] += fluxVars.advectiveFlux(phaseIdx, upwindTerm);
 
  213            EnergyLocalResidual::heatConvectionFlux(flux, fluxVars, phaseIdx);
 
  217        EnergyLocalResidual::heatConductionFlux(flux, fluxVars);
 
  218        EnergyLocalResidual::heatDispersionFlux(flux, fluxVars);