✨ Added timeout for QuickSim

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

@@ -46,8 +46,9 @@ inline void quicksim(pybind11::module& m)
         .def_readwrite("alpha", &fiction::quicksim_params::alpha, DOC(fiction_quicksim_params_alpha))
         .def_readwrite("number_threads", &fiction::quicksim_params::number_threads,
                        DOC(fiction_quicksim_params_number_threads))
+        .def_readwrite("timeout", &fiction::quicksim_params::timeout, DOC(fiction_quicksim_params_timeout));
 
-        ;
+    ;
 
     // NOTE be careful with the order of the following calls! Python will resolve the first matching overload!
 

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

@@ -14,19 +14,77 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 
+#include <any>
+#include <cstdint>
+#include <stdexcept>
 #include <string>
+#include <unordered_map>
 
 namespace pyfiction
 {
 
 namespace detail
 {
 
+namespace py = pybind11;
+
+// Helper function to convert std::any to Python objects
+inline py::object convert_any_to_py(const std::any& value)
+{
+    try
+    {
+        if (value.type() == typeid(int))
+        {
+            return py::int_(std::any_cast<int>(value));
+        }
+        else if (value.type() == typeid(double))
+        {
+            return py::float_(std::any_cast<double>(value));
+        }
+        else if (value.type() == typeid(bool))
+        {
+            return py::bool_(std::any_cast<bool>(value));
+        }
+        else if (value.type() == typeid(std::string))
+        {
+            return py::str(std::any_cast<std::string>(value));
+        }
+        else if (value.type() == typeid(uint64_t))
+        {
+            return pybind11::int_(std::any_cast<uint64_t>(value));
+        }
+        else
+        {
+            throw std::runtime_error(std::string("Unsupported type in std::any: ") + value.type().name());
+        }
+    }
+    catch (const std::exception& e)
+    {
+        throw std::runtime_error(std::string("Error in convert_any_to_py: ") + e.what());
+    }
+}
+
+inline py::dict convert_map_to_py(const std::unordered_map<std::string, std::any>& map)
+{
+    pybind11::dict result;
+    for (const auto& [key, value] : map)
+    {
+        try
+        {
+            result[key.c_str()] = convert_any_to_py(value);
+        }
+        catch (const std::exception& e)
+        {
+            throw std::runtime_error(fmt::format("Error converting key: {}", e.what()));
+        }
+    }
+    return result;
+}
+
 template <typename Lyt>
 void sidb_simulation_result(pybind11::module& m, const std::string& lattice = "")
 {
     namespace py = pybind11;
-    namespace py = pybind11;
 
     py::class_<fiction::sidb_simulation_result<Lyt>>(m, fmt::format("sidb_simulation_result{}", lattice).c_str(),
                                                      DOC(fiction_sidb_simulation_result))
@@ -39,16 +97,17 @@ void sidb_simulation_result(pybind11::module& m, const std::string& lattice = ""
                        DOC(fiction_sidb_simulation_result_charge_distributions))
         .def_readwrite("simulation_parameters", &fiction::sidb_simulation_result<Lyt>::simulation_parameters,
                        DOC(fiction_sidb_simulation_result_simulation_parameters))
-        .def_readwrite("additional_simulation_parameters",
-                       &fiction::sidb_simulation_result<Lyt>::additional_simulation_parameters,
-                       DOC(fiction_sidb_simulation_result_additional_simulation_parameters));
+        .def_property_readonly(
+            "additional_simulation_parameters", [](const fiction::sidb_simulation_result<Lyt>& self)
+            { return convert_map_to_py(self.additional_simulation_parameters); },
+            DOC(fiction_sidb_simulation_result_additional_simulation_parameters));
 }
 
 }  // namespace detail
 
 inline void sidb_simulation_result(pybind11::module& m)
 {
-    // NOTE be careful with the order of the following calls! Python will resolve the first matching overload!
+    // Define simulation result for specific lattices
     detail::sidb_simulation_result<py_sidb_100_lattice>(m, "_100");
     detail::sidb_simulation_result<py_sidb_111_lattice>(m, "_111");
 }

bindings/mnt/pyfiction/include/pyfiction/pybind11_mkdoc_docstrings.hpp

@@ -18236,6 +18236,8 @@ the number of available hardware threads.)doc";
 
 static const char *__doc_fiction_quicksim_params_simulation_parameters = R"doc(Simulation parameters for the simulation of the physical SiDB system.)doc";
 
+static const char *__doc_fiction_quicksim_params_timeout = R"doc(Timeout limit (in ms).)doc";
+
 static const char *__doc_fiction_random_coordinate =
 R"doc(Generates a random coordinate within the region spanned by two given
 coordinates. The two given coordinates form the top left corner and
@@ -19877,7 +19879,7 @@ R"doc(Default constructor. It only exists to allow for the use of
 
 static const char *__doc_fiction_sidb_simulation_result_simulation_parameters = R"doc(Physical parameters used in the simulation.)doc";
 
-static const char *__doc_fiction_sidb_simulation_result_simulation_runtime = R"doc(Total simulation runtime.)doc";
+static const char *__doc_fiction_sidb_simulation_result_simulation_runtime = R"doc(Total simulation runtime in seconds.)doc";
 
 static const char *__doc_fiction_sidb_skeleton_bestagon_library =
 R"doc(This library contains SiDB I/O wires designed for both 1- and 2-input

bindings/mnt/pyfiction/test/algorithms/simulation/sidb/test_quicksim.py

@@ -80,6 +80,19 @@ def test_perturber_and_sidb_pair_111(self):
         self.assertEqual(groundstate[0].get_charge_state((2, 0)), sidb_charge_state.NEUTRAL)
         self.assertEqual(groundstate[0].get_charge_state((3, 0)), sidb_charge_state.NEGATIVE)
 
+        # test timeout
+        params.timeout = 1
+        params.iteration_steps = 10000
+        params.number_threads = 1
+        result_timeout_1 = quicksim(layout, params)
+        groundstate_timeout_1 = groundstate_from_simulation_result(result_timeout_1)
+        print(groundstate_timeout_1)
+
+        print(result_timeout_1.additional_simulation_parameters)
+        self.assertEqual(result_timeout_1.additional_simulation_parameters["alpha"], 0.7)
+        self.assertEqual(result_timeout_1.additional_simulation_parameters["iteration_steps"], 10000)
+        self.assertTrue(result_timeout_1.additional_simulation_parameters["timeout_reached"])
+
 
 if __name__ == "__main__":
     unittest.main()

bindings/mnt/pyfiction/test/algorithms/simulation/sidb/test_sidb_simulation_result.py

@@ -16,44 +16,100 @@
 
 class TestSiDBSimulationResult(unittest.TestCase):
     def test_negative_and_neutral_layout_100_lattice(self):
-        # Use standard constructor.
+        """Test ground state calculation for a negative and neutral layout on the 100 lattice."""
+        # Initialize the result object.
         result = sidb_simulation_result_100()
 
+        # Create a 2x3 lattice and assign NORMAL cell types.
         layout = sidb_100_lattice((2, 3))
         layout.assign_cell_type((0, 1), sidb_technology.cell_type.NORMAL)
         layout.assign_cell_type((0, 3), sidb_technology.cell_type.NORMAL)
 
+        # Generate charge distributions for negative and neutral states.
         cds_negative = charge_distribution_surface_100(layout)
-
         cds_neutral = charge_distribution_surface_100(layout, sidb_simulation_parameters(), sidb_charge_state.NEUTRAL)
 
+        # Assign charge distributions to the result.
         result.charge_distributions = [cds_negative, cds_neutral]
 
+        # Calculate the ground state from the simulation result.
         groundstate = groundstate_from_simulation_result(result)
 
-        self.assertEqual(len(groundstate), 1)
-        self.assertEqual(groundstate[0].get_charge_state((0, 1)), sidb_charge_state.NEUTRAL)
-        self.assertEqual(groundstate[0].get_charge_state((0, 3)), sidb_charge_state.NEUTRAL)
+        # Validate ground state results.
+        self.assertEqual(len(groundstate), 1, "Expected exactly one ground state.")
+        self.assertEqual(
+            groundstate[0].get_charge_state((0, 1)),
+            sidb_charge_state.NEUTRAL,
+            "Cell (0, 1) should have a NEUTRAL charge state.",
+        )
+        self.assertEqual(
+            groundstate[0].get_charge_state((0, 3)),
+            sidb_charge_state.NEUTRAL,
+            "Cell (0, 3) should have a NEUTRAL charge state.",
+        )
 
     def test_negative_and_neutral_layout_111_lattice(self):
-        # Use standard constructor.
+        """Test ground state calculation for a negative and neutral layout on the 111 lattice."""
+        # Initialize the result object.
         result = sidb_simulation_result_111()
 
+        # Create a 2x3 lattice and assign NORMAL cell types.
         layout = sidb_111_lattice((2, 3))
         layout.assign_cell_type((0, 1), sidb_technology.cell_type.NORMAL)
         layout.assign_cell_type((0, 3), sidb_technology.cell_type.NORMAL)
 
+        # Generate charge distributions for negative and neutral states.
         cds_negative = charge_distribution_surface_111(layout)
-
         cds_neutral = charge_distribution_surface_111(layout, sidb_simulation_parameters(), sidb_charge_state.NEUTRAL)
 
+        # Assign charge distributions to the result.
         result.charge_distributions = [cds_negative, cds_neutral]
 
+        # Calculate the ground state from the simulation result.
+        groundstate = groundstate_from_simulation_result(result)
+
+        # Validate ground state results.
+        self.assertEqual(len(groundstate), 1, "Expected exactly one ground state.")
+        self.assertEqual(
+            groundstate[0].get_charge_state((0, 1)),
+            sidb_charge_state.NEUTRAL,
+            "Cell (0, 1) should have a NEUTRAL charge state.",
+        )
+        self.assertEqual(
+            groundstate[0].get_charge_state((0, 3)),
+            sidb_charge_state.NEUTRAL,
+            "Cell (0, 3) should have a NEUTRAL charge state.",
+        )
+
+    def test_empty_layout_100_lattice(self):
+        """Test handling of an empty layout on the 100 lattice."""
+        result = sidb_simulation_result_100()
+
+        layout = sidb_100_lattice((0, 0))  # Empty layout
+
+        # Attempting to generate charge distributions should not throw errors.
+        cds_empty = charge_distribution_surface_100(layout)
+
+        # Assign the empty distribution and check ground state handling.
+        result.charge_distributions = [cds_empty]
+        groundstate = groundstate_from_simulation_result(result)
+
+        self.assertEqual(len(groundstate), 1)
+
+    def test_empty_layout_111_lattice(self):
+        """Test handling of an empty layout on the 111 lattice."""
+        result = sidb_simulation_result_111()
+
+        layout = sidb_111_lattice((0, 0))  # Empty layout
+
+        # Attempting to generate charge distributions should not throw errors.
+        cds_empty = charge_distribution_surface_111(layout)
+
+        # Assign the empty distribution and check ground state handling.
+        result.charge_distributions = [cds_empty]
         groundstate = groundstate_from_simulation_result(result)
 
         self.assertEqual(len(groundstate), 1)
-        self.assertEqual(groundstate[0].get_charge_state((0, 1)), sidb_charge_state.NEUTRAL)
-        self.assertEqual(groundstate[0].get_charge_state((0, 3)), sidb_charge_state.NEUTRAL)
 
 
 if __name__ == "__main__":

include/fiction/algorithms/simulation/sidb/quicksim.hpp

@@ -14,14 +14,15 @@
 #include <mockturtle/utils/stopwatch.hpp>
 
 #include <algorithm>
+#include <chrono>
 #include <cstdint>
+#include <limits>
 #include <mutex>
 #include <thread>
 #include <vector>
 
 namespace fiction
 {
-
 /**
  * This struct stores the parameters for the *QuickSim* algorithm.
  */
@@ -43,6 +44,10 @@ struct quicksim_params
      * Number of threads to spawn. By default the number of threads is set to the number of available hardware threads.
      */
     uint64_t number_threads{std::thread::hardware_concurrency()};
+    /**
+     * Timeout limit (in ms).
+     */
+    uint64_t timeout = std::numeric_limits<uint64_t>::max();
 };
 
 /**
@@ -80,9 +85,21 @@ sidb_simulation_result<Lyt> quicksim(const Lyt& lyt, const quicksim_params& ps =
     st.simulation_parameters = ps.simulation_parameters;
     st.charge_distributions.reserve(ps.iteration_steps);
 
+    if (ps.timeout == 0)
+    {
+        st.additional_simulation_parameters.emplace("timeout_reached", true);
+        return st;
+    }
+
+    bool timeout_limit_reached = false;
+
     mockturtle::stopwatch<>::duration time_counter{};
 
+    // Track the start time for timeout
+    auto start_time = std::chrono::high_resolution_clock::now();
+
     // measure run time (artificial scope)
+    // main loop
     {
         const mockturtle::stopwatch stop{time_counter};
 
@@ -150,14 +167,23 @@ sidb_simulation_result<Lyt> quicksim(const Lyt& lyt, const quicksim_params& ps =
 
                     for (uint64_t l = 0ul; l < iter_per_thread; ++l)
                     {
+                        // Check if the timeout has been reached before starting the iterations
+                        const auto current_time = std::chrono::high_resolution_clock::now();
+                        const auto elapsed_time =
+                            std::chrono::duration_cast<std::chrono::milliseconds>(current_time - start_time).count();
+
+                        if (elapsed_time >= static_cast<decltype(elapsed_time)>(ps.timeout))
+                        {
+                            timeout_limit_reached = true;
+                            return;  // Exit the thread if the timeout has been reached
+                        }
+
                         for (uint64_t i = 0ul; i < charge_lyt.num_cells(); ++i)
                         {
+                            if (std::find(negative_sidb_indices.cbegin(), negative_sidb_indices.cend(), i) !=
+                                negative_sidb_indices.cend())
                             {
-                                if (std::find(negative_sidb_indices.cbegin(), negative_sidb_indices.cend(), i) !=
-                                    negative_sidb_indices.cend())
-                                {
-                                    continue;
-                                }
+                                continue;
                             }
 
                             std::vector<uint64_t> index_start{i};
@@ -209,6 +235,11 @@ sidb_simulation_result<Lyt> quicksim(const Lyt& lyt, const quicksim_params& ps =
 
     st.simulation_runtime = time_counter;
 
+    if (timeout_limit_reached)
+    {
+        st.additional_simulation_parameters.emplace("timeout_reached", true);
+    }
+
     return st;
 }
 

include/fiction/algorithms/simulation/sidb/sidb_simulation_result.hpp

@@ -41,7 +41,7 @@ struct sidb_simulation_result
      */
     std::string algorithm_name{};
     /**
-     * Total simulation runtime.
+     * Total simulation runtime in seconds.
      */
     std::chrono::duration<double> simulation_runtime{};
     /**

test/algorithms/simulation/sidb/quicksim.cpp

@@ -438,6 +438,17 @@ TEMPLATE_TEST_CASE("QuickSim simulation of a Y-shaped SiDB OR gate with input 01
         check_for_absence_of_positive_charges(simulation_results);
         check_for_runtime_measurement(simulation_results);
         check_charge_configuration(simulation_results);
+
+        SECTION("timeout with 0 ms")
+        {
+            quicksim_params.timeout                 = 0;
+            const auto simulation_results_timeout_0 = quicksim<TestType>(lyt, quicksim_params);
+
+            CHECK(simulation_results_timeout_0.charge_distributions.empty());
+            CHECK(simulation_results_timeout_0.simulation_runtime.count() == 0);
+            CHECK(std::any_cast<bool>(
+                simulation_results_timeout_0.additional_simulation_parameters.at("timeout_reached")));
+        }
     }
 }
 
@@ -1095,4 +1106,17 @@ TEMPLATE_TEST_CASE("QuickSim AND gate simulation on the Si-111 surface", "[quick
 
         CHECK(ground_state.front().get_charge_state({23, 29, 1}) == sidb_charge_state::NEGATIVE);
     }
+
+    SECTION("timeout with 100 ms")
+    {
+        auto                  lyt = blueprints::and_gate_111<TestType>();
+        const quicksim_params params{sidb_simulation_parameters{2, -0.32, 5.6, 5}, 3000, 0.5, 1, 100};
+        const auto            simulation_results_timeout_100 = quicksim<TestType>(lyt, params);
+
+        check_for_absence_of_positive_charges(simulation_results_timeout_100);
+        CHECK_THAT(mockturtle::to_seconds(simulation_results_timeout_100.simulation_runtime) * 1000,
+                   Catch::Matchers::WithinAbs(100, 5));
+        CHECK(
+            std::any_cast<bool>(simulation_results_timeout_100.additional_simulation_parameters.at("timeout_reached")));
+    }
 }