Skip to content

Base

AtomArrangement

Bases: ProgramStart, TransformTrait

n_atoms property 

n_atoms

number of atoms (filled sites) in the register.

n_dims property 

n_dims

number of dimensions in the register.

n_sites property 

n_sites

number of sites in the register.

n_vacant property 

n_vacant

number of vacant sites in the register.

enumerate 

enumerate()

enumerate all locations in the register.

Source code in src/bloqade/ir/location/base.py 
106
107
108
def enumerate(self) -> Generator[LocationInfo, None, None]:
    """enumerate all locations in the register."""
    raise NotImplementedError

figure 

figure(fig_kwargs=None, **assignments)

obtain a figure object from the atom arrangement.

Source code in src/bloqade/ir/location/base.py 
110
111
112
def figure(self, fig_kwargs=None, **assignments):
    """obtain a figure object from the atom arrangement."""
    return get_atom_arrangement_figure(self, fig_kwargs, **assignments)

rydberg_interaction 

rydberg_interaction(**assignments)

calculate the Rydberg interaction matrix.

Parameters:

Name Type Description Default
**assignments

the values to assign to the variables in the register.

 {}

Returns:

Name Type Description
NDArray NDArray

the Rydberg interaction matrix in the lower triangular form.
Source code in src/bloqade/ir/location/base.py 
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
def rydberg_interaction(self, **assignments) -> NDArray:
    """calculate the Rydberg interaction matrix.

    Args:
        **assignments: the values to assign to the variables in the register.

    Returns:
        NDArray: the Rydberg interaction matrix in the lower triangular form.

    """

    from bloqade.constants import RB_C6

    # calculate the Interaction matrix
    V_ij = np.zeros((self.n_sites, self.n_sites))
    for i, site_i in enumerate(self.enumerate()):
        pos_i = np.array([float(ele(**assignments)) for ele in site_i.position])

        for j, site_j in enumerate(self.enumerate()):
            if j >= i:
                break  # enforce lower triangular form

            pos_j = np.array([float(ele(**assignments)) for ele in site_j.position])
            r_ij = np.linalg.norm(pos_i - pos_j)

            V_ij[i, j] = RB_C6 / r_ij**6

    return V_ij

ParallelRegister 

ParallelRegister(register, cluster_spacing)

Bases: ProgramStart

Parallel Register

Source code in src/bloqade/ir/location/base.py 
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
@beartype
def __init__(self, register: AtomArrangement, cluster_spacing: ScalarType):
    self._register = register
    self._cluster_spacing = cast(cluster_spacing)

    if register.n_atoms > 0:
        # calculate bounding box
        # of this register
        location_iter = register.enumerate()
        (x, y) = next(location_iter).position
        x_min = x
        x_max = x
        y_min = y
        y_max = y

        for location_info in location_iter:
            (x, y) = location_info.position
            x_min = x.min(x_min)
            x_max = x.max(x_max)
            y_min = y.min(y_min)
            y_max = y.max(y_max)

        shift_x = (x_max - x_min) + cluster_spacing
        shift_y = (y_max - y_min) + cluster_spacing

        register_locations = [
            list(location_info.position) for location_info in register.enumerate()
        ]
        register_filling = [
            location_info.filling.value for location_info in register.enumerate()
        ]
        shift_vectors = [[shift_x, cast(0)], [cast(0), shift_y]]
    else:
        raise ValueError("No locations to parallelize.")

    self.register_locations = register_locations
    self.register_filling = register_filling
    self.shift_vectors = shift_vectors
    super().__init__(self)