extract num rows in ml schwarz

+ format

Author: greole

CMakeLists.txt

@@ -75,7 +75,7 @@ to turn off this check")
 endif()
 
 set(GINKGO_CHECKOUT_VERSION
-   "ogl_0600_gko190"
+    "ogl_0600_gko190"
     CACHE STRING "Use specific version of ginkgo")
 
 if(OGL_DEVEL_TOOLS)
@@ -216,14 +216,14 @@ target_sources(
           src/MatrixWrapper/SparsityPattern.cpp
           src/MatrixWrapper/Distributed.cpp
           src/MatrixWrapper/Combination.cpp
-	  src/Preconditioner/CoarseSolver.cpp
+          src/Preconditioner/CoarseSolver.cpp
           src/Repartitioner.cpp
           src/Solver/CG.cpp
-	  src/Solver/PipeCG.cpp
-	  src/Solver/BiCGStab.cpp
-	  src/Solver/GMRES.cpp
-	  src/Solver/Multigrid.cpp
-	  # src/Solver/IR.cpp
+          src/Solver/PipeCG.cpp
+          src/Solver/BiCGStab.cpp
+          src/Solver/GMRES.cpp
+          src/Solver/Multigrid.cpp
+          # src/Solver/IR.cpp
 )
 
 enable_sanitizers(

include/OGL/Preconditioner/Cholesky.hpp

@@ -96,12 +96,8 @@ class Cholesky  // : public PreconditionerWrapper
 
         auto wrapper = [this](auto f) {
             if (multi_level_schwarz_) {
-                auto distmtx =
-                    gko::as<RepartDistMatrix>(mtx_)->get_dist_matrix();
-                auto local = gko::as<RepartDistMatrix>(mtx_)->get_local();
-                auto local_rows = local->get_size()[0];
-                return wrap_multi_level_schwarz(distmtx, exec_, f, d_,
-                                                local_rows, verbose_);
+                return wrap_multi_level_schwarz(
+                    mtx_, exec_, f, d_.subDict("multiLevelConfig"), verbose_);
             } else {
                 return wrap_schwarz(mtx_, exec_, std::move(f),
                                     generate_factorization());

include/OGL/Preconditioner/ISAI.hpp

@@ -64,12 +64,8 @@ class ISAI  // : public PreconditionerWrapper
     {
         auto wrapper = [this](auto f) {
             if (multi_level_schwarz_) {
-                // auto distmtx =
-                //     gko::as<RepartDistMatrix>(mtx_)->get_dist_matrix();
-                // auto local = gko::as<RepartDistMatrix>(mtx_)->get_local();
-                // auto local_rows = local->get_size()[0];
-                // return wrap_multi_level_schwarz(distmtx, exec_, f, d_,
-                //                                 local_rows, verbose_);
+                return wrap_multi_level_schwarz(
+                    mtx_, exec_, f, d_.subDict("multiLevelConfig"), verbose_);
             } else {
                 return wrap_schwarz(mtx_, exec_, std::move(f));
             }

include/OGL/Preconditioner/Jacobi.hpp

@@ -49,25 +49,13 @@ class BlockJacobi  // : public PreconditionerWrapper
                                   .on(exec_));
         };
 
-        auto wrapper = [this](auto f) {
-            if (multi_level_schwarz_) {
-                auto distmtx =
-                    gko::as<RepartDistMatrix>(mtx_)->get_dist_matrix();
-                auto local = gko::as<RepartDistMatrix>(mtx_)->get_local();
-                auto local_rows = local->get_size()[0];
-                return wrap_multi_level_schwarz(distmtx, exec_, f,
-                                                d_.subDict("multiLevelConfig"),
-                                                local_rows, verbose_);
-            } else {
-                return wrap_schwarz(mtx_, exec_, std::move(f));
-            }
-        };
-
         if (precision_ == "double") {
-            return wrapper(builder(dbj::build()));
+            return dispatch_schwarz(mtx_, exec_, builder(dbj::build()),
+                                    d_, verbose);
         }
         if (precision_ == "float") {
-            return wrapper(builder(fbj::build()));
+            return dispatch_schwarz(mtx_, exec_, builder(fbj::build()),
+                                    d_, verbose);
         }
 
         return {};

include/OGL/Preconditioner/LU.hpp

@@ -96,12 +96,8 @@ class LU  // : public PreconditionerWrapper
 
         auto wrapper = [this](auto f) {
             if (multi_level_schwarz_) {
-                auto distmtx =
-                    gko::as<RepartDistMatrix>(mtx_)->get_dist_matrix();
-                auto local = gko::as<RepartDistMatrix>(mtx_)->get_local();
-                auto local_rows = local->get_size()[0];
-                return wrap_multi_level_schwarz(distmtx, exec_, f, d_,
-                                                local_rows, verbose_);
+                return wrap_multi_level_schwarz(
+                    mtx_, exec_, f, d_.subDict("multiLevelConfig"), verbose_);
             } else {
                 return wrap_schwarz(mtx_, exec_, std::move(f),
                                     generate_factorization());

include/OGL/Preconditioner/Multigrid.hpp

@@ -37,7 +37,6 @@ class Multigrid {
     label minRowsC_;
     word smoother_;
     word coarsening_;
-    word coarseSolver_;
     label maxIterS_;
 
 public:
@@ -58,7 +57,6 @@ class Multigrid {
           minRowsC_(d.lookupOrDefault("minCoarseRows", label(64000))),
           smoother_(d.lookupOrDefault("smoother", word("Jacobi"))),
           coarsening_(d.lookupOrDefault("coarsening", word("GAMG"))),
-          coarseSolver_(d.lookupOrDefault("coarseSolver", word("Jacobi"))),
           maxIterS_(d.lookupOrDefault("maxIterSmoother", label(1)))
     {
         word msg = "\nGenerate Multigrid preconditioner:\n\tmaxLevels:" +
@@ -68,7 +66,6 @@ class Multigrid {
                    "\n\trelaxationFactor: " + std::to_string(relaxFac_) +
                    "\n\tmaxIterSmoother: " + std::to_string(maxIterS_) +
                    "\n\tcoarsening: " + coarsening_ +
-                   "\n\tcoarseSolver: " + coarseSolver_ +
                    "\n\tcycle: " + cycleName_ + "\n\ttype: " + type_;
         MLOG_0(verbose_, msg)
         // FatalErrorInFunction << "Unknown Multigrid type: " << type

include/OGL/Preconditioner/Schwarz.hpp

@@ -45,10 +45,9 @@ std::shared_ptr<gko::LinOp> wrap_schwarz(
 
 template <typename PrecondFactory>
 std::shared_ptr<gko::LinOp> wrap_multi_level_schwarz(
-    std::shared_ptr<const gko::LinOp> gkomatrix,
+    std::shared_ptr<const gko::LinOp> mtx,
     std::shared_ptr<gko::Executor> device_exec,
-    std::shared_ptr<PrecondFactory> precond, const dictionary &d,
-    label local_rows, label verbose)
+    std::shared_ptr<PrecondFactory> precond, const dictionary &d, label verbose)
 {
     using pgm = gko::multigrid::Pgm<scalar, label>;
     using fc = gko::multigrid::FixedCoarsening<scalar, label>;
@@ -58,6 +57,10 @@ std::shared_ptr<gko::LinOp> wrap_multi_level_schwarz(
         gko::experimental::distributed::preconditioner::Schwarz<scalar, label,
                                                                 label>;
 
+    auto distmtx = gko::as<RepartDistMatrix>(mtx)->get_dist_matrix();
+    auto local_rows =
+        gko::as<RepartDistMatrix>(mtx)->get_local()->get_size()[0];
+
     auto coarse_solver = generate_coarse_solver(device_exec, d, verbose);
     auto coarsening = d.lookupOrDefault<word>("coarsening", word("PGM"));
     auto coarseWeight = d.lookupOrDefault("coarseWeight", scalar(0.1));
@@ -80,20 +83,19 @@ std::shared_ptr<gko::LinOp> wrap_multi_level_schwarz(
         for (auto i = 0; i < sel_rows.get_size(); i++) {
             sel_rows.get_data()[i] = selCoarseRows * i;
         }
-
         sel_rows.set_executor(device_exec);
-        auto pgm_fac = gko::share(
+        auto coarsening_fac = gko::share(
             fc::build().with_skip_sorting(true).with_coarse_rows(sel_rows).on(
                 device_exec));
 
         return gko::share(ras::build()
                               .with_local_solver(precond)
-                              .with_coarse_level(pgm_fac)
+                              .with_coarse_level(coarsening_fac)
                               .with_l1_smoother(false)
                               .with_coarse_solver(coarse_solver)
                               .with_coarse_weight(coarseWeight)
                               .on(device_exec)
-                              ->generate(gkomatrix));
+                              ->generate(distmtx));
     }
     if (coarsening == "PGM") {
         word msg =
@@ -110,7 +112,21 @@ std::shared_ptr<gko::LinOp> wrap_multi_level_schwarz(
                               .with_coarse_weight(coarseWeight)
                               .with_coarse_solver(coarse_solver)
                               .on(device_exec)
-                              ->generate(gkomatrix));
+                              ->generate(distmtx));
+    }
+}
+
+
+template <typename PrecondFactory>
+std::shared_ptr<gko::LinOp> dispatch_schwarz(
+    std::shared_ptr<const gko::LinOp> mtx, std::shared_ptr<gko::Executor> exec,
+    std::shared_ptr<PrecondFactory> precond, const dictionary &d, label verbose)
+{
+    if (d.lookupOrDefault<Switch>("multiLevelSchwarz", false)) {
+        return wrap_multi_level_schwarz(mtx, exec, precond,
+                                        d.subDict("multiLevelConfig"), verbose);
+    } else {
+        return wrap_schwarz(mtx, exec, std::move(precond));
     }
 }