[Cleanup] Make time relative

src/assemblers.cc

@@ -16,11 +16,11 @@ void assemble_neumann(GridView const &gridView, AssemblerType const &assembler,
                       Dune::BitSetVector<1> const &neumannNodes,
                       Dune::BlockVector<LocalVectorType> &f,
                       Dune::VirtualFunction<double, double> const &neumann,
-                      double time) { // constant sample function on neumann
-                                     // boundary
+                      double relativeTime) { // constant sample function on
+                                             // neumann boundary
   BoundaryPatch<GridView> const neumannBoundary(gridView, neumannNodes);
   LocalVectorType SampleVector(0);
-  neumann.evaluate(time, SampleVector[0]);
+  neumann.evaluate(relativeTime, SampleVector[0]);
   ConstantFunction<LocalVectorType, LocalVectorType> const fNeumann(
       SampleVector);
   NeumannBoundaryAssembler<typename GridView::Grid, LocalVectorType>

src/assemblers.hh

@@ -16,7 +16,7 @@ void assemble_neumann(GridView const &gridView, AssemblerType const &assembler,
                       Dune::BitSetVector<1> const &neumannNodes,
                       Dune::BlockVector<LocalVectorType> &f,
                       Dune::VirtualFunction<double, double> const &neumann,
-                      double time);
+                      double relativeTime);
 
 template <class GridView, class LocalVectorType, class AssemblerType>
 Dune::shared_ptr<Dune::BlockVector<Dune::FieldVector<double, 1>>>

src/assemblers_tmpl.cc

@@ -27,7 +27,7 @@ template void assemble_neumann<GridView, SmallVector, AssemblerType>(
     GridView const &gridView, AssemblerType const &assembler,
     Dune::BitSetVector<1> const &neumannNodes,
     Dune::BlockVector<SmallVector> &f,
-    Dune::VirtualFunction<double, double> const &neumann, double time);
+    Dune::VirtualFunction<double, double> const &neumann, double relativeTime);
 
 template Dune::shared_ptr<Dune::BlockVector<Dune::FieldVector<double, 1>>>
 assemble_frictional<GridView, SmallVector, AssemblerType>(

src/one-body-sample.cc

@@ -339,9 +339,9 @@ int main(int argc, char *argv[]) {
         frictionalNodes, *nodalIntegrals, frictionData);
 
     // Problem formulation: right-hand side
-    auto const createRHS = [&](double _time, VectorType &_ell) {
+    auto const createRHS = [&](double _relativeTime, VectorType &_ell) {
       assemble_neumann(leafView, p1Assembler, neumannNodes, _ell,
-                       neumannFunction, _time);
+                       neumannFunction, _relativeTime);
       _ell += gravityFunctional;
     };
     VectorType ell(finestSize);
@@ -491,16 +491,16 @@ int main(int argc, char *argv[]) {
       stateUpdater->nextTimeStep();
       timeSteppingScheme->nextTimeStep();
 
-      double const time = tau * run;
-      createRHS(time, ell);
+      auto const relativeTime = double(run) / double(timesteps);
+      createRHS(relativeTime, ell);
 
       MatrixType velocityMatrix;
       VectorType velocityRHS(finestSize);
       VectorType velocityIterate(finestSize);
 
       stateUpdater->setup(tau);
-      timeSteppingScheme->setup(ell, tau, time, velocityRHS, velocityIterate,
-                                velocityMatrix);
+      timeSteppingScheme->setup(ell, tau, relativeTime, velocityRHS,
+                                velocityIterate, velocityMatrix);
 
       LoopSolver<VectorType> velocityProblemSolver(
           multigridStep, maximumIterations, tolerance, &AMNorm, verbosity,

src/one-body-sample.py

 class neumannCondition:
-    def __call__(self, x):
+    def __call__(self, relativeTime):
         return 0
 
 class velocityDirichletCondition:
-    def __call__(self, x):
+    def __call__(self, relativeTime):
         return 2e-4
 
 Functions = {

src/timestepping.hh

@@ -7,7 +7,7 @@ template <class VectorType, class MatrixType, class FunctionType, size_t dim>
 class TimeSteppingScheme {
 public:
   void virtual nextTimeStep() = 0;
-  void virtual setup(VectorType const &ell, double _tau, double time,
+  void virtual setup(VectorType const &ell, double _tau, double relativeTime,
                      VectorType &rhs, VectorType &iterate, MatrixType &AB) = 0;
 
   void virtual postProcess(VectorType const &iterate) = 0;

src/timestepping/backward_euler.cc

@@ -21,7 +21,7 @@ void BackwardEuler<VectorType, MatrixType, FunctionType, dim>::nextTimeStep() {
 
 template <class VectorType, class MatrixType, class FunctionType, size_t dim>
 void BackwardEuler<VectorType, MatrixType, FunctionType, dim>::setup(
-    VectorType const &ell, double _tau, double time, VectorType &rhs,
+    VectorType const &ell, double _tau, double relativeTime, VectorType &rhs,
     VectorType &iterate, MatrixType &AM) {
   postProcessCalled = false;
 
@@ -77,11 +77,11 @@ void BackwardEuler<VectorType, MatrixType, FunctionType, dim>::setup(
         continue;
       case dim:
         iterate[i] = 0;
-        dirichletFunction.evaluate(time, iterate[i][0]);
+        dirichletFunction.evaluate(relativeTime, iterate[i][0]);
         break;
       case 1:
         if (dirichletNodes[i][0]) {
-          dirichletFunction.evaluate(time, iterate[i][0]);
+          dirichletFunction.evaluate(relativeTime, iterate[i][0]);
           break;
         }
         if (dirichletNodes[i][1]) {

src/timestepping/newmark.cc

@@ -24,7 +24,7 @@ void Newmark<VectorType, MatrixType, FunctionType, dim>::nextTimeStep() {
 
 template <class VectorType, class MatrixType, class FunctionType, size_t dim>
 void Newmark<VectorType, MatrixType, FunctionType, dim>::setup(
-    VectorType const &ell, double _tau, double time, VectorType &rhs,
+    VectorType const &ell, double _tau, double relativeTime, VectorType &rhs,
     VectorType &iterate, MatrixType &AM) {
   postProcessCalled = false;
 
@@ -83,11 +83,11 @@ void Newmark<VectorType, MatrixType, FunctionType, dim>::setup(
         continue;
       case dim:
         iterate[i] = 0;
-        dirichletFunction.evaluate(time, iterate[i][0]);
+        dirichletFunction.evaluate(relativeTime, iterate[i][0]);
         break;
       case 1:
         if (dirichletNodes[i][0]) {
-          dirichletFunction.evaluate(time, iterate[i][0]);
+          dirichletFunction.evaluate(relativeTime, iterate[i][0]);
           break;
         }
         if (dirichletNodes[i][1]) {