Namespace na¶

namespace na¶

Enums

enum class Dimension : std::uint8_t¶

Values:

enumerator X¶

enumerator Y¶

Functions

auto writeJSONSchema(std::ostream &os) -> void¶

Writes a JSON schema with default values for the device configuration to the specified output stream.

Parameters:: os – is the output stream to write the JSON schema to.
Throws:: std::runtime_error – if the JSON conversion fails.

auto writeJSONSchema(const std::string &path) -> void¶

Writes a JSON schema with default values for the device configuration to the specified path.

Parameters:: path – The path to write the JSON schema to.
Throws:: std::runtime_error – if the JSON conversion fails or the file cannot be opened.

auto readJSON(std::istream &is) -> Device ¶

Parses the device configuration from an input stream.

Parameters:: is – is the input stream containing the JSON representation of the device configuration.
Throws:: std::runtime_error – if the JSON cannot be parsed.
Returns:: The parsed device configuration as a Protobuf message.

auto readJSON(const std::string &path) -> Device ¶

Parses the device configuration from a JSON file.

Parameters:: path – is the path to the JSON file containing the device configuration.
Throws:: std::runtime_error – if the JSON file does not exist, or the JSON file cannot be parsed.
Returns:: The parsed device configuration as a Protobuf message.

auto writeHeader(const Device &device, std::ostream &os) -> void¶

Writes a header file with the device configuration to the specified output stream.

Note

This implementation only supports multi-qubit gates up to two qubits.

Parameters:

device – is the protobuf representation of the device.
os – is the output stream to write the header file to.

Throws:

std::runtime_error – if the file cannot be opened or written to.

auto writeHeader(const Device &device, const std::string &path) -> void¶

Writes a header file with the device configuration to the specified path.

Note

This implementation only supports multi-qubit gates up to two qubits.

Parameters:

device – is the protobuf representation of the device.
path – is the path to write the header file to.

Throws:

std::runtime_error – if the file cannot be opened or written to.

auto forEachRegularSites(const std::vector<Device::Lattice> &lattices, const std::function<void(const SiteInfo&)> &f, size_t startId = 0) -> void¶

Iterates over all regular sites created by the given lattices and calls the given function for each site.

Parameters:

lattices – is the list of lattices to iterate over.
f – is the function to call for each regular site, receiving a SiteInfo struct containing all site information.
startId – is the starting identifier for the sites. Default is 0.

Throws:

std::runtime_error – if lattice vectors are degenerate (i.e., the determinant of the lattice vector matrix is near zero, causing the system of equations to have no unique solution).

class AodOperation : public qc::Operation ¶

class Atom¶

#include <Atom.hpp>

Represents an atom in the NAComputation.

The name of the atom is used for printing the NAComputation. To maintain the uniqueness of atoms, the name of the atom should be unique.

Public Functions

inline explicit Atom(std::string name)¶

Creates a new atom with the given name.

Parameters:: name – The name of the atom.

inline auto getName() const -> std::string¶: Returns the name of the atom.

inline auto operator==(const Atom &other) const -> bool¶

Compares two atoms for equality.

Parameters:: other – The atom to compare with.
Returns:: True if the atoms are equal, false otherwise.

inline auto operator!=(const Atom &other) const -> bool¶

Compares two atoms for inequality.

Parameters:: other – The atom to compare with.
Returns:: True if the atoms are not equal, false otherwise.

Friends

inline friend auto operator<<(std::ostream &os, const Atom &obj) -> std::ostream&¶

Prints the atom to the given output stream.

Parameters:

os – The output stream to print the atom to.
obj – The atom to print.

Returns:

The output stream after printing the atom.

struct Device¶

#include <Generator.hpp>

Represents a neutral atom device configuration.

This struct defines the schema for the JSON representation of a neutral atom device configuration. This struct, including all its sub-structs, implements functions to serialize and deserialize to and from JSON using the nlohmann::json library.

Note

All duration and length values are in multiples of the time unit and the length unit, respectively.

Subclassed by na::Session::Device

Public Members

std::string name¶: The name of the device.

uint64_t numQubits = 0¶: The number of qubits in the device.

std::vector<Lattice> traps¶: The list of lattices (trap areas) in the device.

uint64_t minAtomDistance = 0¶: The minimum distance between atoms in the device that must be respected.

std::vector<GlobalSingleQubitOperation> globalSingleQubitOperations¶: The list of global single-qubit operations supported by the device.

std::vector<GlobalMultiQubitOperation> globalMultiQubitOperations¶: The list of global multi-qubit operations supported by the device.

std::vector<LocalSingleQubitOperation> localSingleQubitOperations¶: The list of local single-qubit operations supported by the device.

std::vector<LocalMultiQubitOperation> localMultiQubitOperations¶: The list of local multi-qubit operations supported by the device.

std::vector<ShuttlingUnit> shuttlingUnits¶: The list of shuttling units supported by the device.

DecoherenceTimes decoherenceTimes¶: The decoherence times of the device.

Unit lengthUnit = {.unit = "um",.scaleFactor = 1.0}: The unit of measurement for lengths in the device.

Unit durationUnit = {.unit = "us",.scaleFactor = 1.0}: The unit of measurement for time in the device.

struct DecoherenceTimes¶

#include <Generator.hpp>

Represents the decoherence times of the device.

Public Members

uint64_t t1 = 0¶: The T1 time.

uint64_t t2 = 0¶: The T2 time.

struct GlobalMultiQubitOperation : public na::Device::Operation¶

#include <Generator.hpp>

Represents a global multi-qubit operation.

Public Members

uint64_t interactionRadius = 0¶: The interaction radius of the operation within which two qubits can interact.

uint64_t blockingRadius = 0¶: The blocking radius of the operation within which no other operation can be performed to avoid interference.

double idlingFidelity = 0.0¶: The fidelity of the operation when no qubits are interacting.

uint64_t numQubits = 0¶: The number of qubits involved in the operation.

struct GlobalSingleQubitOperation : public na::Device::Operation¶: #include <Generator.hpp>

Represents a global single-qubit operation.

struct Lattice¶

#include <Generator.hpp>

Represents a lattice of traps in the device.

Public Members

Vector latticeOrigin¶: The origin of the lattice.

Vector latticeVector1¶

The first lattice vector.

Multiples of this vector are added to the lattice origin to create the lattice structure.

Vector latticeVector2¶

The second lattice vector.

Multiples of this vector are added to the lattice origin and multiples of the first lattice vector to create the lattice structure.

std::vector<Vector> sublatticeOffsets¶

The offsets for each sublattice.

The actual locations of traps are calculated by adding the each offset to the points in the lattice defined by the lattice vectors, i.e., for each sublattice offset offset and indices i and j, the trap location is latticeOrigin + i * latticeVector1 + j * latticeVector2 + offset.

Region extent¶

The extent of the lattice.

The extent defines the boundary of the lattice in which traps are placed. Only traps of the lattice that are within this extent are considered valid.

struct LocalMultiQubitOperation : public na::Device::Operation¶

#include <Generator.hpp>

Represents a local multi-qubit operation.

Public Members

uint64_t interactionRadius = 0¶: The interaction radius of the operation within which two qubits can interact.

uint64_t blockingRadius = 0¶: The blocking radius of the operation within which no other operation can be performed to avoid interference.

uint64_t numQubits = 0¶: The number of qubits involved in the operation.

struct LocalSingleQubitOperation : public na::Device::Operation¶: #include <Generator.hpp>

Represents a local single-qubit operation.

struct Region¶

#include <Generator.hpp>

Represents a region in the device.

Public Members

Vector origin¶: The origin of the region.

Size size¶: The size of the region.

struct Size¶

#include <Generator.hpp>

The size of the region.

Public Members

uint64_t width = 0¶: The width of the region.

uint64_t height = 0¶: The height of the region.

struct ShuttlingUnit¶

#include <Generator.hpp>

Represents a shuttling unit in the device.

Public Members

size_t id = 0¶: Unique identifier for the shuttling unit.

Region region¶: The region in which the shuttling unit operates.

uint64_t loadDuration = 0¶: The duration of the load operation in the shuttling unit.

uint64_t storeDuration = 0¶: The duration of the store operation in the shuttling unit.

double loadFidelity = 0.0¶: The fidelity of the load operation in the shuttling unit.

double storeFidelity = 0.0¶: The fidelity of the store operation in the shuttling unit.

uint64_t numParameters = 0¶: The number of parameters the shuttling unit takes.

uint64_t meanShuttlingSpeed = 0¶: The mean shuttling speed.

Note

Only for shuttling operations.

struct Unit¶

#include <Generator.hpp>

Represents a unit of measurement for length and time.

Public Members

std::string unit¶: The unit of measurement (e.g., “µm” for micrometers, “ns” for nanoseconds).

double scaleFactor = 0¶: The factor of the unit.

struct Vector¶

#include <Generator.hpp>

Represents a 2D-vector.

Public Members

int64_t x = 0¶: The x-coordinate of the vector.

int64_t y = 0¶: The y-coordinate of the vector.

class GlobalCZOp : public na::GlobalOp ¶

#include <GlobalCZOp.hpp>

Represents a global CZ operation in the NAComputation.

Public Functions

inline explicit GlobalCZOp(std::vector<const Zone*> zones)¶

Creates a new CZ operation in the given zones.

Parameters:: zones – The zones the operation is applied to.

inline explicit GlobalCZOp(const Zone &zone)¶

Creates a new CZ operation in the given zone.

Parameters:: zone – The zone the operation is applied to.

class GlobalOp : public na::Op ¶

#include <GlobalOp.hpp>

Represents a global operation in the NAComputation.

Global operations are applied to entire zones instead of to individual atoms.

Subclassed by na::GlobalCZOp, na::GlobalRYOp

Public Functions

inline auto getParams() const -> auto&¶: Returns the parameters of the operation.

inline auto getZones() const -> auto&¶: Returns the zone the operation is applied to.

virtual auto toString() const -> std::string override¶: Returns a string representation of the operation.

class GlobalRYOp : public na::GlobalOp ¶

#include <GlobalRYOp.hpp>

Represents a global RY operation in the NAComputation.

Public Functions

inline GlobalRYOp(std::vector<const Zone*> zones, const qc::fp angle)¶

Creates a new RY operation in the given zones with the given angle.

Parameters:

zones – The zones the operation is applied to.
angle – The angle of the operation.

inline GlobalRYOp(const Zone &zone, const qc::fp angle)¶

Creates a new RY operation in the given zone with the given angle.

Parameters:

zone – The zone the operation is applied to.
angle – The angle of the operation.

class LoadOp : public na::ShuttlingOp ¶

#include <LoadOp.hpp>

Represents a load operation in the NAComputation.

Before an atom can be moved, it must be loaded, i.e., transferred from a static SLM to an adjustable AOD trap.

Public Functions

inline LoadOp(std::vector<const Atom*> atoms, std::vector<Location> targetLocations)¶

Creates a new load operation with the given atoms and target locations.

The target locations can be set if the loading operation contains a certain offset.

Parameters:

atoms – The atoms to load.
targetLocations – The target locations to load the atoms to.

inline explicit LoadOp(std::vector<const Atom*> atoms)¶

Creates a new load operation with the given atoms.

This constructor is used if the target locations are not set, i.e., the load operation does not incorporate any offset.

Parameters:: atoms – The atoms to load.

inline LoadOp(const Atom &atom, const Location &targetLocation)¶

Creates a new load operation with the given atom and target location.

The target locations can be set if the loading operation contains a certain offset.

Parameters:

atom – The atom to load.
targetLocation – The target location to load the atom to.

inline explicit LoadOp(const Atom &atom)¶

Creates a new load operation with the given atom.

This constructor is used if the target locations are not set, i.e., the load operation does not incorporate any offset.

Parameters:: atom – The atom to load.

inline virtual auto hasTargetLocations() const -> bool override¶: Returns whether the load operation has target locations set.

inline virtual auto getTargetLocations() const -> const std::vector<Location>& override¶: Returns the target locations of the load operation.

virtual auto toString() const -> std::string override¶: Returns a string representation of the load operation.

class LocalOp : public na::Op ¶

#include <LocalOp.hpp>

Represents a local operation in the NAComputation.

A local operation is applied to individual atoms.

Subclassed by na::LocalRZOp, na::LocalUOp

Public Functions

inline auto getAtoms() const -> auto&¶: Returns the atoms the operation is applied to.

inline auto getParams() const -> auto&¶: Returns the parameters of the operation.

virtual auto toString() const -> std::string override¶: Returns a string representation of the operation.

class LocalRZOp : public na::LocalOp ¶

#include <LocalRZOp.hpp>

Represents a local RZ operation in the NAComputation.

Public Functions

inline LocalRZOp(std::vector<const Atom*> atoms, const qc::fp angle)¶

Creates a new RZ operation with the given atoms and angle.

Parameters:

atoms – The atoms the operation is applied to.
angle – The angle of the operation.

inline LocalRZOp(const Atom &atom, const qc::fp angle)¶

Creates a new RZ operation with the given atom and angle.

Parameters:

atom – The atom the operation is applied to.
angle – The angle of the operation.

class LocalUOp : public na::LocalOp ¶

#include <LocalUOp.hpp>

Represents a local U3 operation in the NAComputation.

Public Functions

inline LocalUOp(std::vector<const Atom*> atoms, const qc::fp theta, const qc::fp phi, const qc::fp lambda)¶

Creates a new U3 operation with the given atoms and angles.

Parameters:

atoms – The atoms the operation is applied to.
theta – The first parameter of the operation.
phi – The second parameter of the operation.
lambda – The third parameter of the operation.

inline LocalUOp(const Atom &atom, const qc::fp theta, const qc::fp phi, const qc::fp lambda)¶

Creates a new U3 operation with the given atom and angle.

Parameters:

atom – The atom the operation is applied to.
theta – The first parameter of the operation.
phi – The second parameter of the operation.
lambda – The third parameter of the operation.

struct Location¶

#include <Location.hpp>

Class to store two-dimensional coordinates of type double.

Public Functions

inline Location operator-(const Location &loc) const¶

Subtracts the coordinates of the given location from this location.

Parameters:: loc – The location to subtract.
Returns:: The location resulting from the subtraction.

inline Location operator+(const Location &loc) const¶

Adds the coordinates of the given location to this location.

Parameters:: loc – The location to add.
Returns:: The location resulting from the addition.

inline auto length() const -> double¶: Returns the length of the vector from the origin to this location.

inline auto toString() const -> std::string¶: Returns a string representation of the location in the format “(x, y)”.

inline auto operator==(const Location &other) const -> bool¶

Compares two locations for equality.

Parameters:: other – The location to compare with.
Returns:: True if the locations are equal, false otherwise.

inline auto operator!=(const Location &other) const -> bool¶

Compares two locations for inequality.

Parameters:: other – The location to compare with.
Returns:: True if the locations are not equal, false otherwise.

inline auto operator<(const Location &other) const -> bool¶

Compares two locations for less than.

Parameters:: other – The location to compare with.
Returns:: True if this location is less than the other location, false

inline auto operator>(const Location &other) const -> bool¶

Compares two locations for greater than.

Parameters:: other – The location to compare with.
Returns:: True if this location is greater than the other location, false

inline auto operator>=(const Location &other) const -> bool¶

Compares two locations for greater than or equal.

Parameters:: other – The location to compare with.
Returns:: True if this location is greater than or equal to the other

inline auto operator<=(const Location &other) const -> bool¶

Compares two locations for less than or equal.

Parameters:: other – The location to compare with.
Returns:: True if this location is less than or equal to the other location,

inline auto getEuclideanDistance(const Location &loc) const -> double¶

Computes the Euclidean distance between this location and the given location.

Parameters:: loc – The location to compute the distance to.
Returns:: The Euclidean distance between the two locations.

inline auto getManhattanDistanceX(const Location &loc) const -> double¶

Computes the horizontal distance between this location and the given location.

Parameters:: loc – The location to compute the distance to.
Returns:: The horizontal distance between the two locations.

inline auto getManhattanDistanceY(const Location &loc) const -> double¶

Computes the vertical distance between this location and the given location.

Parameters:: loc – The location to compute the distance to.
Returns:: The vertical distance between the two locations.

Public Members

double x = 0¶: The x-coordinate of the location.

double y = 0¶: The y-coordinate of the location.

Public Static Functions

static inline auto distance(const Location &loc1, const Location &loc2) -> double¶: Returns the distance between two locations.

Friends

inline friend auto operator<<(std::ostream &os, const Location &obj) -> std::ostream&¶

Prints the location to the given output stream.

Parameters:

os – The output stream to print the location to.
obj – The location to print.

Returns:

The output stream after printing the location.

class MoveOp : public na::ShuttlingOp ¶

#include <MoveOp.hpp>

Represents a move operation in the NAComputation.

Public Functions

inline MoveOp(std::vector<const Atom*> atoms, std::vector<Location> targetLocations)¶

Creates a new move operation with the given atoms and target locations.

Parameters:

atoms – The atoms to move.
targetLocations – The target locations to move the atoms to.

inline MoveOp(const Atom &atom, const Location &targetLocation)¶

Creates a new move operation with the given atom and target location.

Parameters:

atom – The atom to move.
targetLocation – The target location to move the atom to.

inline virtual auto hasTargetLocations() const -> bool override¶: Returns whether the move operation has target locations set.

inline virtual auto getTargetLocations() const -> const decltype(targetLocations_)& override¶: Returns the target locations of the move operation.

virtual auto toString() const -> std::string override¶: Returns a string representation of the operation.

class NAComputation¶

#include <NAComputation.hpp>

Represents a neutral atom computation.

Public Functions

inline auto begin() -> auto¶: Returns an iterator to the beginning of the operations.

inline auto begin() const -> auto¶: Returns an iterator to the beginning of the operations.

inline auto end() -> auto¶: Returns an iterator to the end of the operations.

inline auto end() const -> auto¶: Returns an iterator to the end of the operations.

inline auto size() const -> std::size_t¶: Returns the number of operations in the NAComputation.

inline auto operator[](const std::size_t i) -> Op&¶

Returns a reference to the operation at the given index.

Parameters:: i – The index of the operation.
Returns:: A reference to the operation at the given index.

inline auto operator[](const std::size_t i) const -> const Op&¶

Returns a const reference to the operation at the given index.

Parameters:: i – The index of the operation.
Returns:: A const reference to the operation at the given index.

inline auto clear() -> void¶: Clears the operations in the NAComputation.

inline auto getAtomsSize() const -> std::size_t¶: Returns the number of atoms used in the NAComputation.

inline auto getAtoms() const -> auto&¶: Returns the atoms used in the NAComputation.

inline auto getZones() const -> auto&¶: Returns the zones used in global operations within the NAComputation.

inline auto getInitialLocations() const -> auto&¶: Returns the initial locations of the atoms.

auto getLocationOfAtomAfterOperation(const Atom &atom, const Op &op) const -> Location ¶

Returns the location of the given atom after the given operation.

Parameters:

atom – The atom to get the location for.
op – The operation to get the location after.

Returns:

The location of the atom after the operation.

inline auto emplaceBackAtom(std::string name) -> const Atom&¶

Emplaces a new atom with the given name and returns a reference to the newly created atom.

Parameters:: name – The name of the atom.
Returns:: A reference to the newly created atom.

template<typename ...Args> inline auto emplaceBackZone(Args&&... args) -> const Zone&¶

Emplaces a new zone with the given name and returns a reference to the newly created zone.

Parameters:: args – The name of the zone and, optionally, the extent of the zone.
Returns:: A reference to the newly created zone.

inline auto emplaceInitialLocation(const Atom &atom, const Location &loc) -> const Location&¶

Emplaces a new initial location for the given atom with the given location and returns a reference to the newly created location.

Parameters:

atom – The atom to set the initial location for.
loc – The location of the atom.

Returns:

A reference to the newly created location.

template<typename ...Args> inline auto emplaceInitialLocation(const Atom &atom, Args&&... loc) -> const Location&¶

Emplaces a new initial location for the given atom with the given arguments and returns a reference to the newly created location.

Parameters:

atom – The atom to set the initial location for.
loc – The parameters for the location of the atom.

Returns:

A reference to the newly created location.

template<class T> inline auto emplaceBack(T &&op) -> const Op&¶

Emplaces a new operation of type T with the given operation and returns a reference to the newly created operation.

Template Parameters:: T – The concrete type of the operation.
Parameters:: op – The operation to emplace.
Returns:: A reference to the newly created operation.

template<class T, typename ...Args> inline auto emplaceBack(Args&&... args) -> const Op&¶

Emplaces a new operation of type T with the given arguments and returns a reference to the newly created operation.

Template Parameters:: T – The concrete type of the operation.
Parameters:: args – The arguments for the operation.
Returns:: A reference to the newly created operation.

auto toString() const -> std::string¶: Returns a string representation of the NAComputation.

auto validate() const -> std::pair<bool, std::string>¶

Validates the NAComputation and checks whether all AOD constraints are fulfilled. Specifically,

each atom is loaded before it is moved
the relative order of loaded atoms is preserved
each atom is loaded before it is stored
each atom is stored before it is loaded (again)

Returns:: a pair of a Boolean indicating whether the NAComputation is valid and a string containing the error message if the NAComputation is invalid.

Friends

inline friend auto operator<<(std::ostream &os, const NAComputation &qc) -> std::ostream&¶

Outputs the NAComputation to the given output stream, i.e., the string returned by toString().

Parameters:

os – The output stream to print the NAComputation to.
qc – The NAComputation to print.

Returns:

The output stream after printing the NAComputation.

class Op¶

#include <Op.hpp>

This is the base class for all operations in the NAComputation.

Subclassed by na::GlobalOp, na::LocalOp, na::ShuttlingOp

Public Functions

Op() = default¶: Default constructor.

virtual ~Op() = default¶: Virtual destructor.

virtual auto toString() const -> std::string = 0¶: Returns a string representation of the operation.

template<class T> inline auto is() const -> bool¶

Checks if the operation is of the given type.

Template Parameters:: T – The type to check for.
Returns:: True if the operation is of the given type, false otherwise.

template<class T> inline auto as() -> T&¶

Casts the operation to the given type.

Template Parameters:: T – The type to cast to.
Returns:: A reference to the operation as the given type.

template<class T> inline auto as() const -> const T&¶

Casts the operation to the given type.

Template Parameters:: T – The type to cast to.
Returns:: A const reference to the operation as the given type.

Friends

inline friend auto operator<<(std::ostream &os, const Op &obj) -> std::ostream&¶

Prints the operation to the given output stream.

Parameters:

os – The output stream to print the operation to.
obj – The operation to print.

Returns:

The output stream after printing the operation.

class Session : public fomac::Session ¶

#include <Device.hpp>

Class representing the Session library with neutral atom extensions.