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