✨ Support defects in print function.

include/fiction/io/print_layout.hpp

@@ -7,8 +7,11 @@
 
 #include "fiction/layouts/bounding_box.hpp"
 #include "fiction/technology/charge_distribution_surface.hpp"
+#include "fiction/technology/sidb_defects.hpp"
+#include "fiction/technology/sidb_surface.hpp"
 #include "fiction/traits.hpp"
 #include "fiction/types.hpp"
+#include "fiction/utils/layout_utils.hpp"
 
 #include <fmt/color.h>
 #include <fmt/format.h>
@@ -45,6 +48,13 @@
 static const auto SIDB_NEUT_COLOR = fmt::fg(fmt::color::white);
 // Escape color sequence for lattice background colors (grey).
 static const auto SIDB_LAT_COLOR = fmt::fg(fmt::color::gray);
+
+// Escape color sequence for positively charged defect colors (red).
+static const auto SIDB_DEF_POS_COLOR = fmt::fg(fmt::color::red);
+// Escape color sequence for negatively charged defect colors (blue).
+static const auto SIDB_DEF_NEG_COLOR = fmt::fg(fmt::color::blue);
+// Escape color sequence for neutrally charged defect colors (yellow).
+static const auto SIDB_DEF_NEU_COLOR = fmt::fg(fmt::color::yellow);
 // Empty escape color sequence
 inline constexpr auto NO_COLOR = fmt::text_style{};
 
@@ -325,7 +335,7 @@
     os << std::endl;
 }
 /**
- * Writes a simplified 2D representation of an SiDB charge layout to an output stream.
+ * Writes a simplified 2D representation of an SiDB surface or charge distribution surface to an output stream.
  *
  * @tparam Lyt SiDB cell-level layout with charge-information based on SiQAD coordinates, e.g., a
  * charge_distribution_surface object.
@@ -343,41 +353,147 @@
     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");
     static_assert(has_siqad_coord_v<Lyt>, "Lyt is not based on SiQAD coordinates");
-    static_assert(has_get_charge_state_v<Lyt>, "Lyt does not implement the get_charge_state function");
+    static_assert(has_get_charge_state_v<Lyt> | has_get_sidb_defect_v<Lyt>,
+                  "Lyt does not implement the get_charge_state function");
 
     // empty layout
     if (lyt.is_empty())
     {
-        os << "[i] empty layout" << std::endl;
-        return;
+        if constexpr (has_get_sidb_defect_v<Lyt>)
+        {
+            if (lyt.num_defects() == 0)
+            {
+                os << "[i] empty layout" << std::endl;
+                return;
+            }
+        }
+        else
+        {
+            os << "[i] empty layout" << std::endl;
+            return;
+        }
     }
 
-    coordinate<Lyt> min{};
-    coordinate<Lyt> max{lyt.x(), lyt.y(), 1};
+    // determine the north-west and south-west cell in siqad-coordinates.
+    const auto [nw, se] = bounding_box_siqad<Lyt>(lyt);
 
-    if (crop_layout)
+    auto min_nw = nw;
+    auto max_se = se;
+
+    std::vector<typename Lyt::cell> defects{};
+
+    // Check if defects exist in the layout.
+    if constexpr (has_get_sidb_defect_v<Lyt>)
     {
-        const auto bb = bounding_box_2d{lyt};
 
+        defects.reserve(lyt.num_defects());
+        lyt.foreach_sidb_defect([&defects](const auto& c) { defects.push_back(c.first); });
+        std::sort(defects.begin(), defects.end());
+        if (!defects.empty())
+        {
+            min_nw = min_nw > defects.front() ?
+                         defects.front() :
+                         min_nw;  // if a defect is more north-west than nw, this position is used as min.
+            max_se = max_se < defects.back() ?
+                         defects.back() :
+                         max_se;  // if a defect is more south-east than se, this position is used as max.
+        }
+    }
+
+    if (crop_layout)
+    {
         // apply padding of maximally one dimer row and two columns
-        min = bb.get_min() - coordinate<Lyt>{2, 1};
-        max = bb.get_max() + coordinate<Lyt>{2, 1};
+        min_nw = min_nw - coordinate<Lyt>{2, 1};
+        max_se = max_se + coordinate<Lyt>{2, 1};
 
         // ensure only full dimer rows are printed
-        min.z = 0;
-        max.z = 1;
+        min_nw.z = 0;
+        max_se.z = 1;
     }
 
-    // iterate over all coordinates in the rows determined by the vertical crop
-    lyt.foreach_coordinate(
-        [&](const coordinate<Lyt>& c)
+    // loop coordinate is initialized with the north-west coordinate.
+    auto loop_coordinate = min_nw;
+
+    while (loop_coordinate <= max_se)
+    {
+        // Check if layout is a sidb_surface and a charge distribution surface.
+        if constexpr (has_get_sidb_defect_v<Lyt> && has_get_charge_state_v<Lyt>)
         {
-            if (crop_layout && (c.x < min.x || c.x > max.x))  // apply horizontal crop
+            if (lyt.get_sidb_defect(loop_coordinate) != sidb_defect{sidb_defect_type::NONE})
             {
-                return;
+                if (is_negatively_charged_defect(lyt.get_sidb_defect(loop_coordinate)))
+                {
+                    os << fmt::format(cs_color ? detail::SIDB_NEG_COLOR : detail::NO_COLOR, " ⊟ ");
+                }
+
+                else if (is_positively_charged_defect(lyt.get_sidb_defect(loop_coordinate)))
+                {
+                    os << fmt::format(cs_color ? detail::SIDB_NEG_COLOR : detail::NO_COLOR, " ⊞ ");
+                }
+                else if (is_neutrally_charged_defect(lyt.get_sidb_defect(loop_coordinate)))
+                {
+                    os << fmt::format(cs_color ? detail::SIDB_NEG_COLOR : detail::NO_COLOR, " ⊡ ");
+                }
             }
+            else
+            {
+                switch (lyt.get_charge_state(
+                    loop_coordinate))  // switch over the charge state of the SiDB at the current coordinate
+                {
+                    case sidb_charge_state::NEGATIVE:
+                    {
+                        os << fmt::format(cs_color ? detail::SIDB_NEG_COLOR : detail::NO_COLOR, " ● ");
+                        break;
+                    }
+                    case sidb_charge_state::POSITIVE:
+                    {
+                        os << fmt::format(cs_color ? detail::SIDB_POS_COLOR : detail::NO_COLOR, " ⨁ ");
+                        break;
+                    }
+                    case sidb_charge_state::NEUTRAL:
+                    {
+                        os << fmt::format(cs_color ? detail::SIDB_NEUT_COLOR : detail::NO_COLOR, " ◯ ");
+                        break;
+                    }
+                    default:  // NONE charge state case -> empty cell
+                    {
+                        os << (draw_lattice ? fmt::format(cs_color ? detail::SIDB_LAT_COLOR : detail::NO_COLOR, " · ") :
+                                              "  ");
+                    }
+                }
+            }
+        }
+
+        // Check if layout is only a sidb_surface.
+        else if constexpr (has_get_sidb_defect_v<Lyt>)
+        {
+            if (lyt.get_sidb_defect(loop_coordinate) != sidb_defect{sidb_defect_type::NONE})
+            {
+                if (is_negatively_charged_defect(lyt.get_sidb_defect(loop_coordinate)))
+                {
+                    os << fmt::format(cs_color ? detail::SIDB_DEF_NEG_COLOR : detail::NO_COLOR, " ⊟ ");
+                }
+
+                else if (is_positively_charged_defect(lyt.get_sidb_defect(loop_coordinate)))
+                {
+                    os << fmt::format(cs_color ? detail::SIDB_DEF_POS_COLOR : detail::NO_COLOR, " ⊞ ");
+                }
+                else if (is_neutrally_charged_defect(lyt.get_sidb_defect(loop_coordinate)))
+                {
+                    os << fmt::format(cs_color ? detail::SIDB_DEF_NEU_COLOR : detail::NO_COLOR, " ⊡ ");
+                }
+            }
+            else
+            {
+                os << (draw_lattice ? fmt::format(cs_color ? detail::SIDB_LAT_COLOR : detail::NO_COLOR, " · ") : "  ");
+            }
+        }
 
-            switch (lyt.get_charge_state(c))  // switch over the charge state of the SiDB at the current coordinate
+        // Check if layout is only a charge distribution surface.
+        else if constexpr (has_get_charge_state_v<Lyt>)
+        {
+            switch (lyt.get_charge_state(
+                loop_coordinate))  // switch over the charge state of the SiDB at the current coordinate
             {
                 case sidb_charge_state::NEGATIVE:
                 {
@@ -396,19 +512,39 @@
                 }
                 default:  // NONE charge state case -> empty cell
                 {
-                    os << (draw_lattice || !lyt.is_empty_cell(c) ?
-                               fmt::format(cs_color ? detail::SIDB_LAT_COLOR : detail::NO_COLOR, " · ") :
-                               "  ");
+                    os << (draw_lattice ? fmt::format(cs_color ? detail::SIDB_LAT_COLOR : detail::NO_COLOR, " · ") :
+                                          "  ");
                 }
             }
+        }
+
+        // If the x-coordinate of loop_coordinate is still less than the x-coordinate of the south-west cell, the
+        // x-coordinate is increased by 1.
+        if (loop_coordinate.x < max_se.x)
+        {
+            loop_coordinate.x += 1;
+        }
 
-            if (c.x == max.x)
+        else if (loop_coordinate.x == max_se.x && loop_coordinate != max_se)
+        {
+            if (loop_coordinate.z == 1)
             {
-                os << (c.z == 1 ? "\n\n" : "\n");
+                os << "\n\n";  // gap between two dimers.
             }
-        },
-        min, max + coordinate<Lyt>{1, 0});
-
+            else
+            {
+                os << "\n";
+            }
+            loop_coordinate.x = min_nw.x;
+            loop_coordinate.y += (loop_coordinate.z == 1) ? 1 : 0;
+            loop_coordinate.z = (loop_coordinate.z == 0) ? 1 : 0;
+        }
+        else if (loop_coordinate == max_se)
+        {
+            os << "\n\n";  // add a gap between two dimers.
+            break;
+        }
+    }
     // flush stream
     os << std::endl;
 }

include/fiction/technology/sidb_defects.hpp

@@ -5,6 +5,7 @@
 #ifndef FICTION_SIDB_DEFECTS_HPP
 #define FICTION_SIDB_DEFECTS_HPP
 
+#include <cassert>
 #include <cmath>
 #include <cstdint>
 #include <utility>
@@ -57,7 +58,7 @@ struct sidb_defect
             lambda_tf{screening_distance}
     {
 
-        assert(((std::fmod(charge, 1) == 0)) && "charge value has to be an integer");
+        assert((std::fmod(charge, 1) == 0) && "charge value has to be an integer");
         assert((epsilon_r >= 0) && "epsilon_r has to be >= 0.0");
         assert((lambda_tf >= 0.0) && "lambda_tf has to be >= 0.0 nanometer");
     }
@@ -78,6 +79,31 @@ struct sidb_defect
      */
     const double lambda_tf;
 };
+/**
+ * This operator compares two sidb_defect instances for equality. It checks if the type, charge,
+ * epsilon_r, and lambda_tf members of the two instances are equal.
+ *
+ * @param lhs The left-hand side sidb_defect instance.
+ * @param rhs The right-hand side sidb_defect instance.
+ * @return Returns true if the two sidb_defect instances are equal, false otherwise.
+ */
+static constexpr bool operator==(const sidb_defect& lhs, const sidb_defect& rhs) noexcept
+{
+    return lhs.type == rhs.type && lhs.charge == rhs.charge && lhs.epsilon_r == rhs.epsilon_r &&
+           lhs.lambda_tf == rhs.lambda_tf;
+}
+/**
+ * This operator compares two sidb_defect instances for inequality. It uses the operator== to check
+ * if the two instances are equal and returns the negation of the result.
+ *
+ * @param lhs The left-hand side sidb_defect instance.
+ * @param rhs The right-hand side sidb_defect instance.
+ * @return Returns true if the two sidb_defect instances are not equal, false if they are equal.
+ */
+static constexpr bool operator!=(const sidb_defect& lhs, const sidb_defect& rhs) noexcept
+{
+    return !(lhs == rhs);
+}
 /**
  * Checks whether the given defect is charged. Charged defects are to be avoided by a larger distance.
  *
@@ -88,6 +114,36 @@ struct sidb_defect
 {
     return defect.type == sidb_defect_type::DB || defect.type == sidb_defect_type::SI_VACANCY;
 }
+/**
+ * Checks whether the given defect is positively charged.
+ *
+ * @param defect Defect to check.
+ * @return `true` iff defect is positively charged.
+ */
+[[nodiscard]] static constexpr bool is_positively_charged_defect(const sidb_defect& defect) noexcept
+{
+    return defect.charge > 0;
+}
+/**
+ * Checks whether the given defect is negatively charged.
+ *
+ * @param defect Defect to check.
+ * @return `true` iff defect is negatively charged.
+ */
+[[nodiscard]] static constexpr bool is_negatively_charged_defect(const sidb_defect& defect) noexcept
+{
+    return defect.charge < 0;
+}
+/**
+ * Checks whether the given defect is neutrally charged.
+ *
+ * @param defect Defect to check.
+ * @return `true` iff defect is neutrally charged.
+ */
+[[nodiscard]] static constexpr bool is_neutrally_charged_defect(const sidb_defect& defect) noexcept
+{
+    return defect.charge == 0;
+}
 /**
  * Checks whether the given defect is not charged. Neutral defects are to be avoided but not by such a large distance.
  * Even though the `NONE` defect type is technically neutral, it is not a defect per se which is why this function

include/fiction/utils/layout_utils.hpp

@@ -398,6 +398,57 @@ CoordinateType random_coordinate(CoordinateType coordinate1, CoordinateType coor
     }
 }
 
+/**
+ * Calculates the north-west and south-east cells of a minimum-sized box around all non-empty cells in a given layout
+ * which is based on SiQAD coordinates.
+ *
+ * @tparam Lyt SiDB cell-level layout type.
+ * @param lyt The layout for which the two corner cells of the minimum-sized box are determined.
+ * @return North-west and south-east cells of minimum-sized box.
+ */
+template <typename Lyt>
+std::pair<typename Lyt::cell, typename Lyt::cell> bounding_box_siqad(const Lyt& lyt) noexcept
+{
+    static_assert(has_siqad_coord_v<Lyt>, "Layout is not based on siqad coordinates");
+
+    if (lyt.num_cells() == 0)
+    {
+        return {typename Lyt::cell{}, typename Lyt::cell{}};
+    }
+
+    const auto converted_layout = convert_to_fiction_coordinates<
+        cell_level_layout<sidb_technology, clocked_layout<cartesian_layout<cube::coord_t>>>>(lyt);
+
+    int32_t min_x = std::numeric_limits<int32_t>::max();
+    int32_t max_x = std::numeric_limits<int32_t>::min();
+
+    int32_t min_y = std::numeric_limits<int32_t>::max();
+    int32_t max_y = std::numeric_limits<int32_t>::min();
+
+    converted_layout.foreach_cell(
+        [&converted_layout, &min_x, &max_x, &min_y, &max_y](const auto& c)
+        {
+            if (c.x < min_x)
+            {
+                min_x = c.x;
+            }
+            if (c.y < min_y)
+            {
+                min_y = c.y;
+            }
+            if (c.x > max_x)
+            {
+                max_x = c.x;
+            }
+            if (c.y > max_y)
+            {
+                max_y = c.y;
+            }
+        });
+
+    return {siqad::to_siqad_coord(cube::coord_t{min_x, min_y}), siqad::to_siqad_coord(cube::coord_t{max_x, max_y})};
+}
+
 }  // namespace fiction
 
 #endif  // FICTION_LAYOUT_UTILS_HPP