improve testing, coverage and fix examples

PierreMarchand20 · PierreMarchand20 · commit 47108fdd815a · 2025-07-22T17:47:33.000+02:00
diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
@@ -137,10 +137,11 @@ jobs:
       - name: Run tests
         run: |
           export PYTHONPATH="$PWD/build"
-          mpirun -np 1 ${{ matrix.MPIEXEC_PREFLAGS }} python3 -m pytest tests
-          mpirun -np 2 ${{ matrix.MPIEXEC_PREFLAGS }} python3 -m pytest tests
-          mpirun -np 3 ${{ matrix.MPIEXEC_PREFLAGS }} python3 -m pytest tests
-          mpirun -np 4 ${{ matrix.MPIEXEC_PREFLAGS }} python3 -m pytest tests
+          mpirun -np 1 ${{ matrix.MPIEXEC_PREFLAGS }} python3 -m pytest tests --ignore=tests/test_hmatrix.py
+          mpirun -np 2 ${{ matrix.MPIEXEC_PREFLAGS }} python3 -m pytest tests --ignore=tests/test_hmatrix.py
+          mpirun -np 3 ${{ matrix.MPIEXEC_PREFLAGS }} python3 -m pytest tests --ignore=tests/test_hmatrix.py
+          mpirun -np 4 ${{ matrix.MPIEXEC_PREFLAGS }} python3 -m pytest tests --ignore=tests/test_hmatrix.py
+          python3 -m pytest tests/test_hmatrix.py
 
       - name: Check format
         if: matrix.CODE_COVERAGE == 'ON'
diff --git a/example/use_block_jacobi_solver.py b/example/use_block_jacobi_solver.py
@@ -11,7 +11,7 @@
 logging.basicConfig(level=logging.INFO)
 
 # Random geometry
-size = 500
+size = 1000
 dimension = 3
 
 [points, _] = create_random_geometries(dimension, size, size)
@@ -20,12 +20,12 @@
 # Htool parameters
 eta = 10
 epsilon = 1e-3
-minclustersize = 10
+maximal_leaf_size = 10
 number_of_children = 2
 
 # Build clusters
 cluster_builder = Htool.ClusterTreeBuilder()
-cluster_builder.set_minclustersize(minclustersize)
+cluster_builder.set_maximal_leaf_size(maximal_leaf_size)
 cluster: Htool.Cluster = cluster_builder.create_cluster_tree(
     points, number_of_children, mpi4py.MPI.COMM_WORLD.size
 )
diff --git a/example/use_cluster_with_given_partition.py b/example/use_cluster_with_given_partition.py
@@ -13,12 +13,12 @@
 
 
 # Parameters
-minclustersize = 10
+maximal_leaf_size = 10
 number_of_children = 2
 
 # Build clusters
 cluster_builder = Htool.ClusterTreeBuilder()
-cluster_builder.set_minclustersize(minclustersize)
+cluster_builder.set_maximal_leaf_size(maximal_leaf_size)
 
 target_cluster: Htool.Cluster = cluster_builder.create_cluster_tree(
     target_points,
diff --git a/example/use_custom_dense_block_generator.py b/example/use_custom_dense_block_generator.py
@@ -19,12 +19,12 @@
 # Htool parameters
 eta = 10
 epsilon = 1e-3
-minclustersize = 10
+maximal_leaf_size = 10
 number_of_children = 2
 
 # Build clusters
 cluster_builder = Htool.ClusterTreeBuilder()
-cluster_builder.set_minclustersize(minclustersize)
+cluster_builder.set_maximal_leaf_size(maximal_leaf_size)
 target_cluster: Htool.Cluster = cluster_builder.create_cluster_tree(
     points, number_of_children, mpi4py.MPI.COMM_WORLD.size
 )
diff --git a/example/use_custom_local_operator.py b/example/use_custom_local_operator.py
@@ -15,12 +15,12 @@
 
 
 # Htool parameters
-minclustersize = 10
+maximal_leaf_size = 10
 number_of_children = 2
 
 # Build clusters
 cluster_builder = Htool.ClusterTreeBuilder()
-cluster_builder.set_minclustersize(minclustersize)
+cluster_builder.set_maximal_leaf_size(maximal_leaf_size)
 target_cluster: Htool.Cluster = cluster_builder.create_cluster_tree(
     target_points,
     number_of_children,
diff --git a/example/use_custom_low_rank_approximation.py b/example/use_custom_low_rank_approximation.py
@@ -22,12 +22,12 @@
 # Htool parameters
 eta = 100
 epsilon = 1e-3
-minclustersize = 10
+maximal_leaf_size = 10
 number_of_children = 2
 
 # Build clusters
 cluster_builder = Htool.ClusterTreeBuilder()
-cluster_builder.set_minclustersize(minclustersize)
+cluster_builder.set_maximal_leaf_size(maximal_leaf_size)
 target_cluster: Htool.Cluster = cluster_builder.create_cluster_tree(
     target_points,
     number_of_children,
diff --git a/example/use_hmatrix_compression.py b/example/use_hmatrix_compression.py
@@ -21,12 +21,12 @@
 # Htool parameters
 eta = 10
 epsilon = 1e-3
-minclustersize = 10
+maximal_leaf_size = 10
 number_of_children = 2
 
 # Build clusters
 cluster_tree_builder = Htool.ClusterTreeBuilder()
-cluster_tree_builder.set_minclustersize(minclustersize)
+cluster_tree_builder.set_maximal_leaf_size(maximal_leaf_size)
 target_cluster: Htool.Cluster = cluster_tree_builder.create_cluster_tree(
     target_points,
     number_of_children,
diff --git a/example/use_local_hmatrix_compression.py b/example/use_local_hmatrix_compression.py
@@ -25,12 +25,12 @@
 # Htool parameters
 eta = 10
 epsilon = 1e-3
-minclustersize = 10
+maximal_leaf_size = 10
 number_of_children = 2
 
 # Build clusters
 cluster_builder = Htool.ClusterTreeBuilder()
-cluster_builder.set_minclustersize(minclustersize)
+cluster_builder.set_maximal_leaf_size(maximal_leaf_size)
 target_cluster: Htool.Cluster = cluster_builder.create_cluster_tree(
     target_points,
     number_of_children,
@@ -65,10 +65,7 @@
     generator,
     target_cluster,
     source_cluster,
-    epsilon,
-    eta,
-    "N",
-    "N",
+    Htool.HMatrixTreeBuilder(epsilon, eta, "N", "N"),
     mpi4py.MPI.COMM_WORLD,
 )
 distributed_operator = default_local_approximation.distributed_operator
@@ -91,7 +88,7 @@
 off_diagonal_partition[0, 1] = off_diagonal_nc_1 + local_nc
 off_diagonal_partition[1, 1] = off_diagonal_nc_2
 off_diagonal_cluster: Htool.Cluster = cluster_builder.create_cluster_tree(
-    permuted_source_points, number_of_children, 2, off_diagonal_partition
+    permuted_source_points, number_of_children, 2, partition=off_diagonal_partition
 )
 
 off_diagonal_generator = CustomGenerator(target_points, permuted_source_points)
diff --git a/src/htool/clustering/cluster_tree_builder.hpp b/src/htool/clustering/cluster_tree_builder.hpp
@@ -26,13 +26,14 @@ void declare_cluster_builder(py::module &m, const std::string &className) {
             auto weights_ptr   = weights.has_value() ? weights.value().data() : nullptr;
             return self.create_cluster_tree(coordinates.shape()[1], coordinates.shape()[0], coordinates.data(), radii_ptr, weights_ptr, number_of_children, size_of_partition, partition_ptr);
         },
-        py::arg("coordinates"),
+        py::arg("coordinates"), // LCOV_EXCL_START
         py::arg("number_of_children"),
         py::arg("size_of_partition"),
         py::kw_only(),
         py::arg("partition") = py::none(),
         py::arg("radii")     = py::none(),
         py::arg("weights")   = py::none());
+    // LCOV_EXCL_STOP
 
     py_class.def("set_maximal_leaf_size", &Class::set_maximal_leaf_size);
     py_class.def("set_partitioning_strategy", &Class::set_partitioning_strategy);
diff --git a/src/htool/hmatrix/hmatrix_tree_builder.hpp b/src/htool/hmatrix/hmatrix_tree_builder.hpp
@@ -23,13 +23,14 @@ void declare_hmatrix_builder(py::module &m, const std::string &className) {
     py_class.def(py::init([](underlying_type<CoefficientPrecision> epsilon, CoordinatePrecision eta, char symmetry, char UPLO, int reqrank, std::shared_ptr<VirtualLowRankGeneratorPython<CoefficientPrecision>> low_rank_strategy) {
                      return std::unique_ptr<Class>(new Class(epsilon, eta, symmetry, UPLO, reqrank, low_rank_strategy));
                  }),
-                 py::arg("epsilon"),
+                 py::arg("epsilon"), // LCOV_EXCL_START
                  py::arg("eta"),
                  py::arg("symmetry"),
                  py::arg("UPLO"),
                  py::kw_only(),
                  py::arg("reqrank")           = -1,
                  py::arg("low_rank_strategy") = nullptr);
+    // LCOV_EXCL_STOP
 
     // Build
     py_class.def("build", [](const Class &self, const VirtualGenerator<CoefficientPrecision> &generator, const Cluster<CoordinatePrecision> &target_cluster, const Cluster<CoordinatePrecision> &source_cluster, int target_partition_number, int partition_number_for_symmetry) { return self.build(generator, target_cluster, source_cluster, target_partition_number, partition_number_for_symmetry); }, py::arg("generator"), py::arg("target_cluster"), py::arg("source_cluster"), py::arg("target_partition_number") = -1, py::arg("partition_number_for_symmetry") = -1);
diff --git a/src/htool/solver/utility.hpp b/src/htool/solver/utility.hpp
@@ -20,7 +20,7 @@ void declare_solver_utility(py::module &m, std::string prefix = "") {
                              auto weights_ptr = weights.has_value() ? weights.value().data() : nullptr;
                              return new DDMSolverBuilder(distributed_operator, ovr_subdomain_to_global, cluster_to_ovr_subdomain, neighbors, intersections, generator, coordinates.shape()[0], coordinates.data(), radii_ptr, weights_ptr, cluster_tree_builder, local_hmatrix_builder);
                          }),
-                         py::keep_alive<1, 2>(),
+                         py::keep_alive<1, 2>(), // LCOV_EXCL_START
                          py::arg("distributed_operator"),
                          py::arg("ovr_subdomain_to_global"),
                          py::arg("cluster_to_ovr_subdomain"),
@@ -33,6 +33,7 @@ void declare_solver_utility(py::module &m, std::string prefix = "") {
                          py::kw_only(),
                          py::arg("radii")   = py::none(),
                          py::arg("weights") = py::none());
+    // LCOV_EXCL_STOP
 
     ddm_solver_class.def_property_readonly(
         "solver", [](const DDMSolverBuilder &self) { return &self.solver; }, py::return_value_policy::reference_internal);
diff --git a/tests/test_ddm_solver.py b/tests/test_ddm_solver.py
@@ -147,6 +147,8 @@ def compute_coarse_space(self, hmatrix_callback):
         (1, "N", "DDMWithHMatrix", "ras", "none", "none"),
         (1, "N", "DDMWithHMatrixDense", "asm", "none", "none"),
         (1, "N", "DDMWithHMatrixDense", "ras", "none", "none"),
+        (1, "N", "DDMWithHMatrixPlusOverlapDense", "asm", "none", "none"),
+        (1, "N", "DDMWithHMatrixPlusOverlapDense", "ras", "none", "none"),
         (10, "N", "BlockJacobi", "none", "none", "none"),
         (10, "N", "BlockJacobi", "asm", "none", "none"),
         (10, "N", "BlockJacobi", "ras", "none", "none"),
@@ -157,6 +159,8 @@ def compute_coarse_space(self, hmatrix_callback):
         (10, "N", "DDMWithHMatrixPlusOverlap", "ras", "none", "none"),
         (10, "N", "DDMWithHMatrix", "asm", "none", "none"),
         (10, "N", "DDMWithHMatrix", "ras", "none", "none"),
+        (10, "N", "DDMWithHMatrixPlusOverlapDense", "asm", "none", "none"),
+        (10, "N", "DDMWithHMatrixPlusOverlapDense", "ras", "none", "none"),
         (10, "N", "DDMWithHMatrixDense", "asm", "none", "none"),
         (10, "N", "DDMWithHMatrixDense", "ras", "none", "none"),
         (1, "S", "BlockJacobi", "none", "none", "none"),
@@ -166,6 +170,8 @@ def compute_coarse_space(self, hmatrix_callback):
         (1, "S", "DDMWithHMatrixPlusOverlap", "ras", "none", "none"),
         (1, "S", "DDMWithHMatrix", "asm", "none", "none"),
         (1, "S", "DDMWithHMatrix", "ras", "none", "none"),
+        (1, "S", "DDMWithHMatrixPlusOverlapDense", "asm", "none", "none"),
+        (1, "S", "DDMWithHMatrixPlusOverlapDense", "ras", "none", "none"),
         (1, "S", "DDMWithHMatrixDense", "asm", "none", "none"),
         (1, "S", "DDMWithHMatrixDense", "ras", "none", "none"),
         (10, "S", "BlockJacobi", "none", "none", "none"),
@@ -481,7 +487,7 @@ def test_ddm_solver(
         local_hmatrix = default_solver_builder.get_local_hmatrix()
         Htool.recompression(local_hmatrix)
 
-    elif ddm_builder == "DDMWithHMatrixDense":
+    elif ddm_builder == "DDMWithHMatrixPlusOverlapDense":
         if symmetry == "S":
             default_solver_builder = Htool.DDMSolverWithDenseLocalSolver(
                 default_approximation.distributed_operator,
@@ -503,6 +509,32 @@ def test_ddm_solver(
                 intersections,
             )
         local_hmatrix = default_solver_builder.get_local_hmatrix()
+    elif ddm_builder == "DDMWithHMatrixDense":
+        if symmetry == "S":
+            default_solver_builder = Htool.DDMSolverWithDenseLocalSolver(
+                default_approximation.distributed_operator,
+                ovr_subdomain_to_global,
+                cluster_to_ovr_subdomain,
+                neighbors,
+                intersections,
+                generator,
+                geometry,
+                epsilon,
+                eta,
+            )
+        else:
+            default_solver_builder = Htool.ComplexDDMSolverWithDenseLocalSolver(
+                default_approximation.distributed_operator,
+                ovr_subdomain_to_global,
+                cluster_to_ovr_subdomain,
+                neighbors,
+                intersections,
+                generator,
+                geometry,
+                epsilon,
+                eta,
+            )
+        local_hmatrix = default_solver_builder.get_local_hmatrix()
 
     solver = default_solver_builder.solver
     distributed_operator = default_approximation.distributed_operator
diff --git a/tests/test_hmatrix.py b/tests/test_hmatrix.py
@@ -0,0 +1,76 @@
+import copy
+import logging
+
+import Htool
+import numpy as np
+import pytest
+
+from example.create_geometry import create_random_geometries
+from example.define_custom_generators import CustomGenerator
+from example.define_custom_low_rank_generator import CustomSVD
+
+
+@pytest.mark.parametrize(
+    "loglevel",
+    [logging.INFO, logging.DEBUG, logging.WARNING, logging.ERROR, logging.CRITICAL],
+)
+def test_hmatrix(loglevel):
+    logging.basicConfig(level=loglevel)
+
+    # Random geometry
+    nb_rows = 500
+    nb_cols = 500
+    dimension = 3
+    [target_points, source_points] = create_random_geometries(
+        dimension, nb_rows, nb_cols
+    )
+    # Htool parameters
+    eta = 100
+    epsilon = 1e-3
+    maximal_leaf_size = 10
+    number_of_children = 2
+
+    # Build clusters
+    cluster_builder = Htool.ClusterTreeBuilder()
+    cluster_builder.set_maximal_leaf_size(maximal_leaf_size)
+    target_cluster: Htool.Cluster = cluster_builder.create_cluster_tree(
+        target_points,
+        number_of_children,
+        number_of_children,
+    )
+    source_cluster: Htool.Cluster = cluster_builder.create_cluster_tree(
+        source_points, number_of_children, number_of_children
+    )
+
+    # Build generator
+    generator = CustomGenerator(target_points, source_points)
+
+    # Custom low rank generator
+    low_rank_generator = CustomSVD(generator)
+
+    # Build HMatrix
+    hmatrix_builder = Htool.HMatrixTreeBuilder(epsilon, eta, "N", "N")
+    hmatrix_builder.set_low_rank_generator(low_rank_generator)
+    hmatrix = hmatrix_builder.build(generator, target_cluster, source_cluster)
+
+    # Copy
+    copy_hmatrix = copy.deepcopy(hmatrix)
+
+    # Densifying
+    _ = hmatrix.to_dense()
+    dense_in_user_numbering = hmatrix.to_dense_in_user_numbering()
+
+    # HMatrix vector product
+    np.random.seed(0)
+    x = np.random.rand(nb_cols)
+    y = hmatrix * x
+    y_dense = dense_in_user_numbering.dot(x)
+    y_copy = copy_hmatrix * x
+    assert np.linalg.norm(y - y_dense) / np.linalg.norm(y_dense) < epsilon
+    assert np.linalg.norm(y - y_copy) < 1e-10
+
+    # Output
+    hmatrix_tree_parameter = hmatrix.get_tree_parameters()
+    hmatrix_local_information = hmatrix.get_local_information()
+    print(hmatrix_tree_parameter)
+    print(hmatrix_local_information)
