src/hdf5-writer.hh

-#ifndef SRC_HDF5_WRITER_HH
-#define SRC_HDF5_WRITER_HH
-
-#include <dune/fufem/functions/basisgridfunction.hh>
-#include <dune/fufem/geometry/convexpolyhedron.hh>
-#include <dune/fufem/hdf5/file.hh>
-
-#include "hdf5/frictionalboundary-writer.hh"
-#include "hdf5/iteration-writer.hh"
-#include "hdf5/patchinfo-writer.hh"
-#include "hdf5/surface-writer.hh"
-#include "hdf5/time-writer.hh"
-
-template <class ProgramState, class VertexBasis, class GridView>
-class HDF5Writer {
-private:
-  using Vector = typename ProgramState::Vector;
-  using Patch = BoundaryPatch<GridView>;
-
-  using LocalVector = typename Vector::block_type;
-
-public:
-  HDF5Writer(HDF5::Grouplike &file, Vector const &vertexCoordinates,
-             VertexBasis const &vertexBasis, Patch const &surface,
-             Patch const &frictionalBoundary,
-             ConvexPolyhedron<LocalVector> const &weakPatch)
-      : file_(file),
-        iterationWriter_(file_),
-        timeWriter_(file_),
-#if MY_DIM == 3
-        patchInfoWriter_(file_, vertexBasis, frictionalBoundary, weakPatch),
-#endif
-        surfaceWriter_(file_, vertexCoordinates, surface),
-        frictionalBoundaryWriter_(file_, vertexCoordinates,
-                                  frictionalBoundary) {
-  }
-
-  template <class Friction>
-  void reportSolution(ProgramState const &programState,
-                      // for the friction coefficient
-                      Friction &friction) {
-    timeWriter_.write(programState);
-#if MY_DIM == 3
-    patchInfoWriter_.write(programState);
-#endif
-    surfaceWriter_.write(programState);
-    frictionalBoundaryWriter_.write(programState, friction);
-  }
-
-  void reportIterations(ProgramState const &programState,
-                        IterationRegister const &iterationCount) {
-    iterationWriter_.write(programState.timeStep, iterationCount);
-  }
-
-private:
-  HDF5::Grouplike &file_;
-
-  IterationWriter iterationWriter_;
-  TimeWriter<ProgramState> timeWriter_;
-#if MY_DIM == 3
-  PatchInfoWriter<ProgramState, VertexBasis, GridView> patchInfoWriter_;
-#endif
-  SurfaceWriter<ProgramState, GridView> surfaceWriter_;
-  FrictionalBoundaryWriter<ProgramState, GridView> frictionalBoundaryWriter_;
-};
-#endif

src/hdf5/frictionalboundary-writer.cc

-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <dune/fufem/hdf5/singletonwriter.hh>
-
-#include "frictionalboundary-writer.hh"
-#include "restrict.hh"
-
-template <class ProgramState, class GridView>
-FrictionalBoundaryWriter<ProgramState, GridView>::FrictionalBoundaryWriter(
-    HDF5::Grouplike &file, Vector const &vertexCoordinates,
-    Patch const &frictionalBoundary)
-    : group_(file, "frictionalBoundary"),
-      frictionalBoundary_(frictionalBoundary),
-      frictionalBoundaryDisplacementWriter_(group_, "displacement",
-                                            frictionalBoundary.numVertices(),
-                                            Vector::block_type::dimension),
-      frictionalBoundaryVelocityWriter_(group_, "velocity",
-                                        frictionalBoundary.numVertices(),
-                                        Vector::block_type::dimension),
-      frictionalBoundaryStateWriter_(group_, "state",
-                                     frictionalBoundary.numVertices()),
-      frictionalBoundaryCoefficientWriter_(group_, "coefficient",
-                                           frictionalBoundary.numVertices()) {
-  auto const frictionalBoundaryCoordinates =
-      restrictToSurface(vertexCoordinates, frictionalBoundary);
-  HDF5::SingletonWriter<2> frictionalBoundaryCoordinateWriter(
-      group_, "coordinates", frictionalBoundaryCoordinates.size(),
-      Vector::block_type::dimension);
-  setEntry(frictionalBoundaryCoordinateWriter, frictionalBoundaryCoordinates);
-}
-
-template <class ProgramState, class GridView>
-template <class Friction>
-void FrictionalBoundaryWriter<ProgramState, GridView>::write(
-    ProgramState const &programState, Friction &friction) {
-  auto const frictionalBoundaryDisplacements =
-      restrictToSurface(programState.u, frictionalBoundary_);
-  addEntry(frictionalBoundaryDisplacementWriter_, programState.timeStep,
-           frictionalBoundaryDisplacements);
-
-  auto const frictionalBoundaryVelocities =
-      restrictToSurface(programState.v, frictionalBoundary_);
-  addEntry(frictionalBoundaryVelocityWriter_, programState.timeStep,
-           frictionalBoundaryVelocities);
-
-  auto const frictionalBoundaryStates =
-      restrictToSurface(programState.alpha, frictionalBoundary_);
-  addEntry(frictionalBoundaryStateWriter_, programState.timeStep,
-           frictionalBoundaryStates);
-
-  friction.updateAlpha(programState.alpha);
-  auto const c = friction.coefficientOfFriction(programState.v);
-  auto const frictionalBoundaryCoefficient =
-      restrictToSurface(c, frictionalBoundary_);
-  addEntry(frictionalBoundaryCoefficientWriter_, programState.timeStep,
-           frictionalBoundaryCoefficient);
-}
-
-#include "frictionalboundary-writer_tmpl.cc"

src/hdf5/frictionalboundary-writer.hh

-#ifndef SRC_HDF_FRICTIONALBOUNDARY_WRITER_HH
-#define SRC_HDF_FRICTIONALBOUNDARY_WRITER_HH
-
-#include <dune/fufem/boundarypatch.hh>
-
-#include <dune/fufem/hdf5/sequenceio.hh>
-
-template <class ProgramState, class GridView> class FrictionalBoundaryWriter {
-  using ScalarVector = typename ProgramState::ScalarVector;
-  using Vector = typename ProgramState::Vector;
-  using Patch = BoundaryPatch<GridView>;
-
-public:
-  FrictionalBoundaryWriter(HDF5::Grouplike &file, Vector const &vertexCoordinates,
-                           Patch const &frictionalBoundary);
-
-  template <class Friction>
-  void write(ProgramState const &programState, Friction &friction);
-
-private:
-  HDF5::Group group_;
-
-  Patch const &frictionalBoundary_;
-
-  HDF5::SequenceIO<2> frictionalBoundaryDisplacementWriter_;
-  HDF5::SequenceIO<2> frictionalBoundaryVelocityWriter_;
-  HDF5::SequenceIO<1> frictionalBoundaryStateWriter_;
-  HDF5::SequenceIO<1> frictionalBoundaryCoefficientWriter_;
-};
-#endif

src/hdf5/frictionalboundary-writer_tmpl.cc

-#include "../explicitvectors.hh"
-#include "../explicitgrid.hh"
-
-#include "../program_state.hh"
-
-using MyProgramState = ProgramState<Vector, ScalarVector>;
-using MyFriction = GlobalFriction<Matrix, Vector>;
-
-template class FrictionalBoundaryWriter<MyProgramState, GridView>;
-template void FrictionalBoundaryWriter<MyProgramState, GridView>::write(
-    MyProgramState const &programState, MyFriction &friction);

src/hdf5/iteration-writer.cc

-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include "iteration-writer.hh"
-
-IterationWriter::IterationWriter(HDF5::Grouplike &file)
-    : group_(file, "iterations"),
-      fpiSubGroup_(group_, "fixedPoint"),
-      mgSubGroup_(group_, "multiGrid"),
-      finalMGIterationWriter_(mgSubGroup_, "final"),
-      finalFPIIterationWriter_(fpiSubGroup_, "final"),
-      totalMGIterationWriter_(mgSubGroup_, "total"),
-      totalFPIIterationWriter_(fpiSubGroup_, "total") {}
-
-void IterationWriter::write(size_t timeStep,
-                            IterationRegister const &iterationCount) {
-  addEntry(finalMGIterationWriter_, timeStep,
-           iterationCount.finalCount.multigridIterations);
-  addEntry(finalFPIIterationWriter_, timeStep,
-           iterationCount.finalCount.iterations);
-  addEntry(totalMGIterationWriter_, timeStep,
-           iterationCount.totalCount.multigridIterations);
-  addEntry(totalFPIIterationWriter_, timeStep,
-           iterationCount.totalCount.iterations);
-}

src/hdf5/iteration-writer.hh

-#ifndef SRC_HDF_ITERATION_WRITER_HH
-#define SRC_HDF_ITERATION_WRITER_HH
-
-#include <dune/fufem/hdf5/sequenceio.hh>
-
-#include "../time-stepping/adaptivetimestepper.hh"
-
-class IterationWriter {
-public:
-  IterationWriter(HDF5::Grouplike &file);
-
-  void write(size_t timeStep, IterationRegister const &iterationCount);
-
-private:
-  HDF5::Group group_;
-  HDF5::Group fpiSubGroup_;
-  HDF5::Group mgSubGroup_;
-
-  HDF5::SequenceIO<0, size_t> finalMGIterationWriter_;
-  HDF5::SequenceIO<0, size_t> finalFPIIterationWriter_;
-  HDF5::SequenceIO<0, size_t> totalMGIterationWriter_;
-  HDF5::SequenceIO<0, size_t> totalFPIIterationWriter_;
-};
-#endif

src/hdf5/patchinfo-writer.cc

-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <dune/fufem/grid/hierarchic-approximation.hh>
-#include <dune/fufem/hdf5/singletonwriter.hh>
-
-#include "patchinfo-writer.hh"
-
-template <class LocalVector, class GridView>
-GridEvaluator<LocalVector, GridView>::GridEvaluator(
-    ConvexPolyhedron<LocalVector> const &weakPatch, GridView const &gridView) {
-  double const bufferWidth = 0.05 * MyGeometry::lengthScale;
-  auto const xminmax = std::minmax_element(
-      weakPatch.vertices.begin(), weakPatch.vertices.end(),
-      [](LocalVector const &a, LocalVector const &b) { return a[0] < b[0]; });
-  double const xmin = (*xminmax.first)[0] - bufferWidth;
-  double const xspan = (*xminmax.second)[0] + bufferWidth - xmin;
-
-  double const zmin = -MyGeometry::depth / 2.0;
-  double const zspan = MyGeometry::depth;
-
-  double spatialResolution = 0.01 * MyGeometry::lengthScale;
-  size_t const xsteps = std::round(xspan / spatialResolution);
-  size_t const zsteps = std::round(zspan / spatialResolution);
-
-  xCoordinates.resize(xsteps + 1);
-  for (size_t xi = 0; xi <= xsteps; xi++)
-    xCoordinates[xi] = xmin + xi * xspan / xsteps;
-  zCoordinates.resize(zsteps + 1);
-  for (size_t zi = 0; zi <= zsteps; zi++)
-    zCoordinates[zi] = zmin + zi * zspan / zsteps;
-
-  HierarchicApproximation<typename GridView::Grid, GridView> const
-      hApproximation(gridView.grid(), gridView, 1e-6 * MyGeometry::lengthScale);
-
-  LocalVector global(0);
-  localInfo.resize(xsteps + 1);
-  for (size_t xi = 0; xi < xCoordinates.size(); ++xi) {
-    localInfo[xi].resize(zsteps + 1);
-    for (size_t zi = 0; zi < zCoordinates.size(); ++zi) {
-      global[0] = xCoordinates[xi];
-      global[2] = zCoordinates[zi];
-      auto const element = hApproximation.findEntity(global);
-      localInfo[xi][zi] =
-          std::make_pair(element, element.geometry().local(global));
-    }
-  }
-}
-
-template <class LocalVector, class GridView>
-template <class Function>
-Dune::Matrix<typename Function::RangeType>
-GridEvaluator<LocalVector, GridView>::evaluate(Function const &f) const {
-  Dune::Matrix<typename Function::RangeType> ret(xCoordinates.size(),
-                                                 zCoordinates.size());
-  for (size_t xi = 0; xi < localInfo.size(); ++xi) {
-    auto const &localInfoX = localInfo[xi];
-    for (size_t zi = 0; zi < localInfoX.size(); ++zi) {
-      auto const &localInfoXZ = localInfoX[zi];
-      f.evaluateLocal(localInfoXZ.first, localInfoXZ.second, ret[xi][zi]);
-    }
-  }
-  return ret;
-}
-
-template <class ProgramState, class VertexBasis, class GridView>
-PatchInfoWriter<ProgramState, VertexBasis, GridView>::PatchInfoWriter(
-    HDF5::Grouplike &file, VertexBasis const &vertexBasis,
-    Patch const &frictionalBoundary,
-    ConvexPolyhedron<LocalVector> const &weakPatch)
-    : group_(file, "weakPatchGrid"),
-      vertexBasis_(vertexBasis),
-      gridEvaluator_(weakPatch, frictionalBoundary.gridView()),
-      weakPatchGridVelocityWriter_(
-          group_, "velocity", gridEvaluator_.xCoordinates.size(),
-          gridEvaluator_.zCoordinates.size(), Vector::block_type::dimension) {
-  HDF5::SingletonWriter<1> weakPatchGridXCoordinateWriter(
-      group_, "xCoordinates", gridEvaluator_.xCoordinates.size());
-  setEntry(weakPatchGridXCoordinateWriter, gridEvaluator_.xCoordinates);
-
-  HDF5::SingletonWriter<1> weakPatchGridZCoordinateWriter(
-      group_, "zCoordinates", gridEvaluator_.zCoordinates.size());
-  setEntry(weakPatchGridZCoordinateWriter, gridEvaluator_.zCoordinates);
-}
-
-template <class ProgramState, class VertexBasis, class GridView>
-void PatchInfoWriter<ProgramState, VertexBasis, GridView>::write(
-    ProgramState const &programState) {
-  BasisGridFunction<VertexBasis, Vector> velocity(vertexBasis_, programState.v);
-  auto const gridVelocity = gridEvaluator_.evaluate(velocity);
-  addEntry(weakPatchGridVelocityWriter_, programState.timeStep, gridVelocity);
-}
-
-#include "patchinfo-writer_tmpl.cc"

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.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/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/multi-body-problem/CMakeLists.txt

+add_custom_target(tectonic_src_multi-body-problem SOURCES
+  multi-body-problem.cfg
+  multi-body-problem-2D.cfg
+  multi-body-problem-3D.cfg
+) 
+
+set(MSW_SOURCE_FILES
+  ../../dune/tectonic/assemblers.cc
+  ../../dune/tectonic/data-structures/body/body.cc
+  ../../dune/tectonic/data-structures/network/levelcontactnetwork.cc
+  ../../dune/tectonic/data-structures/network/contactnetwork.cc
+  ../../dune/tectonic/data-structures/enumparser.cc
+  #../../dune/tectonic/factories/cantorfactory.cc
+  ../../dune/tectonic/factories/threeblocksfactory.cc
+  ../../dune/tectonic/factories/stackedblocksfactory.cc
+  #../../dune/tectonic/io/vtk.cc
+  #../../dune/tectonic/io/hdf5/frictionalboundary-writer.cc
+  #../../dune/tectonic/io/hdf5/iteration-writer.cc
+  #../../dune/tectonic/io/hdf5/patchinfo-writer.cc
+  #../../dune/tectonic/io/hdf5/restart-io.cc
+  #../../dune/tectonic/io/hdf5/surface-writer.cc
+  #../../dune/tectonic/io/hdf5/time-writer.cc
+  ../../dune/tectonic/problem-data/grid/cuboidgeometry.cc
+  ../../dune/tectonic/problem-data/grid/mygrids.cc
+  ../../dune/tectonic/problem-data/grid/simplexmanager.cc
+  ../../dune/tectonic/spatial-solving/solverfactory.cc
+  ../../dune/tectonic/spatial-solving/fixedpointiterator.cc
+  ../../dune/tectonic/time-stepping/coupledtimestepper.cc
+  ../../dune/tectonic/time-stepping/adaptivetimestepper.cc
+  ../../dune/tectonic/time-stepping/rate.cc
+  ../../dune/tectonic/time-stepping/rate/rateupdater.cc
+  ../../dune/tectonic/time-stepping/state.cc
+  multi-body-problem.cc
+)
+
+foreach(_dim 2 3)
+  set(_msw_target multi-body-problem-${_dim}D)
+
+  add_executable(${_msw_target} ${MSW_SOURCE_FILES})
+  
+  add_dune_ug_flags(${_msw_target})
+  add_dune_hdf5_flags(${_msw_target})
+
+  set_property(TARGET ${_msw_target} APPEND PROPERTY COMPILE_DEFINITIONS "MY_DIM=${_dim}")
+  #set_property(TARGET ${_msw_target} APPEND PROPERTY COMPILE_DEFINITIONS "NEW_TNNMG_COMPUTE_ITERATES_DIRECTLY=1")
+endforeach()

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

 # -*- mode:conf -*-
 [boundary.friction]
-smallestDiameter= 2e-3  # [m]
+smallestDiameter = 0.05  # 0.05 2e-3 [m]
 
 [timeSteps]
-refinementTolerance = 1e-5
+refinementTolerance = 2e-2 # 1e-5
 
 [u0.solver]
 tolerance         = 1e-8
@@ -17,5 +17,8 @@ tolerance         = 1e-8
 [v.fpi]
 tolerance         = 1e-5
 
-[solver.tnnmg.linear]
+[solver.tnnmg.preconditioner.basesolver]
+tolerance          = 1e-10
+
+[solver.tnnmg.preconditioner.patchsolver]
 tolerance          = 1e-10