def calibrate(name): m = CORPSECalibration(name) #m = CORPSE_Imod_Calibration(name) funcs.prepare(m) pts = 21 CORPSE_frq = 10e6 m.params['CORPSE_rabi_frequency'] = CORPSE_frq m.params['Ex_SP_amplitude'] = 0 m.params['frq_mod'] = 0e6 m.params['mw_frq'] = m.params['ms-1_cntr_frq'] - m.params['frq_mod'] m.params['pts'] = pts m.params['repetitions'] = 1000 # sweep params m.params['CORPSE_pi_amp'] = 0.5 m.params['CORPSE_pi_sweep_amps'] = np.linspace( 0.50, 0.8, pts) #0.872982*np.ones(pts)# m.params['CORPSE_pulse_delay'] = 0e-9 m.params['CORPSE_pulse_delays'] = 0. * np.ones( pts) #np.linspace(0,10e-9,pts) m.params['CORPSE_eff_rotation_angle'] = 180 m.params['multiplicity'] = 11 m.params['delay_reps'] = 1 m.params['cur_MW_channel'] = 'MW_1' # for the autoanalysis m.params['sweep_name'] = 'CORPSE amplitude (V)' m.params['sweep_pts'] = m.params['CORPSE_pi_sweep_amps'] m.params['wait_for_AWG_done'] = 1 funcs.finish(m, debug=False)
def calibrate_theta_pulse(name, multiplicity=1, debug=False, mw2=False, **kw): m = pulsar_msmt.GeneralPiCalibrationSingleElement(name) espin_funcs.prepare(m) pulse_shape = m.params['pulse_shape'] pts = 25 m.params['pts'] = pts if pulse_shape == 'Square': raise KeyError('This hasnt been written for square pulses yet!') ps.X_pulse( m) #### update the pulse params depending on the chosen pulse shape. m.params['repetitions'] = 2500 m.params['MW_pulse_amplitudes'] = np.linspace(0.3, m.params['Hermite_pi_amp'], pts) m.params['multiplicity'] = np.ones(pts) * multiplicity m.params['delay_reps'] = 0 # for the autoanalysis m.params['sweep_name'] = 'MW amplitude (V)' m.params['sweep_pts'] = m.params['MW_pulse_amplitudes'] m.params['wait_for_AWG_done'] = 1 m.MW_pi = pulse.cp(ps.X_pulse(m), phase=0) espin_funcs.finish(m, debug=debug, pulse_pi=m.MW_pi)
def repelectronramsey(name): m = pulsar.RepElectronRamseys(name) funcs.prepare(m) m.params['wait_after_pulse_duration']=2 m.params['wait_after_RO_pulse_duration']=2 pts = 1 m.params['pts'] = pts m.params['repetitions'] = 50000 m.params['evolution_times'] = np.ones(pts)*(0.25/m.params['N_HF_frq']) # MW pulses m.params['detuning'] = 0.0e6 m.params['CORPSE_pi2_mod_frq'] = m.params['CORPSE_pi2_mod_frq'] m.params['CORPSE_pi2_amps'] = np.ones(pts)*m.params['CORPSE_pi2_amp']*0 m.params['CORPSE_pi2_phases1'] = np.ones(pts) * 0 m.params['CORPSE_pi2_phases2'] = np.ones(pts) * 90 #360 * m.params['evolution_times'] * 2e6 # for the autoanalysis m.params['sweep_name'] = 'evolution time (ns)' m.params['sweep_pts'] = m.params['evolution_times']/1e-9 funcs.finish(m) print m.adwin_var('completed_reps')
def dark_esr(name, Imod_channel=True, pulse_type='Square', debug=False): ''' dark ESR on the 0 <-> -1 transition. ''' m = pulsar_msmt.GeneralDarkESR(name) funcs.prepare(m) pulse_pi, pulse_pi2_not_used = pulse_defs(m, True, pulse_type, Imod_channel) m.params['pulse_type'] = pulse_type m.params['IQmod'] = True m.params['Imod_channel'] = Imod_channel m.params['repetitions'] = 1000 m.params['Ex_SP_amplitude'] = 0 m.params['range'] = 4e6 m.params['pts'] = 131 m.params['MW_pi_duration'] = 2.e-6 m.params['pulse_pi_amp'] = 0.03 m.params['ssbmod_frq_start'] = m.params[ 'MW_pulse_mod_frequency'] - m.params['range'] m.params['ssbmod_frq_stop'] = m.params[ 'MW_pulse_mod_frequency'] + m.params['range'] funcs.finish(m, upload=True, debug=False, pulse_pi=pulse_pi)
def sweep_pm_risetime(name, debug=False, mw2=False, **kw): m = pulsar_msmt.Sweep_pm_risetime(name) espin_funcs.prepare(m) pulse_shape = 'Square' m.params['pulse_shape'] = pulse_shape m.params['pulse_type'] = pulse_shape pts = 20 m.params['pts'] = pts m.params['repetitions'] = 1000 min_risetime = 0e-9 max_risetime = 20e-9 m.params['PM_risetime_sweep'] = np.linspace(min_risetime, max_risetime, pts) # for the autoanalysis m.params['sweep_name'] = 'PM risetime (ns)' m.params['sweep_pts'] = m.params['PM_risetime_sweep'] * 1e9 m.params['wait_for_AWG_done'] = 1 espin_funcs.finish(m, debug=debug, mw2=mw2)
def test_lde_sequence(name, IQmod=False, pulse_type='Hermite', debug=False): m = TestLDESequence(name) funcs.prepare(m) pulse_pi, pulse_pi2 = pulse_defs(m, IQmod, pulse_type) m.params['pulse_type'] = pulse_type m.params['IQmod'] = IQmod m.params['repetitions'] = 12000 m.params['Ex_SP_amplitude'] = 0 pts = 1 m.params['number_pulses'] = 2 # the 1st pi pulse is added m.params['pts'] = pts m.params['free_precession_offsets'] = np.ones(pts) * 0.0e-9 m.params['echo_offsets'] = np.linspace(-10, 10, pts) * 1e-9 # for the autoanalysis m.params['sweep_name'] = 'echo offset (ns)' #'MW_1_separation (ns)' m.params['sweep_pts'] = m.params['echo_offsets'] #XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX(for hannes) #m.autoconfig() #return m.generate_sequence(upload=False, pulse_pi=pulse_pi, pulse_pi2=pulse_pi2) funcs.finish(m, upload=True, debug=debug, pulse_pi=pulse_pi, pulse_pi2=pulse_pi2)
def calibrate_pi2_pulse(name, IQmod=True, Imod_channel=True, pulse_type='CORPSE', debug=False): m = pulsar_msmt.GeneralPi2Calibration(name) funcs.prepare(m) pulse_pi, pulse_pi2 = pulse_defs(m, IQmod, pulse_type, Imod_channel) m.params['pulse_type'] = pulse_type m.params['IQmod'] = IQmod m.params['Imod_channel'] = Imod_channel pts = 11 m.params['pts_awg'] = pts m.params['repetitions'] = 3000 # we do actually two msmts for every sweep point, that's why the awg gets only half of the # pts; m.params['pts'] = 2 * pts m.params['Ex_SP_amplitude'] = 0 m.params['wait_for_AWG_done'] = 1 sweep_axis = m.params['pulse_pi_amp'] + np.linspace(-0.15, 0.15, pts) m.params['pulse_pi2_sweep_amps'] = sweep_axis # for the autoanalysis m.params['sweep_name'] = 'MW pi/2 amp (V)' m.params['sweep_pts'] = np.sort(np.append(sweep_axis, sweep_axis)) funcs.finish(m, debug=debug, pulse_pi=pulse_pi, pulse_pi2=pulse_pi2)
def pi_pulse_sweepdelay(name, multiplicity=1, debug=False): m = pulsar_msmt.PiCalibration_SweepDelay(name) espin_funcs.prepare(m) m.params['pulse_type'] = 'Hermite quantum memory' # m.params['pulse_type'] = 'Square quantum memory' pts = 11 m.params['pts'] = pts # m.params['repetitions'] = 3000 if multiplicity == 1 else 5000 m.params['repetitions'] = 1000 if multiplicity == 1 else 5000 # Pulse settings m.params['multiplicity'] = np.ones(pts) * multiplicity m.params['MW_duration'] = m.params['Hermite_fast_pi_duration'] m.params[ 'MW_pulse_amplitudes'] = m.params['Hermite_fast_pi_amp'] * np.ones(pts) m.params['delay_reps'] = np.linspace(1, 100, pts) m.params['mw_power'] = 20 # for the autoanalysis m.params['sweep_name'] = 'Interpulse delay (us)' m.params['sweep_pts'] = m.params['interpulse_delay'] * 1e6 m.params['wait_for_AWG_done'] = 1 # Add Hermite X pulse m.MW_pi = ps.X_pulse(m) espin_funcs.finish(m, debug=debug, pulse_pi=m.MW_pi)
def sweep_number_pi_pulses(name, debug=False, pts=30): m = pulsar_msmt.GeneralPiCalibration(name) espin_funcs.prepare(m) ps.X_pulse( m) #### update the pulse params depending on the chosen pulse shape. m.params['multiplicity'] = np.arange(1, 1 + 2 * pts, 2) m.params['pulse_type'] = 'Hermite quantum memory' # pts = 10 m.params['pts'] = pts # m.params['repetitions'] = 3000 if multiplicity == 1 else 5000 m.params['repetitions'] = 1000 #if multiplicity == 1 else 5000 # Pulse settings m.params['MW_duration'] = m.params['fast_pi_duration'] m.params['MW_pulse_amplitudes'] = np.ones(pts) * m.params[ 'fast_pi_amp'] #XXXXX -0.05, 0.05 m.params['delay_reps'] = 20 # for the autoanalysis m.params['sweep_name'] = 'Number of pulses' m.params['sweep_pts'] = m.params['multiplicity'] m.params['wait_for_AWG_done'] = 1 # Add Hermite X pulse m.MW_pi = ps.X_pulse(m) espin_funcs.finish(m, debug=debug, pulse_pi=m.MW_pi)
def electronramseyCORPSE(name): m = pulsar_msmt.ElectronRamseyCORPSE(name) funcs.prepare(m) m.params.from_dict(qt.exp_params['protocols']['Hans_sil4']['Magnetometry']) pts = 101 m.params['pts'] = pts m.params['repetitions'] = 1000 print 1 / m.params['N_HF_frq'] #m.params['evolution_times'] = np.linspace(0,(pts-1)*1/m.params['N_HF_frq'],pts) m.params['evolution_times'] = np.linspace(0, 10000e-9, pts) #m.params['evolution_times'] = 5*np.ones (pts)*1e-9 print 'corspe frq', m.params['CORPSE_frq'] # MW pulses m.params['detuning'] = 0e3 m.params['CORPSE_pi2_mod_frq'] = m.params[ 'MW_modulation_frequency'] - m.params['detuning'] m.params['CORPSE_pi2_amps'] = np.ones(pts) * m.params['CORPSE_pi2_amp'] m.params['CORPSE_pi2_phases1'] = np.ones(pts) * 0 m.params['CORPSE_pi2_phases2'] = 0 * np.ones(pts) * ( 90. + 15) ##np.linspace(0,360,pts) #np.ones(pts) * 0# # for the autoanalysis m.params['sweep_name'] = 'evolution time (ns)' m.params['sweep_pts'] = m.params['evolution_times'] / 1e-9 #m.params['sweep_name'] = 'phase second pi2' #m.params['sweep_pts'] = m.params['CORPSE_pi2_phases2'] funcs.finish(m)
def sweep_amplitude(name): m = CORPSEPiCalibration(name) funcs.prepare(m) 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'][SAMPLE_CFG]['Magnetometry']) pts = 11 m.params['pts'] = pts m.params['repetitions'] = 1000 # sweep params m.params['CORPSE_pi_sweep_amps'] = np.ones( pts) * m.params['CORPSE_pi2_amp'] m.params['multiplicity'] = 1 m.params['delay_reps'] = 15 # for the autoanalysis m.params['sweep_name'] = 'CORPSE amplitude (V)' m.params['sweep_pts'] = m.params['CORPSE_pi_sweep_amps'] funcs.finish(m, debug=False)
def dark_esr(name, Imod_channel=True, pulse_type='Square', debug=False): ''' dark ESR on the 0 <-> -1 transition. This class uses IQ modulation, so set the amplitude for the IQ pi pulse and the length. ''' m = pulsar_msmt.GeneralDarkESR(name) funcs.prepare(m) pulse_pi, pulse_pi2_not_used = pulse_defs(m, True, pulse_type, Imod_channel) m.params['pulse_type'] = pulse_type m.params['IQmod'] = True m.params['Imod_channel'] = Imod_channel m.params['repetitions'] = 1000 m.params['Ex_SP_amplitude'] = 0 m.params['range'] = 6e6 m.params['pts'] = 131 # Be careful, this class uses IQ modulation, so set the amplitude for the IQ pi pulse. m.params['ssbmod_frq_start'] = m.params[ 'MW_pulse_mod_frequency'] - m.params['range'] m.params['ssbmod_frq_stop'] = m.params[ 'MW_pulse_mod_frequency'] + m.params['range'] funcs.finish(m, upload=True, debug=False, pulse_pi=pulse_pi)
def sweep_eff_rot_angle(name): m = CORPSECalibration(name) funcs.prepare(m) 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'][SAMPLE_CFG]['Magnetometry']) pts = 21 m.params['pts'] = pts m.params['repetitions'] = 1000 # sweep params m.params['CORPSE_sweep_amps'] = np.ones(pts) * 0.811 m.params['CORPSE_pi_sweep_amps'] = m.params['CORPSE_sweep_amps'] m.params['CORPSE_effective_rotation_angles'] = np.linspace(0, 360, pts) m.params['CORPSE_mod_frq'] = m.params['ms-1_cntr_frq'] - m.params['mw_frq'] m.params['CORPSE_rabi_frequency'] = m.params['CORPSE_frq'] m.params['multiplicity'] = 1 m.params['delay_reps'] = 15 # for the autoanalysis m.params['sweep_name'] = 'CORPSE Desired rotation angle (degrees)' m.params['sweep_pts'] = m.params['CORPSE_effective_rotation_angles'] funcs.finish(m, debug=False)
def _setup_params(msmt, setup): msmt.params['setup']=setup espin_funcs.prepare(msmt) if not(hasattr(msmt,'joint_params')): msmt.joint_params = {} import joint_params reload(joint_params) for k in joint_params.joint_params: msmt.joint_params[k] = joint_params.joint_params[k] if setup == 'lt4' : import params_lt4 reload(params_lt4) msmt.AWG_RO_AOM = qt.instruments['PulseAOM'] for k in params_lt4.params_lt4: msmt.params[k] = params_lt4.params_lt4[k] elif setup == 'lt3' : import params_lt3 reload(params_lt3) msmt.AWG_RO_AOM = qt.instruments['PulseAOM'] for k in params_lt3.params_lt3: msmt.params[k] = params_lt3.params_lt3[k] else: print 'Sweep_bell: invalid setup:', setup msmt.params['send_AWG_start'] = 1 msmt.params['sync_during_LDE'] = 1 msmt.params['wait_for_AWG_done'] = 1 msmt.params['do_general_sweep']= 1 msmt.params['trigger_wait'] = 1
def cal_CORPSE_pi2(name): """ Do a pi/2 with and without a pi pulse afterward, sweeping the amplitude of the pi/2. """ m = CORPSEPi2Calibration(name) funcs.prepare(m) pts = 21 m.params['pts_awg'] = pts # we do actually two msmts for every sweep point, that's why the awg gets only half of the # pts; m.params['pts'] = 2 * pts m.params['repetitions'] = 1000 m.params['wait_for_AWG_done'] = 1 m.params['Ex_SP_amplitude'] = 0 m.params['CORPSE_mod_frq'] = m.params['CORPSE_pi_mod_frq'] sweep_axis = linspace(0.15, 0.3, pts) m.params['CORPSE_pi2_sweep_amps'] = sweep_axis # for the autoanalysis m.params['sweep_name'] = 'MW pi/2 amp (V)' m.params['sweep_pts'] = np.sort(np.append(sweep_axis, sweep_axis)) funcs.finish(m, upload=UPLOAD, debug=DEBUG)
def calibrate_msm1_pi(name): m = CORPSEPiCalibration(name) funcs.prepare(m) pts = 11 CORPSE_frq = 6.5e6 m.params['CORPSE_rabi_frequency'] = CORPSE_frq m.params['CORPSE_pi_amp'] = 0.5 #m.params['msm1_CORPSE_pi_amp'] m.params['CORPSE_pi_60_duration'] = 1. / CORPSE_frq / 6. m.params['CORPSE_pi_m300_duration'] = 5. / CORPSE_frq / 6. m.params['CORPSE_pi_420_duration'] = 7. / CORPSE_frq / 6. m.params[ 'CORPSE_pi_mod_frq'] = m.params['ms-1_cntr_frq'] - m.params['mw_frq'] m.params['pts'] = pts m.params['repetitions'] = 5000 # sweep params m.params['CORPSE_pi_sweep_amps'] = np.linspace(0.7, 0.9, pts) m.params['multiplicity'] = 1 m.params['delay_reps'] = 15 # for the autoanalysis m.params['sweep_name'] = 'CORPSE amplitude (V)' m.params['sweep_pts'] = m.params['CORPSE_pi_sweep_amps'] m.params['wait_for_AWG_done'] = 1 funcs.finish(m, debug=True)
def repelectronramseyCORPSE_loop(label='', delay_time=1, repump_E=0, repump_A=0, nr_of_hyperfine_periods=3, phase=90, reps=2, upload=True): name = 'SIL4_' + str(nr_of_hyperfine_periods) + '_hf' + label n = name + "_" + str(delay_time) + "us" + "A" + str(repump_A) + "E" + str( repump_E) m = pulsar_msmt.RepElectronRamseysCORPSE(n) funcs.prepare(m) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO+MBI']) m.params.from_dict(qt.exp_params['protocols']['Hans_sil4']['Magnetometry']) m.params['repump_E'] = repump_E m.params['repump_A'] = repump_A m.params['wait_time_between_msmnts'] = delay_time pts = 1 m.params['pts'] = pts m.params['repetitions'] = 5000 m.params['evolution_times'] = np.ones( 1) * nr_of_hyperfine_periods / m.params['N_HF_frq'] # MW pulses m.params['CORPSE_pi2_mod_frq'] = m.params['MW_modulation_frequency'] m.params['CORPSE_pi2_amps'] = np.ones(pts) * m.params['CORPSE_pi2_amp'] m.params['CORPSE_pi2_phases1'] = np.ones(pts) * 0 m.params['CORPSE_pi2_phases2'] = np.ones(pts) * ( phase + 15) #360 * m.params['evolution_times'] * 2e6 # for the autoanalysis m.params['sweep_name'] = 'evolution time (ns)' m.params['sweep_pts'] = m.params['evolution_times'] / 1e-9 #m.autoconfig() #return_e=m.generate_sequence() #funcs.finish(m,upload=upload) #print m.adwin_var('completed_reps') m.autoconfig() m.generate_sequence(upload=upload) for i in np.arange(reps): if (msvcrt.kbhit() and (msvcrt.getch() == 'q')): m.finish() raise Exception('User abort') print '#######################################' print '#### Rep nr ', str(i), ' / ', str(reps), ' ##########' print '#######################################' m.run(autoconfig=False) m.save('rep_' + str(i)) m.finish()
def dd_calibrate_T2(name): m = dd_msmt.DynamicalDecoupling('calibrate_T2') funcs.prepare(m) m.params_lt3 = m.params m.params_lt3['pi2_pulse_phase'] = 0 #Y m.params_lt3['DD_pi_phases'] = [90, 0, 90] ## THIS DEFINES THE XYX SEQUENCE m.params_lt3['CORPSE_pi2_wait_length'] = 1300e-9 m.params_lt3[ 'first_C_revival'] = 106.579e-6 / 2. #C revival after CORPSE_pi2_wait_length m.params_lt3['dd_extra_t_between_pi_pulses'] = -0.111e-6 #0.470e-6 m.params_lt3['dd_spin_echo_time'] = -83.5e-9 m.params['dd_use_delay_reps'] = False m.params['EOM_trigger_length'] = 100e-9 m.params['PLU_gate_duration'] = 100e-9 m.params['Ex_SP_amplitude'] = 0 m.update_definitions() m.params['dd_use_delay_reps'] = True pts_per_revival = 2 revivals = 16 pts = pts_per_revival * (revivals - 1) m.params['pts'] = pts m.params['repetitions'] = 750 m.params_lt3['wait_for_AWG_done'] = 1 # sweep params #free evolutiona time is half the total evolution time!!! from centre to centre of pulses sweep_array = m.params_lt3['first_C_revival'] + np.linspace( -1e-6, 1e-6, pts_per_revival) for r in range(2, revivals): sweep_array=np.append(sweep_array, \ r * (m.params_lt3['first_C_revival'] \ + m.params_lt3['CORPSE_pi2_wait_length'] \ + m.params_lt3['dd_extra_t_between_pi_pulses']) + np.linspace(-1e-6, 1e-6, pts_per_revival)) print sweep_array m.params_lt3['free_evolution_times'] = sweep_array m.params_lt3['DD_pi_phases'] = [0] m.dd_sweep_free_ev_time_msmt() # for the autoanalysis m.params_lt3['sweep_name'] = 'total free evolution time (us)' m.params_lt3['sweep_pts'] = 2 * m.params_lt3['free_evolution_times'] / 1e-6 funcs.finish(m, upload=UPLOAD, debug=False)
def rabi(name, IQmod=True, Imod_channel=True, pulse_type='Square', debug=False): m = pulsar_msmt.GeneralElectronRabi(name) funcs.prepare(m) pulse, pulse_pi2_not_used = pulse_defs(m, IQmod, pulse_type, Imod_channel) m.params['pulse_type'] = pulse_type m.params['IQmod'] = IQmod m.params['Imod_channel'] = Imod_channel m.params['pts'] = 21 pts = m.params['pts'] m.params['repetitions'] = 2000 m.params['Ex_SP_amplitude'] = 0 sweep_duration = False if sweep_duration: m.params['pulse_sweep_durations'] = np.linspace(0, 50, pts) * 1e-9 m.params['pulse_sweep_amps'] = np.ones(pts) * 0.9 # for autoanalysis m.params['sweep_name'] = 'Pulse durations (ns)' m.params['sweep_pts'] = m.params['pulse_sweep_durations'] * 1e9 else: m.params['pulse_sweep_durations'] = np.ones( pts) * 4000e-9 #np.linspace(0, 10, pts) * 1e-6 m.params['pulse_sweep_amps'] = np.linspace(0., 0.04, pts) #0.55*np.ones(pts) # for autoanalysis m.params['sweep_name'] = 'MW_pulse_amplitudes (V)' m.params['sweep_pts'] = m.params['pulse_sweep_amps'] print m.params['sweep_pts'] print Imod_channel funcs.finish(m, upload=True, debug=debug, pulse_pi=pulse, Imod_channel=Imod_channel) print "\nAnalysis suggestion : execfile(r'D:\measuring\\analysis\scripts\espin\electron_rabi_analysis.py')"
def sweep_amplitude(name): m = CORPSEPiCalibration(name) funcs.prepare(m) pts = 11 m.params['pts'] = pts m.params['repetitions'] = 1000 # sweep params m.params['CORPSE_pi_sweep_amps'] = np.linspace(0.6, 0.8, pts) m.params['multiplicity'] = 11 m.params['delay_reps'] = 15 # for the autoanalysis m.params['sweep_name'] = 'CORPSE amplitude (V)' m.params['sweep_pts'] = m.params['CORPSE_pi_sweep_amps'] funcs.finish(m, debug=True)
def calibrate_pi_pulse_NoIQSource(name, multiplicity=1, debug=False): m = pulsar_msmt.General_mw2_PiCalibrationSingleElement(name) espin_funcs.prepare(m) m.params['pulse_type'] = 'Hermite quantum memory' # m.params['pulse_type'] = 'Square quantum memory' pts = 16 m.params['pts'] = pts # m.params['repetitions'] = 3000 if multiplicity == 1 else 5000 m.params['repetitions'] = 600 rng = 8e-9 if multiplicity == 1 else 4e-9 ### Pulse settings m.params['multiplicity'] = np.ones(pts) * multiplicity # For square pulses m.params['MW2_duration'] = m.params['mw2_fast_pi_duration'] + np.linspace( -rng, rng, pts) m.params['MW2_pulse_amplitudes'] = m.params[ 'mw2_fast_pi_amp'] #XXXXX -0.05, 0.05 # For hermite pulses # m.params['MW_duration'] = m.params['Hermite_fast_pi_duration'] # m.params['MW_pulse_amplitudes'] = m.params['Hermite_fast_pi_amp'] + np.linspace(-0.04, 0.02, pts) #XXXXX -0.05, 0.05 m.params['delay_reps'] = 195 ## Currently not used # m.params['mw_power'] = 20 ###put in msmt_params. # for the autoanalysis m.params['sweep_name'] = 'MW duration (ns)' m.params['sweep_pts'] = m.params['MW2_duration'] * 1e9 m.params['wait_for_AWG_done'] = 1 # Add Hermite X pulse # m.MW_pi = hermite_Xpi(m) m.MW_pi = pulse.cp(ps.pi_pulse_MW2(m), phase=0) print 'amplitude ', m.params['MW2_pulse_amplitudes'] print 'duration ', m.params['MW2_duration'][0] espin_funcs.finish(m, debug=debug, pulse_pi=m.MW_pi)
def calibrate_pi2_pulse(name, debug=False, mw2=False): m = pulsar_msmt.GeneralPi2Calibration(name) espin_funcs.prepare(m) pts = 11 m.params['pulse_type'] = 'Hermite' m.params['pts_awg'] = pts m.params['repetitions'] = 2000 if mw2: print m.params['mw2_pulse_shape'] m.MW_pi = ps.mw2_X_pulse(m) m.MW_pi2 = ps.mw2_Xpi2_pulse(m) sweep_axis = m.params['mw2_Hermite_pi2_amp'] + np.linspace( -0.12, 0.12, pts) m.params['pulse_pi2_sweep_amps'] = sweep_axis else: print m.params['pulse_shape'] m.MW_pi = ps.X_pulse(m) m.MW_pi2 = ps.Xpi2_pulse(m) sweep_axis = m.params['Hermite_pi2_amp'] + np.linspace( -0.12, 0.12, pts) m.params['pulse_pi2_sweep_amps'] = sweep_axis # print 'this is the length',m.MW_pi2.length # we do actually two msmts for every sweep point, that's why the awg gets only half of the # pts; m.params['pts'] = 2 * pts m.params['Ex_SP_amplitude'] = 0 # m.params['SP_duration'] = 50 m.params['wait_for_AWG_done'] = 1 # Square pulses # sweep_axis = m.params['fast_pi2_amp'] + np.linspace(-0.02, 0.02, pts) # m.params['pulse_pi2_sweep_amps'] = sweep_axis # for the autoanalysis m.params['sweep_name'] = 'MW pi/2 amp (V)' m.params['sweep_pts'] = np.sort(np.append(sweep_axis, sweep_axis)) espin_funcs.finish(m, debug=debug, pulse_pi=m.MW_pi, pulse_pi2=m.MW_pi2)
def calibrate_pi_pulse(name, multiplicity=1, debug=False, mw2=False, **kw): m = pulsar_msmt.GeneralPiCalibrationSingleElement(name) espin_funcs.prepare(m) pulse_shape = m.params['pulse_shape'] pts = 15 m.params['pts'] = pts ps.X_pulse( m) #### update the pulse params depending on the chosen pulse shape. m.params['repetitions'] = 1000 if multiplicity == 1 else 1000 rng = 0.1 if multiplicity == 1 else 0.06 ### comment NK: the previous parameters for MW_duration etc. were not used anywhere in the underlying measurement class. ### therefore, I removed them if mw2: m.params[ 'MW_pulse_amplitudes'] = m.params['mw2_fast_pi_amp'] + np.linspace( -rng, rng, pts) else: m.params[ 'MW_pulse_amplitudes'] = m.params['fast_pi_amp'] + np.linspace( -rng, rng, pts) # m.params['MW_pulse_amplitudes'] = np.linspace(0,0.9,pts) m.params['interpulse_delay'] = [7.5e-6] * pts m.params['AWG_controlled_readout'] = 0 m.params['multiplicity'] = np.ones(pts) * multiplicity m.params['delay_reps'] = 0 # for the autoanalysis m.params['sweep_name'] = 'MW amplitude (V)' m.params['sweep_pts'] = m.params['MW_pulse_amplitudes'] m.params['wait_for_AWG_done'] = 1 m.MW_pi = pulse.cp(ps.mw2_X_pulse(m), phase=0) if mw2 else pulse.cp( ps.X_pulse(m), phase=0) espin_funcs.finish(m, debug=debug, pulse_pi=m.MW_pi)
def calibrate_comp_pi2_pi_pi2_pulse(name, multiplicity=1, debug=False): m = pulsar_msmt.CompositePiCalibrationSingleElement(name) espin_funcs.prepare(m) m.params['pulse_type'] = 'Hermite composite' # m.params['pulse_type'] = 'Square quantum memory' pts = 30 m.params['pts'] = pts m.params['repetitions'] = 600 rng = 0.1 if multiplicity == 1 else 0.05 m.params['wait_for_AWG_done'] = 1 ### Pulse settings # m.params['multiplicity'] = np.ones(pts)*multiplicity m.params['multiplicity'] = multiplicity m.params['Hermite_pi_amp'] = 0.93 m.params['Hermite_pi2_amp'] = 0.75 m.params['interpulse_delay'] = 4e-9 m.params['X_phase'] = 90.05 m.params['Y_phase'] = -0.028 #sweep generation # m.params['general_sweep_pts'] = m.params['Hermite_pi_amp'] + np.linspace(-rng,rng,pts) # m.params['general_sweep_name'] = 'Hermite_pi_amp' m.params['general_sweep_pts'] = np.arange(1, 1 + 4 * pts, 4) m.params['general_sweep_name'] = 'multiplicity' # m.params['general_sweep_pts'] = np.linspace(m.params['Y_phase']-2,m.params['Y_phase']+2,pts) # m.params['general_sweep_name'] = 'Y_phase' # m.params['general_sweep_pts'] = np.round(np.linspace(0,100e-9,pts),9) # m.params['general_sweep_name'] = 'interpulse_delay' # for the autoanalysis m.params['sweep_name'] = m.params['general_sweep_name'] m.params['sweep_pts'] = m.params['general_sweep_pts'] # Create pi pulse m.comp_pi = pulse.cp(ps.comp_pi2_pi_pi2_pulse(m), phase=0) espin_funcs.finish(m, debug=debug, pulse_pi=m.comp_pi)
def repelectronramsey(name): m = pulsar_msmt.RepElectronRamseys(name) funcs.prepare(m) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO+MBI']) m.params['SP_duration'] = 10 m.params['A_SP_amplitude'] = 50e-9 m.params['SSRO_duration'] = 10 pts = 1 m.params['pi2_amps'] = np.ones(pts) * 1 m.params['pi2_phases1'] = np.ones(pts) * 1 m.params['pi2_phases2'] = np.ones(pts) * 1 m.params['pi2_lengths'] = np.ones(pts) * 1 m.params['MW_pulse_frequency'] = 100e6 m.params['wait_after_pulse_duration'] = 2 m.params['wait_after_RO_pulse_duration'] = 2 pts = 1 m.params['pts'] = pts m.params['repetitions'] = 5000 m.params['evolution_times'] = np.linspace(0, 1 * (pts - 1) * 1 / 2.165e6, pts) # MW pulses m.params['detuning'] = 0.0e6 m.params['CORPSE_pi2_mod_frq'] = m.params[ 'MW_modulation_frequency'] + m.params['detuning'] - 50e3 m.params['CORPSE_pi2_amps'] = np.ones(pts) * m.params['CORPSE_pi2_amp'] m.params['CORPSE_pi2_phases1'] = np.ones(pts) * 0 m.params['CORPSE_pi2_phases2'] = np.ones( pts) * 90 #360 * m.params['evolution_times'] * 2e6 # for the autoanalysis m.params['sweep_name'] = 'evolution time (ns)' m.params['sweep_pts'] = m.params['evolution_times'] / 1e-9 funcs.finish(m, upload=True) print m.adwin_var('completed_reps')
def cal_ssro_teleportation(name, A_SP_duration=250): m = ssro.AdwinSSRO('SSROCalibration_' + name) m.params.from_dict(qt.cfgman['protocols']['AdwinSSRO']) funcs.prepare(m) m.params['SSRO_repetitions'] = 5000 m.params['SSRO_duration'] = 50 m.params[ 'SP_duration'] = A_SP_duration # we want to calibrate the RO, not the SP # ms = 1 calibration m.params['Ex_SP_amplitude'] = 0 m.run() m.save('ms0') # ms = 1 calibration m.params['A_SP_amplitude'] = 0. m.params['SP_duration'] = 250 m.params['Ex_SP_amplitude'] = 10e-9 m.run() m.save('ms1') m.finish()
def repelectronramseyCORPSE(name, delay_time=1, repump_E=0, repump_A=0, nr_of_hyperfine_periods=3, phase=90, upload=False): m = pulsar_msmt.RepElectronRamseysCORPSE(name) funcs.prepare(m) m.params.from_dict(qt.exp_params['protocols']['AdwinSSRO+MBI']) m.params.from_dict(qt.exp_params['protocols']['Hans_sil4']['Magnetometry']) m.params['repump_E'] = repump_E m.params['repump_A'] = repump_A m.params['wait_time_between_msmnts'] = delay_time pts = 1 m.params['pts'] = pts m.params['repetitions'] = 5000 m.params['evolution_times'] = np.ones( 1) * nr_of_hyperfine_periods / m.params['N_HF_frq'] # MW pulses m.params['CORPSE_pi2_mod_frq'] = m.params['MW_modulation_frequency'] m.params['CORPSE_pi2_amps'] = np.ones( pts) * 1 # np.ones(pts)*m.params['CORPSE_pi2_amp'] m.params['CORPSE_pi2_phases1'] = np.ones(pts) * 0 m.params['CORPSE_pi2_phases2'] = np.ones( pts) * phase #360 * m.params['evolution_times'] * 2e6 # for the autoanalysis m.params['sweep_name'] = 'evolution time (ns)' m.params['sweep_pts'] = m.params['evolution_times'] / 1e-9 #m.autoconfig() #return_e=m.generate_sequence() funcs.finish(m, upload=upload) print m.adwin_var('completed_reps')
def ramsey(name, IQmod=False, Imod_channel=True, pulse_type='Square', debug=False): m = pulsar_msmt.GeneralElectronRamsey(name) funcs.prepare(m) pulse_pi_not_used, pulse_pi2 = pulse_defs(m, IQmod, pulse_type, Imod_channel) m.params['pulse_type'] = pulse_type m.params['IQmod'] = IQmod m.params['Imod_channel'] = Imod_channel pts = 250 m.params['pts'] = pts m.params['repetitions'] = 1000 m.params['Ex_SP_amplitude'] = 0 m.params['detuning'] = 0.e6 m.params['mw_frq'] -= m.params['detuning'] #m.params['evolution_times'] = np.linspace(0,(pts-1)*1/m.params['N_HF_frq'],pts) m.params['evolution_times'] = np.linspace(0, 10000e-9, pts) #m.params['evolution_times'] = 5*np.ones (pts)*1e-9 # MW pulses m.params['pulse_sweep_pi2_phases1'] = np.ones(pts) * 0 m.params['pulse_sweep_pi2_phases2'] = 0 * np.ones( pts) #* (90.+15) ##np.linspace(0,360,pts) #np.ones(pts) * 0# # for the autoanalysis m.params['sweep_name'] = 'evolution time (ns)' m.params['sweep_pts'] = m.params['evolution_times'] / 1e-9 #m.params['sweep_name'] = 'phase second pi2' #m.params['sweep_pts'] = m.params['CORPSE_pi2_phases2'] funcs.finish(m, debug=debug, pulse_pi2=pulse_pi2)
def electronramsey(name): m = pulsar.ElectronRamsey(name) funcs.prepare(m) pts = 61 m.params['pts'] = pts m.params['repetitions'] = 1000 m.params['evolution_times'] = np.linspace(0,450e-9,pts) # MW pulses m.params['detuning'] = 0.0e6 m.params['CORPSE_pi2_mod_frq'] = m.params['CORPSE_pi2_mod_frq'] + m.params['detuning'] m.params['CORPSE_pi2_amps'] = np.ones(pts)*m.params['CORPSE_pi2_amp'] m.params['CORPSE_pi2_phases1'] = np.ones(pts) * 0 m.params['CORPSE_pi2_phases2'] = np.ones(pts) * 0#360 * m.params['evolution_times'] * 2e6 # for the autoanalysis m.params['sweep_name'] = 'evolution time (ns)' m.params['sweep_pts'] = m.params['evolution_times']/1e-9 funcs.finish(m)
def cal_CORPSE_pi(name, multiplicity=1): m = CORPSE_calibration.CORPSEPiCalibration(name + 'M={}'.format(multiplicity)) funcs.prepare(m) pts = 11 m.params['pts'] = pts m.params['repetitions'] = 1000 m.params['wait_for_AWG_done'] = 1 m.params['Ex_SP_amplitude'] = 0 # sweep params m.params['CORPSE_mod_frq'] = m.params['CORPSE_pi_mod_frq'] m.params['CORPSE_pi_sweep_amps'] = np.linspace(0.15, 0.25, pts) m.params['multiplicity'] = multiplicity name + 'M={}'.format(m.params['multiplicity']) m.params['delay_reps'] = 15 # for the autoanalysis m.params['sweep_name'] = 'CORPSE amplitude (V)' m.params['sweep_pts'] = m.params['CORPSE_pi_sweep_amps'] funcs.finish(m, upload=UPLOAD, debug=False)
def calibrate_pi4_pulse(name, IQmod=True, pulse_type='CORPSE', debug=False): #m = GeneralPi4Calibration(name) m = pulsar_msmt.GeneralPi4Calibration_2(name) funcs.prepare(m) pulse_pi, pulse_pi2 = calib.pulse_defs(m, IQmod, pulse_type) m.params['pulse_type'] = pulse_type m.params['IQmod'] = IQmod pts = 11 m.params['pts_awg'] = pts m.params['repetitions'] = 5000 # we do actually two msmts for every sweep point, that's why the awg gets only half of the # pts; m.params['pts'] = 2 * pts m.params['Ex_SP_amplitude'] = 0 m.params['wait_for_AWG_done'] = 1 sweep_axis = np.linspace(0.25, 0.5, pts) m.params['pulse_pi4_sweep_amps'] = sweep_axis m.params['pulse_pi4_sweep_durations'] = np.ones( pts) * m.params['Hermite_pi4_length'] m.params['pulse_pi4_sweep_phases'] = np.zeros(pts) m.params['evolution_times'] = np.ones(pts) * 500e-9 m.params['extra_wait_final_pi4'] = np.ones(pts) * 0. # for the autoanalysis m.params['sweep_name'] = 'MW pi/4 amp (V)' m.params['sweep_pts'] = np.sort(np.append(sweep_axis, sweep_axis)) funcs.finish(m, debug=debug, pulse_pi=pulse_pi, pulse_pi2=pulse_pi2)
def dd_calibrate_C13_revival(name): m = dd_msmt.DynamicalDecoupling('calibrate_first_revival') funcs.prepare(m) m.params_lt3 = m.params m.params_lt3['pi2_pulse_phase'] = 0 #Y m.params_lt3['DD_pi_phases'] = [90, 0, 90] ## THIS DEFINES THE XYX SEQUENCE m.params_lt3['CORPSE_pi2_wait_length'] = 1300e-9 m.params_lt3[ 'first_C_revival'] = 106.579e-6 / 2. #C revival after CORPSE_pi2_wait_length m.params_lt3['dd_extra_t_between_pi_pulses'] = -0.111e-6 #0.470e-6 m.params_lt3['dd_spin_echo_time'] = -83.5e-9 m.params['dd_use_delay_reps'] = False m.params['EOM_trigger_length'] = 100e-9 m.params['PLU_gate_duration'] = 100e-9 m.params['Ex_SP_amplitude'] = 0 m.update_definitions() pts = 11 m.params['pts'] = pts m.params['repetitions'] = 2000 m.params_lt3['wait_for_AWG_done'] = 1 # sweep params #free evolutiona time is half the total evolution time!!! from centre to centre of pulses m.params_lt3['free_evolution_times'] = 52.4e-6 + np.linspace( -5e-6, 5e-6, pts) #m.params_lt3['first_C_revival'] # m.params_lt3['DD_pi_phases'] = [0] m.dd_sweep_free_ev_time_msmt() # for the autoanalysis m.params_lt3['sweep_name'] = 'total free evolution time (us)' m.params_lt3['sweep_pts'] = 2 * m.params_lt3['free_evolution_times'] / 1e-6 funcs.finish(m, upload=UPLOAD, debug=False)