✨ Added function to generate random SiDB layouts and write simulation results to file.

docs/algorithms/sidb_simulation.rst

@@ -94,3 +94,13 @@ Time-to-Solution (TTS) Statistics
 **Header:** ``fiction/algorithms/simulation/sidb/time_to_solution.hpp``
 
 .. doxygenfunction:: fiction::sim_acc_tts
+
+
+Random Layout Generator
+#######################
+
+**Header:** ``fiction/algorithms/simulation/sidb/random_layout_generator.hpp``
+
+.. doxygenstruct:: fiction::random_layout_params
+.. doxygenfunction:: fiction::generate_random_layout
+.. doxygenfunction:: fiction::generate_multiple_random_layout

docs/io/physical_simulation.rst

@@ -64,6 +64,11 @@ SiQAD
 .. doxygenfunction:: fiction::write_sqd_sim_result(const sidb_simulation_result<Lyt>& sim_result, std::ostream& os)
 .. doxygenfunction:: fiction::write_sqd_sim_result(const sidb_simulation_result<Lyt>& sim_result, const std::string_view& filename)
 
+**Header:** ``fiction/io/write_txt_sim_result.hpp``
+
+.. doxygenfunction:: fiction::write_txt_sim_result(const sidb_simulation_result<Lyt>& sim_result, std::ostream& os)
+.. doxygenfunction:: fiction::write_txt_sim_result(const sidb_simulation_result<Lyt>& sim_result, const std::string_view& filename)
+
 **Header:** ``fiction/io/read_sqd_layout.hpp``
 
 .. doxygenfunction:: fiction::read_sqd_layout(std::istream& is, const std::string_view& name = "")

experiments/random_layout_generation/random_layout_generation.cpp

@@ -0,0 +1,96 @@
+//
+// Created by Jan Drewniok on 04.05.23.
+//
+
+#include <fiction/algorithms/simulation/sidb/random_layout_generator.hpp>
+#include <fiction/io/read_sqd_layout.hpp>
+#include <fiction/types.hpp>
+
+#include <filesystem>
+#include <iomanip>
+#include <iostream>
+#include <string>
+
+using namespace fiction;
+
+int main()  // NOLINT
+{
+    try
+    {
+        // This script generates random layouts as .sqd file.
+        using cell_level_layout = cell_level_layout<sidb_technology, clocked_layout<cartesian_layout<cube::coord_t>>>;
+        constexpr const char* folder_name = "random_layouts_test_new/";
+        std::filesystem::path folder_path(EXPERIMENTS_PATH);
+
+        folder_path /= folder_name;
+
+        if (std::filesystem::exists(folder_path))
+        {
+            std::cout << "Folder *" << folder_path << "* exists!" << std::endl;
+        }
+        else
+        {
+            if (std::filesystem::create_directory(folder_path))
+            {
+                std::cout << "Folder *random_layouts* created successfully" << std::endl;
+            }
+            else
+            {
+                std::cout << "Failed to create folder" << std::endl;
+            }
+        }
+        // number of randomly generated layouts for a given number of placed SiDBs.
+        const uint64_t number_of_layouts = 10;
+        // number of SiDBs of the first bunch of randomly generated layouts.
+        uint64_t number_of_sidbs_lower_limit = 20;
+        // number of SiDBs of the final bunch of randomly generated layouts.
+        uint64_t number_of_sidbs_upper_limit = 21;
+
+        if (number_of_sidbs_upper_limit < number_of_sidbs_lower_limit)
+        {
+            std::swap(number_of_sidbs_upper_limit, number_of_sidbs_lower_limit);
+        }
+
+        for (uint64_t num_sidbs = number_of_sidbs_lower_limit; num_sidbs < number_of_sidbs_upper_limit; num_sidbs++)
+        {
+            const std::filesystem::path dir_path = folder_path.string() + "number_sidbs_" + std::to_string(num_sidbs);
+            const std::filesystem::path dir_path_sqd =
+                folder_path.string() + "number_sidbs_" + std::to_string(num_sidbs) + "/sqd";
+            const std::filesystem::path dir_path_loc =
+                folder_path.string() + "number_sidbs_" + std::to_string(num_sidbs) + "/loc";
+            try
+            {
+                if (!std::filesystem::exists(dir_path))
+                {
+                    std::filesystem::create_directory(dir_path);
+                    std::cout << "Folder created." << std::endl;
+                    std::filesystem::create_directory(dir_path_sqd);
+                    std::filesystem::create_directory(dir_path_loc);
+                }
+                else
+                {
+                    std::cout << "Folder already exists." << std::endl;
+                }
+
+                const random_layout_params<cell_level_layout> params{{{0, 0}, {20, 20}}, num_sidbs, false};
+
+                const auto unique_lyts =
+                    generate_multiple_random_layout<cell_level_layout>(params, cell_level_layout{}, number_of_layouts);
+                for (auto i = 0u; i < unique_lyts.size(); i++)
+                {
+                    write_sqd_layout(unique_lyts[i], dir_path_sqd.string() + "/layout_" + std::to_string(i) + ".sqd");
+                }
+            }
+            catch (const std::filesystem::filesystem_error& ex)
+            {
+                // Exception is handled.
+                std::cerr << "Filesystem error: " << ex.what() << std::endl;
+            }
+        }
+    }
+    catch (const std::filesystem::filesystem_error& ex)
+    {
+        // Exception occurred, handle it here
+        std::cerr << "Filesystem error: " << ex.what() << std::endl;
+    }
+}

experiments/random_layout_generation/simulation_result_file.cpp

@@ -0,0 +1,80 @@
+//
+// Created by Jan Drewniok on 04.05.23.
+//
+
+#include "fiction/algorithms/simulation/sidb/exhaustive_ground_state_simulation.hpp"
+#include "fiction/io/read_sqd_layout.hpp"
+#include "fiction/io/write_txt_sim_result.hpp"
+#include "fiction/technology/charge_distribution_surface.hpp"
+#include "fiction/types.hpp"
+
+#include <cstdlib>
+#include <filesystem>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+using namespace fiction;
+
+int main()  // NOLINT
+{
+    // This script uses the randomly generated layouts (hence, random_layout_generation.cpp should be executed first),
+    // simulates them, and collects the simulation results as a text file. The text file has three columns: x,y, charge
+    // state (as integer) of the ground state.
+    try
+    {
+        constexpr const char* folder_name = "random_layouts_test_new/";
+        std::filesystem::path folder_path(EXPERIMENTS_PATH);
+        folder_path /= folder_name;
+
+        if (std::filesystem::exists(folder_path))
+        {
+            for (const auto& folder : std::filesystem::directory_iterator(folder_path))
+            {
+                if (std::filesystem::exists(folder_path))
+                {
+                    for (const auto& file : std::filesystem::directory_iterator(folder.path().string() + "/sqd"))
+                    {
+                        const auto& benchmark = file.path();
+
+                        // When random layouts are generated with the script random_layout_generation.cpp, they have the
+                        // following file name format: layout_xxx (xxx is the numbering). In the following code lines,
+                        // the file name of the current file is extracted from the file path.
+                        const std::string path  = benchmark.string();
+                        const uint64_t    start = path.rfind("layout") + 7;
+                        const uint64_t    end   = path.rfind(".sqd") - 1;
+                        const std::string name  = path.substr(start, end - start + 1);
+
+                        std::cout << benchmark << std::endl;
+
+                        auto lyt = read_sqd_layout<sidb_cell_clk_lyt_siqad>(benchmark.string());
+
+                        const sidb_simulation_parameters params{2, -0.32};
+                        const auto                       simulation_results =
+                            exhaustive_ground_state_simulation<sidb_cell_clk_lyt_siqad>(lyt, params);
+                        std::stringstream ss;
+                        ss << std::fixed << std::setprecision(3) << -params.mu;
+                        std::string const file_path =
+                            folder.path().string() + "/loc/" + name + "_sim_µ_minus_" + ss.str() + ".txt";
+                        write_txt_sim_result(simulation_results, file_path);
+                    }
+                }
+                else
+                {
+                    std::cout << "Folder" + std::string("/sqd") + "does not exist." << std::endl;
+                }
+            }
+        }
+        else
+        {
+            std::cout << "Folder" + std::string(folder_name) + "does not exist." << std::endl;
+        }
+    }
+    catch (const std::filesystem::filesystem_error& ex)
+    {
+        std::cerr << "Error accessing folder: " << ex.what() << std::endl;
+    }
+
+    return EXIT_SUCCESS;
+}

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

@@ -0,0 +1,178 @@
+//
+// Created by Jan Drewniok on 05.04.23.
+//
+
+#ifndef FICTION_RANDOM_LAYOUT_GENERATOR_HPP
+#define FICTION_RANDOM_LAYOUT_GENERATOR_HPP
+
+#include "fiction/algorithms/path_finding/distance.hpp"
+#include "fiction/io/write_sqd_layout.hpp"
+#include "fiction/layouts/cell_level_layout.hpp"
+#include "fiction/technology/cell_technologies.hpp"
+#include "fiction/technology/charge_distribution_surface.hpp"
+#include "fiction/technology/sidb_nm_position.hpp"
+#include "fiction/traits.hpp"
+#include "fiction/types.hpp"
+#include "fiction/utils/hash.hpp"
+#include "fiction/utils/layout_utils.hpp"
+
+#include <cstdint>
+#include <iostream>
+#include <random>
+#include <string_view>
+#include <unordered_set>
+#include <vector>
+
+namespace fiction
+{
+/**
+ * This struct stores the parameters for the *generate_random_layout* algorithm.
+ */
+template <typename Lyt>
+struct random_layout_params
+{
+    /**
+     * Two coordinates that span the region where SiDBs may be placed (order is not important).
+     */
+    std::pair<typename Lyt::cell, typename Lyt::cell> coordinate_pair;
+    /**
+     * Number of SiDBs that are placed on the layout.
+     */
+    uint64_t number_of_sidbs = 0;
+    /**
+     * If positively charged SiDBs should be prevented, SiDBs are not placed closer than the minimal_spacing.
+     */
+    bool prevent_positive_charges = true;
+    /**
+     * If positively charged SiDBs should be prevented, SiDBs are not placed closer than this value (2 cells as
+     * Euclidean distance by default).
+     */
+    double minimal_spacing = 2;
+    /**
+     * Maximal number of steps to place the given number of SiDBs.
+     */
+    uint64_t maximal_attempts = 10E6;
+};
+
+/**
+ * Generates a random layout of SiDBs based on the provided parameters.
+ *
+ * @tparam Lyt The layout type.
+ * @param params The parameters for generating the random layout.
+ * @param lyt_skeleton A layout to which random cells are added (useful if you need to add random cells to a given
+ * layout).
+ * @return A randomly generated layout of SiDBs.
+ */
+template <typename Lyt>
+Lyt generate_random_layout(const random_layout_params<Lyt>& params, const Lyt& lyt_skeleton)
+{
+    static_assert(is_cell_level_layout_v<Lyt>, "Lyt is not a cell-level layout");
+
+    const uint64_t number_of_sidbs_of_final_layout = lyt_skeleton.num_cells() + params.number_of_sidbs;
+
+    Lyt lyt{};
+
+    if (lyt_skeleton.num_cells() != 0)
+    {
+        lyt_skeleton.foreach_cell([&lyt, &lyt_skeleton](const auto& cell)
+                                  { lyt.assign_cell_type(cell, lyt_skeleton.get_cell_type(cell)); });
+    }
+
+    bool     successful_generation = false;
+    uint64_t attempt_counter       = 0;
+
+    // Stops if either all SiDBs are placed or the maximum number of attempts were performed.
+    while (lyt.num_cells() < number_of_sidbs_of_final_layout && attempt_counter < params.maximal_attempts)
+    {
+        const auto random_coord = random_coordinate(params.coordinate_pair.first, params.coordinate_pair.second);
+
+        bool constraint_violation_positive_sidbs = false;
+
+        if (params.prevent_positive_charges)
+        {
+            // Checks if the new coordinate is not closer than 2 cells (Euclidean distance) from an already
+            // placed SiDB.
+            lyt.foreach_cell(
+                [&lyt, &random_coord, &constraint_violation_positive_sidbs, &params](const auto& c1)
+                {
+                    if (euclidean_distance<Lyt>(lyt, c1, random_coord) < params.minimal_spacing)
+                    {
+                        constraint_violation_positive_sidbs = true;
+                    }
+                });
+        }
+        // If the constraint that no positive SiDBs occur is satisfied, the SiDB is added to the layout.
+        if (!constraint_violation_positive_sidbs)
+        {
+            lyt.assign_cell_type(random_coord, Lyt::cell_type::NORMAL);
+        }
+        attempt_counter += 1;
+    }
+
+    return lyt;
+}
+
+/**
+ * Generates multiple unique random layouts of SiDBs based on the provided parameters.
+ *
+ * @tparam Lyt The layout type.
+ * @param params The parameters for generating the random layouts.
+ * @param lyt_skeleton A layout to which random cells are added (useful if you need to add random cells to a given
+ * layout).
+ * @param number_of_unique_generated_layouts The desired number of unique layouts to be generated.
+ * @param maximal_attempts The maximum number of attempts allowed to generate a unique layout (default: \f$ 10^{6} \f$).
+ * @return A vector containing the unique randomly generated layouts.
+ */
+template <typename Lyt>
+std::vector<Lyt> generate_multiple_random_layout(const random_layout_params<Lyt>& params, const Lyt& lyt_skeleton,
+                                                 const uint64_t number_of_unique_generated_layouts,
+                                                 const uint64_t maximal_attemps = 10E6)
+{
+    static_assert(is_cell_level_layout_v<Lyt>, "Lyt is not a cell-level layout");
+
+    std::vector<Lyt> unique_lyts{};
+    unique_lyts.reserve(number_of_unique_generated_layouts);
+    uint64_t counter = 0;
+    while (unique_lyts.size() < number_of_unique_generated_layouts && counter < maximal_attemps)
+    {
+        const auto random_lyt = generate_random_layout(params, lyt_skeleton);
+
+        uint64_t identical_layout_counter = 0;
+        for (const auto& old_lyt : unique_lyts)
+        {
+            // Checks if two layouts have the same cell.
+            uint64_t identical_cell_counter = 0;
+            old_lyt.foreach_cell(
+                [&identical_cell_counter, random_lyt](const auto& cell_old)
+                {
+                    random_lyt.foreach_cell(
+                        [&identical_cell_counter, &cell_old](const auto& cell_new)
+                        {
+                            if (cell_new == cell_old)
+                            {
+                                identical_cell_counter += 1;
+                            }
+                        });
+                });
+
+            // all cells are identical, so the new layout is a duplicate.
+            if (identical_cell_counter == random_lyt.num_cells())
+            {
+                identical_layout_counter += 1;
+            }
+        }
+
+        if (identical_layout_counter == 0)
+        {
+            unique_lyts.push_back(random_lyt);
+        }
+
+        counter += 1;
+    }
+
+    return unique_lyts;
+}
+
+}  // namespace fiction
+
+#endif  // FICTION_RANDOM_LAYOUT_GENERATOR_HPP