mirror of
https://github.com/m-labs/artiq.git
synced 2024-12-25 11:18:27 +08:00
103 lines
3.1 KiB
Python
103 lines
3.1 KiB
Python
import numpy as np
|
|
|
|
from artiq import *
|
|
|
|
|
|
# data is usually precomputed offline
|
|
transport_data = dict(
|
|
t=np.linspace(0, 10, 101), # waveform time
|
|
u=np.random.randn(101, 4*3*3), # waveform data,
|
|
# 4 devices, 3 board each, 3 dacs each
|
|
)
|
|
|
|
class Transport(EnvExperiment):
|
|
"""Transport"""
|
|
|
|
def build(self):
|
|
self.attr_device("core")
|
|
self.attr_device("bd")
|
|
self.attr_device("bdd")
|
|
self.attr_device("pmt")
|
|
self.attr_device("electrodes")
|
|
|
|
self.attr_argument("wait_at_stop", FreeValue(100*us))
|
|
self.attr_argument("speed", FreeValue(1.5))
|
|
self.attr_argument("repeats", FreeValue(100))
|
|
self.attr_argument("nbins", FreeValue(100))
|
|
|
|
def calc_waveforms(self, stop):
|
|
t = transport_data["t"][:stop]*self.speed
|
|
u = transport_data["u"][:stop]
|
|
|
|
self.electrodes.disarm()
|
|
self.tf = self.electrodes.create_frame()
|
|
self.tf.create_segment(t, u, name="to_stop")
|
|
# append the reverse transport (from stop to 0)
|
|
# both durations are the same in this case
|
|
self.tf.create_segment(t[-1] - t[::-1], u[::-1], name="from_stop")
|
|
# distributes frames to the sub-devices in CompoundPDQ2
|
|
# and uploads them
|
|
self.electrodes.arm()
|
|
|
|
@kernel
|
|
def cool(self):
|
|
with parallel:
|
|
self.bd.pulse(200*MHz, 1*ms)
|
|
self.bdd.pulse(300*MHz, 1*ms)
|
|
self.bd.pulse(210*MHz, 100*us)
|
|
|
|
@kernel
|
|
def transport(self):
|
|
# selects transport frame
|
|
# triggers pdqs to start transport frame segment
|
|
# plays the transport waveform from 0 to stop
|
|
# delay()s the core by the duration of the waveform segment
|
|
self.tf.to_stop.advance()
|
|
# leaves the ion in the dark at the transport endpoint
|
|
delay(self.wait_at_stop)
|
|
# transport back (again: trigger, delay())
|
|
# segments can only be advance()ed in order
|
|
# since this is the last segment, pdq will go back to jump table
|
|
self.tf.from_stop.advance()
|
|
|
|
@kernel
|
|
def detect(self):
|
|
with parallel:
|
|
self.bd.pulse(220*MHz, 100*us)
|
|
self.pmt.gate_rising(100*us)
|
|
self.bd.on(200*MHz)
|
|
self.bdd.on(300*MHz)
|
|
return self.pmt.count()
|
|
|
|
@kernel
|
|
def one(self):
|
|
self.cool()
|
|
self.transport()
|
|
return self.detect()
|
|
|
|
@kernel
|
|
def repeat(self):
|
|
self.histogram = [0 for _ in range(self.nbins)]
|
|
|
|
for i in range(self.repeats):
|
|
n = self.one()
|
|
if n >= self.nbins:
|
|
n = self.nbins - 1
|
|
self.histogram[n] += 1
|
|
|
|
def scan(self, stops):
|
|
for s in stops:
|
|
self.histogram = []
|
|
# non-kernel, build frames
|
|
# could also be rpc'ed from repeat()
|
|
self.calc_waveforms(s)
|
|
# kernel part
|
|
self.repeat()
|
|
# live update 2d plot with current self.histogram
|
|
# broadcast(s, self.histogram)
|
|
|
|
def run(self):
|
|
# scan transport endpoint
|
|
stops = range(10, len(transport_data["t"]), 10)
|
|
self.scan(stops)
|