120                const Problem &problem,
 
  121                const Element &element,
 
  125        const auto& 
priVars = elemSol[scv.localDofIndex()];
 
  126        const auto phasePresence = 
priVars.state();
 
  131            if (phasePresence == threePhases)
 
  135                sg_ = 1. - sw_ - sn_;
 
  137            else if (phasePresence == wPhaseOnly)
 
  143            else if (phasePresence == gnPhaseOnly)
 
  149            else if (phasePresence == wnPhaseOnly)
 
  155            else if (phasePresence == gPhaseOnly)
 
  161            else if (phasePresence == wgPhaseOnly)
 
  167            else DUNE_THROW(Dune::InvalidStateException, 
"phasePresence: " << phasePresence << 
" is invalid.");
 
  173            const auto fluidMatrixInteraction = problem.spatialParams().fluidMatrixInteraction(element, scv, elemSol);
 
  176            const Scalar pcgw = fluidMatrixInteraction.pcgw(sw_, sn_);
 
  177            const Scalar pcnw = fluidMatrixInteraction.pcnw(sw_, sn_);
 
  178            const Scalar pcgn = fluidMatrixInteraction.pcgn(sw_, sn_);
 
  180            const Scalar pcAlpha = fluidMatrixInteraction.pcAlpha(sw_, sn_);
 
  181            const Scalar pcNW1 = 0.0; 
 
  184            if (phasePresence == threePhases || phasePresence == gnPhaseOnly || phasePresence == gPhaseOnly || phasePresence == wgPhaseOnly)
 
  187                 pn_ = pg_- pcAlpha * pcgn - (1.-pcAlpha)*(pcgw - pcNW1);
 
  188                 pw_ = pn_ - pcAlpha * pcnw - (1.-pcAlpha)*pcNW1;
 
  190            else if (phasePresence == wPhaseOnly || phasePresence == wnPhaseOnly)
 
  193                 pn_ = pw_ + pcAlpha * pcnw + (1.-pcAlpha)*pcNW1;
 
  194                 pg_ = pn_ + pcAlpha * pcgn + (1.-pcAlpha)*(pcgw - pcNW1);
 
  196            else DUNE_THROW(Dune::InvalidStateException, 
"phasePresence: " << phasePresence << 
" is invalid.");
 
  203            if (phasePresence == wPhaseOnly || phasePresence == wnPhaseOnly || phasePresence == gPhaseOnly)
 
  207            else if (phasePresence == threePhases)
 
  210                 Scalar temp = FluidSystem::inverseVaporPressureCurve(
fluidState_, gPhaseIdx, wCompIdx); 
 
  211                 for(
int phaseIdx=0; phaseIdx < FluidSystem::numPhases; ++phaseIdx)
 
  216                 Scalar defect = pg_ - FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, wCompIdx)
 
  217                                     - FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, nCompIdx);
 
  220                 while(abs(defect) > 0.01) 
 
  222                     Scalar deltaT = 1.e-8 * temp;
 
  223                 for(
int phaseIdx=0; phaseIdx < FluidSystem::numPhases; ++phaseIdx)
 
  228                     Scalar fUp = pg_ - FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, wCompIdx)
 
  229                                      - FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, nCompIdx);
 
  231                  for(
int phaseIdx=0; phaseIdx < FluidSystem::numPhases; ++phaseIdx)
 
  236                     Scalar fDown = pg_ - FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, wCompIdx)
 
  237                                      - FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, nCompIdx);
 
  239                     temp = temp - defect * 2. * deltaT / (fUp - fDown);
 
  241                     for(
int phaseIdx=0; phaseIdx < FluidSystem::numPhases; ++phaseIdx)
 
  246                     defect = pg_ - FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, wCompIdx)
 
  247                                  - FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, nCompIdx);
 
  251            else if (phasePresence == wgPhaseOnly)
 
  254                 temp_ = FluidSystem::inverseVaporPressureCurve(
fluidState_, gPhaseIdx, wCompIdx);
 
  256            else if (phasePresence == gnPhaseOnly)
 
  259                 temp_ = FluidSystem::inverseVaporPressureCurve(
fluidState_, gPhaseIdx, nCompIdx);
 
  261            else DUNE_THROW(Dune::InvalidStateException, 
"phasePresence: " << phasePresence << 
" is invalid.");
 
  263            for(
int phaseIdx=0; phaseIdx < FluidSystem::numPhases; ++phaseIdx)
 
  270            if (phasePresence == threePhases) {
 
  274                Scalar partPressH2O = FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, wCompIdx);
 
  275                Scalar partPressNAPL =  pg_ - partPressH2O;
 
  277                Scalar xgn = partPressNAPL/pg_;
 
  278                Scalar xgw = partPressH2O/pg_;
 
  281                Scalar xwn = partPressNAPL / FluidSystem::henryCoefficient(
fluidState_, wPhaseIdx,nCompIdx);
 
  285                Scalar xnw = partPressH2O / FluidSystem::henryCoefficient(
fluidState_, nPhaseIdx,wCompIdx);
 
  288                fluidState_.setMoleFraction(wPhaseIdx, wCompIdx, xww);
 
  289                fluidState_.setMoleFraction(wPhaseIdx, nCompIdx, xwn);
 
  290                fluidState_.setMoleFraction(gPhaseIdx, wCompIdx, xgw);
 
  291                fluidState_.setMoleFraction(gPhaseIdx, nCompIdx, xgn);
 
  292                fluidState_.setMoleFraction(nPhaseIdx, wCompIdx, xnw);
 
  293                fluidState_.setMoleFraction(nPhaseIdx, nCompIdx, xnn);
 
  295                Scalar rhoW = FluidSystem::density(
fluidState_, wPhaseIdx);
 
  296                Scalar rhoG = FluidSystem::density(
fluidState_, gPhaseIdx);
 
  297                Scalar rhoN = FluidSystem::density(
fluidState_, nPhaseIdx);
 
  298                Scalar rhoWMolar = FluidSystem::molarDensity(
fluidState_, wPhaseIdx);
 
  299                Scalar rhoGMolar = FluidSystem::molarDensity(
fluidState_, gPhaseIdx);
 
  300                Scalar rhoNMolar = FluidSystem::molarDensity(
fluidState_, nPhaseIdx);
 
  309            else if (phasePresence == wPhaseOnly) {
 
  314                Scalar xwn = 
priVars[switch2Idx];
 
  315                Scalar xww = 1 - xwn;
 
  318                fluidState_.setMoleFraction(wPhaseIdx, wCompIdx, xww);
 
  319                fluidState_.setMoleFraction(wPhaseIdx, nCompIdx, xwn);
 
  323                Scalar xgn = FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, nCompIdx) / pg_;
 
  324                Scalar xgw = FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, wCompIdx) / pg_;
 
  330                Scalar xnn = xwn * FluidSystem::henryCoefficient(
fluidState_, wPhaseIdx,nCompIdx) / (xgn * pg_);
 
  331                Scalar xnw = xgw*pg_ / FluidSystem::henryCoefficient(
fluidState_, nPhaseIdx,wCompIdx);
 
  333                fluidState_.setMoleFraction(gPhaseIdx, wCompIdx, xgw);
 
  334                fluidState_.setMoleFraction(gPhaseIdx, nCompIdx, xgn);
 
  335                fluidState_.setMoleFraction(nPhaseIdx, wCompIdx, xnw);
 
  336                fluidState_.setMoleFraction(nPhaseIdx, nCompIdx, xnn);
 
  338                Scalar rhoW = FluidSystem::density(
fluidState_, wPhaseIdx);
 
  339                Scalar rhoG = FluidSystem::density(
fluidState_, gPhaseIdx);
 
  340                Scalar rhoN = FluidSystem::density(
fluidState_, nPhaseIdx);
 
  341                Scalar rhoWMolar = FluidSystem::molarDensity(
fluidState_, wPhaseIdx);
 
  342                Scalar rhoGMolar = FluidSystem::molarDensity(
fluidState_, gPhaseIdx);
 
  343                Scalar rhoNMolar = FluidSystem::molarDensity(
fluidState_, nPhaseIdx);
 
  352            else if (phasePresence == gnPhaseOnly) {
 
  356                Scalar xnw = 
priVars[switch2Idx];
 
  358                Scalar xgn = FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, nCompIdx) / pg_;
 
  363                Scalar xww = FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, wCompIdx) / pg_;
 
  366                fluidState_.setMoleFraction(wPhaseIdx, wCompIdx, xww);
 
  367                fluidState_.setMoleFraction(gPhaseIdx, wCompIdx, xgw);
 
  368                fluidState_.setMoleFraction(gPhaseIdx, nCompIdx, xgn);
 
  369                fluidState_.setMoleFraction(nPhaseIdx, wCompIdx, xnw);
 
  370                fluidState_.setMoleFraction(nPhaseIdx, nCompIdx, xnn);
 
  372                Scalar rhoW = FluidSystem::density(
fluidState_, wPhaseIdx);
 
  373                Scalar rhoG = FluidSystem::density(
fluidState_, gPhaseIdx);
 
  374                Scalar rhoN = FluidSystem::density(
fluidState_, nPhaseIdx);
 
  375                Scalar rhoWMolar = FluidSystem::molarDensity(
fluidState_, wPhaseIdx);
 
  376                Scalar rhoGMolar = FluidSystem::molarDensity(
fluidState_, gPhaseIdx);
 
  377                Scalar rhoNMolar = FluidSystem::molarDensity(
fluidState_, nPhaseIdx);
 
  387            else if (phasePresence == wnPhaseOnly) {
 
  390                Scalar partPressH2O = FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, wCompIdx);
 
  391                Scalar partPressNAPL =  FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, nCompIdx);
 
  393                Scalar xgn = partPressNAPL/pg_;
 
  394                Scalar xgw = partPressH2O/pg_;
 
  397                Scalar xwn = partPressNAPL / FluidSystem::henryCoefficient(
fluidState_, wPhaseIdx,nCompIdx);
 
  400                Scalar xnw = partPressH2O / FluidSystem::henryCoefficient(
fluidState_, nPhaseIdx,wCompIdx);
 
  403                fluidState_.setMoleFraction(wPhaseIdx, wCompIdx, xww);
 
  404                fluidState_.setMoleFraction(wPhaseIdx, nCompIdx, xwn);
 
  405                fluidState_.setMoleFraction(gPhaseIdx, wCompIdx, xgw);
 
  406                fluidState_.setMoleFraction(gPhaseIdx, nCompIdx, xgn);
 
  407                fluidState_.setMoleFraction(nPhaseIdx, wCompIdx, xnw);
 
  408                fluidState_.setMoleFraction(nPhaseIdx, nCompIdx, xnn);
 
  410                Scalar rhoW = FluidSystem::density(
fluidState_, wPhaseIdx);
 
  411                Scalar rhoG = FluidSystem::density(
fluidState_, gPhaseIdx);
 
  412                Scalar rhoN = FluidSystem::density(
fluidState_, nPhaseIdx);
 
  413                Scalar rhoWMolar = FluidSystem::molarDensity(
fluidState_, wPhaseIdx);
 
  414                Scalar rhoGMolar = FluidSystem::molarDensity(
fluidState_, gPhaseIdx);
 
  415                Scalar rhoNMolar = FluidSystem::molarDensity(
fluidState_, nPhaseIdx);
 
  424            else if (phasePresence == gPhaseOnly) {
 
  428                const Scalar xgn = 
priVars[switch2Idx];
 
  429                Scalar xgw = 1 - xgn;
 
  432                fluidState_.setMoleFraction(gPhaseIdx, wCompIdx, xgw);
 
  433                fluidState_.setMoleFraction(gPhaseIdx, nCompIdx, xgn);
 
  437                Scalar xww = FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, wCompIdx) / pg_;
 
  438                Scalar xnn = FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, nCompIdx) / pg_;
 
  440                fluidState_.setMoleFraction(wPhaseIdx, wCompIdx, xww);
 
  441                fluidState_.setMoleFraction(nPhaseIdx, nCompIdx, xnn);
 
  443                Scalar rhoW = FluidSystem::density(
fluidState_, wPhaseIdx);
 
  444                Scalar rhoG = FluidSystem::density(
fluidState_, gPhaseIdx);
 
  445                Scalar rhoN = FluidSystem::density(
fluidState_, nPhaseIdx);
 
  446                Scalar rhoWMolar = FluidSystem::molarDensity(
fluidState_, wPhaseIdx);
 
  447                Scalar rhoGMolar = FluidSystem::molarDensity(
fluidState_, gPhaseIdx);
 
  448                Scalar rhoNMolar = FluidSystem::molarDensity(
fluidState_, nPhaseIdx);
 
  457            else if (phasePresence == wgPhaseOnly) {
 
  459                const Scalar xgn = 
priVars[switch2Idx];
 
  460                Scalar xgw = 1 - xgn;
 
  463                fluidState_.setMoleFraction(gPhaseIdx, wCompIdx, xgw);
 
  464                fluidState_.setMoleFraction(gPhaseIdx, nCompIdx, xgn);
 
  467                Scalar xwn = xgn*pg_/FluidSystem::henryCoefficient(
fluidState_, wPhaseIdx,nCompIdx);
 
  471                fluidState_.setMoleFraction(wPhaseIdx, wCompIdx, xww);
 
  472                fluidState_.setMoleFraction(wPhaseIdx, nCompIdx, xwn);
 
  476                Scalar xnn = FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, nCompIdx) / pg_;
 
  478                fluidState_.setMoleFraction(nPhaseIdx, nCompIdx, xnn);
 
  480                Scalar rhoW = FluidSystem::density(
fluidState_, wPhaseIdx);
 
  481                Scalar rhoG = FluidSystem::density(
fluidState_, gPhaseIdx);
 
  482                Scalar rhoN = FluidSystem::density(
fluidState_, nPhaseIdx);
 
  483                Scalar rhoWMolar = FluidSystem::molarDensity(
fluidState_, wPhaseIdx);
 
  484                Scalar rhoGMolar = FluidSystem::molarDensity(
fluidState_, gPhaseIdx);
 
  485                Scalar rhoNMolar = FluidSystem::molarDensity(
fluidState_, nPhaseIdx);
 
  501            if (phasePresence == threePhases)
 
  505                sg_ = 1. - sw_ - sn_;
 
  507            else if (phasePresence == wnPhaseOnly)
 
  513            else DUNE_THROW(Dune::InvalidStateException, 
"phasePresence: " << phasePresence << 
" is invalid.");
 
  519            const auto fluidMatrixInteraction = problem.spatialParams().fluidMatrixInteraction(element, scv, elemSol);
 
  522            const Scalar pcgw = fluidMatrixInteraction.pcgw(sw_, sn_);
 
  523            const Scalar pcnw = fluidMatrixInteraction.pcnw(sw_, sn_);
 
  524            const Scalar pcgn = fluidMatrixInteraction.pcgn(sw_, sn_);
 
  526            const Scalar pcAlpha = fluidMatrixInteraction.pcAlpha(sw_, sn_);
 
  527            const Scalar pcNW1 = 0.0; 
 
  530            if (phasePresence == threePhases)
 
  533                 pn_ = pg_- pcAlpha * pcgn - (1.-pcAlpha)*(pcgw - pcNW1);
 
  534                 pw_ = pn_ - pcAlpha * pcnw - (1.-pcAlpha)*pcNW1;
 
  536            else if (phasePresence == wnPhaseOnly)
 
  539                 pn_ = pw_ + pcAlpha * pcnw + (1.-pcAlpha)*pcNW1;
 
  540                 pg_ = pn_ + pcAlpha * pcgn + (1.-pcAlpha)*(pcgw - pcNW1);
 
  542            else DUNE_THROW(Dune::InvalidStateException, 
"phasePresence: " << phasePresence << 
" is invalid.");
 
  549            if (phasePresence == wnPhaseOnly)
 
  553            else if (phasePresence == threePhases)
 
  557                     Scalar tempOnlyWater = FluidSystem::inverseVaporPressureCurve(
fluidState_, gPhaseIdx, wCompIdx);
 
  558                     temp_ = tempOnlyWater;
 
  562                     Scalar tempOnlyNAPL = FluidSystem::inverseVaporPressureCurve(
fluidState_, gPhaseIdx, nCompIdx);
 
  563                     temp_ = tempOnlyNAPL;
 
  568                     Scalar tempOnlyNAPL = FluidSystem::inverseVaporPressureCurve(
fluidState_, gPhaseIdx, nCompIdx);
 
  569                     Scalar tempOnlyWater = FluidSystem::inverseVaporPressureCurve(
fluidState_, gPhaseIdx, wCompIdx);
 
  570                     for(
int phaseIdx=0; phaseIdx < FluidSystem::numPhases; ++phaseIdx)
 
  572                        fluidState_.setTemperature(phaseIdx, tempOnlyWater);
 
  575                     Scalar defect = pg_ - FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, wCompIdx)
 
  576                                         - FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, nCompIdx);
 
  578                     Scalar temp = tempOnlyWater; 
 
  581                     while(abs(defect) > 0.01) 
 
  583                         Scalar deltaT = 1.e-6; 
 
  584                         for(
int phaseIdx=0; phaseIdx < FluidSystem::numPhases; ++phaseIdx)
 
  589                         Scalar fUp = pg_ - FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, wCompIdx)
 
  590                                          - FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, nCompIdx);
 
  592                        for(
int phaseIdx=0; phaseIdx < FluidSystem::numPhases; ++phaseIdx)
 
  597                         Scalar fDown = pg_ - FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, wCompIdx)
 
  598                                          - FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, nCompIdx);
 
  600                         temp = temp - defect * 2. * deltaT / (fUp - fDown);
 
  602                         for(
int phaseIdx=0; phaseIdx < FluidSystem::numPhases; ++phaseIdx)
 
  607                         defect = pg_ - FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, wCompIdx)
 
  608                                      - FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, nCompIdx);
 
  610                         if (counter>10) 
break;
 
  612                     if ((sw_>1.e-10)&&(sw_<0.01))
 
  613                         temp = temp + (sw_ - 1.e-10) * (temp - tempOnlyNAPL) / (0.01 - 1.e-10);
 
  614                     if ((sn_>1.e-10)&&(sn_<0.01))
 
  615                         temp = temp + (sn_ - 1.e-10) * (temp - tempOnlyWater) / (0.01 - 1.e-10);
 
  619            else DUNE_THROW(Dune::InvalidStateException, 
"phasePresence: " << phasePresence << 
" is invalid.");
 
  621            for (
int phaseIdx=0; phaseIdx < FluidSystem::numPhases; ++phaseIdx)
 
  627            if (phasePresence == threePhases) {
 
  631                Scalar partPressH2O = FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, wCompIdx);
 
  632                Scalar partPressNAPL =  pg_ - partPressH2O;
 
  635                if (sw_<0.02) partPressH2O *= sw_/0.02;
 
  636                if (partPressH2O < 0.) partPressH2O = 0;
 
  637                if (sn_<0.02) partPressNAPL *= sn_ / 0.02;
 
  638                if (partPressNAPL < 0.) partPressNAPL = 0;
 
  640                Scalar xgn = partPressNAPL/pg_;
 
  641                Scalar xgw = partPressH2O/pg_;
 
  651                fluidState_.setMoleFraction(wPhaseIdx, wCompIdx, xww);
 
  652                fluidState_.setMoleFraction(wPhaseIdx, nCompIdx, xwn);
 
  653                fluidState_.setMoleFraction(gPhaseIdx, wCompIdx, xgw);
 
  654                fluidState_.setMoleFraction(gPhaseIdx, nCompIdx, xgn);
 
  655                fluidState_.setMoleFraction(nPhaseIdx, wCompIdx, xnw);
 
  656                fluidState_.setMoleFraction(nPhaseIdx, nCompIdx, xnn);
 
  658                Scalar rhoW = FluidSystem::density(
fluidState_, wPhaseIdx);
 
  659                Scalar rhoG = FluidSystem::density(
fluidState_, gPhaseIdx);
 
  660                Scalar rhoN = FluidSystem::density(
fluidState_, nPhaseIdx);
 
  661                Scalar rhoWMolar = FluidSystem::molarDensity(
fluidState_, wPhaseIdx);
 
  662                Scalar rhoGMolar = FluidSystem::molarDensity(
fluidState_, gPhaseIdx);
 
  663                Scalar rhoNMolar = FluidSystem::molarDensity(
fluidState_, nPhaseIdx);
 
  672            else if (phasePresence == wnPhaseOnly) {
 
  674                Scalar partPressH2O = FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, wCompIdx);
 
  675                Scalar partPressNAPL =  FluidSystem::partialPressureGas(
fluidState_, gPhaseIdx, nCompIdx);
 
  677                Scalar xgn = partPressNAPL/pg_;
 
  678                Scalar xgw = partPressH2O/pg_;
 
  687                fluidState_.setMoleFraction(wPhaseIdx, wCompIdx, xww);
 
  688                fluidState_.setMoleFraction(wPhaseIdx, nCompIdx, xwn);
 
  689                fluidState_.setMoleFraction(gPhaseIdx, wCompIdx, xgw);
 
  690                fluidState_.setMoleFraction(gPhaseIdx, nCompIdx, xgn);
 
  691                fluidState_.setMoleFraction(nPhaseIdx, wCompIdx, xnw);
 
  692                fluidState_.setMoleFraction(nPhaseIdx, nCompIdx, xnn);
 
  694                Scalar rhoW = FluidSystem::density(
fluidState_, wPhaseIdx);
 
  695                Scalar rhoG = FluidSystem::density(
fluidState_, gPhaseIdx);
 
  696                Scalar rhoN = FluidSystem::density(
fluidState_, nPhaseIdx);
 
  697                Scalar rhoWMolar = FluidSystem::molarDensity(
fluidState_, wPhaseIdx);
 
  698                Scalar rhoGMolar = FluidSystem::molarDensity(
fluidState_, gPhaseIdx);
 
  699                Scalar rhoNMolar = FluidSystem::molarDensity(
fluidState_, nPhaseIdx);
 
  708            else DUNE_THROW(Dune::InvalidStateException, 
"phasePresence: " << phasePresence << 
" is invalid.");
 
  711        const auto fluidMatrixInteraction = problem.spatialParams().fluidMatrixInteraction(element, scv, elemSol);
 
  712        for (
int phaseIdx = 0; phaseIdx < numPs; ++phaseIdx)
 
  720            const Scalar kr = fluidMatrixInteraction.kr(phaseIdx,
 
  723            mobility_[phaseIdx] = kr / mu;
 
  728            bulkDensTimesAdsorpCoeff_ = fluidMatrixInteraction.adsorptionModel().bulkDensTimesAdsorpCoeff();
 
  732        EnergyVolVars::updateSolidEnergyParams(elemSol, problem, element, scv, 
solidState_);
 
  734        auto getEffectiveDiffusionCoefficient = [&](
int phaseIdx, 
int compIIdx, 
int compJIdx)
 
  736            return EffDiffModel::effectiveDiffusionCoefficient(*
this, phaseIdx, compIIdx, compJIdx);
 
  739        effectiveDiffCoeff_.update(getEffectiveDiffusionCoefficient);
 
  742        permeability_ = problem.spatialParams().permeability(element, scv, elemSol);
 
  746        for (
int phaseIdx = 0; phaseIdx < numPs; ++phaseIdx)
 
  748            Scalar h = FluidSystem::enthalpy(
fluidState_, phaseIdx);
 
  752        EnergyVolVars::updateEffectiveThermalConductivity();