✨ Option for efficient determination of non-operational status

bindings/mnt/pyfiction/include/pyfiction/algorithms/simulation/sidb/is_operational.hpp

@@ -8,12 +8,14 @@
 #include "pyfiction/documentation.hpp"
 #include "pyfiction/types.hpp"
 
+#include <fiction/algorithms/simulation/sidb/detect_bdl_wires.hpp>
 #include <fiction/algorithms/simulation/sidb/is_operational.hpp>
 
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 
 #include <optional>
+#include <vector>
 
 namespace pyfiction
 {
@@ -26,23 +28,59 @@ void is_operational(pybind11::module& m)
 {
     namespace py = pybind11;
 
-    m.def("is_operational", &fiction::is_operational<Lyt, py_tt>, py::arg("lyt"), py::arg("spec"),
-          py::arg("params") = fiction::is_operational_params{}, py::arg("input_bdl_wire") = std::nullopt,
-          py::arg("output_bdl_wire") = std::nullopt, DOC(fiction_is_operational));
-
-    m.def("operational_input_patterns", &fiction::operational_input_patterns<Lyt, py_tt>, py::arg("lyt"),
-          py::arg("spec"), py::arg("params") = fiction::is_operational_params{},
+    m.def("is_operational",
+          py::overload_cast<const Lyt&, const std::vector<py_tt>&, const fiction::is_operational_params&>(
+              &fiction::is_operational<Lyt, py_tt>),
+          py::arg("lyt"), py::arg("spec"), py::arg("params") = fiction::is_operational_params{},
+          DOC(fiction_is_operational));
+
+    m.def("is_operational",
+          py::overload_cast<const Lyt&, const std::vector<py_tt>&, const fiction::is_operational_params&,
+                            const std::vector<fiction::bdl_wire<Lyt>>&, const std::vector<fiction::bdl_wire<Lyt>>&,
+                            const std::optional<Lyt>&>(&fiction::is_operational<Lyt, py_tt>),
+          py::arg("lyt"), py::arg("spec"), py::arg("params"), py::arg("input_bdl_wire"), py::arg("output_bdl_wire"),
+          py::arg("canvas_lyt") = std::nullopt, DOC(fiction_is_operational_2));
+
+    m.def("operational_input_patterns",
+          py::overload_cast<const Lyt&, const std::vector<py_tt>&, const fiction::is_operational_params&>(
+              &fiction::operational_input_patterns<Lyt, py_tt>),
+          py::arg("lyt"), py::arg("spec"), py::arg("params") = fiction::is_operational_params{},
           DOC(fiction_operational_input_patterns));
 
-    m.def("is_kink_induced_non_operational", &fiction::is_kink_induced_non_operational<Lyt, py_tt>, py::arg("lyt"),
-          py::arg("spec"), py::arg("params") = fiction::is_operational_params{},
-          py::arg("input_bdl_wire") = std::nullopt, py::arg("output_bdl_wire") = std::nullopt,
-          DOC(fiction_is_kink_induced_non_operational));
+    m.def("operational_input_patterns",
+          py::overload_cast<const Lyt&, const std::vector<py_tt>&, const fiction::is_operational_params&,
+                            const std::vector<fiction::bdl_wire<Lyt>>&, const std::vector<fiction::bdl_wire<Lyt>>&,
+                            const std::optional<Lyt>&>(&fiction::operational_input_patterns<Lyt, py_tt>),
+          py::arg("lyt"), py::arg("spec"), py::arg("params") = fiction::is_operational_params{},
+          py::arg("input_bdl_wire"), py::arg("output_bdl_wire"), py::arg("canvas_lyt") = std::nullopt,
+          DOC(fiction_operational_input_patterns_2));
 
     m.def("kink_induced_non_operational_input_patterns",
-          &fiction::kink_induced_non_operational_input_patterns<Lyt, py_tt>, py::arg("lyt"), py::arg("spec"),
-          py::arg("params") = fiction::is_operational_params{},
+          py::overload_cast<const Lyt&, const std::vector<py_tt>&, const fiction::is_operational_params&>(
+              &fiction::kink_induced_non_operational_input_patterns<Lyt, py_tt>),
+          py::arg("lyt"), py::arg("spec"), py::arg("params") = fiction::is_operational_params{},
           DOC(fiction_kink_induced_non_operational_input_patterns));
+
+    m.def(
+        "kink_induced_non_operational_input_patterns",
+        py::overload_cast<const Lyt&, const std::vector<py_tt>&, const fiction::is_operational_params&,
+                          const std::vector<fiction::bdl_wire<Lyt>>&, const std::vector<fiction::bdl_wire<Lyt>>&,
+                          const std::optional<Lyt>&>(&fiction::kink_induced_non_operational_input_patterns<Lyt, py_tt>),
+        py::arg("lyt"), py::arg("spec"), py::arg("params"), py::arg("input_bdl_wire"), py::arg("output_bdl_wire"),
+        py::arg("canvas_lyt") = std::nullopt, DOC(fiction_kink_induced_non_operational_input_patterns_2));
+
+    m.def("is_kink_induced_non_operational",
+          py::overload_cast<const Lyt&, const std::vector<py_tt>&, const fiction::is_operational_params&>(
+              &fiction::is_kink_induced_non_operational<Lyt, py_tt>),
+          py::arg("lyt"), py::arg("spec"), py::arg("params") = fiction::is_operational_params{},
+          DOC(fiction_is_kink_induced_non_operational));
+
+    m.def("is_kink_induced_non_operational",
+          py::overload_cast<const Lyt&, const std::vector<py_tt>&, const fiction::is_operational_params&,
+                            const std::vector<fiction::bdl_wire<Lyt>>&, const std::vector<fiction::bdl_wire<Lyt>>&,
+                            const std::optional<Lyt>&>(&fiction::is_kink_induced_non_operational<Lyt, py_tt>),
+          py::arg("lyt"), py::arg("spec"), py::arg("params"), py::arg("input_bdl_wire"), py::arg("output_bdl_wire"),
+          py::arg("canvas_lyt") = std::nullopt, DOC(fiction_is_kink_induced_non_operational_2));
 }
 
 }  // namespace detail
@@ -56,11 +94,12 @@ inline void is_operational(pybind11::module& m)
         .value("NON_OPERATIONAL", fiction::operational_status::NON_OPERATIONAL,
                DOC(fiction_operational_status_NON_OPERATIONAL));
 
-    py::enum_<fiction::operational_condition>(m, "operational_condition", DOC(fiction_operational_condition))
-        .value("TOLERATE_KINKS", fiction::operational_condition::TOLERATE_KINKS,
-               DOC(fiction_operational_condition_TOLERATE_KINKS))
-        .value("REJECT_KINKS", fiction::operational_condition::REJECT_KINKS,
-               DOC(fiction_operational_condition_REJECT_KINKS));
+    py::enum_<fiction::is_operational_params::operational_condition>(
+        m, "operational_condition", DOC(fiction_is_operational_params_operational_condition))
+        .value("TOLERATE_KINKS", fiction::is_operational_params::operational_condition::TOLERATE_KINKS,
+               DOC(fiction_is_operational_params_operational_condition_TOLERATE_KINKS))
+        .value("REJECT_KINKS", fiction::is_operational_params::operational_condition::REJECT_KINKS,
+               DOC(fiction_is_operational_params_operational_condition_REJECT_KINKS));
 
     py::class_<fiction::is_operational_params>(m, "is_operational_params", DOC(fiction_is_operational_params))
         .def(py::init<>())
@@ -71,7 +110,10 @@ inline void is_operational(pybind11::module& m)
         .def_readwrite("input_bdl_iterator_params", &fiction::is_operational_params::input_bdl_iterator_params,
                        DOC(fiction_is_operational_params_input_bdl_iterator_params))
         .def_readwrite("op_condition", &fiction::is_operational_params::op_condition,
-                       DOC(fiction_is_operational_params_op_condition));
+                       DOC(fiction_is_operational_params_op_condition))
+        .def_readwrite("strategy_to_analyze_operational_status",
+                       &fiction::is_operational_params::strategy_to_analyze_operational_status,
+                       DOC(fiction_is_operational_params_strategy_to_analyze_operational_status));
 
     // NOTE be careful with the order of the following calls! Python will resolve the first matching overload!
     detail::is_operational<py_sidb_100_lattice>(m);

bindings/mnt/pyfiction/include/pyfiction/inout/read_sqd_layout.hpp

@@ -20,38 +20,38 @@ namespace pyfiction
 namespace detail
 {
 
-template <typename Lyt>
-void read_sqd_layout(pybind11::module& m)
+void read_sqd_layout_100(pybind11::module& m)
 {
     namespace py = pybind11;
 
-    py::register_exception<fiction::sqd_parsing_error>(m, "sqd_parsing_error", PyExc_RuntimeError);
+    py_sidb_100_lattice (*read_sqd_layout_function_pointer)(const std::string_view&, const std::string_view&) =
+        &fiction::read_sqd_layout<py_sidb_100_lattice>;
 
-    Lyt (*read_sqd_layout_function_pointer)(const std::string_view&, const std::string_view&) =
-        &fiction::read_sqd_layout<Lyt>;
-
-    if constexpr (fiction::is_sidb_lattice_100_v<Lyt>)
-    {
-        m.def("read_sqd_layout_100", read_sqd_layout_function_pointer, py::arg("filename"), py::arg("layout_name") = "",
-              DOC(fiction_read_sqd_layout_3));
-    }
-    else
-    {
-        m.def("read_sqd_layout_111", read_sqd_layout_function_pointer, py::arg("filename"), py::arg("layout_name") = "",
-              DOC(fiction_read_sqd_layout_3));
-    }
+    m.def("read_sqd_layout_100", read_sqd_layout_function_pointer, py::arg("filename"), py::arg("layout_name") = "",
+          DOC(fiction_read_sqd_layout_3));
 }
 
-}  // namespace detail
-
-inline void read_sqd_layout_100(pybind11::module& m)
+void read_sqd_layout_111(pybind11::module& m)
 {
-    detail::read_sqd_layout<py_sidb_100_lattice>(m);
+    namespace py = pybind11;
+
+    py_sidb_111_lattice (*read_sqd_layout_function_pointer)(const std::string_view&, const std::string_view&) =
+        &fiction::read_sqd_layout<py_sidb_111_lattice>;
+
+    m.def("read_sqd_layout_111", read_sqd_layout_function_pointer, py::arg("filename"), py::arg("layout_name") = "",
+          DOC(fiction_read_sqd_layout_3));
 }
 
-inline void read_sqd_layout_111(pybind11::module& m)
+}  // namespace detail
+
+inline void read_sqd_layout(pybind11::module& m)
 {
-    detail::read_sqd_layout<py_sidb_111_lattice>(m);
+    namespace py = pybind11;
+
+    py::register_exception<fiction::sqd_parsing_error>(m, "sqd_parsing_error", PyExc_RuntimeError);
+
+    detail::read_sqd_layout_100(m);
+    detail::read_sqd_layout_111(m);
 }
 
 }  // namespace pyfiction