[swe][frictionlaws] Add an abstract base class

To improve the weird inheritance from Nikuradse to Manning a abstract
base class FrictionLaw as base for all friction laws is introduced, by
making computeUstarH virtual.

dumux/material/fluidmatrixinteractions/frictionlaws/CMakeLists.txt

 install(FILES
 manning.hh
 nikuradse.hh
+frictionlaw.hh
 DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dumux/material/fluidmatrixinteractions/frictionslaws)

dumux/material/fluidmatrixinteractions/frictionlaws/frictionlaw.hh

+// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+// vi: set et ts=4 sw=4 sts=4:
+/*****************************************************************************
+ *   See the file COPYING for full copying permissions.                      *
+ *                                                                           *
+ *   This program is free software: you can redistribute it and/or modify    *
+ *   it under the terms of the GNU General Public License as published by    *
+ *   the Free Software Foundation, either version 3 of the License, or       *
+ *   (at your option) any later version.                                     *
+ *                                                                           *
+ *   This program is distributed in the hope that it will be useful,         *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the            *
+ *   GNU General Public License for more details.                            *
+ *                                                                           *
+ *   You should have received a copy of the GNU General Public License       *
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>.   *
+ *****************************************************************************/
+/*!
+ * \file
+ * \ingroup Fluidmatrixinteractions
+ * \copydoc Dumux::FrictionLaw
+ */
+#ifndef DUMUX_FRICTIONLAW_HH
+#define DUMUX_FRICTIONLAW_HH
+
+#include <algorithm>
+#include <cmath>
+
+namespace Dumux {
+/*!
+ * \ingroup Fluidmatrixinteractions
+ * \brief Implementation of the abstract base class for friction laws.
+ *
+ * The LET mobility model is used to limit the friction for small water depths.
+ */
+
+template <typename Scalar>
+class FrictionLaw
+{
+public:
+    /*!
+     * \brief Compute the friction ustar_h.
+     *
+     * \return ustar_h friction used for the source term in shallow water models.
+     */
+
+    virtual Scalar computeUstarH(const Scalar waterDepth) =0;
+
+    /*!
+     * \brief Limit the friction for small water depth.
+     *
+     * We define a water depth minUpperH. If the water depth is
+     * smaller, we start to limit the friciton.
+     * So the friciton term get's not extreme large for small water
+     * depths.
+     *
+     * ------------------------- minUpperh -----------
+     *
+     *
+     *
+     * ------------------------rough_h ---------------
+     *    /\  /\   roughness                  /grain\
+     * -------------------------------bottom ------------------
+     * /////////////////////////////////////////////////
+     *
+     * For the limiting the LET model is used, which is usually applied in the
+     * porous media flow to limit the permeability due to the saturation. It employs
+     * the three empirical paramaters L, E and T, which describe the limiting curve.
+     *
+     * \param rough_h roughness height of the representive structure (e.g. largest grain size).
+     * \param waterDepth water depth.
+     */
+    Scalar limitRoughH(Scalar rough_h, const Scalar waterDepth)
+    {
+        using std::pow;
+        using std::min;
+        using std::max;
+
+        const Scalar letL = 0.0; //!< empirical parameter of the LET model
+        const Scalar letT = 2.0; //!< empirical parameter of the LET model
+        const Scalar letE = 1.0; //!< empirical parameter of the LET model
+        Scalar mobility_max = 1.0; //!< maximal mobility
+
+        auto minUpperH = rough_h * 2.0;
+        auto sw = min(waterDepth * (1.0/minUpperH),1.0);
+        sw = max(0.0,sw);
+        auto mobility = (mobility_max * pow(sw,letL))/(pow(sw,letL) + letE * pow(1.0-sw,letT));
+        return rough_h * (1.0 - mobility);
+    }
+};
+
+} // end namespace Dumux
+
+#endif // DUMUX_FRICTIONLAW_HH

dumux/material/fluidmatrixinteractions/frictionlaws/manning.hh

@@ -19,16 +19,14 @@
 /*!
  * \file
  * \ingroup Fluidmatrixinteractions
- * \brief Implementation of the friction law after Manning.
- *
- * The LET mobility model is used to limit the friction for small water depths.
+ * \copydoc Dumux::FrictionLawManning
  */
 #ifndef DUMUX_FRICTIONLAW_MANNING_HH
 #define DUMUX_FRICTIONLAW_MANNING_HH
 
 #include <algorithm>
 #include <cmath>
-#include "nikuradse.hh"
+#include "frictionlaw.hh"
 
 namespace Dumux {
 /*!
@@ -39,29 +37,34 @@ namespace Dumux {
  */
 
 template <typename Scalar>
-class FrictionLawManning : FrictionLawNikuradse<Scalar>
+class FrictionLawManning : FrictionLaw<Scalar>
 {
 public:
+    FrictionLawManning(const Scalar manningN, const Scalar gravity)
+        : manningN_(manningN), gravity_(gravity) {}
     /*!
      * \brief Compute the friction ustar_h.
      *
      * \param waterDepth water depth.
-     * \param manningN Mannings friction value.
+     *
      * \return ustar_h friction used for the source term in shallow water models.
      */
-    Scalar computeUstarH(const Scalar waterDepth, const Scalar manningN, const Scalar gravity)
+    Scalar computeUstarH(const Scalar waterDepth)
     {
         using std::pow;
 
         Scalar ustar_h = 0.0;
-        Scalar rough_h = pow(25.68/(1.0/manningN),6.0);
+        Scalar rough_h = pow(25.68/(1.0/manningN_),6.0);
 
         rough_h = this->limitRoughH(rough_h, waterDepth);
 
-        auto cfric = pow((waterDepth + rough_h),1.0/6.0) * 1.0/(manningN);
-        ustar_h = gravity / pow(cfric,2.0);
+        auto cfric = pow((waterDepth + rough_h),1.0/6.0) * 1.0/(manningN_);
+        ustar_h = gravity_ / pow(cfric,2.0);
         return ustar_h;
     }
+private:
+    Scalar manningN_;
+    Scalar gravity_;
 };
 
 } // end namespace Dumux

dumux/material/fluidmatrixinteractions/frictionlaws/nikuradse.hh

@@ -19,15 +19,14 @@
 /*!
  * \file
  * \ingroup Fluidmatrixinteractions
- * \brief Implementation of the friction law after Nikuradse.
- *
- * The LET mobility model is used to limit the friction for small water depths.
+ * \copydoc Dumux::FrictionLawNikuradse
  */
 #ifndef DUMUX_FRICTIONLAW_NIKURADSE_HH
 #define DUMUX_FRICTIONLAW_NIKURADSE_HH
 
 #include <algorithm>
 #include <cmath>
+#include "frictionlaw.hh"
 
 namespace Dumux {
 /*!
@@ -38,71 +37,33 @@ namespace Dumux {
  */
 
 template <typename Scalar>
-class FrictionLawNikuradse
+class FrictionLawNikuradse : FrictionLaw<Scalar>
 {
 public:
+    FrictionLawNikuradse(const Scalar ks)
+        : ks_(ks) {}
     /*!
      * \brief Compute the friction ustar_h.
      *
      * \param waterDepth water depth.
-     * \param ks the Strickler friction value.
+     *
      * \return ustar_h friction used for the source term in shallow water models.
      */
 
-    Scalar computeUstarH(const Scalar waterDepth,const Scalar ks)
+    Scalar computeUstarH(const Scalar waterDepth)
     {
         using std::pow;
         using std::log;
 
         Scalar ustar_h = 0.0;
-        Scalar rough_h = ks;
+        Scalar rough_h = ks_;
 
-        rough_h = limitRoughH(rough_h, waterDepth);
-        ustar_h = pow(0.41,2.0)/pow(log((12*(waterDepth + rough_h))/ks),2.0);
+        rough_h = this->limitRoughH(rough_h, waterDepth);
+        ustar_h = pow(0.41,2.0)/pow(log((12*(waterDepth + rough_h))/ks_),2.0);
         return ustar_h;
     }
-
-    /*!
-     * \brief Limit the friction for small water depth.
-     *
-     * We define a water depth minUpperH. If the water depth is
-     * smaller, we start to limit the friciton.
-     * So the friciton term get's not extreme large for small water
-     * depths.
-     *
-     * ------------------------- minUpperh -----------
-     *
-     *
-     *
-     * ------------------------rough_h ---------------
-     *    /\  /\   roughness                  /grain\
-     * -------------------------------bottom ------------------
-     * /////////////////////////////////////////////////
-     *
-     * For the limiting the LET model is used, which is usually applied in the
-     * porous media flow to limit the permeability due to the saturation. It employs
-     * the three empirical paramaters L, E and T, which describe the limiting curve.
-     *
-     * \param rough_h roughness height of the representive structure (e.g. largest grain size).
-     * \param waterDepth water depth.
-     */
-    Scalar limitRoughH(Scalar rough_h, const Scalar waterDepth)
-    {
-        using std::pow;
-        using std::min;
-        using std::max;
-
-        const Scalar letL = 0.0; //!< empirical parameter of the LET model
-        const Scalar letT = 2.0; //!< empirical parameter of the LET model
-        const Scalar letE = 1.0; //!< empirical parameter of the LET model
-        Scalar mobility_max = 1.0; //!< maximal mobility
-
-        auto minUpperH = rough_h * 2.0;
-        auto sw = min(waterDepth * (1.0/minUpperH),1.0);
-        sw = max(0.0,sw);
-        auto mobility = (mobility_max * pow(sw,letL))/(pow(sw,letL) + letE * pow(1.0-sw,letT));
-        return rough_h * (1.0 - mobility);
-    }
+private:
+    Scalar ks_;
 };
 
 } // end namespace Dumux

test/freeflow/shallowwater/roughchannel/problem.hh

@@ -33,7 +33,6 @@
 #include <dumux/freeflow/shallowwater/boundaryfluxes.hh>
 #include <dumux/material/fluidmatrixinteractions/frictionlaws/manning.hh>
 
-
 namespace Dumux {
 
 template <class TypeTag>
@@ -228,14 +227,13 @@ public:
 
         const auto& globalPos = scv.center();
         const auto& volVars = elemVolVars[scv];
-        const auto& elementIndex = scv.elementIndex();
 
         const auto gravity = this->spatialParams().gravity(globalPos);
         const auto manningN = this->spatialParams().frictionValue(globalPos);
         auto h = volVars.waterDepth();
         auto u = volVars.velocity(0);
         auto v = volVars.velocity(1);
-        auto ustarH = FrictionLawManning<Scalar>().computeUstarH(h,manningN,gravity);
+        auto ustarH = FrictionLawManning<Scalar>(manningN,gravity).computeUstarH(h);
         auto uv = sqrt(pow(u,2.0) + pow(v,2.0));
 
         source[0] = 0.0;