update

Author: PierreMarchand20

example/define_custom_local_operator.py

@@ -2,7 +2,7 @@
 import numpy as np
 
 
-class CustomLocalOperator(Htool.LocalOperator):
+class CustomLocalOperator(Htool.RestrictedGlobalToLocalOperator):
     def __init__(
         self,
         generator: Htool.VirtualGenerator,

example/use_local_hmatrix_compression.py

@@ -102,9 +102,9 @@
     )
 
 if local_operator_1:
-    distributed_operator.add_local_operator(local_operator_1)
+    distributed_operator.add_global_to_local_operator(local_operator_1)
 if local_operator_2:
-    distributed_operator.add_local_operator(local_operator_2)
+    distributed_operator.add_global_to_local_operator(local_operator_2)
 
 # Test matrix vector product
 np.random.seed(0)

lib/htool

@@ -15,7 +15,8 @@ void declare_distributed_operator(py::module &m, const std::string &class_name)
 
     py::class_<Class> py_class(m, class_name.c_str());
     py_class.def(py::init<VirtualPartition<CoefficientPrecision> &, VirtualPartition<CoefficientPrecision> &, MPI_Comm_wrapper>(), py::keep_alive<1, 2>(), py::keep_alive<1, 3>());
-    py_class.def("add_local_operator", &Class::add_local_operator, py::keep_alive<1, 2>());
+    py_class.def("add_global_to_local_operator", &Class::add_global_to_local_operator, py::keep_alive<1, 2>());
+    py_class.def("add_local_to_local_operator", &Class::add_local_to_local_operator, py::keep_alive<1, 2>());
 
     // Linear algebra
     py_class.def(

src/htool/distributed_operator/distributed_operator.hpp

@@ -17,7 +17,8 @@ void declare_distributed_operator_utility(py::module &m, std::string prefix = ""
     std::string default_local_approximation_name = prefix + "DefaultLocalApproximationBuilder";
 
     py::class_<CustomApproximation> custom_approximation_class(m, custom_approximation_name.c_str());
-    custom_approximation_class.def(py::init<const Cluster<CoordinatePrecision> &, const Cluster<CoordinatePrecision> &, MPI_Comm_wrapper, const VirtualLocalOperator<CoefficientPrecision> &>());
+    custom_approximation_class.def(py::init<const Cluster<CoordinatePrecision> &, const Cluster<CoordinatePrecision> &, MPI_Comm_wrapper, const VirtualLocalToLocalOperator<CoefficientPrecision> &>());
+    custom_approximation_class.def(py::init<const Cluster<CoordinatePrecision> &, const Cluster<CoordinatePrecision> &, MPI_Comm_wrapper, const VirtualGlobalToLocalOperator<CoefficientPrecision> &>());
     custom_approximation_class.def_property_readonly(
         "distributed_operator", [](const CustomApproximation &self) { return &self.distributed_operator; }, py::return_value_policy::reference_internal);
 

src/htool/distributed_operator/utility.hpp

@@ -1,15 +1,15 @@
 #ifndef HTOOL_LOCAL_OPERATOR_CPP
 #define HTOOL_LOCAL_OPERATOR_CPP
 
-#include <htool/distributed_operator/implementations/local_operators/local_operator.hpp>
+#include <htool/distributed_operator/implementations/global_to_local_operators/restricted_operator.hpp>
 #include <pybind11/pybind11.h>
 
 template <typename CoefficientPrecision>
-class LocalOperatorPython : public htool::LocalOperator<CoefficientPrecision> {
+class RestrictedGlobalToLocalOperatorPython : public htool::RestrictedGlobalToLocalOperator<CoefficientPrecision> {
   public:
-    using htool::LocalOperator<CoefficientPrecision>::LocalOperator;
+    using htool::RestrictedGlobalToLocalOperator<CoefficientPrecision>::RestrictedGlobalToLocalOperator;
 
-    LocalOperatorPython(LocalRenumbering target_local_renumbering, LocalRenumbering source_local_renumbering, bool target_use_permutation_to_mvprod = false, bool source_use_permutation_to_mvprod = false) : LocalOperator<CoefficientPrecision>(target_local_renumbering, source_local_renumbering, target_use_permutation_to_mvprod, source_use_permutation_to_mvprod) {}
+    RestrictedGlobalToLocalOperatorPython(LocalRenumbering target_local_renumbering, LocalRenumbering source_local_renumbering, bool target_use_permutation_to_mvprod = false, bool source_use_permutation_to_mvprod = false) : RestrictedGlobalToLocalOperator<CoefficientPrecision>(target_local_renumbering, source_local_renumbering, target_use_permutation_to_mvprod, source_use_permutation_to_mvprod) {}
 
     void local_add_vector_product(char trans, CoefficientPrecision alpha, const CoefficientPrecision *in, CoefficientPrecision beta, CoefficientPrecision *out) const override {
 
@@ -35,16 +35,16 @@ class LocalOperatorPython : public htool::LocalOperator<CoefficientPrecision> {
 };
 
 template <typename CoefficientPrecision>
-class PyLocalOperator : public LocalOperatorPython<CoefficientPrecision> {
+class PyRestrictedGlobalToLocalOperator : public RestrictedGlobalToLocalOperatorPython<CoefficientPrecision> {
   public:
-    using LocalOperatorPython<CoefficientPrecision>::LocalOperatorPython;
+    using RestrictedGlobalToLocalOperatorPython<CoefficientPrecision>::RestrictedGlobalToLocalOperatorPython;
 
     /* Trampoline (need one for each virtual function) */
     virtual void add_vector_product(char trans, CoefficientPrecision alpha, const py::array_t<CoefficientPrecision> &in, CoefficientPrecision beta, py::array_t<CoefficientPrecision> &out) const override {
         PYBIND11_OVERRIDE_PURE(
-            void,                                      /* Return type */
-            LocalOperatorPython<CoefficientPrecision>, /* Parent class */
-            add_vector_product,                        /* Name of function in C++ (must match Python name) */
+            void,                                                        /* Return type */
+            RestrictedGlobalToLocalOperatorPython<CoefficientPrecision>, /* Parent class */
+            add_vector_product,                                          /* Name of function in C++ (must match Python name) */
             trans,
             alpha,
             in,
@@ -54,9 +54,9 @@ class PyLocalOperator : public LocalOperatorPython<CoefficientPrecision> {
     }
     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 override {
         PYBIND11_OVERRIDE_PURE(
-            void,                                      /* Return type */
-            LocalOperatorPython<CoefficientPrecision>, /* Parent class */
-            add_matrix_product_row_major,              /* Name of function in C++ (must match Python name) */
+            void,                                                        /* Return type */
+            RestrictedGlobalToLocalOperatorPython<CoefficientPrecision>, /* Parent class */
+            add_matrix_product_row_major,                                /* Name of function in C++ (must match Python name) */
             trans,
             alpha,
             in,
@@ -67,15 +67,15 @@ class PyLocalOperator : public LocalOperatorPython<CoefficientPrecision> {
 };
 
 template <typename CoefficientPrecision>
-void declare_local_operator(py::module &m, const std::string &class_name) {
-    using VirtualClass = htool::VirtualLocalOperator<CoefficientPrecision>;
-    py::class_<VirtualClass>(m, ("Virtual" + class_name).c_str());
+void declare_global_to_local_operator(py::module &m, const std::string &class_name) {
+    using VirtualClass = htool::VirtualGlobalToLocalOperator<CoefficientPrecision>;
+    py::class_<VirtualClass>(m, "IGlobalToLocalOperator");
 
-    using BaseClass = LocalOperator<CoefficientPrecision>;
-    py::class_<BaseClass, VirtualClass> py_base_class(m, ("Base" + class_name).c_str());
+    using BaseClass = RestrictedGlobalToLocalOperator<CoefficientPrecision>;
+    py::class_<BaseClass, VirtualClass> py_base_class(m, "IRestrictedGlobalToLocalOperator");
 
-    using Class = LocalOperatorPython<CoefficientPrecision>;
-    py::class_<Class, PyLocalOperator<CoefficientPrecision>, BaseClass> py_class(m, class_name.c_str());
+    using Class = RestrictedGlobalToLocalOperatorPython<CoefficientPrecision>;
+    py::class_<Class, PyRestrictedGlobalToLocalOperator<CoefficientPrecision>, BaseClass> py_class(m, class_name.c_str());
     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);