✨ Support defects in SiQAD coordinates for layout reading and writing

include/fiction/io/read_sqd_layout.hpp

@@ -278,7 +278,14 @@ class read_sqd_layout_impl
                 for (const auto* latcoord = incl_coords->FirstChildElement("latcoord"); latcoord != nullptr;
                      latcoord             = latcoord->NextSiblingElement("latcoord"))
                 {
-                    incl_cells.push_back(parse_latcoord(latcoord));
+                    if constexpr (has_siqad_coord_v<Lyt>)
+                    {
+                        incl_cells.push_back(parse_latcoord_siqad(latcoord));
+                    }
+                    else
+                    {
+                        incl_cells.push_back(parse_latcoord(latcoord));
+                    }
                 }
                 if (incl_cells.empty())
                 {

include/fiction/io/write_sqd_layout.hpp

@@ -221,9 +221,19 @@ class write_sqd_layout_impl
                 // generate SiDB cells
                 if constexpr (has_sidb_technology_v<Lyt>)
                 {
-                    design << fmt::format(siqad::DBDOT_BLOCK,
-                                          fmt::format(siqad::LATTICE_COORDINATE, c.x, c.y / 2, c.y % 2),
-                                          siqad::NORMAL_COLOR);
+                    if constexpr (has_siqad_coord_v<Lyt>)
+                    {
+                        design << fmt::format(siqad::DBDOT_BLOCK, fmt::format(siqad::LATTICE_COORDINATE, c.x, c.y, c.z),
+                                              siqad::NORMAL_COLOR);
+                    }
+                    else
+                    {
+                        design << fmt::format(
+                            siqad::DBDOT_BLOCK,
+                            fmt::format(siqad::LATTICE_COORDINATE, fiction::siqad::to_siqad_coord(c).x,
+                                        fiction::siqad::to_siqad_coord(c).y, fiction::siqad::to_siqad_coord(c).z),
+                            siqad::NORMAL_COLOR);
+                    }
                 }
                 // generate QCA cell blocks
                 else if constexpr (has_qca_technology_v<Lyt>)
@@ -273,15 +283,31 @@ class write_sqd_layout_impl
             lyt.foreach_sidb_defect(
                 [&design](const auto& cd)
                 {
-                    const auto& cell   = cd.first;
                     const auto& defect = cd.second;
 
-                    design << fmt::format(siqad::DEFECT_BLOCK,
-                                          fmt::format(siqad::LATTICE_COORDINATE, cell.x, cell.y / 2, cell.y % 2),
-                                          is_charged_defect(defect) ? fmt::format(siqad::COULOMB, defect.charge,
-                                                                                  defect.epsilon_r, defect.lambda_tf) :
-                                                                      "",
-                                          get_defect_type_name(defect.type));
+                    // layout is not based on siqad coordinates, coordinate transformation is performed
+                    if constexpr (has_siqad_coord_v<Lyt>)
+                    {
+                        const auto& cell = cd.first;
+
+                        design << fmt::format(
+                            siqad::DEFECT_BLOCK, fmt::format(siqad::LATTICE_COORDINATE, cell.x, cell.y, cell.z),
+                            is_charged_defect(defect) ?
+                                fmt::format(siqad::COULOMB, defect.charge, defect.epsilon_r, defect.lambda_tf) :
+                                "",
+                            get_defect_type_name(defect.type));
+                    }
+                    else
+                    {
+                        const auto cell = fiction::siqad::to_siqad_coord(cd.first);
+
+                        design << fmt::format(
+                            siqad::DEFECT_BLOCK, fmt::format(siqad::LATTICE_COORDINATE, cell.x, cell.y, cell.z),
+                            is_charged_defect(defect) ?
+                                fmt::format(siqad::COULOMB, defect.charge, defect.epsilon_r, defect.lambda_tf) :
+                                "",
+                            get_defect_type_name(defect.type));
+                    }
                 });
         }
     }

test/io/write_sqd_layout.cpp

@@ -21,6 +21,7 @@
 #include <fiction/technology/sidb_defects.hpp>
 #include <fiction/technology/sidb_surface.hpp>
 #include <fiction/traits.hpp>
+#include <fiction/types.hpp>
 
 #include <map>
 #include <sstream>
@@ -175,3 +176,58 @@ TEST_CASE("Write defective surface SQD layout", "[sqd]")
 
     compare_written_and_read_layout(defect_layout, read_layout);
 }
+
+TEST_CASE("Write multi-dot SQD layout based on SiQAD coordinates", "[sqd]")
+{
+    sidb_cell_clk_lyt_siqad layout{{4, 4}};
+    layout.assign_cell_type({0, 0}, sidb_technology::cell_type::NORMAL);
+    layout.assign_cell_type({1, 1}, sidb_technology::cell_type::NORMAL);
+    layout.assign_cell_type({0, 2}, sidb_technology::cell_type::NORMAL);
+    layout.assign_cell_type({0, 3}, sidb_technology::cell_type::NORMAL);
+    layout.assign_cell_type({4, 4}, sidb_technology::cell_type::NORMAL);
+
+    std::stringstream layout_stream{};
+
+    write_sqd_layout(layout, layout_stream);
+
+    const auto read_layout = read_sqd_layout<sidb_cell_clk_lyt_siqad>(layout_stream);
+
+    compare_written_and_read_layout(layout, read_layout);
+}
+
+TEST_CASE("Write defective surface SQD layout based on SiQAD coordinates", "[sqd]")
+{
+    static const std::map<cell<sidb_cell_clk_lyt_siqad>, sidb_defect> defect_map{
+        {{{0, 0, 1}, sidb_defect{sidb_defect_type::NONE}},
+         {{0, 1}, sidb_defect{sidb_defect_type::DB}},
+         {{0, 2}, sidb_defect{sidb_defect_type::SI_VACANCY}},
+         {{0, 3}, sidb_defect{sidb_defect_type::SINGLE_DIHYDRIDE}},
+         {{0, 4, 1}, sidb_defect{sidb_defect_type::DIHYDRIDE_PAIR}},
+         {{0, 5, 1}, sidb_defect{sidb_defect_type::ONE_BY_ONE}},
+         {{0, 6}, sidb_defect{sidb_defect_type::THREE_BY_ONE}},
+         {{0, 7}, sidb_defect{sidb_defect_type::SILOXANE}},
+         {{0, 8}, sidb_defect{sidb_defect_type::RAISED_SI}},
+         {{0, 9}, sidb_defect{sidb_defect_type::MISSING_DIMER}},
+         {{0, 10, 1}, sidb_defect{sidb_defect_type::ETCH_PIT}},
+         {{0, 11}, sidb_defect{sidb_defect_type::STEP_EDGE}},
+         {{0, 12, 0}, sidb_defect{sidb_defect_type::GUNK}},
+         {{0, 13}, sidb_defect{sidb_defect_type::UNKNOWN}}}};
+
+    const sidb_cell_clk_lyt_siqad lyt{aspect_ratio<sidb_cell_clk_lyt_siqad>{0, defect_map.size() - 1}};
+
+    sidb_surface<sidb_cell_clk_lyt_siqad> defect_layout{lyt};
+
+    // assign defects
+    for (const auto& [c, d] : defect_map)
+    {
+        defect_layout.assign_sidb_defect(c, d);
+    }
+
+    std::stringstream layout_stream{};
+
+    write_sqd_layout(defect_layout, layout_stream);
+
+    const auto read_layout = read_sqd_layout<sidb_surface<sidb_cell_clk_lyt_siqad>>(layout_stream);
+
+    compare_written_and_read_layout(defect_layout, read_layout);
+}