✨ QuickCell: An Algorithm for Automatic Standard Cell Design

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

@@ -32,8 +32,8 @@ void bdl_input_iterator(pybind11::module& m, const std::string& lattice)
 
     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(py::init<const Lyt&, const fiction::detect_bdl_wires_params&>(), "lyt"_a,
+             "params"_a = fiction::detect_bdl_wires_params{}, DOC(fiction_bdl_input_iterator_bdl_input_iterator))
         .def(
             "__next__",
             [](fiction::bdl_input_iterator<Lyt>& self) -> Lyt&

bindings/pyfiction/include/pyfiction/algorithms/physical_design/design_sidb_gates.hpp

@@ -25,22 +25,38 @@ void design_sidb_gates(pybind11::module& m)
     using namespace py::literals;
 
     m.def("design_sidb_gates", &fiction::design_sidb_gates<Lyt, py_tt>, "skeleton"_a, "spec"_a,
-          "params"_a = fiction::design_sidb_gates_params<fiction::cell<Lyt>>{}, DOC(fiction_design_sidb_gates));
+          "params"_a = fiction::design_sidb_gates_params<fiction::cell<Lyt>>{}, "stats"_a = nullptr,
+          DOC(fiction_design_sidb_gates));
 }
 
 }  // namespace detail
 
 inline void design_sidb_gates(pybind11::module& m)
 {
     namespace py = pybind11;
+
+    py::class_<fiction::design_sidb_gates_stats>(m, "design_sidb_gates_stats", DOC(fiction_design_sidb_gates_stats))
+        .def(py::init<>())
+        .def("__repr__",
+             [](const fiction::design_sidb_gates_stats& stats)
+             {
+                 std::stringstream stream{};
+                 stats.report(stream);
+                 return stream.str();
+             });
+
     /**
      * Design approach selector type.
      */
     pybind11::enum_<typename fiction::design_sidb_gates_params<fiction::offset::ucoord_t>::design_sidb_gates_mode>(
         m, "design_sidb_gates_mode", DOC(fiction_design_sidb_gates_params_design_sidb_gates_mode))
-        .value("EXHAUSTIVE",
-               fiction::design_sidb_gates_params<fiction::offset::ucoord_t>::design_sidb_gates_mode::EXHAUSTIVE,
-               DOC(fiction_design_sidb_gates_params_design_sidb_gates_mode_EXHAUSTIVE))
+        .value("QUICKCELL",
+               fiction::design_sidb_gates_params<fiction::offset::ucoord_t>::design_sidb_gates_mode::QUICKCELL,
+               DOC(fiction_design_sidb_gates_params_design_sidb_gates_mode_QUICKCELL))
+        .value("AUTOMATIC_EXHAUSTIVE_GATE_DESIGNER",
+               fiction::design_sidb_gates_params<
+                   fiction::offset::ucoord_t>::design_sidb_gates_mode::AUTOMATIC_EXHAUSTIVE_GATE_DESIGNER,
+               DOC(fiction_design_sidb_gates_params_design_sidb_gates_mode_QUICKCELL))
         .value("RANDOM", fiction::design_sidb_gates_params<fiction::offset::ucoord_t>::design_sidb_gates_mode::RANDOM,
                DOC(fiction_design_sidb_gates_params_design_sidb_gates_mode_RANDOM));
 
@@ -50,18 +66,16 @@ inline void design_sidb_gates(pybind11::module& m)
     py::class_<fiction::design_sidb_gates_params<fiction::offset::ucoord_t>>(m, "design_sidb_gates_params",
                                                                              DOC(fiction_design_sidb_gates_params))
         .def(py::init<>())
-        .def_readwrite("simulation_parameters",
-                       &fiction::design_sidb_gates_params<fiction::offset::ucoord_t>::simulation_parameters,
+        .def_readwrite("operational_params",
+                       &fiction::design_sidb_gates_params<fiction::offset::ucoord_t>::operational_params,
                        DOC(fiction_design_sidb_gates_params))
         .def_readwrite("design_mode", &fiction::design_sidb_gates_params<fiction::offset::ucoord_t>::design_mode,
                        DOC(fiction_design_sidb_gates_params_design_mode))
         .def_readwrite("canvas", &fiction::design_sidb_gates_params<fiction::offset::ucoord_t>::canvas,
                        DOC(fiction_design_sidb_gates_params_canvas))
         .def_readwrite("number_of_sidbs",
                        &fiction::design_sidb_gates_params<fiction::offset::ucoord_t>::number_of_sidbs,
-                       DOC(fiction_design_sidb_gates_params_number_of_sidbs))
-        .def_readwrite("sim_engine", &fiction::design_sidb_gates_params<fiction::offset::ucoord_t>::sim_engine,
-                       DOC(fiction_design_sidb_gates_params_sim_engine));
+                       DOC(fiction_design_sidb_gates_params_number_of_sidbs));
 
     detail::design_sidb_gates<py_sidb_100_lattice>(m);
     detail::design_sidb_gates<py_sidb_111_lattice>(m);

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

@@ -91,8 +91,8 @@ inline void critical_temperature(pybind11::module& m)
                        DOC(fiction_critical_temperature_params_confidence_level))
         .def_readwrite("max_temperature", &fiction::critical_temperature_params::max_temperature,
                        DOC(fiction_critical_temperature_params_max_temperature))
-        .def_readwrite("bdl_params", &fiction::critical_temperature_params::bdl_params,
-                       DOC(fiction_critical_temperature_params_bdl_params));
+        .def_readwrite("bdl_wire_params", &fiction::critical_temperature_params::bdl_wire_params,
+                       DOC(fiction_critical_temperature_params_bdl_wire_params));
 
     // NOTE be careful with the order of the following calls! Python will resolve the first matching overload!
 

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

@@ -27,10 +27,9 @@ namespace detail
 template <typename Lyt>
 void detect_bdl_pairs(pybind11::module& m)
 {
-    namespace py = pybind11;
     using namespace pybind11::literals;
 
-    m.def("detect_bdl_pairs", &fiction::detect_bdl_pairs<Lyt>, "lyt"_a, "type"_a,
+    m.def("detect_bdl_pairs", &fiction::detect_bdl_pairs<Lyt>, "lyt"_a, "type"_a = nullptr,
           "params"_a = fiction::detect_bdl_pairs_params{}, DOC(fiction_detect_bdl_pairs));
 }
 

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

@@ -0,0 +1,71 @@
+//
+// Created by Jan Drewniok on 17.07.24.
+//
+
+#ifndef PYFICTION_DETECT_BDL_WIRES_HPP
+#define PYFICTION_DETECT_BDL_WIRES_HPP
+
+#include "pyfiction/documentation.hpp"
+#include "pyfiction/types.hpp"
+
+#include <fiction/algorithms/simulation/sidb/detect_bdl_pairs.hpp>
+#include <fiction/algorithms/simulation/sidb/detect_bdl_wires.hpp>
+
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include <vector>
+
+namespace pyfiction
+{
+
+namespace detail
+{
+
+template <typename Lyt>
+void detect_bdl_wires(pybind11::module& m)
+{
+    using namespace pybind11::literals;
+
+    m.def("detect_bdl_wires", &fiction::detect_bdl_wires<Lyt>, "lyt"_a, "params"_a = fiction::detect_bdl_wires_params{},
+          "wire_selection"_a = fiction::bdl_wire_selection::ALL);
+}
+
+}  // namespace detail
+
+inline void detect_bdl_wires(pybind11::module& m)
+{
+    namespace py = pybind11;
+    using namespace pybind11::literals;
+
+    py::class_<fiction::bdl_wire<fiction::offset::ucoord_t>>(m, "bdl_wire")
+        .def(py::init<>())
+        .def(py::init<std::vector<fiction::bdl_pair<fiction::offset::ucoord_t>>>(), "p"_a, DOC(fiction_bdl_wire))
+        .def_readwrite("pairs", &fiction::bdl_wire<fiction::offset::ucoord_t>::pairs, DOC(fiction_bdl_wire_pairs))
+        .def_readwrite("direction", &fiction::bdl_wire<fiction::offset::ucoord_t>::direction,
+                       DOC(fiction_bdl_wire_direction));
+
+    py::enum_<fiction::bdl_wire_direction>(m, "bdl_wire_direction")
+        .value("NORTH_SOUTH", fiction::bdl_wire_direction::NORTH_SOUTH)
+        .value("SOUTH_NORTH", fiction::bdl_wire_direction::SOUTH_NORTH)
+        .value("NO_DIRECTION", fiction::bdl_wire_direction::NO_DIRECTION);
+
+    py::enum_<fiction::bdl_wire_selection>(m, "bdl_wire_selection")
+        .value("ALL", fiction::bdl_wire_selection::ALL)
+        .value("INPUT", fiction::bdl_wire_selection::INPUT)
+        .value("OUTPUT", fiction::bdl_wire_selection::OUTPUT);
+
+    py::class_<fiction::detect_bdl_wires_params>(m, "detect_bdl_wires_params")
+        .def(py::init<>())
+        .def_readwrite("threshold_bdl_interdistance", &fiction::detect_bdl_wires_params::threshold_bdl_interdistance)
+        .def_readwrite("params_bdl_pairs", &fiction::detect_bdl_wires_params::params_bdl_pairs);
+
+    // NOTE be careful with the order of the following calls! Python will resolve the first matching overload!
+
+    detail::detect_bdl_wires<py_sidb_100_lattice>(m);
+    detail::detect_bdl_wires<py_sidb_111_lattice>(m);
+}
+
+}  // namespace pyfiction
+
+#endif  // PYFICTION_DETECT_BDL_WIRES_HPP

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

@@ -27,7 +27,8 @@ void is_operational(pybind11::module& m)
     using namespace pybind11::literals;
 
     m.def("is_operational", &fiction::is_operational<Lyt, py_tt>, "lyt"_a, "spec"_a,
-          "params"_a = fiction::is_operational_params{}, DOC(fiction_is_operational));
+          "params"_a = fiction::is_operational_params{}, "input_bdl_wire"_a = nullptr, "output_bdl_wire"_a = nullptr,
+          DOC(fiction_is_operational));
 
     m.def("operational_input_patterns", &fiction::operational_input_patterns<Lyt, py_tt>, "lyt"_a, "spec"_a,
           "params"_a = fiction::is_operational_params{}, DOC(fiction_is_operational));
@@ -44,17 +45,22 @@ 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("ALLOWING_KINKS", fiction::operational_condition::ALLOWING_KINKS,
+               DOC(fiction_operational_condition_ALLOWING_KINKS))
+        .value("FORBIDDING_KINKS", fiction::operational_condition::FORBIDDING_KINKS,
+               DOC(fiction_operational_condition_FORBIDDING_KINKS));
+
     py::class_<fiction::is_operational_params>(m, "is_operational_params", DOC(fiction_is_operational_params))
         .def(py::init<>())
         .def_readwrite("simulation_parameters", &fiction::is_operational_params::simulation_parameters,
                        DOC(fiction_is_operational_params))
         .def_readwrite("sim_engine", &fiction::is_operational_params::sim_engine,
                        DOC(fiction_is_operational_params_sim_engine))
-        .def_readwrite("bdl_params", &fiction::is_operational_params::bdl_params,
-                       DOC(fiction_is_operational_params_bdl_params));
+        .def_readwrite("bdl_wire_params", &fiction::is_operational_params::bdl_wire_params)
+        .def_readwrite("op_condition", &fiction::is_operational_params::op_condition);
 
     // 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);
     detail::is_operational<py_sidb_111_lattice>(m);
 }

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

@@ -107,14 +107,10 @@ inline void operational_domain(pybind11::module& m)
     py::class_<fiction::operational_domain_params>(m, "operational_domain_params",
                                                    DOC(fiction_operational_domain_params))
         .def(py::init<>())
-        .def_readwrite("simulation_parameters", &fiction::operational_domain_params::simulation_parameters,
-                       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("operational_params", &fiction::operational_domain_params::operational_params,
+                       DOC(fiction_operational_domain_params_operational_params))
         .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))
 
         ;
 

bindings/pyfiction/include/pyfiction/layouts/cell_level_layout.hpp

@@ -70,7 +70,7 @@ void fcn_technology_cell_level_layout(pybind11::module& m)
     }
     else if constexpr (std::is_same_v<Technology, fiction::sidb_technology>)
     {
-        // no additional cell types required
+        cell_type.value("LOGIC", Technology::cell_type::LOGIC);
     }
     // NOTE: more technologies go here