✨ Multi-dimensional operational domain computation

bindings/pyfiction/include/pyfiction/algorithms/iter/bdl_input_iterator.hpp

@@ -0,0 +1,113 @@
+//
+// Created by marcel on 19.05.24.
+//
+
+#ifndef PYFICTION_BDL_INPUT_ITERATOR_HPP
+#define PYFICTION_BDL_INPUT_ITERATOR_HPP
+
+#include "pyfiction/documentation.hpp"
+#include "pyfiction/types.hpp"
+
+#include <fiction/algorithms/iter/bdl_input_iterator.hpp>
+#include <fiction/algorithms/simulation/sidb/detect_bdl_pairs.hpp>
+
+#include <fmt/format.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include <cstdint>
+#include <string>
+
+namespace pyfiction
+{
+
+namespace detail
+{
+
+template <typename Lyt>
+void bdl_input_iterator(pybind11::module& m, const std::string& lattice)
+{
+    namespace py = pybind11;
+    using namespace py::literals;
+
+    py::class_<fiction::bdl_input_iterator<Lyt>>(m, fmt::format("bdl_input_iterator_{}", lattice).c_str(),
+                                                 DOC(fiction_bdl_input_iterator))
+        .def(py::init<const Lyt&, const fiction::detect_bdl_pairs_params&>(), "lyt"_a,
+             "params"_a = fiction::detect_bdl_pairs_params{}, DOC(fiction_bdl_input_iterator_bdl_input_iterator))
+        .def(
+            "__next__",
+            [](fiction::bdl_input_iterator<Lyt>& self) -> Lyt&
+            {
+                if (self >= ((1ull << self.num_input_pairs()) - 1))
+                {
+                    throw py::stop_iteration();
+                }
+
+                auto result = *self;
+                ++self;
+                return result;
+            },
+            DOC(fiction_bdl_input_iterator_operator_mul))
+        .def(
+            "__eq__", [](const fiction::bdl_input_iterator<Lyt>& self, const uint64_t m) -> bool { return self == m; },
+            "m"_a, DOC(fiction_bdl_input_iterator_operator_eq))
+        .def(
+            "__ne__", [](const fiction::bdl_input_iterator<Lyt>& self, const uint64_t m) -> bool { return self != m; },
+            "m"_a, DOC(fiction_bdl_input_iterator_operator_ne))
+        .def(
+            "__lt__", [](const fiction::bdl_input_iterator<Lyt>& self, const uint64_t m) -> bool { return self < m; },
+            "m"_a, DOC(fiction_bdl_input_iterator_operator_lt))
+        .def(
+            "__le__", [](const fiction::bdl_input_iterator<Lyt>& self, const uint64_t m) -> bool { return self <= m; },
+            "m"_a, DOC(fiction_bdl_input_iterator_operator_le))
+        .def(
+            "__gt__", [](const fiction::bdl_input_iterator<Lyt>& self, const uint64_t m) -> bool { return self > m; },
+            "m"_a, DOC(fiction_bdl_input_iterator_operator_gt))
+        .def(
+            "__ge__", [](const fiction::bdl_input_iterator<Lyt>& self, const uint64_t m) -> bool { return self >= m; },
+            "m"_a, DOC(fiction_bdl_input_iterator_operator_ge))
+        .def(
+            "__add__", [](const fiction::bdl_input_iterator<Lyt>& self, const int m) -> fiction::bdl_input_iterator<Lyt>
+            { return self + m; }, "m"_a, DOC(fiction_bdl_input_iterator_operator_add))
+        .def(
+            "__iadd__",
+            [](fiction::bdl_input_iterator<Lyt>& self, const int m) -> fiction::bdl_input_iterator<Lyt>&
+            {
+                self += m;
+                return self;
+            },
+            "m"_a, DOC(fiction_bdl_input_iterator_operator_iadd))
+        .def(
+            "__sub__", [](const fiction::bdl_input_iterator<Lyt>& self, const int m) { return self - m; }, "m"_a,
+            DOC(fiction_bdl_input_iterator_operator_sub))
+        .def(
+            "__isub__",
+            [](fiction::bdl_input_iterator<Lyt>& self, const int m) -> fiction::bdl_input_iterator<Lyt>&
+            {
+                self -= m;
+                return self;
+            },
+            "m"_a, DOC(fiction_bdl_input_iterator_operator_isub))
+        .def(
+            "__getitem__", [](const fiction::bdl_input_iterator<Lyt>& self, int m) -> fiction::bdl_input_iterator<Lyt>
+            { return self[m]; }, "m"_a, DOC(fiction_bdl_input_iterator_operator_array))
+
+        .def("num_input_pairs", &fiction::bdl_input_iterator<Lyt>::num_input_pairs)
+        .def("get_layout", [](const fiction::bdl_input_iterator<Lyt>& self) -> const Lyt& { return *self; })
+
+        ;
+}
+
+}  // namespace detail
+
+inline void bdl_input_iterator(pybind11::module& m)
+{
+    // NOTE be careful with the order of the following calls! Python will resolve the first matching overload!
+
+    detail::bdl_input_iterator<py_sidb_100_lattice>(m, "100");
+    detail::bdl_input_iterator<py_sidb_111_lattice>(m, "111");
+}
+
+}  // namespace pyfiction
+
+#endif  // PYFICTION_BDL_INPUT_ITERATOR_HPP

bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/detect_bdl_pairs.hpp

@@ -9,10 +9,15 @@
 #include "pyfiction/types.hpp"
 
 #include <fiction/algorithms/simulation/sidb/detect_bdl_pairs.hpp>
+#include <fiction/technology/cell_technologies.hpp>
+#include <fiction/traits.hpp>
 
+#include <fmt/format.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 
+#include <string>
+
 namespace pyfiction
 {
 
@@ -49,7 +54,9 @@ inline void detect_bdl_pairs(pybind11::module& m)
         .def_readwrite("minimum_distance", &fiction::detect_bdl_pairs_params::minimum_distance,
                        DOC(fiction_detect_bdl_pairs_params_minimum_distance))
         .def_readwrite("maximum_distance", &fiction::detect_bdl_pairs_params::maximum_distance,
-                       DOC(fiction_detect_bdl_pairs_params_maximum_distance));
+                       DOC(fiction_detect_bdl_pairs_params_maximum_distance))
+
+        ;
 
     // NOTE be careful with the order of the following calls! Python will resolve the first matching overload!
 

bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/determine_physically_valid_parameters.hpp

@@ -38,13 +38,9 @@ inline void determine_physically_valid_parameters(pybind11::module& m)
 
     py::class_<fiction::operational_domain<fiction::parameter_point, uint64_t>>(m, "physically_valid_parameters_domain",
                                                                                 DOC(fiction_operational_domain))
+        // todo add docu
         .def(py::init<>())
-        .def_readwrite("x_dimension_parameter",
-                       &fiction::operational_domain<fiction::parameter_point, uint64_t>::x_dimension,
-                       DOC(fiction_operational_domain_x_dimension))
-        .def_readwrite("y_dimension_parameter",
-                       &fiction::operational_domain<fiction::parameter_point, uint64_t>::y_dimension,
-                       DOC(fiction_operational_domain_y_dimension))
+        .def_readwrite("dimensions", &fiction::operational_domain<fiction::parameter_point, uint64_t>::dimensions)
 
         .def(
             "get_excited_state_number_for_parameter",

bindings/pyfiction/include/pyfiction/algorithms/simulation/sidb/operational_domain.hpp

@@ -8,13 +8,14 @@
 #include "pyfiction/documentation.hpp"
 #include "pyfiction/types.hpp"
 
+#include <fiction/algorithms/simulation/sidb/is_operational.hpp>
 #include <fiction/algorithms/simulation/sidb/operational_domain.hpp>
 
 #include <pybind11/operators.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 
-#include <string>
+#include <vector>
 
 namespace pyfiction
 {
@@ -51,18 +52,10 @@ inline void operational_domain(pybind11::module& m)
     namespace py = pybind11;
     using namespace pybind11::literals;
 
-    py::enum_<fiction::sweep_parameter>(m, "sweep_parameter", DOC(fiction_sweep_parameter))
-        .value("EPSILON_R", fiction::sweep_parameter::EPSILON_R, DOC(fiction_sweep_parameter_EPSILON_R))
-        .value("LAMBDA_TF", fiction::sweep_parameter::LAMBDA_TF, DOC(fiction_sweep_parameter_LAMBDA_TF))
-        .value("MU_MINUS", fiction::sweep_parameter::MU_MINUS, DOC(fiction_sweep_parameter_MU_MINUS))
-
-        ;
-
     py::class_<fiction::parameter_point>(m, "parameter_point", DOC(fiction_parameter_point))
-        .def(py::init<>())
-        .def(py::init<const double, const double>(), "x_val"_a, "y_val"_a)
-        .def_readwrite("x", &fiction::parameter_point::x, DOC(fiction_parameter_point_x))
-        .def_readwrite("y", &fiction::parameter_point::y, DOC(fiction_parameter_point_y))
+        .def(py::init<>(), DOC(fiction_parameter_point_parameter_point))
+        .def(py::init<const std::vector<double>>(), "values"_a, DOC(fiction_parameter_point_parameter_point_2))
+        .def_readwrite("parameters", &fiction::parameter_point::parameters, DOC(fiction_parameter_point))
 
         .def(py::self == py::self, "other"_a, DOC(fiction_parameter_point_operator_eq))
         .def(py::self != py::self, "other"_a, DOC(fiction_parameter_point_operator_ne))
@@ -72,19 +65,44 @@ inline void operational_domain(pybind11::module& m)
 
         ;
 
+    py::enum_<fiction::sweep_parameter>(m, "sweep_parameter", DOC(fiction_sweep_parameter))
+        .value("EPSILON_R", fiction::sweep_parameter::EPSILON_R, DOC(fiction_sweep_parameter_EPSILON_R))
+        .value("LAMBDA_TF", fiction::sweep_parameter::LAMBDA_TF, DOC(fiction_sweep_parameter_LAMBDA_TF))
+        .value("MU_MINUS", fiction::sweep_parameter::MU_MINUS, DOC(fiction_sweep_parameter_MU_MINUS))
+
+        ;
+
     py::class_<fiction::operational_domain<fiction::parameter_point, fiction::operational_status>>(
         m, "operational_domain", DOC(fiction_operational_domain))
         .def(py::init<>())
-        .def_readwrite("x_dimension",
-                       &fiction::operational_domain<fiction::parameter_point, fiction::operational_status>::x_dimension,
-                       DOC(fiction_operational_domain_x_dimension))
-        .def_readwrite("y_dimension",
-                       &fiction::operational_domain<fiction::parameter_point, fiction::operational_status>::y_dimension,
-                       DOC(fiction_operational_domain_y_dimension))
+        .def_readwrite("dimensions",
+                       &fiction::operational_domain<fiction::parameter_point, fiction::operational_status>::dimensions,
+                       DOC(fiction_operational_domain_dimensions))
         .def_readwrite(
             "operational_values",
             &fiction::operational_domain<fiction::parameter_point, fiction::operational_status>::operational_values,
-            DOC(fiction_operational_domain_operational_values));
+            DOC(fiction_operational_domain_operational_values))
+
+        .def("get_value",
+             &fiction::operational_domain<fiction::parameter_point, fiction::operational_status>::get_value, "point"_a,
+             DOC(fiction_operational_domain_get_value))
+
+        ;
+
+    py::class_<fiction::operational_domain_value_range>(m, "operational_domain_value_range",
+                                                        DOC(fiction_operational_domain_value_range))
+        .def(py::init<fiction::sweep_parameter>(), "dimension"_a)
+        .def(py::init<fiction::sweep_parameter, double, double, double>(), "dimension"_a, "min"_a, "max"_a, "step"_a)
+        .def_readwrite("dimension", &fiction::operational_domain_value_range::dimension,
+                       DOC(fiction_operational_domain_value_range_dimension))
+        .def_readwrite("min", &fiction::operational_domain_value_range::min,
+                       DOC(fiction_operational_domain_value_range_dimension))
+        .def_readwrite("max", &fiction::operational_domain_value_range::max,
+                       DOC(fiction_operational_domain_value_range_max))
+        .def_readwrite("step", &fiction::operational_domain_value_range::step,
+                       DOC(fiction_operational_domain_value_range_step))
+
+        ;
 
     py::class_<fiction::operational_domain_params>(m, "operational_domain_params",
                                                    DOC(fiction_operational_domain_params))
@@ -93,42 +111,30 @@ inline void operational_domain(pybind11::module& m)
                        DOC(fiction_operational_domain_params_simulation_parameters))
         .def_readwrite("sim_engine", &fiction::operational_domain_params::sim_engine,
                        DOC(fiction_operational_domain_params_sim_engine))
-        .def_readwrite("x_dimension", &fiction::operational_domain_params::x_dimension,
-                       DOC(fiction_operational_domain_params_x_dimension))
-        .def_readwrite("x_min", &fiction::operational_domain_params::x_min,
-                       DOC(fiction_operational_domain_params_x_min))
-        .def_readwrite("x_max", &fiction::operational_domain_params::x_max,
-                       DOC(fiction_operational_domain_params_x_max))
-        .def_readwrite("x_step", &fiction::operational_domain_params::x_step,
-                       DOC(fiction_operational_domain_params_x_step))
-        .def_readwrite("y_dimension", &fiction::operational_domain_params::y_dimension,
-                       DOC(fiction_operational_domain_params_y_dimension))
-        .def_readwrite("y_min", &fiction::operational_domain_params::y_min,
-                       DOC(fiction_operational_domain_params_y_min))
-        .def_readwrite("y_max", &fiction::operational_domain_params::y_max,
-                       DOC(fiction_operational_domain_params_y_max))
-        .def_readwrite("y_step", &fiction::operational_domain_params::y_step,
-                       DOC(fiction_operational_domain_params_y_step))
+        .def_readwrite("sweep_dimensions", &fiction::operational_domain_params::sweep_dimensions,
+                       DOC(fiction_operational_domain_params_sweep_dimensions))
         .def_readwrite("bdl_params", &fiction::operational_domain_params::bdl_params,
                        DOC(fiction_operational_domain_params_bdl_params))
 
         ;
 
     py::class_<fiction::operational_domain_stats>(m, "operational_domain_stats", DOC(fiction_operational_domain_stats))
         .def(py::init<>())
-        .def_readwrite("time_total", &fiction::operational_domain_stats::time_total,
-                       DOC(fiction_operational_domain_stats_duration))
-        .def_readwrite("num_simulator_invocations", &fiction::operational_domain_stats::num_simulator_invocations,
-                       DOC(fiction_operational_domain_stats_num_simulator_invocations))
-        .def_readwrite("num_evaluated_parameter_combinations",
-                       &fiction::operational_domain_stats::num_evaluated_parameter_combinations,
-                       DOC(fiction_operational_domain_stats_num_evaluated_parameter_combinations))
-        .def_readwrite("num_operational_parameter_combinations",
-                       &fiction::operational_domain_stats::num_operational_parameter_combinations,
-                       DOC(fiction_operational_domain_stats_num_operational_parameter_combinations))
-        .def_readwrite("num_non_operational_parameter_combinations",
-                       &fiction::operational_domain_stats::num_non_operational_parameter_combinations,
-                       DOC(fiction_operational_domain_stats_num_non_operational_parameter_combinations));
+        .def_readonly("time_total", &fiction::operational_domain_stats::time_total,
+                      DOC(fiction_operational_domain_stats_duration))
+        .def_readonly("num_simulator_invocations", &fiction::operational_domain_stats::num_simulator_invocations,
+                      DOC(fiction_operational_domain_stats_num_simulator_invocations))
+        .def_readonly("num_evaluated_parameter_combinations",
+                      &fiction::operational_domain_stats::num_evaluated_parameter_combinations,
+                      DOC(fiction_operational_domain_stats_num_evaluated_parameter_combinations))
+        .def_readonly("num_operational_parameter_combinations",
+                      &fiction::operational_domain_stats::num_operational_parameter_combinations,
+                      DOC(fiction_operational_domain_stats_num_operational_parameter_combinations))
+        .def_readonly("num_non_operational_parameter_combinations",
+                      &fiction::operational_domain_stats::num_non_operational_parameter_combinations,
+                      DOC(fiction_operational_domain_stats_num_non_operational_parameter_combinations))
+
+        ;
 
     // NOTE be careful with the order of the following calls! Python will resolve the first matching overload!