[Cleanup] Kill quasistatic Euler

src/enum_scheme.cc

@@ -2,9 +2,6 @@
 
 template <> struct StringToEnum<Config::scheme> {
   static Config::scheme convert(std::string const &s) {
-    if (s == "implicitEuler")
-      return Config::ImplicitEuler;
-
     if (s == "newmark")
       return Config::Newmark;
 

src/enums.hh

@@ -7,7 +7,6 @@ struct Config {
     Ruina
   };
   enum scheme {
-    ImplicitEuler,
     Newmark,
     EulerPair
   };

src/one-body-sample.cc

@@ -102,11 +102,6 @@ initTimeStepper(Config::scheme scheme,
                 VectorType const &u_initial, VectorType const &v_initial,
                 VectorType const &a_initial) {
   switch (scheme) {
-    case Config::ImplicitEuler:
-      return Dune::make_shared<
-          ImplicitEuler<VectorType, MatrixType, FunctionType, dims>>(
-          stiffnessMatrix, u_initial, v_initial, velocityDirichletNodes,
-          velocityDirichletFunction);
     case Config::Newmark:
       return Dune::make_shared<
           Newmark<VectorType, MatrixType, FunctionType, dims>>(

src/timestepping.cc

@@ -8,7 +8,6 @@
 #include "timestepping.hh"
 
 #include "timestepping/eulerpair.cc"
-#include "timestepping/impliciteuler.cc"
 #include "timestepping/newmark.cc"
 
 #include "timestepping_tmpl.cc"

src/timestepping.hh

@@ -16,7 +16,6 @@ class TimeSteppingScheme {
   void virtual extractVelocity(VectorType &velocity) const = 0;
 };
 
-#include "timestepping/impliciteuler.hh"
 #include "timestepping/newmark.hh"
 #include "timestepping/eulerpair.hh"
 

src/timestepping/impliciteuler.cc

-template <class VectorType, class MatrixType, class FunctionType, int dim>
-ImplicitEuler<VectorType, MatrixType, FunctionType, dim>::ImplicitEuler(
-    MatrixType const &_A, VectorType const &_u_initial,
-    VectorType const &_v_initial,
-    Dune::BitSetVector<dim> const &_dirichletNodes,
-    FunctionType const &_dirichletFunction)
-    : A(_A),
-      u(_u_initial),
-      v(_v_initial),
-      dirichletNodes(_dirichletNodes),
-      dirichletFunction(_dirichletFunction) {}
-
-template <class VectorType, class MatrixType, class FunctionType, int dim>
-void ImplicitEuler<VectorType, MatrixType, FunctionType, dim>::nextTimeStep() {
-  v_o = v;
-  u_o = u;
-}
-
-template <class VectorType, class MatrixType, class FunctionType, int dim>
-void ImplicitEuler<VectorType, MatrixType, FunctionType, dim>::setup(
-    VectorType const &ell, double _tau, double time, VectorType &problem_rhs,
-    VectorType &problem_iterate, MatrixType &problem_AB) {
-  postProcessCalled = false;
-
-  tau = _tau;
-
-  problem_rhs = ell;
-  Arithmetic::subtractProduct(problem_rhs, A, u_o);
-
-  // For fixed tau, we'd only really have to do this once
-  problem_AB = A;
-  problem_AB *= tau;
-
-  // v_o makes a good initial iterate; we could use anything, though
-  problem_iterate = v_o;
-
-  for (size_t i = 0; i < dirichletNodes.size(); ++i)
-    switch (dirichletNodes[i].count()) {
-      case 0:
-        continue;
-      case dim:
-        problem_iterate[i] = 0;
-        dirichletFunction.evaluate(time, problem_iterate[i][0]);
-        break;
-      case 1:
-        if (dirichletNodes[i][0]) {
-          dirichletFunction.evaluate(time, problem_iterate[i][0]);
-          break;
-        }
-        if (dirichletNodes[i][1]) {
-          problem_iterate[i][1] = 0;
-          break;
-        }
-        assert(false);
-      default:
-        assert(false);
-    }
-}
-
-template <class VectorType, class MatrixType, class FunctionType, int dim>
-void ImplicitEuler<VectorType, MatrixType, FunctionType, dim>::postProcess(
-    VectorType const &problem_iterate) {
-  postProcessCalled = true;
-
-  v = problem_iterate;
-
-  u = u_o;
-  Arithmetic::addProduct(u, tau, v);
-}
-
-template <class VectorType, class MatrixType, class FunctionType, int dim>
-void ImplicitEuler<VectorType, MatrixType, FunctionType,
-                   dim>::extractDisplacement(VectorType &displacement) const {
-  if (!postProcessCalled)
-    DUNE_THROW(Dune::Exception, "It seems you forgot to call postProcess!");
-
-  displacement = u;
-}
-
-template <class VectorType, class MatrixType, class FunctionType, int dim>
-void ImplicitEuler<VectorType, MatrixType, FunctionType, dim>::extractVelocity(
-    VectorType &velocity) const {
-  if (!postProcessCalled)
-    DUNE_THROW(Dune::Exception, "It seems you forgot to call postProcess!");
-
-  velocity = v;
-}

src/timestepping/impliciteuler.hh

-#ifndef DUNE_TECTONIC_TIMESTEPPING_IMPLICITEULER_HH
-#define DUNE_TECTONIC_TIMESTEPPING_IMPLICITEULER_HH
-
-template <class VectorType, class MatrixType, class FunctionType, int dim>
-class ImplicitEuler
-    : public TimeSteppingScheme<VectorType, MatrixType, FunctionType, dim> {
-public:
-  ImplicitEuler(MatrixType const &_A, VectorType const &_u_initial,
-                VectorType const &_v_initial,
-                Dune::BitSetVector<dim> const &_dirichletNodes,
-                FunctionType const &_dirichletFunction);
-
-  void virtual nextTimeStep() override;
-  void virtual setup(VectorType const &, double, double, VectorType &,
-                     VectorType &, MatrixType &) override;
-  void virtual postProcess(VectorType const &) override;
-  void virtual extractDisplacement(VectorType &) const override;
-  void virtual extractVelocity(VectorType &) const override;
-
-private:
-  MatrixType const &A;
-  VectorType u;
-  VectorType v;
-  Dune::BitSetVector<dim> const &dirichletNodes;
-  FunctionType const &dirichletFunction;
-
-  VectorType u_o;
-  VectorType v_o;
-
-  double tau;
-
-  bool postProcessCalled = false;
-};
-#endif

src/timestepping_tmpl.cc

@@ -14,6 +14,5 @@ using MatrixType = Dune::BCRSMatrix<SmallMatrix>;
 using VectorType = Dune::BlockVector<SmallVector>;
 using FunctionType = Dune::VirtualFunction<double, double>;
 
-template class ImplicitEuler<VectorType, MatrixType, FunctionType, DIM>;
 template class Newmark<VectorType, MatrixType, FunctionType, DIM>;
 template class EulerPair<VectorType, MatrixType, FunctionType, DIM>;