✨ Added conversion functions for layouts of different coordinate types

docs/utils/utils.rst

@@ -54,6 +54,9 @@ Layout Utils
 .. doxygenfunction:: fiction::num_adjacent_coordinates
 .. doxygenfunction:: fiction::relative_to_absolute_cell_position
 .. doxygenfunction:: fiction::port_direction_to_coordinate
+.. doxygenfunction:: fiction::lyt_coordinates_to_siqad
+.. doxygenfunction:: fiction::lyt_coordinates_to_fiction
+.. doxygenfunction:: fiction::normalize_layout_coordinates
 
 
 Placement Utils

include/fiction/traits.hpp

@@ -575,6 +575,8 @@ template <typename Lyt>
 inline constexpr const bool has_sidb_technology_v = std::is_same_v<technology<Lyt>, sidb_technology>;
 template <typename Lyt>
 inline constexpr const bool has_siqad_coord_v = std::is_same_v<coordinate<Lyt>, siqad::coord_t>;
+template <typename Lyt>
+inline constexpr const bool has_offset_ucoord_v = std::is_same_v<coordinate<Lyt>, offset::ucoord_t>;
 
 #pragma region is_cell_level_layout
 template <class Lyt, class = void>

include/fiction/utils/layout_utils.hpp

@@ -5,8 +5,11 @@
 #ifndef FICTION_LAYOUT_UTILS_HPP
 #define FICTION_LAYOUT_UTILS_HPP
 
+#include "fiction/layouts/cell_level_layout.hpp"
+#include "fiction/layouts/coordinates.hpp"
 #include "fiction/technology/cell_ports.hpp"
 #include "fiction/traits.hpp"
+#include "fiction/types.hpp"
 
 #include <cassert>
 #include <cstdint>
@@ -224,6 +227,123 @@ template <typename Lyt>
     return {};
 }
 
+/**
+ * The layout is shifted by x_min and y_min such that the cells' coordinates are positive.
+ *
+ * @tparam Lyt Cell-level layout.
+ * @param lyt The given layout which is shifted.
+ * @return shifted layout.
+ */
+template <typename Lyt>
+Lyt normalize_layout_coordinates(const Lyt& lyt)
+{
+    if (lyt.num_cells() == 0)
+    {
+        return lyt;
+    }
+    Lyt  lyt_new{};
+    auto x_min = INT32_MAX;
+    auto y_min = INT32_MAX;
+    lyt.foreach_cell(
+        [&lyt, &x_min, &y_min](const auto& c)
+        {
+            if (c.y <= y_min && c.x <= x_min)
+            {
+                y_min = c.y;
+                x_min = c.x;
+            }
+            else if (c.y <= y_min)
+            {
+                y_min = c.y;
+            }
+            else if (c.x <= x_min)
+            {
+                x_min = c.x;
+            }
+        });
+
+    lyt.foreach_cell(
+        [&lyt_new, &lyt, &x_min, &y_min](const auto& c)
+        {
+            lyt_new.assign_cell_type({c.x - x_min, c.y - y_min}, lyt.get_cell_type(c)),
+                lyt_new.assign_cell_mode({c.x - x_min, c.y - y_min}, lyt.get_cell_mode(c)),
+                lyt_new.assign_cell_name({c.x - x_min, c.y - y_min}, lyt.get_cell_name(c));
+        });
+    lyt_new.set_layout_name(lyt.get_layout_name());
+    return lyt_new;
+}
+
+/**
+ * The cell coordinates of a given layout are converted to SiQAD coordinates. A new layout with SiQAD coordinates is
+ * returned.
+ *
+ * @tparam Lyt Cell-level layout based on Fiction coordinates (Cube, Offset).
+ * @param lyt The given layout which is converted to a new layout based on SiQAD coordinates.
+ * @return new layout based on SiQAD coordinates.
+ */
+template <typename Lyt>
+sidb_cell_clk_lyt_siqad lyt_coordinates_to_siqad(const Lyt& lyt)
+{
+    static_assert(is_cartesian_layout_v<Lyt>, "Lyt is not a cartesian layout");
+    static_assert(is_cell_level_layout_v<Lyt>, "Lyt is not a cell-level layout");
+    static_assert(has_sidb_technology_v<Lyt>, "Lyt is not an SiDB layout");
+
+    sidb_cell_clk_lyt_siqad lyt_new{};
+    lyt.foreach_cell(
+        [&lyt_new, &lyt](const auto& c)
+        {
+            lyt_new.assign_cell_type(siqad::to_siqad_coord<cell<Lyt>>(c), lyt.get_cell_type(c)),
+                lyt_new.assign_cell_mode(siqad::to_siqad_coord<cell<Lyt>>(c), lyt.get_cell_mode(c)),
+                lyt_new.assign_cell_name(siqad::to_siqad_coord<cell<Lyt>>(c), lyt.get_cell_name(c));
+        });
+    lyt_new.set_layout_name(lyt.get_layout_name());
+
+    return lyt_new;
+}
+
+/**
+ * The cell coordinates of a given layout are converted to Fiction coordinates. A new layout with Fiction coordinates is
+ * returned.
+ *
+ * @tparam Lyt Cell-level layout based on Fiction coordinates.
+ * @param lyt The given layout which is converted to a new layout based on Fiction coordinates.
+ * @return New layout based on Fiction coordinates.
+ */
+template <typename Lyt>
+Lyt lyt_coordinates_to_fiction(const sidb_cell_clk_lyt_siqad& lyt)
+{
+    static_assert(is_cartesian_layout_v<Lyt>, "Lyt is not a cartesian layout");
+    static_assert(is_cell_level_layout_v<Lyt>, "Lyt is not a cell-level layout");
+    static_assert(has_sidb_technology_v<Lyt>, "Lyt is not an SiDB layout");
+
+    Lyt lyt_new{};
+
+    if constexpr (has_offset_ucoord_v<Lyt>)
+    {
+        auto lyt_normalized = normalize_layout_coordinates<sidb_cell_clk_lyt_siqad>(lyt);
+        lyt_normalized.foreach_cell(
+            [&lyt_new, &lyt_normalized](const auto& c)
+            {
+                lyt_new.assign_cell_type(siqad::to_fiction_coord<cell<Lyt>>(c), lyt_normalized.get_cell_type(c)),
+                    lyt_new.assign_cell_mode(siqad::to_fiction_coord<cell<Lyt>>(c), lyt_normalized.get_cell_mode(c)),
+                    lyt_new.assign_cell_name(siqad::to_fiction_coord<cell<Lyt>>(c), lyt_normalized.get_cell_name(c));
+            });
+        lyt_new.set_layout_name(lyt_normalized.get_layout_name());
+    }
+    else
+    {
+        lyt.foreach_cell(
+            [&lyt_new, &lyt](const auto& c)
+            {
+                lyt_new.assign_cell_type(siqad::to_fiction_coord<cell<Lyt>>(c), lyt.get_cell_type(c)),
+                    lyt_new.assign_cell_mode(siqad::to_fiction_coord<cell<Lyt>>(c), lyt.get_cell_mode(c)),
+                    lyt_new.assign_cell_name(siqad::to_fiction_coord<cell<Lyt>>(c), lyt.get_cell_name(c));
+            });
+        lyt_new.set_layout_name(lyt.get_layout_name());
+    }
+    return lyt_new;
+}
+
 }  // namespace fiction
 
 #endif  // FICTION_LAYOUT_UTILS_HPP

test/utils/layout_utils.cpp

@@ -5,6 +5,7 @@
 #include <catch2/catch_template_test_macros.hpp>
 
 #include <fiction/layouts/cartesian_layout.hpp>
+#include <fiction/layouts/cell_level_layout.hpp>
 #include <fiction/layouts/coordinates.hpp>
 #include <fiction/layouts/hexagonal_layout.hpp>
 #include <fiction/utils/layout_utils.hpp>
@@ -38,3 +39,141 @@ TEMPLATE_TEST_CASE("Port directions to coordinates", "[layout-utils]", (cartesia
                   lyt.north_west(c));
         });
 }
+
+TEMPLATE_TEST_CASE("offset::ucoord_t to siqad layout", "[layout_fiction_coordinates_to_siqad]", sidb_cell_clk_lyt)
+{
+    SECTION("empty layout")
+    {
+        TestType lyt{{10, 10}, "test"};
+        auto     lyt_transformed = lyt_coordinates_to_siqad<TestType>(lyt);
+        CHECK(lyt_transformed.is_empty());
+        CHECK(lyt_transformed.get_layout_name() == "test");
+    }
+
+    SECTION("layout with one normal and one input cell")
+    {
+        TestType lyt{};
+        lyt.assign_cell_type({5, 3}, TestType::cell_type::NORMAL);
+        lyt.assign_cell_type({5, 1}, TestType::cell_type::INPUT);
+        auto lyt_transformed = lyt_coordinates_to_siqad<TestType>(lyt);
+        CHECK(lyt_transformed.num_cells() == 2);
+        CHECK(lyt_transformed.get_cell_type({5, 1, 1}) == TestType::cell_type::NORMAL);
+        CHECK(lyt_transformed.get_cell_type({5, 0, 1}) == TestType::cell_type::INPUT);
+    }
+
+    SECTION("layout with three cells")
+    {
+        TestType lyt{};
+        lyt.assign_cell_type({0, 0}, TestType::cell_type::NORMAL);
+        lyt.assign_cell_type({5, 3}, TestType::cell_type::INPUT);
+        lyt.assign_cell_type({5, 1}, TestType::cell_type::OUTPUT);
+        lyt.assign_cell_name({0, 0}, "normal cell");
+        lyt.assign_cell_name({5, 3}, "input cell");
+        lyt.assign_cell_name({5, 1}, "output cell");
+        auto lyt_transformed = lyt_coordinates_to_siqad<TestType>(lyt);
+        CHECK(lyt_transformed.num_cells() == 3);
+        CHECK(lyt_transformed.get_cell_type({0, 0, 0}) == TestType::cell_type::NORMAL);
+        CHECK(lyt_transformed.get_cell_type({5, 1, 1}) == TestType::cell_type::INPUT);
+        CHECK(lyt_transformed.get_cell_type({5, 0, 1}) == TestType::cell_type::OUTPUT);
+        CHECK(lyt_transformed.get_cell_name({0, 0, 0}) == "normal cell");
+        CHECK(lyt_transformed.get_cell_name({5, 1, 1}) == "input cell");
+        CHECK(lyt_transformed.get_cell_name({5, 0, 1}) == "output cell");
+    }
+}
+
+TEMPLATE_TEST_CASE("siqad layout is normalized, shifted to positive coordinates", "[normalize_layout_coordinates]", sidb_cell_clk_lyt_siqad)
+{
+    SECTION("empty layout")
+    {
+        TestType lyt{{}, "layout based on siqad coordinates"};
+        lyt.assign_cell_type({-5,-1}, TestType::cell_type::NORMAL);
+        lyt.assign_cell_type({5,1}, TestType::cell_type::NORMAL);
+        auto     lyt_transformed = normalize_layout_coordinates<TestType>(lyt);
+        CHECK(lyt_transformed.get_layout_name() == "layout based on siqad coordinates");
+        CHECK(lyt_transformed.get_cell_type({0,0}) == TestType::cell_type::NORMAL);
+        CHECK(lyt_transformed.get_cell_type({10,2}) == TestType::cell_type::NORMAL);
+        CHECK(lyt_transformed.get_cell_type({-5,-1}) == TestType::cell_type::EMPTY);
+    }
+}
+
+TEMPLATE_TEST_CASE("siqad layout to offset::ucoord_t layout", "[layout_siqad_coordinates_to_fiction]", sidb_cell_clk_lyt)
+{
+    SECTION("empty layout")
+    {
+        sidb_cell_clk_lyt_siqad lyt{{}, "layout based on siqad coordinates"};
+        auto     lyt_transformed = lyt_coordinates_to_fiction<TestType>(lyt);
+        CHECK(lyt_transformed.is_empty());
+        CHECK(lyt_transformed.get_layout_name() == "layout based on siqad coordinates");
+    }
+
+    SECTION("layout with one normal and one input cell")
+    {
+        sidb_cell_clk_lyt_siqad lyt{};
+        lyt.assign_cell_type({5, 3}, TestType::cell_type::NORMAL);
+        lyt.assign_cell_type({-5, -1}, TestType::cell_type::INPUT);
+        auto lyt_transformed = lyt_coordinates_to_fiction<TestType>(lyt);
+        CHECK(lyt_transformed.num_cells() == 2);
+        CHECK(lyt_transformed.get_cell_type({10, 8}) == TestType::cell_type::NORMAL);
+        CHECK(lyt_transformed.get_cell_type({0, 0}) == TestType::cell_type::INPUT);
+    }
+
+    SECTION("layout with three cells")
+    {
+        sidb_cell_clk_lyt_siqad lyt{};
+        lyt.assign_cell_type({5, 3}, TestType::cell_type::NORMAL);
+        lyt.assign_cell_type({0, 0}, TestType::cell_type::INPUT);
+        lyt.assign_cell_type({5, 1}, TestType::cell_type::OUTPUT);
+        lyt.assign_cell_name({5, 3}, "normal cell");
+        lyt.assign_cell_name({0, 0}, "input cell");
+        lyt.assign_cell_name({5, 1}, "output cell");
+        auto lyt_transformed = lyt_coordinates_to_fiction<TestType>(lyt);
+        CHECK(lyt_transformed.num_cells() == 3);
+        CHECK(lyt_transformed.get_cell_type({5, 6}) == TestType::cell_type::NORMAL);
+        CHECK(lyt_transformed.get_cell_type({0, 0}) == TestType::cell_type::INPUT);
+        CHECK(lyt_transformed.get_cell_type({5, 2}) == TestType::cell_type::OUTPUT);
+        CHECK(lyt_transformed.get_cell_name({5, 6}) == "normal cell");
+        CHECK(lyt_transformed.get_cell_name({0, 0}) == "input cell");
+        CHECK(lyt_transformed.get_cell_name({5, 2}) == "output cell");
+    }
+}
+
+TEMPLATE_TEST_CASE("siqad layout to cube::coord_t layout", "[layout_siqad_coordinates_to_fiction]", (cell_level_layout<sidb_technology, clocked_layout<cartesian_layout<cube::coord_t>>>))
+{
+    SECTION("empty layout")
+    {
+        sidb_cell_clk_lyt_siqad lyt{{}, "layout based on siqad coordinates"};
+        auto     lyt_transformed = lyt_coordinates_to_fiction<TestType>(lyt);
+        CHECK(lyt_transformed.is_empty());
+        CHECK(lyt_transformed.get_layout_name() == "layout based on siqad coordinates");
+    }
+
+    SECTION("layout with one normal and one input cell")
+    {
+        sidb_cell_clk_lyt_siqad lyt{};
+        lyt.assign_cell_type({5,-1,1}, TestType::cell_type::NORMAL);
+        lyt.assign_cell_type({5, 1, 0}, TestType::cell_type::INPUT);
+        auto lyt_transformed = lyt_coordinates_to_fiction<TestType>(lyt);
+        CHECK(lyt_transformed.num_cells() == 2);
+        CHECK(lyt_transformed.get_cell_type({5, -1}) == TestType::cell_type::NORMAL);
+        CHECK(lyt_transformed.get_cell_type({5, 2,0}) == TestType::cell_type::INPUT);
+    }
+
+    SECTION("layout with three cells")
+    {
+        sidb_cell_clk_lyt_siqad lyt{};
+        lyt.assign_cell_type({5, -3}, TestType::cell_type::NORMAL);
+        lyt.assign_cell_type({0, 0}, TestType::cell_type::INPUT);
+        lyt.assign_cell_type({5, 3}, TestType::cell_type::OUTPUT);
+        lyt.assign_cell_name({5, -3}, "normal cell");
+        lyt.assign_cell_name({0, 0}, "input cell");
+        lyt.assign_cell_name({5, 3}, "output cell");
+        auto lyt_transformed = lyt_coordinates_to_fiction<TestType>(lyt);
+        CHECK(lyt_transformed.num_cells() == 3);
+        CHECK(lyt_transformed.get_cell_type({5, -6}) == TestType::cell_type::NORMAL);
+        CHECK(lyt_transformed.get_cell_type({0, 0}) == TestType::cell_type::INPUT);
+        CHECK(lyt_transformed.get_cell_type({5, 6}) == TestType::cell_type::OUTPUT);
+        CHECK(lyt_transformed.get_cell_name({5, -6}) == "normal cell");
+        CHECK(lyt_transformed.get_cell_name({0, 0}) == "input cell");
+        CHECK(lyt_transformed.get_cell_name({5, 6}) == "output cell");
+    }
+}