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'])})