1/eta -> V0

dune/tectonic/globalruinanonlinearity.hh

@@ -24,7 +24,7 @@ class GlobalRuinaNonlinearity
   using GlobalNonlinearity<MatrixType, VectorType>::dim;
 
   GlobalRuinaNonlinearity(dataref nodalIntegrals, dataref a, dataref mu,
-                          dataref eta, dataref normalStress, dataref b,
+                          dataref V0, dataref normalStress, dataref b,
                           dataref state, dataref L)
       : restrictions(nodalIntegrals.size()) {
     auto trivialNonlinearity = make_shared<LocalNonlinearity<dim> const>(
@@ -34,7 +34,7 @@ class GlobalRuinaNonlinearity
                             ? trivialNonlinearity
                             : make_shared<LocalNonlinearity<dim> const>(
                                   make_shared<RuinaFunction const>(
-                                      nodalIntegrals[i], a[i], mu[i], eta[i],
+                                      nodalIntegrals[i], a[i], mu[i], V0[i],
                                       normalStress[i], b[i], state[i], L[i]));
     }
   }

dune/tectonic/nicefunction.hh

@@ -40,18 +40,18 @@ class NiceFunction {
 
 class RuinaFunction : public NiceFunction {
 public:
-  RuinaFunction(double coefficient, double a, double mu, double eta,
+  RuinaFunction(double coefficient, double a, double mu, double V0,
                 double normalStress, double b, double state, double L)
       : NiceFunction(),
         a(a),
-        eta(eta),
+        V0(V0),
         coefficientProduct(coefficient * normalStress),
-        K(mu + b * (state - std::log(eta * L))), // state is assumed to be
-                                                 // logarithmic
+        K(mu +
+          b * (state + std::log(V0 / L))), // state is assumed to be logarithmic
         rho(std::exp(-K / a)) {}
 
   double virtual evaluate(double x) const {
-    double const arg = x * eta;
+    double const arg = x / V0;
     if (arg <= rho)
       return 0;
 
@@ -60,7 +60,7 @@ class RuinaFunction : public NiceFunction {
   }
 
   double virtual leftDifferential(double x) const {
-    double const arg = x * eta;
+    double const arg = x / V0;
     if (arg <= rho)
       return 0;
 
@@ -73,7 +73,7 @@ class RuinaFunction : public NiceFunction {
   }
 
   double virtual second_deriv(double x) const {
-    double const arg = x * eta;
+    double const arg = x / V0;
     if (arg <= rho)
       return 0;
 
@@ -81,7 +81,7 @@ class RuinaFunction : public NiceFunction {
   }
 
   double virtual regularity(double x) const {
-    double const arg = x * eta;
+    double const arg = x / V0;
     // TODO: Make this controllable
     if (std::abs(arg - rho) < 1e-14)
       return std::numeric_limits<double>::infinity();
@@ -93,7 +93,7 @@ class RuinaFunction : public NiceFunction {
 
 private:
   double const a;
-  double const eta;
+  double const V0;
   double const coefficientProduct;
   double const K;
   double const rho;

src/assemblers.cc

@@ -74,8 +74,8 @@ assemble_nonlinearity(
       SingletonVectorType a(size);
       a = parset.get<double>("ruina.a");
 
-      SingletonVectorType eta(size);
-      eta = parset.get<double>("eta");
+      SingletonVectorType V0(size);
+      V0 = parset.get<double>("V0");
 
       SingletonVectorType b(size);
       b = parset.get<double>("ruina.b");
@@ -85,7 +85,7 @@ assemble_nonlinearity(
 
       return Dune::make_shared<
           Dune::GlobalRuinaNonlinearity<MatrixType, VectorType> const>(
-          nodalIntegrals, a, mu, eta, normalStress, b, state, L);
+          nodalIntegrals, a, mu, V0, normalStress, b, state, L);
     }
     case Config::Laursen:
       assert(false);

src/one-body-sample.cc

@@ -277,7 +277,7 @@ int main(int argc, char *argv[]) {
     auto const L = parset.get<double>("boundary.friction.ruina.L");
     auto const a = parset.get<double>("boundary.friction.ruina.a");
     auto const b = parset.get<double>("boundary.friction.ruina.b");
-    auto const eta = parset.get<double>("boundary.friction.eta");
+    auto const V0 = parset.get<double>("boundary.friction.V0");
     auto const mu = parset.get<double>("boundary.friction.mu");
     auto const timesteps = parset.get<size_t>("timeSteps");
     double const tau = 1.0 / timesteps;
@@ -450,8 +450,8 @@ int main(int argc, char *argv[]) {
 
         for (size_t i = 0; i < frictionalNodes.size(); ++i)
           if (frictionalNodes[i][0])
-            coefficient_writer << mu + a *std::log(ud[i].two_norm() * eta) +
-                                      b * (alpha[i] - std::log(eta * L)) << " ";
+            coefficient_writer << mu + a *std::log(ud[i].two_norm() / V0) +
+                                      b * (alpha[i] + std::log(V0 / L)) << " ";
         coefficient_writer << std::endl;
       }
 

src/one-body-sample.parset

@@ -52,7 +52,7 @@ requiredResidual = 1e-12
 #    constitutive properties for earthquake prediction
 #    http://earthquake.usgs.gov/research/physics/lab/prediction.pdf
 mu = 0.6
-eta = 1
+V0 = 1
 model = Exponential
 
 [boundary.friction.state]