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 get_vf(device, qubit_id, freq):
pi2 = get_excitation_pulse(device, qubit_id, np.pi / 2.)
channel_amplitudes_ = channel_amplitudes.channel_amplitudes(
device.exdir_db.select_measurement_by_id(
pi2.references['channel_amplitudes']))
v_pulse = [(c, pulses.vf, freq) for c, a in channel_amplitudes_.items()]
for name, two_qubit_gate in device.get_two_qubit_gates().items():
if two_qubit_gate.metadata['pulse_type'] == 'parametric':
if two_qubit_gate.metadata['q1'] == qubit_id:
factor = float(two_qubit_gate.metadata['carrier_harmonic'])
if two_qubit_gate.metadata['transition_q1'] == '01':
factor *= 1
elif two_qubit_gate.metadata['transition_q1'] == '12':
factor *= -1
else:
factor = 0
elif two_qubit_gate.metadata['q2'] == qubit_id:
factor = -float(two_qubit_gate.metadata['carrier_harmonic'])
if two_qubit_gate.metadata['transition_q2'] == '01':
factor *= 1
elif two_qubit_gate.metadata['transition_q2'] == '12':
factor *= -1
else:
factor = 0
else:
factor = 0
if not factor == 0.0:
v_pulse.append((two_qubit_gate.metadata['carrier_name'],
pulses.vf, factor * freq))
'''Warning'''
sequence_f = [device.pg.pmulti(device, 0, *tuple(v_pulse))]
return sequence_f
def filler_func(self, length):
self.length = length
channel_amplitudes_ = channel_amplitudes.channel_amplitudes(
device, **{gate.metadata['carrier_name']: self.amplitude})
if 'pulse_type' in gate.metadata:
if gate.metadata['pulse_type'] == 'cos':
frequency = float(gate.metadata['frequency'])
#print(frequency)
#print(self.length)
channel_pulses = [
(c, device.pg.sin, self.amplitude, frequency)
for c, a in channel_amplitudes_.metadata.items()
]
gate_pulse = [
device.pg.pmulti(self.length, *tuple(channel_pulses))
]
else:
gate_pulse = excitation_pulse.get_rect_cos_pulse_sequence(
device=device,
channel_amplitudes=channel_amplitudes_,
tail_length=float(gate.metadata['tail_length']),
length=self.length,
phase=0.0)
return [device.pg.pmulti(pre_pause)
] + gate_pulse + [device.pg.pmulti(post_pause)]
def filler_func(length):
channel_amplitudes_ = channel_amplitudes.channel_amplitudes(device,
**{gate.metadata['carrier_name']: float(gate.metadata['amplitude'])})
return excitation_pulse.get_rect_cos_pulse_sequence(device = device,
channel_amplitudes = channel_amplitudes_ ,
tail_length = float(gate.metadata['tail_length']),
length = length,
phase = 0.0)
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 filler_func(self, length):
channel_amplitudes_ = channel_amplitudes.channel_amplitudes(
device, **{gate.metadata['carrier_name']: self.amplitude})
return [device.pg.pmulti(pre_pause)
] + excitation_pulse.get_rect_cos_pulse_sequence(
device=device,
channel_amplitudes=channel_amplitudes_,
tail_length=float(gate.metadata['tail_length']),
length=length,
phase=0.0) + [device.pg.pmulti(post_pause)]
def get_hadamard(device, qubit_id):
pi2 = get_excitation_pulse(device, qubit_id, np.pi / 2.)
channel_amplitudes_ = channel_amplitudes.channel_amplitudes(
device.exdir_db.select_measurement_by_id(
pi2.references['channel_amplitudes']))
# s_pulse = [(c, pulses.vz, np.pi / 2.) for c, a in channel_amplitudes_.items()]
# sequence_z = [device.pg.pmulti(0, *tuple(s_pulse))]
sequence_z = get_s(device, qubit_id, phase=np.pi / 2.)
return sequence_z + pi2.get_pulse_sequence(np.pi) + sequence_z
def __init__(self, *args, **kwargs):
self.device = args[0]
if len(args) == 2 and isinstance(
args[1],
MeasurementState) and not len(kwargs): # copy constructor
super().__init__(args[1])
else: # otherwise initialize from dict and device
metadata = {
'qubit_id': kwargs['qubit_id'],
'transition': kwargs['transition'],
'rotation_angle': str(kwargs['rotation_angle']),
'pulse_type': 'gauss_hd',
'length': str(kwargs['length']),
'sigma': str(kwargs['sigma']),
'alpha': str(kwargs['alpha']),
'amplitude': str(kwargs['amplitude'])
}
if 'calibration_type' in kwargs:
metadata['calibration_type'] = kwargs['calibration_type']
references = {
'channel_amplitudes':
int(kwargs['channel_amplitudes']),
'gauss_hd_Rabi_amplitude_adaptive':
int(kwargs['gauss_hd_Rabi_amplitude_adaptive_measurement'])
}
if 'gauss_hd_ape_correction_adaptive_measurement' in kwargs:
references['gauss_hd_ape_correction_adaptive'] = int(
kwargs['gauss_hd_ape_correction_adaptive_measurement'])
# check if such measurement exists
try:
measurement = self.device.exdir_db.select_measurement(
measurement_type='qubit_excitation_pulse',
metadata=metadata,
references_that=references)
super().__init__(measurement)
except:
traceback.print_exc()
super().__init__(measurement_type='qubit_excitation_pulse',
sample_name=self.device.exdir_db.sample_name,
metadata=metadata,
references=references)
self.device.exdir_db.save_measurement(self)
#inverse_references = {v:k for k,v in self.references.items()}
#print ('inverse_references in __init__:', inverse_references)
self.channel_amplitudes = channel_amplitudes(
self.device.exdir_db.select_measurement_by_id(
self.references['channel_amplitudes']))
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())
def filler_func(self, length):
self.length = length
channel_amplitudes_ = channel_amplitudes.channel_amplitudes(device, **{gate.metadata[
'carrier_name']: self.amplitude})
gate_pulse = excitation_pulse.get_rect_cos_pulse_sequence(device=device,
channel_amplitudes=channel_amplitudes_,
tail_length=float(
gate.metadata['tail_length']),
length=self.length,
phase=0.0,
fast_control=True)
self.pre_pause_seq = [device.pg.pmulti(device, pre_pause)]
self.gate_pulse_seq = gate_pulse
self.post_pause_seq = [device.pg.pmulti(device, post_pause)]
return self.pre_pause_seq, self.gate_pulse_seq, self.post_pause_seq
def __init__(self, *args, **kwargs):
self.device = args[0]
if len(args) == 2 and isinstance(args[1], MeasurementState) and not len(kwargs): # copy constructor
super().__init__(args[1])
else: # otherwise initialize from dict and device
metadata = {'rotation_angle': str(kwargs['rotation_angle']),
'pulse_type': 'rect',
'length': str(kwargs['length']),
'tail_length': str(kwargs['tail_length']),
'phase_q1': str(kwargs['phase_q1']),
'phase_q2': str(kwargs['phase_q2']),
'q1': str(kwargs['q1']),
'q2': str(kwargs['q2']),
'frequency_shift': str(kwargs['frequency_shift']),
'carrier_name': str(kwargs['carrier_name']),
'carrier_harmonic': str(kwargs['carrier_harmonic'])}
if 'calibration_type' in kwargs:
metadata['calibration_type'] = kwargs['calibration_type']
references = {'channel_amplitudes': int(kwargs['channel_amplitudes']),
'Rabi_rect': int(kwargs['Rabi_rect_measurement']),
'gate_settings': int(kwargs['gate_settings'])}
if 'phase_scan_q1' in kwargs:
references['phase_scan_q1'] = int(kwargs['phase_scan_q1'])
if 'phase_scan_q2' in kwargs:
references['phase_scan_q2'] = int(kwargs['phase_scan_q2'])
# check if such measurement exists
try:
measurement = self.device.exdir_db.select_measurement(measurement_type='parametric_two_qubit_gate', metadata=metadata, references_that=references)
super().__init__(measurement)
except IndexError as e:
traceback.print_exc()
super().__init__(measurement_type='parametric_two_qubit_gate', sample_name=self.device.exdir_db.sample_name, metadata=metadata, references=references)
self.device.exdir_db.save_measurement(self)
#inverse_references = {v:k for k,v in self.references.items()}
#print ('inverse_references in __init__:', inverse_references)
self.channel_amplitudes = channel_amplitudes.channel_amplitudes(self.device.exdir_db.select_measurement_by_id(self.references['channel_amplitudes']))
def get_preferred_length(device, qubit_id, channel):
'''
calculates the preffered gate length for single-qubit gate on qubit_id applied through channel.
Caluclation involves the Rabi max_Rabi_freq qubit or global parameter and the Rabi frequencies of other
qubits driven through this iq_ex device and max_parasitic_Rabi_ratio control.
Parameters
----------
device
qubit_id
channel
Returns
-------
prefered maximum gate length for rect pulses.
'''
max_Rabi_freq = float(device.get_qubit_constant(qubit_id=qubit_id, name='max_Rabi_freq'))
max_parasitic_Rabi_ratio = float(device.get_qubit_constant(qubit_id=qubit_id, name='max_parasitic_Rabi_ratio'))
pulse_length_alignment = float(device.get_qubit_constant(qubit_id=qubit_id, name='pulse_length_alignment'))
sigmas_in_gauss = float(device.get_qubit_constant(qubit_id=qubit_id, name='sigmas_in_gauss'))
amplitude_default = float(device.get_qubit_constant(qubit_id=qubit_id, name='amplitude_default'))
channel_device = device.get_qubit_excitation_channel_list(qubit_id)[channel]
# loop over other qubits
pulse_amplitude = amplitude_default
print('getting other qubit excitition pulse with qubit_id {} and channel {}'.format(qubit_id, channel))
rect_pulse = get_rect_excitation_pulse(device=device,
qubit_id=qubit_id,
rotation_angle=2 * np.pi,
channel_amplitudes_override=channel_amplitudes(device, **{
channel: amplitude_default}),
recalibrate=True)
channel_amplitudes_ = device.exdir_db.select_measurement_by_id(rect_pulse.references['channel_amplitudes'])
amplitude = float(channel_amplitudes_.metadata[channel])
Rabi_freq = 1 / (float(rect_pulse.metadata['length']) * amplitude)
if Rabi_freq > max_Rabi_freq:
pulse_amplitude = max_Rabi_freq / Rabi_freq
for other_qubit_id in device.get_qubit_list():
if other_qubit_id == qubit_id:
continue
if channel_device not in device.get_qubit_excitation_channel_list(other_qubit_id).values():
continue
for other_qubit_channel, other_qubit_channel_device in device.get_qubit_excitation_channel_list(
other_qubit_id).items():
if other_qubit_channel_device == channel_device:
other_qubit_channel_ = other_qubit_channel
print('getting other qubit excitition pulse with qubit_id {} and channel {}'.format(other_qubit_id,
other_qubit_channel_))
other_qubit_excitation_pulse = get_excitation_pulse(device=device,
qubit_id=other_qubit_id,
rotation_angle=2 * np.pi,
channel_amplitudes_override=channel_amplitudes(device, **{
other_qubit_channel_: amplitude_default}),
recalibrate=True)
other_length = float(other_qubit_excitation_pulse.metadata['length'])
channel_amplitudes_ = device.exdir_db.select_measurement_by_id(
other_qubit_excitation_pulse.references['channel_amplitudes'])
other_amplitude = float(channel_amplitudes_.metadata[other_qubit_channel_])
other_qubit_Rabi_freq = 1 / (other_length * other_amplitude)
print('other_qubit_Rabi_freq', other_qubit_Rabi_freq)
if np.isfinite(other_qubit_Rabi_freq):
max_parasitic_Rabi = max_parasitic_Rabi_ratio * np.abs(
device.get_qubit_fq(other_qubit_id) - device.get_qubit_fq(qubit_id))
# Rabi_freq_over_detuning = other_qubit_Rabi_freq/np.abs(device.get_qubit_fq(other_qubit_id)-device.get_qubit_ids(qubit_id))
if other_qubit_Rabi_freq * pulse_amplitude > max_parasitic_Rabi:
pulse_amplitude = max_parasitic_Rabi / other_qubit_Rabi_freq
print('max_parasitic_Rabi', max_parasitic_Rabi)
print('other_qubit_Rabi_freq', other_qubit_Rabi_freq)
rect_length_preferred = 0.5 / (Rabi_freq * pulse_amplitude) # for a pi-pulse
gauss_length_preferred = rect_length_preferred / per_amplitude_angle_guess(1, 1 / sigmas_in_gauss)
print('Rabi_freq', Rabi_freq, 'pulse_amplitude', pulse_amplitude)
print('Non-rounded (rect): ', rect_length_preferred)
print('Non-rounded (gauss_length_preferred):', gauss_length_preferred)
rect_length_preferred = np.ceil(rect_length_preferred / pulse_length_alignment) * pulse_length_alignment
gauss_length_preferred = np.ceil(gauss_length_preferred / pulse_length_alignment) * pulse_length_alignment
print('gauss_length_preferred:', gauss_length_preferred)
return gauss_length_preferred # rect_length_preferred, gauss_length_preferred
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,
two_qubit_num=0,
random_gate_num=1):
channel_amplitudes_ = {}
pi2_pulses = {}
pi_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'])
pi_pulses[qubit_id] = excitation_pulse.get_excitation_pulse(
device, qubit_id, np.pi)
pi_pulse_length = float(pi_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.)
pi_pulses[qubit_id] = excitation_pulse.get_excitation_pulse(
device, qubit_id, np.pi)
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, length, qubit_id):
fast_control = False
z_pulse = [(c, device.pg.virtual_z, z_phase * 360 / 2 / np.pi,
fast_control)
for c, a in channel_amplitudes_[qubit_id].items()]
sequence_z = [device.pg.pmulti(device, length, *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
#TODO
qubit_readout_pulse, readout_device = calibrated_readout.get_calibrated_measurer(
device, qubit_ids)
generators = {}
for qubit_id in qubit_ids:
HZ = {
'X': {
'pulses': pi_pulses[qubit_id].get_pulse_sequence(0),
'unitary': tensor_product(np.asarray([[0, 1], [1, 0]]),
qubit_id),
'price': 1.0
},
'X/2': {
'pulses':
pi2_pulses[qubit_id].get_pulse_sequence(0),
'unitary':
np.sqrt(0.5) *
tensor_product(np.asarray([[1, -1j], [-1j, 1]]), qubit_id),
'price':
1.0
},
'-X/2': {
'pulses':
pi2_pulses[qubit_id].get_pulse_sequence(np.pi),
'unitary':
np.sqrt(0.5) *
tensor_product(np.asarray([[1, 1j], [1j, 1]]), qubit_id),
'price':
1.0
},
'Z': {
'pulses': get_pulse_seq_z(np.pi, pi2_pulse_length, qubit_id),
'unitary': tensor_product([[1, 0], [0, -1]], qubit_id),
'price': 0.1
},
'Z/2': {
'pulses': get_pulse_seq_z(np.pi / 2, pi2_pulse_length,
qubit_id),
'unitary': tensor_product([[1, 0], [0, 1j]], qubit_id),
'price': 0.1
},
'-Z/2': {
'pulses': get_pulse_seq_z(-np.pi / 2., pi2_pulse_length,
qubit_id),
'unitary': tensor_product([[1, 0], [0, -1j]], qubit_id),
'price': 0.1
},
'I': {
'pulses': get_pulse_seq_z(0, pi2_pulse_length, qubit_id),
'unitary': tensor_product([[1, 0], [0, 1]], qubit_id),
'price': 0.1
}
}
generators[qubit_id] = HZ
if len(qubit_ids) == 2:
#TODO
HZ_group = clifford.two_qubit_clifford(
*tuple([g for g in generators.values()]),
plus_op_parallel=device.pg.parallel,
two_qubit_gate=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))
# TODO qubit sequencer
exitation_channel = [
i
for i in device.get_qubit_excitation_channel_list(qubit_ids[0]).keys()
][0]
ex_channel = device.awg_channels[exitation_channel]
if ex_channel.is_iq():
control_seq_id = ex_channel.parent.sequencer_id
else:
control_seq_id = ex_channel.channel // 2
ex_sequencers = []
for seq_id in device.pre_pulses.seq_in_use:
if seq_id != control_seq_id:
ex_seq = zi_scripts.SIMPLESequence(sequencer_id=seq_id,
awg=device.modem.awg,
awg_amp=1,
use_modulation=True,
pre_pulses=[])
else:
ex_seq = zi_scripts.SIMPLESequence(sequencer_id=seq_id,
awg=device.modem.awg,
awg_amp=1,
use_modulation=True,
pre_pulses=[],
control=True)
control_sequence = ex_seq
device.pre_pulses.set_seq_offsets(ex_seq)
device.pre_pulses.set_seq_prepulses(ex_seq)
ex_seq.start()
ex_sequencers.append(ex_seq)
seeds = np.random.randint(100000,
size=(random_sequence_num, len(qubit_ids),
len(seq_lengths)))
references = {'seeds': seeds}
pi2_bench = interleaved_benchmarking.interleaved_benchmarking(
readout_device,
ex_sequencers,
seeds,
seq_lengths,
interleavers=HZ_group,
random_sequence_num=random_sequence_num,
two_qubit_num=two_qubit_num,
random_gate_num=random_gate_num)
#TODO prepare_seq
prepare_seq = pi2_bench.create_hdawg_generator()
sequence_control.set_preparation_sequence(device, ex_sequencers,
prepare_seq)
#TODO readout sequence
#ro_seq = [device.pg.pmulti(pause_length)]+device.trigger_readout_seq+qubit_readout_pulse.get_pulse_sequence()
readout_sequencer = sequence_control.define_readout_control_seq(
device, qubit_readout_pulse)
readout_sequencer.start()
pi2_bench.random_sequence_num = random_sequence_num
seeds_ids = np.arange(seeds.shape[0])
references = references.update({('pi2_pulse', qubit_id):
pi2_pulses[qubit_id].id
for qubit_id in qubit_ids})
references = references.update({('pi_pulse', qubit_id):
pi_pulses[qubit_id].id
for qubit_id in qubit_ids})
# TODO
# 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([(seeds_ids, pi2_bench.set_interleaved_sequence,
'Random seeds 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, '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, '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
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'])
pi_pulse = excitation_pulse.get_excitation_pulse(device, qubit_id, np.pi)
pi_pulse_length = float(pi_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, length):
fast_control = False
z_pulse = [(c, device.pg.virtual_z, z_phase * 360 / 2 / np.pi,
fast_control) for c, a in channel_amplitudes_.items()]
sequence_z = [device.pg.pmulti(device, length, *tuple(z_pulse))]
return sequence_z
#TODO
qubit_readout_pulse, readout_device = calibrated_readout.get_calibrated_measurer(
device, [qubit_id])
#HZ = {'X': {'pulses': pi_pulse.get_pulse_sequence(0), 'unitary': np.asarray([[0, 1], [1, 0]]), 'price': 1.0},
# 'X/2': {'pulses': pi2_pulse.get_pulse_sequence(0), 'unitary': np.sqrt(0.5) * np.asarray([[1, -1j], [-1j, 1]]), 'price': 1.0},
# '-X/2': {'pulses': pi2_pulse.get_pulse_sequence(np.pi), 'unitary': np.sqrt(0.5) * np.asarray([[1, 1j], [1j, 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': get_pulse_seq_z(0, qubit_id), 'unitary': np.asarray([[1, 0], [0, 1]]), 'price':0.1}
# }
#X_metadata = pi_pulse.metadata()
#X2_metadata = pi2_pulse.metadata()
#X_2_metadata = pi2_pulse.metadata()
#X_2_metadata['amplitude'] = float(a) * float(self.metadata['amplitude']) * np.exp(1j * phase)
HZ = {
'X': {
'pulses': pi_pulse.get_pulse_sequence(0),
'unitary': np.asarray([[0, 1], [1, 0]]),
'price': 1.0
},
'X/2': {
'pulses': pi2_pulse.get_pulse_sequence(0),
'unitary': np.sqrt(0.5) * np.asarray([[1, -1j], [-1j, 1]]),
'price': 1.0
},
'-X/2': {
'pulses': pi2_pulse.get_pulse_sequence(np.pi),
'unitary': np.sqrt(0.5) * np.asarray([[1, 1j], [1j, 1]]),
'price': 1.0
},
'Z': {
'pulses': get_pulse_seq_z(np.pi, pi2_pulse_length),
'unitary': np.asarray([[1, 0], [0, -1]]),
'price': 0.1
},
'Z/2': {
'pulses': get_pulse_seq_z(np.pi / 2, pi2_pulse_length),
'unitary': np.asarray([[1, 0], [0, 1j]]),
'price': 0.1
},
'-Z/2': {
'pulses': get_pulse_seq_z(-np.pi / 2., pi2_pulse_length),
'unitary': np.asarray([[1, 0], [0, -1j]]),
'price': 0.1
},
'I': {
'pulses': get_pulse_seq_z(0, pi2_pulse_length),
'unitary': np.asarray([[1, 0], [0, 1]]),
'price': 0.1
}
}
HZ_group = clifford.generate_group(HZ)
#TODO qubit sequencer
exitation_channel = [
i for i in device.get_qubit_excitation_channel_list(qubit_id).keys()
][0]
ex_channel = device.awg_channels[exitation_channel]
if ex_channel.is_iq():
control_seq_id = ex_channel.parent.sequencer_id
else:
control_seq_id = ex_channel.channel // 2
ex_sequencers = []
for seq_id in device.pre_pulses.seq_in_use:
if seq_id != control_seq_id:
ex_seq = zi_scripts.SIMPLESequence(sequencer_id=seq_id,
awg=device.modem.awg,
awg_amp=1,
use_modulation=True,
pre_pulses=[])
else:
ex_seq = zi_scripts.SIMPLESequence(sequencer_id=seq_id,
awg=device.modem.awg,
awg_amp=1,
use_modulation=True,
pre_pulses=[],
control=True)
control_sequence = ex_seq
device.pre_pulses.set_seq_offsets(ex_seq)
device.pre_pulses.set_seq_prepulses(ex_seq)
ex_seq.start()
ex_sequencers.append(ex_seq)
pi2_bench = interleaved_benchmarking.interleaved_benchmarking(
readout_device, ex_sequencers, HZ_group)
#pi2_bench.interleavers = HZ_group
#TODO prepare_seq
prepare_seq = pi2_bench.create_hdawg_generator()
sequence_control.set_preparation_sequence(device, ex_sequencers,
prepare_seq)
# TODO Readout sequencer
#ro_seq = [device.pg.pmulti(pause_length)]+device.trigger_readout_seq+qubit_readout_pulse.get_pulse_sequence()
readout_sequencer = sequence_control.define_readout_control_seq(
device, qubit_readout_pulse)
readout_sequencer.start()
#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,
'pi_pulse': pi_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
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 two_qubit_gate_channel_amplitudes (device, gate):
return channel_amplitudes.channel_amplitudes(device, **{gate.metadata['carrier_name']: float(gate.metadata['amplitude'])})
