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 xeb_single_qubit_rotation(device, qubit_id): from .readout_pulse2 import get_uncalibrated_measurer from qsweepy.qubit_calibrations import excitation_pulse2 as excitation_pulse qubit_readout_pulse, readout_device = get_uncalibrated_measurer(device, qubit_id) rotation = excitation_pulse.get_excitation_pulse(device, qubit_id, np.pi / 2.) random_phase_gats = [] # TODO: define random phase gates for single-qubit XEBs
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_confusion_matrix(device, qubit_ids, pause_length=0, recalibrate=True, force_recalibration=False): qubit_readout_pulse, readout_device = get_calibrated_measurer(device, qubit_ids) # TODO '''Warning''' 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 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)[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(), control_seq=None, # 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 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) # TODO '''Warning''' 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 re_sequence = sequence_control.define_readout_control_seq(device, qubit_readout_pulse) #TODO 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) #sequence_control.set_preparation_sequence(device, ex_sequencers, [other_qubit_pulse_sequence+ # qubit_excitation_pulse.get_pulse_sequence(0)]) def set_target_state(state): re_sequence.awg.stop_seq(re_sequence.params['sequencer_id']) preparation_sequence = [] for _id, qubit_id in enumerate(qubit_ids): qubit_state = (1 << _id) & state if qubit_state: # TODO '''Warning''' preparation_sequence.extend(excitation_pulses[qubit_id].get_pulse_sequence(0)) if middle_seq_generator is not None: # TODO '''Warning''' middle_pulse = middle_seq_generator() preparation_sequence.extend(middle_pulse) else: middle_pulse = [] # TODO '''Warning''' sequence_control.set_preparation_sequence(device, ex_sequencers, preparation_sequence) re_sequence.awg.start_seq(re_sequence.params['sequencer_id']) 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 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: '''Warning''' #TODO 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)) '''Warning''' # TODO 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}) #TODO 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) sequence_control.set_preparation_sequence(device, ex_sequencers, other_qubit_pulse_sequence+ qubit_excitation_pulse.get_pulse_sequence(0)) '''Warning''' #readout_sequencer = sequence_control.define_readout_control_seq(device, readout_channel) #raise ValueError('fallos') re_channel = device.awg_channels[readout_channel] readout_sequencer = zi_scripts.READSequence(re_channel.parent.sequencer_id, device.modem.awg) def_frag, play_frag = device.pg.readout_rect(channel=readout_channel, length=readout_pulse_lengths[0], amplitude=readout_pulse_amplitudes[0]) readout_sequencer.add_readout_pulse(def_frag, play_frag) readout_sequencer.stop() device.modem.awg.set_sequence(readout_sequencer.params['sequencer_id'], readout_sequencer) readout_sequencer.set_delay(device.modem.trigger_channel.delay) readout_sequencer.start() classifier = single_shot_readout.single_shot_readout(device=device, adc=adc, prepare_seqs=[other_qubit_pulse_sequence, other_qubit_pulse_sequence + qubit_excitation_pulse.get_pulse_sequence(0)], ex_seqs=ex_sequencers, ro_seq=readout_sequencer, control_seq=control_sequence, #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 class ParameterSetter: def __init__(self): self.readout_amplitude = 0 self.readout_length = 0 self.channel = readout_channel def set_readout_amplitude(self, x): #nonlocal readout_amplitude self.readout_amplitude = x #classifier.ro_seq = device.trigger_readout_seq + [ # device.pg.p(readout_channel, readout_length, device.pg.rect, readout_amplitude)] classifier.ro_seq.set_awg_amp(x) def set_readout_length(self, x): #nonlocal readout_length self.readout_length = x #classifier.ro_seq = device.trigger_readout_seq + [ # device.pg.p(readout_channel, readout_length, device.pg.rect, readout_amplitude)] classifier.ro_seq.awg.stop_seq(classifier.ro_seq.params['sequencer_id']) def_frag, play_frag = device.pg.readout_rect(channel=self.channel, length=self.readout_length, amplitude=self.readout_amplitude) classifier.ro_seq.clear_readout_pulse() classifier.ro_seq.add_readout_pulse(def_frag, play_frag) device.modem.awg.set_sequence(classifier.ro_seq.params['sequencer_id'], classifier.ro_seq) classifier.ro_seq.awg.start_seq(classifier.ro_seq.params['sequencer_id']) setter = ParameterSetter() try: adc.set_adc_nums(nums) measurement = device.sweeper.sweep(classifier, (readout_pulse_lengths, setter.set_readout_length, 'length', 's'), (readout_pulse_amplitudes, setter.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 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: # TODO '''Warning''' 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)) # TODO '''Warning''' 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}) #TODO 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) sequence_control.set_preparation_sequence(device, ex_sequencers, other_qubit_pulse_sequence+ qubit_excitation_pulse.get_pulse_sequence(0)) '''Warning''' #readout_sequencer = sequence_control.define_readout_control_seq(device, readout_channel) #raise ValueError('fallos') readout_sequencer = sequence_control.define_readout_control_seq(device, qubit_readout_pulse) readout_sequencer.start() classifier = single_shot_readout.single_shot_readout(device=device, adc=adc, prepare_seqs=[other_qubit_pulse_sequence, other_qubit_pulse_sequence + qubit_excitation_pulse.get_pulse_sequence(0)], ex_seqs=ex_sequencers, ro_seq=readout_sequencer, control_seq = control_sequence, #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' 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 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 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) 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) #device.modem.awg.set_sequence(ex_seq.params['sequencer_id'], ex_seq) ex_seq.start() ex_sequencers.append(ex_seq) readout_sequencer = sequence_control.define_readout_control_seq( device, readout_pulse) readout_sequencer.start() class ParameterSetter: def __init__(self): self.ex_sequencers = ex_sequencers self.prepare_seq = [] self.readout_sequencer = readout_sequencer self.delay_seq_generator = delay_seq_generator self.lengths = lengths self.control_sequence = control_sequence # Create preparation sequence self.prepare_seq.extend(ex_pulse.get_pulse_sequence(0)) if self.delay_seq_generator is None: self.prepare_seq.extend([device.pg.pmulti(device, 0)]) self.prepare_seq.extend( [device.pg.pmulti(device, self.lengths)]) self.prepare_seq.extend([device.pg.pmulti(device, 0)]) else: self.pre_pause, self.delay_sequence, self.post_pause = self.delay_seq_generator( self.lengths) self.prepare_seq.extend(self.pre_pause) self.prepare_seq.extend(self.delay_sequence) self.prepare_seq.extend(self.post_pause) # Set preparation sequence sequence_control.set_preparation_sequence(device, self.ex_sequencers, self.prepare_seq) self.readout_sequencer.start() def set_delay(self, length): if self.delay_seq_generator is None: for ex_seq in self.ex_sequencers: ex_seq.set_length(length) else: if length == self.lengths[0]: self.readout_sequencer.awg.stop_seq( self.readout_sequencer.params['sequencer_id']) self.pre_pause, self.delay_sequence, self.post_pause = self.delay_seq_generator( self.lengths) self.prepare_seq[-2] = self.delay_sequence[0] sequence_control.set_preparation_sequence( device, self.ex_sequencers, self.prepare_seq, self.control_sequence) for ex_seq in self.ex_sequencers: ex_seq.set_length(length) self.readout_sequencer.awg.start_seq( self.readout_sequencer.params['sequencer_id']) else: for ex_seq in self.ex_sequencers: ex_seq.set_length(length) setter = ParameterSetter() 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, setter.set_delay, 'Delay', 's'), fitter_arguments=fitter_arguments, measurement_type=measurement_type, metadata=metadata, references=references) return measurement
def Ramsey(device, qubit_id, transition='01', *extra_sweep_args, channel_amplitudes1=None, channel_amplitudes2=None, lengths=None, target_freq_offset=None, readout_delay=0, delay_seq_generator=None, measurement_type='Ramsey', additional_references = {}, additional_metadata = {}): from .readout_pulse2 import get_uncalibrated_measurer 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) ex_pulse1 = excitation_pulse.get_excitation_pulse(device, qubit_id, np.pi/2., channel_amplitudes_override=channel_amplitudes1) ex_pulse2 = excitation_pulse.get_excitation_pulse(device, qubit_id, np.pi/2., channel_amplitudes_override=channel_amplitudes2) 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) #device.modem.awg.set_sequence(ex_seq.params['sequencer_id'], ex_seq) ex_seq.start() ex_sequencers.append(ex_seq) readout_sequencer = sequence_control.define_readout_control_seq(device, readout_pulse) readout_sequencer.start() class ParameterSetter: def __init__(self): self.ex_sequencers=ex_sequencers self.prepare_seq = [] self.readout_sequencer = readout_sequencer self.delay_seq_generator = delay_seq_generator self.lengths = lengths self.control_sequence = control_sequence # Create preparation sequence self.prepare_seq.extend(ex_pulse1.get_pulse_sequence(0)) if self.delay_seq_generator is None: self.prepare_seq.extend([device.pg.pmulti(device, 0)]) self.prepare_seq.extend([device.pg.pmulti(device, self.lengths)]) self.prepare_seq.extend([device.pg.pmulti(device, 0)]) else: self.pre_pause, self.delay_sequence, self.post_pause = self.delay_seq_generator(self.lengths) self.prepare_seq.extend(self.pre_pause) self.prepare_seq.extend(self.delay_sequence) self.prepare_seq.extend(self.post_pause) self.prepare_seq.extend(excitation_pulse.get_s(device, qubit_id, phase=(64/self.control_sequence.clock)*target_freq_offset*360 % 360, fast_control='quasi-binary')) self.prepare_seq.extend(ex_pulse2.get_pulse_sequence(0)) # Set preparation sequence sequence_control.set_preparation_sequence(device, self.ex_sequencers, self.prepare_seq) self.readout_sequencer.start() def set_delay(self, length): phase = int(np.round((length+140e-9)*self.control_sequence.clock)+64)/self.control_sequence.clock*target_freq_offset*360 % 360 #print ('length: ', length, ', phase: ', phase, ', phase register: ', int(phase/360*(2**6))) if self.delay_seq_generator is None: for ex_seq in self.ex_sequencers: ex_seq.set_length(length) self.control_sequence.set_phase(int(phase/360*(2**8))) else: if length == self.lengths[0]: self.readout_sequencer.awg.stop_seq(self.readout_sequencer.params['sequencer_id']) self.pre_pause, self.delay_sequence, self.post_pause = self.delay_seq_generator(self.lengths) self.prepare_seq[-4] = self.delay_sequence[0] #sequence_control.set_preparation_sequence(device, self.ex_sequencers, self.prepare_seq, #self.control_sequence) sequence_control.set_preparation_sequence(device, self.ex_sequencers, self.prepare_seq) for ex_seq in self.ex_sequencers: ex_seq.set_length(length) self.control_sequence.set_phase(int(phase/360*(2**8))) self.readout_sequencer.awg.start_seq(self.readout_sequencer.params['sequencer_id']) else: for ex_seq in self.ex_sequencers: ex_seq.set_length(length) self.control_sequence.set_phase(int(phase/360*(2**8))) def set_delay1(self, length): self.prepare_seq[-2] = excitation_pulse.get_s(device, qubit_id, phase=(int(np.round(length*self.control_sequence.clock)+64)/self.control_sequence.clock)*target_freq_offset*360) if self.delay_seq_generator is None: self.readout_sequencer.awg.stop_seq(self.readout_sequencer.params['sequencer_id']) for ex_seq in self.ex_sequencers: ex_seq.set_length(length) if ex_seq.params['sequencer_id'] == self.control_sequence.params['sequencer_id']: ex_seq.awg.stop_seq(ex_seq.params['sequencer_id']) ex_seq.clear_pulse_sequence() for prep_seq in self.prepare_seq: for seq_id, single_sequence in prep_seq[0].items(): if seq_id == ex_seq.params['sequencer_id']: ex_seq.add_definition_fragment(single_sequence[0]) ex_seq.add_play_fragment(single_sequence[1]) device.modem.awg.set_sequence(ex_seq.params['sequencer_id'], ex_seq) ex_seq.awg.start_seq(ex_seq.params['sequencer_id']) self.readout_sequencer.awg.start_seq(self.readout_sequencer.params['sequencer_id']) else: if length == self.lengths[0]: self.readout_sequencer.awg.stop_seq(self.readout_sequencer.params['sequencer_id']) self.pre_pause, self.delay_sequence, self.post_pause = self.delay_seq_generator(self.lengths) self.prepare_seq[-4] = self.delay_sequence sequence_control.set_preparation_sequence(device, self.ex_sequencers, self.prepare_seq) for ex_seq in self.ex_sequencers: ex_seq.set_length(length) self.readout_sequencer.awg.start_seq(self.readout_sequencer.params['sequencer_id']) else: self.readout_sequencer.awg.stop_seq(self.readout_sequencer.params['sequencer_id']) for ex_seq in self.ex_sequencers: ex_seq.set_length(length) if ex_seq.params['sequencer_id'] == self.control_sequence.params['sequencer_id']: ex_seq.awg.stop_seq(ex_seq.params['sequencer_id']) ex_seq.clear_pulse_sequence() for prep_seq in self.prepare_seq: for seq_id, single_sequence in prep_seq[0].items(): if seq_id == ex_seq.params['sequencer_id']: ex_seq.add_definition_fragment(single_sequence[0]) ex_seq.add_play_fragment(single_sequence[1]) device.modem.awg.set_sequence(ex_seq.params['sequencer_id'], ex_seq) ex_seq.awg.start_seq(ex_seq.params['sequencer_id']) self.readout_sequencer.awg.start_seq(self.readout_sequencer.params['sequencer_id']) setter = ParameterSetter() references = {'ex_pulse1':ex_pulse1.id, 'ex_pulse2':ex_pulse2.id, 'frequency_controls':device.get_frequency_control_measurement_id(qubit_id=qubit_id), 'readout_pulse':readout_pulse.id } references.update(additional_references) if hasattr(measurer, 'references'): references.update(measurer.references) fitter_arguments = ('iq'+qubit_id, exp_sin_fitter(), -1, np.arange(len(extra_sweep_args))) metadata = {'qubit_id': qubit_id, 'transition': transition, '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, setter.set_delay, 'Delay','s'), fitter_arguments = fitter_arguments, measurement_type=measurement_type, metadata=metadata, references=references, on_update_divider=10) for ex_seq in ex_sequencers: ex_seq.stop() readout_sequencer.stop() return measurement
def Ramsey_process(device, qubit_id1, qubit_id2, process, channel_amplitudes1=None, channel_amplitudes2=None): ''' :param device QubitDevice: ''' from .readout_pulse2 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) #TODO #New sequencer exitation_channel = [i for i in device.get_qubit_excitation_channel_list(qubit_id1).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_sequencers.append(ex_seq) # Create preparation sequence prepare_seq = [] prepare_seq.extend(ex_pulse1.get_pulse_sequence(0)) # prepare_seq.append(excitation_pulse.get_s(device, qubit_id, # phase=(round(float(ex_pulse1.metadata['length'])*control_sequence.clock/32)*32/control_sequence.clock)*target_freq_offset*360)) prepare_seq.extend(process.get_pulse_sequence()) prepare_seq.extend(excitation_pulse.get_s(device, qubit_id2, phase=phases[0]/2/np.pi*360,)) prepare_seq.extend(ex_pulse2.get_pulse_sequence(0)) # Set preparation sequence sequence_control.set_preparation_sequence(device, ex_sequencers, prepare_seq) readout_sequencer = sequence_control.define_readout_control_seq(device, readout_pulse) readout_sequencer.start() def set_phase(phase): readout_sequencer.awg.stop_seq(readout_sequencer.params['sequencer_id']) for ex_seq in ex_sequencers: ex_seq.clear_pulse_sequence() prepare_seq[-2] = excitation_pulse.get_s(device, qubit_id2, phase=phase / 2 / np.pi * 360) sequence_control.set_preparation_sequence(device, ex_sequencers, prepare_seq) readout_sequencer.awg.start_seq(readout_sequencer.params['sequencer_id']) 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 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_pulse2 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 echo_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_pulse_pi = excitation_pulse.get_excitation_pulse( device, qubit_id1, np.pi, 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_pulse_pi(phase) + 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_pulse_pi': ex_pulse_pi.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='echo_process', metadata=metadata, references=references) return measurement