src/time-stepping/rate/rateupdater.cc

-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include "rateupdater.hh"
-
-template <class Vector, class Matrix, class Function, size_t dim>
-RateUpdater<Vector, Matrix, Function, dim>::RateUpdater(
-    Matrices<Matrix> const &_matrices, Vector const &_u_initial,
-    Vector const &_v_initial, Vector const &_a_initial,
-    Dune::BitSetVector<dim> const &_dirichletNodes,
-    Function const &_dirichletFunction)
-    : matrices(_matrices),
-      u(_u_initial),
-      v(_v_initial),
-      a(_a_initial),
-      dirichletNodes(_dirichletNodes),
-      dirichletFunction(_dirichletFunction) {}
-
-template <class Vector, class Matrix, class Function, size_t dim>
-void RateUpdater<Vector, Matrix, Function, dim>::nextTimeStep() {
-  u_o = u;
-  v_o = v;
-  a_o = a;
-  postProcessCalled = false;
-}
-
-template <class Vector, class Matrix, class Function, size_t dim>
-void RateUpdater<Vector, Matrix, Function, dim>::extractDisplacement(
-    Vector &displacement) const {
-  if (!postProcessCalled)
-    DUNE_THROW(Dune::Exception, "It seems you forgot to call postProcess!");
-
-  displacement = u;
-}
-
-template <class Vector, class Matrix, class Function, size_t dim>
-void RateUpdater<Vector, Matrix, Function, dim>::extractVelocity(
-    Vector &velocity) const {
-  if (!postProcessCalled)
-    DUNE_THROW(Dune::Exception, "It seems you forgot to call postProcess!");
-
-  velocity = v;
-}
-
-template <class Vector, class Matrix, class Function, size_t dim>
-void RateUpdater<Vector, Matrix, Function, dim>::extractOldVelocity(
-    Vector &oldVelocity) const {
-  oldVelocity = v_o;
-}
-
-template <class Vector, class Matrix, class Function, size_t dim>
-void RateUpdater<Vector, Matrix, Function, dim>::extractAcceleration(
-    Vector &acceleration) const {
-  if (!postProcessCalled)
-    DUNE_THROW(Dune::Exception, "It seems you forgot to call postProcess!");
-
-  acceleration = a;
-}
-
-#include "backward_euler.cc"
-#include "newmark.cc"
-#include "rateupdater_tmpl.cc"

src/time-stepping/rate/rateupdater.hh

-#ifndef SRC_TIME_STEPPING_RATE_RATEUPDATER_HH
-#define SRC_TIME_STEPPING_RATE_RATEUPDATER_HH
-
-#include <memory>
-
-#include <dune/common/bitsetvector.hh>
-
-#include "../../matrices.hh"
-
-template <class Vector, class Matrix, class Function, size_t dim>
-class RateUpdater {
-protected:
-  RateUpdater(Matrices<Matrix> const &_matrices, Vector const &_u_initial,
-              Vector const &_v_initial, Vector const &_a_initial,
-              Dune::BitSetVector<dim> const &_dirichletNodes,
-              Function const &_dirichletFunction);
-
-public:
-  void nextTimeStep();
-  void virtual setup(Vector const &ell, double _tau, double relativeTime,
-                     Vector &rhs, Vector &iterate, Matrix &AB) = 0;
-
-  void virtual postProcess(Vector const &iterate) = 0;
-  void extractDisplacement(Vector &displacement) const;
-  void extractVelocity(Vector &velocity) const;
-  void extractOldVelocity(Vector &velocity) const;
-  void extractAcceleration(Vector &acceleration) const;
-
-  std::shared_ptr<RateUpdater<Vector, Matrix, Function, dim>> virtual clone()
-      const = 0;
-
-protected:
-  Matrices<Matrix> const &matrices;
-  Vector u, v, a;
-  Dune::BitSetVector<dim> const &dirichletNodes;
-  Function const &dirichletFunction;
-  double dirichletValue;
-
-  Vector u_o, v_o, a_o;
-  double tau;
-
-  bool postProcessCalled = true;
-};
-#endif

src/time-stepping/rate/rateupdater_tmpl.cc

-#ifndef MY_DIM
-#error MY_DIM unset
-#endif
-
-#include <dune/common/function.hh>
-
-#include "../../explicitvectors.hh"
-
-using Function = Dune::VirtualFunction<double, double>;
-
-template class RateUpdater<Vector, Matrix, Function, MY_DIM>;
-template class Newmark<Vector, Matrix, Function, MY_DIM>;
-template class BackwardEuler<Vector, Matrix, Function, MY_DIM>;

src/time-stepping/rate_tmpl.cc

-#include "../explicitvectors.hh"
-
-#include <dune/common/function.hh>
-
-using Function = Dune::VirtualFunction<double, double>;
-
-template std::shared_ptr<RateUpdater<Vector, Matrix, Function, MY_DIM>>
-initRateUpdater<Vector, Matrix, Function, MY_DIM>(
-    Config::scheme scheme, Function const &velocityDirichletFunction,
-    Dune::BitSetVector<MY_DIM> const &velocityDirichletNodes,
-    Matrices<Matrix> const &matrices, Vector const &u_initial,
-    Vector const &v_initial, Vector const &a_initial);

src/time-stepping/state.cc

-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include "state.hh"
-#include "state/ageinglawstateupdater.cc"
-#include "state/sliplawstateupdater.cc"
-
-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::AgeingLaw:
-      return std::make_shared<AgeingLawStateUpdater<ScalarVector, Vector>>(
-          alpha_initial, frictionalNodes, L, V0);
-    case Config::SlipLaw:
-      return std::make_shared<SlipLawStateUpdater<ScalarVector, Vector>>(
-          alpha_initial, frictionalNodes, L, V0);
-    default:
-      assert(false);
-  }
-}
-
-#include "state_tmpl.cc"

src/time-stepping/state.hh

-#ifndef SRC_TIME_STEPPING_STATE_HH
-#define SRC_TIME_STEPPING_STATE_HH
-
-#include <memory>
-
-#include <dune/common/bitsetvector.hh>
-
-#include "../enums.hh"
-#include "state/ageinglawstateupdater.hh"
-#include "state/sliplawstateupdater.hh"
-#include "state/stateupdater.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);
-
-#endif

src/time-stepping/state/ageinglawstateupdater.hh

-#ifndef SRC_TIME_STEPPING_STATE_AGEINGLAWSTATEUPDATER_HH
-#define SRC_TIME_STEPPING_STATE_AGEINGLAWSTATEUPDATER_HH
-
-#include "stateupdater.hh"
-
-template <class ScalarVector, class Vector>
-class AgeingLawStateUpdater : public StateUpdater<ScalarVector, Vector> {
-public:
-  AgeingLawStateUpdater(ScalarVector const &_alpha_initial,
-                        Dune::BitSetVector<1> const &_nodes, double _L,
-                        double _V0);
-
-  void nextTimeStep() override;
-  void setup(double _tau) override;
-  void solve(Vector const &velocity_field) override;
-  void extractAlpha(ScalarVector &) override;
-
-  std::shared_ptr<StateUpdater<ScalarVector, Vector>> clone() const override;
-
-private:
-  ScalarVector alpha_o;
-  ScalarVector alpha;
-  Dune::BitSetVector<1> const &nodes;
-  double const L;
-  double const V0;
-  double tau;
-};
-#endif

src/time-stepping/state/sliplawstateupdater.hh

-#ifndef SRC_TIME_STEPPING_STATE_SLIPLAWSTATEUPDATER_HH
-#define SRC_TIME_STEPPING_STATE_SLIPLAWSTATEUPDATER_HH
-
-#include "stateupdater.hh"
-
-template <class ScalarVector, class Vector>
-class SlipLawStateUpdater : public StateUpdater<ScalarVector, Vector> {
-public:
-  SlipLawStateUpdater(ScalarVector const &_alpha_initial,
-                      Dune::BitSetVector<1> const &_nodes, double _L,
-                      double _V0);
-
-  void nextTimeStep() override;
-  void setup(double _tau) override;
-  void solve(Vector const &velocity_field) override;
-  void extractAlpha(ScalarVector &) override;
-
-  std::shared_ptr<StateUpdater<ScalarVector, Vector>> clone() const override;
-
-private:
-  ScalarVector alpha_o;
-  ScalarVector alpha;
-  Dune::BitSetVector<1> const &nodes;
-  double const L;
-  double const V0;
-  double tau;
-};
-
-#endif

src/time-stepping/state/stateupdater.hh

-#ifndef SRC_TIME_STEPPING_STATE_STATEUPDATER_HH
-#define SRC_TIME_STEPPING_STATE_STATEUPDATER_HH
-
-template <class ScalarVectorTEMPLATE, class Vector> class StateUpdater {
-public:
-  using ScalarVector = ScalarVectorTEMPLATE;
-
-  void virtual nextTimeStep() = 0;
-  void virtual setup(double _tau) = 0;
-  void virtual solve(Vector const &velocity_field) = 0;
-  void virtual extractAlpha(ScalarVector &alpha) = 0;
-
-  std::shared_ptr<StateUpdater<ScalarVector, Vector>> virtual clone() const = 0;
-};
-
-#endif

src/time-stepping/state_tmpl.cc

-#include "../explicitvectors.hh"
-
-template std::shared_ptr<StateUpdater<ScalarVector, Vector>>
-initStateUpdater<ScalarVector, Vector>(
-    Config::stateModel model, ScalarVector const &alpha_initial,
-    Dune::BitSetVector<1> const &frictionalNodes, double L, double V0);

src/vtk.cc

-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <dune/grid/io/file/vtk/vtkwriter.hh>
-
-#include <dune/fufem/functions/vtkbasisgridfunction.hh>
-
-#include "vtk.hh"
-
-template <class VertexBasis, class CellBasis>
-MyVTKWriter<VertexBasis, CellBasis>::MyVTKWriter(
-    CellBasis const &_cellBasis, VertexBasis const &_vertexBasis,
-    std::string _prefix)
-    : cellBasis(_cellBasis), vertexBasis(_vertexBasis), prefix(_prefix) {}
-
-template <class VertexBasis, class CellBasis>
-template <class Vector, class ScalarVector>
-void MyVTKWriter<VertexBasis, CellBasis>::write(
-    size_t record, Vector const &u, Vector const &v, ScalarVector const &alpha,
-    ScalarVector const &stress) const {
-  Dune::VTKWriter<typename VertexBasis::GridView> writer(
-      vertexBasis.getGridView());
-
-  auto const displacementPointer =
-      std::make_shared<VTKBasisGridFunction<VertexBasis, Vector> const>(
-          vertexBasis, u, "displacement");
-  writer.addVertexData(displacementPointer);
-
-  auto const velocityPointer =
-      std::make_shared<VTKBasisGridFunction<VertexBasis, Vector> const>(
-          vertexBasis, v, "velocity");
-  writer.addVertexData(velocityPointer);
-
-  auto const AlphaPointer =
-      std::make_shared<VTKBasisGridFunction<VertexBasis, ScalarVector> const>(
-          vertexBasis, alpha, "Alpha");
-  writer.addVertexData(AlphaPointer);
-
-  auto const stressPointer =
-      std::make_shared<VTKBasisGridFunction<CellBasis, ScalarVector> const>(
-          cellBasis, stress, "stress");
-  writer.addCellData(stressPointer);
-
-  std::string const filename = prefix + std::to_string(record);
-  writer.write(filename.c_str(), Dune::VTK::appendedraw);
-}
-
-template <class VertexBasis, class CellBasis>
-void MyVTKWriter<VertexBasis, CellBasis>::writeGrid() const {
-  Dune::VTKWriter<typename VertexBasis::GridView> writer(
-      vertexBasis.getGridView());
-
-  std::string const filename = prefix + "_grid";
-  writer.write(filename.c_str(), Dune::VTK::appendedraw);
-}
-
-#include "vtk_tmpl.cc"

src/vtk.hh

-#ifndef SRC_VTK_HH
-#define SRC_VTK_HH
-
-#include <string>
-
-template <class VertexBasis, class CellBasis> class MyVTKWriter {
-  CellBasis const &cellBasis;
-  VertexBasis const &vertexBasis;
-  std::string const prefix;
-
-public:
-  MyVTKWriter(CellBasis const &cellBasis, VertexBasis const &vertexBasis,
-              std::string prefix);
-
-  template <class Vector, class ScalarVector>
-  void write(size_t record, Vector const &u, Vector const &v,
-             ScalarVector const &alpha, ScalarVector const &stress) const;
-
-  void writeGrid() const;
-};
-#endif

src/vtk_tmpl.cc

-#ifndef MY_DIM
-#error MY_DIM unset
-#endif
-
-#include "explicitgrid.hh"
-#include "explicitvectors.hh"
-
-#include <dune/fufem/functionspacebases/p0basis.hh>
-#include <dune/fufem/functionspacebases/p1nodalbasis.hh>
-
-using MyP0Basis = P0Basis<GridView, double>;
-using P1Basis = P1NodalBasis<GridView, double>;
-
-template class MyVTKWriter<P1Basis, MyP0Basis>;
-
-template void MyVTKWriter<P1Basis, MyP0Basis>::write<Vector, ScalarVector>(
-    size_t record, Vector const &u, Vector const &v, ScalarVector const &alpha,
-    ScalarVector const &stress) const;