Integrate Neutral Atom State Preparation

cmake/ExternalDependencies.cmake

@@ -29,7 +29,7 @@ endif()
 # cmake-format: off
 set(MQT_CORE_VERSION 2.5.2
     CACHE STRING "MQT Core version")
-set(MQT_CORE_REV "7a9a20269462360d2c2a951647eb6fbf4e3094e2"
+set(MQT_CORE_REV "dcd8ac50b00d9ffef9de37d22775b12548a01871"
     CACHE STRING "MQT Core identifier (tag, branch or commit hash)")
 set(MQT_CORE_REPO_OWNER "cda-tum"
     CACHE STRING "MQT Core repository owner (change when using a fork)")
@@ -104,5 +104,21 @@ if(BUILD_MQT_QMAP_BINDINGS)
   endif()
 endif()
 
+# Add YAML-CPP as a dependency.
+set(YAML_VERSION
+    0.8.0
+    CACHE STRING "YAML-CPP version")
+set(YAML_URL https://github.com/jbeder/yaml-cpp/archive/refs/tags/${YAML_VERSION}.tar.gz)
+if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.24)
+  FetchContent_Declare(yaml-cpp URL ${YAML_URL} FIND_PACKAGE_ARGS ${YAML_VERSION})
+  list(APPEND FETCH_PACKAGES yaml-cpp)
+else()
+  find_package(yaml-cpp ${YAML_VERSION} QUIET)
+  if(NOT yaml-cpp_FOUND)
+    FetchContent_Declare(yaml-cpp URL ${YAML_URL})
+    list(APPEND FETCH_PACKAGES yaml-cpp)
+  endif()
+endif()
+
 # Make all declared dependencies available.
 FetchContent_MakeAvailable(${FETCH_PACKAGES})

include/na/Architecture.hpp

@@ -231,6 +231,7 @@ class Architecture {
   [[nodiscard]] auto isAllowedGlobally(const FullOpType& t,
                                        const Zone&       zone) const -> bool;
   [[nodiscard]] auto getNrowsInZone(const Zone& z) const -> Index;
+  [[nodiscard]] auto getNColsInZone(const Zone& z) const -> Index;
   [[nodiscard]] auto
   getSitesInRow(const Zone& z, const Index& row) const -> std::vector<Index>;
   [[nodiscard]] auto getNearestXLeft(const Number& x, const Zone& z,

include/na/NAMapper.hpp → include/na/nalac/NAMapper.hpp

@@ -6,8 +6,8 @@
 
 #pragma once
 
+#include "../Configuration.hpp"
 #include "Architecture.hpp"
-#include "Configuration.hpp"
 #include "Definitions.hpp"
 #include "QuantumComputation.hpp"
 #include "na/NAComputation.hpp"

include/na/nasp/CodeGenerator.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "QuantumComputation.hpp"
+#include "Solver.hpp"
+#include "na/NAComputation.hpp"
+#include "na/NADefinitions.hpp"
+
+#include <cstddef>
+#include <cstdint>
+
+namespace na {
+using namespace qc;
+
+class CodeGenerator {
+private:
+  static auto coordFromDiscrete(std::int32_t x, std::int32_t y, std::int32_t h,
+                                std::int32_t v, std::int32_t maxHOffset,
+                                std::int32_t maxVOffset,
+                                std::int32_t minEntanglingY,
+                                std::int32_t maxEntanglingY) -> Point;
+
+public:
+  [[nodiscard]] static auto
+  generate(const QuantumComputation& input, const NASolver::Result& result,
+           std::uint16_t maxHOffset, std::uint16_t maxVOffset,
+           std::uint16_t minEntanglingY,
+           std::uint16_t maxEntanglingY) -> NAComputation;
+};
+} // namespace na

include/na/nasp/Optimizer.hpp

@@ -0,0 +1,90 @@
+#pragma once
+
+#include "Solver.hpp"
+
+#include <chrono>
+#include <cstddef>
+#include <functional>
+#include <optional>
+#include <stdexcept>
+#include <unordered_map>
+
+namespace na {
+
+class Optimizer {
+public:
+  using ObjectiveFunction = std::function<NASolver::Result(std::size_t)>;
+
+private:
+  struct OptimizerProcess {
+    std::size_t arg        = 0;
+    int         readPipeFd = 0;
+  };
+
+  std::chrono::minutes            timeout      = std::chrono::minutes::zero();
+  std::size_t                     maxNSubProcs = 1;
+  std::size_t                     initialValue = 0;
+  std::size_t                     maxValue     = 0;
+  ObjectiveFunction               objective    = nullptr;
+  std::optional<NASolver::Result> extremum     = std::nullopt;
+  bool                            quiet        = true;
+
+  // auxiliary variables for minimize
+  std::optional<std::uint16_t>                maxUnsat = std::nullopt;
+  std::optional<std::uint16_t>                minSat   = std::nullopt;
+  std::unordered_map<pid_t, OptimizerProcess> processData;
+
+  [[nodiscard]] auto getNSubProcsRunning() const -> std::size_t {
+    return processData.size();
+  }
+
+  [[nodiscard]] auto isSubProcRunning() const -> bool {
+    return !processData.empty();
+  }
+
+  auto forkChildProcess(std::uint16_t        arg,
+                        std::chrono::seconds childTimeout) -> void;
+
+  auto waitForChildProcess() -> void;
+
+  auto killAllChildProcesses() -> void;
+
+public:
+  [[nodiscard]] auto getExtremum() const -> NASolver::Result {
+    if (!extremum.has_value()) {
+      throw std::runtime_error("No extremum found.");
+    }
+    return extremum.value();
+  }
+
+  [[nodiscard]] auto getExtremumOpt() const -> std::optional<NASolver::Result> {
+    return extremum;
+  }
+
+  auto setTimeout(const std::chrono::minutes newTimeout) -> void {
+    timeout = newTimeout;
+  }
+
+  auto setMaxNSubProcs(const std::uint16_t newMaxNSubProcs) -> void {
+    maxNSubProcs = newMaxNSubProcs;
+  }
+
+  auto setInitialValue(const std::uint16_t newInitialValue) -> void {
+    initialValue = newInitialValue;
+  }
+
+  auto setMaxValue(const std::uint16_t newMaxValue) -> void {
+    maxValue = newMaxValue;
+  }
+
+  auto setQuiet(const bool newQuiet) -> void { quiet = newQuiet; }
+
+  auto setObjectiveFunction(
+      const std::function<NASolver::Result(std::uint16_t)>& newObjective)
+      -> void {
+    objective = newObjective;
+  }
+
+  auto minimize() -> void;
+};
+} // namespace na