def test_points(SR, N):
elem = Element()
with pytest.raises(KeyError):
elem.points
bp = bb.BluePrint()
bp.insertSegment(0, ramp, (0, 0), dur=N / SR)
bp.setSR(SR)
wfm = np.linspace(-1, 1, N)
elem.addArray(1, wfm, SR)
elem.addBluePrint(2, bp)
assert elem.points == N
elem = Element()
bp = bb.BluePrint()
bp.insertSegment(0, ramp, (0, 0), dur=N / SR)
bp.setSR(SR)
wfm = np.linspace(-1, 1, N)
elem.addArray(2, wfm, SR)
elem.addBluePrint(1, bp)
assert elem.points == N
def elem_from_lists(step_list_a: list, step_list_b: list, ramplist: list,
duration: float = 1e-6, dac_a: float = 0, dac_b: float = 0,
divider_a: float = 1.0, divider_b: float = 1.0,
SR: float = 1e9,
chx: int = 1, chy: int = 2) -> bb.Element:
#Make element from pulse table
elem = bb.Element()
blueprint_a = bb.BluePrint()
blueprint_a.setSR(SR)
blueprint_b = bb.BluePrint()
blueprint_b.setSR(SR)
step_a_old = 0
step_b_old = 0
for i in range(len(step_list_a)):
if ramplist[i] == 1:
step_a = (step_list_a[i]-dac_a)*divider_a
step_b = (step_list_b[i]-dac_b)*divider_b
blueprint_a.insertSegment(i, ramp, (step_a_old, step_a), name=ascii_lowercase[i], dur=duration)
blueprint_b.insertSegment(i, ramp, (step_b_old, step_b), name=ascii_lowercase[i], dur=duration)
else:
step_a = (step_list_a[i]-dac_a)*divider_a
step_b = (step_list_b[i]-dac_b)*divider_b
blueprint_a.insertSegment(i, ramp, (step_a, step_a), name=ascii_lowercase[i], dur=duration)
blueprint_b.insertSegment(i, ramp, (step_b, step_b), name=ascii_lowercase[i], dur=duration)
step_a_old = step_a
step_b_old = step_b
elem.addBluePrint(chx, blueprint_a)
elem.addBluePrint(chy, blueprint_b)
elem.validateDurations()
return elem
def build_jump_and_back_pulse_bp(self, pulse_dict):
sample_rate = pulse_dict.get('sample_rate', self.sample_rate)
ramp_ranges = pulse_dict['vec_amps']
vecs = pulse_dict['vecs']
durs = pulse_dict['durations']
first_index = pulse_dict.get('first_index',0)
channels = pulse_dict['channels']
bps = pulse_dict.get('bps',[bb.BluePrint() for _ in channels])
start = np.array(pulse_dict.get('start',[0 for _ in channels])).astype(float)
start_time = pulse_dict.get('start_time',0.0)
area = np.zeros([2])
for index_ch, ch in enumerate(channels):
bps[index_ch].setSR(sample_rate)
for index_ramp, ramp_range in enumerate(ramp_ranges):
scaled = self._scale_from_vec(vecs[index_ramp], ramp_range)
area[index_ch] += (scaled[index_ch]) * durs[index_ramp]
bps[index_ch].insertSegment(first_index + index_ramp, bb_ramp, (scaled[index_ch],scaled[index_ch]), dur=durs[index_ramp])
if pulse_dict.get('marker1', []):
bps[index_ch].marker1 = [(start_time + t, self.marker_length) for t in pulse_dict.get('marker1',[])]
if pulse_dict.get('marker2', []):
bps[index_ch].marker2 = [(start_time + t, self.marker_length) for t in pulse_dict.get('marker2',[])]
self.bp_dict[str(ch)][pulse_dict['name']] = bps[index_ch]
end = start
final_index = first_index + len(ramp_ranges)
final_time = np.sum(durs) + start_time
update_for_next = {'bps':bps, 'start':end, 'first_index':final_index, 'start_time':final_time}
self.area_dict[pulse_dict.get('name')] = area
return update_for_next
def __init__(self,
chan_map,
sample_rate=1e9,
autofill=True,
detect_autofill=True,
length=None):
self.bps = {}
self.map = {}
chan_map = chan_map.copy()
for i, lst in chan_map.items():
self.bps[i] = bb.BluePrint()
self.bps[i].setSR(sample_rate)
if detect_autofill:
if lst[0] is None and len(lst) > 1:
for elt in lst[1:]:
if elt not in [None, '']:
lst[0] = self.FILL_TOKENS[i - 1]
for j, name in enumerate(lst):
if name is not None:
self.map[name] = (i, j)
if autofill and length is not None and name in self.FILL_TOKENS:
self[name].insertSegment(0,
ramp, (0, 0),
dur=length,
name=name + '_segment')
def subseq1():
"""
A small sequence meant to be used as a subsequence
"""
longdur = 201e-9
wait = bb.BluePrint()
wait.insertSegment(0, ramp, args=(0, 0), dur=10e-9)
wait.setSR(SR1)
wiggle = bb.BluePrint()
wiggle.insertSegment(0, sine, args=(10e6, 10e-3, 0, 0), dur=longdur)
wiggle.setSR(SR1)
blob = bb.BluePrint()
blob.insertSegment(0, gauss, args=(25e-3, 12e-9, 0, 0), dur=longdur)
blob.setSR(SR1)
slope = bb.BluePrint()
slope.insertSegment(0, ramp, (0, 15e-3), dur=longdur)
slope.setSR(SR1)
elem1 = bb.Element()
elem1.addBluePrint(1, wait)
elem1.addBluePrint(2, wait)
elem1.addBluePrint(3, wait)
elem2 = bb.Element()
elem2.addBluePrint(1, wiggle)
elem2.addBluePrint(2, slope)
elem2.addBluePrint(3, blob)
elem3 = elem1.copy()
seq = Sequence()
seq.setSR(SR1)
seq.addElement(1, elem1)
seq.addElement(2, elem2)
seq.addElement(3, elem3)
seq.setSequencingNumberOfRepetitions(1, 10)
seq.setSequencingNumberOfRepetitions(3, 10)
return seq
def protosequence1():
SR = 1e9
th = bb.BluePrint()
th.insertSegment(0, ramp, args=(0, 0), name='ramp', dur=10e-6)
th.insertSegment(1, ramp, args=(1, 1), name='ramp', dur=5e-6)
th.insertSegment(2, ramp, args=(0, 0), name='ramp', dur=10e-6)
th.setSR(SR)
wiggle1 = bb.BluePrint()
wiggle1.insertSegment(0, sine, args=(4e6, 0.5, 0, 0), dur=25e-6)
wiggle1.setSR(SR)
wiggle2 = bb.BluePrint()
wiggle2.insertSegment(0, sine, args=(8e6, 0.5, 0, 0), dur=25e-6)
wiggle2.setSR(SR)
elem1 = bb.Element()
elem1.addBluePrint(1, th)
elem1.addBluePrint(2, wiggle1)
elem2 = bb.Element()
elem2.addBluePrint(1, th)
elem2.addBluePrint(2, wiggle2)
seq = bb.Sequence()
seq.addElement(1, elem1)
seq.addElement(2, elem2)
seq.setSR(SR)
seq.name = 'protoSequence'
seq.setChannelAmplitude(1, 2)
seq.setChannelAmplitude(2, 2)
seq.setChannelOffset(1, 0)
seq.setChannelOffset(2, 0)
seq.setSequencingTriggerWait(1, 1)
seq.setSequencingTriggerWait(2, 1)
seq.setSequencingEventJumpTarget(1, 1)
seq.setSequencingEventJumpTarget(2, 1)
seq.setSequencingGoto(1, 1)
seq.setSequencingGoto(2, 1)
return seq
def test_invalid_durations(SR1, SR2, N, M):
"""
There are soooo many ways to have invalid durations, here
we hit a couple of them
"""
# differing sample rates
elem = Element()
bp = bb.BluePrint()
bp.insertSegment(0, ramp, (0, 0), dur=N / SR2)
bp.setSR(SR2)
wfm = np.linspace(-1, 1, N)
elem.addArray(1, wfm, SR1)
elem.addBluePrint(2, bp)
if SR1 == SR2:
elem.validateDurations()
else:
with pytest.raises(ElementDurationError):
elem.validateDurations()
# differing durations
bp1 = bb.BluePrint()
bp1.insertSegment(0, ramp, (0, 1), dur=N / SR1)
bp1.setSR(SR1)
bp2 = bb.BluePrint()
bp2.insertSegment(0, ramp, (0, 2), dur=M / SR1)
bp2.setSR(SR1)
elem = Element()
elem.addBluePrint(1, bp1)
elem.addBluePrint(2, bp2)
if N == M:
elem.validateDurations()
else:
with pytest.raises(ElementDurationError):
elem.validateDurations()
def bp_element():
dur = 100e-9
bp1 = bb.BluePrint()
bp1.insertSegment(0, sine, (1e6, 10e-3, 0, 0), dur=dur)
bp2 = bb.BluePrint()
bp2.insertSegment(0, sine, (2e6, 10e-3, 0, np.pi / 2), dur=dur)
bp3 = bb.BluePrint()
bp3.insertSegment(0, sine, (3e6, 10e-3, 0, -1), dur=dur)
for bp in [bp1, bp2, bp3]:
bp.setSR(SR1)
elem = bb.Element()
for ch, bp in enumerate([bp1, bp2, bp3]):
elem.addBluePrint(ch + 1, bp)
return elem
def blueprint_tophat():
"""
Return a blueprint consisting of three slopeless ramps forming something
similar to a tophat
"""
th = bb.BluePrint()
th.insertSegment(0, ramp, args=(0, 0), name='ramp', dur=1)
th.insertSegment(1, ramp, args=(1, 1), name='ramp', dur=0.5)
th.insertSegment(2, ramp, args=(0, 0), name='ramp', dur=1)
th.setSR(tophat_SR)
return th
def protosequence2():
SR = 1e9
saw = bb.BluePrint()
saw.insertSegment(0, ramp, args=(0, 100e-3), dur=11e-6)
saw.insertSegment(1, 'waituntil', args=(25e-6))
saw.setSR(SR)
lineandwiggle = bb.BluePrint()
lineandwiggle.insertSegment(0, 'waituntil', args=(11e-6))
lineandwiggle.insertSegment(1, sine, args=(10e6, 50e-6, 10e-6), dur=14e-6)
lineandwiggle.setSR(SR)
elem1 = bb.Element()
elem1.addBluePrint(1, saw)
elem1.addBluePrint(2, lineandwiggle)
elem2 = bb.Element()
elem2.addBluePrint(2, saw)
elem2.addBluePrint(1, lineandwiggle)
seq = bb.Sequence()
seq.setSR(SR)
seq.addElement(1, elem1)
seq.addElement(2, elem2)
seq.setChannelAmplitude(1, 1.5)
seq.setChannelOffset(1, 0)
seq.setChannelAmplitude(2, 1)
seq.setChannelOffset(2, 0)
seq.setSequencingTriggerWait(1, 0)
seq.setSequencingTriggerWait(2, 1)
seq.setSequencingNumberOfRepetitions(1, 2)
seq.setSequencingEventJumpTarget(1, 0)
seq.setSequencingEventJumpTarget(2, 0)
seq.setSequencingGoto(1, 2)
seq.setSequencingGoto(2, 1)
return seq
def __init__(self, chan_map, sample_rate=1e9, autofill=True, length=None):
self.bps = {}
self.map = {}
for i, lst in chan_map.items():
self.bps[i] = bb.BluePrint()
self.bps[i].setSR(sample_rate)
for j, name in enumerate(lst):
if name is not None:
self.map[name] = (i, j)
if autofill and length is not None and name in self.FILL_TOKENS:
self[name].insertSegment(0, ramp, (0, 0), dur=length, name=name+'_segment')
def badseq_missing_pos():
SR = 1e9
saw = bb.BluePrint()
saw.insertSegment(0, ramp, args=(0, 100e-3), dur=11e-6)
saw.insertSegment(1, 'waituntil', args=(25e-6))
saw.setSR(SR)
lineandwiggle = bb.BluePrint()
lineandwiggle.insertSegment(0, 'waituntil', args=(11e-6))
lineandwiggle.insertSegment(1, sine, args=(10e6, 50e-6, 10e-6), dur=14e-6)
lineandwiggle.setSR(SR)
elem1 = bb.Element()
elem1.addBluePrint(1, saw)
elem1.addBluePrint(2, lineandwiggle)
elem2 = bb.Element()
elem2.addBluePrint(2, saw)
elem2.addBluePrint(1, lineandwiggle)
seq = bb.Sequence()
seq.setSR(SR)
seq.addElement(1, elem1)
seq.addElement(3, elem2) # <--- A gap in the sequence
seq.setChannelAmplitude(1, 1.5)
seq.setChannelOffset(1, 0)
seq.setChannelAmplitude(2, 1)
seq.setChannelOffset(2, 0)
seq.setSequencingTriggerWait(3, 1)
seq.setSequencingNumberOfRepetitions(1, 2)
seq.setSequencingGoto(1, 2)
seq.setSequencingGoto(3, 1)
# seq.setSequenceSettings(1, 0, 2, 0, 2)
# seq.setSequenceSettings(2, 1, 1, 0, 1)
return seq
def squarepulse_baseelem():
SR = 1e6
basebp = bb.BluePrint()
basebp.insertSegment(0, ramp, (0, 0), dur=0.5e-4)
basebp.insertSegment(1, ramp, (1, 1), dur=1e-4, name='varyme')
basebp.insertSegment(2, 'waituntil', 5e-4)
basebp.setSR(SR)
baseelem = bb.Element()
baseelem.addBluePrint(1, basebp)
return baseelem
def test_correct_periods():
SR = 1e9
dur = 100e-9
freqs = [100e6, 200e6, 500e6]
periods = [int(SR / freq) for freq in freqs]
for freq, period in zip(freqs, periods):
bp = bb.BluePrint()
bp.insertSegment(0, sine, (freq, 1, 0, 0), dur=dur)
bp.setSR(SR)
wfm = _subelementBuilder(bp, SR, [dur])['wfm']
assert _has_period(wfm, period)
def test_too_short_durations_rejected(SR, ratio):
# Any ratio larger than 1 will be rounded up by
# _subelementBuilder to yield two points
# (is that desired?)
shortdur = ratio*1/SR
bp = bb.BluePrint()
bp.setSR(SR)
bp.insertSegment(0, ramp, (0, 1), dur=shortdur)
if ratio < 1.5:
with pytest.raises(SegmentDurationError):
_subelementBuilder(bp, SR, [shortdur])
else:
_subelementBuilder(bp, SR, [shortdur])
def mixed_element(blueprint_tophat):
"""
An element with blueprints and arrays
"""
noise = np.random.randn(blueprint_tophat.points)
wiggle = bb.BluePrint()
wiggle.insertSegment(0, sine, args=(1, 10, 0, 0), dur=2.5)
wiggle.setSR(blueprint_tophat.SR)
elem = Element()
elem.addBluePrint(1, blueprint_tophat)
elem.addArray(2, noise, blueprint_tophat.SR)
elem.addBluePrint(3, wiggle)
return elem
def blueprint_nasty():
"""
Return a nasty blueprint trying to hit some corner cases
"""
ns = bb.BluePrint()
ns.insertSegment(0, 'waituntil', args=(1, ))
ns.insertSegment(1, ramp, (-1 / 3, 1 / 3), dur=0.1)
ns.insertSegment(2, 'waituntil', args=(1 + 2 / 3, ))
ns.setSR(tophat_SR)
ns.setSegmentMarker('ramp', (-0.1, 0.1), 1)
ns.setSegmentMarker('waituntil2', (0, 2 / 3), 2)
ns.marker1 = [(0, 0.1)]
ns.marker2 = [(1, 0.1)]
return ns
def make_seq(seqlen, channels, SR):
seq = Sequence()
seq.setSR(SR)
for pos in range(1, seqlen + 1):
elem = bb.Element()
for chan in channels:
bp = bb.BluePrint()
bp.insertSegment(-1, ramp, (0, 0), dur=20 / SR)
bp.insertSegment(-1, ramp, (1, 1), dur=10 / SR)
bp.insertSegment(-1, ramp, (0, 0), dur=5 / SR)
bp.setSR(SR)
elem.addBluePrint(chan, bp)
seq.addElement(pos, elem)
return seq
def test_correct_marker_times():
SR = 100
bp = bb.BluePrint()
bp.insertSegment(-1, ramp, (0, 0), dur=1, name='A')
bp.insertSegment(-1, ramp, (0, 0), dur=1, name='B')
bp.insertSegment(-1, ramp, (0, 0), dur=1, name='C')
bp.setSR(SR)
bp.setSegmentMarker('A', (0, 0.5), 1)
bp.setSegmentMarker('B', (-0.1, 0.25), 2)
bp.setSegmentMarker('C', (0.1, 0.25), 1)
forged_bp = _subelementBuilder(bp, SR, [1, 1, 1])
m1 = forged_bp['m1']
assert (m1 == np.concatenate(
(np.ones(50), np.zeros(160), np.ones(25), np.zeros(65)))).all()
def seg_pi(self,
pulse_to_readout_time:float = 0) -> bb.BluePrint:
"""
Returns a broadbean BluePrint of a PI pulse
args:
pulse_to_readout_time (float): time between the end of the PI pulse and the readout
"""
first_time = self.cycle_time-self.pulse_time-self.readout_time-pulse_to_readout_time
end_time = self.readout_time+pulse_to_readout_time
seg_sin = bb.BluePrint()
seg_sin.insertSegment(0, ramp, (0, 0), name='first', dur=first_time)
seg_sin.insertSegment(1, ramp, (0.05, 0.05), name='pulse', dur=self.pulse_time)
seg_sin.insertSegment(2, ramp, (0, 0), name='read', dur=end_time)
seg_sin.marker1 = [(first_time+self.pulse_time+self.marker_offset+pulse_to_readout_time, self.cycle_time)]
seg_sin.setSR(self.SR.get())
return seg_sin
def test_too_short_durations_rejected(SR, ratio):
# Any ratio larger than 1 will be rounded up by
# _subelementBuilder to yield two points
# (is that desired?)
shortdur = ratio * 1 / SR
# however, since this is caluclated as dur*SR
# it is possible for ratio > 1.5 but
# shortdur*SR to be smaller due to fp roundoff
# here we explicitly use shortdur*SR for that reason
round_tripped_ratio = shortdur * SR
bp = bb.BluePrint()
bp.setSR(SR)
bp.insertSegment(0, ramp, (0, 1), dur=shortdur)
if round_tripped_ratio < 1.5:
with pytest.raises(SegmentDurationError):
_subelementBuilder(bp, SR, [shortdur])
else:
_subelementBuilder(bp, SR, [shortdur])
def build_named_ramp_pulse_bp(self, pulse_dict):
sample_rate = pulse_dict.get('sample_rate', self.sample_rate)
ramp_range = pulse_dict['vec_amps'][0]
vec = pulse_dict['vecs'][0]
dur = pulse_dict['durations'][0]
first_index = pulse_dict.get('first_index', 0)
channels = pulse_dict['channels']
bps = pulse_dict.get('bps', [bb.BluePrint() for _ in channels])
start = np.array(pulse_dict.get('start', [0 for _ in channels])).astype(float)
start_time = pulse_dict.get('start_time', 0.0)
area = np.zeros([2])
for index_ch, ch in enumerate(channels):
bps[index_ch].setSR(sample_rate)
scaled = self._scale_from_vec(vec, ramp_range)
area[index_ch] += 0.5*(start[index_ch]*2 + scaled[index_ch])*dur
bps[index_ch].insertSegment(first_index, bb_ramp,
(start[index_ch], start[index_ch] + scaled[index_ch]), dur=dur, name=pulse_dict.get('vary_name')[index_ch])
start[index_ch] += scaled[index_ch]
if pulse_dict.get('marker1', []):
for index, t in enumerate(pulse_dict.get('marker1',[])):
bps[index_ch].setSegmentMarker(pulse_dict.get('vary_name')[index_ch], (t, self.marker_length), index+1)
if pulse_dict.get('marker2', []):
for index, t in enumerate(pulse_dict.get('marker1',[])):
bps[index_ch].setSegmentMarker(pulse_dict.get('vary_name')[index_ch], (t, self.marker_length), index+1)
self.bp_dict[str(ch)][pulse_dict['name']] = bps[index_ch]
end = start
final_index = first_index + 1
final_time = dur + start_time
update_for_next = {'bps': bps, 'start': end, 'first_index': final_index, 'start_time': final_time}
self.area_dict[pulse_dict.get('name')] = area
return update_for_next
def seg_sine_readout(self,
frequency:float,
phase:float = 0,
amplitude:float = 1e-3,
marker:bool = True ) -> bb.BluePrint:
"""
Returns a broadbean BluePrint contaning a flat segment, sine segment and a flat segment for readout
args:
frequency (float): frequency of the sine
phase (float): phase of the sine
"""
first_time = self.cycle_time-self.readout_time
seg_sin = bb.BluePrint()
seg_sin.insertSegment(0, ramp, (0, 0), name='first', dur=first_time)
seg_sin.insertSegment(1, sine, (frequency, amplitude, 0, phase), name='pulse', dur=self.readout_time)
if marker:
seg_sin.marker1 = [(first_time+self.marker_offset, self.cycle_time)]
seg_sin.setSR(self.SR.get())
return seg_sin
def generateElement(self):
# Make element from pulse table
self.gelem = bb.Element()
h = int((self.table.columnCount() - 2) / 3)
prevlvl = 0
v = self.table.rowCount()
for col in range(2, h + 2):
chno = int(self.table.horizontalHeaderItem(col).text()[2])
gp = bb.BluePrint()
gp.setSR(self.awgclock)
for row in range(v):
nm = self.table.verticalHeaderItem(row).text()
dr = (float(self.table.item(row, 0).text())) * 1e-6
rmp = int(self.table.item(row, 1).text())
lvl = (float(self.table.item(
row, col).text())) * self.divider_ch[col - 2] * 1e-3
mkr1 = int(self.table.item(row, h + 2).text())
mkr2 = int(self.table.item(row, h + 3).text())
if rmp == 0:
gp.insertSegment(row, ramp, (lvl, lvl), name=nm, dur=dr)
if rmp == 1:
if row == 0:
gp.insertSegment(row, ramp, (0, lvl), name=nm, dur=dr)
else:
gp.insertSegment(row,
ramp, (prevlvl, lvl),
name=nm,
dur=dr)
if mkr1 == 1:
gp.setSegmentMarker(nm, (0, dr), 1)
if mkr2 == 1:
gp.setSegmentMarker(nm, (0, dr), 2)
prevlvl = lvl
self.gelem.addBluePrint(chno, gp)
h = h + 2
self.gelem.validateDurations()
try:
from broadbean.plotting import plotter
except:
plotter = bb.plotter
sine = bb.PulseAtoms.sine
ramp = bb.PulseAtoms.ramp
SR = 1e9
t1 = 200e-6 # wait
t2 = 20e-9 # perturb the system
t3 = 250e-6 # read out
compression = 100 # this number has to be chosen with some care
bp1 = bb.BluePrint()
bp1.insertSegment(0, ramp, (0, 0), dur=t1 / compression)
bp1.setSR(SR)
elem1 = bb.Element()
elem1.addBluePrint(1, bp1)
#
bp2 = bb.BluePrint()
bp2.insertSegment(0, ramp, (1, 1), dur=t2, name='perturbation')
bp2.setSR(SR)
elem2 = bb.Element()
elem2.addBluePrint(1, bp2)
#
bp3 = bb.BluePrint()
bp3.insertSegment(0, ramp, (0, 0), dur=t3 / compression, name='marker')
bp3.setSegmentMarker('marker', (0.0, 1e-6), 1)
bp3.setSR(SR)
arrays_after = element.getArrays()
assert len(arrays_after[1]['wfm']) == 5200
assert mixed_element.duration == 2.5
assert element.duration == 2.6
assert element._data[1]['blueprint'].length_segments == 4
assert element._data[3]['blueprint'].length_segments == 2
##################################################
# Input validation
@pytest.mark.parametrize('improper_bp', [{1: 2}, 'blueprint', bb.BluePrint()])
def test_input_fail1(improper_bp):
elem = Element()
with pytest.raises(ValueError):
elem.addBluePrint(1, improper_bp)
##################################################
# Properties
@settings(max_examples=25,
suppress_health_check=(HealthCheck.function_scoped_fixture, ))
@given(SR=hst.integers(min_value=1, max_value=25 * 10**8),
N=hst.integers(min_value=2, max_value=25 * 10**6))
def test_points(SR, N):
def ramp(samples, start, stop, f_sam = 2.4e9):
bp = bb.BluePrint()
dur = samples/f_sam
bp.insertSegment(0, bb_ramp, (start, stop), dur=dur)
bp.setSR(f_sam)
return bp
def rect(samples, amp, f_sam = 2.4e9):
bp = bb.BluePrint()
dur = samples/f_sam
bp.insertSegment(0, bb_ramp, (amp, amp), dur=dur)
bp.setSR(f_sam)
return bp
def virgin_blueprint():
"""
Return an empty instance of BluePrint
"""
return bb.BluePrint()
def makeT2Sequence(hightimes, trig_delay, RF_delay, meastime, cycletime,
pulsehigh, pulselow, no_of_avgs, SR):
"""
Generate the pulse sequence for the experiment.
The sequence consists of three parts:
1: A wait with zeros allowing the ZI to get ready. This part is
short, but repeated waitbits times
2: A short zero part with the marker2 trigger for the ramp
3: The high pulse and a marker1 trigger for the ZI
Args:
hightimes (iterables): The widths of the pulse (s)
trig_delay (float): The delay to start measuring after the end of the
pulse (s).
meastime (float): The time of each measurement (s).
cycletime (float): The time of each pulse-measure cycle (s).
pulsehigh (float): The amplitude of the pulse (V)
pulselow (float): The amplitude during the measurement (V)
no_of_avgs (int): The number of averages
SR (int): The AWG sample rate (Sa/s)
"""
segname = 'high'
# Fail if the sequence would end up being too long for the AWG to handle
if len(hightimes) * cycletime * SR >= 16e6:
raise ValueError("Sequence too long. You are trying to build a "
"sequence with {:d} MSamples. The maximally allowed "
"number of samples is "
"16 MSamples.".format(
int(len(hightimes) * cycletime * SR / 1e6)))
##################################################################
# The pulsed part
bp1 = bb.BluePrint()
bp1.setSR(SR)
bp1.insertSegment(0,
ramp, (pulsehigh, pulsehigh),
durs=hightimes[0],
name=segname)
bp1.insertSegment(1,
ramp, (pulselow, pulselow),
durs=meastime,
name='measure')
# dead time for the scope to re-arm its trigger
bp1.insertSegment(2, 'waituntil', cycletime)
bp1.setSegmentMarker(segname, (RF_delay, meastime),
1) # segment name, (delay, duration), markerID
bp1.setSegmentMarker(segname, (trig_delay, meastime), 2)
pulseelem = bb.Element()
pulseelem.addBluePrint(1, bp1)
seq = bb.Sequence()
seq.setSR(SR)
for index, ht in enumerate(hightimes):
elem = pulseelem.copy()
elem.changeDuration(1, segname, ht)
seq.addElement(index + 1, elem)
seq.setSequenceSettings(index + 1, 0, no_of_avgs, 0, 0)
return seq
