improve coverage removing unnecessary interfaces

PierreMarchand20 · PierreMarchand20 · commit 1b08e46944cc · 2025-07-22T12:01:08.000+02:00
diff --git a/src/htool/solver/geneo/coarse_space_builder.hpp b/src/htool/solver/geneo/coarse_space_builder.hpp
diff --git a/src/htool/solver/geneo/coarse_space_dense_builder.hpp b/src/htool/solver/geneo/coarse_space_dense_builder.hpp
@@ -74,7 +74,8 @@ void declare_geneo_coarse_space_dense_builder(py::module &m, const std::string &
                  py::arg("symmetry"),
                  py::arg("uplo"),
                  py::kw_only(),
-                 py::arg("geneo_nu")); // LCOV_EXCL_STOP
+                 py::arg("geneo_nu"));
+    // LCOV_EXCL_STOP
     py_class.def(py::init([](int size_wo_overlap, int size_with_overlap, const HMatrix<CoefficientPrecision, underlying_type<CoefficientPrecision>> &Ai, py::array_t<CoefficientPrecision, py::array::f_style> Bi, char symmetry, char uplo, double geneo_threshold) {
                      Matrix<CoefficientPrecision> Bi_mat;
                      Bi_mat.assign(Bi.shape()[0], Bi.shape()[1], Bi.mutable_data(), false);
@@ -87,7 +88,8 @@ void declare_geneo_coarse_space_dense_builder(py::module &m, const std::string &
                  py::arg("symmetry"),
                  py::arg("uplo"),
                  py::kw_only(),
-                 py::arg("geneo_threshold")); // LCOV_EXCL_STOP
+                 py::arg("geneo_threshold"));
+    // LCOV_EXCL_STOP
 }
 
 template <typename CoefficientPrecision>
@@ -102,14 +104,16 @@ void declare_virtual_geneo_coarse_space_dense_builder(py::module &m, const std::
                      Bi_mat.assign(Bi.shape()[0], Bi.shape()[1], Bi.mutable_data(), false);
                      return PyGeneoCoarseSpaceDenseBuilder<CoefficientPrecision>(size_wo_overlap, size_with_overlap, Ai_mat, Bi_mat, symmetry, uplo, geneo_nu, -1);
                  }),
-                 py::arg("size_wo_overlap"), // LCOV_EXCL_START
+                 // LCOV_EXCL_START
+                 py::arg("size_wo_overlap"),
                  py::arg("size_with_overlap"),
                  py::arg("Ai"),
                  py::arg("Bi"),
                  py::arg("symmetry"),
                  py::arg("uplo"),
                  py::kw_only(),
-                 py::arg("geneo_nu")); // LCOV_EXCL_STOP
+                 py::arg("geneo_nu"));
+    // LCOV_EXCL_STOP
     py_class.def(py::init([](int size_wo_overlap, int size_with_overlap, py::array_t<CoefficientPrecision, py::array::f_style> Ai, py::array_t<CoefficientPrecision, py::array::f_style> Bi, char symmetry, char uplo, double geneo_threshold) {
                      Matrix<CoefficientPrecision> Ai_mat;
                      Ai_mat.assign(Ai.shape()[0], Ai.shape()[1], Ai.mutable_data(), false);
@@ -124,7 +128,8 @@ void declare_virtual_geneo_coarse_space_dense_builder(py::module &m, const std::
                  py::arg("symmetry"),
                  py::arg("uplo"),
                  py::kw_only(),
-                 py::arg("geneo_threshold")); // LCOV_EXCL_STOP
+                 py::arg("geneo_threshold"));
+    // LCOV_EXCL_STOP
     py_class.def("set_coarse_space", &Class::set_coarse_space);
     py_class.def_property_readonly("symmetry", &Class::get_symmetry);
     py_class.def_property_readonly("geneo_nu", &Class::get_geneo_nu);
diff --git a/src/htool/solver/interfaces/virtual_coarse_space_builder.hpp b/src/htool/solver/interfaces/virtual_coarse_space_builder.hpp
@@ -7,42 +7,70 @@
 
 namespace py = pybind11;
 
-template <typename CoefficientPrecision>
-class VirtualCoarseSpaceBuilderPython : public VirtualCoarseSpaceBuilder<CoefficientPrecision> {
+template <typename CoefficientPrecision, typename CoordinatePrecision = htool::underlying_type<CoefficientPrecision>>
+class VirtualGeneoCoarseSpaceBuilderPython : public VirtualCoarseSpaceBuilder<CoefficientPrecision> {
     py::array_t<CoefficientPrecision, py::array::f_style> m_coarse_space;
 
+    int m_size_wo_overlap;
+    int m_size_with_overlap;
+    const HMatrix<CoefficientPrecision, CoordinatePrecision> &m_local_hmatrix;
+    int m_geneo_nu                                                 = 2;
+    htool::underlying_type<CoefficientPrecision> m_geneo_threshold = -1.;
+
   public:
-    Matrix<CoefficientPrecision> build_coarse_space() {
-        compute_coarse_space();
-        if (m_coarse_space.ndim() != 2) {
-            htool::Logger::get_instance()
-                .log(LogLevel::ERROR, "Wrong dimension for coarse space matrix when building coarse space."); // LCOV_EXCL_LINE
+    int get_geneo_nu() { return this->m_geneo_nu; }
+    htool::underlying_type<CoefficientPrecision> get_geneo_threshold() { return this->m_geneo_threshold; }
+
+    explicit VirtualGeneoCoarseSpaceBuilderPython(int size_wo_overlap, int size_with_overlap, const HMatrix<CoefficientPrecision> &Ai, int geneo_nu, htool::underlying_type<CoefficientPrecision> geneo_threshold) : m_size_wo_overlap(size_wo_overlap), m_size_with_overlap(size_with_overlap), m_local_hmatrix(Ai), m_geneo_nu(geneo_nu), m_geneo_threshold(geneo_threshold) {}
+
+    Matrix<CoefficientPrecision> build_coarse_space() override {
+        std::function<py::array_t<CoefficientPrecision>(py::array_t<CoefficientPrecision>)> hmatrix_callback;
+
+        if (this->m_local_hmatrix.nb_cols() == this->m_size_with_overlap) {
+            hmatrix_callback = [this](py::array_t<CoefficientPrecision> in) {
+                std::fill(in.mutable_data() + this->m_size_wo_overlap, in.mutable_data() + this->m_size_with_overlap, CoefficientPrecision(0));
+                py::array_t<CoefficientPrecision> out(this->m_local_hmatrix.nb_rows());
+                std::fill_n(out.mutable_data(), this->m_local_hmatrix.nb_rows(), CoefficientPrecision(0));
+                add_hmatrix_vector_product('N', CoefficientPrecision(1), this->m_local_hmatrix, in.data(), CoefficientPrecision(0), out.mutable_data());
+                std::fill(out.mutable_data() + this->m_size_wo_overlap, out.mutable_data() + this->m_size_with_overlap, CoefficientPrecision(0));
+                return out;
+            };
+        } else if (this->m_local_hmatrix.nb_cols() == this->m_size_wo_overlap) {
+            hmatrix_callback = [this](py::array_t<CoefficientPrecision> in) {
+                py::array_t<CoefficientPrecision> out(in.size());
+                std::fill_n(out.mutable_data(), in.size(), CoefficientPrecision(0));
+                internal_add_hmatrix_vector_product('N', CoefficientPrecision(1), this->m_local_hmatrix, in.data(), CoefficientPrecision(0), out.mutable_data());
+                return out;
+            };
         }
 
-        Matrix<CoefficientPrecision> coarse_space(m_coarse_space.shape()[0], m_coarse_space.shape()[1]);
-        std::copy_n(m_coarse_space.data(), m_coarse_space.shape()[0] * m_coarse_space.shape()[1], coarse_space.data());
-        return coarse_space;
+        compute_coarse_space(hmatrix_callback);
+        Matrix<CoefficientPrecision> coarse_space_mat(m_coarse_space.shape()[0], m_coarse_space.shape()[1]);
+        std::copy_n(m_coarse_space.data(), m_coarse_space.shape()[0] * m_coarse_space.shape()[1], coarse_space_mat.data()); // HPDDM deletes the coarse space, so we have to copy.
+        return coarse_space_mat;
     }
 
-    // lcov does not see it because of trampoline I assume
-    virtual void compute_coarse_space() const = 0; // LCOV_EXCL_LINE
+    virtual void compute_coarse_space(std::function<py::array_t<CoefficientPrecision>(py::array_t<CoefficientPrecision>)> Ai) = 0;
 
     void set_coarse_space(py::array_t<CoefficientPrecision, py::array::f_style> coarse_space) {
         m_coarse_space = coarse_space;
     }
 };
 
-template <typename CoefficientPrecision>
-class PyVirtualCoarseSpaceBuilder : public VirtualCoarseSpaceBuilderPython<CoefficientPrecision> {
+template <typename CoefficientPrecision, typename CoordinatePrecision = CoefficientPrecision>
+class PyVirtualGeneoCoarseSpaceBuilder : public VirtualGeneoCoarseSpaceBuilderPython<CoefficientPrecision> {
+
   public:
-    using VirtualCoarseSpaceBuilderPython<CoefficientPrecision>::VirtualCoarseSpaceBuilderPython;
+    /* Inherit the constructors */
+    using VirtualGeneoCoarseSpaceBuilderPython<CoefficientPrecision>::VirtualGeneoCoarseSpaceBuilderPython;
 
     /* Trampoline (need one for each virtual function) */
-    virtual void compute_coarse_space() const override {
+    void compute_coarse_space(std::function<py::array_t<CoefficientPrecision>(py::array_t<CoefficientPrecision>)> Ai) override {
         PYBIND11_OVERRIDE_PURE(
-            void,                                                  /* Return type */
-            VirtualCoarseSpaceBuilderPython<CoefficientPrecision>, /* Parent class */
-            compute_coarse_space                                   /* Name of function in C++ (must match Python name) */
+            void,                                                       /* Return type */
+            VirtualGeneoCoarseSpaceBuilderPython<CoefficientPrecision>, /* Parent class */
+            compute_coarse_space,                                       /* Name of function in C++ (must match Python name) */
+            Ai                                                          /* Argument(s) */
         );
     }
 };
@@ -52,10 +80,28 @@ void declare_virtual_coarse_space_builder(py::module &m, const std::string &clas
     using BaseClass = VirtualCoarseSpaceBuilder<CoefficientPrecision>;
     py::class_<BaseClass>(m, base_class_name.c_str());
 
-    using Class = VirtualCoarseSpaceBuilderPython<CoefficientPrecision>;
-    py::class_<Class, BaseClass, PyVirtualCoarseSpaceBuilder<CoefficientPrecision>> py_class(m, className.c_str());
-    py_class.def(py::init<>());
-    py_class.def("compute_coarse_space", &Class::compute_coarse_space);
+    using Class = VirtualGeneoCoarseSpaceBuilderPython<CoefficientPrecision>;
+    py::class_<Class, PyVirtualGeneoCoarseSpaceBuilder<CoefficientPrecision>, VirtualCoarseSpaceBuilder<CoefficientPrecision>> py_class(m, className.c_str());
+    py_class.def(py::init([](int size_wo_overlap, int size_with_overlap, const HMatrix<CoefficientPrecision> &Ai, int geneo_nu) {
+                     return PyVirtualGeneoCoarseSpaceBuilder<CoefficientPrecision>(size_wo_overlap, size_with_overlap, Ai, geneo_nu, -1);
+                 }),
+                 py::arg("size_wo_overlap"), // LCOV_EXCL_START
+                 py::arg("size_with_overlap"),
+                 py::arg("Ai"),
+                 py::kw_only(),
+                 py::arg("geneo_nu"));
+    // LCOV_EXCL_STOP
+    py_class.def(py::init([](int size_wo_overlap, int size_with_overlap, const HMatrix<CoefficientPrecision> &Ai, double geneo_threshold) {
+                     return PyVirtualGeneoCoarseSpaceBuilder<CoefficientPrecision>(size_wo_overlap, size_with_overlap, Ai, 0, geneo_threshold);
+                 }),
+                 py::arg("size_wo_overlap"), // LCOV_EXCL_START
+                 py::arg("size_with_overlap"),
+                 py::arg("Ai"),
+                 py::kw_only(),
+                 py::arg("geneo_threshold"));
+    // LCOV_EXCL_STOP
     py_class.def("set_coarse_space", &Class::set_coarse_space);
+    py_class.def_property_readonly("geneo_nu", &Class::get_geneo_nu);
+    py_class.def_property_readonly("geneo_threshold", &Class::get_geneo_threshold);
 }
 #endif
diff --git a/tests/test_ddm_solver.py b/tests/test_ddm_solver.py
@@ -554,7 +554,6 @@ def test_ddm_solver(
                 geneo_threshold=100,
             )
         elif geneo_type == "custom_geneo_nu":
-            print("ICI")
             geneo_space_operator_builder = CustomGeneoCoarseSpaceBuilder(
                 local_size_wo_overlap,
                 local_size_with_overlap,

Original file line number	Diff line number	Diff line change
`@@ -554,7 +554,6 @@ def test_ddm_solver(`
`554`	`554`	`geneo_threshold=100,`
`555`	`555`	`)`
`556`	`556`	`elif geneo_type == "custom_geneo_nu":`
`557`		`- print("ICI")`
`558`	`557`	`geneo_space_operator_builder = CustomGeneoCoarseSpaceBuilder(`
`559`	`558`	`local_size_wo_overlap,`
`560`	`559`	`local_size_with_overlap,`