src/hdf5/patchinfo-writer.hh → src/io/hdf5/patchinfo-writer.hh

@@ -8,7 +8,7 @@
 #include <dune/fufem/geometry/convexpolyhedron.hh>
 #include <dune/fufem/hdf5/sequenceio.hh>
 
-#include "../one-body-problem-data/mygeometry.hh"
+#include "../../one-body-problem-data/mygeometry.hh"
 
 template <class LocalVector, class GridView> class GridEvaluator {
   using Element = typename GridView::Grid::template Codim<0>::Entity;
@@ -36,11 +36,14 @@ class PatchInfoWriter {
 public:
   PatchInfoWriter(HDF5::Grouplike &file, VertexBasis const &vertexBasis,
                   Patch const &frictionalBoundary,
-                  ConvexPolyhedron<LocalVector> const &weakPatch);
+                  ConvexPolyhedron<LocalVector> const &weakPatch,
+                  size_t const id);
 
   void write(ProgramState const &programState);
 
 private:
+  const size_t id_;
+
   HDF5::Group group_;
 
   VertexBasis const &vertexBasis_;

src/io/hdf5/patchinfo-writer_tmpl.cc

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

src/hdf5/restart-io.cc → src/io/hdf5/restart-io.cc

@@ -5,26 +5,66 @@
 #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),
+RestartBodyIO<ProgramState>::RestartBodyIO(HDF5::Grouplike &group, const size_t vertexCount, const size_t id)
+    : id_(id),
+      displacementWriter_(group, "displacement"+std::to_string(id_), vertexCount,
+                          ProgramState::Vector::block_type::dimension),
+      velocityWriter_(group, "velocity"+std::to_string(id_), vertexCount,
+                      ProgramState::Vector::block_type::dimension),
+      accelerationWriter_(group, "acceleration"+std::to_string(id_), vertexCount,
+                          ProgramState::Vector::block_type::dimension),
+      stateWriter_(group, "state"+std::to_string(id_), vertexCount),
+      weightedNormalStressWriter_(group, "weightedNormalStress"+std::to_string(id_), vertexCount) {}
+
+template <class ProgramState>
+void RestartBodyIO<ProgramState>::write(const ProgramState& programState) {
+
+  addEntry(displacementWriter_, programState.timeStep, programState.u[id_]);
+  addEntry(velocityWriter_, programState.timeStep, programState.v[id_]);
+  addEntry(accelerationWriter_, programState.timeStep, programState.a[id_]);
+  addEntry(stateWriter_, programState.timeStep, programState.alpha[id_]);
+  addEntry(weightedNormalStressWriter_, programState.timeStep,
+           programState.weightedNormalStress[id_]);
+}
+
+template <class ProgramState>
+void RestartBodyIO<ProgramState>::read(size_t timeStep,
+                                   ProgramState& programState) {
+
+  readEntry(displacementWriter_, timeStep, programState.u[id_]);
+  readEntry(velocityWriter_, timeStep, programState.v[id_]);
+  readEntry(accelerationWriter_, timeStep, programState.a[id_]);
+  readEntry(stateWriter_, timeStep, programState.alpha[id_]);
+  readEntry(weightedNormalStressWriter_, timeStep,
+            programState.weightedNormalStress[id_]);
+}
+
+template <class ProgramState>
+RestartIO<ProgramState>::RestartIO(HDF5::Grouplike& group, const std::vector<size_t>& vertexCounts)
+    : bodyIO_(vertexCounts.size()),
       relativeTimeWriter_(group, "relativeTime"),
-      relativeTimeIncrementWriter_(group, "relativeTimeIncrement") {}
+      relativeTimeIncrementWriter_(group, "relativeTimeIncrement") {
+
+  for (size_t i=0; i<bodyIO_.size(); i++) {
+    bodyIO_[i] = new RestartBodyIO<ProgramState>(group, vertexCounts[i], i);
+  }
+}
+
+template <class ProgramState>
+RestartIO<ProgramState>::~RestartIO() {
+  for (size_t i=0; i<bodyIO_.size(); i++) {
+    delete bodyIO_[i];
+  }
+}
 
 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);
+  assert(programState.size() == bodyIO_.size());
+
+  for (size_t i=0; i<bodyIO_.size(); i++) {
+    bodyIO_[i]->write(programState);
+  }
+
   addEntry(relativeTimeWriter_, programState.timeStep,
            programState.relativeTime);
   addEntry(relativeTimeIncrementWriter_, programState.timeStep,
@@ -33,14 +73,15 @@ void RestartIO<ProgramState>::write(ProgramState const &programState) {
 
 template <class ProgramState>
 void RestartIO<ProgramState>::read(size_t timeStep,
-                                   ProgramState &programState) {
+                                   ProgramState& programState) {
+  assert(programState.size() == bodyIO_.size());
+
   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);
+
+  for (size_t i=0; i<bodyIO_.size(); i++) {
+    bodyIO_[i]->read(timeStep, programState);
+  }
+
   readEntry(relativeTimeWriter_, timeStep, programState.relativeTime);
   readEntry(relativeTimeIncrementWriter_, timeStep, programState.relativeTau);
 }

src/hdf5/restart-io.hh → src/io/hdf5/restart-io.hh

@@ -4,23 +4,37 @@
 #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;
-
+template <class ProgramState> class RestartBodyIO {
 public:
-  RestartIO(HDF5::Grouplike &group, size_t vertexCount);
+  RestartBodyIO(HDF5::Grouplike& group, const size_t vertexCount, const size_t id);
 
-  void write(ProgramState const &programState);
+  void write(const ProgramState& programState);
 
-  void read(size_t timeStep, ProgramState &programState);
+  void read(size_t timeStep, ProgramState& programState);
 
 private:
+  const size_t id_;
+
   HDF5::SequenceIO<2> displacementWriter_;
   HDF5::SequenceIO<2> velocityWriter_;
   HDF5::SequenceIO<2> accelerationWriter_;
   HDF5::SequenceIO<1> stateWriter_;
   HDF5::SequenceIO<1> weightedNormalStressWriter_;
+};
+
+template <class ProgramState> class RestartIO {
+
+public:
+  RestartIO(HDF5::Grouplike& group, const std::vector<size_t>& vertexCounts);
+  ~RestartIO();
+
+  void write(const ProgramState& programState);
+
+  void read(size_t timeStep, ProgramState& programState);
+
+private:
+  std::vector<RestartBodyIO<ProgramState>* > bodyIO_;
+
   HDF5::SequenceIO<0> relativeTimeWriter_;
   HDF5::SequenceIO<0> relativeTimeIncrementWriter_;
 };

src/hdf5/restart-io_tmpl.cc → src/io/hdf5/restart-io_tmpl.cc

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

src/hdf5/restrict.hh → src/io/hdf5/restrict.hh

@@ -5,7 +5,7 @@
 
 #include <dune/common/bitsetvector.hh>
 
-#include "../tobool.hh"
+#include "../../utils/tobool.hh"
 
 template <class Vector, class Patch>
 Vector restrictToSurface(Vector const &v1, Patch const &patch) {

src/hdf5/surface-writer.cc → src/io/hdf5/surface-writer.cc

@@ -7,8 +7,9 @@
 
 template <class ProgramState, class GridView>
 SurfaceWriter<ProgramState, GridView>::SurfaceWriter(
-    HDF5::Grouplike &file, Vector const &vertexCoordinates, Patch const &surface)
-    : group_(file, "surface"),
+    HDF5::Grouplike &file, Vector const &vertexCoordinates, Patch const &surface, size_t const id)
+    : id_(id),
+      group_(file, "surface"+std::to_string(id_)),
       surface_(surface),
       surfaceDisplacementWriter_(group_, "displacement", surface.numVertices(),
                                  Vector::block_type::dimension),
@@ -24,11 +25,12 @@ SurfaceWriter<ProgramState, GridView>::SurfaceWriter(
 template <class ProgramState, class GridView>
 void SurfaceWriter<ProgramState, GridView>::write(
     ProgramState const &programState) {
-  auto const surfaceDisplacements = restrictToSurface(programState.u, surface_);
+
+  auto const surfaceDisplacements = restrictToSurface(programState.u[id_], surface_);
   addEntry(surfaceDisplacementWriter_, programState.timeStep,
            surfaceDisplacements);
 
-  auto const surfaceVelocities = restrictToSurface(programState.v, surface_);
+  auto const surfaceVelocities = restrictToSurface(programState.v[id_], surface_);
   addEntry(surfaceVelocityWriter_, programState.timeStep, surfaceVelocities);
 }