.

src/solverfactorytest.cc

@@ -164,7 +164,7 @@ void solveProblem(const ContactNetwork& contactNetwork,
     using Step = Dune::TNNMG::TNNMGStep<ContactFunctional, BitVector, Linearization, DefectProjection, LocalSolver, ContactNetwork>;
 
     // set multigrid solver
-    auto smoother = TruncatedBlockGSStep<Matrix, Vector>{};
+    auto smoother = TruncatedBlockGSStep<Matrix, Vector>();
 
     using TransferOperator = NBodyContactTransfer<ContactNetwork, Vector>;
     using TransferOperators = std::vector<std::shared_ptr<TransferOperator>>;
@@ -284,7 +284,7 @@ void solveProblem(const ContactNetwork& contactNetwork,
     //Norm mgNorm(*linearMultigridStep);
     //auto mgSolver = std::make_shared<Solver>(linearMultigridStep, parset.get<size_t>("solver.tnnmg.linear.maximumIterations"), parset.get<double>("solver.tnnmg.linear.tolerance"), mgNorm, Solver::QUIET);
     Norm mgNorm(*cgStep);
-    auto mgSolver = std::make_shared<Solver>(cgStep, parset.get<size_t>("solver.tnnmg.linear.maximumIterations"), parset.get<double>("solver.tnnmg.linear.tolerance"), mgNorm, Solver::QUIET);
+    auto mgSolver = std::make_shared<Solver>(cgStep, parset.get<int>("solver.tnnmg.main.multi"), parset.get<double>("solver.tnnmg.linear.tolerance"), mgNorm, Solver::QUIET);
 
     using Factory = SolverFactory<MyFunctional, BitVector, ContactNetwork>;
     Factory factory(parset.sub("solver.tnnmg"), J, *mgSolver, ignore, contactNetwork);

src/spatial-solving/preconditioners/levelpatchpreconditioner.hh

@@ -184,38 +184,39 @@ class LevelPatchPreconditioner : public LinearIterationStep<MatrixType, VectorTy
         for (const auto& p : patches_) {
             x = 0;
 
-            /*
+            auto ignore = this->ignore();
+            for (size_t i=0; i<ignore.size(); i++) {
+                for (size_t d=0; d<dim; d++) {
+                   if (p[i][d])
+                       ignore[i][d] = true;
+                }
+            }
+
             auto& step = patchSolver_->getIterationStep();
             dynamic_cast<LinearIterationStep<MatrixType, VectorType>&>(step).setProblem(*this->mat_, x, *this->rhs_);
-            step.setIgnore(p);
+            step.setIgnore(ignore);
 
             patchSolver_->check();
             patchSolver_->preprocess();
             patchSolver_->solve();
 
-            *(this->x_) += step.getSol();*/
+            *(this->x_) += x;
+
 
-            auto ignore = this->ignore();
-            for (size_t i=0; i<ignore.size(); i++) {
-                for (size_t d=0; d<dim; d++) {
-                   if (p[i][d])
-                       ignore[i][d] = true;
-                }
-            }
 
-            LocalProblem<MatrixType, VectorType> localProblem(*this->mat_, *this->rhs_, ignore);
+            /*LocalProblem<MatrixType, VectorType> localProblem(*this->mat_, *this->rhs_, ignore);
             Vector newR;
-            localProblem.getLocalRhs(x, newR);
+            localProblem.getLocalRhs(x, newR); */
 
             /*print(ignore, "ignore:");
             print(*this->mat_, "Mat:");
             print(localProblem.getMat(), "localMat:");*/
 
-            patchSolver_->setProblem(localProblem.getMat(), x, newR);
+            /*patchSolver_->setProblem(localProblem.getMat(), x, newR);
             patchSolver_->preprocess();
             patchSolver_->solve();
 
-            *(this->x_) += x;
+            *(this->x_) += x;*/
         }
     }
 

src/spatial-solving/preconditioners/multilevelpatchpreconditioner.hh

@@ -15,6 +15,7 @@
 //#include <dune/solvers/iterationsteps/blockgsstep.hh>
 #include <dune/solvers/iterationsteps/cgstep.hh>
 #include <dune/solvers/iterationsteps/lineariterationstep.hh>
+#include <dune/solvers/iterationsteps/truncatedblockgsstep.hh>
 
 #include "nbodycontacttransfer.hh"
 #include "levelpatchpreconditioner.hh"
@@ -29,8 +30,8 @@ class MultilevelPatchPreconditioner : public LinearIterationStep<MatrixType, Vec
 private:
     using Base = LinearIterationStep<MatrixType, VectorType>;
 
-    //using PatchSolver = typename Dune::Solvers::LoopSolver<Vector, BitVector>;
-    using PatchSolver = Dune::Solvers::UMFPackSolver<MatrixType, VectorType>;
+    using PatchSolver = typename Dune::Solvers::LoopSolver<Vector, BitVector>;
+    //using PatchSolver = Dune::Solvers::UMFPackSolver<MatrixType, VectorType>;
 
     using LevelContactNetwork = typename ContactNetwork::LevelContactNetwork;
     using LevelPatchPreconditioner = LevelPatchPreconditioner<LevelContactNetwork, PatchSolver, MatrixType, VectorType>;
@@ -104,27 +105,27 @@ class MultilevelPatchPreconditioner : public LinearIterationStep<MatrixType, Vec
         levelItSteps_.resize(size());
         levelErrorNorms_.resize(size());
         //auto coarseStep =
-        levelItSteps_[0] = Dune::Solvers::BlockGSStepFactory<MatrixType, VectorType>::createPtr(Dune::Solvers::BlockGS::LocalSolvers::direct(0.0));
+        levelItSteps_[0] = std::make_shared<TruncatedBlockGSStep<MatrixType, VectorType>>();//Dune::Solvers::BlockGSStepFactory<MatrixType, VectorType>::createPtr(Dune::Solvers::BlockGS::LocalSolvers::direct(0.0));
         levelErrorNorms_[0] = std::make_shared<EnergyNorm<MatrixType, VectorType>>(*levelItSteps_[0].get());
-        levelSolvers_[0] = /*std::make_shared<PatchSolver>(*levelItSteps_[0].get(),
+        levelSolvers_[0] = std::make_shared<PatchSolver>(*levelItSteps_[0].get(),
                                    parset.get<size_t>("maximumIterations"),
                                    parset.get<double>("tolerance"),
                                    *levelErrorNorms_[0].get(),
                                    parset.get<Solver::VerbosityMode>("verbosity"),
-                                   false); // absolute error */
-                std::make_shared<PatchSolver>();
+                                   false); // absolute error
+                //std::make_shared<PatchSolver>();
 
         for (size_t i=1; i<levelSolvers_.size(); i++) {
             //auto gsStep = Dune::Solvers::BlockGSStepFactory<MatrixType, VectorType>::create(Dune::Solvers::BlockGS::LocalSolvers::direct(0.0));
-            levelItSteps_[i] = Dune::Solvers::BlockGSStepFactory<MatrixType, VectorType>::createPtr(Dune::Solvers::BlockGS::LocalSolvers::direct(0.0));
+            levelItSteps_[i] = std::make_shared<TruncatedBlockGSStep<MatrixType, VectorType>>(); //Dune::Solvers::BlockGSStepFactory<MatrixType, VectorType>::createPtr(Dune::Solvers::BlockGS::LocalSolvers::direct(0.0));
             levelErrorNorms_[i] = std::make_shared<EnergyNorm<MatrixType, VectorType>>(*levelItSteps_[i].get());
-            levelSolvers_[i] = /*std::make_shared<PatchSolver>(*levelItSteps_[i].get(),
+            levelSolvers_[i] = std::make_shared<PatchSolver>(*levelItSteps_[i].get(),
                                        parset.get<size_t>("maximumIterations"),
                                        parset.get<double>("tolerance"),
                                        *levelErrorNorms_[i].get(),
                                        parset.get<Solver::VerbosityMode>("verbosity"),
-                                       false); // absolute error*/
-                    std::make_shared<PatchSolver>();
+                                       false); // absolute error
+                    //std::make_shared<PatchSolver>();
             levelPatchPreconditioners_[i]->setPatchSolver(levelSolvers_[i]);
         }
 
@@ -257,11 +258,6 @@ class MultilevelPatchPreconditioner : public LinearIterationStep<MatrixType, Vec
         for (int i=levelPatchPreconditioners_.size()-2; i>0; i--) {
             const auto& transfer = *mgTransfer_[i];
 
-            /*print(levelX_[i+1], "levelX_:");
-            print(levelX_[i], "levelX_:");
-            print(levelRhs_[i+1], "levelRhs_:");
-            print(levelRhs_[i], "levelRhs_:");*/
-
             transfer.restrict(levelX_[i+1], levelX_[i]);
             transfer.restrict(levelRhs_[i+1], levelRhs_[i]);
         }
@@ -279,16 +275,13 @@ class MultilevelPatchPreconditioner : public LinearIterationStep<MatrixType, Vec
     }
 
     void iterateAdd() {
-        //print(this->ignore(), "ignore: ");
-
         *(this->x_) = 0;	
 
         VectorType x;
 
-        /*
         // solve coarse global problem
         auto& coarseSolver = levelSolvers_[0];
-        //coarseSolver->getIterationStep().setIgnore(ignoreHierarchy_[0]);
+        coarseSolver->getIterationStep().setIgnore(ignoreHierarchy_[0]);
 
         dynamic_cast<LinearIterationStep<MatrixType, VectorType>&>(levelSolvers_[0]->getIterationStep()).setProblem(levelMat_[0], levelX_[0], levelRhs_[0]);
 
@@ -296,10 +289,10 @@ class MultilevelPatchPreconditioner : public LinearIterationStep<MatrixType, Vec
         coarseSolver->preprocess();
         coarseSolver->solve();
 
-        mgTransfer_[0]->prolong(coarseSolver->getIterationStep().getSol(), x); */
+        mgTransfer_[0]->prolong(levelX_[0], x);
 
 
-        BitVector emptyIgnore0(levelX_[0].size(), false);
+       /* BitVector emptyIgnore0(levelX_[0].size(), false);
         LocalProblem<MatrixType, VectorType> localProblem(levelMat_[0], levelRhs_[0], ignoreHierarchy_[0]);
         Vector newR;
         localProblem.getLocalRhs(levelX_[0], newR);
@@ -309,7 +302,7 @@ class MultilevelPatchPreconditioner : public LinearIterationStep<MatrixType, Vec
         coarseSolver->preprocess();
         coarseSolver->solve();
 
-        mgTransfer_[0]->prolong(levelX_[0], x);
+        mgTransfer_[0]->prolong(levelX_[0], x);*/
 
         //print(levelX_[0], "MultilevelPatchPreconditioner: levelX_[0]");
         //print(x, "MultilevelPatchPreconditioner: x0");