116                const Problem &problem,
 
  117                const Element &element,
 
  121        const auto& 
priVars = elemSol[scv.localDofIndex()];
 
  122        const auto phasePresence = 
priVars.state();
 
  124        constexpr bool useConstraintSolver = ModelTraits::useConstraintSolver();
 
  129        if (phasePresence == threePhases)
 
  133            sg_ = 1. - sw_ - sn_;
 
  135        else if (phasePresence == wPhaseOnly)
 
  141        else if (phasePresence == gnPhaseOnly)
 
  147        else if (phasePresence == wnPhaseOnly)
 
  153        else if (phasePresence == gPhaseOnly)
 
  159        else if (phasePresence == wgPhaseOnly)
 
  166            DUNE_THROW(Dune::InvalidStateException, 
"phasePresence: " << phasePresence << 
" is invalid.");
 
  177        const auto fluidMatrixInteraction = problem.spatialParams().fluidMatrixInteraction(element, scv, elemSol);
 
  178        Scalar pcgw = fluidMatrixInteraction.pcgw(sw_, sn_);
 
  179        Scalar pcnw = fluidMatrixInteraction.pcnw(sw_, sn_);
 
  180        Scalar pcgn = fluidMatrixInteraction.pcgn(sw_, sn_);
 
  182        const Scalar pcAlpha = fluidMatrixInteraction.pcAlpha(sw_, sn_);
 
  183        const Scalar pcNW1 = 0.0; 
 
  185        pn_ = pg_- pcAlpha * pcgn - (1.-pcAlpha)*(pcgw - pcNW1);
 
  186        pw_ = pn_ - pcAlpha * pcnw - (1.-pcAlpha)*pcNW1;
 
  196        typename FluidSystem::ParameterCache paramCache;
 
  198        for (
int phaseIdx = 0; phaseIdx < ModelTraits::numFluidPhases(); ++ phaseIdx) {
 
  199            assert(FluidSystem::isIdealMixture(phaseIdx));
 
  201            for (
int compIdx = 0; compIdx < ModelTraits::numFluidComponents(); ++ compIdx) {
 
  202                Scalar phi = FluidSystem::fugacityCoefficient(
fluidState_, paramCache, phaseIdx, compIdx);
 
  203                fluidState_.setFugacityCoefficient(phaseIdx, compIdx, phi);
 
  208        if (phasePresence == threePhases) {
 
  213            if (useConstraintSolver) {
 
  222                Scalar partPressH2O = FluidSystem::fugacityCoefficient(
fluidState_,
 
  225                if (partPressH2O > pg_) partPressH2O = pg_;
 
  226                Scalar partPressNAPL = FluidSystem::fugacityCoefficient(
fluidState_,
 
  229                if (partPressNAPL > pg_) partPressNAPL = pg_;
 
  230                Scalar partPressAir = pg_ - partPressH2O - partPressNAPL;
 
  232                Scalar xgn = partPressNAPL/pg_;
 
  233                Scalar xgw = partPressH2O/pg_;
 
  234                Scalar xgg = partPressAir/pg_;
 
  237                Scalar xwn = partPressNAPL
 
  241                Scalar xwg = partPressAir
 
  245                Scalar xww = 1.-xwg-xwn;
 
  247                Scalar xnn = 1.-2.e-10;
 
  251                fluidState_.setMoleFraction(wPhaseIdx, wCompIdx, xww);
 
  252                fluidState_.setMoleFraction(wPhaseIdx, gCompIdx, xwg);
 
  253                fluidState_.setMoleFraction(wPhaseIdx, nCompIdx, xwn);
 
  254                fluidState_.setMoleFraction(gPhaseIdx, wCompIdx, xgw);
 
  255                fluidState_.setMoleFraction(gPhaseIdx, gCompIdx, xgg);
 
  256                fluidState_.setMoleFraction(gPhaseIdx, nCompIdx, xgn);
 
  257                fluidState_.setMoleFraction(nPhaseIdx, wCompIdx, xnw);
 
  258                fluidState_.setMoleFraction(nPhaseIdx, gCompIdx, xna);
 
  259                fluidState_.setMoleFraction(nPhaseIdx, nCompIdx, xnn);
 
  261                Scalar rhoW = FluidSystem::density(
fluidState_, wPhaseIdx);
 
  262                Scalar rhoG = FluidSystem::density(
fluidState_, gPhaseIdx);
 
  263                Scalar rhoN = FluidSystem::density(
fluidState_, nPhaseIdx);
 
  264                Scalar rhoWMolar = FluidSystem::molarDensity(
fluidState_, wPhaseIdx);
 
  265                Scalar rhoGMolar = FluidSystem::molarDensity(
fluidState_, gPhaseIdx);
 
  266                Scalar rhoNMolar = FluidSystem::molarDensity(
fluidState_, nPhaseIdx);
 
  276        else if (phasePresence == wPhaseOnly) {
 
  281            Scalar xwg = 
priVars[switch1Idx];
 
  282            Scalar xwn = 
priVars[switch2Idx];
 
  283            Scalar xww = 1 - xwg - xwn;
 
  286            fluidState_.setMoleFraction(wPhaseIdx, wCompIdx, xww);
 
  287            fluidState_.setMoleFraction(wPhaseIdx, gCompIdx, xwg);
 
  288            fluidState_.setMoleFraction(wPhaseIdx, nCompIdx, xwn);
 
  293            if (useConstraintSolver)
 
  303                Scalar xgg = xwg * FluidSystem::fugacityCoefficient(
fluidState_,
 
  306                Scalar xgn = xwn * FluidSystem::fugacityCoefficient(
fluidState_,
 
  309                Scalar xgw = FluidSystem::fugacityCoefficient(
fluidState_,
 
  316                Scalar xnn = xwn * FluidSystem::fugacityCoefficient(
fluidState_,
 
  322                fluidState_.setMoleFraction(gPhaseIdx, wCompIdx, xgw);
 
  323                fluidState_.setMoleFraction(gPhaseIdx, gCompIdx, xgg);
 
  324                fluidState_.setMoleFraction(gPhaseIdx, nCompIdx, xgn);
 
  325                fluidState_.setMoleFraction(nPhaseIdx, wCompIdx, xnw);
 
  326                fluidState_.setMoleFraction(nPhaseIdx, gCompIdx, xna);
 
  327                fluidState_.setMoleFraction(nPhaseIdx, nCompIdx, xnn);
 
  329                Scalar rhoW = FluidSystem::density(
fluidState_, wPhaseIdx);
 
  330                Scalar rhoG = FluidSystem::density(
fluidState_, gPhaseIdx);
 
  331                Scalar rhoN = FluidSystem::density(
fluidState_, nPhaseIdx);
 
  332                Scalar rhoWMolar = FluidSystem::molarDensity(
fluidState_, wPhaseIdx);
 
  333                Scalar rhoGMolar = FluidSystem::molarDensity(
fluidState_, gPhaseIdx);
 
  334                Scalar rhoNMolar = FluidSystem::molarDensity(
fluidState_, nPhaseIdx);
 
  344        else if (phasePresence == gnPhaseOnly) {
 
  353            Scalar partPressNAPL = 
fluidState_.fugacityCoefficient(nPhaseIdx, nCompIdx)*pn_;
 
  354            if (partPressNAPL > pg_) partPressNAPL = pg_;
 
  356            Scalar xgw = 
priVars[switch1Idx];
 
  357            Scalar xgn = partPressNAPL/pg_;
 
  358            Scalar xgg = 1.-xgw-xgn;
 
  361            fluidState_.setMoleFraction(gPhaseIdx, wCompIdx, xgw);
 
  362            fluidState_.setMoleFraction(gPhaseIdx, gCompIdx, xgg);
 
  363            fluidState_.setMoleFraction(gPhaseIdx, nCompIdx, xgn);
 
  372        else if (phasePresence == wnPhaseOnly) {
 
  374            Scalar partPressNAPL = 
fluidState_.fugacityCoefficient(nPhaseIdx,nCompIdx)*pn_;
 
  375            if (partPressNAPL > pg_) partPressNAPL = pg_;
 
  376            Scalar henryC = 
fluidState_.fugacityCoefficient(wPhaseIdx,nCompIdx)*pw_;
 
  378            Scalar xwg = 
priVars[switch1Idx];
 
  379            Scalar xwn = partPressNAPL/henryC;
 
  380            Scalar xww = 1.-xwg-xwn;
 
  383            fluidState_.setMoleFraction(wPhaseIdx, wCompIdx, xww);
 
  384            fluidState_.setMoleFraction(wPhaseIdx, gCompIdx, xwg);
 
  385            fluidState_.setMoleFraction(wPhaseIdx, nCompIdx, xwn);
 
  394        else if (phasePresence == gPhaseOnly) {
 
  398            const Scalar xgw = 
priVars[switch1Idx];
 
  399            const Scalar xgn = 
priVars[switch2Idx];
 
  400            Scalar xgg = 1 - xgw - xgn;
 
  403            fluidState_.setMoleFraction(gPhaseIdx, wCompIdx, xgw);
 
  404            fluidState_.setMoleFraction(gPhaseIdx, gCompIdx, xgg);
 
  405            fluidState_.setMoleFraction(gPhaseIdx, nCompIdx, xgn);
 
  410            if (useConstraintSolver)
 
  421                Scalar xww = xgw * pg_
 
  430                Scalar xnn = xgn * pg_
 
  437                fluidState_.setMoleFraction(wPhaseIdx, wCompIdx, xww);
 
  438                fluidState_.setMoleFraction(wPhaseIdx, gCompIdx, xwg);
 
  439                fluidState_.setMoleFraction(wPhaseIdx, nCompIdx, xwn);
 
  440                fluidState_.setMoleFraction(nPhaseIdx, wCompIdx, xnw);
 
  441                fluidState_.setMoleFraction(nPhaseIdx, gCompIdx, xna);
 
  442                fluidState_.setMoleFraction(nPhaseIdx, nCompIdx, xnn);
 
  444                Scalar rhoW = FluidSystem::density(
fluidState_, wPhaseIdx);
 
  445                Scalar rhoG = FluidSystem::density(
fluidState_, gPhaseIdx);
 
  446                Scalar rhoN = FluidSystem::density(
fluidState_, nPhaseIdx);
 
  447                Scalar rhoWMolar = FluidSystem::molarDensity(
fluidState_, wPhaseIdx);
 
  448                Scalar rhoGMolar = FluidSystem::molarDensity(
fluidState_, gPhaseIdx);
 
  449                Scalar rhoNMolar = FluidSystem::molarDensity(
fluidState_, nPhaseIdx);
 
  459        else if (phasePresence == wgPhaseOnly) {
 
  461            Scalar xgn = 
priVars[switch2Idx];
 
  462            Scalar partPressH2O = 
fluidState_.fugacityCoefficient(wPhaseIdx, wCompIdx)*pw_;
 
  463            if (partPressH2O > pg_) partPressH2O = pg_;
 
  465            Scalar xgw = partPressH2O/pg_;
 
  466            Scalar xgg = 1.-xgn-xgw;
 
  469            fluidState_.setMoleFraction(gPhaseIdx, wCompIdx, xgw);
 
  470            fluidState_.setMoleFraction(gPhaseIdx, gCompIdx, xgg);
 
  471            fluidState_.setMoleFraction(gPhaseIdx, nCompIdx, xgn);
 
  476            if (useConstraintSolver)
 
  485                Scalar xwn = xgn * pg_
 
  489                Scalar xwg = xgg * pg_
 
  493                Scalar xww = 1.-xwg-xwn;
 
  497                Scalar xnn = xgn * pg_
 
  504                fluidState_.setMoleFraction(wPhaseIdx, wCompIdx, xww);
 
  505                fluidState_.setMoleFraction(wPhaseIdx, gCompIdx, xwg);
 
  506                fluidState_.setMoleFraction(wPhaseIdx, nCompIdx, xwn);
 
  507                fluidState_.setMoleFraction(nPhaseIdx, wCompIdx, xnw);
 
  508                fluidState_.setMoleFraction(nPhaseIdx, gCompIdx, xna);
 
  509                fluidState_.setMoleFraction(nPhaseIdx, nCompIdx, xnn);
 
  511                Scalar rhoW = FluidSystem::density(
fluidState_, wPhaseIdx);
 
  512                Scalar rhoG = FluidSystem::density(
fluidState_, gPhaseIdx);
 
  513                Scalar rhoN = FluidSystem::density(
fluidState_, nPhaseIdx);
 
  514                Scalar rhoWMolar = FluidSystem::molarDensity(
fluidState_, wPhaseIdx);
 
  515                Scalar rhoGMolar = FluidSystem::molarDensity(
fluidState_, gPhaseIdx);
 
  516                Scalar rhoNMolar = FluidSystem::molarDensity(
fluidState_, nPhaseIdx);
 
  527            DUNE_THROW(Dune::InvalidStateException, 
"phasePresence: " << phasePresence << 
" is invalid.");
 
  529        for (
int phaseIdx = 0; phaseIdx < ModelTraits::numFluidPhases(); ++phaseIdx)
 
  538            const Scalar kr = fluidMatrixInteraction.kr(phaseIdx,
 
  541            mobility_[phaseIdx] = kr / mu;
 
  546            bulkDensTimesAdsorpCoeff_ = fluidMatrixInteraction.adsorptionModel().bulkDensTimesAdsorpCoeff();
 
  556        auto getEffectiveDiffusionCoefficient = [&](
int phaseIdx, 
int compIIdx, 
int compJIdx)
 
  558            return EffDiffModel::effectiveDiffusionCoefficient(*
this, phaseIdx, compIIdx, compJIdx);
 
  564        effectiveDiffCoeff_.update(getEffectiveDiffusionCoefficient);
 
  566        EnergyVolVars::updateSolidEnergyParams(elemSol, problem, element, scv, 
solidState_);
 
  567        permeability_ = problem.spatialParams().permeability(element, scv, elemSol);
 
  568        EnergyVolVars::updateEffectiveThermalConductivity();
 
  571        for (
int phaseIdx = 0; phaseIdx < ModelTraits::numFluidPhases(); ++phaseIdx)
 
  573            Scalar h = EnergyVolVars::enthalpy(
fluidState_, paramCache, phaseIdx);