def CROT_cali_meas(pair, target, ancilla, old_freq, time, flip): s = six_dot_sample(qc.Station.default.pulse) var_mgr = variable_mgr() pair = str(int(pair)) s.init(pair[0], pair[1]) s.wait(100).add(s.manip) s.pre_pulse.add(s.manip) s.wait(100).add(s.manip) gate_set = getattr(s, f'q{pair}') target_gate_set = getattr(s, f'q{pair[target-1]}') ancilla_gate_set = getattr(s, f'q{pair[ancilla-1]}') if flip: ancilla_gate_set.X180.add(s.manip) # target_gate_set.X180.add(s.manip) scan_range = single_qubit_gate_spec(f'qubit{target}_MW', linspace(old_freq*1e9-10e6, old_freq*1e9+10e6, 100, axis= 0, name='freq', unit='Hz'), time, getattr(var_mgr, f'q{pair[target-1]}_MW_power'), padding=2) gate_to_test = getattr(gate_set, f'CROT{target}{ancilla}') gate_to_test.add(s.manip, gate_spec = scan_range) s.wait(100).add(s.manip) s.read(pair[target-1]) sequence, minstr, name = run_qubit_exp(f'crot-z_crot_cal_q{pair}_target{pair[target-1]}', s.segments(), s.measurement_manager) return sequence, minstr, name
def cphase_ZZ_calib(target, even=False, plot=False): ''' Args: qubit_pair (str) : pair of qubits to calibrate cphase for. ''' s = six_dot_sample(qc.Station.default.pulse) target = str(int(target)) s.init(target[0], target[1]) s.wait(100).add(s.manip) s.pre_pulse.add(s.manip) s.wait(100).add(s.manip) sweep = lp.linspace(-0.2*np.pi,4*np.pi, 100, 'angle', 'rad', 0)/2 getattr(s,f'q{target[0]}').X90.add(s.manip) getattr(s,f'q{target}').cphase.add(s.manip, cphase_angle=sweep, padding = 30, phase_corrections={}) getattr(s,f'q{target[0]}').X180.add(s.manip) getattr(s,f'q{target[1]}').X180.add(s.manip) getattr(s,f'q{target}').cphase.add(s.manip, cphase_angle=sweep, padding = 30, phase_corrections={}) getattr(s,f'q{target[0]}').X90.add(s.manip) s.wait(100).add(s.manip) s.read(target[0], target[1]) sequence, minstr, name = run_qubit_exp(f'cphase cal :: {target}', s.segments(), s.measurement_manager) ds = scan_generic(sequence, minstr, name=name).run() target_ds = target[0] input_phases = ds(f'read{target_ds}').x() amplitude = ds(f'read{target_ds}').y() # get rid of the first part due to heating input_phases = input_phases[10:] amplitude = amplitude[10:] phase, std_error = fit_phase(input_phases, amplitude, plot=plot) if even == True: cphase_angle = (3*np.pi - phase)/2 else: cphase_angle = (2*np.pi + phase)/2 var_mgr = variable_mgr() setattr(var_mgr, f'J_pi_{target}', cphase_angle) if not hasattr(var_mgr,f'J_pi_{target}'): var_mgr.add_variable(f'cphase{target}',f'J_pi_{target}','rad',0.1,0) old_phase = getattr(var_mgr,f'J_pi_{target}') setattr(var_mgr,f'J_pi_{target}', round(phase,3))
def calib_J_V_off(target, plot=False): ''' calibrates a single qubit phase for a target qubit Args: target (int) : qubit pair to target ''' var_mgr = variable_mgr() s = six_dot_sample(qc.Station.default.pulse) target = str(int(target)) s.init(target[0], target[1]) s.wait(100).add(s.manip) s.pre_pulse.add(s.manip) s.wait(100).add(s.manip) gates = globals()[f'J{target}'].gates voltages =globals()[f'J{target}'].voltages_gates gate_time = lp.linspace(0,getattr(var_mgr, f'time_{target}')*8, 100, axis=0, name='time', unit='ns') getattr(s,f'q{target[0]}').X90.add(s.manip) cphase_basic(s.manip, gates, tuple([0]*len(gates)), voltages, t_gate= gate_time/2, t_ramp=100) getattr(s,f'q{target[0]}').X180.add(s.manip) getattr(s,f'q{target[1]}').X180.add(s.manip) cphase_basic(s.manip, gates, tuple([0]*len(gates)), voltages, t_gate= gate_time/2, t_ramp=100) getattr(s,f'q{target[0]}').X90.add(s.manip) s.wait(100).add(s.manip) s.read(target[0], target[1]) sequence, minstr, name = run_qubit_exp(f'J_V_off cal :: {target}', s.segments(), s.measurement_manager) ds = scan_generic(sequence, minstr, name=name).run() time = ds(f'read{target[0]}').x()*1e-9 probabilities = ds(f'read{target[0]}').y() time = time[5:] probabilities = probabilities[5:] Pi_time = fit_ramsey(time, probabilities, plot=plot) J_max = 1/(Pi_time*2)*1e9 J_max_voltage = J_to_voltage(J_max, 0, globals()[f'J{target}'].J_max, globals()[f'J{target}'].alpha) J_off = J_max_voltage - 1 if not hasattr(var_mgr,f'J_V_off{target}'): var_mgr.add_variable(f'cphase{target}',f'J_V_off{target}', 'mV',0.1,0) old_phase = getattr(var_mgr,f'J_V_off{target}') setattr(var_mgr,f'J_V_off{target}', round(J_off,3)) return J_off
def cphase_ZI_IZ_cal(pair, target, even=True, plot=False): ''' calibrate single qubit phases. args: pair : pair of qubit to calibrate target : qubit to target with the cnot even : if initial state is even Flase, else True ''' s = six_dot_sample(qc.Station.default.pulse) pair = str(int(pair)) s.init(pair[0], pair[1]) s.wait(100).add(s.manip) s.pre_pulse.add(s.manip) s.wait(100).add(s.manip) getattr(s, f'q{target}').X90.add(s.manip) getattr(s, f'q{pair}').cphase.add(s.manip, padding = 30, phase_corrections={}) getattr(s, f'q{target}').X90.add(s.manip, phase = lp.linspace(-1,4*np.pi, 80, 'angle', 'rad', 0)) s.wait(100).add(s.manip) s.read(pair[0], pair[1]) sequence, minstr, name = run_qubit_exp(f'cphase single qubit phase cal :: q{target}', s.segments(), s.measurement_manager) ds = scan_generic(sequence, minstr, name=name).run() input_phases = ds(f'read{target}').x() amplitude = ds(f'read{target}').y() # get rid of the first part due to heating input_phases = input_phases[10:] amplitude = amplitude[10:] phase, std_error = fit_phase(input_phases, amplitude, plot=plot) phase = -phase if even == True: phase += np.pi var_mgr = variable_mgr() if not hasattr(var_mgr, f'PHASE_q{target}_q{pair}_cphase'): var_mgr.add_variable(f'cphase{pair}',f'PHASE_q{target}_q{pair}_cphase','rad',0.1,0) old_phase = getattr(var_mgr, f'PHASE_q{target}_q{pair}_cphase') setattr(var_mgr, f'PHASE_q{target}_q{pair}_cphase', round(phase,3)) print('setting ' + f'PHASE_q{target}_q{pair}_cphase to {phase}')
def res_calib(target, plot=False): ''' calibrates a single qubit phase for a target qubit Args: target (int) : qubit number to target (1-6) ancillary (list) : qubit that need to be initialized to make this work ''' s = six_dot_sample(qc.Station.default.pulse) var_mgr = variable_mgr() s.init(target) s.wait(100).add(s.manip) s.pre_pulse.add(s.manip) s.wait(100).add(s.manip) gate_set = getattr(s, f'q{target}') old_freq = getattr(var_mgr, f'frequency_q{target}') gate_set.X180.add(s.manip, f_qubit=linspace(old_freq * 1e9 - 10e6, old_freq * 1e9 + 10e6, 100, axis=0, name='freq', unit='Hz')) s.wait(100).add(s.manip) s.read(target) sequence, minstr, name = run_qubit_exp(f'frequency_cal_q{target}', s.segments(), s.measurement_manager) ds = scan_generic(sequence, minstr, name=name).run() frequency = ds(f'read{target}').x() probabilities = ds(f'read{target}').y() resonance = fit_resonance(frequency, probabilities, plot=plot) var_mgr = variable_mgr() old_res = getattr(var_mgr, f'frequency_q{target}') setattr(var_mgr, f'frequency_q{target}', round(resonance * 1e-9, 6)) print( f'calibrated resonance for qubit {target}, ' + f'Old resonance : {round(old_res,6)} \n New resonance : {round(resonance*1e-9,6)} \n' )
def phase_offset_charac(seg, gate_set_qubit_1, gate_to_test=None, npoints=100, axis=0): ''' detects for example start shifts on other qubits due due to a drive ''' gate_set_qubit_1.X.add(seg, phase_corrections={}) if gate_to_test is not None: gate_to_test.add(seg, phase_corrections={}) gate_set_qubit_1.Z( linspace(0, np.pi * 4, npoints, axis=axis, name='Phase shift', unit='rad')).add(seg) gate_set_qubit_1.X.add(seg, phase_corrections={})
def Pi_calib(target, plot=False): ''' calibrates a single qubit phase for a target qubit Args: target (int) : qubit number to target (1-6) ancillary (list) : qubit that need to be initialized to make this work ''' s = six_dot_sample(qc.Station.default.pulse) var_mgr = variable_mgr() s.init(target) s.wait(100).add(s.manip) s.pre_pulse.add(s.manip) s.wait(100).add(s.manip) gate_set = getattr(s, f'q{target}') old_pi = getattr(var_mgr, f'pi_q{target}_m3dbm') gate_set.X90.add(s.manip, t_pulse = linspace(0,old_pi*4, 60, 'time', 'ns', 0)) s.wait(100).add(s.manip) s.read(target) sequence, minstr, name = run_qubit_exp(f'Pi_cal_q{target}', s.segments(), s.measurement_manager) ds = scan_generic(sequence, minstr, name=name).run() time = ds(f'read{target}').x()*1e-9 probabilities = ds(f'read{target}').y() time = time[5:] probabilities = probabilities[5:] Pi_time = fit_ramsey(time, probabilities, plot=plot) var_mgr = variable_mgr() old_Pi = getattr(var_mgr, f'pi_q{target}_m3dbm') setattr(var_mgr, f'pi_q{target}_m3dbm', round(Pi_time,6)) print(f'calibrated resonance for qubit {target}, '+ f'Old resonance : {round(old_Pi,6)} \n New resonance : {round(Pi_time,6)} \n')
def generature_single_qubit_RB(segment, gate_set, n_gates, n_rand, RB_type='XZ', interleave=None, seed=None): ''' generate a RB sequence for a single qubit. Args: segment (segment_container) : container of the segments gate_set (load_set_single_qubit) : object containg instruction of the gate set n_gates (lp.loopobj) : x axis of the RB plot n_rand (int) : number of repetition for each n in n_gates RB_type (str) : 'XY' or 'XZ', which type of gate should be used for this RB interleave (gate) : gate of gate_set (e.g. gate_set.X) seed (int) : seed number to start from (if you want to generate multiple times the same RB sequence) ''' # make sure current dimensions are applied (-- overwrite user specs) n_gates.axis = [0] n_gates.name = 'N Cliffords' n_gates.unit = '#' rand = linspace(1, n_rand, n_rand, axis=1, name='Nth rep', unit='#') getattr(segment, gate_set.qubit).update_dim(rand) getattr(segment, gate_set.qubit).update_dim(n_gates) RB_mgmt = RB_mgr(gate_set, RB_type, seed) cl_n = [[[] for i in range(n_gates.data.size)] for j in range(n_rand)] for n in range(n_rand): for m in range(n_gates.data.size): rands = RB_mgmt.add_cliffords( getattr(segment, gate_set.qubit)[n, m], int(n_gates.data[m])) cl_n[n][m] = rands return rands
# @@@ test timing of 200 * 200 2D loop with 100 pulse segments # a) adding pulses # b) rendering pulse segments # import matplotlib.pyplot as plt from pulse_lib.segments.segment_HVI_variables import segment_HVI_variables test_HVI_marker = segment_HVI_variables("name") s = segment_pulse("test", test_HVI_marker) from pulse_lib.segments.utility.looping import linspace a = tuple() b = tuple() print(a, b, a+b) t2 = linspace(100,500, 20, axis= 0) t = linspace(1,50, 10000, name = "test", unit = "test", axis= 0) # s.data_tmp = s.data[0] s.add_block(20, 50, 20) print(s.data[0].total_time) s.add_HVI_marker("test", 15) # s.reset_time() # s.add_block(20, 30, t) # s.wait(10) # s.plot_segment() # plt.show() print(s.setpoints) # print(s.loops) # print(s.units) print(test_HVI_marker.data)
# create "AWG1" awgs = init_hardware() # create channels P1, P2 p = init_pulselib(awgs, virtual_gates=True) gates = ['vP1', 'vP2'] v_init = [70, 20] v_manip = [0, 0] v_read = [30, 25] t_measure = 100 # short time for visibility of other pulses t_X90 = 50 amplitude = 50 t_pulse = lp.linspace(100, 1000, 10, axis=0) f_drive = lp.linspace(2.41e9, 2.43e9, 11, axis=1) amplitude = 50 # init pulse init = p.mk_segment() init.add_block(0, 100, gates, v_init, reset_time=True) init.add_ramp(0, 50, gates, v_init, v_manip) manip = p.mk_segment() manip.q1.add_MW_pulse(0, t_pulse, amplitude, f_drive) # read-out t_measure = 200 # short time for visibility of pulse readout = p.mk_segment() readout.add_ramp(0, 100, gates, v_manip, v_read, reset_time=True)
super().__init__(name=name, val_mapping=val_map, initial_value=my_seq.setpoints[dim][0]) def set_raw(self, value): self.my_seq.set_sweep_index(self.dim, value) if __name__ == '__main__': from pulse_lib.segments.segment_container import segment_container import pulse_lib.segments.utility.looping as lp a = segment_container(["a", "b"]) b = segment_container(["a", "b"]) b.a.add_block(0, lp.linspace(30, 100, 10), 100) b.a.reset_time() a.add_HVI_marker("marker_name", 20) b.add_HVI_marker("marker_name2", 50) b.add_HVI_variable("my_vatr", 800) a.a.add_block(20, lp.linspace(50, 100, 10, axis=1, name="time", unit="ns"), 100) b.slice_time(0, lp.linspace(80, 100, 10, name="time", unit="ns", axis=2)) my_seq = [a, b] seq = sequencer(None, dict()) seq.add_sequence(my_seq) print(seq.HVI_variables.flat[0].HVI_markers)
from pulse_lib.base_pulse import pulselib @loops_to_numpy def triangle(height:np.ndarray, slope1:np.ndarray, slope2:np.ndarray) -> np.ndarray: ''' height: height in mV slope1: rising slope in mV/ns slope2: falling slope in mV/ns ''' t_ramp1 = height/slope1 t_ramp2 = -height/slope2 return t_ramp1, t_ramp2 p = pulselib('') p.define_channel('P1', 'AWG1', 1) slope1 = linspace(10, 100, 10, axis=0) slope2 = -linspace(20, 100, 5, axis=1) height = 400 t_ramp1, t_ramp2 = triangle(height, slope1, slope2) s = p.mk_segment() s.P1.add_ramp_ss(0, t_ramp1, 0, height) s.reset_time() s.P1.add_ramp_ss(0, t_ramp2, height, 0) s.plot([0,0]) s.plot([0,5]) s.plot([1,0]) import matplotlib.pyplot as plt plt.show()
# create channels P1, P2 p = init_pulselib(awgs, virtual_gates=True) gates = ['vP1','vP2'] v_init = [70, 20] v_manip = [0,0] v_read = [30, 25] t_measure = 100 # short time for visibility of other pulses f_drive = 2.420e9 t_X90 = 50 amplitude = 50 t_wait = lp.linspace(0, 200, 21, axis=0) # init pulse init = p.mk_segment() init.add_block(0, 100, gates, v_init) init.add_ramp(100, 140, gates, v_init, v_manip) # Ramsey manip = p.mk_segment() init.add_block(0, -1, gates, v_manip) manip.q1.add_MW_pulse(0, t_X90, amplitude, f_drive) manip.q1.wait(t_wait) manip.q1.reset_time() manip.q1.add_MW_pulse(0, t_X90, amplitude, f_drive) # read-out
import matplotlib.pyplot as pt from pulse_lib.tests.hw_schedule_mock import HardwareScheduleMock import pulse_lib.segments.utility.looping as lp from configuration.small import init_hardware, init_pulselib from utils.plot import plot_awgs # create "AWG1" awgs = init_hardware() # create channels P1, P2 p = init_pulselib(awgs) v_param = lp.linspace(0, 200, 5, axis=0, unit = "mV", name = "vPulse") t_wait = lp.linspace(20, 100, 3, axis=1, unit = "mV", name = "t_wait") seg1 = p.mk_segment() seg2 = p.mk_segment() seg1.P1.add_ramp_ss(0, 100, 0, v_param) seg1.P1.add_block(100, 200, v_param) seg2.P2.add_block(0, 100, 200) seg2.P2.wait(t_wait) seg2.reset_time() seg2.add_HVI_marker('dig_trigger_1', t_off=50) seg2.P1.add_block(0, 100, v_param)
def calib_symm_point(target, even=False, plot=False): ''' Args: qubit_pair (str) : pair of qubits to calibrate cphase for. ''' s = six_dot_sample(qc.Station.default.pulse) var_mgr = variable_mgr() J_off_volt = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) time = getattr(var_mgr, f'time_{target}') target = str(int(target)) s.init(target[0], target[1]) gates = globals()[f'J{target}'].gates voltages_gates = globals()[f'J{target}'].voltages_gates voltages_gates = list(voltages_gates) sweep_gate = lp.linspace(-6, 6, 51, axis=0, name=f'vP{target[0]}', unit='mV') step_gate = lp.linspace(-6, 6, 51, axis=1, name=f'vP{target[1]}', unit='mV') voltages_gates[2 * (int(target[0]) - 1) + 1] = sweep_gate voltages_gates[2 * (int(target[1]) - 1) + 1] = step_gate voltages_gates = tuple(voltages_gates) cphase = two_qubit_gate_generic( cphase_basic, { 'gates': gates, 'v_exchange_pulse_off': J_off_volt, 'v_exchange_pulse_on': voltages_gates, 't_gate': time, 't_ramp': 20 }, {}) s.wait(100).add(s.manip) s.pre_pulse.add(s.manip) s.wait(100).add(s.manip) getattr(s, f'q{target[0]}').X90.add(s.manip) cphase.add(s.manip) getattr(s, f'q{target[0]}').X180.add(s.manip) getattr(s, f'q{target[1]}').X180.add(s.manip) cphase.add(s.manip) getattr(s, f'q{target[0]}').X90.add(s.manip) s.wait(100).add(s.manip) s.read(target[0]) sequence, minstr, name = run_qubit_exp(f'symm cal :: {target}', s.segments(), s.measurement_manager) ds = scan_generic(sequence, minstr, name=name).run() x_axis = ds(f'read{target[0]}').x() y_axis = ds(f'read{target[0]}').y() probabilities = ds(f'read{target[0]}').z() fit_symmetry(x_axis, y_axis, probabilities, plot)
def SD2_calibration(verbose=False): gates, _311113, ST_anti_12, ST_anti_12_tc_high, ST_anti_56, vSD1_threshold, vSD2_threshold = variables( ) anticrossing = ST_anti_56 pulse = qc.Station.default.pulse TRIG = mk_TRIG() EMPTY = pulse.mk_segment() var_mgr = variable_mgr() anticrossing = list(anticrossing) anticrossing[11] = lp.linspace(anticrossing[11] - 2, anticrossing[11] + 2, 2, axis=1, name='vP6', unit='mV') anticrossing[13] = lp.linspace(anticrossing[13] - 2, anticrossing[13] + 2, 80, axis=0, name='vSD2', unit='mV') anticrossing = tuple(anticrossing) PSB_read_multi(EMPTY, gates, 2e3, 2e3, _311113, anticrossing, 1, unmute='M_SD2') seq = [TRIG, EMPTY] raw_trace = False t_meas = 2e3 n_qubit = 1 n_rep = 500 sequence, minstr, name = run_PSB_exp( 'SD2_calibration', seq, t_meas, n_rep, n_qubit, raw_trace, phase=[var_mgr.RF_readout_phase, var_mgr.RF_readout_phase_SD2], order=[2]) ds = scan_generic(sequence, minstr, name=name).run() data = ds.m1a() y = ds.m1.y() SD2_winner = 0 contrast = 0 threshold = 0 for x in range(50): if data[1][x] - data[0][x] > contrast: contrast = data[1][x] - data[0][x] threshold = (data[1][x] + data[0][x]) / 2 SD2_winner = y[x] print(SD2_winner) var_mgr.SD2_P_on_11 = SD2_winner print(contrast) print(threshold) var_mgr.vSD2_threshold = threshold return None
# create channels P1, P2 p = init_pulselib(awgs, virtual_gates=True) seg = p.mk_segment() # points to pulse to gates = ['vP1', 'vP2'] P0 = (-100, -100) P1 = (-100, 100) P2 = ( -25, 25) P3 = ( 5, -5) # check PSB result for all values in square defined by P2 and P3 PSB_sweep = ( lp.linspace(P2[0],P3[0],5, axis=0, unit = "mV", name = "vP1"), lp.linspace(P2[1],P3[1],10, axis=1, unit = "mV", name = "vP2") ) seg.add_block(0, 10000, gates, P0, reset_time=True) seg.add_block(0, 10000, gates, P1, reset_time=True) seg.add_ramp(0, 500, gates, P1, P2, reset_time=True) seg.add_ramp(0, 500, gates, P2, PSB_sweep, reset_time=True) seg.add_HVI_marker('dig_trigger_1', 100) seg.add_block(0, 50000, gates, PSB_sweep, reset_time=True) seg.add_block(0, 10000, gates, P0, reset_time=True) for index in [(0,0), (0,4), (9,0), (9,4)]: pt.figure()
def calib_J_alpha(target, plot=False): ''' calibrates a single qubit phase for a target qubit Args: target (int) : qubit pair to target ''' var_mgr = variable_mgr() s = six_dot_sample(qc.Station.default.pulse) target = str(int(target)) s.init(target[0], target[1]) s.wait(100).add(s.manip) s.pre_pulse.add(s.manip) s.wait(100).add(s.manip) gates = globals()[f'J{target}'].gates N_J = 5 voltages_gates = globals()[f'J{target}'].voltages_gates voltages_gates = list(voltages_gates) sweep_gate = lp.linspace(voltages_gates[2 * (int(target[0]))] / 2, voltages_gates[2 * (int(target[0]))], N_J, axis=1, name=f'vB{target[0]}', unit='mV') voltages_gates[2 * (int(target[0]))] = sweep_gate voltages_gates = tuple(voltages_gates) gate_time = lp.linspace(0, getattr(var_mgr, f'time_{target}') * 10, 80, axis=0, name='time', unit='ns') getattr(s, f'q{target[0]}').X90.add(s.manip) cphase_basic(s.manip, gates, tuple([0] * len(gates)), voltages_gates, t_gate=gate_time / 2, t_ramp=100) getattr(s, f'q{target[0]}').X180.add(s.manip) getattr(s, f'q{target[1]}').X180.add(s.manip) cphase_basic(s.manip, gates, tuple([0] * len(gates)), voltages_gates, t_gate=gate_time / 2, t_ramp=100) getattr(s, f'q{target[0]}').X90.add(s.manip) s.wait(100).add(s.manip) s.read(target[0], target[1]) sequence, minstr, name = run_qubit_exp(f'J_V cal :: {target}', s.segments(), s.measurement_manager) ds = scan_generic(sequence, minstr, name=name).run() time = ds(f'read{target[0]}').y() * 1e-9 probabilities = ds(f'read{target[0]}').z() J_meas = [] for i in range(N_J): time_fit = time[5:] probabilities_fit = probabilities[i][5:] J_meas += [ 1 / (fit_ramsey(time_fit, probabilities_fit, plot=plot) * 2) * 1e9 ] barrier_percentage = sweep_gate.data / sweep_gate.data.max() J_V_off, J_max, alpha = fit_J(barrier_percentage, np.array(J_meas), plot=plot) if not hasattr(var_mgr, f'J_V_off{target}'): var_mgr.add_variable(f'cphase{target}', f'J_V_off{target}', 'mV', 0.1, 0) if not hasattr(var_mgr, f'J_max{target}'): var_mgr.add_variable(f'cphase{target}', f'J_max{target}', 'mV', 0.1, 0) if not hasattr(var_mgr, f'J_alpha{target}'): var_mgr.add_variable(f'cphase{target}', f'J_alpha{target}', 'mV', 0.1, 0) setattr(var_mgr, f'J_V_off{target}', round(J_V_off, 3)) setattr(var_mgr, f'J_max{target}', round(J_max, 3)) setattr(var_mgr, f'J_alpha{target}', round(alpha, 3))
stop = 200 # ns m = 80 # ns Should be at least 2*stddev stddev = 10 # ns # step up gate.add_custom_pulse(start - m, start + m, amp, gaussian_step, stddev=stddev) # block starts after gaussian ramp up, but ends *after* ramp down. gate.add_block(start + m, stop + m, amp) gate.add_custom_pulse(stop - m, stop + m, -amp, gaussian_step, stddev=stddev) gate.wait(50 - m) # reset time aligns all channels after last pulse or wait. seg.reset_time() # looping on arguments stddev_loop = lp.linspace(10, 2.5, n_steps=4, name='alpha', axis=0) amplitude_loop = lp.linspace(100, 150, n_steps=2, name='amplitude', unit='mV', axis=1) gate = seg.P2 gate.add_ramp_ss(0, stop, 0, 200) # only step up gate.add_custom_pulse(start - m, start + m, amplitude_loop, gaussian_step, stddev=stddev_loop)
dig = SD_DIG('DIG1', 1, dig_slot) load_iq_image(dig.SD_AIN) print_fpga_info(dig.SD_AIN) dig.set_acquisition_mode(dig_mode) ## add to pulse lib. p = create_pulse_lib(awgs) schedule = Hvi2ScheduleLoader(p, "SingleShot", dig) ## create waveforms seg = p.mk_segment() t_measure_loop = looping.linspace(100, 1000, 10, name="t_measure", unit="ns", axis=0) for awg in awgs: for ch in [1, 2, 3, 4]: channel = getattr(seg, f'{awg.name}_{ch}') channel.wait(t_wave) channel.add_block(t_pulse, t_pulse + pulse_duration, 800) channel.add_block(t_pulse, t_pulse + pulse_duration, 0 * t_measure_loop) seg.add_HVI_marker('dig_trigger_1', t_off=t_pulse - 100) seg.add_HVI_variable('t_measure', t_measure_loop) ## create sequencer sequencer = p.mk_sequence([seg])
plot_seg(self.segments()) from pulse_templates.demo_pulse_lib.virtual_awg import get_demo_lib import pulse_lib.segments.utility.looping as lp pulse = get_demo_lib('six') s = six_dot_sample(pulse) s.init12.add() s.init56.add() s.init3.add() s.init4.add() # do a rabi on qubit 1 s.wait(5e3).add() s.q2.X.add(t_pulse = lp.linspace(0, 1e3, 50, axis=0)) # do a cnot to qubit 4 s.q23.CNOT21.add(t_gate = 50) s.q34.CNOT21.add() s.q45.CNOT21.add() s.wait(5e3).add() s.read12.add() s.read3.add(flip='qubit12') s.read56.add() s.read4.add(flip='qubit56') # s.plot_sequence()
f(*args, **kwargs) return function_info return my_wrapper if __name__ == '__main__': from pulse_lib.segments.utility.looping import loop_obj, linspace from pulse_templates.demo_pulse_lib.virtual_awg import get_demo_lib pulse = get_demo_lib('quad') seg = pulse.mk_segment() @template_wrapper def pulse_intra(segment, gates, t_wait, t_ramp, p_0, p_1, **kwargs): pass info = pulse_intra(seg, ('P1', 'P2'), 1000, 100, (0, 0), (0.1, 3), debug=True) print(info) info = pulse_intra(seg, ('P1', 'P2'), 1000, linspace(0, 1, axis=0), (0, 1), (0.1, 3)) print(info) info = pulse_intra(seg, ('P1', 'P2'), 1000, 100, (0, linspace(0, 1, axis=1)), (0.1, 3)) print(info)
awgs = init_hardware() # create channels P1, P2 p = init_pulselib(awgs, virtual_gates=True) seg = p.mk_segment() seg.P1.wait(10) seg.P1.reset_time() seg.P1.add_custom_pulse(0, 60, 350.0, tukey_pulse, alpha=0.5) seg.P1.add_sin(20, 40, 50.0, 2e8) seg.P1.wait(10) seg.reset_time() # looping on arguments alpha_loop = lp.linspace(0.3, 0.5, n_steps=2, name='alpha', axis=0) amplitude_loop = lp.linspace(300, 500, n_steps=3, name='amplitude', unit='mV', axis=1) seg.P2.wait(10) seg.P2.reset_time() seg.P2.add_custom_pulse(0, 60, amplitude_loop, tukey_pulse, alpha=alpha_loop) seg.P2.add_sin(20, 40, 50.0, 2e8) seg.P2.wait(10) seg.reset_time() # virtual gate: compensation is visible on P1
getattr(segment, gate_set.qubit).update_dim(n_gates) RB_mgmt = RB_mgr(gate_set, RB_type, seed) cl_n = [[[] for i in range(n_gates.data.size)] for j in range(n_rand)] for n in range(n_rand): for m in range(n_gates.data.size): rands = RB_mgmt.add_cliffords( getattr(segment, gate_set.qubit)[n, m], int(n_gates.data[m])) cl_n[n][m] = rands return rands if __name__ == '__main__': from pulse_templates.coherent_control.single_qubit_gates.standard_set import single_qubit_std_set from pulse_templates.coherent_control.single_qubit_gates.single_qubit_gates import single_qubit_gate_spec from pulse_templates.demo_pulse_lib.virtual_awg import get_demo_lib from pulse_templates.utility.plotting import plot_seg pulse = get_demo_lib('quad') seg = pulse.mk_segment() xpi2 = single_qubit_gate_spec('qubit4_MW', 1e9, 100, 120) xpi = single_qubit_gate_spec('qubit4_MW', 1e9, 200, 120) ss_set = single_qubit_std_set() ss_set.X = xpi2 ss_set.X2 = xpi IQ_channel = getattr(seg, ss_set.qubit) generature_single_qubit_RB(seg, ss_set, linspace(5, 50, 10), 10)
# print(seg.channels) # print(seg.q1) q1_channel = QubitChannel('q1', None, None) I_out = IQ_out_channel_info('AWG1_I', 'I', '+') Q_out = IQ_out_channel_info('AWG1_Q', 'Q', '+') seg.a.add_IQ_channel(seg.q1, q1_channel, I_out, 1.0e9) seg.b.add_IQ_channel(seg.q1, q1_channel, Q_out, 1.0e9) seg.M1.add_reference_marker_IQ(seg.q1) seg['c'].add_block(0, 10, 100) seg.add_block(10, 50, ['c', 'd'], [50, -50]) seg.add_ramp(10, 50, ['d', 'c'], [-100, 50], [-50, 150], reset_time=True) seg.add_ramp(0, 40, ['c', 'd'], [200, -100], [0, 0]) seg.a.add_block(0, lp.linspace(50, 100, 10), 100) seg.a += 500 seg.b += 500 seg.reset_time() seg.q1.add_MW_pulse(0, 100, 10, 1.010e9) seg.q1.wait(10) seg.reset_time() seg.q1.add_chirp(0, 100, 1e7, 1.1e8, 100) seg.q1.wait(20) seg.q1.reset_time() seg.q1.add_chirp(0, 100, 1.1e9, 1.e9, 100) seg.q1.wait(10) seg.add_HVI_marker("my_test") # print(seg._software_markers.data) # print(seg.setpoint_data) # print(a.a.data[2,2,2])
from pulse_templates.oper.operators import wait pulse = get_demo_lib('six') seg = pulse.mk_segment() gates = ('vP4', ) base_level = (0, ) # seg.vP4 += 10 qubit = 'qubit4_MW' t_drive = 1000 amp = 10 freq = 200e8 padding = 10 Q4_Pi2 = single_qubit_gate_spec(qubit, freq, t_drive, amp, AM_mod='flattop', phase_corrections={'qubit2_MW': 0.23}) # # T2* measurement single_qubit_gate_simple(seg, Q4_Pi2, reset=False) wait(seg, gates, linspace(10, 100), base_level) # shorthand syntax Q4_Pi2.add(seg, reset=True) wait(seg, gates, 80, base_level) # shorthand syntax Q4_Pi2.add(seg, reset=True, MW_power=200) wait(seg, gates, 80, base_level) Q4_Pi2.add(seg, reset=True) plot_seg(seg)
from pulse_lib.segments.segment_container import segment_container import matplotlib.pyplot as plt pulse, virtual_gate = return_pulse_lib() PSB_pulse = pulse.mk_segment() # important points to pulse to P0 = (-100,-100) P1 = (-100,100) P2 = (-25,25) P3 = (-5,-5) P4 = (25, 25) import pulse_lib.segments.utility.looping as lp P4_Point_3 = lp.linspace(P2[0],P3[0],5, axis=0, unit = "mV", name = "vP4") P5_Point_3 = lp.linspace(P2[1],P3[1],5, axis=1, unit = "mV", name = "vP5") PSB_pulse.vP4.add_block(0,10000, P0[0]) PSB_pulse.vP5.add_block(0,10000, P0[1]) PSB_pulse.reset_time() PSB_pulse.vP4.add_block(0,10000, P1[0]) PSB_pulse.vP5.add_block(0,10000, P1[1]) PSB_pulse.reset_time() PSB_pulse.vP4.add_ramp_ss(0,500, P1[0], P2[0]) PSB_pulse.vP5.add_ramp_ss(0,500, P1[1], P2[1]) PSB_pulse.reset_time() PSB_pulse.vP4.add_ramp_ss(0,500, P2[0], P4_Point_3) PSB_pulse.vP5.add_ramp_ss(0,500, P2[1], P5_Point_3) PSB_pulse.reset_time()
pulse = return_pulse_lib() import time # t1 = time.time() pulse.cpp_uploader.resegment_memory() # t2 = time.time() # print(t2-t1) nagaoka_pulsing = pulse.mk_segment() base_level = 5 #mV import pulse_lib.segments.utility.looping as lp ramp_amp = lp.linspace(50, 200, 50, axis=0) ramp_time = lp.linspace(5, 100, 50, axis=1) nagaoka_pulsing.B4 += base_level nagaoka_pulsing.B2.add_block(0, 500, 1000) nagaoka_pulsing.B4.add_block(0, 50, 750) nagaoka_pulsing.B4.reset_time() nagaoka_pulsing.B4.add_block(0, 50, 700) nagaoka_pulsing.B4.reset_time() nagaoka_pulsing.B4.add_block(0, 100, 100) nagaoka_pulsing.B4.reset_time() nagaoka_pulsing.B4.add_ramp(0, 100, ramp_amp * .8) nagaoka_pulsing.B4.reset_time() nagaoka_pulsing.B4.add_block(0, ramp_time, ramp_amp * .8) nagaoka_pulsing.B4.add_ramp(0, ramp_time, ramp_amp * .2)
import matplotlib.pyplot as pt from pulse_lib.tests.hw_schedule_mock import HardwareScheduleMock import pulse_lib.segments.utility.looping as lp from configuration.small import init_hardware, init_pulselib from utils.plot import plot_awgs # create "AWG1" awgs = init_hardware() # create channels P1, P2 p = init_pulselib(awgs) t_measure_loop = lp.linspace(100,800,8,name="t_measure",unit="ns",axis=0) v_param = lp.linspace(20,240,12,name="vP1",unit="mV",axis=1) t_wait = 100 seg1 = p.mk_segment() seg2 = p.mk_segment() seg1.P1.add_ramp_ss(0, 100, 0, v_param) seg1.P1.add_block(100, 200, v_param) seg2.P2.add_block(0, 100, 200) seg2.P2.wait(t_wait) seg2.reset_time() seg2.add_HVI_marker('dig_trigger_1', t_off=50) seg2.P1.add_block(0, 100, v_param)
def return_amp(amp): def J_pulse(x): return np.sqrt(x) / np.sqrt(5e6) * amp return J_pulse def f_res(f_res, delta_fres): def f_res_relation(J): return f_res + J**2 / 5e6**2 * delta_fres return f_res_relation J_to_voltage_relation = (return_amp(-0.2), return_amp(1), return_amp(-0.23)) sweep = linspace(0, 2 * np.pi, 20, axis=1) import good_morning.static.J45 as J45 iswap(seg, J45.gates, np.pi, 0, 6e6, 80e6, J45.gen_J_to_voltage(), J45.return_delta_B_J_relation()) # iswap_cal(seg, gates, 5e6, 5e6, linspace(75e6, 85e6, 80, 'freq', 'Hz', 0), np.pi, J_to_voltage_relation, 20) # print(gates, J45.gates) # print(J_to_voltage_relation, J45.gen_J_to_voltage()) # ratios = J45.gen_J_to_voltage() # iswap_cal(seg, J45.gates, 5e6, 5e6, 80e6, 3.14, ratios, 20) # iswap_cal(seg, J45.gates, 5e6, 5e6, 80e6, linspace(3.14, 2.65, 80, 'freq', 'Hz', 0), ratios, 20) # plot_seg(seg, 0) # plot_seg(seg, 5)