material: renaming according to refined naming rules, this time for

local variables.
Reviewed by Christoph.


git-svn-id: svn://svn.iws.uni-stuttgart.de/DUMUX/dumux/trunk@10774 2fb0f335-1f38-0410-981e-8018bf24f1b0

dumux/material/constraintsolvers/compositionalflash.hh

@@ -171,10 +171,10 @@ public:
         fluidState.setDensity(wPhaseIdx, FluidSystem::density(fluidState, wPhaseIdx));
         fluidState.setDensity(nPhaseIdx, FluidSystem::density(fluidState, nPhaseIdx));
 
-        Scalar Sw = fluidState.phaseMassFraction(wPhaseIdx) / fluidState.density(wPhaseIdx);
-        Sw /= (fluidState.phaseMassFraction(wPhaseIdx)/fluidState.density(wPhaseIdx)
+        Scalar sw = fluidState.phaseMassFraction(wPhaseIdx) / fluidState.density(wPhaseIdx);
+        sw /= (fluidState.phaseMassFraction(wPhaseIdx)/fluidState.density(wPhaseIdx)
                     + fluidState.phaseMassFraction(nPhaseIdx)/fluidState.density(nPhaseIdx));
-        fluidState.setSaturation(wPhaseIdx, Sw);
+        fluidState.setSaturation(wPhaseIdx, sw);
     };
 
     //! The simplest possible update routine for 1p2c "flash" calculations

dumux/material/constraintsolvers/immiscibleflash.hh

@@ -377,12 +377,12 @@ protected:
         // update the pressures using the material law (saturations
         // and first pressure are already set because it is implicitly
         // solved for.)
-        ComponentVector pC;
-        MaterialLaw::capillaryPressures(pC, matParams, fluidState);
+        ComponentVector pc;
+        MaterialLaw::capillaryPressures(pc, matParams, fluidState);
         for (int phaseIdx = 1; phaseIdx < numPhases; ++phaseIdx)
             fluidState.setPressure(phaseIdx,
                                    fluidState.pressure(0)
-                                   + (pC[phaseIdx] - pC[0]));
+                                   + (pc[phaseIdx] - pc[0]));
 
         // update the parameter cache
         paramCache.updateAll(fluidState, /*except=*/ParameterCache::Temperature|ParameterCache::Composition);
@@ -459,12 +459,12 @@ protected:
 
             // update all fluid pressures using the capillary pressure
             // law
-            ComponentVector pC;
-            MaterialLaw::capillaryPressures(pC, matParams, fs);
+            ComponentVector pc;
+            MaterialLaw::capillaryPressures(pc, matParams, fs);
             for (int phaseIdx = 1; phaseIdx < numPhases; ++phaseIdx)
                 fs.setPressure(phaseIdx,
                                fs.pressure(0)
-                               + (pC[phaseIdx] - pC[0]));
+                               + (pc[phaseIdx] - pc[0]));
             paramCache.updateAllPressures(fs);
 
             // update all densities

dumux/material/constraintsolvers/ncpflash.hh

@@ -472,12 +472,12 @@ protected:
         // update the pressures using the material law (saturations
         // and first pressure are already set because it is implicitly
         // solved for.)
-        ComponentVector pC;
-        MaterialLaw::capillaryPressures(pC, matParams, fluidState);
+        ComponentVector pc;
+        MaterialLaw::capillaryPressures(pc, matParams, fluidState);
         for (int phaseIdx = 1; phaseIdx < numPhases; ++phaseIdx)
             fluidState.setPressure(phaseIdx,
                                    fluidState.pressure(0)
-                                   + (pC[phaseIdx] - pC[0]));
+                                   + (pc[phaseIdx] - pc[0]));
 
         // update the parameter cache
         paramCache.updateAll(fluidState, /*except=*/ParameterCache::Temperature);
@@ -569,12 +569,12 @@ protected:
 
             // update all fluid pressures using the capillary pressure
             // law
-            ComponentVector pC;
-            MaterialLaw::capillaryPressures(pC, matParams, fs);
+            ComponentVector pc;
+            MaterialLaw::capillaryPressures(pc, matParams, fs);
             for (int phaseIdx = 1; phaseIdx < numPhases; ++phaseIdx)
                 fs.setPressure(phaseIdx,
                                fs.pressure(0)
-                               + (pC[phaseIdx] - pC[0]));
+                               + (pc[phaseIdx] - pc[0]));
             paramCache.updateAllPressures(fs);
 
             // update all densities and fugacity coefficients

dumux/material/fluidmatrixinteractions/2p/brookscorey.hh

@@ -61,23 +61,23 @@ public:
         p_C = p_e\overline{S}_w^{-1/\lambda}
     *  \f]
     *
-     * \param Swe       Effective saturation of the wetting phase \f$\overline{S}_w\f$
+     * \param swe       Effective saturation of the wetting phase \f$\overline{S}_w\f$
      * \param params    A container object that is populated with the appropriate coefficients for the respective law.
      *                  Therefore, in the (problem specific) spatialParameters  first, the material law is chosen, and then the params container
      *                  is constructed accordingly. Afterwards the values are set there, too.
      * \return          Capillary pressure calculated by Brooks & Corey constitutive relation.
      */
-    static Scalar pc(const Params &params, Scalar Swe)
+    static Scalar pc(const Params &params, Scalar swe)
     {
-        assert(0 <= Swe && Swe <= 1);
+        assert(0 <= swe && swe <= 1);
 
-        return params.pe()*pow(Swe, -1.0/params.lambda());
+        return params.pe()*pow(swe, -1.0/params.lambda());
     }
 
     DUNE_DEPRECATED_MSG("use pc() (uncapitalized 'c') instead")
-    static Scalar pC(const Params &params, Scalar Swe)
+    static Scalar pC(const Params &params, Scalar swe)
     {
-        return pc(params, Swe);
+        return pc(params, swe);
     }
 
     /*!
@@ -88,24 +88,24 @@ public:
      \overline{S}_w = (\frac{p_C}{p_e})^{-\lambda}
      \f]
      *
-     * \param pC        Capillary pressure \f$p_C\f$
+     * \param pc        Capillary pressure \f$p_C\f$
      * \param params    A container object that is populated with the appropriate coefficients for the respective law.
      *                  Therefore, in the (problem specific) spatialParameters  first, the material law is chosen, and then the params container
      *                  is constructed accordingly. Afterwards the values are set there, too.
      * \return          Effective wetting phase saturation calculated as inverse of BrooksCorey constitutive relation.
      */
-    static Scalar sw(const Params &params, Scalar pC)
+    static Scalar sw(const Params &params, Scalar pc)
     {
-        assert(pC >= 0);
+        assert(pc >= 0);
 
-        Scalar tmp = pow(pC/params.pe(), -params.lambda());
+        Scalar tmp = pow(pc/params.pe(), -params.lambda());
         return std::min(std::max(tmp, Scalar(0.0)), Scalar(1.0));
     }
 
     DUNE_DEPRECATED_MSG("use sw() (uncapitalized 's') instead")
-    static Scalar Sw(const Params &params, Scalar pC)
+    static Scalar Sw(const Params &params, Scalar pc)
     {
-        return sw(params, pC);
+        return sw(params, pc);
     }
 
     /*!
@@ -118,46 +118,46 @@ public:
      -\frac{p_e}{\lambda} \overline{S}_w^{-1/\lambda - 1}
      \f]
      *
-     * \param Swe       Effective saturation of the wetting phase \f$\overline{S}_w\f$
+     * \param swe       Effective saturation of the wetting phase \f$\overline{S}_w\f$
      * \param params    A container object that is populated with the appropriate coefficients for the respective law.
      *                  Therefore, in the (problem specific) spatialParameters  first, the material law is chosen, and then the params container
      *                  is constructed accordingly. Afterwards the values are set there, too.
      * \return          Partial derivative of \f$p_c\f$ w.r.t. effective saturation according to Brooks & Corey.
     */
-    static Scalar dpc_dsw(const Params &params, Scalar Swe)
+    static Scalar dpc_dsw(const Params &params, Scalar swe)
     {
-        assert(0 <= Swe && Swe <= 1);
+        assert(0 <= swe && swe <= 1);
 
-        return - params.pe()/params.lambda() * pow(Swe, -1/params.lambda() - 1);
+        return - params.pe()/params.lambda() * pow(swe, -1/params.lambda() - 1);
     }
 
     DUNE_DEPRECATED_MSG("use dpc_dsw() (uncapitalized 'c', 's') instead")
-    static Scalar dpC_dSw(const Params &params, Scalar Swe)
+    static Scalar dpC_dSw(const Params &params, Scalar swe)
     {
-        return dpc_dsw(params, Swe);
+        return dpc_dsw(params, swe);
     }
 
     /*!
      * \brief The partial derivative of the effective
      *        saturation w.r.t. the capillary pressure according to Brooks & Corey.
      *
-     * \param pC        Capillary pressure \f$p_C\f$
+     * \param pc        Capillary pressure \f$p_C\f$
      * \param params    A container object that is populated with the appropriate coefficients for the respective law.
      *                  Therefore, in the (problem specific) spatialParameters  first, the material law is chosen, and then the params container
      *                  is constructed accordingly. Afterwards the values are set there, too.
      * \return          Partial derivative of effective saturation w.r.t. \f$p_c\f$ according to Brooks & Corey.
      */
-    static Scalar dsw_dpc(const Params &params, Scalar pC)
+    static Scalar dsw_dpc(const Params &params, Scalar pc)
     {
-        assert(pC >= 0);
+        assert(pc >= 0);
 
-        return -params.lambda()/params.pe() * pow(pC/params.pe(), - params.lambda() - 1);
+        return -params.lambda()/params.pe() * pow(pc/params.pe(), - params.lambda() - 1);
     }
 
     DUNE_DEPRECATED_MSG("use dsw_dpc() (uncapitalized 's', 'c') instead")
-    static Scalar dSw_dpC(const Params &params, Scalar pC)
+    static Scalar dSw_dpC(const Params &params, Scalar pc)
     {
-        return dsw_dpc(params, pC);
+        return dsw_dpc(params, pc);
     }
 
     /*!
@@ -165,17 +165,17 @@ public:
      *        the medium implied by the Brooks-Corey
      *        parameterization.
      *
-     * \param Swe       The mobile saturation of the wetting phase.
+     * \param swe       The mobile saturation of the wetting phase.
      * \param params    A container object that is populated with the appropriate coefficients for the respective law.
      *                  Therefore, in the (problem specific) spatialParameters  first, the material law is chosen, and then the params container
      *                  is constructed accordingly. Afterwards the values are set there, too.
      * \return          Relative permeability of the wetting phase calculated as implied by Brooks & Corey.
      */
-    static Scalar krw(const Params &params, Scalar Swe)
+    static Scalar krw(const Params &params, Scalar swe)
     {
-        assert(0 <= Swe && Swe <= 1);
+        assert(0 <= swe && swe <= 1);
 
-        return pow(Swe, 2.0/params.lambda() + 3);
+        return pow(swe, 2.0/params.lambda() + 3);
     };
 
     /*!
@@ -183,23 +183,23 @@ public:
      *        wetting phase with regard to the wetting saturation of the
      *        medium implied by the Brooks-Corey parameterization.
      *
-     * \param Swe       The mobile saturation of the wetting phase.
+     * \param swe       The mobile saturation of the wetting phase.
      * \param params    A container object that is populated with the appropriate coefficients for the respective law.
      *                  Therefore, in the (problem specific) spatialParameters  first, the material law is chosen, and then the params container
      *                  is constructed accordingly. Afterwards the values are set there, too.
      * \return          Derivative of the relative permeability of the wetting phase w.r.t. effective wetting phase saturation calculated as implied by Brooks & Corey.
      */
-    static Scalar dkrw_dsw(const Params &params, Scalar Swe)
+    static Scalar dkrw_dsw(const Params &params, Scalar swe)
     {
-        assert(0 <= Swe && Swe <= 1);
+        assert(0 <= swe && swe <= 1);
 
-        return (2.0/params.lambda() + 3)*pow(Swe, 2.0/params.lambda() + 2);
+        return (2.0/params.lambda() + 3)*pow(swe, 2.0/params.lambda() + 2);
     };
 
     DUNE_DEPRECATED_MSG("use dkrw_dsw() (uncapitalized 's') instead")
-    static Scalar dkrw_dSw(const Params &params, Scalar Swe)
+    static Scalar dkrw_dSw(const Params &params, Scalar swe)
     {
-        return dkrw_dsw(params, Swe);
+        return dkrw_dsw(params, swe);
     }
 
     /*!
@@ -207,19 +207,19 @@ public:
      *        the medium as implied by the Brooks-Corey
      *        parameterization.
      *
-     * \param Swe       The mobile saturation of the wetting phase.
+     * \param swe       The mobile saturation of the wetting phase.
      * \param params    A container object that is populated with the appropriate coefficients for the respective law.
      *                  Therefore, in the (problem specific) spatialParameters  first, the material law is chosen, and then the params container
      *                  is constructed accordingly. Afterwards the values are set there, too.
      * \return          Relative permeability of the non-wetting phase calculated as implied by Brooks & Corey.
      */
-    static Scalar krn(const Params &params, Scalar Swe)
+    static Scalar krn(const Params &params, Scalar swe)
     {
-        assert(0 <= Swe && Swe <= 1);
+        assert(0 <= swe && swe <= 1);
 
         Scalar exponent = 2.0/params.lambda() + 1;
-        Scalar tmp = 1. - Swe;
-        return tmp*tmp*(1. - pow(Swe, exponent));
+        Scalar tmp = 1. - swe;
+        return tmp*tmp*(1. - pow(swe, exponent));
     }
 
     /*!
@@ -228,30 +228,30 @@ public:
      *        the medium as implied by the Brooks-Corey
      *        parameterization.
      *
-     * \param Swe       The mobile saturation of the wetting phase.
+     * \param swe       The mobile saturation of the wetting phase.
      * \param params    A container object that is populated with the appropriate coefficients for the respective law.
      *                  Therefore, in the (problem specific) spatialParameters  first, the material law is chosen, and then the params container
      *                  is constructed accordingly. Afterwards the values are set there, too.
      * \return          Derivative of the relative permeability of the non-wetting phase w.r.t. effective wetting phase saturation calculated as implied by Brooks & Corey.
      */
-    static Scalar dkrn_dsw(const Params &params, Scalar Swe)
+    static Scalar dkrn_dsw(const Params &params, Scalar swe)
     {
-        assert(0 <= Swe && Swe <= 1);
+        assert(0 <= swe && swe <= 1);
 
         return
-            2.0*(Swe - 1)*(
+            2.0*(swe - 1)*(
                 1 +
-                pow(Swe, 2.0/params.lambda())*(
+                pow(swe, 2.0/params.lambda())*(
                     1.0/params.lambda() + 1.0/2 -
-                    Swe*(1.0/params.lambda() + 1.0/2)
+                    swe*(1.0/params.lambda() + 1.0/2)
                     )
                 );
     }
 
     DUNE_DEPRECATED_MSG("use dkrn_dsw() (uncapitalized 's') instead")
-    static Scalar dkrn_dSw(const Params &params, Scalar Swe)
+    static Scalar dkrn_dSw(const Params &params, Scalar swe)
     {
-        return dkrn_dsw(params, Swe);
+        return dkrn_dsw(params, swe);
     }
 
 };

dumux/material/fluidmatrixinteractions/2p/efftoabslaw.hh

@@ -42,7 +42,7 @@ namespace Dumux
  *        The numeric calculations however are performed with absolute saturations. The EffToAbsLaw class gets
  *        the "material laws" actually used as well as the corresponding parameter container as template arguments.
  *
- *        Subsequently, the desired function (pc, Sw... ) of the actually used "material laws" are called but with the
+ *        Subsequently, the desired function (pc, sw... ) of the actually used "material laws" are called but with the
  *        saturations already converted from absolute to effective.
  *
  *        This approach makes sure that in the "material laws" only effective saturations are considered, which makes sense,
@@ -70,7 +70,7 @@ public:
      * \brief The capillary pressure-saturation curve.
      *
      *
-     * \param Sw        Absolute saturation of the wetting phase \f$\overline{S}_w\f$. It is converted to effective saturation
+     * \param sw        Absolute saturation of the wetting phase \f$\overline{S}_w\f$. It is converted to effective saturation
      *                  and then handed over to the material law actually used for calculation.
      * \param params    A container object that is populated with the appropriate coefficients for the respective law.
      *                  Therefore, in the (problem specific) spatialParameters  first, the material law is chosen, and then the params container
@@ -78,21 +78,21 @@ public:
      * \return          Capillary pressure calculated by specific constitutive relation (EffLaw e.g. Brooks & Corey, van Genuchten, linear...)
      *
      */
-    static Scalar pc(const Params &params, Scalar Sw)
+    static Scalar pc(const Params &params, Scalar sw)
     {
-        return EffLaw::pc(params, swToSwe(params, Sw));
+        return EffLaw::pc(params, swToSwe(params, sw));
     }
 
     DUNE_DEPRECATED_MSG("use pc() (uncapitalized 'c') instead")
-    static Scalar pC(const Params &params, Scalar Sw)
+    static Scalar pC(const Params &params, Scalar sw)
     {
-        return pc(params, Sw);
+        return pc(params, sw);
     }
 
     /*!
      * \brief The saturation-capillary pressure curve.
      *
-     * \param pC        Capillary pressure \f$p_C\f$:
+     * \param pc        Capillary pressure \f$p_C\f$:
      * \param params    A container object that is populated with the appropriate coefficients for the respective law.
      *                  Therefore, in the (problem specific) spatialParameters  first, the material law is chosen, and then the params container
      *                  is constructed accordingly. Afterwards the values are set there, too.
@@ -100,15 +100,15 @@ public:
      *
      * \return The absolute saturation of the wetting phase \f$S_w\f$
      */
-    static Scalar sw(const Params &params, Scalar pC)
+    static Scalar sw(const Params &params, Scalar pc)
     {
-        return sweToSw_(params, EffLaw::sw(params, pC));
+        return sweToSw_(params, EffLaw::sw(params, pc));
     }
 
     DUNE_DEPRECATED_MSG("use sw() (uncapitalized 's') instead")
-    static Scalar Sw(const Params &params, Scalar pC)
+    static Scalar Sw(const Params &params, Scalar pc)
     {
-        return sw(params, pC);
+        return sw(params, pc);
     }
 
     /*!
@@ -120,21 +120,21 @@ public:
              p_c = p_c( \overline S_w (S_w))
              \rightarrow p_c ^\prime = \frac{\partial  p_c}{\partial \overline S_w} \frac{\partial \overline S_w}{\partial S_w}
      \f]
-     * \param Sw        Absolute saturation of the wetting phase \f$\overline{S}_w\f$.
+     * \param sw        Absolute saturation of the wetting phase \f$\overline{S}_w\f$.
      * \param params    A container object that is populated with the appropriate coefficients for the respective law.
      *                  Therefore, in the (problem specific) spatialParameters  first, the material law is chosen, and then the params container
      *                  is constructed accordingly. Afterwards the values are set there, too.
      * \return          Partial derivative of \f$p_c\f$ w.r.t. effective saturation according to EffLaw e.g. Brooks & Corey, van Genuchten, linear... .
     */
-    static Scalar dpc_dsw(const Params &params, Scalar Sw)
+    static Scalar dpc_dsw(const Params &params, Scalar sw)
     {
-        return EffLaw::dpc_dsw(params, swToSwe(params, Sw) )*dswe_dsw_(params);
+        return EffLaw::dpc_dsw(params, swToSwe(params, sw) )*dswe_dsw_(params);
     }
 
     DUNE_DEPRECATED_MSG("use dpc_dsw() (uncapitalized 'c', 's') instead")
-    static Scalar dpC_dSw(const Params &params, Scalar Sw)
+    static Scalar dpC_dSw(const Params &params, Scalar sw)
     {
-        return dpc_dsw(params, Sw);
+        return dpc_dsw(params, sw);
     }
 
     /*!
@@ -148,27 +148,27 @@ public:
      \f]
      *
      *
-     * \param pC        Capillary pressure \f$p_C\f$:
+     * \param pc        Capillary pressure \f$p_C\f$:
      * \param params    A container object that is populated with the appropriate coefficients for the respective law.
      *                  Therefore, in the (problem specific) spatialParameters  first, the material law is chosen, and then the params container
      *                  is constructed accordingly. Afterwards the values are set there, too.
      * \return          Partial derivative of effective saturation w.r.t. \f$p_c\f$ according to EffLaw e.g. Brooks & Corey, van Genuchten, linear... .
      */
-    static Scalar dsw_dpc(const Params &params, Scalar pC)
+    static Scalar dsw_dpc(const Params &params, Scalar pc)
     {
-        return EffLaw::dsw_dpc(params, pC)*dsw_dswe_(params);
+        return EffLaw::dsw_dpc(params, pc)*dsw_dswe_(params);
     }
 
     DUNE_DEPRECATED_MSG("use dsw_dpc() (uncapitalized 's', 'c') instead")
-    static Scalar dSw_dpC(const Params &params, Scalar pC)
+    static Scalar dSw_dpC(const Params &params, Scalar pc)
     {
-        return dsw_dpc(params, pC);
+        return dsw_dpc(params, pc);
     }
 
     /*!
      * \brief The relative permeability for the wetting phase.
      *
-     * \param Sw        Absolute saturation of the wetting phase \f$\overline{S}_w\f$. It is converted to effective saturation
+     * \param sw        Absolute saturation of the wetting phase \f$\overline{S}_w\f$. It is converted to effective saturation
      *                  and then handed over to the material law actually used for calculation.
      * \param params    A container object that is populated with the appropriate coefficients for the respective law.
      *                  Therefore, in the (problem specific) spatialParameters  first, the material law is chosen, and then the params container
@@ -176,79 +176,79 @@ public:
      * \return          Relative permeability of the wetting phase calculated as implied by EffLaw e.g. Brooks & Corey, van Genuchten, linear... .
      *
      */
-    static Scalar krw(const Params &params, Scalar Sw)
+    static Scalar krw(const Params &params, Scalar sw)
     {
-        return EffLaw::krw(params, swToSwe(params, Sw));
+        return EffLaw::krw(params, swToSwe(params, sw));
     };
 
     /*!
      * \brief The relative permeability for the non-wetting phase.
      *
-     * \param Sw        Absolute saturation of the wetting phase \f${S}_w\f$. It is converted to effective saturation
+     * \param sw        Absolute saturation of the wetting phase \f${S}_w\f$. It is converted to effective saturation
      *                  and then handed over to the material law actually used for calculation.
      * \param params    A container object that is populated with the appropriate coefficients for the respective law.
      *                  Therefore, in the (problem specific) spatialParameters  first, the material law is chosen, and then the params container
      *                  is constructed accordingly. Afterwards the values are set there, too.
      * \return          Relative permeability of the non-wetting phase calculated as implied by EffLaw e.g. Brooks & Corey, van Genuchten, linear... .
      */
-    static Scalar krn(const Params &params, Scalar Sw)
+    static Scalar krn(const Params &params, Scalar sw)
     {
-        return EffLaw::krn(params, swToSwe(params, Sw));
+        return EffLaw::krn(params, swToSwe(params, sw));
     }
 
     /*!
      * \brief Convert an absolute wetting saturation to an effective one.
      *
-     * \param Sw        Absolute saturation of the wetting phase \f${S}_w\f$.
+     * \param sw        Absolute saturation of the wetting phase \f${S}_w\f$.
      * \param params    A container object that is populated with the appropriate coefficients for the respective law.
      *                  Therefore, in the (problem specific) spatialParameters  first, the material law is chosen, and then the params container
      *                  is constructed accordingly. Afterwards the values are set there, too.
      * \return          Effective saturation of the wetting phase.
      */
-    static Scalar swToSwe(const Params &params, Scalar Sw)
+    static Scalar swToSwe(const Params &params, Scalar sw)
     {
-        return (Sw - params.swr())/(1 - params.swr() - params.snr());
+        return (sw - params.swr())/(1 - params.swr() - params.snr());
     }
 
     DUNE_DEPRECATED_MSG("use swToSwe() (uncapitalized 's') instead")
-    static Scalar SwToSwe(const Params &params, Scalar Sw)
+    static Scalar SwToSwe(const Params &params, Scalar sw)
     {
-        return swToSwe(params, Sw);
+        return swToSwe(params, sw);
     }
 
     /*!
      * \brief Convert an absolute non-wetting saturation to an effective one.
      *
-     * \param Sn        Absolute saturation of the non-wetting phase \f${S}_n\f$.
+     * \param sn        Absolute saturation of the non-wetting phase \f${S}_n\f$.
      * \param params    A container object that is populated with the appropriate coefficients for the respective law.
      *                  Therefore, in the (problem specific) spatialParameters  first, the material law is chosen, and then the params container
      *                  is constructed accordingly. Afterwards the values are set there, too.
      * \return          Effective saturation of the non-wetting phase.
      */
-    static Scalar snToSne(const Params &params, Scalar Sn)
+    static Scalar snToSne(const Params &params, Scalar sn)
     {
-        return (Sn - params.snr())/(1 - params.swr() - params.snr());
+        return (sn - params.snr())/(1 - params.swr() - params.snr());
     }
 
     DUNE_DEPRECATED_MSG("use snToSne() (uncapitalized 's') instead")
-    static Scalar SnToSne(const Params &params, Scalar Sn)
+    static Scalar SnToSne(const Params &params, Scalar sn)
     {
-        return snToSne(params, Sn);
+        return snToSne(params, sn);
     }
 
 private:
     /*!
      * \brief Convert an effective wetting saturation to an absolute one.
      *
-     * \param Swe       Effective saturation of the non-wetting phase \f$\overline{S}_n\f$.
+     * \param swe       Effective saturation of the non-wetting phase \f$\overline{S}_n\f$.
      * \param params    A container object that is populated with the appropriate coefficients for the respective law.
      *                  Therefore, in the (problem specific) spatialParameters  first, the material law is chosen, and then the params container
      *                  is constructed accordingly. Afterwards the values are set there, too.
      * \return          Absolute saturation of the non-wetting phase.
      */
-    static Scalar sweToSw_(const Params &params, Scalar Swe)
+    static Scalar sweToSw_(const Params &params, Scalar swe)
     {
-        return Swe*(1 - params.swr() - params.snr()) + params.swr();
+        return swe*(1 - params.swr() - params.snr()) + params.swr();
     }
 
     /*!

dumux/material/fluidmatrixinteractions/2p/linearmaterial.hh

@@ -59,21 +59,21 @@ public:
      p_C = (1 - \overline{S}_w) (p_{C,max} - p_{C,entry}) + p_{C,entry}
      \f]
      *
-     * \param Swe       Effective saturation of the wetting phase \f$\overline{S}_w\f$ conversion from absolute saturation happened in EffToAbsLaw.
+     * \param swe       Effective saturation of the wetting phase \f$\overline{S}_w\f$ conversion from absolute saturation happened in EffToAbsLaw.
      * \param params    A container object that is populated with the appropriate coefficients for the respective law.
      *                  Therefore, in the (problem specific) spatialParameters  first, the material law is chosen, and then the params container
      *                  is constructed accordingly. Afterwards the values are set there, too.
      * \return          Capillary pressure calculated by linear constitutive relation.
      */
-    static Scalar pc(const Params &params, Scalar Swe)
+    static Scalar pc(const Params &params, Scalar swe)
     {
-        return (1 - Swe)*(params.maxPc() - params.entryPc()) + params.entryPc();
+        return (1 - swe)*(params.maxPc() - params.entryPc()) + params.entryPc();
     }
 
     DUNE_DEPRECATED_MSG("use pc() (uncapitalized 'c') instead")
-    static Scalar pC(const Params &params, Scalar Swe)
+    static Scalar pC(const Params &params, Scalar swe)
     {
-        return pc(params, Swe);
+        return pc(params, swe);
     }
 
     /*!
@@ -84,21 +84,21 @@ public:
          S_w = 1 - \frac{p_C - p_{C,entry}}{p_{C,max} - p_{C,entry}}
      \f]
      *
-     * \param pC        Capillary pressure \f$p_C\f$
+     * \param pc        Capillary pressure \f$p_C\f$
      * \param params    A container object that is populated with the appropriate coefficients for the respective law.
      *                  Therefore, in the (problem specific) spatialParameters  first, the material law is chosen, and then the params container
      *                  is constructed accordingly. Afterwards the values are set there, too.
      * \return          Effective wetting phase saturation calculated as inverse of the linear constitutive relation.
      */
-    static Scalar sw(const Params &params, Scalar pC)
+    static Scalar sw(const Params &params, Scalar pc)
     {
-        return 1 - (pC - params.entryPc())/(params.maxPc() - params.entryPc());
+        return 1 - (pc - params.entryPc())/(params.maxPc() - params.entryPc());
     }