Adjust to upstream changes

linelast.cc

@@ -27,7 +27,7 @@
 #ifdef HAVE_IPOPT
 #include <dune/solvers/solvers/quadraticipopt.hh>
 #endif
-#include <dune/solvers/iterationsteps/blockgsstep.hh>
+#include <dune/solvers/iterationsteps/blockgssteps.hh>
 #include <dune/solvers/iterationsteps/multigridstep.hh>
 #include <dune/solvers/transferoperators/compressedmultigridtransfer.hh>
 #include <dune/solvers/solvers/loopsolver.hh>
@@ -182,48 +182,49 @@ int main (int argc, char *argv[]) try
 #if !defined HAVE_IPOPT
 #error You need to have IPOpt installed if you want to use it as the base solver!
 #endif
-        QuadraticIPOptSolver<OperatorType,VectorType> baseSolver;
-        baseSolver.tolerance_ = baseTolerance;
-        baseSolver.verbosity_ = Solver::QUIET;
+        QuadraticIPOptSolver<OperatorType,VectorType> baseSolver(baseTolerance, 100, Solver::QUIET);
 
 #else // Gauss-Seidel is the base solver
 
-        BlockGSStep<OperatorType, VectorType> baseSolverStep;
+        auto baseSolverStep = Dune::Solvers::BlockGSStepFactory<OperatorType, VectorType>::create(
+               Dune::Solvers::BlockGS::LocalSolvers::direct(0.0));
+
 
         EnergyNorm<OperatorType,VectorType> baseEnergyNorm(baseSolverStep);
 
-        LoopSolver<VectorType> baseSolver(&baseSolverStep,
+        LoopSolver<VectorType> baseSolver(baseSolverStep,
                                                baseIt,
                                                baseTolerance,
-                                               &baseEnergyNorm,
+                                               baseEnergyNorm,
                                                Solver::QUIET);
 #endif
 
         // Make pre and postsmoothers
-        BlockGSStep<OperatorType, VectorType> presmoother;
-        BlockGSStep<OperatorType, VectorType> postsmoother;
-
+        auto presmoother = Dune::Solvers::BlockGSStepFactory<OperatorType, VectorType>::create(
+               Dune::Solvers::BlockGS::LocalSolvers::direct(0.0));
+        auto postsmoother = Dune::Solvers::BlockGSStepFactory<OperatorType, VectorType>::create(
+               Dune::Solvers::BlockGS::LocalSolvers::direct(0.0));
 
         MultigridStep<OperatorType, VectorType> multigridStep(stiffnessMatrix, x, rhs);
 
         multigridStep.setMGType(mu, nu1, nu2);
-        multigridStep.ignoreNodes_    = &dirichletNodes;
-        multigridStep.basesolver_     = &baseSolver;
+        multigridStep.setIgnore(dirichletNodes);
+        multigridStep.setBaseSolver(baseSolver);
         multigridStep.setSmoother(&presmoother,&postsmoother);
 
-        std::vector<CompressedMultigridTransfer<VectorType>* > mgTransfers(grid->maxLevel());
+        std::vector<std::shared_ptr<CompressedMultigridTransfer<VectorType> > > mgTransfers(grid->maxLevel());
         for (size_t i=0; i<mgTransfers.size(); i++) {
-            mgTransfers[i] = new CompressedMultigridTransfer<VectorType>;
+            mgTransfers[i] = std::make_shared<CompressedMultigridTransfer<VectorType> >();
             mgTransfers[i]->setup(*grid, i, i+1);
         }
 
         multigridStep.setTransferOperators(mgTransfers);
         EnergyNorm<OperatorType, VectorType> energyNorm(multigridStep);
 
-        LoopSolver<VectorType> solver(&multigridStep,
+        LoopSolver<VectorType> solver(multigridStep,
                                       numIt,
                                       tolerance,
-                                      &energyNorm,
+                                      energyNorm,
                                       Solver::FULL);
 
 

viscoelast.cc

@@ -10,7 +10,7 @@
 
 #include <dune/istl/io.hh>
 
-#include <dune/solvers/iterationsteps/blockgsstep.hh>
+#include <dune/solvers/iterationsteps/blockgssteps.hh>
 #include <dune/solvers/iterationsteps/multigridstep.hh>
 #include <dune/solvers/transferoperators/compressedmultigridtransfer.hh>
 #include <dune/solvers/norms/energynorm.hh>
@@ -177,24 +177,23 @@ int main (int argc, char *argv[]) try {
     // ///////////////////////////
 
     // First create a base solver
-    BlockGSStep<MatrixType, VectorType> baseSolverStep;
+    auto baseSolverStep = Dune::Solvers::BlockGSStepFactory<MatrixType, VectorType>::create(
+               Dune::Solvers::BlockGS::LocalSolvers::direct(0.0));
 
     EnergyNorm<MatrixType, VectorType> baseEnergyNorm(baseSolverStep);
 
-    ::LoopSolver<VectorType> baseSolver(&baseSolverStep,
+    ::LoopSolver<VectorType> baseSolver(baseSolverStep,
             baseIt,
             baseTolerance,
-            &baseEnergyNorm,
+            baseEnergyNorm,
             Solver::QUIET);
 
-    baseSolver.verbosity_ = Solver::QUIET;
-    baseSolver.tolerance_ = baseTolerance;
-
     // Make pre and postsmoothers
-    BlockGSStep<MatrixType, VectorType> presmoother;
-    BlockGSStep<MatrixType, VectorType> postsmoother;
-
 
+    auto presmoother = Dune::Solvers::BlockGSStepFactory<MatrixType, VectorType>::create(
+               Dune::Solvers::BlockGS::LocalSolvers::direct(0.0));
+    auto postsmoother = Dune::Solvers::BlockGSStepFactory<MatrixType, VectorType>::create(
+               Dune::Solvers::BlockGS::LocalSolvers::direct(0.0));
 
     //FEM leads to:
     //Quasistatic equation of the form : N*D'(t)+K*D(t)=rhs(t)  N viscous_stiffness  K elastic_stiffness D displacement
@@ -215,23 +214,23 @@ int main (int argc, char *argv[]) try {
         MultigridStep<MatrixType, VectorType> multigridStep(lgs, x, erhs);
 
         multigridStep.setMGType(mu, nu1, nu2);
-        multigridStep.ignoreNodes_    = &dirichletNodes;
-        multigridStep.basesolver_     = &baseSolver;
+        multigridStep.setIgnore(dirichletNodes);
+        multigridStep.setBaseSolver(baseSolver);
         multigridStep.setSmoother(&presmoother,&postsmoother);
 
-        std::vector<CompressedMultigridTransfer<VectorType>* > transfers(grid->maxLevel());
+        std::vector<std::shared_ptr<CompressedMultigridTransfer<VectorType> > > transfers(grid->maxLevel());
         for (size_t i=0; i<transfers.size(); i++) {
-            transfers[i] = new CompressedMultigridTransfer<VectorType>;
+            transfers[i] = std::make_shared<CompressedMultigridTransfer<VectorType> >();
             transfers[i]->setup(*grid, i, i+1);
         }
         multigridStep.setTransferOperators(transfers);
 
         EnergyNorm<MatrixType, VectorType> energyNorm(multigridStep);
 
-        ::LoopSolver<VectorType> solver(&multigridStep,
+        ::LoopSolver<VectorType> solver(multigridStep,
                 numIt,
                 tolerance,
-                &energyNorm,
+                energyNorm,
                 Solver::FULL);
 
         solver.preprocess();