🎨 Refactored random layout design functions (cda-tum#678)

Drewniok · actions-user · web-flow · commit e356987bb5bb · 2025-02-27T16:32:26.000+01:00
* 🎨 restructure random layout design.

* 📝 Update pyfiction docstrings

Signed-off-by: GitHub Actions &lt;actions@github.com&gt;

* 📝 update docu.

* ✅ small fix.

* ⚗️ update experiment script after changes.

* ⚗️ update experiment script after changes.

* ⚗️ update experiment script after changes.

* 🎨 small fix.

* 🎨 remove missing todo.

* 🎨 implement Marcel's feedback.

* 📝 Update pyfiction docstrings

Signed-off-by: GitHub Actions &lt;actions@github.com&gt;

* 🎨 small fix.

* 🎨 implement Marcel's feedback.

* 🎨 implement Marcel's feedback.

* 📝 Update pyfiction docstrings

Signed-off-by: GitHub Actions &lt;actions@github.com&gt;

---------

Signed-off-by: GitHub Actions &lt;actions@github.com&gt;
Co-authored-by: GitHub Actions &lt;actions@github.com&gt;
diff --git a/bindings/mnt/pyfiction/include/pyfiction/algorithms/simulation/sidb/random_sidb_layout_generator.hpp b/bindings/mnt/pyfiction/include/pyfiction/algorithms/simulation/sidb/random_sidb_layout_generator.hpp
@@ -26,22 +26,20 @@ void random_layout_generator(pybind11::module& m)
 {
     namespace py = pybind11;
 
-    m.def("generate_random_sidb_layout", &fiction::generate_random_sidb_layout<Lyt>, py::arg("lyt_skeleton"),
+    m.def("generate_random_sidb_layout", &fiction::generate_random_sidb_layout<Lyt>,
           py::arg("params") = fiction::generate_random_sidb_layout_params<fiction::cell<Lyt>>{},
-          DOC(fiction_generate_random_sidb_layout));
+          py::arg("lyt_skeleton"), DOC(fiction_generate_random_sidb_layout));
 
     m.def("generate_multiple_random_sidb_layouts", &fiction::generate_multiple_random_sidb_layouts<Lyt>,
-          py::arg("lyt_skeleton"),
           py::arg("params") = fiction::generate_random_sidb_layout_params<fiction::cell<Lyt>>{},
-          DOC(fiction_generate_multiple_random_sidb_layouts));
+          py::arg("lyt_skeleton"), DOC(fiction_generate_multiple_random_sidb_layouts));
 }
 
 }  // namespace detail
 
 inline void random_sidb_layout_generator(pybind11::module& m)
 {
     namespace py = pybind11;
-    namespace py = pybind11;
 
     py::enum_<typename fiction::generate_random_sidb_layout_params<fiction::offset::ucoord_t>::positive_charges>(
         m, "positive_charges", DOC(fiction_generate_random_sidb_layout_params_positive_charges))
@@ -70,6 +68,9 @@ inline void random_sidb_layout_generator(pybind11::module& m)
         .def_readwrite("positive_sidbs",
                        &fiction::generate_random_sidb_layout_params<fiction::offset::ucoord_t>::positive_sidbs,
                        DOC(fiction_generate_random_sidb_layout_params_positive_sidbs))
+        .def_readwrite("simulation_parameters",
+                       &fiction::generate_random_sidb_layout_params<fiction::offset::ucoord_t>::simulation_parameters,
+                       DOC(fiction_generate_random_sidb_layout_params_simulation_parameters))
         .def_readwrite("maximal_attempts",
                        &fiction::generate_random_sidb_layout_params<fiction::offset::ucoord_t>::maximal_attempts,
                        DOC(fiction_generate_random_sidb_layout_params_maximal_attempts))
@@ -85,6 +86,7 @@ inline void random_sidb_layout_generator(pybind11::module& m)
     // NOTE be careful with the order of the following calls! Python will resolve the first matching overload!
     detail::random_layout_generator<py_sidb_100_lattice>(m);
     detail::random_layout_generator<py_sidb_111_lattice>(m);
+    detail::random_layout_generator<py_sidb_layout>(m);
 }
 
 }  // namespace pyfiction
diff --git a/bindings/mnt/pyfiction/include/pyfiction/pybind11_mkdoc_docstrings.hpp b/bindings/mnt/pyfiction/include/pyfiction/pybind11_mkdoc_docstrings.hpp
@@ -13469,39 +13469,40 @@ R"doc(For each routing objective that cannot be fulfilled in the given
 layout, this counter is incremented.)doc";
 
 static const char *__doc_fiction_generate_multiple_random_sidb_layouts =
-R"doc(Generates multiple unique random SiDB layouts by adding them to the
-provided layout skeleton. The layout skeleton serves as the starting
-layout to which SiDBs are added to create unique SiDB layouts.
+R"doc(Generates multiple random layouts featuring a random arrangement of
+SiDBs. These randomly placed dots can be incorporated into an existing
+layout skeleton that may be optionally provided.
 
 Template parameter ``Lyt``:
     SiDB cell-level SiDB layout type.
 
-Parameter ``lyt_skeleton``:
-    A layout to which random SiDBs are added to create unique layouts.
-
 Parameter ``params``:
     The parameters for generating the random SiDB layouts.
 
+Parameter ``skeleton``:
+    Optional layout to which random dots are added.
+
 Returns:
-    A vector containing the unique randomly generated SiDB layouts.)doc";
+    A vector containing the unique randomly generated SiDB layouts. If
+    the design is impossible, `std::nullopt`)doc";
 
 static const char *__doc_fiction_generate_random_sidb_layout =
-R"doc(Generates a random layout of SiDBs by adding them to the provided
-layout skeleton. The layout skeleton serves as the starting layout to
-which SiDBs are added to create the final layout.
+R"doc(Generates a layout featuring a random arrangement of SiDBs. These
+randomly placed dots can be incorporated into an existing layout
+skeleton that may be optionally provided.
 
 Template parameter ``Lyt``:
     SiDB cell-level SiDB layout type.
 
-Parameter ``lyt_skeleton``:
-    A layout to which random cells are added to create the final
-    layout.
-
 Parameter ``params``:
     The parameters for generating the random layout.
 
+Parameter ``skeleton``:
+    Optional layout to which random dots are added.
+
 Returns:
-    A randomly-generated layout of SiDBs.)doc";
+    A randomly generated SiDB layout, or `std::nullopt` if the process
+    failed due to conflicting parameters.)doc";
 
 static const char *__doc_fiction_generate_random_sidb_layout_params =
 R"doc(This struct stores the parameters for the
@@ -13550,7 +13551,7 @@ static const char *__doc_fiction_generate_random_sidb_layout_params_positive_sid
 R"doc(If positively charged SiDBs should be prevented, SiDBs are not placed
 closer than the minimal_spacing.)doc";
 
-static const char *__doc_fiction_generate_random_sidb_layout_params_sim_params = R"doc(Simulation parameters.)doc";
+static const char *__doc_fiction_generate_random_sidb_layout_params_simulation_parameters = R"doc(Simulation parameters.)doc";
 
 static const char *__doc_fiction_geometric_temperature_schedule =
 R"doc(A logarithmically decreasing temperature schedule. The temperature is
diff --git a/bindings/mnt/pyfiction/include/pyfiction/technology/charge_distribution_surface.hpp b/bindings/mnt/pyfiction/include/pyfiction/technology/charge_distribution_surface.hpp
@@ -32,7 +32,6 @@ template <typename Lyt>
 void charge_distribution_surface_layout(pybind11::module& m, const std::string& lattice = "")
 {
     namespace py = pybind11;
-    namespace py = pybind11;
 
     using py_cds = py_charge_distribution_surface_layout<Lyt>;
 
diff --git a/bindings/mnt/pyfiction/test/algorithms/simulation/sidb/test_random_sidb_layout_generator.py b/bindings/mnt/pyfiction/test/algorithms/simulation/sidb/test_random_sidb_layout_generator.py
@@ -1,10 +1,14 @@
 import unittest
 
 from mnt.pyfiction import (
+    charge_distribution_surface_100,
+    charge_distribution_surface_111,
+    generate_multiple_random_sidb_layouts,
     generate_random_sidb_layout,
     generate_random_sidb_layout_params,
     sidb_100_lattice,
     sidb_111_lattice,
+    sidb_layout,
 )
 
 
@@ -13,30 +17,67 @@ def test_area_with_one_sidb_100_lattice(self):
         params = generate_random_sidb_layout_params()
         params.number_of_sidbs = 1
         params.coordinate_pair = ((10, 10), (10, 10))
-        result_lyt = generate_random_sidb_layout(sidb_100_lattice(), params)
+        result_lyt = generate_random_sidb_layout(params, sidb_100_lattice())
         self.assertEqual(result_lyt.num_cells(), 1)
         cell = (result_lyt.cells())[0]
         self.assertEqual(cell.x, 10)
         self.assertEqual(cell.y, 10)
 
+    def test_area_with_five_sidb_layout(self):
+        params = generate_random_sidb_layout_params()
+        params.number_of_sidbs = 5
+        print(params.number_of_sidbs)
+        params.coordinate_pair = ((0, 0), (10, 10))
+        result_lyt = generate_random_sidb_layout(params, sidb_layout())
+        self.assertEqual(result_lyt.num_cells(), 5)
+
     def test_area_with_five_sidb_100_lattice(self):
         params = generate_random_sidb_layout_params()
         params.number_of_sidbs = 5
         print(params.number_of_sidbs)
         params.coordinate_pair = ((0, 0), (10, 10))
-        result_lyt = generate_random_sidb_layout(sidb_100_lattice(), params)
+        result_lyt = generate_random_sidb_layout(params, sidb_100_lattice())
+        self.assertEqual(result_lyt.num_cells(), 5)
+
+    def test_area_with_five_sidbs_cds_100(self):
+        params = generate_random_sidb_layout_params()
+        params.number_of_sidbs = 5
+        print(params.number_of_sidbs)
+        params.coordinate_pair = ((0, 0), (10, 10))
+        result_lyt = generate_random_sidb_layout(params, charge_distribution_surface_100())
+        self.assertEqual(result_lyt.num_cells(), 5)
+
+    def test_area_with_five_sidbs_cds_111(self):
+        params = generate_random_sidb_layout_params()
+        params.number_of_sidbs = 5
+        print(params.number_of_sidbs)
+        params.coordinate_pair = ((0, 0), (10, 10))
+        result_lyt = generate_random_sidb_layout(params, charge_distribution_surface_111())
         self.assertEqual(result_lyt.num_cells(), 5)
 
     def test_area_with_one_coordinate_111_lattice(self):
         params = generate_random_sidb_layout_params()
         params.number_of_sidbs = 1
         params.coordinate_pair = ((10, 10), (10, 10))
-        result_lyt = generate_random_sidb_layout(sidb_111_lattice(), params)
+        result_lyt = generate_random_sidb_layout(params, sidb_111_lattice())
         self.assertEqual(result_lyt.num_cells(), 1)
         cell = (result_lyt.cells())[0]
         self.assertEqual(cell.x, 10)
         self.assertEqual(cell.y, 10)
 
+    def test_impossible_design_of_single_layout(self):
+        params = generate_random_sidb_layout_params()
+        params.number_of_sidbs = 2
+        result_lyt = generate_random_sidb_layout(params, sidb_layout())
+        self.assertIsNone(result_lyt)
+
+    def test_impossible_design_of_mutiple_layouts(self):
+        params = generate_random_sidb_layout_params()
+        params.maximal_attempts_for_multiple_layouts = 5
+        params.number_of_sidbs = 2
+        result_lyt = generate_multiple_random_sidb_layouts(params, sidb_layout())
+        self.assertIsNone(result_lyt)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/experiments/random_sidb_layout_generation/random_sidb_layout_generation.cpp b/experiments/random_sidb_layout_generation/random_sidb_layout_generation.cpp
@@ -181,10 +181,15 @@ int main(int argc, const char* argv[])  // NOLINT
                 const generate_random_sidb_layout_params<offset::ucoord_t> params{
                     {{nw_x, nw_y}, {se_x, se_y}},         number_of_placed_sidbs,      charges,
                     sidb_simulation_parameters{3, -0.32}, static_cast<uint64_t>(10E6), number_of_layouts};
-                const auto unique_lyts = generate_multiple_random_sidb_layouts(sidb_100_cell_clk_lyt{}, params);
-                for (auto i = 0u; i < unique_lyts.size(); i++)
+                const auto unique_lyts = generate_multiple_random_sidb_layouts<sidb_100_cell_clk_lyt>(params);
+
+                if (unique_lyts.has_value())
                 {
-                    write_sqd_layout(unique_lyts[i], fmt::format("{}/layout_{}.sqd", dir_path_sqd.string(), i));
+                    for (auto i = 0u; i < unique_lyts.value().size(); i++)
+                    {
+                        write_sqd_layout(unique_lyts.value()[i],
+                                         fmt::format("{}/layout_{}.sqd", dir_path_sqd.string(), i));
+                    }
                 }
             }
             catch (const std::filesystem::filesystem_error& ex)
diff --git a/experiments/sidb_simulation/electrostatic_ground_state/runtime_analysis_layouts_with_possible_positive_sidbs.cpp b/experiments/sidb_simulation/electrostatic_ground_state/runtime_analysis_layouts_with_possible_positive_sidbs.cpp
@@ -9,6 +9,7 @@
 #include <fiction/algorithms/simulation/sidb/quickexact.hpp>
 #include <fiction/algorithms/simulation/sidb/random_sidb_layout_generator.hpp>
 #include <fiction/algorithms/simulation/sidb/sidb_simulation_parameters.hpp>
+#include <fiction/types.hpp>
 
 #include <mockturtle/utils/stopwatch.hpp>
 
@@ -52,15 +53,20 @@ int main()  // NOLINT
     {
         random_layouts_params.number_of_sidbs = num_sidbs;
 
-        const auto random_layouts = generate_multiple_random_sidb_layouts(Lyt{}, random_layouts_params);
+        const auto random_layouts = generate_multiple_random_sidb_layouts<Lyt>(random_layouts_params);
 
         double runtime_exhaustive = 0;
         double runtime_quickexact = 0;
 
         std::vector<std::size_t> number_of_positive_sidbs_of_gs_per_layout{};
         number_of_positive_sidbs_of_gs_per_layout.reserve(random_layouts_params.number_of_unique_generated_layouts);
 
-        for (const auto& layout : random_layouts)
+        if (!random_layouts.has_value())
+        {
+            continue;
+        }
+
+        for (const auto& layout : random_layouts.value())
         {
             const auto exhaustive_results_layout = exhaustive_ground_state_simulation(layout, sim_params);
 
@@ -80,7 +86,7 @@ int main()  // NOLINT
                                                 number_of_positive_sidbs_of_gs_per_layout.cend(), 0u)) /
             static_cast<double>(number_of_positive_sidbs_of_gs_per_layout.size());
 
-        simulation_exp(random_layouts_params.number_of_sidbs, random_layouts.size(), runtime_exhaustive,
+        simulation_exp(random_layouts_params.number_of_sidbs, random_layouts.value().size(), runtime_exhaustive,
                        runtime_quickexact, average_pos_sibs_of_gs);
 
         simulation_exp.save();
diff --git a/include/fiction/algorithms/physical_design/design_sidb_gates.hpp b/include/fiction/algorithms/physical_design/design_sidb_gates.hpp
@@ -328,36 +328,46 @@ class design_sidb_gates_impl
                 {
                     while (!gate_layout_is_found)
                     {
-                        auto result_lyt = generate_random_sidb_layout<Lyt>(skeleton_layout, parameter);
+                        auto result_lyt = generate_random_sidb_layout<Lyt>(parameter, skeleton_layout);
+
+                        if (!result_lyt.has_value())
+                        {
+                            continue;
+                        }
+
                         if constexpr (has_get_sidb_defect_v<Lyt>)
                         {
-                            result_lyt.foreach_sidb_defect(
+                            result_lyt.value().foreach_sidb_defect(
                                 [&result_lyt](const auto& cd)
                                 {
                                     if (is_neutrally_charged_defect(cd.second))
                                     {
-                                        result_lyt.assign_sidb_defect(cd.first, sidb_defect{sidb_defect_type::NONE});
+                                        result_lyt.value().assign_sidb_defect(cd.first,
+                                                                              sidb_defect{sidb_defect_type::NONE});
                                     }
                                 });
                         }
-                        if (const auto [status, sim_calls] = is_operational(
-                                result_lyt, truth_table, params.operational_params, input_bdl_wires, output_bdl_wires);
+
+                        if (const auto [status, sim_calls] =
+                                is_operational(result_lyt.value(), truth_table, params.operational_params,
+                                               input_bdl_wires, output_bdl_wires);
                             status == operational_status::OPERATIONAL)
                         {
                             const std::lock_guard lock{mutex_to_protect_designed_gate_layouts};
+
                             if constexpr (has_get_sidb_defect_v<Lyt>)
                             {
                                 skeleton_layout.foreach_sidb_defect(
                                     [&result_lyt](const auto& cd)
                                     {
                                         if (is_neutrally_charged_defect(cd.second))
                                         {
-                                            result_lyt.assign_sidb_defect(cd.first, cd.second);
+                                            result_lyt.value().assign_sidb_defect(cd.first, cd.second);
                                         }
                                     });
                             }
 
-                            randomly_designed_gate_layouts.push_back(result_lyt);
+                            randomly_designed_gate_layouts.push_back(result_lyt.value());
                             gate_layout_is_found = true;
                             break;
                         }
diff --git a/include/fiction/algorithms/simulation/sidb/random_sidb_layout_generator.hpp b/include/fiction/algorithms/simulation/sidb/random_sidb_layout_generator.hpp
diff --git a/test/algorithms/simulation/sidb/random_sidb_layout_generator.cpp b/test/algorithms/simulation/sidb/random_sidb_layout_generator.cpp

Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,6 @@ template <typename Lyt>`
`32`	`32`	`void charge_distribution_surface_layout(pybind11::module& m, const std::string& lattice = "")`
`33`	`33`	`{`
`34`	`34`	`namespace py = pybind11;`
`35`		`- namespace py = pybind11;`
`36`	`35`
`37`	`36`	`using py_cds = py_charge_distribution_surface_layout<Lyt>;`
`38`	`37`
Original file line number	Diff line number	Diff line change
`@@ -181,10 +181,15 @@ int main(int argc, const char* argv[]) // NOLINT`
`181`	`181`	`const generate_random_sidb_layout_params<offset::ucoord_t> params{`
`182`	`182`	`{{nw_x, nw_y}, {se_x, se_y}}, number_of_placed_sidbs, charges,`
`183`	`183`	`sidb_simulation_parameters{3, -0.32}, static_cast<uint64_t>(10E6), number_of_layouts};`
`184`		`- const auto unique_lyts = generate_multiple_random_sidb_layouts(sidb_100_cell_clk_lyt{}, params);`
`185`		`- for (auto i = 0u; i < unique_lyts.size(); i++)`
	`184`	`+ const auto unique_lyts = generate_multiple_random_sidb_layouts<sidb_100_cell_clk_lyt>(params);`
	`185`	`+`
	`186`	`+ if (unique_lyts.has_value())`
`186`	`187`	`{`
`187`		`- write_sqd_layout(unique_lyts[i], fmt::format("{}/layout_{}.sqd", dir_path_sqd.string(), i));`
	`188`	`+ for (auto i = 0u; i < unique_lyts.value().size(); i++)`
	`189`	`+ {`
	`190`	`+ write_sqd_layout(unique_lyts.value()[i],`
	`191`	`+ fmt::format("{}/layout_{}.sqd", dir_path_sqd.string(), i));`
	`192`	`+ }`
`188`	`193`	`}`
`189`	`194`	`}`
`190`	`195`	`catch (const std::filesystem::filesystem_error& ex)`
Original file line number	Diff line number	Diff line change
`@@ -328,36 +328,46 @@ class design_sidb_gates_impl`
`328`	`328`	`{`
`329`	`329`	`while (!gate_layout_is_found)`
`330`	`330`	`{`
`331`		`- auto result_lyt = generate_random_sidb_layout<Lyt>(skeleton_layout, parameter);`
	`331`	`+ auto result_lyt = generate_random_sidb_layout<Lyt>(parameter, skeleton_layout);`
	`332`	`+`
	`333`	`+ if (!result_lyt.has_value())`
	`334`	`+ {`
	`335`	`+ continue;`
	`336`	`+ }`
	`337`	`+`
`332`	`338`	`if constexpr (has_get_sidb_defect_v<Lyt>)`
`333`	`339`	`{`
`334`		`- result_lyt.foreach_sidb_defect(`
	`340`	`+ result_lyt.value().foreach_sidb_defect(`
`335`	`341`	`[&result_lyt](const auto& cd)`
`336`	`342`	`{`
`337`	`343`	`if (is_neutrally_charged_defect(cd.second))`
`338`	`344`	`{`
`339`		`- result_lyt.assign_sidb_defect(cd.first, sidb_defect{sidb_defect_type::NONE});`
	`345`	`+ result_lyt.value().assign_sidb_defect(cd.first,`
	`346`	`+ sidb_defect{sidb_defect_type::NONE});`
`340`	`347`	`}`
`341`	`348`	`});`
`342`	`349`	`}`
`343`		`- if (const auto [status, sim_calls] = is_operational(`
`344`		`- result_lyt, truth_table, params.operational_params, input_bdl_wires, output_bdl_wires);`
	`350`	`+`
	`351`	`+ if (const auto [status, sim_calls] =`
	`352`	`+ is_operational(result_lyt.value(), truth_table, params.operational_params,`
	`353`	`+ input_bdl_wires, output_bdl_wires);`
`345`	`354`	`status == operational_status::OPERATIONAL)`
`346`	`355`	`{`
`347`	`356`	`const std::lock_guard lock{mutex_to_protect_designed_gate_layouts};`
	`357`	`+`
`348`	`358`	`if constexpr (has_get_sidb_defect_v<Lyt>)`
`349`	`359`	`{`
`350`	`360`	`skeleton_layout.foreach_sidb_defect(`
`351`	`361`	`[&result_lyt](const auto& cd)`
`352`	`362`	`{`
`353`	`363`	`if (is_neutrally_charged_defect(cd.second))`
`354`	`364`	`{`
`355`		`- result_lyt.assign_sidb_defect(cd.first, cd.second);`
	`365`	`+ result_lyt.value().assign_sidb_defect(cd.first, cd.second);`
`356`	`366`	`}`
`357`	`367`	`});`
`358`	`368`	`}`
`359`	`369`
`360`		`- randomly_designed_gate_layouts.push_back(result_lyt);`
	`370`	`+ randomly_designed_gate_layouts.push_back(result_lyt.value());`
`361`	`371`	`gate_layout_is_found = true;`
`362`	`372`	`break;`
`363`	`373`	`}`