[Cleanup] Rename: Dieterich/Ruina -> {A./S.}Law

src/enum_state_model.cc

@@ -4,11 +4,11 @@
 
 template <> struct StringToEnum<Config::stateModel> {
   static Config::stateModel convert(std::string const &s) {
-    if (s == "Dieterich")
-      return Config::Dieterich;
+    if (s == "AgeingLaw")
+      return Config::AgeingLaw;
 
-    if (s == "Ruina")
-      return Config::Ruina;
+    if (s == "SlipLaw")
+      return Config::SlipLaw;
 
     DUNE_THROW(Dune::Exception, "failed to parse enum");
   }

src/enums.hh

@@ -3,8 +3,8 @@
 
 struct Config {
   enum stateModel {
-    Dieterich,
-    Ruina
+    AgeingLaw,
+    SlipLaw
   };
   enum scheme {
     Newmark,

src/sand-wedge-data/parset.cfg

@@ -26,7 +26,7 @@ mu0             = 0.7   # [1]
 V0              = 5e-5  # [m/s]
 L               = 2e-5  # [m]      ?
 initialAlpha    = 0.916290731874155 # [ ]      ?
-stateModel      = Dieterich
+stateModel      = AgeingLaw
 [boundary.friction.weakening]
 a               = 0.015 # [1]      ?
 b               = 0.030 # [1]      ?

src/state.hh

@@ -5,19 +5,19 @@
 
 #include "enums.hh"
 #include "state/stateupdater.hh"
-#include "state/ruinastateupdater.hh"
-#include "state/dieterichstateupdater.hh"
+#include "state/ageinglawstateupdater.hh"
+#include "state/sliplawstateupdater.hh"
 
 template <class ScalarVector, class Vector>
 std::shared_ptr<StateUpdater<ScalarVector, Vector>> initStateUpdater(
     Config::stateModel model, ScalarVector const &alpha_initial,
     Dune::BitSetVector<1> const &frictionalNodes, double L, double V0) {
   switch (model) {
-    case Config::Dieterich:
-      return std::make_shared<DieterichStateUpdater<ScalarVector, Vector>>(
+    case Config::AgeingLaw:
+      return std::make_shared<AgeingLawStateUpdater<ScalarVector, Vector>>(
           alpha_initial, frictionalNodes, L, V0);
-    case Config::Ruina:
-      return std::make_shared<RuinaStateUpdater<ScalarVector, Vector>>(
+    case Config::SlipLaw:
+      return std::make_shared<SlipLawStateUpdater<ScalarVector, Vector>>(
           alpha_initial, frictionalNodes, L, V0);
     default:
       assert(false);

src/state/dieterichstateupdater.hh → src/state/ageinglawstateupdater.hh

-#ifndef DIETERICH_STATE_UPDATER_HH
-#define DIETERICH_STATE_UPDATER_HH
+#ifndef SRC_STATE_AGEINGLAWSTATEUPDATER_HH
+#define SRC_STATE_AGEINGLAWSTATEUPDATER_HH
 
 #include "tobool.hh"
 #include "stateupdater.hh"
 
 template <class ScalarVector, class Vector>
-class DieterichStateUpdater : public StateUpdater<ScalarVector, Vector> {
+class AgeingLawStateUpdater : public StateUpdater<ScalarVector, Vector> {
 public:
-  DieterichStateUpdater(ScalarVector _alpha_initial,
+  AgeingLawStateUpdater(ScalarVector _alpha_initial,
                         Dune::BitSetVector<1> const &_nodes, double _L,
                         double _V0);
 
@@ -26,18 +26,18 @@ class DieterichStateUpdater : public StateUpdater<ScalarVector, Vector> {
 };
 
 template <class ScalarVector, class Vector>
-DieterichStateUpdater<ScalarVector, Vector>::DieterichStateUpdater(
+AgeingLawStateUpdater<ScalarVector, Vector>::AgeingLawStateUpdater(
     ScalarVector _alpha_initial, Dune::BitSetVector<1> const &_nodes, double _L,
     double _V0)
     : alpha(_alpha_initial), nodes(_nodes), L(_L), V0(_V0) {}
 
 template <class ScalarVector, class Vector>
-void DieterichStateUpdater<ScalarVector, Vector>::nextTimeStep() {
+void AgeingLawStateUpdater<ScalarVector, Vector>::nextTimeStep() {
   alpha_o = alpha;
 }
 
 template <class ScalarVector, class Vector>
-void DieterichStateUpdater<ScalarVector, Vector>::setup(double _tau) {
+void AgeingLawStateUpdater<ScalarVector, Vector>::setup(double _tau) {
   tau = _tau;
 }
 
@@ -53,7 +53,7 @@ double liftSingularity(double c, double x) {
 }
 
 template <class ScalarVector, class Vector>
-void DieterichStateUpdater<ScalarVector, Vector>::solve(
+void AgeingLawStateUpdater<ScalarVector, Vector>::solve(
     Vector const &velocity_field) {
   for (size_t i = 0; i < nodes.size(); ++i) {
     if (not toBool(nodes[i]))
@@ -67,9 +67,8 @@ void DieterichStateUpdater<ScalarVector, Vector>::solve(
 }
 
 template <class ScalarVector, class Vector>
-void DieterichStateUpdater<ScalarVector, Vector>::extractAlpha(
+void AgeingLawStateUpdater<ScalarVector, Vector>::extractAlpha(
     ScalarVector &_alpha) {
   _alpha = alpha;
 }
-
 #endif

src/state/ruinastateupdater.hh → src/state/sliplawstateupdater.hh

-#ifndef RUINA_STATE_UPDATER_HH
-#define RUINA_STATE_UPDATER_HH
+#ifndef SRC_STATE_SLIPLAWSTATEUPDATER_HH
+#define SRC_STATE_SLIPLAWSTATEUPDATER_HH
 
 #include "tobool.hh"
 #include "stateupdater.hh"
 
 template <class ScalarVector, class Vector>
-class RuinaStateUpdater : public StateUpdater<ScalarVector, Vector> {
+class SlipLawStateUpdater : public StateUpdater<ScalarVector, Vector> {
 public:
-  RuinaStateUpdater(ScalarVector _alpha_initial,
-                    Dune::BitSetVector<1> const &_nodes, double _L, double _V0);
+  SlipLawStateUpdater(ScalarVector _alpha_initial,
+                      Dune::BitSetVector<1> const &_nodes, double _L,
+                      double _V0);
 
   void virtual nextTimeStep();
   void virtual setup(double _tau);
@@ -25,23 +26,23 @@ class RuinaStateUpdater : public StateUpdater<ScalarVector, Vector> {
 };
 
 template <class ScalarVector, class Vector>
-RuinaStateUpdater<ScalarVector, Vector>::RuinaStateUpdater(
+SlipLawStateUpdater<ScalarVector, Vector>::SlipLawStateUpdater(
     ScalarVector _alpha_initial, Dune::BitSetVector<1> const &_nodes, double _L,
     double _V0)
     : alpha(_alpha_initial), nodes(_nodes), L(_L), V0(_V0) {}
 
 template <class ScalarVector, class Vector>
-void RuinaStateUpdater<ScalarVector, Vector>::nextTimeStep() {
+void SlipLawStateUpdater<ScalarVector, Vector>::nextTimeStep() {
   alpha_o = alpha;
 }
 
 template <class ScalarVector, class Vector>
-void RuinaStateUpdater<ScalarVector, Vector>::setup(double _tau) {
+void SlipLawStateUpdater<ScalarVector, Vector>::setup(double _tau) {
   tau = _tau;
 }
 
 template <class ScalarVector, class Vector>
-void RuinaStateUpdater<ScalarVector, Vector>::solve(
+void SlipLawStateUpdater<ScalarVector, Vector>::solve(
     Vector const &velocity_field) {
   for (size_t i = 0; i < nodes.size(); ++i) {
     if (not toBool(nodes[i]))
@@ -55,7 +56,7 @@ void RuinaStateUpdater<ScalarVector, Vector>::solve(
 }
 
 template <class ScalarVector, class Vector>
-void RuinaStateUpdater<ScalarVector, Vector>::extractAlpha(
+void SlipLawStateUpdater<ScalarVector, Vector>::extractAlpha(
     ScalarVector &_alpha) {
   _alpha = alpha;
 }