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
gate_set_qubit_1.X.add(seg, phase_corrections={})
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
from pulse_lib.segments.utility.looping import linspace
pulse = get_demo_lib('six')
seg = pulse.mk_segment()
X90 = single_qubit_gate_spec(
'qubit4_MW',
1e9,
200,
120,
padding=20,
)
ss_set = single_qubit_std_set()
ss_set.X = X90
test_pulse = single_qubit_gate_spec(
'qubit2_MW',
1e9,
200,
120,
padding=20,
phase_corrections={'qubit4_MW': 1 * np.pi})
phase_offset_charac(seg, ss_set, test_pulse, 0)
gate_set (single_qubit_gate_spec) : object containg instruction of the gate set
repeat (int) : the number of time to repeat the allxy experiment =
'''
allXY_set, setpoint = get_allXY_specs(repeat)
setpoint.axis = [axis]
getattr(segment, gate_set.qubit).update_dim(setpoint)
for i in range(setpoint.data.size):
gate_set.load_std_gate(
getattr(segment, gate_set.qubit)[i], allXY_set[i])
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
from pulse_lib.segments.utility.looping import linspace
pulse = get_demo_lib('six')
seg = pulse.mk_segment()
ss_set = single_qubit_std_set()
ss_set.X = single_qubit_gate_spec('qubit4_MW', 1e9, 100, 120)
# ss_set.X2 = single_qubit_gate_spec('qubit4_MW', 1e9, 200, 120)
# ss_set.X.add(seg)
print(seg)
generate_all_XY(seg, ss_set)
plot_seg(seg, 1)
def __init__(self, pulse):
self.measurement_manager = measurement_manager()
self.segment_mgr = segment_mgr(pulse)
self.wait = wait_std_set(self.segment_mgr, gates=('P1',), p_0=(0,))
self.q1 = single_qubit_std_set(self.segment_mgr)
self.q1.X = single_qubit_gate_spec('qubit1_MW', 11.002e9, 100, MW_power=5)
self.q1.X2 = single_qubit_gate_spec('qubit1_MW', 11.002e9, 200, MW_power=5)
self.q2 = single_qubit_std_set(self.segment_mgr)
self.q2.X = single_qubit_gate_spec('qubit2_MW', 11.103e9, 100, MW_power=5)
self.q2.X2 = single_qubit_gate_spec('qubit2_MW', 11.103e9, 200, MW_power=5)
self.q3 = single_qubit_std_set(self.segment_mgr)
self.q3.X = single_qubit_gate_spec('qubit3_MW', 11.201e9, 100, MW_power=5)
self.q3.X2 = single_qubit_gate_spec('qubit3_MW', 11.201e9, 200, MW_power=5)
self.q4 = single_qubit_std_set(self.segment_mgr)
self.q4.X = single_qubit_gate_spec('qubit4_MW', 11.303e9, 100, MW_power=5)
self.q4.X2 = single_qubit_gate_spec('qubit4_MW', 11.303e9, 200, MW_power=5)
self.q5 = single_qubit_std_set(self.segment_mgr)
self.q5.X = single_qubit_gate_spec('qubit5_MW', 11.405e9, 100, MW_power=5)
self.q5.X2 = single_qubit_gate_spec('qubit5_MW', 11.405e9, 200, MW_power=5)
self.q6 = single_qubit_std_set(self.segment_mgr)
self.q6.X = single_qubit_gate_spec('qubit6_MW', 11.508e9, 100, MW_power=5)
self.q6.X2 = single_qubit_gate_spec('qubit6_MW', 11.508e9, 200, MW_power=5)
cphase12 = two_qubit_gate_generic(cphase_basic, {'gates' : ('vP1','vB1', 'vP2'),
'v_exchange_pulse_off' : (0,4,0),
'v_exchange_pulse_on' : (0,8,0),
't_gate' : 100,
't_ramp' : 20},
{'qubit1_MW' : 0.23, 'qubit2_MW' : 0.8})
self.q12 = two_qubit_std_set(self.q1, self.q2, self.segment_mgr)
self.q12.cphase = cphase12
cphase23 = two_qubit_gate_generic(cphase_basic, {'gates' : ('vP2','vB2', 'vP3'),
'v_exchange_pulse_off' : (0,4,0),
'v_exchange_pulse_on' : (0,8,0),
't_gate' : 100,
't_ramp' : 20},
{'qubit2_MW' : 0.23, 'qubit3_MW' : 0.8})
self.q23 = two_qubit_std_set(self.q2, self.q3, self.segment_mgr)
self.q23.cphase = cphase23
cphase34 = two_qubit_gate_generic(cphase_basic, {'gates' : ('vP3','vB3', 'vP4'),
'v_exchange_pulse_off' : (0,4,0),
'v_exchange_pulse_on' : (0,8,0),
't_gate' : 100,
't_ramp' : 20},
{'qubit3_MW' : 0.23, 'qubit4_MW' : 0.8})
self.q34 = two_qubit_std_set(self.q3, self.q4, self.segment_mgr)
self.q34.cphase = cphase34
cphase45 = two_qubit_gate_generic(cphase_basic, {'gates' : ('vP4','vB4', 'vP5'),
'v_exchange_pulse_off' : (0,4,0),
'v_exchange_pulse_on' : (0,8,0),
't_gate' : 100,
't_ramp' : 20},
{'qubit4_MW' : 0.23, 'qubit5_MW' : 0.8})
self.q45 = two_qubit_std_set(self.q4, self.q5, self.segment_mgr)
self.q45.cphase = cphase45
cphase56 = two_qubit_gate_generic(cphase_basic, {'gates' : ('vP5','vB5', 'vP6'),
'v_exchange_pulse_off' : (0,4,0),
'v_exchange_pulse_on' : (0,8,0),
't_gate' : 100,
't_ramp' : 20},
{'qubit5_MW' : 0.23, 'qubit6_MW' : 0.8})
self.q56 = two_qubit_std_set(self.q5, self.q6, self.segment_mgr)
self.q56.cphase = cphase56
i_12 = measurement('PSB_12_init', chan=[1,2], accept=0, threshold=0.5, phase=0.3)
init12_kwargs = {'gates' : ('vP1','vB1', 'vP2'), 't_ramp' : 2e3,
't_read' : 2e3, 'p_0' : (0,0,0), 'p_1' : (5.5,0,-5.5)}
init_spec_12 = readout_spec(i_12, PSB_read, init12_kwargs)
self.init12 = readout_std_set(init_spec_12, self.measurement_manager, self.segment_mgr)
i_3 = measurement('PSB_3_init', chan=[1,2], accept=0, threshold=0.5, phase=0.3)
init_spec_3 = readout_spec(i_3, PSB_read, init12_kwargs, (self.wait(100), self.q23.CNOT12, self.wait(100),))
self.init3 = readout_std_set(init_spec_3, self.measurement_manager, self.segment_mgr)
i_56 = measurement('PSB_56_init', chan=[3,4], accept=0, threshold=0.5, phase=0.3)
init56_kwargs = {'gates' : ('vP5','vB5', 'vP6'), 't_ramp' : 2e3,
't_read' : 2e3, 'p_0' : (0,0,0), 'p_1' : (-5.5,0,5.5)}
init_spec_56 = readout_spec(i_56, PSB_read, init56_kwargs)
self.init56 = readout_std_set(init_spec_56, self.measurement_manager, self.segment_mgr)
i_4 = measurement('PSB_4_init', chan=[1,2], accept=0, threshold=0.5, phase=0.3)
init_spec_4 = readout_spec(i_4, PSB_read, init56_kwargs, (self.wait(100), self.q45.CNOT21, self.wait(100),))
self.init4 = readout_std_set(init_spec_4, self.measurement_manager, self.segment_mgr)
r_12 = measurement('read12', chan=[1,2], threshold=0.5, phase=0.3)
readout_spec_12 = readout_spec(r_12, PSB_read, init12_kwargs)
self.read12 = readout_std_set(readout_spec_12, self.measurement_manager, self.segment_mgr)
r_1 = measurement('read1', chan=[1,2], threshold=0.5, phase=0.3)
readout_spec_1 = readout_spec(r_1, PSB_read, init12_kwargs, (self.wait(100),self.q12.CNOT12,self.wait(100)))
self.read1 = readout_std_set(readout_spec_1, self.measurement_manager, self.segment_mgr)
r_2 = measurement('read2', chan=[1,2], threshold=0.5, phase=0.3)
readout_spec_2 = readout_spec(r_2, PSB_read, init12_kwargs, (self.wait(100),self.q12.CNOT21,self.wait(100)))
self.read2 = readout_std_set(readout_spec_2, self.measurement_manager, self.segment_mgr)
r_3 = measurement('read3', flip='read12', chan=[1,2], threshold=0.5, phase=0.3)
readout_spec_3 = readout_spec(r_3, PSB_read, init12_kwargs, (self.wait(100),self.q23.CNOT12,self.wait(100)))
self.read3 = readout_std_set(readout_spec_3, self.measurement_manager, self.segment_mgr)
r_56 = measurement('read56', chan=[3,4], threshold=0.5, phase=0.3)
readout_spec_56 = readout_spec(r_56, PSB_read, init56_kwargs)
self.read56 = readout_std_set(readout_spec_56, self.measurement_manager, self.segment_mgr)
r_6 = measurement('read6', chan=[5,6], threshold=0.5, phase=0.3)
readout_spec_6 = readout_spec(r_6, PSB_read, init56_kwargs, (self.wait(100),self.q56.CNOT21,self.wait(100)))
self.read6 = readout_std_set(readout_spec_6, self.measurement_manager, self.segment_mgr)
r_5 = measurement('read5', chan=[5,6], threshold=0.5, phase=0.3)
readout_spec_5 = readout_spec(r_5, PSB_read, init56_kwargs, (self.wait(100),self.q56.CNOT12,self.wait(100)))
self.read5 = readout_std_set(readout_spec_5, self.measurement_manager, self.segment_mgr)
r_4 = measurement('read4', flip='read56', chan=[5,6], threshold=0.5, phase=0.3)
readout_spec_4 = readout_spec(r_4, PSB_read, init56_kwargs, (self.wait(100),self.q45.CNOT21,self.wait(100)))
self.read4 = readout_std_set(readout_spec_4, self.measurement_manager, self.segment_mgr)
# assume 1QD -- elzerman init
t_init = 50e3
gates = ('vP1', )
p_0 = (200, )
add_block(INIT, t_init, gates, p_0)
#done.
# add single qubit gates in manip
# add default dc levels
MANIP.vP1 += 20
# define a set
xpi2 = single_qubit_gate_spec('qubit1_MW', 1.1e8, 1000, 120, padding=2)
xpi = single_qubit_gate_spec('qubit1_MW', 1.1e8, 2000, 120, padding=2)
ss_set = single_qubit_std_set()
ss_set.X = xpi2
ss_set.X2 = xpi
ss_set.X.add(MANIP)
# assume 1QD -- elzerman read -- simplified
t_read = 50e3
gates = ('vP1', )
p_readout = (-100, )
elzerman_read(READ, gates, t_read, p_readout)
#done.
T2_CPMG_t_tot(seg, gate_set, t_wait, 1, f_bg_oscillations)
if __name__ == '__main__':
import pulse_lib.segments.utility.looping as lp
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('qubit1_MW', 1e9, 100, 120)
xpi = single_qubit_gate_spec('qubit1_MW', 1e9, 200, 120)
ss_set = single_qubit_std_set()
ss_set.X = xpi2
ss_set.X2 = xpi
pulse.IQ_channels[0].virtual_channel_map[0].reference_frequency = 1.01e9
# seg = pulse.mk_segment()
# T2_ramsey(seg, ss_set, lp.linspace(100,1000), 10e6)
# plot_seg(seg)
# seg = pulse.mk_segment()
# T2_hahn(seg, ss_set, lp.linspace(200,1000, axis=0), 10e6)
# plot_seg(seg)
# example -- make cphase spec
cphase12 = two_qubit_gate_generic(
cphase_basic, {
'gates': gates,
'v_exchange_pulse_off': (0, 4, 0),
'v_exchange_pulse_on': (0, 8, 0),
't_gate': 100,
't_ramp': 20
}, {
'qubit1_MW': 0.23,
'qubit2_MW': 0.8
})
# make two sinle qubit gates sets
qubit_1 = single_qubit_std_set(ss)
qubit_1.X = single_qubit_gate_spec('qubit1_MW', 1e9, 100, MW_power=5)
qubit_2 = single_qubit_std_set(ss)
qubit_2.X = single_qubit_gate_spec('qubit2_MW', 1e9, 100, MW_power=5)
two_qubit_gate_spec = two_qubit_std_set(qubit_1, qubit_2, ss)
two_qubit_gate_spec.cphase = cphase12
qubit_1.X.add(seg)
two_qubit_gate_spec.cphase.add(seg)
qubit_1.X.add(seg)
# # composite gate
# two_qubit_gate_spec.CNOT12.add(v_exchange_pulse_on = (0,12,0))
# wait(seg, gates, 250, base_level)
return self.X.qubit_name
if __name__ == '__main__':
from pulse_templates.utility.plotting import plot_seg
from pulse_templates.demo_pulse_lib.virtual_awg import get_demo_lib
from pulse_templates.coherent_control.single_qubit_gates.single_qubit_gates import single_qubit_gate_spec
pulse = get_demo_lib('six')
seg = pulse.mk_segment()
test = single_qubit_std_set()
test.X = single_qubit_gate_spec('qubit1_MW',
1e9,
100,
MW_power=500,
padding=10)
# test.wait(seg, 100)
# create custom Z with custom phase --
# test.Z(3.14).add(seg, f_qubit=1.12e9)
# print(test.Z)
# a = test.Z
# print(test.Z(0))
# test.Z(0).add(seg)
# # test.Y2.add(seg)
test.X180.add(seg)
print('start second gate')
# print(test.X)
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
from pulse_lib.segments.utility.looping import linspace
import matplotlib.pyplot as plt
pulse = get_demo_lib('six')
seg = pulse.mk_segment()
ss_set4 = single_qubit_std_set()
ss_set4.X = single_qubit_gate_spec('qubit4_MW', 1e9, 100, 120)
ss_set3 = single_qubit_std_set()
ss_set3.X = single_qubit_gate_spec('qubit3_MW', 1e9, 100, 120)
# ss_set.X2 = single_qubit_gate_spec('qubit4_MW', 1e9, 200, 120)
print('executing test')
print(generate_measurement_operators(2))
# ss_set.X.add(seg)
generate_state_tomography(seg, ss_set3, ss_set4, axis=0)
print('test done')
plot_seg(seg, 1)
plt.show()
