.

src/multi-body-problem.cc

@@ -485,6 +485,7 @@ int main(int argc, char *argv[]) {
 
     using MyUpdater = Updaters<RateUpdater<Vector, Matrix, Function, dims>,
                                StateUpdater<ScalarVector, Vector>>;
+    /*
     MyUpdater current(
         initRateUpdater(parset.get<Config::scheme>("timeSteps.scheme"),
                         velocityDirichletFunction, dirichletNodes, matrices,
@@ -494,6 +495,7 @@ int main(int argc, char *argv[]) {
             programState.alpha, *frictionalBoundary.getVertices(),
             parset.get<double>("boundary.friction.L"),
             parset.get<double>("boundary.friction.V0")));
+   */
 
     auto const refinementTolerance =
         parset.get<double>("timeSteps.refinementTolerance");

src/spatial-solving/fixedpointiterator.cc

@@ -4,7 +4,8 @@
 
 #include <dune/common/exceptions.hh>
 
-#include <dune/solvers/common/arithmetic.hh>
+#include <dune/matrix-vector/axpy.hh>
+
 #include <dune/solvers/norms/energynorm.hh>
 #include <dune/solvers/solvers/loopsolver.hh>
 
@@ -53,7 +54,7 @@ FixedPointIterator<Factory, Updaters, ErrorNorm>::run(
     Updaters updaters, const std::vector<Matrix>& velocityMatrices, const std::vector<Vector>& velocityRHSs,
     std::vector<Vector>& velocityIterates) {
 
-  EnergyNorm<Matrix, Vector> energyNorm(velocityMatrix);
+  //EnergyNorm<Matrix, Vector> energyNorm(velocityMatrix);
   LoopSolver<Vector> velocityProblemSolver(step_.get(), velocityMaxIterations_,
                                            velocityTolerance_, &energyNorm,
                                            verbosity_, false); // absolute error
@@ -66,10 +67,10 @@ FixedPointIterator<Factory, Updaters, ErrorNorm>::run(
        ++fixedPointIteration) {
     // solve a velocity problem
    // globalFriction_->updateAlpha(alpha);
-    ConvexProblem convexProblem(1.0, velocityMatrix, *globalFriction_,
-                                velocityRHS, velocityIterate);
-    BlockProblem velocityProblem(parset_, convexProblem);
-    step_->setProblem(velocityIterate, velocityProblem);
+    //ConvexProblem convexProblem(1.0, velocityMatrix, *globalFriction_,
+    //                            velocityRHSs, velocityIterate);
+    //BlockProblem velocityProblem(parset_, convexProblem);
+    //step_->setProblem(velocityIterate, velocityProblem);
     //step_->setProblem(velocityIterate);
     velocityProblemSolver.preprocess();
     velocityProblemSolver.solve();
@@ -81,7 +82,7 @@ FixedPointIterator<Factory, Updaters, ErrorNorm>::run(
 
     for (size_t i=0; i<v_m.size(); i++) {
       v_m[i] *= 1.0 - lambda_;
-      //Arithmetic::addProduct(v_m[i], lambda_, velocityIterate[i]);
+      Dune::MatrixVector::addProduct(v_m[i], lambda_, velocityIterates[i]);
     }
 
     // compute relative velocities on contact boundaries
@@ -102,7 +103,7 @@ FixedPointIterator<Factory, Updaters, ErrorNorm>::run(
   if (fixedPointIteration == fixedPointMaxIterations_)
     DUNE_THROW(Dune::Exception, "FPI failed to converge");
 
-  updaters.rate_->postProcess(velocityIterate);
+  updaters.rate_->postProcess(velocityIterates);
 
   // Cannot use return { fixedPointIteration, multigridIterations };
   // with gcc 4.9.2, see also http://stackoverflow.com/a/37777814/179927
@@ -121,6 +122,7 @@ std::ostream &operator<<(std::ostream &stream,
 template <class Factory, class Updaters, class ErrorNorm>
 void FixedPointIterator<Factory, Updaters, ErrorNorm>::relativeVelocities(std::vector<Vector>& v_m) const {
   // needs assemblers to obtain basis
+    /*
   std::vector<std::shared_ptr<MyAssembler>> assemblers(bodyCount);
 
   using field_type = typename Factory::Matrix::field_type;
@@ -145,6 +147,7 @@ void FixedPointIterator<Factory, Updaters, ErrorNorm>::relativeVelocities(std::v
   for (size_t i=0; i<gridFunctions.size(); i++) {
     gridFunctions[i] = new BasisGridFunction<MyAssembler::VertexBasis, Vector>(assemblers[i]->vertexBasis, v_m[i]);
   }
+ */
 
   /*
   for (size_t i=0; i<nBodyAssembler_.nCouplings(); i++) {

src/spatial-solving/fixedpointiterator.hh

@@ -25,9 +25,8 @@ class FixedPointIterator {
   using ScalarVector = typename Updaters::StateUpdater::ScalarVector;
   using Vector = typename Factory::Vector;
   using Matrix = typename Factory::Matrix;
-  using ConvexProblem = typename Factory::ConvexProblem;
-  using BlockProblem = typename Factory::BlockProblem;
-  using Nonlinearity = typename ConvexProblem::NonlinearityType;
+
+ // using Nonlinearity = typename ConvexProblem::NonlinearityType;
 
   using DeformedGrid = typename Factory::DeformedGrid;
 
@@ -40,9 +39,9 @@ class FixedPointIterator {
                      const ErrorNorm& errorNorm);
 
   FixedPointIterationCounter run(Updaters updaters,
-                                 Matrix const &velocityMatrix,
-                                 Vector const &velocityRHS,
-                                 Vector &velocityIterate);
+                                 const std::vector<Matrix>& velocityMatrices,
+                                 const std::vector<Vector>& velocityRHSs,
+                                 std::vector<Vector>& velocityIterates);
 
 private:
 

src/spatial-solving/fixedpointiterator_tmpl.cc

@@ -21,10 +21,8 @@
 #include "solverfactory.hh"
 
 using Function = Dune::VirtualFunction<double, double>;
-using Factory = SolverFactory<
-    MY_DIM,
-    MyBlockProblem<ConvexProblem<GlobalFriction<Matrix, Vector>, Matrix>>,
-    DeformedGrid>;
+using Factory = SolverFactory<DeformedGrid, Matrix, Vector>;
+
 using MyStateUpdater = StateUpdater<ScalarVector, Vector>;
 using MyRateUpdater = RateUpdater<Vector, Matrix, Function, MY_DIM>;
 using MyUpdaters = Updaters<MyRateUpdater, MyStateUpdater>;