diff --git a/dumux/discretization/cellcentered/tpfa/fourierslawnonequilibrium.hh b/dumux/discretization/cellcentered/tpfa/fourierslawnonequilibrium.hh
index df203a6d334bfb11948ff7d4d1c6fab1cce2b808..e0b784c0fc32a637f707a49696077111bbf21a78 100644
--- a/dumux/discretization/cellcentered/tpfa/fourierslawnonequilibrium.hh
+++ b/dumux/discretization/cellcentered/tpfa/fourierslawnonequilibrium.hh
@@ -184,9 +184,6 @@ public:
         }
         return tij;
     }
-
-private:
-
 };
 
 } // end namespace Dumux
diff --git a/dumux/material/constraintsolvers/immiscibleflash.hh b/dumux/material/constraintsolvers/immiscibleflash.hh
index 8677de23161ed73d723a0cea5041d772bdc4ce68..483bb6c818aabd7ea5e21df3b6b9883ced7568a6 100644
--- a/dumux/material/constraintsolvers/immiscibleflash.hh
+++ b/dumux/material/constraintsolvers/immiscibleflash.hh
@@ -151,7 +151,7 @@ public:
             }
         }
 
-        /////////////////////////
+//         /////////////////////////
         // Newton method
         /////////////////////////
 
@@ -392,7 +392,7 @@ protected:
         // and first pressure are already set because it is implicitly
         // solved for.)
         ComponentVector pc;
-        MaterialLaw::capillaryPressures(pc, matParams, fluidState, fluidState.wettingPhase());
+        MaterialLaw::capillaryPressures(pc, matParams, fluidState);
         for (int phaseIdx = 1; phaseIdx < numPhases; ++phaseIdx)
             fluidState.setPressure(phaseIdx,
                                    fluidState.pressure(0)
@@ -478,7 +478,7 @@ protected:
             // update all fluid pressures using the capillary pressure
             // law
             ComponentVector pc;
-            MaterialLaw::capillaryPressures(pc, matParams, fs, fs.wettingPhase());
+            MaterialLaw::capillaryPressures(pc, matParams, fs);
             for (int phaseIdx = 1; phaseIdx < numPhases; ++phaseIdx)
                 fs.setPressure(phaseIdx,
                                fs.pressure(0)
diff --git a/dumux/material/constraintsolvers/ncpflash.hh b/dumux/material/constraintsolvers/ncpflash.hh
index 3dc0e3678a78edb737209a57f494e6a4bbb3f615..a10c2c3959f69e2ce1ba656bbf3123c35a52da1a 100644
--- a/dumux/material/constraintsolvers/ncpflash.hh
+++ b/dumux/material/constraintsolvers/ncpflash.hh
@@ -514,7 +514,7 @@ protected:
         // and first pressure are already set because it is implicitly
         // solved for.)
         ComponentVector pc;
-        MaterialLaw::capillaryPressures(pc, matParams, fluidState, fluidState.wettingPhase());
+        MaterialLaw::capillaryPressures(pc, matParams, fluidState);
         for (int phaseIdx = 1; phaseIdx < numPhases; ++phaseIdx)
             fluidState.setPressure(phaseIdx,
                                    fluidState.pressure(0)
@@ -616,7 +616,7 @@ protected:
             // update all fluid pressures using the capillary pressure
             // law
             ComponentVector pc;
-            MaterialLaw::capillaryPressures(pc, matParams, fs, fs.wettingPhase());
+            MaterialLaw::capillaryPressures(pc, matParams, fs);
             for (int phaseIdx = 1; phaseIdx < numPhases; ++phaseIdx)
                 fs.setPressure(phaseIdx,
                                fs.pressure(0)
diff --git a/dumux/material/fluidmatrixinteractions/mp/mpadapter.hh b/dumux/material/fluidmatrixinteractions/mp/mpadapter.hh
index a9294a43303556678d0f58e2f37c93fde5169e03..2a903dec7da5f823665a01e6f8387c5326846a68 100644
--- a/dumux/material/fluidmatrixinteractions/mp/mpadapter.hh
+++ b/dumux/material/fluidmatrixinteractions/mp/mpadapter.hh
@@ -53,14 +53,13 @@ public:
      * \param values Container for the return values
      * \param params Array of parameters
      * \param state Fluidstate
-     * \param wPhaseIdx index of the wetting phase
      */
     template <class ContainerT, class FluidState>
     static void capillaryPressures(ContainerT &values,
                                    const Params &params,
-                                   const FluidState &state,
-                                   const int wPhaseIdx)
+                                   const FluidState &state)
     {
+        const int wPhaseIdx = state.wettingPhase();
         assert(values.size() == 2);
         const int nPhaseIdx = 1 - wPhaseIdx;
         // non-wetting phase gets the capillary pressure added
@@ -74,14 +73,13 @@ public:
      * \param values Container for the return values
      * \param params Array of parameters
      * \param state Fluidstate
-     * \param wPhaseIdx index of the wetting phase
      */
     template <class ContainerT, class FluidState>
     static void relativePermeabilities(ContainerT &values,
                                        const Params &params,
-                                       const FluidState &state,
-                                       const int wPhaseIdx)
+                                       const FluidState &state)
     {
+        const int wPhaseIdx = state.wettingPhase();
         assert(values.size() == 2);
         const int nPhaseIdx = 1 - wPhaseIdx;
         values[wPhaseIdx] = MaterialLaw::krw(params, state.saturation(wPhaseIdx));
diff --git a/dumux/material/fluidmatrixinteractions/mp/mplinearmaterial.hh b/dumux/material/fluidmatrixinteractions/mp/mplinearmaterial.hh
index 5a5c5f0ddfb3a88d5daf83693d62122152802311..d1b1aa33be4aa8f7be1c91fefc151fa429de22c7 100644
--- a/dumux/material/fluidmatrixinteractions/mp/mplinearmaterial.hh
+++ b/dumux/material/fluidmatrixinteractions/mp/mplinearmaterial.hh
@@ -61,13 +61,11 @@ public:
      * \param values Container for the return values
      * \param params Array of Parameters
      * \param state The fluid state
-     * \param wPhaseIdx index of the wetting phase
      */
     template <class ContainerT, class FluidState>
     static void capillaryPressures(ContainerT &values,
                                    const Params &params,
-                                   const FluidState &state,
-                                   const int wPhaseIdx)
+                                   const FluidState &state)
     {
         for (int phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
             Scalar S = state.saturation(phaseIdx);
@@ -82,13 +80,11 @@ public:
      * \param values Container for the return values
      * \param params Array of Parameters
      * \param state The fluid state
-     * \param wPhaseIdx index of the wetting phase
      */
     template <class ContainerT, class FluidState>
     static void relativePermeabilities(ContainerT &values,
                                        const Params &params,
-                                       const FluidState &state,
-                                       const int wPhaseIdx)
+                                       const FluidState &state)
     {
         using std::max;
         using std::min;
diff --git a/dumux/material/spatialparams/fvnonequilibrium.hh b/dumux/material/spatialparams/fvnonequilibrium.hh
index c2cf3be5563f787914c8d81f34fac0dbd8b6b443..809adc95e9271c79ad619ff2bd5f174dc1e76488 100644
--- a/dumux/material/spatialparams/fvnonequilibrium.hh
+++ b/dumux/material/spatialparams/fvnonequilibrium.hh
@@ -45,7 +45,6 @@ class FVNonEquilibriumSpatialParams
 
 public:
     //! export the types used for interfacial area calculations
-
     using AwnSurfaceParams = Scalar;
     using AwsSurfaceParams = Scalar;
     using AnsSurfaceParams = Scalar;
diff --git a/dumux/porousmediumflow/mpnc/volumevariables.hh b/dumux/porousmediumflow/mpnc/volumevariables.hh
index 7684073074172fea995be6db9ee77f8ffb05f1d4..04b1ca55713d09cbd6fe011dae1bbb0d60c523e9 100644
--- a/dumux/porousmediumflow/mpnc/volumevariables.hh
+++ b/dumux/porousmediumflow/mpnc/volumevariables.hh
@@ -106,14 +106,12 @@ public:
 
         //calculate the remaining quantities
         const auto& materialParams = problem.spatialParams().materialLawParams(element, scv, elemSol);
-        const int wPhaseIdx = problem.spatialParams().template wettingPhase<FluidSystem>(element, scv, elemSol);
         // relative permeabilities
         using MaterialLaw = typename Problem::SpatialParams::MaterialLaw;
         using MPAdapter = MPAdapter<MaterialLaw, numPhases()>;
         MPAdapter::relativePermeabilities(relativePermeability_,
                                             materialParams,
-                                            fluidState_,
-                                            wPhaseIdx);
+                                            fluidState_);
         typename FluidSystem::ParameterCache paramCache;
         paramCache.updateAll(fluidState_);
         if (enableDiffusion)
@@ -184,13 +182,14 @@ public:
         /////////////
         // capillary pressure parameters
         const int wPhaseIdx = problem.spatialParams().template wettingPhase<FluidSystem>(element, scv, elemSol);
+        fluidState.setWettingPhase(wPhaseIdx);
         const auto& materialParams =
             problem.spatialParams().materialLawParams(element, scv, elemSol);
         // capillary pressures
         std::vector<Scalar> capPress(numPhases());
         using MaterialLaw = typename Problem::SpatialParams::MaterialLaw;
         using MPAdapter = MPAdapter<MaterialLaw, numPhases()>;
-        MPAdapter::capillaryPressures(capPress, materialParams, fluidState, wPhaseIdx);
+        MPAdapter::capillaryPressures(capPress, materialParams, fluidState);
         // add to the pressure of the first fluid phase
 
         // depending on which pressure is stored in the primary variables
@@ -563,13 +562,11 @@ public:
         const auto& materialParams = problem.spatialParams().materialLawParams(element, scv, elemSol);
 
         // relative permeabilities
-        const int wPhaseIdx = problem.spatialParams().template wettingPhase<FluidSystem>(element, scv, elemSol);
         using MaterialLaw = typename Problem::SpatialParams::MaterialLaw;
         using MPAdapter = MPAdapter<MaterialLaw, numPhases()>;
         MPAdapter::relativePermeabilities(relativePermeability_,
                                           materialParams,
-                                          fluidState_,
-                                          wPhaseIdx);
+                                          fluidState_);
         typename FluidSystem::ParameterCache paramCache;
         paramCache.updateAll(fluidState_);
         if (enableDiffusion)
@@ -641,11 +638,12 @@ public:
         const auto& materialParams =
             problem.spatialParams().materialLawParams(element, scv, elemSol);
         const int wPhaseIdx = problem.spatialParams().template wettingPhase<FluidSystem>(element, scv, elemSol);
+        fluidState.setWettingPhase(wPhaseIdx);
         // capillary pressures
         std::vector<Scalar> capPress(numPhases());
         using MaterialLaw = typename Problem::SpatialParams::MaterialLaw;
         using MPAdapter = MPAdapter<MaterialLaw, numPhases()>;
-        MPAdapter::capillaryPressures(capPress, materialParams, fluidState, wPhaseIdx);
+        MPAdapter::capillaryPressures(capPress, materialParams, fluidState);
         // add to the pressure of the first fluid phase
 
         // depending on which pressure is stored in the primary variables
diff --git a/test/material/immiscibleflash/test_immiscibleflash.cc b/test/material/immiscibleflash/test_immiscibleflash.cc
index 76106c43392761a15df4e208a0b19fc3f4f25d92..14133fa5485a80b79af219e64102555b4ccdde4f 100644
--- a/test/material/immiscibleflash/test_immiscibleflash.cc
+++ b/test/material/immiscibleflash/test_immiscibleflash.cc
@@ -82,7 +82,7 @@ void checkSame(const FluidState &fsRef, const FluidState &fsFlash)
     }
 }
 
-template <class Scalar, class FluidSystem, class MaterialLaw, class MPAdapter, class FluidState>
+template <class Scalar, class FluidSystem, class MaterialLaw, class FluidState>
 void checkImmiscibleFlash(const FluidState &fsRef,
                           typename MaterialLaw::Params &matParams)
 {
@@ -109,14 +109,14 @@ void checkImmiscibleFlash(const FluidState &fsRef,
     // run the flash calculation
     typename FluidSystem::ParameterCache paramCache;
     ImmiscibleFlash::guessInitial(fsFlash, paramCache, globalMolarities);
-    ImmiscibleFlash::template solve<MPAdapter>(fsFlash, paramCache, matParams, globalMolarities);
+    ImmiscibleFlash::template solve<MaterialLaw>(fsFlash, paramCache, matParams, globalMolarities);
 
     // compare the "flashed" fluid state with the reference one
     checkSame<Scalar>(fsRef, fsFlash);
 }
 
 
-template <class Scalar, class FluidSystem, class MaterialLaw, class MPAdapter, class FluidState>
+template <class Scalar, class FluidSystem, class MaterialLaw, class FluidState>
 void completeReferenceFluidState(FluidState &fs,
                                  typename MaterialLaw::Params &matParams,
                                  int refPhaseIdx)
@@ -132,7 +132,7 @@ void completeReferenceFluidState(FluidState &fs,
 
     // calulate the capillary pressure
     PhaseVector pc;
-    MPAdapter::capillaryPressures(pc, matParams, fs, fs.wettingPhase());
+    MaterialLaw::capillaryPressures(pc, matParams, fs);
     fs.setPressure(otherPhaseIdx,
                    fs.pressure(refPhaseIdx)
                    + (pc[otherPhaseIdx] - pc[refPhaseIdx]));
@@ -202,10 +202,10 @@ int main()
     fsRef.setPressure(liquidPhaseIdx, 1e6);
 
     // set the remaining parameters of the reference fluid state
-    completeReferenceFluidState<Scalar, FluidSystem, MaterialLaw, MPAdapter>(fsRef, matParams, liquidPhaseIdx);
+    completeReferenceFluidState<Scalar, FluidSystem, MPAdapter>(fsRef, matParams, liquidPhaseIdx);
 
     // check the flash calculation
-    checkImmiscibleFlash<Scalar, FluidSystem, MaterialLaw, MPAdapter>(fsRef, matParams);
+    checkImmiscibleFlash<Scalar, FluidSystem, MPAdapter>(fsRef, matParams);
 
     ////////////////
     // only gas
@@ -217,10 +217,10 @@ int main()
     fsRef.setPressure(gasPhaseIdx, 1e6);
 
     // set the remaining parameters of the reference fluid state
-    completeReferenceFluidState<Scalar, FluidSystem, MaterialLaw, MPAdapter>(fsRef, matParams, gasPhaseIdx);
+    completeReferenceFluidState<Scalar, FluidSystem, MPAdapter>(fsRef, matParams, gasPhaseIdx);
 
     // check the flash calculation
-    checkImmiscibleFlash<Scalar, FluidSystem, MaterialLaw, MPAdapter>(fsRef, matParams);
+    checkImmiscibleFlash<Scalar, FluidSystem, MPAdapter>(fsRef, matParams);
 
     ////////////////
     // both phases
@@ -234,10 +234,10 @@ int main()
     fsRef.setWettingPhase(liquidPhaseIdx);
 
     // set the remaining parameters of the reference fluid state
-    completeReferenceFluidState<Scalar, FluidSystem, MaterialLaw, MPAdapter>(fsRef, matParams, liquidPhaseIdx);
+    completeReferenceFluidState<Scalar, FluidSystem, MPAdapter>(fsRef, matParams, liquidPhaseIdx);
 
     // check the flash calculation
-    checkImmiscibleFlash<Scalar, FluidSystem, MaterialLaw, MPAdapter>(fsRef, matParams);
+    checkImmiscibleFlash<Scalar, FluidSystem, MPAdapter>(fsRef, matParams);
 
     ////////////////
     // with capillary pressure
@@ -257,10 +257,10 @@ int main()
     fsRef.setPressure(liquidPhaseIdx, 1e6);
 
     // set the remaining parameters of the reference fluid state
-    completeReferenceFluidState<Scalar, FluidSystem, MaterialLaw, MPAdapter>(fsRef, matParams2, liquidPhaseIdx);
+    completeReferenceFluidState<Scalar, FluidSystem, MPAdapter>(fsRef, matParams2, liquidPhaseIdx);
 
     // check the flash calculation
-    checkImmiscibleFlash<Scalar, FluidSystem, MaterialLaw, MPAdapter>(fsRef, matParams2);
+    checkImmiscibleFlash<Scalar, FluidSystem, MPAdapter>(fsRef, matParams2);
 
     return 0;
 }
diff --git a/test/material/ncpflash/test_ncpflash.cc b/test/material/ncpflash/test_ncpflash.cc
index 460341a3962c4e4469bd05a18d5b564136ae62e9..0be92f8936b5049910afb7539c8a275e99113740 100644
--- a/test/material/ncpflash/test_ncpflash.cc
+++ b/test/material/ncpflash/test_ncpflash.cc
@@ -82,7 +82,7 @@ void checkSame(const FluidState &fsRef, const FluidState &fsFlash)
     }
 }
 
-template <class Scalar, class FluidSystem, class MaterialLaw, class MPAdapter, class FluidState>
+template <class Scalar, class FluidSystem, class MaterialLaw, class FluidState>
 void checkNcpFlash(const FluidState &fsRef,
                    typename MaterialLaw::Params &matParams)
 {
@@ -109,14 +109,14 @@ void checkNcpFlash(const FluidState &fsRef,
     // run the flash calculation
     typename FluidSystem::ParameterCache paramCache;
     NcpFlash::guessInitial(fsFlash, paramCache, globalMolarities);
-    NcpFlash::template solve<MPAdapter>(fsFlash, paramCache, matParams, globalMolarities);
+    NcpFlash::template solve<MaterialLaw>(fsFlash, paramCache, matParams, globalMolarities);
 
     // compare the "flashed" fluid state with the reference one
     checkSame<Scalar>(fsRef, fsFlash);
 }
 
 
-template <class Scalar, class FluidSystem, class MaterialLaw, class MPAdapter, class FluidState>
+template <class Scalar, class FluidSystem, class MaterialLaw, class FluidState>
 void completeReferenceFluidState(FluidState &fs,
                                  typename MaterialLaw::Params &matParams,
                                  int refPhaseIdx)
@@ -133,7 +133,7 @@ void completeReferenceFluidState(FluidState &fs,
 
     // calulate the capillary pressure
     PhaseVector pc;
-    MPAdapter::capillaryPressures(pc, matParams, fs, refPhaseIdx);
+    MaterialLaw::capillaryPressures(pc, matParams, fs);
     fs.setPressure(otherPhaseIdx,
                    fs.pressure(refPhaseIdx)
                    + (pc[otherPhaseIdx] - pc[refPhaseIdx]));
@@ -212,10 +212,10 @@ int main()
     fsRef.setWettingPhase(wPhaseIdx);
 
     // "complete" the fluid state
-    completeReferenceFluidState<Scalar, FluidSystem, MaterialLaw, MPAdapter>(fsRef, matParams, liquidPhaseIdx);
+    completeReferenceFluidState<Scalar, FluidSystem, MPAdapter>(fsRef, matParams, liquidPhaseIdx);
 
     // check the flash calculation
-    checkNcpFlash<Scalar, FluidSystem, MaterialLaw, MPAdapter>(fsRef, matParams);
+    checkNcpFlash<Scalar, FluidSystem, MPAdapter>(fsRef, matParams);
 
     ////////////////
     // only gas
@@ -232,10 +232,10 @@ int main()
     fsRef.setMoleFraction(gasPhaseIdx, H2OIdx, 0.001);
 
     // "complete" the fluid state
-    completeReferenceFluidState<Scalar, FluidSystem, MaterialLaw, MPAdapter>(fsRef, matParams, gasPhaseIdx);
+    completeReferenceFluidState<Scalar, FluidSystem, MPAdapter>(fsRef, matParams, gasPhaseIdx);
 
     // check the flash calculation
-    checkNcpFlash<Scalar, FluidSystem, MaterialLaw, MPAdapter>(fsRef, matParams);
+    checkNcpFlash<Scalar, FluidSystem, MPAdapter>(fsRef, matParams);
 
     ////////////////
     // both phases
@@ -255,7 +255,7 @@ int main()
     MiscibleMultiPhaseComposition::solve(fsRef, paramCache);
 
     // check the flash calculation
-    checkNcpFlash<Scalar, FluidSystem, MaterialLaw, MPAdapter>(fsRef, matParams);
+    checkNcpFlash<Scalar, FluidSystem, MPAdapter>(fsRef, matParams);
 
     ////////////////
     // with capillary pressure
@@ -277,7 +277,7 @@ int main()
     // calulate the capillary pressure
     using PhaseVector = Dune::FieldVector<Scalar, numPhases>;
     PhaseVector pc;
-    MPAdapter::capillaryPressures(pc, matParams2, fsRef, wPhaseIdx);
+    MPAdapter::capillaryPressures(pc, matParams2, fsRef);
     fsRef.setPressure(gasPhaseIdx,
                       fsRef.pressure(liquidPhaseIdx)
                       + (pc[gasPhaseIdx] - pc[liquidPhaseIdx]));
@@ -287,7 +287,7 @@ int main()
 
 
     // check the flash calculation
-    checkNcpFlash<Scalar, FluidSystem, MaterialLaw, MPAdapter>(fsRef, matParams2);
+    checkNcpFlash<Scalar, FluidSystem, MPAdapter>(fsRef, matParams2);
 
     return 0;
 }
diff --git a/test/porousmediumflow/mpnc/implicit/2p2ccomparison/problem.hh b/test/porousmediumflow/mpnc/implicit/2p2ccomparison/problem.hh
index ba230134a59593c10008d4a5b8d5b080e59c6de6..a405e000522074f298540e5733b502183dc92136 100644
--- a/test/porousmediumflow/mpnc/implicit/2p2ccomparison/problem.hh
+++ b/test/porousmediumflow/mpnc/implicit/2p2ccomparison/problem.hh
@@ -282,10 +282,9 @@ private:
         const auto& matParams =
             this->spatialParams().materialLawParamsAtPos(globalPos);
         PhaseVector pc;
-        const int wPhaseIdx = this->spatialParams().template wettingPhaseAtPos<FluidSystem>(globalPos);
         using MaterialLaw = typename ParentType::SpatialParams::MaterialLaw;
         using MPAdapter = MPAdapter<MaterialLaw, numPhases>;
-        MPAdapter::capillaryPressures(pc, matParams, fs, wPhaseIdx);
+        MPAdapter::capillaryPressures(pc, matParams, fs);
         fs.setPressure(liquidPhaseIdx,
                        fs.pressure(gasPhaseIdx) + pc[liquidPhaseIdx] - pc[gasPhaseIdx]);
 
diff --git a/test/porousmediumflow/mpnc/implicit/kinetic/problem.hh b/test/porousmediumflow/mpnc/implicit/kinetic/problem.hh
index a3797f7a1fea23085d5732fb1c87504785b185f6..56d577e9811a017b4bb9f2a0dc1b78c2ce312b0e 100644
--- a/test/porousmediumflow/mpnc/implicit/kinetic/problem.hh
+++ b/test/porousmediumflow/mpnc/implicit/kinetic/problem.hh
@@ -421,12 +421,10 @@ private:
         const auto &materialParams =
             this->spatialParams().materialLawParamsAtPos(globalPos);
         std::vector<Scalar> capPress(numPhases);
-        //get the index for the wettingphase
-        const int wPhaseIdx = this->spatialParams().template wettingPhaseAtPos<FluidSystem>(globalPos);
         //obtain pc according to saturation
         using MaterialLaw = typename ParentType::SpatialParams::MaterialLaw;
         using MPAdapter = MPAdapter<MaterialLaw, numPhases>;
-        MPAdapter::capillaryPressures(capPress, materialParams, equilibriumFluidState, wPhaseIdx);
+        MPAdapter::capillaryPressures(capPress, materialParams, equilibriumFluidState);
 
         Scalar p[numPhases];
         if (this->spatialParams().inPM_(globalPos)){
diff --git a/test/porousmediumflow/mpnc/implicit/obstacle/problem.hh b/test/porousmediumflow/mpnc/implicit/obstacle/problem.hh
index d078d08b3d444bbfc747943e4d15b850ff50a29c..57ae2e56cb60fd9f11e706ba0be4529b7448e81c 100644
--- a/test/porousmediumflow/mpnc/implicit/obstacle/problem.hh
+++ b/test/porousmediumflow/mpnc/implicit/obstacle/problem.hh
@@ -360,10 +360,9 @@ private:
         // calulate the capillary pressure
         const auto& matParams = this->spatialParams().materialLawParamsAtPos(globalPos);
         PhaseVector pc;
-        const int wPhaseIdx = this->spatialParams().template wettingPhaseAtPos<FluidSystem>(globalPos);
         using MaterialLaw = typename ParentType::SpatialParams::MaterialLaw;
         using MPAdapter = MPAdapter<MaterialLaw, numPhases>;
-        MPAdapter::capillaryPressures(pc, matParams, fs, wPhaseIdx);
+        MPAdapter::capillaryPressures(pc, matParams, fs);
         fs.setPressure(otherPhaseIdx,
                        fs.pressure(refPhaseIdx)
                        + (pc[otherPhaseIdx] - pc[refPhaseIdx]));
diff --git a/test/porousmediumflow/mpnc/implicit/thermalnonequilibrium/problem.hh b/test/porousmediumflow/mpnc/implicit/thermalnonequilibrium/problem.hh
index 5784778fdaf8042dd73005ceef2d5acbe6a3a023..876244001da5872c0c80a2b79951d3f60c368f4d 100644
--- a/test/porousmediumflow/mpnc/implicit/thermalnonequilibrium/problem.hh
+++ b/test/porousmediumflow/mpnc/implicit/thermalnonequilibrium/problem.hh
@@ -454,10 +454,9 @@ private:
         //obtain pc according to saturation
         const auto &materialParams =
         this->spatialParams().materialLawParamsAtPos(globalPos);
-        const int wPhaseIdx = this->spatialParams().template wettingPhaseAtPos<FluidSystem>(globalPos);
         using MaterialLaw = typename ParentType::SpatialParams::MaterialLaw;
         using MPAdapter = MPAdapter<MaterialLaw, numPhases>;
-        MPAdapter::capillaryPressures(capPress, materialParams, fluidState, wPhaseIdx);
+        MPAdapter::capillaryPressures(capPress, materialParams, fluidState);
 
         Scalar p[numPhases];