[Cleanup] Compile adaptive time stepper separately

src/CMakeLists.txt

 set(SOURCE_FILES
+  adaptivetimestepper.cc
   assemblers.cc
   boundary_writer.cc
   coupledtimestepper.cc

src/adaptivetimestepper.cc

+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "adaptivetimestepper.hh"
+
+template <class Factory, class Updaters, class ErrorNorm>
+AdaptiveTimeStepper<Factory, Updaters, ErrorNorm>::AdaptiveTimeStepper(
+    Factory &factory, Dune::ParameterTree const &parset,
+    std::shared_ptr<Nonlinearity> globalFriction, Updaters &current,
+    double relativeTime, double relativeTau,
+    std::function<void(double, Vector &)> externalForces,
+    ErrorNorm const &errorNorm,
+    std::function<bool(Updaters &, Updaters &)> mustRefine)
+    : relativeTime_(relativeTime),
+      relativeTau_(relativeTau),
+      finalTime_(parset.get<double>("problem.finalTime")),
+      factory_(factory),
+      parset_(parset),
+      globalFriction_(globalFriction),
+      current_(current),
+      R1_(current_.clone()),
+      externalForces_(externalForces),
+      mustRefine_(mustRefine),
+      iterationWriter_("iterations", std::fstream::out),
+      errorNorm_(errorNorm) {
+  MyCoupledTimeStepper coupledTimeStepper(finalTime_, factory_, parset_,
+                                          globalFriction_, R1_, errorNorm,
+                                          externalForces_);
+  stepAndReport("R1", coupledTimeStepper, relativeTime_, relativeTau_);
+  iterationWriter_ << std::endl;
+}
+
+template <class Factory, class Updaters, class ErrorNorm>
+bool AdaptiveTimeStepper<Factory, Updaters, ErrorNorm>::reachedEnd() {
+  return relativeTime_ >= 1.0;
+}
+
+template <class Factory, class Updaters, class ErrorNorm>
+bool AdaptiveTimeStepper<Factory, Updaters, ErrorNorm>::coarsen() {
+  bool didCoarsen = false;
+
+  while (relativeTime_ + relativeTau_ < 1.0) {
+    R2_ = R1_.clone();
+    {
+      MyCoupledTimeStepper coupledTimeStepper(finalTime_, factory_, parset_,
+                                              globalFriction_, R2_, errorNorm_,
+                                              externalForces_);
+      stepAndReport("R2", coupledTimeStepper, relativeTime_ + relativeTau_,
+                    relativeTau_);
+    }
+
+    Updaters C = current_.clone();
+    {
+      MyCoupledTimeStepper coupledTimeStepper(finalTime_, factory_, parset_,
+                                              globalFriction_, C, errorNorm_,
+                                              externalForces_);
+
+      stepAndReport("C", coupledTimeStepper, relativeTime_, 2.0 * relativeTau_);
+    }
+
+    if (!mustRefine_(C, R2_)) {
+      R2_ = { nullptr, nullptr };
+      R1_ = C;
+      relativeTau_ *= 2.0;
+      didCoarsen = true;
+    } else {
+      break;
+    }
+  }
+  return didCoarsen;
+}
+
+template <class Factory, class Updaters, class ErrorNorm>
+void AdaptiveTimeStepper<Factory, Updaters, ErrorNorm>::refine() {
+  while (true) {
+    Updaters F2 = current_.clone();
+    Updaters F1;
+    {
+      MyCoupledTimeStepper coupledTimeStepper(finalTime_, factory_, parset_,
+                                              globalFriction_, F2, errorNorm_,
+                                              externalForces_);
+      stepAndReport("F1", coupledTimeStepper, relativeTime_,
+                    relativeTau_ / 2.0);
+
+      F1 = F2.clone();
+      stepAndReport("F2", coupledTimeStepper,
+                    relativeTime_ + relativeTau_ / 2.0, relativeTau_ / 2.0);
+    }
+
+    if (!mustRefine_(R1_, F2)) {
+      break;
+    } else {
+      R1_ = F1;
+      R2_ = F2;
+      relativeTau_ /= 2.0;
+    }
+  }
+}
+
+template <class Factory, class Updaters, class ErrorNorm>
+void AdaptiveTimeStepper<Factory, Updaters, ErrorNorm>::advance() {
+  if (!coarsen())
+    refine();
+
+  iterationWriter_ << std::endl;
+
+  current_ = R1_;
+  R1_ = R2_;
+  relativeTime_ += relativeTau_;
+}
+
+template <class Factory, class Updaters, class ErrorNorm>
+void AdaptiveTimeStepper<Factory, Updaters, ErrorNorm>::stepAndReport(
+    std::string type, MyCoupledTimeStepper &stepper, double rTime,
+    double rTau) {
+  iterationWriter_ << type << " " << stepper.step(rTime, rTau) << " "
+                   << std::flush;
+}
+
+#include "adaptivetimestepper_tmpl.cc"

src/adaptivetimestepper.hh

+#ifndef SRC_ADAPTIVETIMESTEPPER_HH
+#define SRC_ADAPTIVETIMESTEPPER_HH
+
+#include <fstream>
+
 #include "coupledtimestepper.hh"
 
 template <class Factory, class Updaters, class ErrorNorm>
@@ -15,109 +20,19 @@ class AdaptiveTimeStepper {
                       double relativeTau,
                       std::function<void(double, Vector &)> externalForces,
                       ErrorNorm const &errorNorm,
-                      std::function<bool(Updaters &, Updaters &)> mustRefine)
-      : relativeTime_(relativeTime),
-        relativeTau_(relativeTau),
-        finalTime_(parset.get<double>("problem.finalTime")),
-        factory_(factory),
-        parset_(parset),
-        globalFriction_(globalFriction),
-        current_(current),
-        R1_(current_.clone()),
-        externalForces_(externalForces),
-        mustRefine_(mustRefine),
-        iterationWriter_("iterations", std::fstream::out),
-        errorNorm_(errorNorm) {
-    MyCoupledTimeStepper coupledTimeStepper(finalTime_, factory_, parset_,
-                                            globalFriction_, R1_, errorNorm,
-                                            externalForces_);
-    stepAndReport("R1", coupledTimeStepper, relativeTime_, relativeTau_);
-    iterationWriter_ << std::endl;
-  }
-
-  bool reachedEnd() { return relativeTime_ >= 1.0; }
-
-  bool coarsen() {
-    bool didCoarsen = false;
-
-    while (relativeTime_ + relativeTau_ < 1.0) {
-      R2_ = R1_.clone();
-      {
-        MyCoupledTimeStepper coupledTimeStepper(finalTime_, factory_, parset_,
-                                                globalFriction_, R2_,
-                                                errorNorm_, externalForces_);
-        stepAndReport("R2", coupledTimeStepper, relativeTime_ + relativeTau_,
-                      relativeTau_);
-      }
-
-      Updaters C = current_.clone();
-      {
-        MyCoupledTimeStepper coupledTimeStepper(finalTime_, factory_, parset_,
-                                                globalFriction_, C, errorNorm_,
-                                                externalForces_);
-
-        stepAndReport("C", coupledTimeStepper, relativeTime_,
-                      2.0 * relativeTau_);
-      }
-
-      if (!mustRefine_(C, R2_)) {
-        R2_ = { nullptr, nullptr };
-        R1_ = C;
-        relativeTau_ *= 2.0;
-        didCoarsen = true;
-      } else {
-        break;
-      }
-    }
-    return didCoarsen;
-  }
-
-  void refine() {
-    while (true) {
-      Updaters F2 = current_.clone();
-      Updaters F1;
-      {
-        MyCoupledTimeStepper coupledTimeStepper(finalTime_, factory_, parset_,
-                                                globalFriction_, F2, errorNorm_,
-                                                externalForces_);
-        stepAndReport("F1", coupledTimeStepper, relativeTime_,
-                      relativeTau_ / 2.0);
-
-        F1 = F2.clone();
-        stepAndReport("F2", coupledTimeStepper,
-                      relativeTime_ + relativeTau_ / 2.0, relativeTau_ / 2.0);
-      }
-
-      if (!mustRefine_(R1_, F2)) {
-        break;
-      } else {
-        R1_ = F1;
-        R2_ = F2;
-        relativeTau_ /= 2.0;
-      }
-    }
-  }
-
-  void advance() {
-    if (!coarsen())
-      refine();
-
-    iterationWriter_ << std::endl;
+                      std::function<bool(Updaters &, Updaters &)> mustRefine);
 
-    current_ = R1_;
-    R1_ = R2_;
-    relativeTime_ += relativeTau_;
-  }
+  bool reachedEnd();
+  bool coarsen();
+  void refine();
+  void advance();
 
   double relativeTime_;
   double relativeTau_;
 
 private:
   void stepAndReport(std::string type, MyCoupledTimeStepper &stepper,
-                     double rTime, double rTau) {
-    iterationWriter_ << type << " " << stepper.step(rTime, rTau) << " "
-                     << std::flush;
-  }
+                     double rTime, double rTau);
 
   double finalTime_;
   Factory &factory_;
@@ -131,3 +46,4 @@ class AdaptiveTimeStepper {
   std::fstream iterationWriter_;
   ErrorNorm const &errorNorm_;
 };
+#endif

src/adaptivetimestepper_tmpl.cc

+#ifndef MY_DIM
+#error MY_DIM unset
+#endif
+
+#include <dune/common/function.hh>
+
+#include <dune/solvers/norms/energynorm.hh>
+#include <dune/tnnmg/problem-classes/convexproblem.hh>
+
+#include <dune/tectonic/globalfriction.hh>
+#include <dune/tectonic/myblockproblem.hh>
+
+#include "explicitgrid.hh"
+#include "explicitvectors.hh"
+
+#include "rate/rateupdater.hh"
+#include "solverfactory.hh"
+#include "state/stateupdater.hh"
+#include "updaters.hh"
+
+using Function = Dune::VirtualFunction<double, double>;
+using Factory = SolverFactory<
+    MY_DIM,
+    MyBlockProblem<ConvexProblem<GlobalFriction<Matrix, Vector>, Matrix>>,
+    Grid>;
+using MyStateUpdater = StateUpdater<ScalarVector, Vector>;
+using MyRateUpdater = RateUpdater<Vector, Matrix, Function, MY_DIM>;
+using MyUpdaters = Updaters<MyRateUpdater, MyStateUpdater>;
+
+using ErrorNorm = EnergyNorm<ScalarMatrix, ScalarVector>;
+
+template class AdaptiveTimeStepper<Factory, MyUpdaters, ErrorNorm>;

src/sand-wedge.cc

@@ -52,7 +52,7 @@
 #include <dune/tectonic/myblockproblem.hh>
 #include <dune/tectonic/globalfriction.hh>
 
-#include "adaptivetimestepper.hh" // FIXME
+#include "adaptivetimestepper.hh"
 #include "assemblers.hh"
 #include "distances.hh"
 #include "enumparser.hh"