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)
