✨ Added temperature-aware operational domain simulation.

bindings/mnt/pyfiction/__init__.py

@@ -101,6 +101,11 @@
     create_xor_tt,
     ## properties
     critical_path_length_and_throughput,
+    critical_temperature_domain,
+    critical_temperature_domain_contour_tracing,
+    critical_temperature_domain_flood_fill,
+    critical_temperature_domain_grid_search,
+    critical_temperature_domain_random_sampling,
     critical_temperature_gate_based,
     critical_temperature_non_gate_based,
     critical_temperature_params,
@@ -304,13 +309,16 @@
     wiring_reduction,
     wiring_reduction_params,
     wiring_reduction_stats,
+    write_critical_temperature_domain,
+    write_critical_temperature_domain_to_string,
     write_dot_layout,
     write_dot_network,
     write_fgl_layout,
     write_fqca_layout,
     write_fqca_layout_params,
     write_operational_domain,
     write_operational_domain_params,
+    write_operational_domain_to_string,
     write_qca_layout,
     write_qca_layout_params,
     write_qca_layout_svg,
@@ -408,6 +416,11 @@
     "create_xor_tt",
     ## properties
     "critical_path_length_and_throughput",
+    "critical_temperature_domain",
+    "critical_temperature_domain_contour_tracing",
+    "critical_temperature_domain_flood_fill",
+    "critical_temperature_domain_grid_search",
+    "critical_temperature_domain_random_sampling",
     "critical_temperature_gate_based",
     "critical_temperature_non_gate_based",
     "critical_temperature_params",
@@ -611,13 +624,16 @@
     "wiring_reduction",
     "wiring_reduction_params",
     "wiring_reduction_stats",
+    "write_critical_temperature_domain",
+    "write_critical_temperature_domain_to_string",
     "write_dot_layout",
     "write_dot_network",
     "write_fgl_layout",
     "write_fqca_layout",
     "write_fqca_layout_params",
     "write_operational_domain",
     "write_operational_domain_params",
+    "write_operational_domain_to_string",
     "write_qca_layout",
     "write_qca_layout_params",
     "write_qca_layout_svg",

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

@@ -8,13 +8,13 @@
 #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
@@ -28,21 +28,49 @@ void operational_domain(pybind11::module& m)
 {
     namespace py = pybind11;
 
-    m.def("operational_domain_grid_search", &fiction::operational_domain_grid_search<Lyt, py_tt>, py::arg("lyt"),
-          py::arg("spec"), py::arg("params") = fiction::operational_domain_params{}, py::arg("stats") = nullptr,
-          DOC(fiction_operational_domain_grid_search));
+    m.def(fmt::format("operational_domain_grid_search").c_str(), &fiction::operational_domain_grid_search<Lyt, py_tt>,
+          py::arg("lyt"), py::arg("spec"), py::arg("params") = fiction::operational_domain_params{},
+          py::arg("stats") = nullptr, DOC(fiction_operational_domain_grid_search));
 
-    m.def("operational_domain_random_sampling", &fiction::operational_domain_random_sampling<Lyt, py_tt>,
-          py::arg("lyt"), py::arg("spec"), py::arg("samples"), py::arg("params") = fiction::operational_domain_params{},
-          py::arg("stats") = nullptr, DOC(fiction_operational_domain_random_sampling));
+    m.def(fmt::format("operational_domain_random_sampling").c_str(),
+          &fiction::operational_domain_random_sampling<Lyt, py_tt>, py::arg("lyt"), py::arg("spec"), py::arg("samples"),
+          py::arg("params") = fiction::operational_domain_params{}, py::arg("stats") = nullptr,
+          DOC(fiction_operational_domain_random_sampling));
 
-    m.def("operational_domain_flood_fill", &fiction::operational_domain_flood_fill<Lyt, py_tt>, py::arg("lyt"),
-          py::arg("spec"), py::arg("samples"), py::arg("params") = fiction::operational_domain_params{},
+    m.def(fmt::format("operational_domain_flood_fill").c_str(), &fiction::operational_domain_flood_fill<Lyt, py_tt>,
+          py::arg("lyt"), py::arg("spec"), py::arg("samples"), py::arg("params") = fiction::operational_domain_params{},
           py::arg("stats") = nullptr, DOC(fiction_operational_domain_flood_fill));
 
-    m.def("operational_domain_contour_tracing", &fiction::operational_domain_contour_tracing<Lyt, py_tt>,
-          py::arg("lyt"), py::arg("spec"), py::arg("samples"), py::arg("params") = fiction::operational_domain_params{},
-          py::arg("stats") = nullptr, DOC(fiction_operational_domain_contour_tracing));
+    m.def(fmt::format("operational_domain_contour_tracing").c_str(),
+          &fiction::operational_domain_contour_tracing<Lyt, py_tt>, py::arg("lyt"), py::arg("spec"), py::arg("samples"),
+          py::arg("params") = fiction::operational_domain_params{}, py::arg("stats") = nullptr,
+          DOC(fiction_operational_domain_contour_tracing));
+}
+
+template <typename Lyt>
+void critical_temperature_domain(pybind11::module& m)
+{
+    namespace py = pybind11;
+
+    m.def(fmt::format("critical_temperature_domain_grid_search").c_str(),
+          &fiction::operational_domain_grid_search<Lyt, py_tt>, py::arg("lyt"), py::arg("spec"),
+          py::arg("params") = fiction::operational_domain_params{}, py::arg("stats") = nullptr,
+          DOC(fiction_operational_domain_grid_search));
+
+    m.def(fmt::format("critical_temperature_domain_random_sampling").c_str(),
+          &fiction::operational_domain_random_sampling<Lyt, py_tt>, py::arg("lyt"), py::arg("spec"), py::arg("samples"),
+          py::arg("params") = fiction::operational_domain_params{}, py::arg("stats") = nullptr,
+          DOC(fiction_operational_domain_random_sampling));
+
+    m.def(fmt::format("critical_temperature_domain_flood_fill").c_str(),
+          &fiction::operational_domain_flood_fill<Lyt, py_tt>, py::arg("lyt"), py::arg("spec"), py::arg("samples"),
+          py::arg("params") = fiction::operational_domain_params{}, py::arg("stats") = nullptr,
+          DOC(fiction_operational_domain_flood_fill));
+
+    m.def(fmt::format("critical_temperature_domain_contour_tracing").c_str(),
+          &fiction::operational_domain_contour_tracing<Lyt, py_tt>, py::arg("lyt"), py::arg("spec"), py::arg("samples"),
+          py::arg("params") = fiction::operational_domain_params{}, py::arg("stats") = nullptr,
+          DOC(fiction_operational_domain_contour_tracing));
 }
 
 }  // namespace detail
@@ -71,28 +99,41 @@ inline void operational_domain(pybind11::module& m)
 
         ;
 
-    py::class_<fiction::operational_domain<fiction::parameter_point, fiction::operational_status>>(
-        m, "operational_domain", DOC(fiction_operational_domain))
+    py::class_<fiction::critical_temperature_domain>(m, "critical_temperature_domain", DOC(fiction_operational_domain))
         .def(py::init<>())
-        .def_readwrite("dimensions",
-                       &fiction::operational_domain<fiction::parameter_point, fiction::operational_status>::dimensions,
-                       DOC(fiction_operational_domain_dimensions))
-        .def_readwrite(
-            "influence_information",
-            &fiction::operational_domain<fiction::parameter_point, fiction::operational_status>::operational_values,
-            DOC(fiction_operational_domain_operational_values))
-
-        .def("get_value",
-             &fiction::operational_domain<fiction::parameter_point, fiction::operational_status>::get_value,
-             py::arg("point"), DOC(fiction_operational_domain_get_value))
+        .def_readwrite("dimensions", &fiction::critical_temperature_domain::dimensions,
+                       DOC(fiction_critical_temperature_domain_dimensions))
+        .def("get_value", &fiction::critical_temperature_domain::get_value, py::arg("point"))
+        .def("add_value", &fiction::critical_temperature_domain::add_value, py::arg("key"), py::arg("value"))
+        .def("number_of_values", &fiction::critical_temperature_domain::number_of_values)
+        .def("for_each",
+             [](const fiction::critical_temperature_domain& self, const py::function& py_callback)
+             {
+                 self.for_each(
+                     [&py_callback](const auto& key, const auto& value)
+                     {
+                         py_callback(key, value);  // Pass the key and value to the Python callback
+                     });
+             })
 
-        .def("add_value",
-             &fiction::operational_domain<fiction::parameter_point, fiction::operational_status>::add_value,
-             py::arg("key"), py::arg("value"), DOC(fiction_operational_domain_add_value))
+        ;
 
-        .def("get_domain",
-             &fiction::operational_domain<fiction::parameter_point, fiction::operational_status>::get_domain,
-             DOC(fiction_operational_domain_get_domain))
+    py::class_<fiction::operational_domain>(m, "operational_domain", DOC(fiction_operational_domain))
+        .def(py::init<>())
+        .def_readwrite("dimensions", &fiction::operational_domain::dimensions,
+                       DOC(fiction_operational_domain_dimensions))
+        .def("get_value", &fiction::operational_domain::get_value, py::arg("point"))
+        .def("add_value", &fiction::operational_domain::add_value, py::arg("key"), py::arg("value"))
+        .def("number_of_values", &fiction::operational_domain::number_of_values)
+        .def("for_each",
+             [](const fiction::operational_domain& self, const py::function& py_callback)
+             {
+                 self.for_each(
+                     [&py_callback](const auto& key, const auto& value)
+                     {
+                         py_callback(key, value);  // Pass the key and value to the Python callback
+                     });
+             })
 
         ;
 
@@ -118,9 +159,7 @@ inline void operational_domain(pybind11::module& m)
         .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))
-
-        ;
+                       DOC(fiction_operational_domain_params_sweep_dimensions));
 
     py::class_<fiction::operational_domain_stats>(m, "operational_domain_stats", DOC(fiction_operational_domain_stats))
         .def(py::init<>())
@@ -146,6 +185,9 @@ inline void operational_domain(pybind11::module& m)
 
     detail::operational_domain<py_sidb_100_lattice>(m);
     detail::operational_domain<py_sidb_111_lattice>(m);
+
+    detail::critical_temperature_domain<py_sidb_100_lattice>(m);
+    detail::critical_temperature_domain<py_sidb_111_lattice>(m);
 }
 
 }  // namespace pyfiction

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

@@ -37,21 +37,20 @@ inline void physically_valid_parameters(pybind11::module& m)
 {
     namespace py = pybind11;
 
-    py::class_<fiction::operational_domain<fiction::parameter_point, uint64_t>>(m, "physically_valid_parameters_domain")
+    py::class_<fiction::sidb_simulation_domain<fiction::parameter_point, uint64_t>>(
+        m, "physically_valid_parameters_domain")
         .def(py::init<>())
-        .def_readwrite("dimensions", &fiction::operational_domain<fiction::parameter_point, uint64_t>::dimensions)
-
         .def(
             "get_excited_state_number_for_parameter",
-            [](const fiction::operational_domain<fiction::parameter_point, uint64_t>& domain,
-               const fiction::parameter_point&                                        pp)
+            [](const fiction::sidb_simulation_domain<fiction::parameter_point, uint64_t>& domain,
+               const fiction::parameter_point&                                            pp)
             {
                 const auto result = domain.get_value(pp);
 
                 // Check if the result has a value
                 if (result.has_value())
                 {
-                    return result.value();
+                    return std::get<0>(result.value());
                 }
                 // If no value is present, raise a Python ValueError
                 throw py::value_error(

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

@@ -8,13 +8,73 @@
 #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 <fiction/io/write_operational_domain.hpp>
 
 #include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include <string>
+#include <string_view>
 
 namespace pyfiction
 {
 
+namespace detail
+{
+inline void write_operational_domain(pybind11::module& m)
+{
+    namespace py = pybind11;
+
+    // Function pointer for writing to a file
+    void (*write_operational_domain_pointer)(const fiction::operational_domain&, const std::string_view&,
+                                             const fiction::write_operational_domain_params&) =
+        &fiction::write_operational_domain;
+
+    // Define function using function pointer
+    m.def("write_operational_domain", write_operational_domain_pointer, py::arg("opdom"), py::arg("filename"),
+          py::arg("params"), DOC(fiction_write_operational_domain));
+
+    m.def(
+        "write_operational_domain_to_string",
+        [](const fiction::operational_domain&              opdom,
+           const fiction::write_operational_domain_params& params = {}) -> std::string
+        {
+            std::ostringstream oss;
+            fiction::write_operational_domain(opdom, oss, params);
+            return oss.str();
+        },
+        py::arg("opdom"), py::arg("params") = fiction::write_operational_domain_params{});
+}
+
+inline void write_critical_temperature_domain(pybind11::module& m)
+{
+    namespace py = pybind11;
+
+    // Function pointer for writing to a file
+    void (*write_critical_temperature_domain_pointer)(
+        const fiction::critical_temperature_domain&, const std::string_view&,
+        const fiction::write_operational_domain_params&) = &fiction::write_operational_domain;
+
+    // Define function using function pointer
+    m.def("write_critical_temperature_domain", write_critical_temperature_domain_pointer, py::arg("opdom"),
+          py::arg("filename"), py::arg("params"), DOC(fiction_critical_temperature_domain));
+
+    m.def(
+        "write_critical_temperature_domain_to_string",
+        [](const fiction::critical_temperature_domain&     opdom,
+           const fiction::write_operational_domain_params& params = {}) -> std::string
+        {
+            std::ostringstream oss;
+            fiction::write_operational_domain(opdom, oss, params);
+            return oss.str();
+        },
+        py::arg("opdom"), py::arg("params") = fiction::write_operational_domain_params{});
+}
+
+}  // namespace detail
+
 inline void write_operational_domain(pybind11::module& m)
 {
     namespace py = pybind11;
@@ -36,16 +96,10 @@ inline void write_operational_domain(pybind11::module& m)
         .def_readwrite("non_operational_tag", &fiction::write_operational_domain_params::non_operational_tag,
                        DOC(fiction_write_operational_domain_params_non_operational_tag))
         .def_readwrite("writing_mode", &fiction::write_operational_domain_params::writing_mode,
-                       DOC(fiction_write_operational_domain_params_writing_mode))
-
-        ;
+                       DOC(fiction_write_operational_domain_params_writing_mode));
 
-    void (*write_operational_domain_pointer)(
-        const fiction::operational_domain<fiction::parameter_point, fiction::operational_status>&,
-        const std::string_view&, const fiction::write_operational_domain_params&) = &fiction::write_operational_domain;
-
-    m.def("write_operational_domain", write_operational_domain_pointer, py::arg("opdom"), py::arg("filename"),
-          py::arg("params") = fiction::write_operational_domain_params{}, DOC(fiction_write_operational_domain));
+    detail::write_operational_domain(m);
+    detail::write_critical_temperature_domain(m);
 }
 
 }  // namespace pyfiction

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

@@ -64,7 +64,6 @@ inline void write_qca_layout_svg_impl(pybind11::module& m)
 void write_svg_layout(pybind11::module& m)
 {
     namespace py = pybind11;
-    namespace py = pybind11;
 
     py::enum_<fiction::write_sidb_layout_svg_params::color_mode>(m, "color_mode",
                                                                  DOC(fiction_write_sidb_layout_svg_params_color_mode))

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

@@ -32,7 +32,6 @@ template <typename Technology>
 void fcn_technology_cell_level_layout(pybind11::module& m)
 {
     namespace py = pybind11;
-    namespace py = pybind11;
 
     // fetch technology name
     auto tech_name = std::string{fiction::tech_impl_name<Technology>};