def generate_sequence(self, upload=True, **kw): T = pulse.SquarePulse(channel='MW_pulsemod', length=10e-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']) fast_pi = pulse.cp(X, amplitude=self.params['fast_pi_amp'], length=self.params['fast_pi_duration'], frequency=self.params['fast_pi_mod_frq']) fast_pi2 = pulse.cp(X, amplitude=self.params['fast_pi2_amp'], length=self.params['fast_pi2_duration'], frequency=self.params['fast_pi2_mod_frq']) mbi_elt = self._MBI_element() 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('Zeroth revival sequence') for i in range(self.params['pts']): e = element.Element('pi2_pi_pi2-{}'.format(i), pulsar=qt.pulsar, global_time=True, time_offset=0.) e.append(T) e.append(fast_pi2) e.append(pulse.cp(T, length=self.params['free_evolution_times'][i])) e.append(fast_pi) e.append(pulse.cp(T, length=self.params['free_evolution_times'][i])) e.append(pulse.cp(fast_pi2, phase=self.params['pi2_phases'][i])) e.append(T) elts.append(e) seq.append(name='MBI-{}'.format(i), wfname=mbi_elt.name, trigger_wait=True, goto_target='MBI-{}'.format(i), jump_target=e.name) seq.append(name='pi2_pi_pi2-{}'.format(i), wfname=e.name, trigger_wait=True) seq.append(name='sync-{}'.format(i), wfname=sync_elt.name) if upload: qt.pulsar.upload(mbi_elt, sync_elt, *elts) qt.pulsar.program_sequence(seq)
def generate_sequence(self, upload=True): #print 'test' # define the necessary pulses X1 = pulselib.IQ_CORPSE_pulse('CORPSE pi-pulse', I_channel = 'MW_1', 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'], rabi_frequency = self.params['CORPSE_pi_frq'], eff_rotation_angle = 180) X1.channels.remove('dummy') X2 = pulselib.IQ_CORPSE_pulse('CORPSE 2pi-pulse', I_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) X2.channels.remove('dummy') 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 _create_wait_times(Gate): Gate.TIQ = pulse.SquarePulse(channel = 'MW_Imod',length=2e-6) Gate.T = pulse.SquarePulse(channel='MW_pulsemod', length = 50e-9, amplitude = 0) Gate.T_sync = pulse.SquarePulse(channel='sync', length = 50e-9, amplitude = 0)
def generate_sequence(self, **kw): upload = kw.pop('upload', True) T = pulse.SquarePulse(channel = 'Velocity1AOM', length = 1e-6, amplitude = 0.) R = pulse.SquarePulse(channel = 'Velocity1AOM', amplitude = 1.0) Y = pulse.SquarePulse(channel = 'YellowAOM', amplitude = 1.0) MW = pulselib.MW_IQmod_pulse('Long weak pulse', I_channel='MW_Imod', Q_channel='MW_Qmod', PM_channel='MW_pulsemod', frequency = self.params['ms-1_cntr_frq'] - self.params['mw_frq'], PM_risetime = self.params['MW_pulse_mod_risetime'], amplitude = 0.1) ionization_element = element.Element('ionization_element', pulsar = qt.pulsar) ionization_element.add(pulse.cp(R, amplitude = self.params['red_ionization_amplitude'], length = 10e-6), name = 'red ionization pulse') ionization_element.add(pulse.cp(MW, length = 9.5e-6), refpulse = 'red ionization pulse', refpoint = 'start') delay_element = element.Element('delay_element', pulsar = qt.pulsar) delay_element.append(T) 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('Yellow RP Calibration sequence') elements = [] for i in range(self.params['pts']): self.params['AWG_yellow_rp_amplitude'] = \ self.repump_aom.power_to_voltage( self.params['AWG_yellow_rp_powers'][i], controller='sec') repump_element = element.Element('repump_element-{}'.format(i), pulsar = qt.pulsar) repump_element.append(pulse.cp(Y, length = 10e-6, amplitude = self.params['AWG_yellow_rp_amplitude'])) elements.append(repump_element) seq.append(name = ionization_element.name+'_{}'.format(i), wfname = ionization_element.name, trigger_wait = True, repetitions = int(self.params['red_ionization_durations'][i]/10e-6)) seq.append(name = delay_element.name+'_{}'.format(i), wfname = delay_element.name) seq.append(name = repump_element.name+'_{}'.format(i), wfname = repump_element.name, repetitions = int(self.params['yellow_rp_durations'][i]/10e-6)) seq.append(name = sync_elt.name+'-{}'.format(i), wfname = sync_elt.name) # upload the waveforms to the AWG if upload: qt.pulsar.upload(ionization_element, delay_element, sync_elt, *elements) # program the AWG qt.pulsar.program_sequence(seq)
def jitter_timings(name, debug = False, upload = True, run_msmt = True): m = SquarePulseJitter(name) m.adwin_process = 'dynamic_jump' m.params.from_dict(qt.exp_params['samples'][SAMPLE]) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['AdwinSSRO-integrated']) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO+espin']) m.params.from_dict(qt.exp_params['protocols']['cr_mod']) m.params.from_dict(qt.exp_params['protocols'][SAMPLE_CFG]['pulses']) m.params['pulse_type'] = 'Square' m.params['pulse_shape'] = 'Square' m.params['pts'] = 14 m.params['repetitions'] = 1e4 # lt3 params m.params['AWG_start_DO_channel'] = 9 m.params['AWG_jump_strobe_DO_channel'] = 0 m.params['jump_bit_shift'] = 4 m.params['sweep_length'] = m.params['pts'] m.params['reps'] = m.params['repetitions'] * m.params['pts'] m.params['minimal_delay_time'] = 0 m.params['minimal_delay_cycles'] = 0 m.params['delay_clock_cycle_time'] = 20e-9 # m.params['delay_time'] = 2e-6; pulseA = pulse.SquarePulse(channel='HHsync', amplitude = 5, length = 40e-9); pulseB = pulse.SquarePulse(channel='tico_sync', amplitude = 5, length = 40e-9); # Start measurement m.generate_sequence(upload = upload, Square_A = pulseA, Square_B = pulseB) # Print the tables that go to the adwin # print m.params['jump_table'] # print m.params['next_seq_table'] # for delays in m.params['delays_before_jumps']: # print [round(var, 12) for var in delays] if run_msmt: #delay_cycle = np.rint(m.params['delay_time'] / m.params['delay_clock_cycle_time']).astype(np.int32) min_delay = 47 delay_cycles = np.zeros(m.params['pts'] * 2) delay_cycles[0::2] = 100 delay_cycles[1::2] = np.array(range(min_delay, min_delay + m.params['pts'])) delay_cycles = delay_cycles.astype(np.int32) print delay_cycles seq_indices = np.arange(m.params['pts']+1)*2+1 random_jumps = np.random.randint(low = 1, high = 2, size = 1e3) # Unused atm jump_table = np.array([1, 2] * m.params['pts']) next_seq_table = np.repeat(0, 1) # Unused atm m.adwin.start_dynamic_jump(do_init_only = 1) # Necessary for init qt.msleep(0.05) m.adwin.set_dynamic_jump_var( jump_table = (2**m.params['jump_bit_shift']) * jump_table, delay_cycles = delay_cycles, next_seq_table = next_seq_table, seq_indices = seq_indices, random_ints = (2**m.params['jump_bit_shift']) * random_jumps, ) print 'Waiting until AWG done' qt.msleep(7) m.awg.start() qt.msleep(2) print 'Starting msmt' m.adwin.start_dynamic_jump( AWG_start_DO_channel = m.params['AWG_start_DO_channel'], AWG_jump_strobe_DO_channel = m.params['AWG_jump_strobe_DO_channel'], do_init_only = 0, jump_bit_shift = m.params['jump_bit_shift'], sweep_length = m.params['sweep_length'], reps = m.params['reps'], ) pqt.run_HH('getTHdata')
low=0, offset=0., delay=0., active=True) qt.pulsar.define_channel(id='ch4_marker2', name='th_ch1', type='marker', high=2.0, low=0, offset=0., delay=0., active=True) #qt.pulsar.define_channel(id='ch4_marker2', name='th_ch1', type='marker', # high=2.0, low=0, offset=0., delay=0., active=True) test_pulse = pulse.SquarePulse(channel='th_sync', amplitude=1.0) test_pulse2 = pulse.SquarePulse(channel='th_ch1', amplitude=1.0) #test_pulse3 = pulse.SquarePulse(channel = 'th_ch1', amplitude = 1.0) elt1 = element.Element('idle', pulsar=qt.pulsar) #print 'Channel definitions: ' #pprint.pprint(test_element._channels) elt1.add(pulse.cp(test_pulse2, amplitude=1.0, length=100e-9), start=100e-9) elt1.add(pulse.cp(test_pulse, amplitude=1.0, length=1000e-9), start=600e-9) elt1.add(pulse.cp(test_pulse2, amplitude=1.0, length=100e-9), start=1800e-9) elt1.add(pulse.cp(test_pulse2, amplitude=0, length=1000e-9), start=1900e-9) #elt1.add(pulse.cp(test_pulse3, amplitude = 1.0, length = 100e-9), start = 600e-9) #elt1.add(pulse.cp(test_pulse3, amplitude = 0.0, length = 10000e-9), start = 800e-9)
def pulse_defs_lt1(msmt): # a waiting pulse on the MW pulsemod channel msmt.T = pulse.SquarePulse(channel='MW_pulsemod', length=50e-9, amplitude=0) msmt.TIQ = pulse.SquarePulse(channel='MW_Imod', length=10e-9, amplitude=0) # some not yet specified pulse on the electron msmt.e_pulse = pulselib.MW_IQmod_pulse( 'MW pulse', I_channel='MW_Imod', Q_channel='MW_Qmod', PM_channel='MW_pulsemod', PM_risetime=msmt.params['MW_pulse_mod_risetime']) msmt.CORPSE_pi = pulselib.MW_CORPSE_pulse( 'CORPSE pi-pulse', MW_channel='MW_Imod', PM_channel='MW_pulsemod', second_MW_channel='MW_Qmod', PM_risetime=msmt.params['MW_pulse_mod_risetime'], amplitude=msmt.params['CORPSE_pi_amp'], rabi_frequency=msmt.params['CORPSE_rabi_frequency'], eff_rotation_angle=180) msmt.CORPSE_pi2 = pulselib.MW_CORPSE_pulse( 'CORPSE pi2-pulse', MW_channel='MW_Imod', PM_channel='MW_pulsemod', second_MW_channel='MW_Qmod', PM_risetime=msmt.params['MW_pulse_mod_risetime'], amplitude=msmt.params['CORPSE_pi2_amp'], rabi_frequency=msmt.params['CORPSE_rabi_frequency'], eff_rotation_angle=90) msmt.CORPSE_RND0 = pulselib.MW_CORPSE_pulse( 'CORPSE pi2-pulse', MW_channel='MW_Imod', PM_channel='MW_pulsemod', PM_risetime=msmt.params['MW_pulse_mod_risetime'], amplitude=msmt.params['CORPSE_RND_amp'], rabi_frequency=msmt.params['CORPSE_rabi_frequency'], eff_rotation_angle=msmt.params['RND_angle_0']) msmt.CORPSE_RND1 = pulselib.MW_CORPSE_pulse( 'CORPSE pi2-pulse', MW_channel='MW_Qmod', PM_channel='MW_pulsemod', PM_risetime=msmt.params['MW_pulse_mod_risetime'], amplitude=msmt.params['CORPSE_RND_amp'], rabi_frequency=msmt.params['CORPSE_rabi_frequency'], eff_rotation_angle=msmt.params['RND_angle_1']) msmt.eom_pulse = eom_pulses.EOMAOMPulse( 'Eom Aom Pulse', eom_channel='EOM_Matisse', aom_channel='EOM_AOM_Matisse', eom_pulse_duration=msmt.params['eom_pulse_duration'], eom_off_duration=msmt.params['eom_off_duration'], eom_off_amplitude=msmt.params['eom_off_amplitude'], eom_pulse_amplitude=msmt.params['eom_pulse_amplitude'], eom_overshoot_duration1=msmt.params['eom_overshoot_duration1'], eom_overshoot1=msmt.params['eom_overshoot1'], eom_overshoot_duration2=msmt.params['eom_overshoot_duration2'], eom_overshoot2=msmt.params['eom_overshoot2'], aom_risetime=msmt.params['aom_risetime'], aom_amplitude=msmt.params['aom_amplitude']) msmt.RND_halt_off_pulse = pulse.SquarePulse( channel='RND_halt', amplitude=-2.0, length=msmt.params['RND_duration']) ### synchronizing, etc msmt.adwin_trigger_pulse = pulse.SquarePulse(channel='adwin_sync', length=5e-6, amplitude=2) msmt.adwin_success_pulse = pulse.SquarePulse( channel='adwin_success_trigger', length=5e-6, amplitude=2) msmt.sync = pulse.SquarePulse(channel='sync', length=50e-9, amplitude=1.0) msmt.SP_pulse = pulse.SquarePulse(channel='AOM_Newfocus', amplitude=1.0) msmt.RO_pulse = pulse.SquarePulse(channel='AOM_Matisse', amplitude=0.0) msmt.yellow_pulse = pulse.SquarePulse(channel='AOM_Yellow', amplitude=1.0) return True
def generate_sequence(self, upload=True): # MBI element mbi_elt = self._MBI_element() # 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) fast_pi = pulselib.MW_IQmod_pulse( 'MW 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['fast_pi_mod_frq'], amplitude=self.params['fast_pi_amp'], length=self.params['fast_pi_duration']) fast_pi2 = pulselib.MW_IQmod_pulse( 'MW pi2 pulse', I_channel='MW_Imod', Q_channel='MW_Qmod', PM_channel='MW_pulsemod', PM_risetime=self.params['MW_pulse_mod_risetime'], frequency=self.params['fast_pi2_mod_frq'], amplitude=self.params['fast_pi2_amp'], length=self.params['fast_pi2_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) # electron manipulation elements elts = [] seq = pulsar.Sequence('Pi2 Calibration') for i in range(self.params['pts_awg']): e = element.Element('Pi2_Pi-{}'.format(i), pulsar=qt.pulsar, global_time=True) e.append(T) e.append( pulse.cp(fast_pi2, amplitude=self.params['pi2_sweep_amps'][i])) e.append(pulse.cp(TIQ, length=200e-9)) e.append(pulse.cp(fast_pi)) e.append(T) elts.append(e) seq.append(name='MBIa-%d' % i, wfname=mbi_elt.name, trigger_wait=True, goto_target='MBIa-%d' % i, jump_target=e.name) seq.append(name='Pi2_Pi-{}'.format(i), wfname=e.name, trigger_wait=True) seq.append(name='synca-{}'.format(i), wfname=sync_elt.name) e = element.Element('Pi2-{}'.format(i), pulsar=qt.pulsar, global_time=True) e.append(T) e.append( pulse.cp(fast_pi2, amplitude=self.params['pi2_sweep_amps'][i])) e.append(pulse.cp(TIQ, length=200e-9)) e.append(T) elts.append(e) seq.append(name='MBIb-%d' % i, wfname=mbi_elt.name, trigger_wait=True, goto_target='MBIb-%d' % i, jump_target=e.name) seq.append(name='Pi2-{}'.format(i), wfname=e.name, trigger_wait=True) seq.append(name='syncb-{}'.format(i), wfname=sync_elt.name) if upload: qt.pulsar.upload(mbi_elt, sync_elt, *elts) qt.pulsar.program_sequence(seq)
def generate_sequence(self): SP_A_pulse = pulse.SquarePulse(channel='AOM_Newfocus', amplitude=1.0) SP_E_pulse = pulse.SquarePulse(channel='EOM_AOM_Matisse', amplitude=1.0) RO_pulse = pulse.SquarePulse(channel='EOM_AOM_Matisse', amplitude=1.0) T = pulse.SquarePulse(channel='AOM_Newfocus', length=self.params['wait_length'], amplitude=0) adwin_trigger_pulse = pulse.SquarePulse(channel='adwin_sync', length=5e-6, amplitude=2) PQ_sync = pulse.SquarePulse(channel='sync', length=self.params['pq_sync_length'], amplitude=1.0) MW_pi = pulselib.HermitePulse_Envelope( 'Hermite pi-pulse', MW_channel='MW_Imod', PM_channel='MW_pulsemod', second_MW_channel='MW_Qmod', amplitude=self.params['Hermite_pi_amp'], length=self.params['Hermite_pi_length'], PM_risetime=self.params['MW_pulse_mod_risetime'], pi2_pulse=False) elements = [] finished_element = element.Element('finished', pulsar=qt.pulsar) finished_element.append(adwin_trigger_pulse) elements.append(finished_element) seq = pulsar.Sequence('FastSSRO') for i in range(self.params['pts'] / 2): e0 = element.Element('SSRO-ms0-{}'.format(i), pulsar=qt.pulsar) e0.append(pulse.cp(T, length=1e-6)) e0.append(PQ_sync) e0.append(T) e0.append( pulse.cp(SP_A_pulse, length=self.params['A_SP_durations_AWG'][i])) e0.append(T) e0.append( pulse.cp(RO_pulse, length=self.params['pi_pulse_time'][i], amplitude=self.params['E_RO_voltages_AWG'][i])) e0.append(pulse.cp(T, length=self.params['wait_length_MW'])) e0.append(MW_pi) e0.append(pulse.cp(T, length=self.params['wait_length_MW'])) e0.append( pulse.cp(RO_pulse, length=self.params['E_RO_durations_AWG'][i] - self.params['pi_pulse_time'][i], amplitude=self.params['E_RO_voltages_AWG'][i])) e0.append(T) elements.append(e0) seq.append(name='SSRO-ms0-{}'.format(i), wfname=e0.name, trigger_wait=True) seq.append(name='finished-ms0-{}'.format(i), wfname=finished_element.name, trigger_wait=False) e1 = element.Element('SSRO-ms1-{}'.format(i), pulsar=qt.pulsar) e1.append(pulse.cp(T, length=1e-6)) e1.append(PQ_sync) e1.append(T) e1.append( pulse.cp(SP_E_pulse, length=self.params['E_SP_durations_AWG'][i], amplitude=self.params['E_SP_voltages_AWG'][i])) e1.append(T) e1.append( pulse.cp(RO_pulse, length=self.params['pi_pulse_time'][i], amplitude=self.params['E_RO_voltages_AWG'][i])) e1.append(pulse.cp(T, length=self.params['wait_length_MW'])) e1.append(MW_pi) e1.append(pulse.cp(T, length=self.params['wait_length_MW'])) e1.append( pulse.cp(RO_pulse, length=self.params['E_RO_durations_AWG'][i] - self.params['pi_pulse_time'][i], amplitude=self.params['E_RO_voltages_AWG'][i])) e1.append(T) elements.append(e1) seq.append(name='SSRO-ms1-{}'.format(i), wfname=e1.name, trigger_wait=True) seq.append(name='finished-ms1-{}'.format(i), wfname=finished_element.name, trigger_wait=False) qt.pulsar.program_awg(seq, *elements)
def generate_sequence(self): #define the pulses sq_p7889=pulse.SquarePulse(channel='p7889_start',name='p7889_square',amplitude=1) sq_p7889.length=1e-6 #is the length of the p7889 start pulse a problem?? ## changed from 2e-6 to 1e-6 sq_AOMpulse=pulse.SquarePulse(channel='AOM_Green',name='Green_square') sq_AOMpulse.amplitude=1 #sets the marker high sq_AOMpulse.length=self.params['GreenAOM_pulse_length'] wait = pulse.SquarePulse(channel='AOM_Green',name='Green_square') wait.amplitude = 0 wait.length=2e-6 X = pulselib.MW_IQmod_pulse('Rabi_MW_pulse', I_channel='MW_Imod', Q_channel='MW_Qmod', PM_channel='MW_pulsemod', amplitude = self.params['ssbmod_amplitude'], frequency = self.params['ssbmod_frequency'], PM_risetime = self.params['MW_pulse_mod_risetime']) #need one spin polarization pulse at the beginning. init=element.Element('initialize',pulsar=qt.pulsar) init.add(pulse.cp(sq_AOMpulse,length=1e-6,amplitude=0),name='wait') init.add(sq_AOMpulse,name='init',refpulse='wait') init.add(wait,name='init_wait',refpulse='init') #generate a list of pulse elements. One for each modulation freuqency elements=[] elements.append(init) # old sequence MJD # e=element.Element('Rabi_length-%d' % k,pulsar=qt.pulsar) # e.add(pulse.cp(wait,length=2e-6,amplitude=0),name='wait_int') # e.add(X(length=t),name='MWpulse',refpulse='wait_int',refpoint='end') # e.add(sq_p7889,name='p7889Start',refpulse='MWpulse',refpoint='end') # e.add(sq_AOMpulse,start=1e-6,name='GreenLight',refpulse='p7889Start',refpoint='end') # e.add(pulse.cp(sq_AOMpulse,length=50e-9,amplitude=0),name='wait',refpulse='GreenLight') # elements.append(e) for k,t in enumerate(self.params['sweep_pts']/1.e6): e=element.Element('Rabi_length-%d' % k,pulsar=qt.pulsar) e.add(pulse.cp(wait,length=-1e-6,amplitude=0),name='wait_int') e.add(X(length=t),name='MWpulse',refpulse='wait_int',refpoint='end') e.add(sq_p7889,name='p7889Start',start=0.4e-6,refpulse='MWpulse',refpoint='end') e.add(sq_AOMpulse,start=2.1e-6,name='GreenLight',refpulse='p7889Start',refpoint='start') elements.append(e) # was 1.7 before the AOM greenlight pulse # was 0.8 before the p7889Start # wait length before was 1 e-6 but because there is a false delay in the green line (i guess, it doesn't work) # wait length adjusted was -1.6e-6 # Start p7889start adjusted 0.4e-6 # Greenlight start adjusted 2.1e-6 #insert a delay at the end of the sequence such that all outputs of the AWG stay low. end=element.Element('ending delay',pulsar=qt.pulsar) end.add(pulse.cp(sq_AOMpulse,length=1e-6,amplitude=0),name='delay') elements.append(end) #create a sequence from the gathered elements seq=pulsar.Sequence('RabiOsci sequence p7889') for e in elements: seq.append(name=e.name,wfname=e.name) #upload to AWG qt.pulsar.program_awg(seq,*elements)
def generate_sequence(self, upload=True, debug=False): ### define basic pulses/times ### # pi-pulse, needs different pulses for ms=-1 and ms=+1 transitions in the future. X = hermite_Xpi(self) # Wait-times T = pulse.SquarePulse(channel='MW_Imod', name='delay', length=self.params['wait_time_repeat_element'] * 1e-6, amplitude=0.) T_before_p = pulse.SquarePulse( channel='MW_Imod', name='delay', length=100e-9, amplitude=0.) #the unit waittime is 10e-6 s T_after_p = pulse.SquarePulse( channel='MW_Imod', name='delay', length=(1000. - self.params['Hermite_fast_pi_duration'] * 1e9) * 1e-9, amplitude=0. ) # waiting time chosen s.t. T_before_p + X + T_after_p = 1 us # Trigger pulse Trig = pulse.SquarePulse(channel='adwin_sync', length=5e-6, amplitude=2) ### create the elements/waveforms from the basic pulses ### list_of_elements = [] #Pi-pulse element/waveform e = element.Element('Pi_pulse', pulsar=qt.pulsar, global_time=True) e.append(T_before_p) e.append(pulse.cp(X)) e.append(T_after_p) list_of_elements.append(e) #Wait time element/waveform e = element.Element('T1_wait_time', pulsar=qt.pulsar, global_time=True) e.append(T) list_of_elements.append(e) #Trigger element/waveform e = element.Element('ADwin_trigger', pulsar=qt.pulsar, global_time=True) e.append(Trig) list_of_elements.append(e) ### create sequences from the elements/waveforms ### seq = pulsar.Sequence('ElectronT1_sequence') for i in range(len(self.params['wait_times'])): if self.params['wait_times'][i] / self.params[ 'wait_time_repeat_element'] != 0: if self.params['T1_initial_state'] == 'ms=-1': seq.append(name='Init_Pi_pulse_%d' % i, wfname='Pi_pulse', trigger_wait=True) seq.append(name='ElectronT1_wait_time_%d' % i, wfname='T1_wait_time', trigger_wait=False, repetitions=self.params['wait_times'][i] / self.params['wait_time_repeat_element']) if self.params['T1_readout_state'] == 'ms=-1': seq.append(name='Readout_Pi_pulse_%d' % i, wfname='Pi_pulse', trigger_wait=False) seq.append(name='ElectronT1_ADwin_trigger_%d' % i, wfname='ADwin_trigger', trigger_wait=False) #elif self.params['T1_initial_state'] == 'ms=+1': else: seq.append(name='ElectronT1_wait_time_%d' % i, wfname='T1_wait_time', trigger_wait=True, repetitions=self.params['wait_times'][i] / self.params['wait_time_repeat_element']) if self.params['T1_readout_state'] == 'ms=-1': seq.append(name='Readout_Pi_pulse_%d' % i, wfname='Pi_pulse', trigger_wait=False) seq.append(name='ElectronT1_ADwin_trigger_%d' % i, wfname='ADwin_trigger', trigger_wait=False) else: e = element.Element('Wait_time_%d' % i, pulsar=qt.pulsar, global_time=True) e.append( pulse.cp(T, length=self.params['wait_times'][i] * 1e-6)) if self.params['T1_initial_state'] == 'ms=-1' and self.params[ 'T1_readout_state'] == 'ms=0': seq.append(name='Init_Pi_pulse_%d' % i, wfname='Pi_pulse', trigger_wait=True) seq.append(name='Wait_time_%d' % i, wfname='Wait_time_%d' % i, trigger_wait=False) seq.append(name='ElectronT1_ADwin_trigger_%d' % i, wfname='ADwin_trigger', trigger_wait=False) elif self.params['T1_initial_state'] == 'ms=0' and self.params[ 'T1_readout_state'] == 'ms=-1': seq.append(name='Wait_time_%d' % i, wfname='Wait_time_%d' % i, trigger_wait=False) seq.append(name='Readout_Pi_pulse_%d' % i, wfname='Pi_pulse', trigger_wait=True) seq.append(name='ElectronT1_ADwin_trigger_%d' % i, wfname='ADwin_trigger', trigger_wait=False) #elif self.params['T1_initial_state'] == 'ms=+1' and self.params['T1_readout_state'] == 'ms=0': #elif self.params['T1_readout_state'] == 'ms=+1' and self.params['T1_initial_state'] == 'ms=0': else: seq.append(name='ElectronT1_ADwin_trigger_%d' % i, wfname='ADwin_trigger', trigger_wait=True) # upload the waveforms to the AWG if upload: qt.pulsar.program_awg(seq, *list_of_elements, debug=debug)
def generate_sequence(self): #define the pulses sq_p7889=pulse.SquarePulse(channel='p7889_start',name='p7889_square',amplitude=1) sq_p7889.length=2e-6 #that is pretty long, can be reduced in the future. wait = pulse.SquarePulse(channel='AOM_Green',name='Green_square') wait.amplitude = 0 wait.length=2e-6 sq_AOMpulse=pulse.SquarePulse(channel='AOM_Green',name='Green_square') sq_AOMpulse.amplitude=1 #just set the marker high sq_AOMpulse.length=self.params['GreenAOM_pulse_length'] X = pulselib.MW_IQmod_pulse('Weak pi-pulse', I_channel='MW_Imod', Q_channel='MW_Qmod', PM_channel='MW_pulsemod', amplitude = self.params['ssbmod_amplitude'], length = self.params['MW_pulse_length'], PM_risetime = self.params['MW_pulse_mod_risetime']) #need one spin polarization pulse at the beginning. init=element.Element('initialize',pulsar=qt.pulsar) init.add(pulse.cp(sq_AOMpulse,length=1e-6,amplitude=0),name='wait') init.add(sq_AOMpulse,name='init',refpulse='wait') #generate a list of pulse elements. One for each modulation freuqency elements=[] elements.append(init) for k,f in enumerate(np.linspace(self.params['ssbmod_frq_start'],self.params['ssbmod_frq_stop'],self.params['pts'])): e=element.Element('DarkESR_frq-%d' % k,pulsar=qt.pulsar) e.add(pulse.cp(wait,length=-1e-6,amplitude=0),name='wait_int') e.add(X(frequency=f),name='MWpulse',refpulse='wait_int',refpoint='end') e.add(sq_p7889,name='p7889Start',start=0.4e-6,refpulse='MWpulse',refpoint='end') e.add(sq_AOMpulse,name='GreenLight',start=2.1e-6,refpulse='p7889Start',refpoint='start') elements.append(e) # was 1.7 before the AOM greenlight pulse # was 0.8 before the p7889Start # wait length before was 1 e-6 but because there is a false delay in the green line (i guess, it doesn't work) # wait length adjusted was -1.6e-6 # Start p7889start adjusted 0.4e-6 # Greenlight start adjusted 2.1e-6 #insert a delay at the end of the sequence such that all outputs of the AWG stay low. end=element.Element('ending delay',pulsar=qt.pulsar) end.add(pulse.cp(sq_AOMpulse,length=1e-6,amplitude=0),name='delay') elements.append(end) #create a sequence from the gathered elements seq=pulsar.Sequence('DarkESR sequence p7889') for e in elements: seq.append(name=e.name,wfname=e.name) #upload to AWG qt.pulsar.program_awg(seq,*elements)
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=2e-6, amplitude=0) # CORPSE_pi = pulselib.IQ_CORPSE_pi_pulse('msm1 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['msm1_CORPSE_pi_mod_frq'], # amplitude = self.params['msm1_CORPSE_pi_amp'], # length_60 = self.params['msm1_CORPSE_pi_60_duration'], # length_m300 = self.params['msm1_CORPSE_pi_m300_duration'], # length_420 = self.params['msm1_CORPSE_pi_420_duration']) SP = pulse.SquarePulse(channel='AOM_Newfocus', length=self.params['AWG_SP_duration'], amplitude=self.params['AWG_SP_amplitude']) pi2pi_m1 = pulselib.MW_IQmod_pulse( 'pi2pi pulse mI=-1', I_channel='MW_Imod', Q_channel='MW_Qmod', PM_channel='MW_pulsemod', Sw_channel='MW_switch', PM_risetime=self.params['MW_pulse_mod_risetime'], frequency=self.params['pi2pi_mIm1_mod_frq'], amplitude=self.params['pi2pi_mIm1_amp'], length=self.params['pi2pi_mIm1_duration']) X = pulselib.MW_IQmod_pulse( 'electron X-Pi-pulse', I_channel='MW_Imod', Q_channel='MW_Qmod', PM_channel='MW_pulsemod', Sw_channel='MW_switch', frequency=self.params['AWG_MBI_MW_pulse_mod_frq'], PM_risetime=self.params['MW_pulse_mod_risetime'], Sw_risetime=self.params['MW_switch_risetime'], length=self.params['fast_pi_duration'], amplitude=self.params['fast_pi_amp'], phase=self.params['X_phase']) 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)) SP_elt = element.Element('SP_element', pulsar=qt.pulsar) SP_elt.append(T, X, T, SP, T) RO_elt = element.Element('RO_element', pulsar=qt.pulsar) RO_elt.append(T, pi2pi_m1) seq = pulsar.Sequence('N spin flips') for i, r in enumerate(self.params['AWG_sequence_repetitions']): seq.append(name='MBI-%d' % i, wfname=mbi_elt.name, trigger_wait=True, goto_target='MBI-%d' % i, jump_target='SP-{}'.format(i)) if r > 0: seq.append(name='SP-{}'.format(i), wfname=SP_elt.name, trigger_wait=True, repetitions=r) else: seq.append(name='SP-{}'.format(i), wfname=wait_1us.name, trigger_wait=True) seq.append(name='RO-{}'.format(i), wfname=RO_elt.name) seq.append(name='sync-{}'.format(i), wfname=sync_elt.name) combined_list_of_elements = [ mbi_elt, sync_elt, wait_1us, SP_elt, RO_elt ] # program AWG if upload: qt.pulsar.program_awg(seq, *combined_list_of_elements, debug=debug)
def generate_sequence(self, upload=True): SP_A_pulse = pulse.SquarePulse(channel = 'AOM_Newfocus', amplitude = 1.0) SP_E_pulse = pulse.SquarePulse(channel = 'EOM_AOM_Matisse', amplitude = 1.0) RO_pulse = pulse.SquarePulse(channel = 'EOM_AOM_Matisse', amplitude = 1.0) T = pulse.SquarePulse(channel = 'AOM_Newfocus', length = self.params['wait_length'], amplitude = 0) adwin_trigger_pulse = pulse.SquarePulse(channel = 'adwin_sync', length = 5e-6, amplitude = 2) PQ_sync = pulse.SquarePulse(channel = 'sync', length = self.params['pq_sync_length'], amplitude = 1.0) MW_pi_pulse = pulselib.HermitePulse_Envelope('Hermite pi-pulse', MW_channel='MW_Imod', PM_channel='MW_pulsemod', second_MW_channel='MW_Qmod', amplitude = self.params['Hermite_pi_amp'], length = self.params['Hermite_pi_length'], PM_risetime = self.params['MW_pulse_mod_risetime'], pi2_pulse = False) elements = [] finished_element = element.Element('finished', pulsar = qt.pulsar) finished_element.append(adwin_trigger_pulse) elements.append(finished_element) seq = pulsar.Sequence('FastSSRO') for i in range(self.params['pts']/2): e0 = element.Element('SSRO-ms0-{}'.format(i), pulsar = qt.pulsar) e0.append(pulse.cp(T,length=3e-6)) e0.append(PQ_sync) e0.append(T) e0.append(pulse.cp(SP_A_pulse, length=self.params['A_SP_durations_AWG'][i])) e0.append(T) e0.append(pulse.cp(RO_pulse, length=self.params['E_RO_durations_AWG'][i], amplitude=self.params['E_RO_voltages_AWG'][i])) e0.append(T) elements.append(e0) seq.append(name='SSRO-ms0-{}'.format(i), wfname=e0.name, trigger_wait=True) seq.append(name='finished-ms0-{}'.format(i), wfname=finished_element.name, trigger_wait=False) e1 = element.Element('SSRO-ms1-{}'.format(i), pulsar = qt.pulsar) e1.append(pulse.cp(T,length=3e-6)) e1.append(PQ_sync) e1.append(T) if self.params['init_with_MW'] : #SP on ms=0 transition, then apply a MW pi pulse to transfer population into ms=-1 e1.append(pulse.cp(SP_A_pulse, length=self.params['A_SP_durations_AWG'][i])) e1.append(T) e1.append(MW_pi_pulse) self.params['E_SP_durations_AWG'][i] = self.params['A_SP_durations_AWG'][i] + self.params['wait_length'] + self.params['Hermite_pi_length'] else: e1.append(pulse.cp(SP_E_pulse, length=self.params['E_SP_durations_AWG'][i], amplitude=self.params['E_SP_voltages_AWG'][i])) e1.append(T) e1.append(pulse.cp(RO_pulse, length=self.params['E_RO_durations_AWG'][i], amplitude=self.params['E_RO_voltages_AWG'][i])) e1.append(T) elements.append(e1) seq.append(name='SSRO-ms1-{}'.format(i), wfname=e1.name, trigger_wait=True) seq.append(name='finished-ms1-{}'.format(i), wfname=finished_element.name, trigger_wait=False) if upload: if upload=='old_method': qt.pulsar.upload(*elements) qt.pulsar.program_sequence(seq) else: qt.pulsar.program_awg(seq,*elements)
def pulse_defs_lt4(msmt): # a waiting pulse on the MW pulsemod channel msmt.T = pulse.SquarePulse(channel='MW_pulsemod', length=50e-9, amplitude=0) msmt.TIQ = pulse.SquarePulse(channel='MW_Imod', length=10e-9, amplitude=0) msmt.T_sync = pulse.SquarePulse(channel='sync', length=50e-9, amplitude=0) # some not yet specified pulse on the electron msmt.e_pulse = pulselib.MW_IQmod_pulse( 'MW pulse', I_channel='MW_Imod', Q_channel='MW_Qmod', PM_channel='MW_pulsemod', PM_risetime=msmt.params['MW_pulse_mod_risetime']) msmt.MW_pi = pulselib.HermitePulse_Envelope( 'Hermite pi-pulse', MW_channel='MW_Imod', PM_channel='MW_pulsemod', second_MW_channel='MW_Qmod', amplitude=msmt.params['MW_pi_amp'], length=msmt.params['MW_pi_duration'], PM_risetime=msmt.params['MW_pulse_mod_risetime'], pi2_pulse=False) msmt.MW_pi2 = pulselib.HermitePulse_Envelope( 'Hermite pi/2-pulse', MW_channel='MW_Imod', PM_channel='MW_pulsemod', second_MW_channel='MW_Qmod', amplitude=msmt.params['MW_pi2_amp'], length=msmt.params['MW_pi2_duration'], PM_risetime=msmt.params['MW_pulse_mod_risetime'], pi2_pulse=True) msmt.MW_BellAngle = pulselib.HermitePulse_Envelope( 'Hermite pi/2-pulse', MW_channel='MW_Imod', PM_channel='MW_pulsemod', second_MW_channel='MW_Qmod', amplitude=msmt.params['MW_pi2_amp'] * msmt.params['MW_BellStateFactor'], length=msmt.params['MW_pi2_duration'], PM_risetime=msmt.params['MW_pulse_mod_risetime'], pi2_pulse=True) msmt.MW_RND_I = pulselib.HermitePulse_Envelope( 'Hermite RND-pulse-I', MW_channel='MW_Imod', PM_channel='MW_pulsemod', amplitude=msmt.params['MW_RND_amp_I'], length=msmt.params['MW_RND_duration_I'], PM_risetime=msmt.params['MW_pulse_mod_risetime'], pi2_pulse=True) msmt.MW_RND_Q = pulselib.HermitePulse_Envelope( 'Hermite RND-pulse-Q', MW_channel='MW_Qmod', PM_channel='MW_pulsemod', amplitude=msmt.params['MW_RND_amp_Q'], length=msmt.params['MW_RND_duration_Q'], PM_risetime=msmt.params['MW_pulse_mod_risetime'], pi2_pulse=True) msmt.eom_pulse = eom_pulses.OriginalEOMAOMPulse( 'Eom Aom Pulse', eom_channel='EOM_Matisse', aom_channel='EOM_AOM_Matisse', eom_pulse_duration=msmt.params['eom_pulse_duration'], eom_off_duration=msmt.params['eom_off_duration'], eom_off_amplitude=msmt.params['eom_off_amplitude'], eom_pulse_amplitude=msmt.params['eom_pulse_amplitude'], eom_overshoot_duration1=msmt.params['eom_overshoot_duration1'], eom_overshoot1=msmt.params['eom_overshoot1'], eom_overshoot_duration2=msmt.params['eom_overshoot_duration2'], eom_overshoot2=msmt.params['eom_overshoot2'], aom_risetime=msmt.params['aom_risetime'], aom_amplitude=msmt.params['aom_amplitude']) msmt.RND_halt_off_pulse = pulse.SquarePulse( channel='RND_halt', amplitude=2.0, length=msmt.params['RND_duration']) ### synchronizing, etc msmt.adwin_trigger_pulse = pulse.SquarePulse(channel='adwin_sync', length=5e-6, amplitude=2) msmt.sync = pulse.SquarePulse(channel='sync', length=50e-9, amplitude=1.0) msmt.SP_pulse = pulse.SquarePulse(channel='AOM_Newfocus', amplitude=1.0) msmt.RO_pulse = pulse.SquarePulse(channel='EOM_AOM_Matisse', amplitude=0.0) msmt.yellow_pulse = pulse.SquarePulse(channel='AOM_Yellow', amplitude=1.0) msmt.plu_gate = pulse.SquarePulse(channel='plu_sync', amplitude=1.0, length=msmt.params['PLU_gate_duration']) return True
def generate_sequence(self, upload=True, **kw): # electron manipulation pulses init_ms1 = kw.pop('init_ms1', False) T = pulse.SquarePulse(channel='MW_pulsemod', length=10e-9, amplitude=0) CORPSE_pi = self.CORPSE_pi CORPSE_pi2 = self.CORPSE_pi2 # elts includes wait_rest_elts and second_pi2_elts, and if init_ms1: CORPSE_shelv_elt elts = [] if init_ms1: CORPSE_shelving_elt = element.Element('CORPSE_shelving_elt', pulsar=qt.pulsar, global_time=True, time_offset=0.) CORPSE_shelving_elt.append(pulse.cp(T, length=400e-9)) CORPSE_shelving_elt.append( pulse.cp(CORPSE_pi, amplitude=self.params['CORPSE_pi_shelv_amp'])) CORPSE_shelving_elt.append(pulse.cp(T, length=400e-9)) elts.append(CORPSE_shelving_elt) # around each pulse I make an element with length 1600e-9; # the centre of the pulse is in the centre of the element. # this helps me to introduce the right waiting times, # counting from centre of the pulses CORPSE_pi_wait_length = 800e-9 - ( CORPSE_pi.length - 2 * self.params['MW_pulse_mod_risetime']) / 2 CORPSE_pi2_wait_length = 800e-9 - ( CORPSE_pi2.length - 2 * self.params['MW_pulse_mod_risetime']) / 2 first_pi2_elt = element.Element('first_pi2_elt', pulsar=qt.pulsar, global_time=True, time_offset=0.) first_pi2_elt.append(pulse.cp(T, length=100e-9)) first_pi2_elt.append( pulse.cp(CORPSE_pi2, amplitude=self.params['CORPSE_pi2_amp'])) first_pi2_elt.append(pulse.cp(T, length=CORPSE_pi2_wait_length)) wait_1us = element.Element('1us_delay', pulsar=qt.pulsar, global_time=True) 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) # sequence seq = pulsar.Sequence('Dynamical decoupling sequence') for i in range(self.params['pts']): reduced_free_ev_time = self.params['free_evolution_times'][ i] - 800e-9 - 800e-9 # calculate how many waits of 1 us fit in the free evolution time (-1 repetition) # this is twice the 800e-9 s that are the wrap-arounds of the pulses delay_reps = np.floor(reduced_free_ev_time / 1e-6) - 2 #calculate how much wait time should be added to the above to fill the full free evolution time (+1 us to fill full elt) rest_time = np.mod(reduced_free_ev_time, 1e-6) + 2e-6 wait_rest_elt = element.Element('wait_rest_elt-{}'.format(i), pulsar=qt.pulsar, global_time=True) wait_rest_elt.append(pulse.cp(T, length=rest_time)) elts.append(wait_rest_elt) if init_ms1: seq.append(name='CORPSE_shelving-{}'.format(i), wfname=CORPSE_shelving_elt.name, trigger_wait=True) seq.append(name='first_pi2-{}'.format(i), wfname=first_pi2_elt.name) else: seq.append(name='first_pi2-{}'.format(i), wfname=first_pi2_elt.name, trigger_wait=True) for j in range(self.params['multiplicity']): #calculate the time offset for the CORPSE pulse element # the case j>0 asks for adding extra wrap-around times, # that are added to the CORPSE elements. time_offset_CORPSE = first_pi2_elt.length() \ + (2 * j + 1) * reduced_free_ev_time if j > 0: time_offset_CORPSE = time_offset_CORPSE \ + (2 * j - 1) * 1600e-9 \ + (j - 1) * self.params['extra_t_between_pulses'][i] # 1600e-9 is free_ev_time - reduced_free_ev_time CORPSE_elt = element.Element('CORPSE_elt-{}-{}'.format(i, j), pulsar=qt.pulsar, global_time=True, time_offset=time_offset_CORPSE) # append a longer waiting time for the not first CORPSE pulse, to get the right evolution time if j == 0: CORPSE_elt.append(pulse.cp(T, length=CORPSE_pi_wait_length)) else: # add an extra 1600e-9, that would otherwise be the wrap-around of a pulse # also add the possibility to make the time between pi pulses different, # this could correct for where the centre of the pi/2 pulse is. CORPSE_elt.append( pulse.cp(T, length=CORPSE_pi_wait_length + 1600e-9 + self.params['extra_t_between_pulses'][i])) CORPSE_elt.append( pulse.cp(CORPSE_pi, amplitude=self.params['CORPSE_pi_amp'], phase=self.params['CORPSE_pi_phases'][j])) CORPSE_elt.append(pulse.cp(T, length=CORPSE_pi_wait_length)) elts.append(CORPSE_elt) seq.append(name='wait1-{}-{}'.format(i, j), wfname=wait_1us.name, repetitions=delay_reps) seq.append(name='wait_rest1-{}-{}'.format(i, j), wfname=wait_rest_elt.name) seq.append(name=CORPSE_elt.name + '-{}-{}'.format(i, j), wfname=CORPSE_elt.name) seq.append(name='wait2-{}-{}'.format(i, j), wfname=wait_1us.name, repetitions=delay_reps) seq.append(name='wait_rest2-{}-{}'.format(i, j), wfname=wait_rest_elt.name) # calculate the right time offset, that is crucial for the right phase. time_offset_pi2_2 = first_pi2_elt.length() \ + (2 * self.params['multiplicity'] - 1) * 1600e-9 \ + self.params['multiplicity'] * 2 * reduced_free_ev_time \ + (self.params['multiplicity'] - 1 ) * self.params['extra_t_between_pulses'][i] second_pi2_elt = element.Element('second_pi2_elt-{}'.format(i), pulsar=qt.pulsar, global_time=True, time_offset=time_offset_pi2_2) second_pi2_elt.append( pulse.cp(T, length=CORPSE_pi2_wait_length + self.params['extra_ts_before_pi2'][i])) second_pi2_elt.append( pulse.cp(CORPSE_pi2, amplitude=self.params['CORPSE_pi2_2_amp'], phase=self.params['phases'][i])) second_pi2_elt.append(pulse.cp(T, length=100e-9)) elts.append(second_pi2_elt) seq.append(name='second_pi2-{}'.format(i), wfname=second_pi2_elt.name) seq.append(name='sync-{}'.format(i), wfname=sync_elt.name) # program AWG if upload: qt.pulsar.upload(sync_elt, wait_1us, first_pi2_elt, *elts) qt.pulsar.program_sequence(seq)
import qt from measurement.lib.pulsar import pulse, pulselib, element, pulsar awg = qt.instruments['AWG'] pts=1#self._pixel_pts p_wait = pulse.SquarePulse('sync', length=10e-6, amplitude = 0) p_sync = pulse.SquarePulse('sync', length=200e-9, amplitude = 1) elts=[] s= pulsar.Sequence('test_flim_seq') e=element.Element('sync_elt', pulsar=qt.pulsar) e.add(p_sync, start = 200e-9) e.add(p_wait) elts.append(e) for i in range(pts): s.append(name = 'sync_init'+str(i), wfname = e.name, trigger_wait = 0, repetitions = 1) qt.pulsar.program_awg(s,e) # awg.start() # i=0 # awg_ready = False # while not awg_ready and i<100: # if (msvcrt.kbhit() and (msvcrt.getch() == 'x')): # raise Exception('User abort while waiting for AWG') # try: # if awg.get_state() == 'Waiting for trigger': # qt.msleep(1) # awg_ready = True
def generate_sequence(self, upload=True, debug=False): # MBI element mbi_elt = self._MBI_element() ro_elt = self._RO_element() # electron manipulation pulses T = pulse.SquarePulse(channel='MW_pulsemod', length=1000e-9, amplitude=0) X = pulselib.MW_IQmod_pulse( 'MBI MW pulse', I_channel='MW_Imod', Q_channel='MW_Qmod', PM_channel='MW_pulsemod', frequency=self.params['AWG_MBI_MW_pulse_ssbmod_frq'], amplitude=self.params['AWG_MBI_MW_pulse_amp'], length=self.params['AWG_MBI_MW_pulse_duration'], PM_risetime=self.params['MW_pulse_mod_risetime']) adwin_sync = pulse.SquarePulse(channel='adwin_sync', length = (self.params['AWG_to_adwin_ttl_trigger_duration'] \ + self.params['AWG_wait_for_adwin_MBI_duration']), amplitude = 2) # # define the necessary pulses # T = pulse.SquarePulse(channel='MW_pulsemod', # length = 100e-9, amplitude = 0) # X = pulselib.MW_IQmod_pulse('MBI MW pulse', # I_channel = 'MW_Imod', Q_channel = 'MW_Qmod', # PM_channel = 'MW_pulsemod', # frequency = self.params['AWG_MBI_MW_pulse_ssbmod_frq'], # amplitude = self.params['AWG_MBI_MW_pulse_amp'], # length = self.params['AWG_MBI_MW_pulse_duration'], # PM_risetime = self.params['MW_pulse_mod_risetime']) # # the actual element # ro_element = element.Element(name, pulsar=qt.pulsar) # ro_element.append(T) # ro_element.append(X) N_pulse = pulselib.RF_erf_envelope( channel='RF', amplitude=self.params['RF_pulse_amp'], frequency=self.params['RF_pulse_frqs']) # 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('RF_pt-%d' % i, pulsar=qt.pulsar, global_time=True) e.append(pulse.cp(T, length=500e-9)) e.append( pulse.cp(N_pulse, length=self.params['RF_pulse_length'][i], frequency=self.params['RF_pulse_frqs'])) e.append(pulse.cp(T, length=500e-9)) # 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) # gate_seq = [] # for pt in range(self.params['pts']): # rabi_pulse = DD.Gate('Rabi_pulse_'+str(pt),'RF_pulse', # length = self.params['RF_pulse_durations'][pt], # RFfreq = self.params['RF_pulse_frqs'][pt], # amplitude = self.params['RF_pulse_amps'][pt]) # gate_seq.extend([rabi_pulse]) # print 'Gate_seq', gate_seq # gate_seq = DD.NitrogenRabiWithDirectRF.generate_AWG_elements(gate_seq,pt) # this will use resonance = 0 by default in # ### Convert elements to AWG sequence and add to combined list # list_of_elements, seq2 = DD.combine_to_AWG_sequence(gate_seq, explicit=True) # 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) #True seq.append(name='RO_pt-%d' % i, wfname=ro_elt.name, trigger_wait=False) # seq.append(name = 'RO-%d' % i, wfname = mbi_elt.name, # trigger_wait = False) ## According to Norbert the trigger wait time should be set to False. ## This is implemented at the beginning of the MBI because it is waiting for a CR check from the adwin. ## For the readout this doesn't have to be implemented because it is deterministic. 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, ro_elt, *elts, debug=debug)
execfile(qt.reload_current_setup) import msvcrt, time import numpy as np from measurement.lib.pulsar import pulse, pulselib, element, pulsar p_start = pulse.SquarePulse('p7889_start', length=10e-9, amplitude = 1) p_stop = pulse.SquarePulse('p7889_stop', length=10e-9, amplitude = 1) p_wait = pulse.SquarePulse('p7889_start', length=100e-6, amplitude = 0) e=element.Element('test_p7889_elt', pulsar=qt.pulsar) #e.append(T) e.add(p_start, start = 100e-9, name = 'start') e.add(p_stop, start=1e-9, refpulse = 'start') e.add(p_stop, start=30e-9, refpulse = 'start') e.add(p_stop, start=100e-9, refpulse = 'start') e.append(p_wait) e.print_overview() s= pulsar.Sequence('test_p7889_seq') s.append(name = 'test_p7889_seq_1', wfname = e.name, trigger_wait = 0) qt.pulsar.upload(e) qt.pulsar.program_sequence(s) qt.instruments['p7889'].Start() qt.msleep(0.5) qt.instruments['AWG'].start()
def generate_sequence(self, upload=True, debug=False): #configure the dephasing beam. power and AWG channel dephasing_AOM_voltage = qt.instruments[ self.params['dephasing_AOM']].power_to_voltage( self.params['laser_dephasing_amplitude'], controller='sec') if dephasing_AOM_voltage > ( qt.instruments[self.params['dephasing_AOM']]).get_sec_V_max(): print 'Suggested power level would exceed V_max of the AOM driver.' else: #not sure if the secondary channel of an AOM can be obtained in this way? channelDict = { 'ch2m1': 'ch2_marker1', 'ch2m2': 'ch2_marker2', 'ch4m1': 'ch4_marker1' } print 'AOM voltage', dephasing_AOM_voltage self.params['Channel_alias'] = qt.pulsar.get_channel_name_by_id( channelDict[qt.instruments[ self.params['dephasing_AOM']].get_sec_channel()]) qt.pulsar.set_channel_opt(self.params['Channel_alias'], 'high', dephasing_AOM_voltage) print self.params['Channel_alias'] # MBI element mbi_elt = self._MBI_element() # electron manipulation pulses T = pulse.SquarePulse(name='syncpulse', channel='MW_pulsemod', length=1000e-9, amplitude=0) Dephasing = pulse.SquarePulse(channel=self.params['Channel_alias'], length=1000e-9, amplitude=dephasing_AOM_voltage) X = ps.X_pulse(self) try: Pi_mw2 = ps.pi_pulse_MW2(self) except: print 'No parameters for second MW source found' 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('ERamsey_pt-%d' % i, pulsar=qt.pulsar, global_time=True) e.append(T) try: init_with_second_source = self.params[ 'init_with_second_source'] init_in_zero = self.params['init_in_zero'] except: print 'Cannot init. Parameter not defined?' init_with_second_source = False init_in_zero = False if init_with_second_source: e.append( pulse.cp(Pi_mw2, length=self.params['MW_pulse_durations'][i], amplitude=self.params['MW_pulse_amps'][i])) elif not init_in_zero: 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], phase=self.params['MW_pulse_1_phases'][i])) e.append(pulse.cp(T, length=self.params['MW_repump_delay1'][i])) try: #MW2 used for repumping pump_using_newfocus = self.params['pump_using_newfocus'] pump_using_repumper = self.params['pump_using_repumper'] except: print 'pump using NF not defined, set default: True' pump_using_newfocus = True pump_using_repumper = False if self.params['repumping_time'][i] != 0 and pump_using_newfocus: e.append( pulse.cp(Dephasing, length=self.params['repumping_time'][i])) if self.params['repumping_time'][i] != 0 and pump_using_repumper: if pump_using_newfocus: e.append( pulse.cp(T, length=-self.params['repumping_time'][i])) e.append( pulse.cp(Dephasing, channel='AOM_Repumper', length=self.params['repumping_time'][i], amplitude=qt.instruments['RepumperAOM']. power_to_voltage( self.params['repumper_amplitude']))) try: #MW2 used for repumping pump_using_MW2 = self.params['pump_using_MW2'] if pump_using_MW2 and ( self.params['pump_MW2_durations'][i] - 2 * self.params['pump_MW2_falltime'][i]) > 0: #print self.params['pump_MW2_delay'][i] e.append( pulse.cp(T, length=-self.params['repumping_time'][i] + self.params['pump_MW2_delay'][i])) e.append( pulse.cp( Pi_mw2, length=(self.params['pump_MW2_durations'][i] - 2 * self.params['pump_MW2_falltime'][i]), amplitude=self.params['MW2_pulse_amplitudes'][i])) except: print 'Exception in pump using MW2: ', sys.exc_info() e.append(pulse.cp(T, length=self.params['MW_repump_delay2'][i])) do_BB1 = False #Readout in pm1 basis if do_BB1 and self.params['MW_pulse_2_amps'][i] != 0: # necessary defs for BB1 T_BB1 = pulse.SquarePulse( channel='adwin_sync', name='Wait t', length=5 * self.params['fast_pi_duration'] / 2 - self.params['fast_pi2_duration'] / 2, amplitude=0.) # T_rep_BB1 = pulse.SquarePulse(channel='adwin_sync',name='Wait t-trep', # length = t-t_rep-5*self.params['fast_pi_duration']/2, amplitude = 0.) X_BB1 = pulse.cp(X, length=self.params['BB1_fast_pi_duration'], amplitude=self.params['BB1_fast_pi_amp']) BB1_phase1 = pulse.cp(X_BB1, phase=self.params['X_phase'] + 104.5) BB1_phase2 = pulse.cp(X_BB1, phase=self.params['X_phase'] + 313.4) e.append(T_BB1) e.append(BB1_phase1) e.append(BB1_phase2) e.append(BB1_phase2) e.append(BB1_phase1) e.append(X_BB1) elif self.params['MW_pulse_2_amps'][i] != 0 and self.params[ 'readout_with_second_source']: e.append( pulse.cp(Pi_mw2, length=self.params['MW_pulse_2_durations'][i], amplitude=self.params['MW_pulse_2_amps'][i])) elif self.params['MW_pulse_2_amps'][i] != 0 and self.params[ 'readout_with_second_source'] == False: e.append( pulse.cp(X, frequency=self.params['MW_pulse_mod_frqs'][i], amplitude=self.params['MW_pulse_2_amps'][i], length=self.params['MW_pulse_2_durations'][i], phase=self.params['MW_pulse_2_phases'][i])) e.append(pulse.cp(T, length=2e-6)) # e.append(adwin_sync) elts.append(e) # sequence # seq = pulsar.Sequence('MBI Electron Ramsey 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) # program AWG # e = element.Element('Adwin_sync_pt-%d' % i, pulsar=qt.pulsar, # global_time = True) # e.append(adwin_sync) # elts.append(e) adwin_elt = element.Element('Adwin_sync', pulsar=qt.pulsar, global_time=True) adwin_elt.append(adwin_sync) # sequence print len(elts) seq = pulsar.Sequence('MBI Electron Ramsey 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, repetitions=self.params['Repump_multiplicity'][i]) seq.append(name='Adwin-sync-%d' % i, wfname=adwin_elt.name, trigger_wait=False) # program AWG if upload: qt.pulsar.program_awg(seq, mbi_elt, adwin_elt, *elts, debug=debug)
def generate_sequence(self, upload=True, **kw): ''' ''' SP = pulse.SquarePulse(channel='AOM_Newfocus', name='SP')
def generate_sequence(self, upload=True, debug=False): #configure the repumping beam. power and AWG channel repumping_AOM_voltage = qt.instruments[ self.params['repump_AOM']].power_to_voltage( self.params['laser_repump_amplitude'], controller='sec') if repumping_AOM_voltage > ( qt.instruments[self.params['repump_AOM']]).get_sec_V_max(): print 'Suggested power level would exceed V_max of the AOM driver.' return else: #not sure if the secondary channel of an AOM can be obtained in this way? channelDict = { 'ch2m1': 'ch2_marker1', 'ch2m2': 'ch2_marker2', 'ch4m1': 'ch4_marker1' } print 'AOM voltage', repumping_AOM_voltage print self.params['repump_AOM'] self.params['Channel_alias'] = qt.pulsar.get_channel_name_by_id( channelDict[qt.instruments[ self.params['repump_AOM']].get_sec_channel()]) qt.pulsar.set_channel_opt(self.params['Channel_alias'], 'high', repumping_AOM_voltage) print self.params['Channel_alias'] # MBI element mbi_elt = self._MBI_element() # electron manipulation pulses T = pulse.SquarePulse(name='syncpulse', channel='MW_pulsemod', length=1000e-9, amplitude=0) #Called dephasing, but does repump... Dephasing = pulse.SquarePulse(channel=self.params['Channel_alias'], length=1000e-9, amplitude=repumping_AOM_voltage) X = ps.X_pulse(self) X_mw2 = ps.pi_pulse_MW2(self) if False: #optical pumping using p1 transition squareX = ps.mw2_squareX(self) else: #optical pumping using m1 transition squareX = ps.squareX(self) 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('ERamsey_pt-%d' % i, pulsar=qt.pulsar, global_time=True) e.append(T) #initialize the electron after pumping to 0 if self.params['init_state'] == 'm1': e.append(pulse.cp(X)) elif self.params['init_state'] == 'p1': e.append(pulse.cp(X_mw2)) else: # init in zero pass e.append(pulse.cp(T, length=self.params['MW_repump_delay1'][i])) pump_cycle_no = 0 while pump_cycle_no < self.params['pumping_cycles']: pump_cycle_no += 1 if self.params['repumping_time'][i] != 0: if pump_cycle_no > 1: e.append( pulse.cp(T, length=self.params['delay_before_MW'][i])) e.append(pulse.cp(squareX)) e.append( pulse.cp(T, length=self.params['delay_after_MW'][i])) e.append( pulse.cp(Dephasing, length=self.params['repumping_time'][i])) e.append(pulse.cp(T, length=self.params['MW_repump_delay2'][i])) #initialize the electron after pumping to 0 if self.params['ro_state'] == 'm1': e.append(pulse.cp(X)) elif self.params['ro_state'] == 'p1': e.append(pulse.cp(X_mw2)) else: # ro zero pass e.append(pulse.cp(T, length=2e-6)) elts.append(e) adwin_elt = element.Element('Adwin_sync', pulsar=qt.pulsar, global_time=True) adwin_elt.append(adwin_sync) seq = pulsar.Sequence('MBI Electron Ramsey 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, repetitions=self.params['Repump_multiplicity'][i]) seq.append(name='Adwin-sync-%d' % i, wfname=adwin_elt.name, trigger_wait=False) # program AWG if upload: qt.pulsar.program_awg(seq, mbi_elt, adwin_elt, *elts, debug=debug)
def _pulse_defs(self): ### electron manipulation pulses # a waiting pulse on the MW pulsemod channel self.T = pulse.SquarePulse(channel='MW_pulsemod', length=10e-9, amplitude=0) self.TIQ = pulse.SquarePulse(channel='MW_Imod', length=10e-9, amplitude=0) # some not yet specified pulse on the electron self.e_pulse = 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']) # slow pi-pulse for MBI self.slow_pi = pulselib.MW_IQmod_pulse( 'slow pi', I_channel='MW_Imod', Q_channel='MW_Qmod', PM_channel='MW_pulsemod', PM_risetime=self.params['MW_pulse_mod_risetime'], frequency=self.params['selective_pi_mod_frq'], amplitude=self.params['selective_pi_amp'], length=self.params['selective_pi_duration']) # reasonably fast pi and pi/2 pulses self.pi_4MHz = pulselib.MW_IQmod_pulse( '4MHz pi', I_channel='MW_Imod', Q_channel='MW_Qmod', PM_channel='MW_pulsemod', PM_risetime=self.params['MW_pulse_mod_risetime'], frequency=self.params['4MHz_pi_mod_frq'], amplitude=self.params['4MHz_pi_amp'], length=self.params['4MHz_pi_duration']) self.pi2_4MHz = pulselib.MW_IQmod_pulse( '4MHz pi2', I_channel='MW_Imod', Q_channel='MW_Qmod', PM_channel='MW_pulsemod', PM_risetime=self.params['MW_pulse_mod_risetime'], frequency=self.params['4MHz_pi2_mod_frq'], amplitude=self.params['4MHz_pi2_amp'], length=self.params['4MHz_pi2_duration']) # shelving pi-pulse to bring electron to ms=-1 after mbi self.shelving_pulse = pulselib.MW_IQmod_pulse( 'MBI shelving pulse', I_channel='MW_Imod', Q_channel='MW_Qmod', PM_channel='MW_pulsemod', frequency=self.params['AWG_MBI_MW_pulse_mod_frq'], amplitude=self.params['AWG_shelving_pulse_amp'], length=self.params['AWG_shelving_pulse_duration'], PM_risetime=self.params['MW_pulse_mod_risetime']) # CORPSE pi pulse self.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']) # CNOT operation on the electron self.pi2pi_m1 = pulselib.MW_IQmod_pulse( 'pi2pi pulse mI=-1', I_channel='MW_Imod', Q_channel='MW_Qmod', PM_channel='MW_pulsemod', PM_risetime=self.params['MW_pulse_mod_risetime'], frequency=self.params['pi2pi_mIm1_mod_frq'], amplitude=self.params['pi2pi_mIm1_amp'], length=self.params['pi2pi_mIm1_duration']) ### nuclear spin manipulation pulses self.TN = pulse.SquarePulse(channel='RF', length=100e-9, amplitude=0) self.N_pulse = pulselib.RF_erf_envelope( channel='RF', frequency=self.params['N_0-1_splitting_ms-1']) self.N_pi = pulselib.RF_erf_envelope( channel='RF', frequency=self.params['N_0-1_splitting_ms-1'], length=self.params['N_pi_duration'], amplitude=self.params['N_pi_amp']) self.N_pi2 = pulselib.RF_erf_envelope( channel='RF', frequency=self.params['N_0-1_splitting_ms-1'], length=self.params['N_pi2_duration'], amplitude=self.params['N_pi2_amp']) ### synchronizing, etc self.adwin_sync = pulse.SquarePulse(channel='adwin_sync', length=10e-6, amplitude=2) ### useful elements self.mbi_elt = self._MBI_element() self.sync_elt = element.Element('adwin_sync', pulsar=qt.pulsar) self.sync_elt.append(self.adwin_sync)
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', Sw_channel='MW_switch', PM_risetime=self.params['MW_pulse_mod_risetime'], Sw_risetime=self.params['MW_switch_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) 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_new_sequence(m, seq, elements, upload = False): qt.pulsar.AWG_sequence_cfg['JUMP_TIMING'] = 0 # ASYNC [overview, pulse_array] = group_seq_elems(seq, elements) seq_uniq = pulsar.Sequence(seq.name + '-unique') seq_uniq.set_djump(True) elements_uniq = [] unique_pulses = {} jump_index = 0 # empty = pulse.SquarePulse(channel = 'tico_sync', length = 1e-6, amplitude = 0) empty = pulse.SquarePulse(channel = 'adwin_sync', length = 1e-6, amplitude = 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_start_tico = element.Element('start_tico', pulsar = qt.pulsar, global_time = True, min_samples = 1e3) # e_loop.add(pulse.cp(empty, amplitude = 2, length = 100e-9), name = e_loop.name + '_sync') e_wait.add(pulse.cp(empty), name = e_wait.name) elements_uniq.append(e_wait) seq_uniq.append(name = e_wait.name, wfname = e_wait.name, goto_target = e_loop.name, trigger_wait = True) seq_uniq.add_djump_address(jump_index, e_wait.name) # e_start_tico.add(pulse.cp(empty, amplitude = 2, length = 100e-9), name = e_start_tico.name) # elements_uniq.append(e_start_tico) # seq_uniq.append(name = e_start_tico.name, wfname = e_start_tico.name, goto_target = e_loop.name) # seq_uniq.add_djump_address(jump_index, e_start_tico.name) e_loop.add(pulse.cp(empty, length = 1e-3), name = e_loop.name) # + '_empty', refpulse = e_loop.name + '_sync') elements_uniq.append(e_loop) seq_uniq.append(name = e_loop.name, wfname = e_loop.name, goto_target = e_wait.name, repetitions = 65536) m.params['jump_table'] = [] m.params['delays_before_jumps'] = [] m.params['next_seq_table'] = [] start_prev = 0 for seq_idx, (pulse_overview, pulse_seq) in enumerate(zip(overview, pulse_array)): pulse_overview['jump_table'] = [] pulse_overview['delays'] = [] if pulse_overview['trigger_wait'] > 0: start_prev = 0 for pul_idx, pul in enumerate(pulse_seq): pul_physical = None mid_point, length, phase, rotation, special = pul phase = 180 * phase / np.pi key = tuple([round(var, 5) for var in (length, phase, rotation, special)]) # rounding errors in pars if key in unique_pulses: pul_physical = unique_pulses[key][0] else: jump_index += 1 # We are adding a new pulse to the jump table if special == 0: if rotation == np.pi: pul_physical = pulse.cp(ps.X_pulse(m), phase = phase) else: pul_physical = pulse.cp(ps.Xpi2_pulse(m), phase = phase) elif special == 1: pul_phsyical = pulse.SquarePulse(channel='AOM_Newfocus', length = length, amplitude = 0.2) elif special == 2: pul_physical = pulse.SquarePulse(channel='adwin_sync', length = length, amplitude = 2) # ADWIN DOESN'T NEED TO SYNC WITH ITSELF? else: pul_phsyical = pulse.SquarePulse(channel='AOM_Matisse', length = length, amplitude = 0.2) pul_name = pul_physical.name + ('-%i' % jump_index) # Give pulses unique names e = element.Element(pul_name, pulsar = qt.pulsar, global_time = True, min_samples = 1e3) e.add(pul_physical, name = pul_name) elements_uniq.append(e) seq_uniq.append(name = e.name, wfname = e.name, goto_target = e_loop.name) seq_uniq.add_djump_address(jump_index, e.name) unique_pulses[key] = [pul_physical, jump_index] channel_offset = 0 for ch in pul_physical.channels: if qt.pulsar.channels[ch]['delay'] > channel_offset: channel_offset = qt.pulsar.channels[ch]['delay'] length += pul_physical.start_offset + pul_physical.stop_offset start = mid_point - length / 2 - channel_offset delay = start - start_prev pulse_overview['jump_table'].append(unique_pulses[key][1]) pulse_overview['delays'].append(delay) if pul_idx == len(pulse_seq) - 1: pulse_overview['jump_table'].append(0) pulse_overview['delays'].append(pulse_overview['final_time'] - start - length) # Not used atm start_prev = start m.params['jump_table'].append(pulse_overview['jump_table']) m.params['delays_before_jumps'].append(pulse_overview['delays']) if pulse_overview['goto_target'] != 'None': start_prev = 0 next_goto = next(i for (i, o) in enumerate(overview) if o['goto_target'] == pulse_overview['goto_target']) else: start_prev = pulse_overview['final_time'] if seq_idx + 1 == len(overview): next_goto = 1 else: next_goto = seq_idx + 2 if pulse_overview['jump_target'] != 'None': start_prev = 0 next_jump = next(i for (i, o) in enumerate(overview) if o['jump_target'] == pulse_overview['jump_target']) else: start_prev = pulse_overview['final_time'] next_jump = 0 m.params['next_seq_table'].append([next_goto, next_jump]) # upload new seq if upload: qt.pulsar.program_awg(seq_uniq, *elements_uniq)
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=100e-9, amplitude=0) X = pulselib.MW_IQmod_pulse( 'MW pulse', I_channel='MW_Imod', Q_channel='MW_Qmod', PM_channel='MW_pulsemod', Sw_channel='MW_switch', PM_risetime=self.params['MW_pulse_mod_risetime'], Sw_risetime=self.params['MW_switch_risetime']) adwin_sync = pulse.SquarePulse( channel='adwin_sync', length=self.params['AWG_to_adwin_ttl_trigger_duration'], amplitude=2) # electron manipulation elements pulse_elts = [] for i in range(self.params['pts']): e = element.Element('ERabi_pt-%d' % i, pulsar=qt.pulsar) e.append(T) 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(adwin_sync) pulse_elts.append(e) wait_elt = element.Element('pulse_delay', pulsar=qt.pulsar) wait_elt.append(pulse.cp(T, length=1e-6)) sync_elt = element.Element('adwin_sync', pulsar=qt.pulsar) sync_elt.append(adwin_sync) # sequence seq = pulsar.Sequence('MBI Electron Rabi sequence') for i, e in enumerate(pulse_elts): seq.append(name='MBI-%d' % i, wfname=mbi_elt.name, trigger_wait=True, goto_target='MBI-%d' % i, jump_target=e.name + '-0') if self.params['MW_pulse_multiplicities'][i] == 0: seq.append(name=e.name + '-0', wfname=wait_elt.name, trigger_wait=True) else: for j in range(self.params['MW_pulse_multiplicities'][i]): seq.append(name=e.name + '-%d' % j, wfname=e.name, trigger_wait=(j == 0)) seq.append(name='wait-%d-%d' % (i, j), wfname=wait_elt.name, repetitions=int( self.params['MW_pulse_delays'][i] / 1e-6)) seq.append(name='sync-%d' % i, wfname=sync_elt.name) # program AWG if upload: qt.pulsar.program_awg(seq, mbi_elt, wait_elt, sync_elt, *pulse_elts, debug=debug)
def generate_sequence(self,upload=True): #rewrite chan_hhsync = 'HH_sync' # historically PH_start chan_hh_ma1 = 'HH_MA1' # historically PH_sync chan_plusync = 'PLU_gate' chan_adwin='adwin_sync' chan_alaser = 'AOM_Newfocus' chan_yellowlaser = 'AOM_Yellow' chan_eom = 'EOM_Matisse' chan_eom_aom = 'EOM_AOM_Matisse' qt.pulsar.set_channel_opt(chan_alaser,'high', self.params['AWG_A_SP_voltage']) qt.pulsar.set_channel_opt(chan_yellowlaser,'high', self.params['AWG_yellow_voltage']) e_lde = element.Element('lde', pulsar=qt.pulsar) # 1: spin pumping p_wait=pulse.SquarePulse(chan_alaser, 'initialdelay', length = 10e-9, amplitude = 0) last=e_lde.add(p_wait) p_sp=pulse.SquarePulse(chan_alaser, 'spinpumping', length = self.params['AWG_SP_duration'], amplitude = 1) p_yellow=pulse.SquarePulse(chan_yellowlaser, 'yellowpumping', length = self.params['AWG_yellow_duration'], amplitude = 1) e_lde.add(p_yellow, refpulse=last, refpoint='end') last=e_lde.add(p_sp, refpulse=last, refpoint='end') p_sync=pulse.SquarePulse(chan_hhsync,'debug_sync', length = 50e-9, amplitude = 1) p_hh_marker=pulse.SquarePulse(chan_hh_ma1, 'hh_marker', length=50e-9, amplitude=1) P_eom_aom=EOMAOMPulse(chan_eom,chan_eom_aom,'opt_pi',**self.eom_pars) # opt pi 1 i = 1 if self.params['long_histogram']: e_lde.add(p_sync) hhsync_amp=0 else: hhsync_amp=1 last=e_lde.add(pulse.cp(p_sync(amplitude=hhsync_amp)),name='start'+str(i), t0= self.params['wait_after_sp'], refpulse=last, refpoint='end') e_lde.add(p_hh_marker,name='mrkr'+str(i), t0 = -20e-9, refpulse=last, refpoint='start') last=e_lde.add(pulse.cp(p_sync(amplitude=0)),name='start'+str(i)+'delay', refpulse=last, refpoint='end') last=e_lde.add(P_eom_aom, name='eom_pulse'+str(i), t0= self.params['eom_start'], refpulse=last, refpoint = 'start') # opt pi 2 i = 2 last=e_lde.add(pulse.cp(p_sync(amplitude=hhsync_amp)),name='start'+str(i), t0= self.params['opt_pi_separation'], refpulse='start'+str(i-1), refpoint='start') last=e_lde.add(pulse.cp(p_sync(amplitude=0)),name='start'+str(i)+'delay', refpulse=last, refpoint='end') last=e_lde.add(P_eom_aom, name='eom_pulse'+str(i), t0= self.params['eom_start'], refpulse=last, refpoint = 'start') #final delay e_lde.add(pulse.cp(p_wait(length=self.params['finaldelay'])), refpulse=last, refpoint = 'end') # idle element e_idle=element.Element('idle', pulsar=qt.pulsar) last=e_idle.add(pulse.cp(p_wait(length=200e-9))) p_adwin=pulse.SquarePulse(chan_adwin,'adwin_sync', length = 2000e-9, amplitude = 1) e_idle.add(p_adwin, refpulse=last, refpoint = 'end', t0 = 50e-9) seq = pulsar.Sequence('LDE protocol test sequence wo MW') for i,r in enumerate(self.params['protocol_reps_sweep']): #print i, r seq.append(name = 'LDE-%d' % i, wfname = e_lde.name, trigger_wait = True, repetitions=r) seq.append(name = 'wait-%d' % i, wfname = e_idle.name, trigger_wait = False) if upload: qt.pulsar.upload(e_lde,e_idle) qt.pulsar.program_sequence(seq)
def generate_sequence(self, upload=True): #rewrite chan_hhsync = 'HH_sync' # historically PH_start chan_hh_ma1 = 'HH_MA1' # historically PH_sync chan_plusync = 'PLU_gate' self.chan_adwin_sync = 'adwin_sync' self.chan_nf_aom = 'AOM_Newfocus' self.chan_mwI = 'MW_Imod' self.chan_mwQ = 'MW_Qmod' self.chan_mw_pm = 'MW_pulsemod' chan_yellowlaser = 'AOM_Yellow' chan_eom = 'EOM_Matisse' chan_eom_aom = 'EOM_AOM_Matisse' qt.pulsar.set_channel_opt(self.chan_nf_aom, 'high', self.params['AWG_A_SP_voltage']) qt.pulsar.set_channel_opt(chan_yellowlaser, 'high', self.params['AWG_yellow_voltage']) #qt.pulsar.set_channel_opt(chan_eom_aom,'low', 0.1) # MBI element e_mbi = self._MBI_element() # LDE element e_lde = element.Element('lde', pulsar=qt.pulsar) # 1: spin pumping p_wait = pulse.SquarePulse(self.chan_nf_aom, 'initialdelay', length=10e-9, amplitude=0) last = e_lde.add(p_wait) p_sp = pulse.SquarePulse(self.chan_nf_aom, 'spinpumping', length=self.params['AWG_SP_duration'], amplitude=1) p_yellow = pulse.SquarePulse(chan_yellowlaser, 'yellowpumping', length=self.params['AWG_yellow_duration'], amplitude=1) e_lde.add(p_yellow, refpulse=last, refpoint='end') last = e_lde.add(p_sp, refpulse=last, refpoint='end') p_sync = pulse.SquarePulse(chan_hhsync, 'debug_sync', length=50e-9, amplitude=1) p_hh_marker = pulse.SquarePulse(chan_hh_ma1, 'hh_marker', length=50e-9, amplitude=1) P_eom_aom = EOMAOMPulse(chan_eom, chan_eom_aom, 'opt_pi', **self.eom_pars) #pi/2 p_pi2 = pulselib.MW_IQmod_pulse( 'mw_pi2', I_channel=self.chan_mwI, Q_channel=self.chan_mwQ, PM_channel=self.chan_mw_pm, PM_risetime=self.params['MW_pulse_mod_risetime'], length=self.params['4MHz_pi2_duration'], amplitude=self.params['4MHz_pi2_amp'], frequency=self.params['4MHz_pi2_mod_frq'], ) last = e_lde.add(p_pi2, refpulse=last, refpoint='end', start=self.params['wait_after_sp']) # opt pi 1 i = 1 if self.params['long_histogram']: e_lde.add(p_sync) hhsync_amp = 0 else: hhsync_amp = 1 last = e_lde.add(pulse.cp(p_sync(amplitude=hhsync_amp)), name='start' + str(i), start=self.params['wait_after_pi2'], refpulse=last, refpoint='end') e_lde.add(p_hh_marker, name='mrkr' + str(i), start=-20e-9, refpulse=last, refpoint='start') last = e_lde.add(pulse.cp(p_sync(amplitude=0)), name='start' + str(i) + 'delay', refpulse=last, refpoint='end') last = e_lde.add(P_eom_aom, name='eom_pulse' + str(i), start=self.params['eom_start'], refpulse=last, refpoint='start') #pi p_pi = pulselib.MW_IQmod_pulse( 'mw_pi', I_channel=self.chan_mwI, Q_channel=self.chan_mwQ, PM_channel=self.chan_mw_pm, PM_risetime=self.params['MW_pulse_mod_risetime'], length=self.params['4MHz_pi_duration'], amplitude=self.params['4MHz_pi_amp'], frequency=self.params['4MHz_pi_mod_frq'], ) e_lde.add(p_pi, refpulse=last, refpoint='start', start=self.params['wait_after_opt_pi']) # opt pi 2 i = 2 last = e_lde.add(pulse.cp(p_sync(amplitude=hhsync_amp)), name='start' + str(i), start=self.params['opt_pi_separation'], refpulse='start' + str(i - 1), refpoint='start') last = e_lde.add(pulse.cp(p_sync(amplitude=0)), name='start' + str(i) + 'delay', refpulse=last, refpoint='end') last = e_lde.add(P_eom_aom, name='eom_pulse' + str(i), start=self.params['eom_start'], refpulse=last, refpoint='start') #pi/2 e_lde.add(p_pi2, refpulse=last, refpoint='start', start=self.params['wait_after_opt_pi2']) #final delay e_lde.add(pulse.cp(p_wait(length=self.params['finaldelay'])), refpulse=last, refpoint='end') #final SP element e_sp_final = element.Element('sp_final', pulsar=qt.pulsar) e_sp_final.append( pulse.cp(p_sp(length=self.params['AWG__finalSP_duration']))) #RO element e_ro = element.Element('readout', pulsar=qt.pulsar) p_RO = pulselib.MW_IQmod_pulse( 'readout pulse', I_channel=self.chan_mwI, Q_channel=self.chan_mwQ, PM_channel=self.chan_mw_pm, PM_risetime=int(self.params['MW_pulse_mod_risetime']), length=self.params['AWG_RO_MW_pulse_duration'], amplitude=self.params['AWG_RO_MW_pulse_amp'], frequency=self.params['AWG_RO_MW_pulse_ssbmod_frq']) p_ROsync = pulse.SquarePulse( self.chan_adwin_sync, 'adwin_sync', length=self.params['AWG_to_adwin_ttl_trigger_duration'], amplitude=1) e_ro.append(pulse.cp(p_wait(length=200e-9))) last = e_ro.append(p_RO) e_ro.add(p_ROsync, refpoint=last, start=50e-9) seq = pulsar.Sequence('LDE protocol test sequence wo MW') for i, r in enumerate(self.params['protocol_reps_sweep']): #print i, r # 1: MBI seq.append(name='MBI-%d' % i, wfname=e_mbi.name, trigger_wait=True, goto_target='MBI-%d' % i, jump_target='LDE-%d' % i) # 2: repeat LDE r times seq.append(name='LDE-%d' % i, wfname=e_lde.name, repetitions=r) # 3: spin pump a final time for the readout: seq.append(name='sp_final' + str(i), wfname=e_sp_final.name) seq.append(name='N_ro' + str(i), wfname=e_ro.name) if upload: qt.pulsar.upload(e_mbi, e_lde, e_sp_final, e_ro) 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'], pulse_delay=2e-9, 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'], pulse_delay=2e-9, 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 Pi2 Calibration') for i in range(self.params['pts_awg']): e = element.Element('CORPSE_Pi2_Pi-{}'.format(i), pulsar=qt.pulsar, global_time=True) e.append(T) e.append( pulse.cp(CORPSE_pi2, amplitude=self.params['CORPSE_pi2_sweep_amps'][i])) e.append(pulse.cp(TIQ, length=200e-9)) 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='synca-{}'.format(i), wfname=sync_elt.name) e = element.Element('CORPSE_Pi2-{}'.format(i), pulsar=qt.pulsar, global_time=True) e.append(T) e.append( pulse.cp(CORPSE_pi2, amplitude=self.params['CORPSE_pi2_sweep_amps'][i])) e.append(pulse.cp(TIQ, length=200e-9)) e.append(T) elts.append(e) seq.append(name='CORPSE_Pi2-{}'.format(i), wfname=e.name, trigger_wait=True) seq.append(name='syncb-{}'.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, upload=True, debug=False): # MBI element mbi_elt = self._MBI_element() # electron manipulation pulses T = pulse.SquarePulse(channel='MW_pulsemod', length = 750e-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'] ) N_pulse = pulselib.RF_erf_envelope( channel = 'RF', frequency = self.params['N_0-1_splitting_ms-1']) pi2pi_0 = pulselib.MW_IQmod_pulse('pi2pi pulse mI=0', I_channel = 'MW_Imod', Q_channel = 'MW_Qmod', PM_channel = 'MW_pulsemod', PM_risetime = self.params['MW_pulse_mod_risetime'], frequency = self.params['pi2pi_mI0_mod_frq'], amplitude = self.params['pi2pi_mI0_amp'], length = self.params['pi2pi_mI0_duration']) 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('NRabi_pt-%d' % i, pulsar=qt.pulsar, global_time = True) e.append(T) e.append( pulse.cp(X, frequency = self.params['MW_modulation_frequency'], amplitude = self.params['MW_pi_pulse_amp'], length = self.params['MW_pi_pulse_duration'])) e.append(T) for j in range(self.params['RF_pulse_multiplicities'][i]): e.append( pulse.cp(N_pulse, frequency = self.params['RF_pulse_frqs'][i], amplitude = self.params['RF_pulse_amps'][i], length = self.params['RF_pulse_durations'][i])) e.append( pulse.cp(T, length=self.params['RF_pulse_delays'][i])) e.append(pulse.cp(pi2pi_0)) e.append(pulse.cp(T)) e.append(adwin_sync) elts.append(e) # sequence seq = pulsar.Sequence('MBI Nitrogen 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) # program AWG if upload: #qt.pulsar.upload(mbi_elt, *elts) qt.pulsar.program_awg(seq, mbi_elt, *elts , debug=debug)