def four_qubit_off_on( q0_pulse_pars, q1_pulse_pars, q2_pulse_pars, q3_pulse_pars, RO_pars, return_seq=False, verbose=False ): seq_name = "4_qubit_OffOn_sequence" seq = sequence.Sequence(seq_name) station.pulsar.update_channel_settings() el_list = [] # Create a dict with the parameters for all the pulses q0_pulses = add_suffix_to_dict_keys(get_pulse_dict_from_pars(q0_pulse_pars), " q0") q1_pulses = add_suffix_to_dict_keys(get_pulse_dict_from_pars(q1_pulse_pars), " q1") q2_pulses = add_suffix_to_dict_keys(get_pulse_dict_from_pars(q2_pulse_pars), " q2") q3_pulses = add_suffix_to_dict_keys(get_pulse_dict_from_pars(q3_pulse_pars), " q3") RO_dict = {"RO": RO_pars} pulse_dict = {} pulse_dict.update(q0_pulses) pulse_dict.update(q1_pulses) pulse_dict.update(q2_pulses) pulse_dict.update(q3_pulses) pulse_dict.update(RO_dict) # N.B. Identities not needed in all cases pulse_combinations = [ ["I q0", "I q1", "I q2", "I q3", "RO"], ["X180 q0", "I q1", "I q2", "I q3", "RO"], ["I q0", "X180 q1", "I q2", "I q3", "RO"], ["X180 q0", "X180 q1", "I q2", "I q3", "RO"], ["I q0", "I q1", "X180 q2", "I q3", "RO"], ["X180 q0", "I q1", "X180 q2", "I q3", "RO"], ["I q0", "X180 q1", "X180 q2", "I q3", "RO"], ["X180 q0", "X180 q1", "X180 q2", "I q3", "RO"], ["I q0", "I q1", "I q2", "X180 q3", "RO"], ["X180 q0", "I q1", "I q2", "X180 q3", "RO"], ["I q0", "X180 q1", "I q2", "X180 q3", "RO"], ["X180 q0", "X180 q1", "I q2", "X180 q3", "RO"], ["I q0", "I q1", "X180 q2", "X180 q3", "RO"], ["X180 q0", "I q1", "X180 q2", "X180 q3", "RO"], ["I q0", "X180 q1", "X180 q2", "X180 q3", "RO"], ["X180 q0", "X180 q1", "X180 q2", "X180 q3", "RO"], ] for i, pulse_comb in enumerate(pulse_combinations): pulses = [] for p in pulse_comb: pulses += [pulse_dict[p]] el = multi_pulse_elt(i, station, pulses) el_list.append(el) seq.append_element(el, trigger_wait=True) station.components["AWG"].stop() station.pulsar.program_awg(seq, *el_list, verbose=verbose) if return_seq: return seq, el_list else: return seq_name
def GST_from_textfile(pulse_pars, RO_pars, filename, upload=True, seq_name=None, verbose=False): ''' Input pars: pulse_pars: dict containing the pulse parameters RO_pars: dict containing the RO parameters filename: name of a pygsti generated text file upload: upload to AWG or not, if returns seq, el_list ''' if seq_name is None: seq_name = 'GST_seq' seq = sequence.Sequence(seq_name) station.pulsar.update_channel_settings() el_list = [] # Create a dict with the parameters for all the pulses pulse_dict = get_pulse_dict_from_pars(pulse_pars) pulse_dict['RO'] = RO_pars pulse_combinations = create_experiment_list_pyGSTi_general(filename) for i, pulse_comb in enumerate(pulse_combinations): pulse_list = [] for pulse_key in pulse_comb: pulse_list += [pulse_dict[pulse_key]] el = multi_pulse_elt(i, station, pulse_list) el_list.append(el) seq.append_element(el, trigger_wait=True) if upload: station.components['AWG'].stop() station.pulsar.program_awg(seq, *el_list, verbose=verbose) return seq, el_list
def Ramsey_2nd_exc_seq(times, pulse_pars, pulse_pars_2nd, RO_pars, n=1, cal_points=True, post_msmt_delay=3e-6, verbose=False): ''' Rabi sequence for the second excited state Input pars: amps: array of pulse amplitudes (V) pulse_pars: dict containing the pulse parameters pulse_pars_2nd: dict containing pulse_parameters for 2nd exc. state RO_pars: dict containing the RO parameters n: number of pulses (1 is conventional Rabi) post_msmt_delay: extra wait time for resetless compatibility ''' seq_name = 'Ramsey_2nd_exc_sequence' seq = sequence.Sequence(seq_name) station.pulsar.update_channel_settings() el_list = [] pulses = get_pulse_dict_from_pars(pulse_pars) pulses_2nd = get_pulse_dict_from_pars(pulse_pars_2nd) for i, tau in enumerate(times): if cal_points and (i == (len(times)-6) or i == (len(times)-5)): el = multi_pulse_elt(i, station, [pulses['I'], RO_pars]) elif cal_points and (i == (len(times)-4) or i == (len(times)-3)): el = multi_pulse_elt(i, station, [pulses['X180'], RO_pars]) elif cal_points and (i == (len(times)-2) or i == (len(times)-1)): el = multi_pulse_elt(i, station, [pulses['X180'], pulses['X180'], RO_pars]) else: pulse_pars_x2 = deepcopy(pulses_2nd['X90']) pulse_pars_x2['pulse_delay'] = tau pulse_list = ([pulses['X180']]+n*[pulses_2nd['X90'], pulse_pars_x2] + [pulses['X180'], RO_pars]) # copy first element and set extra wait pulse_list[0] = deepcopy(pulse_list[0]) pulse_list[0]['pulse_delay'] += post_msmt_delay el = multi_pulse_elt(i, station, pulse_list) el_list.append(el) seq.append_element(el, trigger_wait=True) station.components['AWG'].stop() station.pulsar.program_awg(seq, *el_list, verbose=verbose) return seq_name
def SSRO_2nd_exc_state(pulse_pars, pulse_pars_2nd, RO_pars, verbose=False): seq_name = 'SSRO_2nd_exc' seq = sequence.Sequence(seq_name) station.pulsar.update_channel_settings() el_list = [] pulses = get_pulse_dict_from_pars(pulse_pars) pulses_2nd = get_pulse_dict_from_pars(pulse_pars_2nd) # First element pulse_combinations = [[pulses['I']] + [RO_pars]] pulse_combinations += [[pulses['X180']] + [RO_pars]] pulse_combinations += [[pulses['X180']] + [pulses_2nd['X180']] + [RO_pars]] for i, pulse_list in enumerate(pulse_combinations): el = multi_pulse_elt(i, station, pulse_list) el_list.append(el) seq.append_element(el, trigger_wait=True) seq.append_element(el, trigger_wait=True) station.pulsar.program_awgs(seq, *el_list, verbose=verbose) return seq_name
def SSRO_2nd_exc_state(pulse_pars, pulse_pars_2nd, RO_pars, verbose=False): seq_name = 'SSRO_2nd_exc' seq = sequence.Sequence(seq_name) station.pulsar.update_channel_settings() el_list = [] pulses = get_pulse_dict_from_pars(pulse_pars) pulses_2nd = get_pulse_dict_from_pars(pulse_pars_2nd) # First element pulse_combinations = [[pulses['I']]+[RO_pars]] pulse_combinations += [[pulses['X180']] +[RO_pars]] pulse_combinations += [[pulses['X180']]+[pulses_2nd['X180']] +[RO_pars]] for i, pulse_list in enumerate(pulse_combinations): el = multi_pulse_elt(i, station, pulse_list) el_list.append(el) seq.append_element(el, trigger_wait=True) seq.append_element(el, trigger_wait=True) station.components['AWG'].stop() station.pulsar.program_awg(seq, *el_list, verbose=verbose) return seq_name
def two_qubit_off_on(q0_pulse_pars, q1_pulse_pars, RO_pars, return_seq=False, verbose=False): seq_name = '2_qubit_OffOn_sequence' seq = sequence.Sequence(seq_name) station.pulsar.update_channel_settings() el_list = [] # Create a dict with the parameters for all the pulses q0_pulses = add_suffix_to_dict_keys( get_pulse_dict_from_pars(q0_pulse_pars), ' q0') q1_pulses = add_suffix_to_dict_keys( get_pulse_dict_from_pars(q1_pulse_pars), ' q1') RO_dict = {'RO': RO_pars} pulse_dict = {} pulse_dict.update(q0_pulses) pulse_dict.update(q1_pulses) pulse_dict.update(RO_dict) # N.B. Identities not needed in all cases pulse_combinations = [['I q0', 'I q1', 'RO'], ['X180 q0', 'I q1', 'RO'], ['I q0', 'X180 q1', 'RO'], ['X180 q0', 'X180 q1', 'RO']] for i, pulse_comb in enumerate(pulse_combinations): pulses = [] for p in pulse_comb: pulses += [pulse_dict[p]] el = multi_pulse_elt(i, station, pulses) el_list.append(el) seq.append_element(el, trigger_wait=True) station.pulsar.program_awgs(seq, *el_list, verbose=verbose) if return_seq: return seq, el_list else: return seq_name
def n_qubit_off_on(pulse_pars_list, RO_pars, return_seq=False, verbose=False, parallel_pulses=False, preselection=False, RO_spacing=200e-9): n = len(pulse_pars_list) seq_name = '{}_qubit_OffOn_sequence'.format(n) seq = sequence.Sequence(seq_name) el_list = [] # Create a dict with the parameters for all the pulses pulse_dict = {'RO': RO_pars} for i, pulse_pars in enumerate(pulse_pars_list): pars = pulse_pars.copy() if i != 0 and parallel_pulses: pars['refpoint'] = 'start' pulses = add_suffix_to_dict_keys( get_pulse_dict_from_pars(pars), ' {}'.format(i)) pulse_dict.update(pulses) spacerpulse = {'pulse_type': 'SquarePulse', 'channel': RO_pars['acq_marker_channel'], 'amplitude': 0.0, 'length': RO_spacing, 'pulse_delay': 0} pulse_dict.update({'spacer': spacerpulse}) # Create a list of required pulses pulse_combinations = [] for pulse_list in itertools.product(*(n*[['I', 'X180']])): pulse_comb = (n+1)*[''] for i, pulse in enumerate(pulse_list): pulse_comb[i] = pulse + ' {}'.format(i) pulse_comb[-1] = 'RO' if preselection: pulse_comb = ['RO', 'spacer'] + pulse_comb pulse_combinations.append(pulse_comb) for i, pulse_comb in enumerate(pulse_combinations): pulses = [] for j, p in enumerate(pulse_comb): pulses += [pulse_dict[p]] el = multi_pulse_elt(i, station, pulses) el_list.append(el) seq.append_element(el, trigger_wait=True) station.pulsar.program_awgs(seq, *el_list, verbose=verbose) if return_seq: return seq, el_list else: return seq_name
def get_pulse_dict(self, pulse_dict={}): ''' Returns a dictionary containing the pulse parameters of the qubit. This function is intended to replace the old get_pulse_pars. Dictionary contains the keys formatted as follows: operation self.name Input args: pulse_dict (dict): Optionally specify an existing pulse dict to update (currently only contains single qubit pulses) ''' drive_pars, RO_pars = self.get_pulse_pars() pulse_dict.update(add_suffix_to_dict_keys( sq.get_pulse_dict_from_pars(drive_pars), ' ' + self.name)) pulse_dict.update({'RO {}'.format(self.name): RO_pars}) spec_pars, RO_pars = self.get_spec_pars() pulse_dict.update({'Spec {}'.format(self.name): spec_pars}) return pulse_dict
def capacity_tomo_seq(bases, states, idle_time, pulse_pars, RO_pars, upload=True, verbose=False): """ input pars bases list of ints: 0 - Z-basis 1 - X-basis 2 - Y-basis states (list of ints): 0 - |0> 1 - |1> idle_time (s) """ assert(len(bases) == len(states)) seq_name = 'Capacity_tomo_seq' seq = sequence.Sequence(seq_name) el_list = [] # Create a dict with the parameters for all the pulses pulse_dict = get_pulse_dict_from_pars(pulse_pars) pulse_dict['I']['pulse_delay'] = idle_time pulse_dict['RO'] = RO_pars pulse_combinations = [['I', 'RO'], ['X180', 'I', 'RO'], ['Y90', 'I', 'mY90', 'RO'], ['mY90', 'I', 'mY90', 'RO'], ['X90', 'I', 'mX90', 'RO'], ['mX90', 'I', 'mX90', 'RO']] # Creates elements containing the primitive pulse sequences for i, pulse_comb in enumerate(pulse_combinations): pulse_list = [] for pulse_key in pulse_comb: pulse_list += [pulse_dict[pulse_key]] el = multi_pulse_elt(i, station, pulse_list) el_list.append(el) seq_idx = [] # Selects the corresponding pulse combination for basis, state in zip(bases, states): if state not in [0, 1]: raise ValueError('state {} not recognized'.format(state)) if basis == 0: # computational(Z)-basis if state == 0: seq_idx += [0] elif state == 1: seq_idx += [1] elif basis == 1: # X basis if state == 0: seq_idx += [2] if state == 1: seq_idx += [3] elif basis == 2: # Y basis if state == 0: seq_idx += [4] if state == 1: seq_idx += [5] else: raise ValueError('basis {} not recognized'.formate(basis)) # Creates a sequence by selecting the right primitive element for i, idx in enumerate(seq_idx): seq.append(name='elt_{}'.format(i), wfname=el_list[idx].name, trigger_wait=True) if upload: station.components['AWG'].stop() station.pulsar.program_awg(seq, *el_list, verbose=verbose) return seq, el_list
def cphase_fringes(phases, q0_pulse_pars, q1_pulse_pars, RO_pars, swap_pars_q0, cphase_pars_q1, timings_dict, distortion_dict, verbose=False, upload=True, return_seq=False): ''' ''' preloaded_kernels_vec = preload_kernels_func(distortion_dict) original_delay = deepcopy(RO_pars)[0]['pulse_delay'] seq_name = 'CPhase' seq = sequence.Sequence(seq_name) station.pulsar.update_channel_settings() el_list = [] # print(q0_pulse_pars) q0_pulses = add_suffix_to_dict_keys( get_pulse_dict_from_pars(q0_pulse_pars[0]), ' q0') q1_pulses = add_suffix_to_dict_keys( get_pulse_dict_from_pars(q1_pulse_pars[0]), ' q1') pulse_dict = {} pulse_dict.update(q0_pulses) pulse_dict.update(q1_pulses) pulse_dict.update({'RO': RO_pars[0]}) # print({'RO': RO_pars}) # Timings buffer_mw_flux = timings_dict[0]['buffer_mw_flux'] buffer_flux_mw = timings_dict[0]['buffer_flux_mw'] msmt_buffer = timings_dict[0]['msmt_buffer'] dead_time = timings_dict[0]['dead_time'] # print(buffer_mw_flux,buffer_flux_mw,msmt_buffer,dead_time) # defining main pulses exc_pulse = deepcopy(pulse_dict['X180 q0']) exc_pulse['pulse_delay'] += 0.01e-6 swap_pulse_1 = deepcopy(swap_pars_q0[0]) # print(swap_pulse_1) swap_pulse_1['pulse_delay'] = buffer_mw_flux + \ exc_pulse['sigma']*exc_pulse['nr_sigma'] ramsey_1 = deepcopy(pulse_dict['Y90 q1']) ramsey_1['pulse_delay'] = buffer_flux_mw + swap_pulse_1['length'] cphase_pulse = cphase_pars_q1[0] cphase_amp = cphase_pulse['amplitude'] cphase_pulse['pulse_delay'] = buffer_mw_flux + \ ramsey_1['sigma']*ramsey_1['nr_sigma'] ramsey_2 = deepcopy(pulse_dict['X90 q1']) ramsey_2['pulse_delay'] = buffer_flux_mw + cphase_pulse['length'] swap_pulse_2 = deepcopy(swap_pars_q0[0]) swap_pulse_2['pulse_delay'] = buffer_mw_flux + \ ramsey_2['sigma']*ramsey_2['nr_sigma'] RO_pars[0]['pulse_delay'] = msmt_buffer + swap_pulse_2['length'] # defining compensation pulses swap_comp_1 = deepcopy(swap_pulse_1) swap_pulse_1['pulse_delay'] = RO_pars[0]['length'] + dead_time cphase_comp = deepcopy(cphase_pulse) swap_comp_2 = deepcopy(swap_pulse_2) dead_time_pulse = {'pulse_type': 'SquarePulse', 'pulse_delay': RO_pars[0]['pulse_delay'], 'channel': swap_pars_q0[0]['channel'], 'amplitude': 0, 'length': dead_time} for i, ph2 in enumerate(phases[0]): # print(ph2) ramsey_2['phase'] = ph2 cphase_pulse['amplitude'] = cphase_amp pulse_list = [exc_pulse, swap_pulse_1, ramsey_1, cphase_pulse, ramsey_2, swap_pulse_2, RO_pars[0], swap_comp_1, cphase_comp, swap_comp_2, dead_time_pulse] el = multi_pulse_elt(2*i, station, pulse_list) el_list.append(el) cphase_pulse['amplitude'] = 0. pulse_list = [exc_pulse, swap_pulse_1, ramsey_1, cphase_pulse, ramsey_2, swap_pulse_2, RO_pars[0], swap_comp_1, cphase_comp, swap_comp_2, dead_time_pulse] el = multi_pulse_elt(2*i+1, station, pulse_list) el_list.append(el) # Compensations for i, el in enumerate(el_list): if distortion_dict is not None: el = distort_and_compensate( el, distortion_dict, preloaded_kernels_vec) el_list[i] = el seq.append_element(el, trigger_wait=True) cal_points = 4 RO_pars[0]['pulse_delay'] = original_delay # Calibration points cal_points = [['I q0', 'I q1', 'RO'], ['I q0', 'I q1', 'RO'], ['X180 q0', 'I q1', 'RO'], ['X180 q0', 'I q1', 'RO'], ['I q0', 'X180 q1', 'RO'], ['I q0', 'X180 q1', 'RO'], ['X180 q0', 'X180 q1', 'RO'], ['X180 q0', 'X180 q1', 'RO']] for i, pulse_comb in enumerate(cal_points): pulses = [] for p in pulse_comb: pulses += [pulse_dict[p]] pulses[0]['pulse_delay'] += 0.01e-6 el = multi_pulse_elt(2*len(phases)+i, station, pulses) el_list.append(el) seq.append_element(el, trigger_wait=True) # upload if upload: station.pulsar.program_awgs(seq, *el_list, verbose=verbose) if return_seq: return seq, el_list else: return seq
def two_qubit_tomo_cardinal(cardinal, q0_pulse_pars, q1_pulse_pars, RO_pars, timings_dict, verbose=False, upload=True, return_seq=False): seq_name = '2_qubit_Card_%d_seq' % cardinal seq = sequence.Sequence(seq_name) station.pulsar.update_channel_settings() el_list = [] # Create a dict with the parameters for all the pulses q0_pulses = add_suffix_to_dict_keys( get_pulse_dict_from_pars(q0_pulse_pars), ' q0') q1_pulses = add_suffix_to_dict_keys( get_pulse_dict_from_pars(q1_pulse_pars), ' q1') RO_dict = {'RO': RO_pars} pulse_dict = {} pulse_dict.update(q0_pulses) pulse_dict.update(q1_pulses) pulse_dict.update(RO_dict) # Timings # FIXME: This dictionary should not be required? -MAR # NOTE: required in the CPhase tomo as input but not used QQ_buffer = timings_dict['QQ_buffer'] wait_time = timings_dict['wait_time'] msmt_buffer = timings_dict['msmt_buffer'] tomo_list_q0 = ['I q0', 'X180 q0', 'Y90 q0', 'mY90 q0', 'X90 q0', 'mX90 q0'] tomo_list_q1 = ['I q1', 'X180 q1', 'Y90 q1', 'mY90 q1', 'X90 q1', 'mX90 q1'] # inner loop on q0 prep_idx_q0 = int(cardinal % 6) prep_idx_q1 = int(((cardinal - prep_idx_q0)/6) % 6) prep_pulse_q0 = pulse_dict[tomo_list_q0[prep_idx_q0]] prep_pulse_q1 = pulse_dict[tomo_list_q1[prep_idx_q1]] prep_pulse_q1['pulse_delay'] = QQ_buffer + (prep_pulse_q0['sigma'] * prep_pulse_q0['nr_sigma']) RO_pars['pulse_delay'] += msmt_buffer - (prep_pulse_q1['sigma'] * prep_pulse_q1['nr_sigma']) # Calibration points cal_points = [['I q0', 'I q1', 'RO'], ['I q0', 'I q1', 'RO'], ['I q0', 'I q1', 'RO'], ['I q0', 'I q1', 'RO'], ['I q0', 'I q1', 'RO'], ['I q0', 'I q1', 'RO'], ['I q0', 'I q1', 'RO'], ['X180 q0', 'I q1', 'RO'], ['X180 q0', 'I q1', 'RO'], ['X180 q0', 'I q1', 'RO'], ['X180 q0', 'I q1', 'RO'], ['X180 q0', 'I q1', 'RO'], ['X180 q0', 'I q1', 'RO'], ['X180 q0', 'I q1', 'RO'], ['I q0', 'X180 q1', 'RO'], ['I q0', 'X180 q1', 'RO'], ['I q0', 'X180 q1', 'RO'], ['I q0', 'X180 q1', 'RO'], ['I q0', 'X180 q1', 'RO'], ['I q0', 'X180 q1', 'RO'], ['I q0', 'X180 q1', 'RO'], ['X180 q0', 'X180 q1', 'RO'], ['X180 q0', 'X180 q1', 'RO'], ['X180 q0', 'X180 q1', 'RO'], ['X180 q0', 'X180 q1', 'RO'], ['X180 q0', 'X180 q1', 'RO'], ['X180 q0', 'X180 q1', 'RO'], ['X180 q0', 'X180 q1', 'RO']] for i in range(36): tomo_idx_q0 = int(i % 6) tomo_idx_q1 = int(((i - tomo_idx_q0)/6) % 6) # print(i,tomo_idx_q0,tomo_idx_q1) tomo_pulse_q0 = pulse_dict[tomo_list_q0[tomo_idx_q0]] tomo_pulse_q1 = pulse_dict[tomo_list_q1[tomo_idx_q1]] tomo_pulse_q0['pulse_delay'] = wait_time + (prep_pulse_q1['sigma'] * prep_pulse_q1['nr_sigma']) tomo_pulse_q1['pulse_delay'] = QQ_buffer + (tomo_pulse_q0['sigma'] * tomo_pulse_q0['nr_sigma']) pulse_list = [prep_pulse_q0, prep_pulse_q1, tomo_pulse_q0, tomo_pulse_q1, RO_pars] el = multi_pulse_elt(i, station, pulse_list) el_list.append(el) seq.append_element(el, trigger_wait=True) for i, pulse_comb in enumerate(cal_points): pulses = [] for p in pulse_comb: pulses += [pulse_dict[p]] el = multi_pulse_elt(35+i, station, pulses) el_list.append(el) seq.append_element(el, trigger_wait=True) station.pulsar.program_awgs(seq, *el_list, verbose=verbose) if return_seq: return seq, el_list else: return seq_name
def two_qubit_tomo_cardinal( cardinal, q0_pulse_pars, q1_pulse_pars, RO_pars, timings_dict, verbose=False, upload=True, return_seq=False ): seq_name = "2_qubit_Card_%d_seq" % cardinal seq = sequence.Sequence(seq_name) station.pulsar.update_channel_settings() el_list = [] # Create a dict with the parameters for all the pulses q0_pulses = add_suffix_to_dict_keys(get_pulse_dict_from_pars(q0_pulse_pars), " q0") q1_pulses = add_suffix_to_dict_keys(get_pulse_dict_from_pars(q1_pulse_pars), " q1") RO_dict = {"RO": RO_pars} pulse_dict = {} pulse_dict.update(q0_pulses) pulse_dict.update(q1_pulses) pulse_dict.update(RO_dict) # Timings QQ_buffer = timings_dict["QQ_buffer"] wait_time = timings_dict["wait_time"] msmt_buffer = timings_dict["msmt_buffer"] tomo_list_q0 = ["I q0", "X180 q0", "Y90 q0", "mY90 q0", "X90 q0", "mX90 q0"] tomo_list_q1 = ["I q1", "X180 q1", "Y90 q1", "mY90 q1", "X90 q1", "mX90 q1"] # inner loop on q0 prep_idx_q0 = int(cardinal % 6) prep_idx_q1 = int(((cardinal - prep_idx_q0) / 6) % 6) prep_pulse_q0 = pulse_dict[tomo_list_q0[prep_idx_q0]] prep_pulse_q1 = pulse_dict[tomo_list_q1[prep_idx_q1]] prep_pulse_q1["pulse_delay"] = QQ_buffer + (prep_pulse_q0["sigma"] * prep_pulse_q0["nr_sigma"]) RO_pars["pulse_delay"] += msmt_buffer - (prep_pulse_q1["sigma"] * prep_pulse_q1["nr_sigma"]) # Calibration points cal_points = [ ["I q0", "I q1", "RO"], ["I q0", "I q1", "RO"], ["I q0", "I q1", "RO"], ["I q0", "I q1", "RO"], ["I q0", "I q1", "RO"], ["I q0", "I q1", "RO"], ["I q0", "I q1", "RO"], ["X180 q0", "I q1", "RO"], ["X180 q0", "I q1", "RO"], ["X180 q0", "I q1", "RO"], ["X180 q0", "I q1", "RO"], ["X180 q0", "I q1", "RO"], ["X180 q0", "I q1", "RO"], ["X180 q0", "I q1", "RO"], ["I q0", "X180 q1", "RO"], ["I q0", "X180 q1", "RO"], ["I q0", "X180 q1", "RO"], ["I q0", "X180 q1", "RO"], ["I q0", "X180 q1", "RO"], ["I q0", "X180 q1", "RO"], ["I q0", "X180 q1", "RO"], ["X180 q0", "X180 q1", "RO"], ["X180 q0", "X180 q1", "RO"], ["X180 q0", "X180 q1", "RO"], ["X180 q0", "X180 q1", "RO"], ["X180 q0", "X180 q1", "RO"], ["X180 q0", "X180 q1", "RO"], ["X180 q0", "X180 q1", "RO"], ] for i in range(36): tomo_idx_q0 = int(i % 6) tomo_idx_q1 = int(((i - tomo_idx_q0) / 6) % 6) # print(i,tomo_idx_q0,tomo_idx_q1) tomo_pulse_q0 = pulse_dict[tomo_list_q0[tomo_idx_q0]] tomo_pulse_q1 = pulse_dict[tomo_list_q1[tomo_idx_q1]] tomo_pulse_q0["pulse_delay"] = wait_time + (prep_pulse_q1["sigma"] * prep_pulse_q1["nr_sigma"]) tomo_pulse_q1["pulse_delay"] = QQ_buffer + (tomo_pulse_q0["sigma"] * tomo_pulse_q0["nr_sigma"]) pulse_list = [prep_pulse_q0, prep_pulse_q1, tomo_pulse_q0, tomo_pulse_q1, RO_pars] pulse_list[0]["pulse_delay"] += 0.01e-6 el = multi_pulse_elt(i, station, pulse_list) el_list.append(el) seq.append_element(el, trigger_wait=True) for i, pulse_comb in enumerate(cal_points): pulses = [] for p in pulse_comb: pulses += [pulse_dict[p]] pulses[0]["pulse_delay"] += 0.01e-6 el = multi_pulse_elt(35 + i, station, pulses) el_list.append(el) seq.append_element(el, trigger_wait=True) station.components["AWG"].stop() station.pulsar.program_awg(seq, *el_list, verbose=verbose) if return_seq: return seq, el_list else: return seq_name
def two_qubit_AllXY( q0_pulse_pars, q1_pulse_pars, RO_pars, double_points=True, verbose=False, upload=True, return_seq=False ): """ Performs an AllXY on the first qubit will doing a pi-pulse before and after the AllXY on the second qubit AllXY q0 - RO X180 q1 - AllXY q0 - X180 q1 - RO """ seq_name = "2_qubit_AllXY_sequence" seq = sequence.Sequence(seq_name) station.pulsar.update_channel_settings() el_list = [] # Create a dict with the parameters for all the pulses q0_pulses = add_suffix_to_dict_keys(get_pulse_dict_from_pars(q0_pulse_pars), " q0") q1_pulses = add_suffix_to_dict_keys(get_pulse_dict_from_pars(q1_pulse_pars), " q1") RO_dict = {"RO": RO_pars} pulse_dict = {} pulse_dict.update(q0_pulses) pulse_dict.update(q1_pulses) pulse_dict.update(RO_dict) AllXY_pulse_combinations = [ ["I q0", "I q0"], ["X180 q0", "X180 q0"], ["Y180 q0", "Y180 q0"], ["X180 q0", "Y180 q0"], ["Y180 q0", "X180 q0"], ["X90 q0", "I q0"], ["Y90 q0", "I q0"], ["X90 q0", "Y90 q0"], ["Y90 q0", "X90 q0"], ["X90 q0", "Y180 q0"], ["Y90 q0", "X180 q0"], ["X180 q0", "Y90 q0"], ["Y180 q0", "X90 q0"], ["X90 q0", "X180 q0"], ["X180 q0", "X90 q0"], ["Y90 q0", "Y180 q0"], ["Y180 q0", "Y90 q0"], ["X180 q0", "I q0"], ["Y180 q0", "I q0"], ["X90 q0", "X90 q0"], ["Y90 q0", "Y90 q0"], ] if double_points: AllXY_pulse_combinations = [val for val in AllXY_pulse_combinations for _ in (0, 1)] pulse_list = [] for pulse_comb in AllXY_pulse_combinations: pulse_list += [pulse_comb + ["RO"]] for pulse_comb in AllXY_pulse_combinations: pulse_list += [["X180 q1"] + pulse_comb + ["X180 q1", "RO"]] for i, pulse_comb in enumerate(pulse_list): pulses = [] for p in pulse_comb: pulses += [pulse_dict[p]] el = multi_pulse_elt(i, station, pulses) el_list.append(el) seq.append_element(el, trigger_wait=True) station.components["AWG"].stop() station.pulsar.program_awg(seq, *el_list, verbose=verbose) if return_seq: return seq, el_list else: return seq_name
def echo_2nd_exc_seq(times, pulse_pars, pulse_pars_2nd, RO_pars, cal_points=True, no_cal_points=6, artificial_detuning=None, verbose=False, upload=True, return_seq=False, last_ge_pulse=True): raise NotImplementedError( 'echo_2nd_exc_seq has not been ' 'converted to the latest waveform generation code and can not be used.') seq_name = 'Echo_2nd_exc_sequence' seq = sequence.Sequence(seq_name) el_list = [] pulses = get_pulse_dict_from_pars(pulse_pars) pulses_2nd = get_pulse_dict_from_pars(pulse_pars_2nd) center_X180ef = deepcopy(pulses_2nd['X180']) final_X90ef = deepcopy(pulses_2nd['X90']) center_X180ef['ref_point'] = 'start' final_X90ef['ref_point'] = 'start' for i, tau in enumerate(times): center_X180ef['pulse_delay'] = tau/2 final_X90ef['pulse_delay'] = tau/2 if artificial_detuning is not None: final_X90ef['phase'] = (tau-times[0]) * artificial_detuning * 360 if cal_points and no_cal_points == 6 and \ (i == (len(times)-6) or i == (len(times)-5)): el = multi_pulse_elt(i, station, [pulses['I'], pulses_2nd['I'], RO_pars]) elif cal_points and no_cal_points == 6 and \ (i == (len(times)-4) or i == (len(times)-3)): el = multi_pulse_elt(i, station, [pulses['X180'], pulses_2nd['I'], RO_pars]) elif cal_points and no_cal_points == 6 and \ (i == (len(times)-2) or i == (len(times)-1)): el = multi_pulse_elt(i, station, [pulses['X180'], pulses_2nd['X180'], RO_pars]) elif cal_points and no_cal_points == 4 and \ (i == (len(times)-4) or i == (len(times)-3)): el = multi_pulse_elt(i, station, [pulses['I'], pulses_2nd['I'], RO_pars]) elif cal_points and no_cal_points == 4 and \ (i == (len(times)-2) or i == (len(times)-1)): el = multi_pulse_elt(i, station, [pulses['X180'], pulses_2nd['I'], RO_pars]) elif cal_points and no_cal_points == 2 and \ (i == (len(times)-2) or i == (len(times)-1)): el = multi_pulse_elt(i, station, [pulses['I'], pulses_2nd['I'], RO_pars]) else: pulse_list = [pulses['X180'], pulses_2nd['X90'], center_X180ef, final_X90ef] if last_ge_pulse: pulse_list += [pulses['X180']] pulse_list += [RO_pars] el = multi_pulse_elt(i, station, pulse_list) el_list.append(el) seq.append_element(el, trigger_wait=True) if upload: station.pulsar.program_awgs(seq, *el_list, verbose=verbose) if return_seq: return seq_name, el_list else: return seq
def readout_pulse_scope_seq(delays, pulse_pars, RO_pars, RO_separation, cal_points=((-4, -3), (-2, -1)), comm_freq=225e6, upload=True, return_seq=False, prep_pulses=None, verbose=False): """ Prepares the AWGs for a readout pulse shape and timing measurement. The sequence consists of two readout pulses where the drive pulse start time is swept through the first readout pulse. Because the photons in the readout resonator induce an ac-Stark shift of the qubit frequency, we can determine the readout pulse shape by sweeping the drive frequency in an outer loop to determine the qubit frequency. Important: This sequence includes two readouts per segment. For this reason the calibration points are also duplicated. Args: delays: A list of delays between the start of the first readout pulse and the end of the drive pulse. pulse_pars: Pulse dictionary for the drive pulse. RO_pars: Pulse dictionary for the readout pulse. RO_separation: Separation between the starts of the two readout pulses. If the comm_freq parameter is not None, the used value is increased to satisfy the commensurability constraint. cal_points: True for default calibration points, False for no calibration points or a list of two lists, containing the indices of the calibration segments for the ground and excited state. comm_freq: The readout pulse separation will be a multiple of 1/comm_freq Returns: The sequence object and the element list if return_seq is True. Else return the sequence name. """ if cal_points: cal_points = ((-4, -3), (-2, -1)) elif not cal_points or cal_points is None: cal_points = ((), ()) if prep_pulses is None: prep_pulses = [] if comm_freq: RO_separation -= RO_separation % (-1 / comm_freq) seq_name = 'readout_pulse_scope_sequence' seq = sequence.Sequence(seq_name) seg_list = [] pulses = get_pulse_dict_from_pars(pulse_pars) min_delay = min(delays) readout_x1 = deepcopy(RO_pars) readout_x1['ref_point'] = 'end' readout_x2 = deepcopy(RO_pars) readout_x2['pulse_delay'] = RO_separation readout_x2['ref_point'] = 'start' probe_pulse = deepcopy(pulses['X180']) prep_pulses = [deepcopy(pulses[pulse_name]) for pulse_name in prep_pulses] for pulse in prep_pulses: pulse['pulse_delay'] = -2 * np.abs(min_delay) for i, tau in enumerate(delays): if i in cal_points[0] or i - len(delays) in cal_points[0]: seg = segment.Segment('segment_{}'.format(2 * i), [pulses['I'], RO_pars]) seg_list.append(seg) seq.add(seg) seg = segment.Segment('segment_{}'.format(2 * i + 1), [pulses['I'], RO_pars]) seg_list.append(seg) seq.add(seg) elif i in cal_points[1] or i - len(delays) in cal_points[1]: seg = segment.Segment('segment_{}'.format(2 * i), [pulses['X180'], RO_pars]) seg_list.append(seg) seq.add(seg) seg = segment.Segment('segment_{}'.format(2 * i + 1), [pulses['X180'], RO_pars]) seg_list.append(seg) seq.add(seg) else: probe_pulse['pulse_delay'] = tau - min_delay readout_x1['pulse_delay'] = -tau seg = segment.Segment( 'segment_{}'.format(2 * i), prep_pulses + [probe_pulse, readout_x1, readout_x2]) seg_list.append(seg) seq.add(seg) if upload: ps.Pulsar.get_instance().program_awgs(seq) if return_seq: return seq, seg_list else: return seq_name
def cphase_fringes( phases, q0_pulse_pars, q1_pulse_pars, RO_pars, swap_pars_q0, cphase_pars_q1, timings_dict, distortion_dict, verbose=False, upload=True, return_seq=False, ): """ """ preloaded_kernels_vec = preload_kernels_func(distortion_dict) original_delay = deepcopy(RO_pars)[0]["pulse_delay"] seq_name = "CPhase" seq = sequence.Sequence(seq_name) station.pulsar.update_channel_settings() el_list = [] # print(q0_pulse_pars) q0_pulses = add_suffix_to_dict_keys(get_pulse_dict_from_pars(q0_pulse_pars[0]), " q0") q1_pulses = add_suffix_to_dict_keys(get_pulse_dict_from_pars(q1_pulse_pars[0]), " q1") pulse_dict = {} pulse_dict.update(q0_pulses) pulse_dict.update(q1_pulses) pulse_dict.update({"RO": RO_pars[0]}) # print({'RO': RO_pars}) # Timings buffer_mw_flux = timings_dict[0]["buffer_mw_flux"] buffer_flux_mw = timings_dict[0]["buffer_flux_mw"] msmt_buffer = timings_dict[0]["msmt_buffer"] dead_time = timings_dict[0]["dead_time"] # print(buffer_mw_flux,buffer_flux_mw,msmt_buffer,dead_time) # defining main pulses exc_pulse = deepcopy(pulse_dict["X180 q0"]) exc_pulse["pulse_delay"] += 0.01e-6 swap_pulse_1 = deepcopy(swap_pars_q0[0]) # print(swap_pulse_1) swap_pulse_1["pulse_delay"] = buffer_mw_flux + exc_pulse["sigma"] * exc_pulse["nr_sigma"] ramsey_1 = deepcopy(pulse_dict["Y90 q1"]) ramsey_1["pulse_delay"] = buffer_flux_mw + swap_pulse_1["length"] cphase_pulse = cphase_pars_q1[0] cphase_amp = cphase_pulse["amplitude"] cphase_pulse["pulse_delay"] = buffer_mw_flux + ramsey_1["sigma"] * ramsey_1["nr_sigma"] ramsey_2 = deepcopy(pulse_dict["X90 q1"]) ramsey_2["pulse_delay"] = buffer_flux_mw + cphase_pulse["length"] swap_pulse_2 = deepcopy(swap_pars_q0[0]) swap_pulse_2["pulse_delay"] = buffer_mw_flux + ramsey_2["sigma"] * ramsey_2["nr_sigma"] RO_pars[0]["pulse_delay"] = msmt_buffer + swap_pulse_2["length"] # defining compensation pulses swap_comp_1 = deepcopy(swap_pulse_1) swap_pulse_1["pulse_delay"] = RO_pars[0]["length"] + dead_time cphase_comp = deepcopy(cphase_pulse) swap_comp_2 = deepcopy(swap_pulse_2) dead_time_pulse = { "pulse_type": "SquarePulse", "pulse_delay": RO_pars[0]["pulse_delay"], "channel": swap_pars_q0[0]["channel"], "amplitude": 0, "length": dead_time, } for i, ph2 in enumerate(phases[0]): # print(ph2) ramsey_2["phase"] = ph2 cphase_pulse["amplitude"] = cphase_amp pulse_list = [ exc_pulse, swap_pulse_1, ramsey_1, cphase_pulse, ramsey_2, swap_pulse_2, RO_pars[0], swap_comp_1, cphase_comp, swap_comp_2, dead_time_pulse, ] el = multi_pulse_elt(2 * i, station, pulse_list) el_list.append(el) cphase_pulse["amplitude"] = 0.0 pulse_list = [ exc_pulse, swap_pulse_1, ramsey_1, cphase_pulse, ramsey_2, swap_pulse_2, RO_pars[0], swap_comp_1, cphase_comp, swap_comp_2, dead_time_pulse, ] el = multi_pulse_elt(2 * i + 1, station, pulse_list) el_list.append(el) # Compensations for i, el in enumerate(el_list): if distortion_dict is not None: el = distort_and_compensate(el, distortion_dict, preloaded_kernels_vec) el_list[i] = el seq.append_element(el, trigger_wait=True) cal_points = 4 RO_pars[0]["pulse_delay"] = original_delay # Calibration points cal_points = [ ["I q0", "I q1", "RO"], ["I q0", "I q1", "RO"], ["X180 q0", "I q1", "RO"], ["X180 q0", "I q1", "RO"], ["I q0", "X180 q1", "RO"], ["I q0", "X180 q1", "RO"], ["X180 q0", "X180 q1", "RO"], ["X180 q0", "X180 q1", "RO"], ] for i, pulse_comb in enumerate(cal_points): pulses = [] for p in pulse_comb: pulses += [pulse_dict[p]] pulses[0]["pulse_delay"] += 0.01e-6 el = multi_pulse_elt(2 * len(phases) + i, station, pulses) el_list.append(el) seq.append_element(el, trigger_wait=True) # upload if upload: station.components["AWG"].stop() station.pulsar.program_awg(seq, *el_list, verbose=verbose) if return_seq: return seq, el_list else: return seq
def readout_photons_in_resonator_seq(delay_to_relax, delay_buffer, ramsey_times, RO_pars, pulse_pars, cal_points=((-4, -3), (-2, -1)), verbose=False, upload=True, return_seq=False, artificial_detuning=None): """ The sequence consists of two readout pulses sandwitching two ramsey pulses inbetween. The delay between the first readout pulse and first ramsey pulse is swept, to measure the ac stark shift and dephasing from any residual photons. Important: This sequence includes two readouts per segment. For this reason the calibration points are also duplicated. Args: delay_ro_relax: delay between the end of the first readout pulse and the start of the first ramsey pulse. pulse_pars: Pulse dictionary for the ramsey pulse. RO_pars: Pulse dictionary for the readout pulse. delay_buffer: delay between the start of the last ramsey pulse and the start of the second readout pulse. ramsey_times: delays between ramsey pulses cal_points: True for default calibration points, False for no calibration points or a list of two lists, containing the indices of the calibration segments for the ground and excited state. Returns: The sequence object and the element list if return_seq is True. Else return the sequence name. """ raise NotImplementedError( 'readout_photons_in_resonator_seq has not been ' 'converted to the latest waveform generation code and can not be used.' ) if cal_points is True: cal_points = ((-4, -3), (-2, -1)) elif cal_points is False or cal_points is None: cal_points = ((), ()) seq_name = 'readout_photons_in_resonator_sequence' seq = sequence.Sequence(seq_name) el_list = [] pulses = get_pulse_dict_from_pars(pulse_pars) ramsey_x1 = deepcopy(pulses['X90']) ramsey_x1['pulse_delay'] = delay_to_relax readout_x2 = deepcopy(RO_pars) readout_x2['pulse_delay'] = delay_buffer for i, tau in enumerate(ramsey_times): if i in cal_points[0] or i - len(ramsey_times) in cal_points[0]: el = multi_pulse_elt(2 * i, station, [pulses['I'], RO_pars]) el_list.append(el) seq.append_element(el, trigger_wait=True) el = multi_pulse_elt(2 * i + 1, station, [pulses['I'], RO_pars]) el_list.append(el) seq.append_element(el, trigger_wait=True) elif i in cal_points[1] or i - len(ramsey_times) in cal_points[1]: el = multi_pulse_elt(2 * i, station, [pulses['X180'], RO_pars]) el_list.append(el) seq.append_element(el, trigger_wait=True) el = multi_pulse_elt(2 * i + 1, station, [pulses['X180'], RO_pars]) el_list.append(el) seq.append_element(el, trigger_wait=True) else: ramsey_x2 = deepcopy(pulses['X90']) ramsey_x2['refpoint'] = 'start' ramsey_x2['pulse_delay'] = tau if artificial_detuning is not None: Dphase = (tau * artificial_detuning * 360) % 360 ramsey_x2['phase'] += Dphase prep_pulse = [pulses['I'], pulses['X180']][i % 2] el = multi_pulse_elt( 2 * i, station, [prep_pulse, RO_pars, ramsey_x1, ramsey_x2, readout_x2]) el_list.append(el) seq.append_element(el, trigger_wait=True) if upload: station.pulsar.program_awgs(seq, *el_list, verbose=verbose) if return_seq: return seq, el_list else: return seq_name
def n_qubit_off_on(pulse_pars_list, RO_pars_list, return_seq=False, parallel_pulses=False, preselection=False, upload=True, RO_spacing=2000e-9): n = len(pulse_pars_list) seq_name = '{}_qubit_OffOn_sequence'.format(n) seq = sequence.Sequence(seq_name) seg_list = [] RO_pars_list_presel = deepcopy(RO_pars_list) for i, RO_pars in enumerate(RO_pars_list): RO_pars['name'] = 'RO_{}'.format(i) RO_pars['element_name'] = 'RO' if i != 0: RO_pars['ref_point'] = 'start' for i, RO_pars_presel in enumerate(RO_pars_list_presel): RO_pars_presel['ref_pulse'] = RO_pars_list[-1]['name'] RO_pars_presel['ref_point'] = 'start' RO_pars_presel['element_name'] = 'RO_presel' RO_pars_presel['pulse_delay'] = -RO_spacing # Create a dict with the parameters for all the pulses pulse_dict = dict() for i, pulse_pars in enumerate(pulse_pars_list): pars = pulse_pars.copy() if i == 0 and parallel_pulses: pars['ref_pulse'] = 'segment_start' if i != 0 and parallel_pulses: pars['ref_point'] = 'start' pulses = add_suffix_to_dict_keys(get_pulse_dict_from_pars(pars), ' {}'.format(i)) pulse_dict.update(pulses) # Create a list of required pulses pulse_combinations = [] for pulse_list in itertools.product(*(n * [['I', 'X180']])): pulse_comb = (n) * [''] for i, pulse in enumerate(pulse_list): pulse_comb[i] = pulse + ' {}'.format(i) pulse_combinations.append(pulse_comb) for i, pulse_comb in enumerate(pulse_combinations): pulses = [] for j, p in enumerate(pulse_comb): pulses += [pulse_dict[p]] pulses += RO_pars_list if preselection: pulses = pulses + RO_pars_list_presel seg = segment.Segment('segment_{}'.format(i), pulses) seg_list.append(seg) seq.add(seg) repeat_dict = {} repeat_pattern = ((1.0 + int(preselection)) * len(pulse_combinations), 1) for i, RO_pars in enumerate(RO_pars_list): repeat_dict = seq.repeat(RO_pars, None, repeat_pattern) if upload: ps.Pulsar.get_instance().program_awgs(seq) if return_seq: return seq, seg_list else: return seq_name