src/hdf5/patchinfo-writer.hh

+#ifndef SRC_HDF_PATCHINFO_WRITER_HH
+#define SRC_HDF_PATCHINFO_WRITER_HH
+
+#include <dune/istl/matrix.hh>
+
+#include <dune/fufem/boundarypatch.hh>
+#include <dune/fufem/functions/basisgridfunction.hh>
+#include <dune/fufem/geometry/convexpolyhedron.hh>
+#include <dune/fufem/hdf5/sequenceio.hh>
+
+#include "../one-body-problem-data/mygeometry.hh"
+
+template <class LocalVector, class GridView> class GridEvaluator {
+  using Element = typename GridView::Grid::template Codim<0>::Entity;
+
+public:
+  GridEvaluator(ConvexPolyhedron<LocalVector> const &weakPatch,
+                GridView const &gridView);
+
+  template <class Function>
+  Dune::Matrix<typename Function::RangeType> evaluate(Function const &f) const;
+
+  Dune::BlockVector<Dune::FieldVector<double, 1>> xCoordinates;
+  Dune::BlockVector<Dune::FieldVector<double, 1>> zCoordinates;
+
+private:
+  std::vector<std::vector<std::pair<Element, LocalVector>>> localInfo;
+};
+
+template <class ProgramState, class VertexBasis, class GridView>
+class PatchInfoWriter {
+  using Vector = typename ProgramState::Vector;
+  using LocalVector = typename Vector::block_type;
+  using Patch = BoundaryPatch<GridView>;
+
+public:
+  PatchInfoWriter(HDF5::Grouplike &file, VertexBasis const &vertexBasis,
+                  Patch const &frictionalBoundary,
+                  ConvexPolyhedron<LocalVector> const &weakPatch);
+
+  void write(ProgramState const &programState);
+
+private:
+  HDF5::Group group_;
+
+  VertexBasis const &vertexBasis_;
+
+  GridEvaluator<LocalVector, GridView> const gridEvaluator_;
+  HDF5::SequenceIO<3> weakPatchGridVelocityWriter_;
+};
+#endif

src/hdf5/patchinfo-writer_tmpl.cc

+#include "../explicitvectors.hh"
+#include "../explicitgrid.hh"
+
+#include "../program_state.hh"
+
+using MyProgramState = ProgramState<Vector, ScalarVector>;
+using P1Basis = P1NodalBasis<GridView, double>;
+using MyFunction = BasisGridFunction<P1Basis, Vector>;
+
+template class GridEvaluator<LocalVector, GridView>;
+template Dune::Matrix<typename MyFunction::RangeType>
+GridEvaluator<LocalVector, GridView>::evaluate(MyFunction const &f) const;
+
+template class PatchInfoWriter<MyProgramState, P1Basis, GridView>;

src/hdf5/restart-io.cc

+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "restart-io.hh"
+
+template <class ProgramState>
+RestartIO<ProgramState>::RestartIO(HDF5::Grouplike &group, size_t vertexCount)
+    : displacementWriter_(group, "displacement", vertexCount,
+                          Vector::block_type::dimension),
+      velocityWriter_(group, "velocity", vertexCount,
+                      Vector::block_type::dimension),
+      accelerationWriter_(group, "acceleration", vertexCount,
+                          Vector::block_type::dimension),
+      stateWriter_(group, "state", vertexCount),
+      weightedNormalStressWriter_(group, "weightedNormalStress", vertexCount),
+      relativeTimeWriter_(group, "relativeTime"),
+      relativeTimeIncrementWriter_(group, "relativeTimeIncrement") {}
+
+template <class ProgramState>
+void RestartIO<ProgramState>::write(ProgramState const &programState) {
+  addEntry(displacementWriter_, programState.timeStep, programState.u);
+  addEntry(velocityWriter_, programState.timeStep, programState.v);
+  addEntry(accelerationWriter_, programState.timeStep, programState.a);
+  addEntry(stateWriter_, programState.timeStep, programState.alpha);
+  addEntry(weightedNormalStressWriter_, programState.timeStep,
+           programState.weightedNormalStress);
+  addEntry(relativeTimeWriter_, programState.timeStep,
+           programState.relativeTime);
+  addEntry(relativeTimeIncrementWriter_, programState.timeStep,
+           programState.relativeTau);
+}
+
+template <class ProgramState>
+void RestartIO<ProgramState>::read(size_t timeStep,
+                                   ProgramState &programState) {
+  programState.timeStep = timeStep;
+  readEntry(displacementWriter_, timeStep, programState.u);
+  readEntry(velocityWriter_, timeStep, programState.v);
+  readEntry(accelerationWriter_, timeStep, programState.a);
+  readEntry(stateWriter_, timeStep, programState.alpha);
+  readEntry(weightedNormalStressWriter_, timeStep,
+            programState.weightedNormalStress);
+  readEntry(relativeTimeWriter_, timeStep, programState.relativeTime);
+  readEntry(relativeTimeIncrementWriter_, timeStep, programState.relativeTau);
+}
+
+#include "restart-io_tmpl.cc"

src/hdf5/restart-io.hh

+#ifndef SRC_HDF_RESTART_HDF_HH
+#define SRC_HDF_RESTART_HDF_HH
+
+#include <dune/fufem/hdf5/file.hh>
+#include <dune/fufem/hdf5/sequenceio.hh>
+
+template <class ProgramState> class RestartIO {
+  using ScalarVector = typename ProgramState::ScalarVector;
+  using Vector = typename ProgramState::Vector;
+
+public:
+  RestartIO(HDF5::Grouplike &group, size_t vertexCount);
+
+  void write(ProgramState const &programState);
+
+  void read(size_t timeStep, ProgramState &programState);
+
+private:
+  HDF5::SequenceIO<2> displacementWriter_;
+  HDF5::SequenceIO<2> velocityWriter_;
+  HDF5::SequenceIO<2> accelerationWriter_;
+  HDF5::SequenceIO<1> stateWriter_;
+  HDF5::SequenceIO<1> weightedNormalStressWriter_;
+  HDF5::SequenceIO<0> relativeTimeWriter_;
+  HDF5::SequenceIO<0> relativeTimeIncrementWriter_;
+};
+#endif

src/hdf5/restart-io_tmpl.cc

+#include "../explicitvectors.hh"
+
+#include "../program_state.hh"
+
+using MyProgramState = ProgramState<Vector, ScalarVector>;
+
+template class RestartIO<MyProgramState>;

src/hdf5/restrict.hh

+#ifndef SRC_HDF5_RESTRICT_HH
+#define SRC_HDF5_RESTRICT_HH
+
+#include <cassert>
+
+#include <dune/common/bitsetvector.hh>
+
+#include "../tobool.hh"
+
+template <class Vector, class Patch>
+Vector restrictToSurface(Vector const &v1, Patch const &patch) {
+  auto const &vertices = *patch.getVertices();
+  assert(vertices.size() == v1.size());
+
+  Vector ret(vertices.count());
+  auto target = ret.begin();
+  for (size_t i = 0; i < v1.size(); ++i)
+    if (toBool(vertices[i]))
+      *(target++) = v1[i];
+  assert(target == ret.end());
+  return ret;
+}
+#endif

src/hdf5/surface-writer.cc

+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "restrict.hh"
+#include "surface-writer.hh"
+
+template <class ProgramState, class GridView>
+SurfaceWriter<ProgramState, GridView>::SurfaceWriter(
+    HDF5::Grouplike &file, Vector const &vertexCoordinates, Patch const &surface)
+    : group_(file, "surface"),
+      surface_(surface),
+      surfaceDisplacementWriter_(group_, "displacement", surface.numVertices(),
+                                 Vector::block_type::dimension),
+      surfaceVelocityWriter_(group_, "velocity", surface.numVertices(),
+                             Vector::block_type::dimension) {
+  auto const surfaceCoordinates = restrictToSurface(vertexCoordinates, surface);
+  HDF5::SingletonWriter<2> surfaceCoordinateWriter(group_, "coordinates",
+                                                 surfaceCoordinates.size(),
+                                                 Vector::block_type::dimension);
+  setEntry(surfaceCoordinateWriter, surfaceCoordinates);
+}
+
+template <class ProgramState, class GridView>
+void SurfaceWriter<ProgramState, GridView>::write(
+    ProgramState const &programState) {
+  auto const surfaceDisplacements = restrictToSurface(programState.u, surface_);
+  addEntry(surfaceDisplacementWriter_, programState.timeStep,
+           surfaceDisplacements);
+
+  auto const surfaceVelocities = restrictToSurface(programState.v, surface_);
+  addEntry(surfaceVelocityWriter_, programState.timeStep, surfaceVelocities);
+}
+
+#include "surface-writer_tmpl.cc"

src/hdf5/surface-writer.hh

+#ifndef SRC_HDF_SURFACE_WRITER_HH
+#define SRC_HDF_SURFACE_WRITER_HH
+
+#include <dune/fufem/boundarypatch.hh>
+
+#include <dune/fufem/hdf5/sequenceio.hh>
+#include <dune/fufem/hdf5/singletonwriter.hh>
+
+template <class ProgramState, class GridView> class SurfaceWriter {
+  using Vector = typename ProgramState::Vector;
+  using Patch = BoundaryPatch<GridView>;
+
+public:
+  SurfaceWriter(HDF5::Grouplike &file, Vector const &vertexCoordinates,
+                Patch const &surface);
+
+  void write(ProgramState const &programState);
+
+private:
+  HDF5::Group group_;
+
+  Patch const &surface_;
+
+  HDF5::SequenceIO<2> surfaceDisplacementWriter_;
+  HDF5::SequenceIO<2> surfaceVelocityWriter_;
+};
+#endif

src/hdf5/surface-writer_tmpl.cc

+#include "../explicitvectors.hh"
+#include "../explicitgrid.hh"
+
+#include "../program_state.hh"
+
+using MyProgramState = ProgramState<Vector, ScalarVector>;
+
+template class SurfaceWriter<MyProgramState, GridView>;

src/hdf5/time-writer.cc

+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "time-writer.hh"
+
+template <class ProgramState>
+TimeWriter<ProgramState>::TimeWriter(HDF5::Grouplike &file)
+    : file_(file),
+      relativeTimeWriter_(file_, "relativeTime"),
+      relativeTimeIncrementWriter_(file_, "relativeTimeIncrement") {}
+
+template <class ProgramState>
+void TimeWriter<ProgramState>::write(ProgramState const &programState) {
+  addEntry(relativeTimeWriter_, programState.timeStep,
+           programState.relativeTime);
+  addEntry(relativeTimeIncrementWriter_, programState.timeStep,
+           programState.relativeTau);
+}
+
+#include "time-writer_tmpl.cc"

src/hdf5/time-writer.hh

+#ifndef SRC_HDF_TIME_WRITER_HH
+#define SRC_HDF_TIME_WRITER_HH
+
+#include <dune/fufem/hdf5/file.hh>
+#include <dune/fufem/hdf5/sequenceio.hh>
+
+template <class ProgramState> class TimeWriter {
+public:
+  TimeWriter(HDF5::Grouplike &file);
+  void write(ProgramState const &programState);
+
+private:
+  HDF5::Grouplike &file_;
+  HDF5::SequenceIO<0> relativeTimeWriter_;
+  HDF5::SequenceIO<0> relativeTimeIncrementWriter_;
+};
+#endif

src/hdf5/time-writer_tmpl.cc

+#include "../explicitvectors.hh"
+
+#include "../program_state.hh"
+
+using MyProgramState = ProgramState<Vector, ScalarVector>;
+
+template class TimeWriter<MyProgramState>;

src/matrices.hh

+#ifndef SRC_MATRICES_HH
+#define SRC_MATRICES_HH
+
+template <class Matrix> struct Matrices {
+  Matrix elasticity;
+  Matrix damping;
+  Matrix mass;
+};
+#endif

src/one-body-problem-2D.cfg

+# -*- mode:conf -*-
+[boundary.friction]
+smallestDiameter= 2e-3  # [m]
+
+[timeSteps]
+refinementTolerance = 1e-5
+
+[u0.solver]
+tolerance         = 1e-8
+
+[a0.solver]
+tolerance         = 1e-8
+
+[v.solver]
+tolerance         = 1e-8
+
+[v.fpi]
+tolerance         = 1e-5
+
+[solver.tnnmg.linear]
+tolerance          = 1e-10

src/one-body-problem-3D.cfg

+# -*- mode:conf -*-
+[boundary.friction]
+smallestDiameter= 2e-2  # [m]
+
+[boundary.friction.weakening]
+patchType       = Trapezoidal
+
+[timeSteps]
+refinementTolerance = 1e-5
+
+[u0.solver]
+tolerance         = 1e-6
+
+[a0.solver]
+tolerance         = 1e-6
+
+[v.solver]
+tolerance         = 1e-6
+
+[v.fpi]
+tolerance         = 1e-5
+
+[solver.tnnmg.linear]
+tolerance          = 1e-10

src/one-body-problem-data/bc.hh

+#ifndef SRC_ONE_BODY_PROBLEM_DATA_BC_HH
+#define SRC_ONE_BODY_PROBLEM_DATA_BC_HH
+
+class VelocityDirichletCondition
+    : public Dune::VirtualFunction<double, double> {
+  void evaluate(double const &relativeTime, double &y) const {
+    // Assumed to vanish at time zero
+    double const finalVelocity = -5e-5;
+    y = (relativeTime <= 0.1)
+            ? finalVelocity * (1.0 - std::cos(relativeTime * M_PI / 0.1)) / 2.0
+            : finalVelocity;
+  }
+};
+
+class NeumannCondition : public Dune::VirtualFunction<double, double> {
+  void evaluate(double const &relativeTime, double &y) const { y = 0.0; }
+};
+#endif

src/sand-wedge-data/midpoint.hh → src/one-body-problem-data/midpoint.hh

@@ -4,7 +4,7 @@
 #include <dune/solvers/common/arithmetic.hh>
 
 template <class Vector> Vector midPoint(Vector const &x, Vector const &y) {
-  Vector ret{ 0 };
+  Vector ret(0);
   Arithmetic::addProduct(ret, 0.5, x);
   Arithmetic::addProduct(ret, 0.5, y);
   return ret;

src/sand-wedge-data/mybody.hh → src/one-body-problem-data/mybody.hh

-#ifndef SRC_SAND_WEDGE_DATA_MYBODY_HH
-#define SRC_SAND_WEDGE_DATA_MYBODY_HH
+#ifndef SRC_ONE_BODY_PROBLEM_DATA_MYBODY_HH
+#define SRC_ONE_BODY_PROBLEM_DATA_MYBODY_HH
 
 #include <dune/common/fvector.hh>
 
@@ -8,8 +8,8 @@
 #include <dune/tectonic/body.hh>
 #include <dune/tectonic/gravity.hh>
 
-#include "twopiece.hh"
 #include "mygeometry.hh"
+#include "segmented-function.hh"
 
 template <int dimension> class MyBody : public Body<dimension> {
   using typename Body<dimension>::ScalarFunction;
@@ -47,9 +47,9 @@ template <int dimension> class MyBody : public Body<dimension> {
 private:
   double const poissonRatio_;
   double const youngModulus_;
-  TwoPieceFunction const shearViscosityField_;
-  TwoPieceFunction const bulkViscosityField_;
-  TwoPieceFunction const densityField_;
+  SegmentedFunction const shearViscosityField_;
+  SegmentedFunction const bulkViscosityField_;
+  SegmentedFunction const densityField_;
   Gravity<dimension> const gravityField_;
 };
 #endif

src/sand-wedge-data/mygeometry.cc → src/one-body-problem-data/mygeometry.cc

@@ -12,13 +12,6 @@
 
 #include "mygeometry.hh"
 
-double MyGeometry::verticalProjection(LocalVector const &x) {
-  return zenith * x;
-}
-double MyGeometry::horizontalProjection(LocalVector const &x) {
-  return rotatedZenith * x;
-}
-
 void MyGeometry::write() {
   std::fstream writer("geometry", std::fstream::out);
   writer << "A = " << A << std::endl;
@@ -132,8 +125,7 @@ void MyGeometry::render() {
 
   // labels
   {
-    auto const label = [&](LocalVector2D const &v,
-                           std::string l) { // TODO: implicit?
+    auto const label = [&](LocalVector2D const &v, std::string l) {
       moveTo(v);
       cr->rel_move_to(0.005, -0.02);
       cr->show_text(l);