def generate_sequence(self, upload=True, period=200e-6, on_time=2e-6): self_trigger = pulse.SquarePulse(channel='self_trigger', length = on_time, amplitude = 2.) T = pulse.SquarePulse(channel='self_trigger', name='delay', length = period - on_time, amplitude = 0) elements = [] period_element = element.Element('Dummy_selftrigger_element', pulsar=qt.pulsar, global_time=True) period_element.append(self_trigger) period_element.append(T) elements.append(period_element) seq = pulsar.Sequence("Dummy self-trigger sequence") seq.append(name=period_element.name, wfname=period_element.name, trigger_wait=True, # goto_target=period_element.name ) # upload the waveforms to the AWG if upload: if upload=='old_method': qt.pulsar.upload(*elements) qt.pulsar.program_sequence(seq) else: qt.pulsar.program_awg(seq,*elements)
def generate_sequence(self, upload=True): # define the necessary pulses X = hermite_Xpi(self) T = pulse.SquarePulse(channel='MW_Imod', name='delay') T.amplitude = 0. T.length = 2e-6 # make the elements - one for each ssb frequency elements = [] for i, f in enumerate(1e9 * self.params['sweep_pts'] - self.params['mw_frq']): e = element.Element('DarkESR_frq-%d' % i, pulsar=qt.pulsar) e.add(T, name='wait') e.add(X(frequency=f), refpulse='wait') elements.append(e) # create a sequence from the pulses seq = pulsar.Sequence('DarkESR sequence') for e in elements: seq.append(name=e.name, wfname=e.name, trigger_wait=True) # upload the waveforms to the AWG if upload: if upload == 'old_method': qt.pulsar.upload(*elements) qt.pulsar.program_sequence(seq) else: qt.pulsar.program_awg(seq, *elements)
def generate_sequence(self, upload=True): # define the necessary pulse V = self.E_aom.power_to_voltage(self.params['Ex_RO_amplitude'], controller='sec') print V qt.pulsar_remote.set_channel_opt('Velocity1AOM', 'high', V) HH_sync = pulse.SquarePulse(channel='HH_sync', length=50e-9, amplitude=1.0) TT = pulse.SquarePulse(channel='HH_sync', length=1000e-9, amplitude=0) RO = pulse.SquarePulse(channel='Velocity1AOM', length=self.params['SSRO_duration'] * 1e-6, amplitude=1) # make the elements - one for each ssb frequency e = element.Element('RO', pulsar=qt.pulsar_remote) e.append(TT) e.append(HH_sync) e.append(TT) e.append(RO) # create a sequence from the pulses seq = pulsar.Sequence('SSRO sequence') seq.append(name=e.name, wfname=e.name, trigger_wait=True) # upload the waveforms to the AWG if upload: qt.pulsar_remote.upload(e) # program the AWG qt.pulsar_remote.program_sequence(seq)
def dd_sweep_free_ev_time_w_LDE_msmt(self): self.seq = pulsar.Sequence('{}_{}_sequence'.format( self.mprefix, self.name)) self.elements = [] LDE_elt = self.LDE_element(eom_pulse_amplitude=0.) self.seq.append(name='LDE_element', wfname=LDE_elt.name) self.elements.append(LDE_elt) print 'LDE' for i in range(self.params['pts']): seq, total_elt_time, elts = self.dynamical_decoupling( self.seq, name=i, time_offset=LDE_elt.length(), begin_offset_time=800e-9 + self.params_lt2['dd_spin_echo_time'], free_evolution_time=self.params_lt2['free_evolution_times'][i]) second_pi2_elt = self.second_pi2(name=i, time_offset=LDE_elt.length() + total_elt_time) self.seq.append(name='second_pi2-{}'.format(i), wfname=second_pi2_elt.name) for e in elts: if e not in self.elements: self.elements.append(e) self.elements.append(second_pi2_elt)
def lt3_sequence(self): print "Make lt3 sequence... " self.lt3_seq = pulsar.Sequence('TailLT3') elements = [] dummy_element = bseq._lt3_dummy_element(self) finished_element = bseq._lt3_sequence_finished_element(self) elements.append(dummy_element) elements.append(finished_element) for i in range(self.params['pts']): eom_p = self.create_eom_pulse(i) e = bseq._lt3_LDE_element( self, name='LT3 Tail sweep element {}'.format(i), eom_pulse=eom_p) #print e.print_overview() elements.append(e) self.lt3_seq.append( name='LT3 Tail sweep {}'.format(i), wfname=e.name, trigger_wait=self.params['trigger_wait'], repetitions=self.params['LDE_attempts_before_CR']) qt.pulsar.upload(*elements) qt.pulsar.program_sequence(self.lt3_seq)
def generate_sequence(self, upload=True): #print 'test' # define the necessary pulses X = pulselib.MW_pulse('Weak pi-pulse', MW_channel='MW_Imod', PM_channel='MW_pulsemod', PM_risetime = self.params['MW_pulse_mod_risetime']) T = pulse.SquarePulse(channel='MW_Qmod', name='delay', length = 200e-9, amplitude = 0.) # make the elements - one for each ssb frequency elements = [] for i in range(self.params['pts']): e = element.Element('ElectronRabi_pt-%d' % i, pulsar=qt.pulsar) e.append(T) e.append(pulse.cp(X, length = self.params['MW_pulse_durations'][i], amplitude = self.params['MW_pulse_amplitudes'][i])) elements.append(e) # create a sequence from the pulses seq = pulsar.Sequence('ElectronRabi sequence') for e in elements: seq.append(name=e.name, wfname=e.name, trigger_wait=True) # upload the waveforms to the AWG if upload: qt.pulsar.program_awg(seq,*elements)
def generate_sequence(self, upload=True): # define the necessary pulse TT = pulse.SquarePulse(channel='HH_sync', length=1000e-9, amplitude=0) SP = pulse.SquarePulse(channel=self.params['sp_channel'], length=self.params['AWG_SP_duration'][0], amplitude=self.params['AWG_SP_voltage'][0]) #print self.params['AWG_SP_voltage'] # make the elements - one for each ssb frequency elements = [] for i in range(self.params['pts']): e = element.Element('AWG_SP_sweep-%d' % i, pulsar=self.pulsar) e.add(TT, name='wait') e.append( pulse.cp( SP(length=self.params['AWG_SP_duration'][i], amplitude=self.params['AWG_SP_voltage'][i]))) elements.append(e) # create a sequence from the pulses seq = pulsar.Sequence('SSRO sequence') for e in elements: seq.append(name=e.name, wfname=e.name, trigger_wait=True) # upload the waveforms to the AWG if upload: self.pulsar.upload(*elements) # program the AWG self.pulsar.program_sequence(seq)
def program_test_master(): #p=pulse.SinePulse(channel='EOM_Matisse', name='pp', length=100e-6, frequency=1/(100e-6), amplitude = 1.8) T = pulse.SquarePulse('scope_sync', length=200e-9, amplitude = 0) p_sync = pulse.SquarePulse('scope_sync', length=50e-9, amplitude = 1) p_pulse = pulse.SquarePulse('scope_pulse', length=200e-9, amplitude = 1) p_trig = pulse.SquarePulse('awg_lt1_trigger', length=50e-9, amplitude = 1) e=element.Element('Sinde', pulsar=qt.pulsar) e.append(T) e.append(p_trig) e.append(pulse.cp(T, length = 500e-9)) e.append(p_sync) e.append(T) e.append(p_pulse) e.append(pulse.cp(T, length = 100 \ 0e-9)) e.print_overview() s= pulsar.Sequence('TEST_AWG_SYNC_LT3') s.append(name = 't1', wfname = e.name, trigger_wait = 0) qt.pulsar.upload(e) qt.pulsar.program_sequence(s) qt.instruments['AWG'].start()
def test_BSM_contrast(self, bs='psi'): sweep_elements = [] self.flattened_elements = [] self.seq = pulsar.Sequence('{}_{}-Sequence'.format( self.mprefix, self.name)) bs_elt = self._BS_element(bs, bs) self.flattened_elements.append(bs_elt) for i in range(self.params['pts']): CNOT, UNROT_H = self.BSM_elements( '{}'.format(i), time_offset=bs_elt.length(), H_phase=self.params_lt1['H_phases'][i], evolution_time=self.params_lt1['H_evolution_time']) self.flattened_elements.append(CNOT) self.flattened_elements.append(UNROT_H) sweep_elements.append([bs_elt, CNOT, UNROT_H]) self.seq = self._add_MBI_and_sweep_elements_to_sequence( sweep_elements, self.N_RO_CNOT_elt, self.adwin_lt1_trigger_element, N_RO_repetitions=1 if not self.repetitive_readout else self.params_lt1['N_RO_repetitions'])
def test_BSM_with_LDE_element_calibrate_echo_time(self): sweep_elements = [] self.flattened_elements = [] self.seq = pulsar.Sequence('{}_{}-Sequence'.format( self.mprefix, self.name)) for i in range(self.params['pts']): N_init = self.N_init_element( 'N_init-{}'.format(i), basis='Z', echo_time_after_LDE=self.params_lt1['echo_times_after_LDE'][i], end_offset_time=-100e-9) e_pi2_elt = element.Element('e_pi2-{}'.format(i), pulsar=qt.pulsar, global_time=True, time_offset=self.LDE_element.length() + N_init.length()) e_pi2_elt.append(pulse.cp(self.TIQ, length=100e-9)) e_pi2_elt.append(self.fast_pi2) self.flattened_elements.append(self.LDE_element) self.flattened_elements.append(N_init) self.flattened_elements.append(e_pi2_elt) sweep_elements.append([self.LDE_element, N_init, e_pi2_elt]) self.seq = self._add_MBI_and_sweep_elements_to_sequence( sweep_elements, self.N_RO_CNOT_elt, self.adwin_lt1_trigger_element)
def generate_sequence(self, upload=True, **kw): # define the necessary pulses # rotations pulse_pi2 = kw.get('pulse_pi2', None) pulse_pi = kw.get('pulse_pi', None) # waiting element T = pulse.SquarePulse(channel='MW_Imod', name='delay', length = 200e-9, amplitude = 0.) adwin_sync = pulse.SquarePulse(channel='adwin_sync', length = self.params['AWG_to_adwin_ttl_trigger_duration'], amplitude = 2) # self_trigger = pulse.SquarePulse(channel='self_trigger', # length = self.params['self_trigger_duration'], # amplitude = 2) # make the elements, one for each evolution time elements = [] for i in range(self.params['pts']): e1 = element.Element('ElectronT2_notrigger_pt-%d_A' % i, pulsar=qt.pulsar, global_time = True) e1.append(pulse.cp(T, length = 3000e-9)) e1.append(pulse.cp(pulse_pi2, phase = self.params['pulse_sweep_pi2_phases1'][i])) e1.append(pulse.cp(T, length = self.params['evolution_times'][i] / 2.)) e1.append(pulse.cp(pulse_pi, phase = self.params['pulse_sweep_pi_phases'][i])) e1.append(pulse.cp(T, length = self.params['evolution_times'][i] / 2.)) e1.append(pulse.cp(pulse_pi2, phase = self.params['pulse_sweep_pi2_phases2'][i])) e1.append(adwin_sync) elements.append(e1) # return_e=e # create a sequence from the pulses seq = pulsar.Sequence('Electron T2 with AWG timing with {} pulses'.format(self.params['pulse_shape'])) for e in elements: seq.append(name=e.name, wfname=e.name, trigger_wait=True) # upload the waveforms to the AWG if upload: if upload=='old_method': qt.pulsar.upload(*elements) qt.pulsar.program_sequence(seq) else: qt.pulsar.program_awg(seq,*elements)
def dd_sweep_free_ev_time_msmt(self): self.seq = pulsar.Sequence('{}_{}_sequence'.format( self.mprefix, self.name)) self.elements = [] first_pi2_elt = self.first_pi2() self.elements.append(first_pi2_elt) for i in range(self.params['pts']): self.seq.append(name='first_pi2-{}'.format(i), wfname=first_pi2_elt.name, trigger_wait=True) seq, total_elt_time, elts = self.dynamical_decoupling( self.seq, name=i, time_offset=first_pi2_elt.length(), free_evolution_time=self.params_lt2['free_evolution_times'][i]) second_pi2_elt = self.second_pi2( name=i, time_offset=first_pi2_elt.length() + total_elt_time) self.seq.append(name='second_pi2-{}'.format(i), wfname=second_pi2_elt.name) self.seq.append(name='sync_elt-{}'.format(i), wfname=self.adwin_lt2_trigger_element.name) for e in elts: if e not in self.elements: self.elements.append(e) self.elements.append(second_pi2_elt) self.elements.append(self.adwin_lt2_trigger_element)
def turn_on_lt4_pulse_path(): #qt.instruments['PMServo'].move_in() p=pulse.SinePulse(channel='EOM_Matisse', name='pp', length=100e-6, frequency=1/(100e-6), amplitude = 1.8) opt = 'offset' if qt.pulsar.channels['EOM_AOM_Matisse']['type']=='analog' else 'low' qt.pulsar.set_channel_opt('EOM_AOM_Matisse', opt, 1.0) e=element.Element('Sinde', pulsar=qt.pulsar) e.append(p) e.print_overview() s= pulsar.Sequence('Sinde') s.append(name = 'Sine', wfname = e.name, trigger_wait = 0) qt.pulsar.upload(e) qt.pulsar.program_sequence(s) qt.instruments['AWG'].set_runmode('SEQ') qt.instruments['AWG'].start() while 1: if (msvcrt.kbhit() and (msvcrt.getch() == 'q')): break qt.msleep(0.1) qt.instruments['AWG'].stop() qt.instruments['AWG'].set_runmode('CONT') qt.pulsar.set_channel_opt('EOM_AOM_Matisse', opt, 0.0)
def generate_sequence(self, upload=True, debug=False): # MBI element mbi_elt = self._MBI_element() # electron manipulation pulses T = pulse.SquarePulse(channel='MW_pulsemod', length = 1000e-9, amplitude = 0) X = pulselib.MW_IQmod_pulse('MW pulse', I_channel = 'MW_Imod', Q_channel = 'MW_Qmod', PM_channel = 'MW_pulsemod', PM_risetime = self.params['MW_pulse_mod_risetime'] ) # X = pulselib.HermitePulse_Envelope_IQ('MW pulse', # I_channel = 'MW_Imod', # Q_channel = 'MW_Qmod', # PM_channel = 'MW_pulsemod', # PM_risetime = self.params['MW_pulse_mod_risetime'] ) adwin_sync = pulse.SquarePulse(channel='adwin_sync', length = self.params['AWG_to_adwin_ttl_trigger_duration'], amplitude = 2) # electron manipulation elements elts = [] for i in range(self.params['pts']): e = element.Element('ERabi_pt-%d' % i, pulsar=qt.pulsar, global_time = True) e.append(T) for j in range(self.params['MW_pulse_multiplicities'][i]): e.append( pulse.cp(X, frequency = self.params['MW_pulse_mod_frqs'][i], amplitude = self.params['MW_pulse_amps'][i], length = self.params['MW_pulse_durations'][i])) e.append( pulse.cp(T, length=self.params['MW_pulse_delays'][i])) e.append(adwin_sync) elts.append(e) # sequence seq = pulsar.Sequence('MBI Electron Rabi sequence') for i,e in enumerate(elts): seq.append(name = 'MBI-%d' % i, wfname = mbi_elt.name, trigger_wait = True, goto_target = 'MBI-%d' % i, jump_target = e.name) seq.append(name = e.name, wfname = e.name, trigger_wait = True) # seq.append(name = 'RO-%d' % i, wfname = mbi_elt.name, # trigger_wait = True, goto_target = 'MBI-%d' % i, # jump_target = e.name) print 'MBI at', self.params['AWG_MBI_MW_pulse_ssbmod_frq'] print 'MW rotations at', self.params['MW_pulse_mod_frqs'][i] # program AWG if upload: #qt.pulsar.upload(mbi_elt, *elts) qt.pulsar.program_awg(seq, mbi_elt, *elts , debug=debug)
def generate_sequence(self, upload=True): # MBI element mbi_elt = self._MBI_element() # electron manipulation pulses T = pulse.SquarePulse(channel='MW_pulsemod', length=10e-9, amplitude=0) CORPSE_pi = pulselib.IQ_CORPSE_pi_pulse( 'CORPSE pi-pulse', I_channel='MW_Imod', Q_channel='MW_Qmod', PM_channel='MW_pulsemod', PM_risetime=self.params['MW_pulse_mod_risetime'], frequency=self.params['CORPSE_pi_mod_frq'], amplitude=self.params['CORPSE_pi_amp'], length_60=self.params['CORPSE_pi_60_duration'], length_m300=self.params['CORPSE_pi_m300_duration'], length_420=self.params['CORPSE_pi_420_duration']) sync_elt = element.Element('adwin_sync', pulsar=qt.pulsar) adwin_sync = pulse.SquarePulse(channel='adwin_sync', length=10e-6, amplitude=2) sync_elt.append(adwin_sync) wait_1us = element.Element('1us_delay', pulsar=qt.pulsar) wait_1us.append(pulse.cp(T, length=1e-6)) elts = [] for i in range(self.params['pts']): e = element.Element('CORPSE-{}'.format(i), pulsar=qt.pulsar) e.append( T, pulse.cp(CORPSE_pi, amplitude=self.params['CORPSE_pi_sweep_amps'][i])) elts.append(e) # sequence seq = pulsar.Sequence('CORPSE pi calibration') for i, e in enumerate(elts): seq.append(name='MBI-%d' % i, wfname=mbi_elt.name, trigger_wait=True, goto_target='MBI-%d' % i, jump_target=e.name + '-0') for j in range(self.params['multiplicity']): seq.append(name=e.name + '-{}'.format(j), wfname=e.name, trigger_wait=(j == 0)) seq.append(name='wait-{}-{}'.format(i, j), wfname=wait_1us.name, repetitions=self.params['delay_reps']) seq.append(name='sync-{}'.format(i), wfname=sync_elt.name) # program AWG if upload: qt.pulsar.upload(mbi_elt, sync_elt, wait_1us, *elts) qt.pulsar.program_sequence(seq)
def generate_sequence(self, upload=True): # electron manipulation pulses T = pulse.SquarePulse(channel='MW_pulsemod', length=100e-9, amplitude=0) TIQ = pulse.SquarePulse(channel='MW_Imod', length=10e-9, amplitude=0) CORPSE_pi = pulselib.IQ_CORPSE_pulse( 'CORPSE pi-pulse', I_channel='MW_Imod', Q_channel='MW_Qmod', PM_channel='MW_pulsemod', PM_risetime=self.params['MW_pulse_mod_risetime'], frequency=self.params['CORPSE_mod_frq'], rabi_frequency=self.params['CORPSE_rabi_frequency'], amplitude=self.params['CORPSE_amp'], eff_rotation_angle=180) CORPSE_pi2 = pulselib.IQ_CORPSE_pulse( 'CORPSE pi-pulse', I_channel='MW_Imod', Q_channel='MW_Qmod', PM_channel='MW_pulsemod', PM_risetime=self.params['MW_pulse_mod_risetime'], frequency=self.params['CORPSE_mod_frq'], rabi_frequency=self.params['CORPSE_rabi_frequency'], amplitude=self.params['CORPSE_amp'], eff_rotation_angle=90) wait_1us = element.Element('1us_delay', pulsar=qt.pulsar) wait_1us.append(pulse.cp(T, length=1e-6)) sync_elt = element.Element('adwin_sync', pulsar=qt.pulsar) adwin_sync = pulse.SquarePulse(channel='adwin_sync', length=10e-6, amplitude=2) sync_elt.append(adwin_sync) elts = [] seq = pulsar.Sequence('CORPSE test') for i in range(self.params['pts']): e = element.Element('CORPSE_Pi2_Pi-{}'.format(i), pulsar=qt.pulsar, global_time=True) e.append(T) e.append(pulse.cp(CORPSE_pi2)) e.append(pulse.cp(TIQ, length=self.params['delays'][i])) e.append(pulse.cp(CORPSE_pi)) e.append(T) elts.append(e) seq.append(name='CORPSE_Pi2_Pi-{}'.format(i), wfname=e.name, trigger_wait=True) seq.append(name='sync-{}'.format(i), wfname=sync_elt.name) if upload: qt.pulsar.upload(sync_elt, wait_1us, *elts) qt.pulsar.program_sequence(seq)
def calibrate_CORPSE_pi_phase_shift_or_e_time(self): """ Do a Hahn echo sequence with the CORPSE pi pulse, and sweep it's zero phase with respect the rotating frame at that time. """ sweep_elements = [] self.flattened_elements = [] self.seq = pulsar.Sequence('{}_{}-Sequence'.format( self.mprefix, self.name)) first_pi2_elt = element.Element('first pi2', pulsar=qt.pulsar, global_time=True) first_pi2_elt.append(pulse.cp(self.T, length=1e-6)) first_pi2_name = first_pi2_elt.append(self.fast_pi2) first_pi2_elt.append(pulse.cp(self.TIQ, length=100e-9)) self.flattened_elements.append(first_pi2_elt) # the start time of the second pi2, and the evolution time depends on the time when the # pulse stops in the first pi2 element: t_pi2 = first_pi2_elt.length() - \ first_pi2_elt.effective_pulse_end_time(first_pi2_name, 'MW_Imod') # calculate the evolution time from the interpulse delay etimes = self.params_lt1[ 'interpulse_delays'] - t_pi2 - self.fast_pi2.effective_length() / 2. pi_elts = [] second_pi2_elts = [] for i in range(self.params['pts']): e = self.UNROT_element('pi-{}'.format(i), None, etimes[i], first_pi2_elt.length(), CORPSE_pi_phase_shift = \ self.params_lt1['CORPSE_pi_phase_shifts'][i]) self.flattened_elements.append(e) pi_elts.append(e) # make the element second_pi2_elt = element.Element('second pi2-{}'.format(i), pulsar=qt.pulsar, global_time=True, time_offset=e.length() + first_pi2_elt.length()) second_pi2_elt.append(pulse.cp(self.TIQ, length=t_pi2)) second_pi2_elt.append(self.fast_pi2) self.flattened_elements.append(second_pi2_elt) second_pi2_elts.append(second_pi2_elt) self.flattened_elements.append(self.N_RO_CNOT_elt) for i in range(self.params['pts']): sweep_elements.append( [first_pi2_elt, pi_elts[i], second_pi2_elts[i]]) self.seq = self._add_MBI_and_sweep_elements_to_sequence( sweep_elements, self.N_RO_CNOT_elt, self.adwin_lt1_trigger_element)
def generate_sequence(self, upload=True): #print 'test' # define the necessary pulses X1 = pulselib.MW_CORPSE_pulse('CORPSE pi-pulse', MW_channel = 'MW_1', PM_channel = 'MW_pulsemod', #second_MW_channel = 'MW_Qmod', PM_risetime = self.params['MW_pulse_mod_risetime'], amplitude = self.params['CORPSE_pi_amp'], rabi_frequency = self.params['CORPSE_pi_frq'], eff_rotation_angle = 180) X2 = pulselib.MW_CORPSE_pulse('CORPSE 2pi-pulse', MW_channel = 'MW_2', PM_channel = 'MW_pulsemod', #second_MW_channel = 'MW_Qmod', PM_risetime = self.params['MW_pulse_mod_risetime'], amplitude = self.params['CORPSE_2pi_amp'], rabi_frequency = self.params['CORPSE_2pi_frq'], eff_rotation_angle = 360) RND_halt = pulse.SquarePulse(channel = 'RND_halt', amplitude = 1.0, length = 400e-9) sync = pulse.SquarePulse(channel = 'sync', length = 50e-9, amplitude = 1.0) T = pulse.SquarePulse(channel='MW_1', name='delay', length = 200e-9, amplitude = 0.) RO_pulse = pulse.SquarePulse(channel = 'AOM_Matisse', amplitude = self.params['E_RO_voltage_AWG'], length = self.params['SSRO_duration']*1e-6) # make the elements - one for each ssb frequency elements = [] for i in range(self.params['pts']): e = element.Element('ElectronRandom_pt-%d' % i, pulsar=qt.pulsar) e.append(T) e.append(sync) e.append(T) e.append(RND_halt) ref=e.append(T) e.add(X1, refpulse=ref) e.add(X2, refpulse=ref) e.append(pulse.cp(T, length = 1e-6)) e.append(RO_pulse) e.append(T) elements.append(e) # create a sequence from the pulses seq = pulsar.Sequence('ElectronRandom sequence') for e in elements: seq.append(name=e.name, wfname=e.name, trigger_wait=True) # upload the waveforms to the AWG if upload: qt.pulsar.program_awg(seq,*elements)
def generate_sequence(self, upload=True, **kw): # define the necessary pulses X=kw.get('pulse_pi2', None) T = pulse.SquarePulse(channel='MW_Imod', name='delay', length = 200e-9, amplitude = 0.) adwin_sync = pulse.SquarePulse(channel='adwin_sync', length = self.params['AWG_to_adwin_ttl_trigger_duration'], amplitude = 2) self_trigger = pulse.SquarePulse(channel='self_trigger', length = self.params['self_trigger_duration'], amplitude = 2) # make the elements - one for each ssb frequency elements = [] for i in range(self.params['pts']): e1 = element.Element('ElectronRamsey_pt-%d_A' % i, pulsar=qt.pulsar, global_time = True) e1.append(pulse.cp(T, length = 1000e-9)) e1.append(pulse.cp(X, phase = self.params['pulse_sweep_pi2_phases1'][i])) e1.append(pulse.cp(T, length = self.params['evolution_times'][i] - self.params['self_trigger_delay'])) e1.append(pulse.cp(self_trigger)) elements.append(e1) e2 = element.Element('ElectronRamsey_pt-%d_B' % i, pulsar=qt.pulsar, global_time = True) e2.append(pulse.cp(X, phase = self.params['pulse_sweep_pi2_phases2'][i])) e2.append(T) e2.append(adwin_sync) elements.append(e2) # return_e=e # create a sequence from the pulses seq = pulsar.Sequence('ElectronRamsey self-triggered sequence with {} pulses'.format(self.params['pulse_shape'])) for e in elements: seq.append(name=e.name, wfname=e.name, trigger_wait=True) # upload the waveforms to the AWG if upload: if upload=='old_method': qt.pulsar.upload(*elements) qt.pulsar.program_sequence(seq) else: qt.pulsar.program_awg(seq,*elements)
def generate_sequence(self, upload=True): # MBI element mbi_elt = self._MBI_element() # electron manipulation pulses self.T = pulse.SquarePulse(channel='MW_pulsemod', length = 100e-9, amplitude = 0) self.g_pulse = self.PulseClass('gaussian IQ pulse', I_channel = 'MW_Imod', Q_channel = 'MW_Qmod', PM_channel = 'MW_pulsemod', PM_risetime = self.params['MW_pulse_mod_risetime'], frequency = self.params['pulse_mod_frqs'][0], amplitude = self.params['pulse_amps'][0], length = self.params['pulse_durations'][0]) elts = [] for i in range(self.params['pts']): e = element.Element('ERabi_pt-{}'.format(i), pulsar=qt.pulsar) e.append(self.T) for j in range(self.params['MW_pulse_multiplicities'][i]): e.append( pulse.cp(self.g_pulse, frequency = self.params['pulse_mod_frqs'][i], amplitude = self.params['pulse_amps'][i], length = self.params['pulse_durations'][i])) e.append( pulse.cp(self.T, length=self.params['MW_pulse_delays'][i])) elts.append(e) sync_elt = element.Element('adwin_sync', pulsar=qt.pulsar) adwin_sync = pulse.SquarePulse(channel='adwin_sync', length = 10e-6, amplitude = 2) sync_elt.append(adwin_sync) seq = pulsar.Sequence('CNOT sequence') for i in range(self.params['pts']): seq.append(name = 'MBI-%d' % i, wfname = mbi_elt.name, trigger_wait = True, goto_target = 'MBI-%d' % i, jump_target = 'pulse-{}'.format(i)) seq.append(name = 'pulse-{}'.format(i), wfname = elts[i].name, trigger_wait=True) seq.append(name = 'sync-{}'.format(i), wfname = sync_elt.name) # program AWG if upload: qt.pulsar.upload(mbi_elt, sync_elt, *elts) qt.pulsar.program_sequence(seq)
def generate_sweep_test_sequence(pts, syncs_per_sweep): sync = pulse.SquarePulse(channel = 'sync', length = 50e-9, amplitude = 2) sync_T = pulse.SquarePulse(channel = 'sync', length = 1e-6, amplitude = 0) ch0 = pulse.SquarePulse(channel = 'AOM_Yellow', length = 50e-9, amplitude = 2) #photon_T = pulse.SquarePulse(channel = 'AOM_Yellow', # length = 1e-6, amplitude = 0) ch1 = pulse.SquarePulse(channel = 'RND_halt', length = 50e-9, amplitude = 2) #MA1_T = pulse.SquarePulse(channel = 'RND_halt', # length = 1e-6, amplitude = 0) seq = pulsar.Sequence('PQ_testing') elts=[] for i in range(pts): elt = element.Element('el-{}'.format(i), pulsar=qt.pulsar) elt.add(sync_T, name='sync_T') elt.add(sync, refpulse='sync_T', name='sync') elt.add(ch0, start = 500e-9+i*10e-9, refpulse = 'sync', refpoint = 'start') elt.add(ch1, start = 250e-9+i*10e-9, refpulse = 'sync', refpoint = 'start') #elt.append(pulse.cp(photon_T, length=1e-6)) #syncs_elt_mod0 = element.Element('2_syncs_photon_after_first', pulsar=qt.pulsar) #syncs_elt_mod0.append(sync_T) #s1 = syncs_elt_mod0.append(sync) #syncs_elt_mod0.append(pulse.cp(sync_T, length=500e-9)) #s2 = syncs_elt_mod0.append(sync) #syncs_elt_mod0.append(pulse.cp(sync_T, length=10e-6)) #syncs_elt_mod0.add(photon, # start = 50e-9, # refpulse = s1) elts.append(elt) seq.append(name = 'test-{}'.format(i), wfname = elt.name, repetitions = syncs_per_sweep, trigger_wait = True if i == 0 else False) #seq.append(name = 'photon_after_sync1', # wfname = syncs_elt_mod0.name, # repetitions = 100) #qt.pulsar.upload(no_syncs_elt, syncs_elt_mod0) #qt.pulsar.program_sequence(seq) qt.pulsar.program_awg(seq,*elts)
def generate_sequence(self, upload=True): # electron manipulation pulses T = pulse.SquarePulse(channel='MW_pulsemod', length=10e-9, amplitude=0) CORPSE = pulselib.IQ_CORPSE_pulse( 'CORPSE pi-pulse', I_channel=self.params['cur_MW_channel'], Q_channel='dummy', PM_channel='MW_pulsemod', #second_MW_channel = 'MW_Qmod', PM_risetime=self.params['MW_pulse_mod_risetime'], amplitude=self.params['CORPSE_pi_amp'], frequency=self.params['frq_mod'], rabi_frequency=self.params['CORPSE_rabi_frequency'], pulse_delay=self.params['CORPSE_pulse_delay'], eff_rotation_angle=self.params['CORPSE_eff_rotation_angle']) CORPSE.channels.remove('dummy') wait_1us = element.Element('1us_delay', pulsar=qt.pulsar) wait_1us.append(pulse.cp(T, length=1e-6)) sync_elt = element.Element('adwin_sync', pulsar=qt.pulsar) adwin_sync = pulse.SquarePulse(channel='adwin_sync', length=10e-6, amplitude=2) sync_elt.append(adwin_sync) elts = [] for i in range(self.params['pts']): e = element.Element('CORPSE-{}'.format(i), pulsar=qt.pulsar) e.append( T, pulse.cp(CORPSE, amplitude=self.params['CORPSE_pi_sweep_amps'][i], pulse_delay=self.params['CORPSE_pulse_delays'][i])) elts.append(e) # sequence seq = pulsar.Sequence('CORPSE pi calibration') for i, e in enumerate(elts): for j in range(self.params['multiplicity']): seq.append(name=e.name + '-{}'.format(j), wfname=e.name, trigger_wait=(j == 0)) seq.append(name='wait-{}-{}'.format(i, j), wfname=wait_1us.name, repetitions=self.params['delay_reps']) seq.append(name='sync-{}'.format(i), wfname=sync_elt.name) # program AWG if upload: #qt.pulsar.upload(sync_elt, wait_1us, *elts) qt.pulsar.program_awg(seq, sync_elt, wait_1us, *elts)
def generate_sequence(self): seq = pulsar.Sequence('Belllt3') bseq.pulse_defs_lt3(self) elements = [] #dummy_element = bseq._dummy_element(self) finished_element = bseq._lt3_sequence_finished_element(self) start_element = bseq._lt3_sequence_start_element(self) succes_element = bseq._lt3_entanglement_event_element(self) elements.append(start_element) elements.append(finished_element) elements.append(succes_element) LDE_element = bseq._LDE_element(self, name='LDE_lt3') elements.append(LDE_element) #seq.append(name = 'start_LDE', # trigger_wait = True, # wfname = start_element.name) seq.append(name='LDE_lt3', wfname=LDE_element.name, trigger_wait=True, jump_target='RO_dummy', repetitions=self.joint_params['LDE_attempts_before_CR']) seq.append( name='LDE_timeout', wfname=finished_element.name, goto_target='LDE_lt3_TPQI_norm' if self.joint_params['TPQI_normalisation_measurement'] else 'LDE_lt3') if self.joint_params['TPQI_normalisation_measurement']: seq.append(name='LDE_lt3_TPQI_norm', trigger_wait=True, wfname=LDE_element.name, jump_target='RO_dummy', repetitions=self.joint_params['LDE_attempts_before_CR']) seq.append(name='LDE_timeout_2', wfname=finished_element.name, goto_target='LDE_lt3') seq.append(name='RO_dummy', wfname=succes_element.name, goto_target='LDE_lt3') #qt.pulsar.program_awg(seq,*elements) qt.pulsar.upload(*elements) qt.pulsar.program_sequence(seq)
def generate_sequence(self, upload = True, **kw): qt.pulsar.AWG_sequence_cfg['JUMP_TIMING'] = 0 # ASYNC seq = pulsar.Sequence('Square Pulses') seq.set_djump(True) elements = [] adwin_sync = pulse.SquarePulse(channel='adwin_sync', length = 1e-6, amplitude = 2) empty = pulse.SquarePulse(channel = 'adwin_sync', length = 1e-6, amplitude = 0) jump_index = 0 e_loop = element.Element('loop', pulsar = qt.pulsar, global_time = True, min_samples = 1e3) e_wait = element.Element('trigger_wait', pulsar = qt.pulsar, global_time = True, min_samples = 1e3) # currently not used e_wait.add(pulse.cp(empty), name = e_wait.name) elements.append(e_wait) seq.append(name = e_wait.name, wfname = e_wait.name, goto_target = e_loop.name, trigger_wait = True) # seq.add_djump_address(jump_index, e_wait.name) e_loop.add(pulse.cp(empty, length = 1e-3), name = e_loop.name) elements.append(e_loop) seq.append(name = e_loop.name, wfname = e_loop.name, goto_target = e_wait.name, repetitions = 65536) for name, ps in kw.iteritems(): jump_index += 1 e = element.Element(name + '-%d' % jump_index, pulsar = qt.pulsar, global_time = True, min_samples = 1e3) e.add(pulse.cp(ps), name = e.name) elements.append(e) seq.append(name = e.name, wfname = e.name, goto_target = e_loop.name) seq.add_djump_address(jump_index, e.name) # For some strange reason the last pulse doenst treat goto_target correctly e_sync = element.Element('sync', pulsar = qt.pulsar, global_time = True, min_samples = 1e3) e_sync.add(pulse.cp(adwin_sync), name = e_sync.name) elements.append(e_sync) seq.append(name = e_sync.name, wfname = e_sync.name, goto_target = e_loop.name) seq.add_djump_address(0, e_sync.name) # upload the waveforms to the AWG if upload: if upload=='old_method': qt.pulsar.upload(*elements) qt.pulsar.program_sequence(seq) else: qt.pulsar.program_awg(seq,*elements)
def generate_test_sequence(): RND_halt_combiner_ch = 'RND_halt' RND_halt_QRNG_ch = 'plu_sync' sync_ch = 'adwin_success_trigger' sync = pulse.SquarePulse(channel=sync_ch, length=50e-9, amplitude=2) RND_halt_QRNG = pulse.SquarePulse(channel=RND_halt_QRNG_ch, length=200e-9, amplitude=2) RND_halt_combiner = pulse.SquarePulse(channel=RND_halt_combiner_ch, length=200e-9, amplitude=2) elt = element.Element('combiner_test_elt', pulsar=qt.pulsar) elt.add(sync, name='sync_T', start=100e-9) elt.add(RND_halt_QRNG, start=500e-9, refpulse='sync_T', name='RND_halt_QRNG_p') elt.add(RND_halt_combiner, start=100e-9, refpulse='RND_halt_QRNG_p', refpoint='start', name='RND_halt_combiner_p') elt.add(pulse.cp(sync, amplitude=0, length=15e-6)) elt2 = element.Element('combiner_test_wait_elt', pulsar=qt.pulsar) elt2.add(pulse.cp(sync, amplitude=0, length=15e-6), start=500e-9) seq = pulsar.Sequence('combiner_test_seq') seq.append(name='combiner_test_seq1', wfname=elt2.name, repetitions=1, trigger_wait=True) seq.append(name='combiner_test_seq2', wfname=elt.name, repetitions=50000, trigger_wait=False) #seq.append(name = 'photon_after_sync1', # wfname = syncs_elt_mod0.name, # repetitions = 100) #qt.pulsar.upload(no_syncs_elt, syncs_elt_mod0) #qt.pulsar.program_sequence(seq) qt.pulsar.program_awg(seq, elt, elt2)
def generate_sequence(self, upload=True): # electron manipulation pulses T = pulse.SquarePulse(channel='MW_pulsemod', length=100e-9, amplitude=0) CORPSE = pulselib.IQ_CORPSE_pulse( 'CORPSE pulse', I_channel='MW_Imod', Q_channel='MW_Qmod', PM_channel='MW_pulsemod', PM_risetime=self.params['MW_pulse_mod_risetime'], frequency=self.params['CORPSE_mod_frq'], rabi_frequency=self.params['CORPSE_rabi_frequency']) sync_elt = element.Element('adwin_sync', pulsar=qt.pulsar) adwin_sync = pulse.SquarePulse(channel='adwin_sync', length=10e-6, amplitude=2) sync_elt.append(adwin_sync) wait_1us = element.Element('1us_delay', pulsar=qt.pulsar) wait_1us.append(pulse.cp(T, length=1e-6)) elts = [] for i in range(self.params['pts']): e = element.Element('CORPSE-{}'.format(i), pulsar=qt.pulsar, global_time=True) e.append(T) e.append( pulse.cp(CORPSE, amplitude=self.params['CORPSE_sweep_amps'][i], eff_rotation_angle=self. params['CORPSE_effective_rotation_angles'][i])) elts.append(e) # sequence seq = pulsar.Sequence('CORPSE (any angle) calibration') for i, e in enumerate(elts): seq.append(name=e.name + '-{}'.format(i), wfname=e.name, trigger_wait=True) seq.append(name='sync-{}'.format(i), wfname=sync_elt.name) # program AWG if upload: #qt.pulsar.upload(sync_elt, *elts) qt.pulsar.program_awg(seq, sync_elt, wait_1us, *elts)
def _add_MBI_and_sweep_elements_to_sequence(self, sweep_elements, *N_RO_elements, **kw): append_sync = kw.pop('append_sync', True) N_RO_repetitions = kw.pop('N_RO_repetitions', 1) # the sequence seq = pulsar.Sequence('{}_{} sequence'.format(self.mprefix, self.name)) for i, e in enumerate(sweep_elements): # the element we jump to after MBI depends on the type of # list we supply as sweep elements if type(e) == list: jmp = 'sweep_element-{}-{}'.format(i, 0) else: jmp = 'sweep_element-{}'.format(i) # for each sweep point we want first an MBI step seq.append(name='MBI-{}'.format(i), wfname=self.mbi_elt.name, trigger_wait=True, goto_target='MBI-{}'.format(i), jump_target=jmp) # append either the only element or the specified sequence of # elements for this sweep point if type(e) != list: seq.append(name='sweep_element-{}'.format(i), wfname=e.name, trigger_wait=True) else: for j, sub_e in enumerate(e): seq.append(name='sweep_element-{}-{}'.format(i, j), wfname=sub_e.name, trigger_wait=(j == 0)) if append_sync: seq.append(name='sync-{}'.format(i), wfname=self.adwin_lt1_trigger_element.name) for k in range(N_RO_repetitions): for j, e in enumerate(N_RO_elements): seq.append(name='N_RO-{}-{}-{}'.format(i, k, j), wfname=e.name, trigger_wait=(j == 0 and append_sync)) return seq
def lt2_sequence(self): print "Make lt2 sequence... " self.lt2_seq = pulsar.Sequence('TeleportationLT2') dummy_element = tseq._lt2_dummy_element(self) LDE_element = tseq._lt2_LDE_element( self, use_short_eom_pulse=self.params['use_short_eom_pulse']) finished_element = tseq._lt2_sequence_finished_element(self) self.lt2_seq.append( name='LDE_LT2', wfname=(LDE_element.name if DO_LDE_SEQUENCE else dummy_element.name), trigger_wait=True, # jump_target = 'DD', TODO: not implemented yet goto_target='LDE_LT2', repetitions=self.params['LDE_attempts_before_CR']) elements = [] elements.append(dummy_element) elements.append(finished_element) if DO_LDE_SEQUENCE: elements.append(LDE_element) qt.pulsar.upload(*elements) qt.pulsar.program_sequence(self.lt2_seq) self.awg_lt2.set_runmode('SEQ') self.awg_lt2.start() i = 0 awg_ready = False while not awg_ready and i < 40: try: if self.awg_lt2.get_state() == 'Waiting for trigger': awg_ready = True except: print 'waiting for awg: usually means awg is still busy and doesnt respond' print 'waiting', i, '/40' i = i + 1 qt.msleep(0.5) if not awg_ready: raise Exception('AWG not ready') def finish(self): self.awg_lt2.stop() self.awg_lt2.set_runmode('CONT')
def program_test_slave(reset=False): T = pulse.SquarePulse('sync', length=10e-9, amplitude=0) p_sync = pulse.SquarePulse('sync', length=50e-9, amplitude=1) e = element.Element('Test_trigger', pulsar=qt.pulsar) e.append(T) e.append(p_sync) e.append(pulse.cp(T, length=5e-6)) s = pulsar.Sequence('TEST_AWG_SYNC_lt3') s.append(name='Slave', wfname=e.name, trigger_wait=1) if reset: print 'RESETTING AWG' qt.pulsar.program_awg(s, e) else: qt.pulsar.upload(e) qt.pulsar.program_sequence(s) qt.instruments['AWG'].start()
def generate_sequence(self, upload=True): ''' if self.params['setup'] == 'lt4': bseq.pulse_defs_lt4(self) elif self.params['setup'] == 'lt3': bseq.pulse_defs_lt3(self) ''' # Here is our pi pulse for excitation eom_pulse = self.eom_pulse # A handy sync pulse for the time tagger T_sync = pulse.SquarePulse(channel='sync', length=50e-9, amplitude=0) # Everyone likes delays T = pulse.SquarePulse(channel='MW_Imod', name='delay') T.amplitude = 0. # make the elements - one for each delay elements = [] for i, delay in enumerate(self.params['opt_pulse_delays']): e = element.Element('seq_TPQI_delay-%d' % i, pulsar=qt.pulsar) e.append(T_sync) # Add in a bunch of optical pi pulses, separated by our precious delay for i in range(self.params['opt_pi_pulses']): name = 'opt pi {}'.format(i + 1) T.length = delay e.append(eom_pulse) e.append(T) elements.append(e) print "Done" # create a sequence from the pulses seq = pulsar.Sequence('seq_TPQI sequence') for e in elements: seq.append(name=e.name, wfname=e.name, trigger_wait=True) # upload the waveforms to the AWG if upload: if upload == 'old_method': qt.pulsar.upload(*elements) qt.pulsar.program_sequence(seq) else: qt.pulsar.program_awg(seq, *elements)