def calibrate_all_single_channel_Rabi(device,
_qubit_id=None,
transition='01',
remove_bad=False):
if _qubit_id is None:
_qubit_id = device.get_qubit_list()
elif type(_qubit_id) is int:
_qubit_id = [_qubit_id]
for qubit_id in _qubit_id:
amplitude_default = float(
device.get_qubit_constant(qubit_id=qubit_id,
name='amplitude_default'))
qubit_channel_calibrated = {}
for channel_name, device_name in device.get_qubit_excitation_channel_list(
qubit_id, transition=transition).items():
ch = channel_amplitudes(device,
**{channel_name: amplitude_default})
try:
excitation_pulse.get_excitation_pulse(
device,
qubit_id,
rotation_angle=np.pi / 2.,
transition=transition,
channel_amplitudes_override=ch)
qubit_channel_calibrated[channel_name] = device_name
except Exception as e:
print('Failed to Rabi-calibrate channel ', channel_name)
traceback.print_exc()
if remove_bad:
print('Removing from channel list!')
if remove_bad:
device.set_qubit_excitation_channel_list(qubit_id,
qubit_channel_calibrated)
def Ramsey_process(device,
qubit_id1,
qubit_id2,
process,
channel_amplitudes1=None,
channel_amplitudes2=None):
'''
:param device QubitDevice:
'''
from .readout_pulse import get_uncalibrated_measurer
readout_pulse, measurer = get_uncalibrated_measurer(
device, qubit_id2
) # we want to measure qubit 2 because otherwise wtf are we are doing the second pi/2 pulse for
phase_scan_points = int(
device.get_sample_global(name='process_phase_scan_points'))
phases = np.linspace(0, 2 * np.pi, phase_scan_points, endpoint=False)
ex_pulse1 = excitation_pulse.get_excitation_pulse(
device,
qubit_id1,
np.pi / 2.,
channel_amplitudes_override=channel_amplitudes1)
ex_pulse2 = excitation_pulse.get_excitation_pulse(
device,
qubit_id2,
np.pi / 2.,
channel_amplitudes_override=channel_amplitudes2)
def set_phase(phase):
device.pg.set_seq(
ex_pulse1.get_pulse_sequence(0.0) + process.get_pulse_sequence() +
ex_pulse2.get_pulse_sequence(phase) + device.trigger_readout_seq +
readout_pulse.get_pulse_sequence())
references = {
'ex_pulse1':
ex_pulse1.id,
'ex_pulse2':
ex_pulse2.id,
('frequency_controls', qubit_id1):
device.get_frequency_control_measurement_id(qubit_id=qubit_id1),
('frequency_controls', qubit_id2):
device.get_frequency_control_measurement_id(qubit_id=qubit_id2),
'process':
process.id
}
metadata = {'q1': qubit_id1, 'q2': qubit_id2}
if hasattr(measurer, 'references'):
references.update(measurer.references)
fitter_arguments = ('iq' + qubit_id2, SinglePeriodSinFitter(), -1, [])
measurement = device.sweeper.sweep_fit_dataset_1d_onfly(
measurer, (phases, set_phase, 'Phase', 'radians'),
fitter_arguments=fitter_arguments,
measurement_type='Ramsey_process',
metadata=metadata,
references=references)
return measurement
def calibrate_parametric_iswap_length_adaptive(device, gate, calibration_qubit='1', frequency_shift=0):
scan_points = int(device.get_qubit_constant(qubit_id=gate.metadata['q1'],
name='adaptive_Rabi_amplitude_scan_points'))
# estimating coherence time
T2_q1 = float(device.exdir_db.select_measurement_by_id(Ramsey.get_Ramsey_coherence_measurement(device, qubit_id=gate.metadata['q1']).id).metadata['T'])
T2_q2 = float(device.exdir_db.select_measurement_by_id(Ramsey.get_Ramsey_coherence_measurement(device, qubit_id=gate.metadata['q2']).id).metadata['T'])
#print (T2_q1.metadata)
max_scan_length = 1/(1/T2_q1+1/T2_q2)
if calibration_qubit == '1':
excite = excitation_pulse.get_excitation_pulse(device=device, qubit_id=gate.metadata['q1'], rotation_angle=np.pi)
else:
excite = excitation_pulse.get_excitation_pulse(device=device, qubit_id=gate.metadata['q2'], rotation_angle=np.pi)
vf_pulse = get_vf(device, gate, frequency_shift) # = get_long_process_vf(device, gate)
if calibration_qubit == '1':
projector_func = lambda x: x[:, 2] - x[:, 1]
else:
projector_func = lambda x: x[:, 1] - x[:, 2]
def infer_parameter_from_measurements(measurements, dataset_name, optimization_parameter_id, projector_func):
parameter_values = measurements[-1].datasets[dataset_name].parameters[optimization_parameter_id].values
measurement_interpolated_combined = np.zeros(parameter_values.shape)
for measurement in measurements:
measurement_interpolated_combined += np.interp(parameter_values,
measurement.datasets[dataset_name].parameters[optimization_parameter_id].values,
projector_func(measurement.datasets[dataset_name].data))
return parameter_values[np.argmin(measurement_interpolated_combined)]
repeats = 2
pulse_length = float(get_iswap_pulse_nophase(device, gate,
frequency_shift=frequency_shift, rotation_angle=np.pi).metadata['length'])
adaptive_measurements = []
while repeats*pulse_length < max_scan_length:
lengths = pulse_length+np.linspace(-pulse_length/repeats, pulse_length/repeats, scan_points)
adaptive_measurements.append(Rabi.Rabi_rect(
device=device, qubit_id=[gate.metadata['q1'], gate.metadata['q2']],
lengths=lengths,
tail_length=float(gate.metadata['tail_length']),
channel_amplitudes=two_qubit_gate_channel_amplitudes(device, gate),
measurement_type=gate.metadata['physical_type'] + '_adaptive_calibration',
pre_pulses=(excite, vf_pulse),
repeats=repeats, additional_metadata={'frequency_shift': str(frequency_shift)},))
pulse_length = infer_parameter_from_measurements(adaptive_measurements, 'resultnumbers',
optimization_parameter_id=0, projector_func=projector_func)
repeats *= 2
return device.exdir_db.save(measurement_type=gate.metadata['physical_type'] + '_adaptive_calibration_summary',
references={'gate': gate.id},
metadata={'frequency_shift':frequency_shift, 'length':pulse_length,
'q1':gate.metadata['q1'], 'q2':gate.metadata['q2']})
def calibrate_readout(device, qubit_id, qubit_readout_pulse, transition='01', ignore_other_qubits=None):
adc, mnames = device.setup_adc_reducer_iq(qubit_id, raw=True)
nums = int(device.get_qubit_constant(qubit_id=qubit_id, name='readout_background_nums'))
old_nums = adc.get_adc_nums()
adc.set_adc_nop(int(device.get_sample_global('readout_adc_points')))
if ignore_other_qubits is None:
ignore_other_qubits = (device.get_qubit_constant(qubit_id=qubit_id, name='readout_calibration_ignore_other_qubits') == 'True')
print ('ignore_other_qubits', ignore_other_qubits)
other_qubit_pulse_sequence = []
references = {}
if not ignore_other_qubits:
for other_qubit_id in device.get_qubit_list():
if other_qubit_id != qubit_id:
half_excited_pulse = excitation_pulse.get_excitation_pulse(device, other_qubit_id,
rotation_angle=np.pi / 2.)
references[('other_qubit_pulse', other_qubit_id)] = half_excited_pulse.id
other_qubit_pulse_sequence.extend(half_excited_pulse.get_pulse_sequence(0))
qubit_excitation_pulse = excitation_pulse.get_excitation_pulse(device, qubit_id, rotation_angle=np.pi)
metadata = {'qubit_id': qubit_id,
'averages': nums,
'ignore_other_qubits': ignore_other_qubits}
references.update({'readout_pulse': qubit_readout_pulse.id,
'excitation_pulse': qubit_excitation_pulse.id,
'delay_calibration': device.modem.delay_measurement.id})
classifier = single_shot_readout.single_shot_readout(adc=adc,
prepare_seqs=[device.pre_pulses + other_qubit_pulse_sequence,
device.pre_pulses + other_qubit_pulse_sequence + qubit_excitation_pulse.get_pulse_sequence(
0)],
ro_seq=device.trigger_readout_seq + qubit_readout_pulse.get_pulse_sequence(),
pulse_generator=device.pg,
ro_delay_seq=None,
_readout_classifier=readout_classifier.binary_linear_classifier(),
adc_measurement_name='Voltage')
classifier.readout_classifier.cov_mode = 'equal'
try:
adc.set_adc_nums(nums)
measurement = device.sweeper.sweep(classifier,
measurement_type='readout_calibration',
metadata=metadata,
references=references)
except:
raise
finally:
adc.set_adc_nums(old_nums)
return measurement
def calibrate_parametric_iswap_length(device, gate, expected_frequency=None, calibration_qubit='1', frequency_shift=0):
if calibration_qubit == '1':
excite = excitation_pulse.get_excitation_pulse(device=device, qubit_id=gate.metadata['q1'], rotation_angle=np.pi)
else:
excite = excitation_pulse.get_excitation_pulse(device=device, qubit_id=gate.metadata['q2'], rotation_angle=np.pi)
vf_pulse = get_vf(device, gate, frequency_shift)#= get_long_process_vf(device, gate)
Rabi_rect_measurement_q1 = Rabi.Rabi_rect_adaptive(device=device, qubit_id=[gate.metadata['q1'], gate.metadata['q2']], tail_length = float(gate.metadata['tail_length']),
channel_amplitudes=two_qubit_gate_channel_amplitudes(device, gate), measurement_type=gate.metadata['physical_type']+'_calibration', pre_pulses=(excite, vf_pulse),
repeats = 1, additional_metadata={'frequency_shift': str(frequency_shift)}, expected_frequency=expected_frequency)
fit_m1 = Rabi_rect_measurement_q1.fit
return Rabi_rect_measurement_q1, fit_m1
def relaxation(device, qubit_id, transition='01', *extra_sweep_args, channel_amplitudes=None, lengths=None,
readout_delay=0, delay_seq_generator=None, measurement_type='decay', ex_pulse=None,
additional_references = {}, additional_metadata = {}):
from .readout_pulse import get_uncalibrated_measurer
from ..fitters.exp import exp_fitter
if type(lengths) is type(None):
lengths = np.arange(0,
float(device.get_qubit_constant(qubit_id=qubit_id, name='Ramsey_length')),
float(device.get_qubit_constant(qubit_id=qubit_id, name='Ramsey_step')))
#readout_pulse = get_qubit_readout_pulse(device, qubit_id)
readout_pulse, measurer = get_uncalibrated_measurer(device, qubit_id, transition)
if ex_pulse is None:
ex_pulse = excitation_pulse.get_excitation_pulse(device, qubit_id, np.pi, channel_amplitudes_override=channel_amplitudes)
def set_delay(length):
#ex_pulse_seq = [device.pg.pmulti(length+2*tail_length, *tuple(channel_pulses))]
if delay_seq_generator is None:
delay_seq = [device.pg.pmulti(length)]
else:
delay_seq = delay_seq_generator(length)
readout_delay_seq = [device.pg.pmulti(readout_delay)]
readout_trigger_seq = device.trigger_readout_seq
readout_pulse_seq = readout_pulse.pulse_sequence
device.pg.set_seq(device.pre_pulses+
ex_pulse.get_pulse_sequence(0)+
delay_seq+
readout_delay_seq+
readout_trigger_seq+
readout_pulse_seq)
references = {'ex_pulse':ex_pulse.id,
'frequency_controls':device.get_frequency_control_measurement_id(qubit_id=qubit_id)}
references.update(additional_references)
if hasattr(measurer, 'references'):
references.update(measurer.references)
fitter_arguments = ('iq'+qubit_id, exp_fitter(), -1, np.arange(len(extra_sweep_args)))
metadata = {'qubit_id': qubit_id,
'transition': transition,
'extra_sweep_args':str(len(extra_sweep_args)),
'readout_delay':str(readout_delay)}
metadata.update(additional_metadata)
measurement = device.sweeper.sweep_fit_dataset_1d_onfly(measurer,
*extra_sweep_args,
(lengths, set_delay, 'Delay','s'),
fitter_arguments = fitter_arguments,
measurement_type=measurement_type,
metadata=metadata,
references=references)
return measurement
def frequency_shift_scan(device, gate, pulse, frequency_shift_range, calibration_qubit='1'):
readout_pulse, measurer = calibrated_readout.get_calibrated_measurer(device, [pulse.metadata['q1'], pulse.metadata['q2']])
pi_pulse = excitation_pulse.get_excitation_pulse(device, qubit_id=gate.metadata['q1' if calibration_qubit == '1' else 'q2'],
rotation_angle=np.pi)
def set_frequency_shift(frequency_shift):
device.pg.set_seq(device.pre_pulses+
pi_pulse.get_pulse_sequence(0.0)+\
pulse.get_pulse_sequence(0.0, frequency_shift=frequency_shift)+\
device.trigger_readout_seq+\
readout_pulse.get_pulse_sequence())
references = {'excitation_pulse':pi_pulse.id,
'parametric_pulse':pulse.id}
return device.sweeper.sweep(measurer,
(frequency_shift_range, set_frequency_shift, 'Frequency shift', 'Hz'),
measurement_type='frequency_shift_scan', metadata={}, references=references)
def get_confusion_matrix(device, qubit_ids, pause_length=0, recalibrate=True, force_recalibration=False):
qubit_readout_pulse, readout_device = get_calibrated_measurer(device, qubit_ids)
excitation_pulses = {qubit_id: excitation_pulse.get_excitation_pulse(device, qubit_id, rotation_angle=np.pi) for
qubit_id in qubit_ids}
references = {('excitation_pulse', qubit_id): pulse.id for qubit_id, pulse in excitation_pulses.items()}
references['readout_pulse'] = qubit_readout_pulse.id
metadata = {'qubit_ids': qubit_readout_pulse.metadata['qubit_ids'], 'pause_length': str(pause_length)}
try:
assert not force_recalibration
confusion_matrix = device.exdir_db.select_measurement(measurement_type='confusion_matrix',
references_that=references, metadata=metadata)
except:
if not recalibrate:
raise
confusion_matrix = calibrate_preparation_and_readout_confusion(device =device, qubit_readout_pulse = qubit_readout_pulse,
readout_device = readout_device,
pause_length = pause_length)
return qubit_readout_pulse, readout_device, confusion_matrix
def calibrate_preparation_and_readout_confusion(device, qubit_readout_pulse, readout_device, *extra_sweep_args,
pause_length=0, middle_seq_generator = None,
additional_references = {}, additional_metadata = {}):
qubit_ids = qubit_readout_pulse.metadata['qubit_ids'].split(',')
target_qubit_states = [0] * len(qubit_ids)
excitation_pulses = {qubit_id: excitation_pulse.get_excitation_pulse(device, qubit_id, rotation_angle=np.pi) for
qubit_id in qubit_ids}
references = {('excitation_pulse', qubit_id): pulse.id for qubit_id, pulse in excitation_pulses.items()}
references['readout_pulse'] = qubit_readout_pulse.id
def set_target_state(state):
excitation_sequence = []
for _id, qubit_id in enumerate(qubit_ids):
qubit_state = (1 << _id) & state
if qubit_state:
excitation_sequence.extend(excitation_pulses[qubit_id].get_pulse_sequence(0))
if middle_seq_generator is not None:
middle_pulse = middle_seq_generator()
else:
middle_pulse = []
device.pg.set_seq(device.pre_pulses + excitation_sequence + middle_pulse + [
device.pg.pmulti(pause_length)] + device.trigger_readout_seq + qubit_readout_pulse.get_pulse_sequence())
if middle_seq_generator is not None:
measurement_type = 'confusion_matrix_middle_seq'
else:
measurement_type = 'confusion_matrix'
metadata = {'qubit_ids': qubit_readout_pulse.metadata['qubit_ids'],
'pause_length': str(pause_length)}
references.update(additional_references)
metadata.update(additional_metadata)
return device.sweeper.sweep(readout_device,
*extra_sweep_args,
(np.arange(2 ** len(qubit_ids)), set_target_state, 'Target state', ''),
measurement_type=measurement_type,
references=references,
metadata=metadata)
def calibrate_all_cross_Ramsey(device):
cross_Ramsey_fits = {}
for qubit_id in device.get_qubit_list():
min_step = float(
device.get_qubit_constant(qubit_id=qubit_id,
name='adaptive_Rabi_min_step'))
scan_points = int(
device.get_qubit_constant(qubit_id=qubit_id,
name='adaptive_Rabi_scan_points'))
points_per_oscillation_target = float(
device.get_qubit_constant(
qubit_id=qubit_id,
name='adaptive_Ramsey_points_per_oscillation'))
initial_delay = float(
device.get_qubit_constant(qubit_id=qubit_id,
name='cross_Ramsey_initial_delay'))
target_offset = 1. / (min_step * points_per_oscillation_target)
amplitude_default = float(
device.get_qubit_constant(qubit_id=qubit_id,
name='amplitude_default'))
lengths = np.arange(initial_delay,
min_step * scan_points + initial_delay, min_step)
cross_Ramsey_fits[qubit_id] = {}
for channel_name1, device_name1 in device.get_qubit_excitation_channel_list(
qubit_id).items():
ch1 = channel_amplitudes(device,
**{channel_name1: amplitude_default})
try:
pulse1 = excitation_pulse.get_excitation_pulse(
device,
qubit_id,
np.pi / 2.,
channel_amplitudes_override=ch1)
except:
print('Failed to Rabi-calibrate channel ', channel_name)
continue
cross_Ramsey_fits[qubit_id][channel_name1] = {}
for channel_name2, device_name2 in device.get_qubit_excitation_channel_list(
qubit_id).items():
ch2 = channel_amplitudes(device,
**{channel_name2: amplitude_default})
try:
pulse2 = excitation_pulse.get_excitation_pulse(
device,
qubit_id,
np.pi / 2.,
channel_amplitudes_override=ch2)
except:
print('Failed to Rabi-calibrate channel ', channel_name)
continue
#cross_Ramsey_measurement_results = {}
cross_Ramsey_measurements = device.exdir_db.select_measurements_db(
measurement_type='Ramsey',
references_that={
'ex_pulse1': pulse1.id,
'ex_pulse2': pulse2.id
})
for m in cross_Ramsey_measurements:
for r in m.reference_two:
if r.ref_type == 'fit_source':
fit = r.this
if int(device.exdir_db.db.Metadata[
fit, 'frequency_goodness_test'].value):
cross_Ramsey_fits[qubit_id][channel_name1][
channel_name2] = device.exdir_db.select_measurement_by_id(
fit.id)
if channel_name2 not in cross_Ramsey_fits[qubit_id][
channel_name1]: # hasn't been found in db
Ramsey(device,
qubit_id,
channel_amplitudes1=ch1,
channel_amplitudes2=ch2,
lengths=lengths,
target_freq_offset=target_offset)
return cross_Ramsey_fits
def Ramsey_crosstalk(device,
target_qubit_id,
control_qubit_id,
*extra_sweep_args,
channel_amplitudes_control=None,
channel_amplitudes1=None,
channel_amplitudes2=None,
lengths=None,
target_freq_offset=None,
readout_delay=0,
delay_seq_generator=None,
measurement_type='Ramsey_crosstalk',
additional_references={}):
#if type(lengths) is type(None):
# lengths = np.arange(0,
# float(device.get_qubit_constant(qubit_id=qubit_id, name='Ramsey_length')),
# float(device.get_qubit_constant(qubit_id=qubit_id, name='Ramsey_step')))
# if we don't have a ramsey coherence scan, get one
from .readout_pulse import get_uncalibrated_measurer
try:
deexcited_measurement = device.exdir_db.select_measurement_by_id(
get_Ramsey_coherence_measurement(
device, target_qubit_id).references['fit_source'])
except:
deexcited_measurement = None
if lengths is None:
lengths = deexcited_measurement.datasets[
'iq' + target_qubit_id].parameters[-1].values
if target_freq_offset is None: ###TODO: make sure we don't skip oscillations due to decoherence
##(improbable but possible if the qubits are very coherent even at high crosstalks AHAHAHA)
target_freq_offset = float(
deexcited_measurement.metadata['target_offset_freq'])
#readout_pulse = get_qubit_readout_pulse(device, target_qubit_id)
readout_pulse, measurer = get_uncalibrated_measurer(
device, target_qubit_id) #, readout_pulse)
ex_control_pulse = excitation_pulse.get_excitation_pulse(
device,
control_qubit_id,
np.pi,
channel_amplitudes_override=channel_amplitudes_control)
ex_pulse1 = excitation_pulse.get_excitation_pulse(
device,
target_qubit_id,
np.pi / 2.,
channel_amplitudes_override=channel_amplitudes1)
ex_pulse2 = excitation_pulse.get_excitation_pulse(
device,
target_qubit_id,
np.pi / 2.,
channel_amplitudes_override=channel_amplitudes2)
def set_delay(length):
#ex_pulse_seq = [device.pg.pmulti(length+2*tail_length, *tuple(channel_pulses))]
if delay_seq_generator is None:
delay_seq = [device.pg.pmulti(length)]
else:
delay_seq = delay_seq_generator(length)
readout_delay_seq = [device.pg.pmulti(readout_delay)]
readout_trigger_seq = device.trigger_readout_seq
readout_pulse_seq = readout_pulse.pulse_sequence
device.pg.set_seq(device.pre_pulses+\
ex_control_pulse.get_pulse_sequence(0)+\
ex_pulse1.get_pulse_sequence(0)+\
delay_seq+\
ex_pulse2.get_pulse_sequence(length*target_freq_offset*2*np.pi)+\
readout_delay_seq+\
readout_trigger_seq+\
readout_pulse_seq)
references = {
'ex_control_pulse':
ex_control_pulse.id,
'ex_pulse1':
ex_pulse1.id,
'ex_pulse2':
ex_pulse2.id,
'frequency_controls':
device.get_frequency_control_measurement_id(qubit_id=target_qubit_id),
}
if deexcited_measurement is not None:
references['deexcited_measurement'] = deexcited_measurement.id
if hasattr(measurer, 'references'):
references.update(measurer.references)
fitter_arguments = ('iq' + target_qubit_id, exp_sin_fitter(), -1,
np.arange(len(extra_sweep_args)))
metadata = {
'target_qubit_id': target_qubit_id,
'control_qubit_id': control_qubit_id,
'extra_sweep_args': str(len(extra_sweep_args)),
'target_offset_freq': str(target_freq_offset),
'readout_delay': str(readout_delay)
}
references.update(additional_references)
measurement = device.sweeper.sweep_fit_dataset_1d_onfly(
measurer,
*extra_sweep_args, (lengths, set_delay, 'Delay', 's'),
fitter_arguments=fitter_arguments,
measurement_type=measurement_type,
metadata=metadata,
references=references)
return measurement
def get_gate_calibration(device, gate, recalibrate=True, force_recalibration=False, rotation_angle=None):
frequency_rounding = float(device.get_sample_global(name='frequency_rounding'))
channel_amplitudes_ = two_qubit_gate_channel_amplitudes(device, gate)
T2_q1 = float(device.exdir_db.select_measurement_by_id(Ramsey.get_Ramsey_coherence_measurement(device, qubit_id=gate.metadata['q1']).id).metadata['T'])
T2_q2 = float(device.exdir_db.select_measurement_by_id(Ramsey.get_Ramsey_coherence_measurement(device, qubit_id=gate.metadata['q2']).id).metadata['T'])
#print (T2_q1.metadata)
T2 = 1/(1/T2_q1+1/T2_q2)
gate_nophase = get_iswap_pulse_nophase(device, gate, frequency_shift = 0)
expected_frequency = float(device.exdir_db.select_measurement(measurement_type='fit_dataset_1d', references_that={'fit_source': gate_nophase.references['Rabi_rect']}).metadata['f'])
iteration = 0
best_frequency = 0
periods = 1
max_iterations = 1
while iteration < max_iterations: # loop exit condition: frequency scan has points closer than frequency_rounding
#coherence_time = float(device.exdir_db.select_measurement_by_id(gate_noshift.references['Rabi_rect']).metadata['decay'])
length = float(gate_nophase.metadata['length'])
try:
q1_excitation_pulse = excitation_pulse.get_excitation_pulse(device, qubit_id='1', rotation_angle=np.pi)
frequency_shift_scan_ = device.exdir_db.select_measurement(measurement_type='frequency_shift_scan',
references_that = {'parametric_pulse': gate_nophase.id,
'excitation_pulse': q1_excitation_pulse.id})
except IndexError as e:
scan_points = int(device.get_sample_global(name='adaptive_Rabi_amplitude_scan_points'))*3
frequency_shift_scan_ = frequency_shift_scan(device, gate, gate_nophase, (np.linspace(-np.sqrt(periods)/(length), np.sqrt(periods)/(length), scan_points)+best_frequency))
frequency_shift_scan_delta = frequency_shift_scan_.datasets['resultnumbers'].parameters[0].values[1] - \
frequency_shift_scan_.datasets['resultnumbers'].parameters[0].values[0]
target = frequency_shift_scan_.datasets['resultnumbers'].data[:, 1] - frequency_shift_scan_.datasets['resultnumbers'].data[:, 2]
best_frequency = frequency_shift_scan_.datasets['resultnumbers'].parameters[0].values[np.argmin(target)]
best_frequency = frequency_rounding*np.round(best_frequency/frequency_rounding)
periods = 1+(4**iteration-1)*2
gate_nophase = get_iswap_pulse_nophase(device, gate, frequency_shift=best_frequency, rotation_angle=np.pi*periods+np.pi/16., expected_frequency=expected_frequency)
expected_frequency = float(device.exdir_db.select_measurement(measurement_type='fit_dataset_1d', references_that={'fit_source': gate_nophase.references['Rabi_rect']}).metadata['f'])
iteration += 1
if frequency_shift_scan_delta < frequency_rounding or float(gate_nophase.metadata['length']) > T2:
break
#gate_nophase = get_iswap_pulse_nophase(device, gate, frequency_shift=best_frequency, rotation_angle=np.pi,
# expected_frequency=expected_frequency)
length_calibration = get_parametric_iswap_length_adaptive_calibration(device, gate, frequency_shift=best_frequency, recalibrate=recalibrate,
force_recalibration=force_recalibration)
gate_nophase = ParametricTwoQubitGate(device, q1=gate.metadata['q1'], q2=gate.metadata['q2'], phase_q1=np.nan,
phase_q2=np.nan, rotation_angle=rotation_angle, length=length_calibration.metadata['length'],
tail_length=gate.metadata['tail_length'], channel_amplitudes=channel_amplitudes_.id,
Rabi_rect_measurement=gate_nophase.references['Rabi_rect'], gate_settings=gate.id,
frequency_shift=best_frequency, carrier_name=gate.metadata['carrier_name'],
carrier_harmonic=gate.metadata['carrier_harmonic'])
try:
references = {'process': gate_nophase.id}
metadata_scan1 = {'q1': gate.metadata['q1'],
'q2': gate.metadata['q2']}
metadata_scan2 = {'q1': gate.metadata['q2'],
'q2': gate.metadata['q1']}
phase_scan1 = device.exdir_db.select_measurement(measurement_type='Ramsey_process', metadata=metadata_scan1, references_that=references)
phase_scan2 = device.exdir_db.select_measurement(measurement_type='Ramsey_process', metadata=metadata_scan2, references_that=references)
phase_scan1_fit = device.exdir_db.select_measurement(measurement_type='fit_dataset_1d', references_that={'fit_source': phase_scan1.id})
phase_scan2_fit = device.exdir_db.select_measurement(measurement_type='fit_dataset_1d', references_that={'fit_source': phase_scan2.id})
except IndexError as e:
traceback.print_exc()
if not recalibrate:
raise
phase_scan1, phase_scan2, phase_scan1_fit, phase_scan2_fit = calibrate_iswap_phase_single_pulse(device, gate_nophase, 1)
# we want -np.pi/2. phase from iSWAP; exchange qubits since phase is applied after iSWAP
phase_q2 = -float(phase_scan1_fit.metadata['phi']) - np.pi/2.
phase_q1 = -float(phase_scan2_fit.metadata['phi']) - np.pi/2.
gate_with_phase = ParametricTwoQubitGate(device,
q1=gate.metadata['q1'],
q2=gate.metadata['q2'],
phase_q1=phase_q1,
phase_q2=phase_q2,
rotation_angle = rotation_angle,
length=gate_nophase.metadata['length'],
tail_length=gate.metadata['tail_length'],
channel_amplitudes=channel_amplitudes_.id,
Rabi_rect_measurement=gate_nophase.id,
phase_scan_q1=phase_scan1.id,
phase_scan_q2=phase_scan2.id,
gate_settings=gate.id,
frequency_shift=best_frequency,
carrier_name=gate.metadata['carrier_name'],
carrier_harmonic=gate.metadata['carrier_harmonic'])
return gate_with_phase
def readout_Zgate_scan(device, qubit_id, qubit_readout_pulse, Zgate, amplitudes, transition='01', ignore_other_qubits=None):
adc, mnames = device.setup_adc_reducer_iq(qubit_id, raw=True)
nums = int(device.get_qubit_constant(qubit_id=qubit_id, name='readout_background_nums'))
old_nums = adc.get_adc_nums()
adc.set_adc_nop(int(device.get_sample_global('readout_adc_points')))
if ignore_other_qubits is None:
ignore_other_qubits = (device.get_qubit_constant(qubit_id=qubit_id, name='readout_calibration_ignore_other_qubits') == 'True')
print ('ignore_other_qubits', ignore_other_qubits)
other_qubit_pulse_sequence = []
references = {}
if not ignore_other_qubits:
for other_qubit_id in device.get_qubit_list():
if other_qubit_id != qubit_id:
half_excited_pulse = excitation_pulse.get_excitation_pulse(device, other_qubit_id,
rotation_angle=np.pi / 2.)
references[('other_qubit_pulse', other_qubit_id)] = half_excited_pulse.id
other_qubit_pulse_sequence.extend(half_excited_pulse.get_pulse_sequence(0))
qubit_excitation_pulse = excitation_pulse.get_excitation_pulse(device, qubit_id, rotation_angle=np.pi)
metadata = {'qubit_id': qubit_id,
'averages': nums,
'ignore_other_qubits': ignore_other_qubits}
references.update({'readout_pulse': qubit_readout_pulse.id,
'excitation_pulse': qubit_excitation_pulse.id,
'delay_calibration': device.modem.delay_measurement.id,
'Zgate': Zgate.id},
)
classifier = single_shot_readout.single_shot_readout(adc=adc,
prepare_seqs=[
device.pre_pulses + other_qubit_pulse_sequence,
device.pre_pulses + other_qubit_pulse_sequence + qubit_excitation_pulse.get_pulse_sequence(
0)],
ro_seq=device.trigger_readout_seq + qubit_readout_pulse.get_pulse_sequence(),
pulse_generator=device.pg,
ro_delay_seq=None,
_readout_classifier=readout_classifier.binary_linear_classifier(),
adc_measurement_name='Voltage')
def set_Zgate_amplitude(x):
channel_amplitudes1_ = channel_amplitudes.channel_amplitudes(device,
**{Zgate.metadata[
'carrier_name']: x})
print(channel_amplitudes1_)
pulse_seq1 = excitation_pulse.get_rect_cos_pulse_sequence(device=device,
channel_amplitudes=channel_amplitudes1_,
tail_length=float(Zgate.metadata['tail_length']),
length=float(qubit_readout_pulse.metadata['length']),
phase=0.0)
classifier.ro_seq = device.trigger_readout_seq + device.pg.parallel(pulse_seq1,qubit_readout_pulse.get_pulse_sequence())
classifier.readout_classifier.cov_mode = 'equal'
try:
adc.set_adc_nums(nums)
measurement = device.sweeper.sweep(classifier,
(amplitudes, set_Zgate_amplitude, 'amplitude', 'Voltage'),
measurement_type='readout_Zgate_scan',
metadata=metadata,
references=references)
except:
raise
finally:
adc.set_adc_nums(old_nums)
return measurement
# classifier.repeat_samples = 2
def readout_fidelity_scan(device, qubit_id, readout_pulse_lengths, readout_pulse_amplitudes,
recalibrate_excitation=True, ignore_other_qubits=False, channel_amplitudes=None):
adc, mnames = device.setup_adc_reducer_iq(qubit_id, raw=True)
nums = int(device.get_qubit_constant(qubit_id=qubit_id, name='readout_background_nums'))
adc.set_adc_nop(int(device.get_sample_global('readout_adc_points')))
old_nums = adc.get_adc_nums()
readout_channel = [i for i in device.get_qubit_readout_channel_list(qubit_id).keys()][0]
other_qubit_pulse_sequence = []
references = {'frequency_controls': device.get_frequency_control_measurement_id(qubit_id=qubit_id)}
if hasattr(device.awg_channels[readout_channel], 'get_calibration_measurement'):
references['channel_calibration'] = device.awg_channels[readout_channel].get_calibration_measurement()
if not ignore_other_qubits:
for other_qubit_id in device.get_qubit_list():
if other_qubit_id != qubit_id:
half_excited_pulse = excitation_pulse.get_excitation_pulse(device, other_qubit_id,
rotation_angle=np.pi / 2.,
recalibrate=recalibrate_excitation)
references[('other_qubit_pulse', other_qubit_id)] = half_excited_pulse.id
other_qubit_pulse_sequence.extend(half_excited_pulse.get_pulse_sequence(0))
qubit_excitation_pulse = excitation_pulse.get_excitation_pulse(device, qubit_id, rotation_angle=np.pi, channel_amplitudes_override=channel_amplitudes,
recalibrate=recalibrate_excitation)
metadata = {'qubit_id': qubit_id,
'averages': nums,
'channel': readout_channel,
'ignore_other_qubits': ignore_other_qubits}
# print ('len(readout_pulse_lengths): ', len(readout_pulse_lengths))
if len(readout_pulse_lengths) == 1:
metadata['length'] = str(readout_pulse_lengths[0])
references.update({'excitation_pulse': qubit_excitation_pulse.id,
'delay_calibration': device.modem.delay_measurement.id})
classifier = single_shot_readout.single_shot_readout(adc=adc,
prepare_seqs=[device.pre_pulses + other_qubit_pulse_sequence,
device.pre_pulses + other_qubit_pulse_sequence +
qubit_excitation_pulse.get_pulse_sequence(0)],
ro_seq=device.trigger_readout_seq,
pulse_generator=device.pg,
ro_delay_seq=None,
_readout_classifier=readout_classifier.binary_linear_classifier(),
adc_measurement_name='Voltage',
dbg_storage=False)
classifier.readout_classifier.cov_mode = 'equal'
# setters for sweep
readout_amplitude = 0
readout_length = 0
def set_readout_amplitude(x):
nonlocal readout_amplitude
readout_amplitude = x
classifier.ro_seq = device.trigger_readout_seq + [
device.pg.p(readout_channel, readout_length, device.pg.rect, readout_amplitude)]
def set_readout_length(x):
nonlocal readout_length
readout_length = x
classifier.ro_seq = device.trigger_readout_seq + [
device.pg.p(readout_channel, readout_length, device.pg.rect, readout_amplitude)]
try:
adc.set_adc_nums(nums)
measurement = device.sweeper.sweep(classifier,
(readout_pulse_lengths, set_readout_length, 'length', 's'),
(readout_pulse_amplitudes, set_readout_amplitude, 'amplitude', ''),
measurement_type='readout_fidelity_scan',
metadata=metadata,
references=references)
except:
raise
finally:
adc.set_adc_nums(old_nums)
return measurement
def echo_crosstalk(device,
target_qubit_id,
control_qubit_id,
*extra_sweep_args,
channel_amplitudes1=None,
channel_amplitudes_pi=None,
channel_amplitudes2=None,
lengths=None,
target_freq_offset=None,
readout_delay=0,
delay_seq_generator=None,
measurement_type='echo_crosstalk',
additional_references={},
additional_metadata={}):
from .readout_pulse import get_uncalibrated_measurer
if type(lengths) is type(None):
lengths = np.arange(
0,
float(
device.get_qubit_constant(qubit_id=target_qubit_id,
name='Ramsey_length')),
float(
device.get_qubit_constant(qubit_id=target_qubit_id,
name='Ramsey_step')))
#readout_pulse = get_qubit_readout_pulse(device, qubit_id)
readout_pulse, measurer = get_uncalibrated_measurer(
device, target_qubit_id)
ex_pulse1 = excitation_pulse.get_excitation_pulse(
device,
target_qubit_id,
np.pi / 2.,
channel_amplitudes_override=channel_amplitudes1)
ex_pulse_pi = excitation_pulse.get_excitation_pulse(
device,
target_qubit_id,
np.pi,
channel_amplitudes_override=channel_amplitudes_pi)
ex_pulse_control = excitation_pulse.get_excitation_pulse(
device, control_qubit_id, np.pi)
ex_pulse2 = excitation_pulse.get_excitation_pulse(
device,
target_qubit_id,
np.pi / 2.,
channel_amplitudes_override=channel_amplitudes2)
def set_delay(length):
#ex_pulse_seq = [device.pg.pmulti(length+2*tail_length, *tuple(channel_pulses))]
if delay_seq_generator is None:
delay_seq = [device.pg.pmulti(length / 2)]
else:
delay_seq = delay_seq_generator(length / 2)
readout_delay_seq = [device.pg.pmulti(readout_delay)]
readout_trigger_seq = device.trigger_readout_seq
readout_pulse_seq = readout_pulse.pulse_sequence
device.pg.set_seq(
device.pre_pulses + ex_pulse1.get_pulse_sequence(0) + delay_seq +
device.pg.parallel(ex_pulse_pi.get_pulse_sequence(
0), ex_pulse_control.get_pulse_sequence(0)) + delay_seq +
ex_pulse2.get_pulse_sequence(length * target_freq_offset * 2 *
np.pi) + readout_delay_seq +
readout_trigger_seq + readout_pulse_seq)
references = {
'ex_pulse_control':
ex_pulse_control.id,
'ex_pulse1':
ex_pulse1.id,
'ex_pulse_pi':
ex_pulse_pi.id,
'ex_pulse2':
ex_pulse2.id,
'frequency_controls':
device.get_frequency_control_measurement_id(qubit_id=target_qubit_id)
}
references.update(additional_references)
if hasattr(measurer, 'references'):
references.update(measurer.references)
fitter_arguments = ('iq' + target_qubit_id, exp_sin_fitter(), -1,
np.arange(len(extra_sweep_args)))
metadata = {
'target_qubit_id': target_qubit_id,
'control_qubit_id': control_qubit_id,
'extra_sweep_args': str(len(extra_sweep_args)),
'target_offset_freq': str(target_freq_offset),
'readout_delay': str(readout_delay)
}
metadata.update(additional_metadata)
measurement = device.sweeper.sweep_fit_dataset_1d_onfly(
measurer,
*extra_sweep_args, (lengths, set_delay, 'Delay', 's'),
fitter_arguments=fitter_arguments,
measurement_type=measurement_type,
metadata=metadata,
references=references)
return measurement
def benchmarking_pi2(device,
qubit_id,
*params,
pause_length=0,
random_sequence_num=1,
seq_lengths_num=400):
coherence_measurement = Ramsey.get_Ramsey_coherence_measurement(
device, qubit_id)
T2 = float(coherence_measurement.metadata['T'])
pi2_pulse = excitation_pulse.get_excitation_pulse(device, qubit_id,
np.pi / 2.)
pi2_pulse_length = float(pi2_pulse.metadata['length'])
channel_amplitudes_ = channel_amplitudes.channel_amplitudes(
device.exdir_db.select_measurement_by_id(
pi2_pulse.references['channel_amplitudes']))
max_pulses = T2 / pi2_pulse_length
seq_lengths = np.asarray(
np.round(np.linspace(0, max_pulses, seq_lengths_num)), int)
def get_pulse_seq_z(z_phase):
pg = device.pg
z_pulse = [(c, vz, z_phase) for c, a in channel_amplitudes_.items()]
sequence_z = [pg.pmulti(0, *tuple(z_pulse))]
return sequence_z
qubit_readout_pulse, readout_device = calibrated_readout.get_calibrated_measurer(
device, [qubit_id])
HZ = {
'H': {
'pulses':
get_pulse_seq_z(np.pi / 2) + pi2_pulse.get_pulse_sequence(np.pi) +
get_pulse_seq_z(np.pi / 2),
'unitary':
np.sqrt(0.5) * np.asarray([[1, 1], [1, -1]]),
'price':
1.0
},
'Z': {
'pulses': get_pulse_seq_z(np.pi),
'unitary': np.asarray([[1, 0], [0, -1]]),
'price': 0.1
},
'Z/2': {
'pulses': get_pulse_seq_z(np.pi / 2),
'unitary': np.asarray([[1, 0], [0, 1j]]),
'price': 0.1
},
'-Z/2': {
'pulses': get_pulse_seq_z(-np.pi / 2.),
'unitary': np.asarray([[1, 0], [0, -1j]]),
'price': 0.1
},
'I': {
'pulses': [],
'unitary': np.asarray([[1, 0], [0, 1]]),
'price': 0.1
}
}
HZ_group = clifford.generate_group(HZ)
ro_seq = [
device.pg.pmulti(pause_length)
] + device.trigger_readout_seq + qubit_readout_pulse.get_pulse_sequence()
pi2_bench = interleaved_benchmarking.interleaved_benchmarking(
readout_device,
set_seq=lambda x: device.pg.set_seq(device.pre_pulses + x + ro_seq))
pi2_bench.interleavers = HZ_group
pi2_bench.random_sequence_num = random_sequence_num
random_sequence_ids = np.arange(random_sequence_num)
pi2_bench.prepare_random_interleaving_sequences()
clifford_bench = device.sweeper.sweep(
pi2_bench, (seq_lengths, pi2_bench.set_sequence_length_and_regenerate,
'Gate number', ''),
*params, (random_sequence_ids, pi2_bench.set_interleaved_sequence,
'Random sequence id', ''),
shuffle=True,
measurement_type='pi2_bench',
metadata={'qubit_id': qubit_id},
references={'pi2_pulse': pi2_pulse.id})
return clifford_bench
def benchmarking_pi2_multi(device,
qubit_ids,
*params,
interleaver=None,
two_qubit_gate=None,
max_pulses=None,
pause_length=0,
random_sequence_num=1,
seq_lengths_num=400):
channel_amplitudes_ = {}
pi2_pulses = {}
generators = {}
if max_pulses is None:
max_pulses = []
for qubit_id in qubit_ids:
coherence_measurement = Ramsey.get_Ramsey_coherence_measurement(
device, qubit_id)
T2 = float(coherence_measurement.metadata['T'])
pi2_pulses[qubit_id] = excitation_pulse.get_excitation_pulse(
device, qubit_id, np.pi / 2.)
pi2_pulse_length = float(pi2_pulses[qubit_id].metadata['length'])
max_pulses.append(T2 / pi2_pulse_length)
if two_qubit_gate is not None:
max_pulses = np.asarray(max_pulses) / 3.
max_pulses = min(max_pulses)
for qubit_id in qubit_ids:
pi2_pulses[qubit_id] = excitation_pulse.get_excitation_pulse(
device, qubit_id, np.pi / 2.)
channel_amplitudes_[qubit_id] = channel_amplitudes.channel_amplitudes(
device.exdir_db.select_measurement_by_id(
pi2_pulses[qubit_id].references['channel_amplitudes']))
seq_lengths = np.asarray(
np.round(np.linspace(0, max_pulses, seq_lengths_num)), int)
def get_pulse_seq_z(z_phase, qubit_id):
pg = device.pg
z_pulse = [(c, vz, z_phase)
for c, a in channel_amplitudes_[qubit_id].items()]
sequence_z = [pg.pmulti(0, *tuple(z_pulse))]
return sequence_z
def tensor_product(unitary, qubit_id):
U = [[1]]
for i in qubit_ids:
U = np.kron(U, np.identity(2) if i != qubit_id else unitary)
return U
qubit_readout_pulse, readout_device = calibrated_readout.get_calibrated_measurer(
device, qubit_ids)
generators = {}
for qubit_id in qubit_ids:
HZ = {
'H_' + qubit_id: {
'pulses':
get_pulse_seq_z(np.pi / 2, qubit_id) +
pi2_pulses[qubit_id].get_pulse_sequence(np.pi) +
get_pulse_seq_z(np.pi / 2, qubit_id),
'unitary':
np.sqrt(0.5) * tensor_product([[1, 1], [1, -1]], qubit_id),
'price':
1.0
},
'Z_' + qubit_id: {
'pulses': get_pulse_seq_z(np.pi, qubit_id),
'unitary': tensor_product([[1, 0], [0, -1]], qubit_id),
'price': 0.1
},
'Z/2_' + qubit_id: {
'pulses': get_pulse_seq_z(np.pi / 2, qubit_id),
'unitary': tensor_product([[1, 0], [0, 1j]], qubit_id),
'price': 0.1
},
'-Z/2_' + qubit_id: {
'pulses': get_pulse_seq_z(-np.pi / 2., qubit_id),
'unitary': tensor_product([[1, 0], [0, -1j]], qubit_id),
'price': 0.1
},
'I_' + qubit_id: {
'pulses': [],
'unitary': tensor_product([[1, 0], [0, 1]], qubit_id),
'price': 0.1
}
}
generators[qubit_id] = HZ
if len(qubit_ids) == 2:
HZ_group = clifford.two_qubit_clifford(
*tuple([g for g in generators.values()]),
plus_op_parallel=device.pg.parallel,
cphase=two_qubit_gate)
elif len(qubit_ids) == 1:
HZ_group = clifford.generate_group(generators[qubit_ids[0]])
else:
raise ValueError('More than two qubits are unsupported')
print('group length:', len(HZ_group))
ro_seq = [
device.pg.pmulti(pause_length)
] + device.trigger_readout_seq + qubit_readout_pulse.get_pulse_sequence()
pi2_bench = interleaved_benchmarking.interleaved_benchmarking(
readout_device,
set_seq=lambda x: device.pg.set_seq(device.pre_pulses + x + ro_seq),
interleavers=HZ_group)
pi2_bench.random_sequence_num = random_sequence_num
random_sequence_ids = np.arange(random_sequence_num)
references = {('pi2_pulse', qubit_id): pi2_pulses[qubit_id].id
for qubit_id in qubit_ids}
pi2_bench.prepare_random_interleaving_sequences()
### search db for previous version of the interleaver measurement
found = False
try:
clifford_bench = device.exdir_db.select_measurement(
measurement_type='clifford_bench',
metadata={'qubit_ids': ','.join(qubit_ids)},
references_that=references)
found = True
except IndexError:
pass
if random_sequence_num > 1:
params = tuple([(random_sequence_ids,
pi2_bench.set_interleaved_sequence,
'Random sequence id', '')] + [p for p in params])
if (not found) or (interleaver is None):
measurement_name = [m for m in pi2_bench.get_points().keys()][0]
fitter_arguments = (measurement_name, exp.exp_fitter(), 0,
np.arange(len(params)).tolist())
clifford_bench = device.sweeper.sweep_fit_dataset_1d_onfly(
pi2_bench,
(seq_lengths, pi2_bench.set_sequence_length_and_regenerate,
'Gate number', ''),
*params,
fitter_arguments=fitter_arguments,
measurement_type='clifford_bench',
metadata={'qubit_ids': ','.join(qubit_ids)},
shuffle=True,
references=references)
## interleaver measurement is found, bench "interleaver" gate
references['Clifford-bench'] = clifford_bench.id
if interleaver is not None:
if 'references' in interleaver:
references.update(interleaver['references'])
pi2_bench.set_target_pulse(interleaver)
measurement_name = [m for m in pi2_bench.get_points().keys()][0]
fitter_arguments = (measurement_name, exp.exp_fitter(), 0,
np.arange(len(params)).tolist())
interleaved_bench = device.sweeper.sweep_fit_dataset_1d_onfly(
pi2_bench,
(seq_lengths, pi2_bench.set_sequence_length_and_regenerate,
'Gate number', ''),
*params,
fitter_arguments=fitter_arguments,
measurement_type='interleaved_bench',
metadata={'qubit_ids': ','.join(qubit_ids)},
shuffle=True,
references=references)
return interleaved_bench
return clifford_bench
