fixup

Author: PierreMarchand20

lib/htool

@@ -32,6 +32,9 @@ class RestrictedGlobalToLocalOperatorPython : public htool::RestrictedGlobalToLo
     // virtual void local_add_vector_product_symmetric(char trans, CoefficientPrecision alpha, const std::vector<CoefficientPrecision> &in, CoefficientPrecision beta, std::vector<CoefficientPrecision> &out) const = 0; // LCOV_EXCL_LINE
 
     virtual void add_matrix_product_row_major(char trans, CoefficientPrecision alpha, const py::array_t<CoefficientPrecision, py::array::c_style> &in, CoefficientPrecision beta, py::array_t<CoefficientPrecision, py::array::c_style> &out) const = 0; // LCOV_EXCL_LINE
+
+    LocalRenumbering get_local_target_renumbering()const {return this->m_local_target_renumbering;}
+    LocalRenumbering get_local_source_renumbering()const {return this->m_local_source_renumbering;}
 };
 
 template <typename CoefficientPrecision>
@@ -79,6 +82,8 @@ void declare_global_to_local_operator(py::module &m, const std::string &class_na
     py_class.def(py::init<LocalRenumbering, LocalRenumbering, bool, bool>());
     py_class.def("add_vector_product", &Class::add_vector_product, py::arg("trans"), py::arg("alpha"), py::arg("in").noconvert(true), py::arg("beta"), py::arg("out").noconvert(true));
     py_class.def("add_matrix_product_row_major", &Class::add_matrix_product_row_major);
+    py_class.def_property_readonly("local_target_renumbering",&Class::get_local_target_renumbering);
+    py_class.def_property_readonly("local_source_renumbering",&Class::get_local_source_renumbering);
 }
 
 #endif

src/htool/local_operator/local_operator.hpp

@@ -15,6 +15,8 @@ void declare_local_renumbering(py::module &m, const std::string &className) {
     py_class.def(py::init<const Cluster<CoordinatePrecision> &>());
     py_class.def_property_readonly("offset", &Class::get_offset);
     py_class.def_property_readonly("size", &Class::get_size);
+    py_class.def_property_readonly("global_size", &Class::get_global_size);
+    py_class.def_property_readonly("is_stable", &Class::is_stable);
     py_class.def_property_readonly("permutation", [](const Class &self) { return py::array_t<int>(std::array<long int, 1>{self.get_global_size()}, self.get_permutation(), py::capsule(self.get_permutation())); });
 }
 

src/htool/local_operator/local_renumbering.hpp

@@ -6,42 +6,49 @@
 
 template <typename CoefficientPrecision, typename CoordinatePrecision = htool::underlying_type<CoefficientPrecision>>
 class VirtualLocalToLocalOperatorPython : public htool::VirtualLocalToLocalOperator<CoefficientPrecision> {
-    const Cluster<CoordinatePrecision> &m_target_cluster;
-    const Cluster<CoordinatePrecision> &m_source_cluster;
+    LocalRenumbering m_local_target_renumbering;
+    LocalRenumbering m_local_source_renumbering;
 
   public:
-    VirtualLocalToLocalOperatorPython(const Cluster<CoordinatePrecision> &target_cluster, const Cluster<CoordinatePrecision> &source_cluster) : m_target_cluster(target_cluster), m_source_cluster(source_cluster) {}
+    VirtualLocalToLocalOperatorPython(LocalRenumbering local_target_renumbering, LocalRenumbering local_source_renumbering) : m_local_target_renumbering(local_target_renumbering), m_local_source_renumbering(local_source_renumbering) {}
 
     void add_vector_product(char trans, CoefficientPrecision alpha, const CoefficientPrecision *const in, CoefficientPrecision beta, CoefficientPrecision *const out) const override {
-        py::array_t<CoefficientPrecision> input(std::array<long int, 1>{trans == 'N' ? m_source_cluster.get_size() : m_target_cluster.get_size()}, in, py::capsule(in));
-        py::array_t<CoefficientPrecision> output(std::array<long int, 1>{trans == 'N' ? m_target_cluster.get_size() : m_source_cluster.get_size()}, out, py::capsule(out));
+        py::array_t<CoefficientPrecision> input(std::array<long int, 1>{trans == 'N' ? m_local_source_renumbering.get_size() : m_local_target_renumbering.get_size()}, in, py::capsule(in));
+        py::array_t<CoefficientPrecision> output(std::array<long int, 1>{trans == 'N' ? m_local_target_renumbering.get_size() : m_local_source_renumbering.get_size()}, out, py::capsule(out));
 
         local_add_vector_product(trans, alpha, input, beta, output);
     }
     void add_matrix_product_row_major(char trans, CoefficientPrecision alpha, const CoefficientPrecision *const in, CoefficientPrecision beta, CoefficientPrecision *const out, int mu) const override {
-        py::array_t<CoefficientPrecision, py::array::c_style> input(std::array<long int, 2>{trans == 'N' ? m_source_cluster.get_size() : m_target_cluster.get_size(), mu}, in, py::capsule(in));
-        py::array_t<CoefficientPrecision, py::array::c_style> output(std::array<long int, 2>{trans == 'N' ? m_target_cluster.get_size() : m_source_cluster.get_size(), mu}, out, py::capsule(out));
+        py::array_t<CoefficientPrecision, py::array::c_style> input(std::array<long int, 2>{trans == 'N' ? m_local_source_renumbering.get_size() : m_local_target_renumbering.get_size(), mu}, in, py::capsule(in));
+        py::array_t<CoefficientPrecision, py::array::c_style> output(std::array<long int, 2>{trans == 'N' ? m_local_target_renumbering.get_size() : m_local_source_renumbering.get_size(), mu}, out, py::capsule(out));
 
         local_add_matrix_product_row_major(trans, alpha, input, beta, output);
     }
 
     void add_sub_matrix_product_to_local(const CoefficientPrecision *const in, CoefficientPrecision *const out, int mu, int offset, int size) const override {
-        int source_offset   = m_source_cluster.get_offset();
-        int source_size     = m_source_cluster.get_size();
-        bool is_output_null = ((offset + size) < source_offset) || (source_offset + source_size < offset);
-        if (!is_output_null) {
-            int temp_offset                           = std::max(offset, source_offset);
-            const CoefficientPrecision *const temp_in = (offset < source_offset) ? in + source_offset - offset : in;
-            int temp_size                             = (size + offset <= source_size + source_offset) ? size - std::max(source_offset - offset, 0) : size - std::max(source_offset - offset, 0) - (size + offset - source_offset - source_size);
-
-            if (temp_offset == source_offset && temp_size == source_size)
-                add_matrix_product_row_major('N', 1, temp_in, 1, out, mu);
-            else {
-                std::vector<CoefficientPrecision> extension_by_zero(source_size * mu);
+        int source_offset   = m_local_source_renumbering.get_offset();
+        int source_size     = m_local_source_renumbering.get_size();
+
+        int source_end = source_size+source_offset;
+        int end = size+offset;
+
+        int temp_offset = std::max(offset,source_offset);
+        int temp_end = std::min(source_end,end);
+
+        bool is_output_null = temp_end-temp_offset<=0 ? true:false;
+        if (offset == source_offset && temp_end == source_end){
+            add_matrix_product_row_major('N', 1, in, 1, out, mu);
+        }
+        else {
+            std::vector<CoefficientPrecision> extension_by_zero(source_size * mu);
+            if (!is_output_null){
+                const CoefficientPrecision *const temp_in = in + temp_offset-offset;
+                int temp_size = temp_end-temp_offset;
                 std::copy_n(temp_in, temp_size * mu, extension_by_zero.data());
-                add_matrix_product_row_major('N', 1, extension_by_zero.data(), 1, out, mu);
             }
+            add_matrix_product_row_major('N', 1, extension_by_zero.data(), 1, out, mu);
         }
+
     }
 
     virtual void local_add_vector_product(char trans, CoefficientPrecision alpha, const py::array_t<CoefficientPrecision> &in, CoefficientPrecision beta, py::array_t<CoefficientPrecision> &out) const = 0; // LCOV_EXCL_LINE
@@ -59,7 +66,7 @@ class PyVirtualLocalToLocalOperator : public VirtualLocalToLocalOperatorPython<C
         PYBIND11_OVERRIDE_PURE(
             void,                                                    /* Return type */
             VirtualLocalToLocalOperatorPython<CoefficientPrecision>, /* Parent class */
-            add_vector_product,                                      /* Name of function in C++ (must match Python name) */
+            local_add_vector_product,                                      /* Name of function in C++ (must match Python name) */
             trans,
             alpha,
             in,
@@ -71,7 +78,7 @@ class PyVirtualLocalToLocalOperator : public VirtualLocalToLocalOperatorPython<C
         PYBIND11_OVERRIDE_PURE(
             void,                                                    /* Return type */
             VirtualLocalToLocalOperatorPython<CoefficientPrecision>, /* Parent class */
-            add_matrix_product_row_major,                            /* Name of function in C++ (must match Python name) */
+            local_add_matrix_product_row_major,                            /* Name of function in C++ (must match Python name) */
             trans,
             alpha,
             in,
@@ -87,10 +94,10 @@ void declare_virtual_local_to_local_operator(py::module &m, const std::string &c
     py::class_<BaseClass>(m, (base_class_name).c_str());
 
     using Class = VirtualLocalToLocalOperatorPython<CoefficientPrecision>;
-    py::class_<Class, PyVirtualLocalToLocalOperator<CoefficientPrecision>, BaseClass> py_class(m, className.c_str());
-    py_class.def(py::init<const Cluster<CoordinatePrecision> &, const Cluster<CoordinatePrecision> &>());
-    py_class.def("local_add_vector_product", &Class::add_vector_product, py::arg("trans"), py::arg("alpha"), py::arg("in").noconvert(true), py::arg("beta"), py::arg("out").noconvert(true));
-    py_class.def("local_add_matrix_product_row_major", &Class::add_matrix_product_row_major);
+    py::class_<Class, BaseClass, PyVirtualLocalToLocalOperator<CoefficientPrecision>> py_class(m, className.c_str());
+    py_class.def(py::init<LocalRenumbering, LocalRenumbering>());
+    py_class.def("local_add_vector_product", &Class::local_add_vector_product, py::arg("trans"), py::arg("alpha"), py::arg("in").noconvert(true), py::arg("beta"), py::arg("out").noconvert(true));
+    py_class.def("local_add_matrix_product_row_major", &Class::local_add_matrix_product_row_major);
 }
 
 #endif