def EOM_test(SpecAn): ## SpecAn.write('LG 10') ## pb.Sequence([(['ch2'], 1*ms)], loop=False) ## sleep(3) ## SpecAn.write('MKPK HI') ## num = SpecAn.query('MKA?') ## print num pb.Sequence([(['ch2', 'ch5'], 1 * ms)], loop=False) sleep(3) SpecAn.write("LG 2") h.run_offset(SpecAn, sweep=2) SpecAn.write('ST 2') filepath = h.create_file(SpecAn, filename='EOM bias test', compensated='Y', n=1, burn_time=0) pb.Sequence([(['ch1'], 4 * s)] + [(['ch2', 'ch4', 'ch5'], 3000 * ms)] + [(['ch2', 'ch5'], 1 * s)], loop=False) filepath = h.record_trace(SpecAn, filepath, compensated='Y', n=1, burn_time=0)
def comb_background_abs(burn_f=1.1 * GHz, shots=1000, delay=0): ''' Idea: Spin pump crystal Burn a narrow hole where the AFC will be (100 kHz) Send broad pulse through quickly after (>1ms after, MHz broad) What comes out should give a measurement of the background where the AFC will be before spin jumping. Turn WF on Set up PS for RAPID BLOCK mode''' mc.setWvfm(0) sleep(0.1) pb.Sequence([(['ch1', 'ch5'], 50 * ms), (['ch5'], 1 * ms)], loop=False) sleep(0.1) AWG_trig_out() ## wf = wf_24_cw(burn_f + 19e6 + 460.99e6, -10) mc.setWvfm(1) sleep(0.1) arr = [(['ch5', 'ch6'], 10 * s), (['ch5'], 20 * ms) ] #10s to spin pol. crystal, 20ms to let the mems switch switch. pb.Sequence(arr, loop=False) time.sleep(10.1) pb.ProbBurnLoop(shots=1000) time.sleep(shots * 7e-4) #replace this is Wvfm time length mc.setWvfm(2) pb.ProbBurnLoop(shots=1000) time.sleep(shots * 5e-4) #replace this is Wvfm time length
def temp_func(): for i in range(10): filepath = hb.create_file(SpecAn, compensated='Y', n=1, burn_time=0, filename=' 2nd background ' + str(i)) sleep(100 * ms) pb.Sequence( [ (['ch5'], 0.5 * s), (['ch5', 'ch6'], 20 * us), (['ch5'], 5 * ms), (['ch2', 'ch4', 'ch5' ], 50 * ms), #RF Switch, Trigger SpecAn, EOM Bias on (['ch2', 'ch5'], 100 * ms), ], loop=False) hb.record_trace(SpecAn, filepath, filename=' 2nd background ' + str(i), compensated='Y', sweep_again='Y', n=1, burn_time='')
def hardburn(): freq = 1.04 * GHz span = 20 * MHz title_str = '20MHz, 2500ms, 1.8GHz' HP8560E_SpecAn_Trigger('FREE', 'CONTS', SpecAn) spin_pump_seq() mc.setWvfm(2) burn_sequence_AWG_cust(burn=50 * ms, burn_freq=freq, record='True', rec_span=span, f_name=' ' + title_str, sa='N') # ' + str(i)) filepath = hb.create_file(SpecAn, compensated='Y', n=1, burn_time=0, filename=' Spin pumped after ' + title_str) sleep(100 * ms) pb.Sequence( [ (['ch5'], 0.5 * s), (['ch2', 'ch4', 'ch5' ], 50 * ms), #RF Switch, Trigger SpecAn, EOM Bias on (['ch2', 'ch5'], 100 * ms), ], loop=False) hb.record_trace(SpecAn, filepath, filename=' Spin pumped after ' + title_str, compensated='Y', sweep_again='N', n=1, burn_time='')
def spin_polarise(SpecAn, SpecAn_Bool, start_freq, pumps = 10, direction = 'backwards'): ''' Controls stanford plugged into VCO to spin pump ensomble by scanning over delta m = +/-1. MIN FREQ: 1900MHz''' sweep_time = 50*ms sweep_array = np.array([[start_freq, start_freq + 800*MHz, sweep_time]]) #Best time scale is 100ms sweep time - Milos print 'Sweep range: ' + str(np.min(sweep_array)) +', '+ str(np.max(sweep_array)/1e6) [Stanford_FG, Stanford_Bool] = stan.Initialise_Stanford_FG() #Tell me the Stanfords settings Stanford_FG.write('AMPL?') print 'Amplitude set to ' + Stanford_FG.read() Stanford_FG.write('OFFS?') print 'Offset set to ' + Stanford_FG.read() if direction == 'backwards': [num_array, waveform_length] = stan.VCO_Sweep_backwards(sweep_array, Stanford_FG, Stanford_Bool, 'op amp 3.7', SpecAn, SpecAn_Bool) elif direction == 'forwards': [num_array, waveform_length] = stan.VCO_Sweep(sweep_array, Stanford_FG, Stanford_Bool, 'op amp 3.7', SpecAn, SpecAn_Bool) else: raise error('direction must be either backwards or forwards') stan.Upload_to_Stanford_FG(num_array,waveform_length, Stanford_FG) #Sets pulseblaster to run VCO via ch3 time = pumps*sweep_time print 'Spin polarizing for: ' + str(time) + ' seconds' array = create_sequence(time) pb.Sequence(array,loop=False)
def test_pico(): ''' Testing the picoscope runblock code. Plug CH7 into the picoscope''' shots = 5 f_ext = 'TestRunIgnore' t_s = 10 * us r_l = 10 * ms ps, t_sample, res = pico.run_rapid_block(Vrange=5, n_captures=shots, t_sample=t_s, record_length=r_l) n_data = r_l / t_s for i in range(shots): storage_arr = [(['ch3', 'ch5'], 25 * us), (['ch1', 'ch5', 'ch7'], 500 * us), (['ch5'], 1 * ms)] pb.Sequence(storage_arr, loop=False) data = pico.get_data_from_rapid_block(ps) t = np.arange(data.shape[1]) * t_s data_total = np.vstack([t, data]) data_total = data_total.T #Save formatted data. file_name = time.strftime("C:\Users\Milos\Desktop\James\\" + "%Y-%m-%d Pico " + f_ext + '.mat') sci.savemat(file_name, {'data': data_total}) plt.plot(t, data[0, :]) plt.show() ps.close()
def spin_pump_seq(freq, pumps, record="False"): ''' Runs spin polarize sequence and allows for the ability to record the spectrum just after spin pumping. ''' time = spin_polarise(SpecAn, SpecAn_Bool, freq, pumps, direction='forwards') sleep(time) #Wait for spin polarize to take place. SpecAn.write('FA ' + str(0 * MHz)) #Start freq SpecAn.write('FB ' + str(2900 * MHz)) #Stop freq save_file = "C:\\Users\\Milos\Desktop\\Er_Experiment_Interface_Code\\amplitude_offset_full.csv" amplitude_offset = np.loadtxt(save_file, delimiter=",") #This if statement is a rewritten version of record_trace if record == 'True': filepath = create_file(SpecAn, compensated='N', n=1, burn_time=0) array = [([], 0.5 * s)] + [(['ch5'], 500 * ms), (['ch2', 'ch4', 'ch5'], 100 * ms) ] + [(['ch2', 'ch5'], 100 * ms)] pb.Sequence(array, loop=False) [x, y, f] = record_trace(SpecAn, filepath, filename='', compensated='Y', sweep_again='Y', n=1, burn_time=0)
def reference_pulse(f_ext='', voltRange=0.2): ''' Spin polarize the crystal and send a pulse through at the freq where the AFC would be. Needs to know the number of teeth to know which bit of memory the pulse is stored at.''' mc.setWvfmKey('Pulse') AWG_trig_out(1) #Set picoscope up to collect data and wait for external trigger t_s = 4 * ns r_l = 20 * us t_sample, res = pico.run_rapid_block(ps, Vrange=voltRange, n_captures=1, t_sample=t_s, record_length=r_l) n_data = r_l / t_s print("Toggling MEMS switch high for 10 s") pb.Sequence( [ (['ch5'], 0.5 * us), (['ch5', 'ch6'], 10), #Spin polarise crystal (['ch5'], 0.5 * us, WAIT), (['ch5'], 49.5 * us), (['ch3', 'ch5'], 0.5 * us), (['ch1', 'ch5'], 50 * us), (['ch5'], 1 * ms) ], loop=False, bStart=False) sleep(11) #Old Sequence ## pb.Sequence([(['ch5'], 0.5*us), (['ch5'], 0.5*us, WAIT), (['ch5'], 49.5*us), ## (['ch3','ch5'], 0.5*us), (['ch1','ch5'],1*ms), (['ch5'], 1*ms)] ,loop=False,bStart=False) #CH3 to picoscope (start recording just before pulse arrives), #CH1 to open RF switch for AWG, #CH5 so carrier sideband beat on laser is strong sleep(0.1) #AWG_trig_out(0) #sleep(1) data = pico.get_data_from_rapid_block(ps) t = np.arange(data.shape[1]) * t_s data_total = np.vstack([t, data]) data_total = data_total.T ## for dat in data_total[0]: ## if dat == "inf" or dat == "-inf": ## raise RuntimeError, "Picoscope V range too small" #Save formatted data. file_name = time.strftime("C:\Users\Milos\Desktop\James\\" + "%Y-%m-%d REFERNCE Pico " + f_ext + '.mat') sci.savemat(file_name, { 'Vrange': voltRange, 'sampleRate': t_s, 'data': data_total })
def spin_pump_seq(spintime=10 * s, SpecAnSweep='Y', rec='Y'): ''' For spin polarizing the crystal. Triggers pulseblaster CH6 on - off, changes the state of the mems switch which lets the photonics laser to sweep over the dm = 1 & 2 for a given time, default 10s Then allows for the recording of the Spin pumped spectrum if rec 'Y' ''' #Toggle the mems switch for n sec if rec == 'Y': HP8560E_SpecAn_Trigger('FREE', 'CONTS', SpecAn) SpecAn.write('CF ' + str(1.45 * GHz)) SpecAn.write('SP ' + str(2.90 * GHz)) pb.mems_switch_toggle(spintime, n=1, other_ch='', init_state=1) sleep(spintime) #Record full span spectrum, else: just toggle the mems switch again if rec == 'Y': filepath = hb.create_file(SpecAn, compensated='Y', n=1, burn_time=0, filename=' Spin pumped') sleep(100 * ms) pb.Sequence( [ (['ch5'], 0.5 * s), (['ch5', 'ch6'], 20 * us), (['ch5'], 5 * ms), (['ch2', 'ch4', 'ch5' ], 50 * ms), #RF Switch, Trigger SpecAn, EOM Bias on (['ch2', 'ch5'], 100 * ms), ], loop=False) hb.record_trace(SpecAn, filepath, filename=' Spin pumped', compensated='Y', sweep_again=SpecAnSweep, n=1, burn_time='') else: pb.Sequence([ (['ch5', 'ch6'], 20 * us), (['ch5'], 5 * ms), ], loop=False)
def getTrace(SpecAn, t_space): pb.Sequence([(['ch2', 'ch4', 'ch5'], 100 * ms), (['ch5'], 10 * us)], loop=False) SpecAn.write('TRA?') time.sleep(t_space - 50 * ms) binary = SpecAn.read_raw() spec_data_temp = np.frombuffer(binary, '>u2') return spec_data_temp
def save_offset_custom(SpecAn, avg_num, save_file, freq, span=40 * MHz, res=30 * kHz, sweep=50 * ms): SpecAn.write("CF " + str(freq)) SpecAn.write("SP " + str(span)) SpecAn.write("RB " + str(res)) SpecAn.write("ST " + str(sweep)) #Give time to let the SpecAn change span settings sleep(0.1) SpecAn.write("SRCPWR?") SpecAn_Power = SpecAn.read() print("Power is: " + str(SpecAn_Power)) #Traces are made up of 601 points (x axis) with a value from 0 to 610 #This can be converted into dB SpecAn.write('LG?') dB_div = float(SpecAn.read()) entire_depth = 10 * dB_div #how many dB in the entire display SpecAn.write('RL?') #Get the reference level ref_level = float(SpecAn.read()) lowest_point = ref_level - entire_depth #To convert Y data to dB -> y_data*entire_depth/610 + lowest_point offset_array = np.zeros((avg_num, 601), dtype=float) HP8560E_SpecAn_Trigger('EXT', 'CONTS', SpecAn) ## pb.Sequence([(['ch2','ch5','ch4'], 1*ms)], loop=False) #Leave enough time for it sweep and store a new trace ## sleep(0.4) ## [SpecAn_track, SpecAn_Power] = HP8560E_SpecAn_RF(tracking_gen, RF_power, SpecAn) #now we collect the data trace for i in range(avg_num): pb.Sequence([(['ch2', 'ch5', 'ch4'], 1 * ms)], loop=False) sleep(sweep + 0.2) SpecAn.write("TRA?") binary_string = SpecAn.read_raw() hex_string = binascii.b2a_hex(binary_string) offset_data_temp = np.zeros(601) for j in range(601): offset_data_temp[j] = int('0x' + hex_string[j * 4:j * 4 + 4], 0) offset_array[i, :] = offset_data_temp[:] time.sleep(0.07) avg_offset_data = np.average(offset_array, 0) avg_offset_data = avg_offset_data * entire_depth / 610 + lowest_point #Convert to dB np.savetxt(save_file, avg_offset_data, fmt='%.10e', delimiter=",")
def spin_jump_record_repeat(burn_f, h_state, file_name, teeth=1, n=1): ''' Spin poliarises the crystal once. Then repeatedly spin jump's and records the anti-hole.''' HP8560E_SpecAn_Trigger('FREE', 'CONTS', SpecAn) spin_pump_seq(spintime=10 * s, SpecAnSweep='N', rec='N') rec_span = 20 * MHz ## state_dict = {'3,2': 0,'1,2': 1,'-1,2': 2,'-3,2': 3,'-5,2': 4,'-7,2': 5} ## num = state_dict[h_state] ## bjt_ext = 5/num #Initial spin jump (longer Burn Jump Time) num_len = int(np.ceil(np.log10(n))) zero = '0' zeros = zero * num_len spin_jump(burn_f, state=h_state, rec='True', span=rec_span, teeth=teeth, f_ext=file_name + ' ' + zeros, bjt=50) #*bjt_ext) for i in range(n - 1): #Each subsequent spin jump should need a much shorter Burn Jump Time spin_jump(burn_f, state=h_state, rec='False', span=rec_span, teeth=teeth, f_ext=file_name + ' ' + str(i + 1).zfill(num_len), bjt=50, rec_offs=False) #Records the 2.9GHz span after all measurements filepath = hb.create_file(SpecAn, compensated='Y', n=1, burn_time=0, filename=' Spin pumped after spinjump ' + h_state) sleep(100 * ms) pb.Sequence( [ (['ch5'], 0.5 * s), (['ch2', 'ch4', 'ch5' ], 50 * ms), #RF Switch, Trigger SpecAn, EOM Bias on (['ch2', 'ch5'], 100 * ms), ], loop=False) hb.record_trace(SpecAn, filepath, filename=' Spin pumped after spinjump ' + h_state, compensated='Y', sweep_again='N', n=1, burn_time='')
def makeNpulse_AFC(burnf, AFCparameters, recComb=False, shots, f_ext='', pico_f_ext=''): ''' Uses make_AFC to create the AFC comb and then set the AWG and Picoscope to store and retrieve pulses from the AFC ''' make_AFC(burnf, AFCparameters, recComb=False, f_ext='') wf_24_cw(burn_f + 15e6 + 460.99e6, -26) #input into the IQ modulator #Set AWG to output storage pulse mc.setWvfmKey('Pulse') AWG_trig_out(1) #Set picoscope to wait for ext trig t_s = 8 * ns t_r = 100 * us pico.setRapidBlock(ps, ch=['A', 'B'], Vrange=0.2, nCaptures=shots, t_sample=t_s, t_record=t_r, trig='External', res='15') #AWG will trigger Pulse blaster #CH3 trigger picoscope. #CH5 suppress carrier EOM. #CH1 Open RF switch for AWG. #CH9 Bypass the AMP going to the EOM for low light level measurements pb.Sequence( [ (['ch5', 'ch9'], 0.5 * us, LOOP, shots), #loop shots times (['ch5', 'ch9' ], 0.5 * us, WAIT), #50us of 'silence' then have the pulse (['ch5', 'ch9'], 49.5 * us), (['ch3', 'ch5', 'ch9' ], 0.5 * us), #Record just before the pulse comes in (['ch1', 'ch5', 'ch9' ], t_r + 10 * us), #Leave enough time for the recording (['ch5', 'ch9'], 10 * us, END_LOOP), (['ch5'], 1 * us) ], loop=False, bStart=False) sleep(0.1) picoData = pico.getRapidBlock(ps) AWG_trig_out(0) return picoData
def multi_record(SpecAn, d_time, n, filepath): '''Takes 'n' scans on the HP Spectrum Analyzer at ~d_time intervals. This is an augmented version of record_trace from holeburn_james. Also records the times for each data recording event.''' #Run the following first to set up the text file. #hb.create_file(SpecAn, filename = '', compensated = 'N', sweep_again = 'Y', n=1, burn_time = '') SpecAn.write('SP?') span = float(SpecAn.read()) SpecAn.write('CF?') center = float(SpecAn.read()) file = open(filepath, 'a') x = np.linspace(center - span / 2, center + span / 2, 601) spec_data_db = np.zeros((601, n)) record_time = [] for i in range(n): SpecAn.write('TS') #Waits for Spectrum Analyser to finish Data sweep SpecAn.wait_for_srq(timeout=30000) #Gets the trace from the SpecAn SpecAn.write('TRA?') binary = SpecAn.read_raw() spec_data_temp = np.frombuffer( binary, '>u2') # Data format is big-endian unsigned integers record_time.append(datetime.now().strftime("%H:%M:%S.%f")) spec_data_db[:, i] = SIH.convert2db(SpecAn, spec_data_temp) if compensated == 'Y': spec_data_db[:, i] = compensate(spec_data_temp, span) SpecAn.write("CLEAR; RQS 4") pb.Sequence([(['ch2', 'ch5'], d_time)], [(['ch2', 'ch5', 'ch4'], 1 * ms)], loop=False) #Conjoins both x and spec_data_temp vectors and saves them to file data = np.vstack([x, spec_data_db]).T np.savetxt(file, data, fmt='%.10e') file.close() pylab.ion() if sweep_again == 'Y': HP8560E_SpecAn_Trigger("FREE", 'CONTS', SpecAn) return x, spec_data_db, filepath
def SpinpumpSite2BurnSite1(f_name='Spinpump site2 burn site1', freq=195.162): fg = rigolfg.RigolFG() #Open the Rigol FG ITLA = ITLA_Wrap.ITLA_Class(port="COM6", baudrate=9600) #Open the Photonics Laser #Probe laser and check it's happy ITLA.ProbeLaser() #Disable laser to change parameters ITLA.EnableLaser(False) #Set Laser to usual parameters for Spin Pumping ITLA.SetFrequency(194.9412) #THz ITLA.SetPower(1600) #dBm * 100 fg.setOutputState(bOn=0) ITLA.EnableLaser(True) ITLA.EnableWhisperMode(True) fg.setOutputState(bOn=1) spin_pump_seq(spintime=10 * s, SpecAnSweep='Y', rec='Y') #Spin pump site 2 HP8560E_SpecAn_Trigger('EXT', 'SNGLS', SpecAn) fg.setOutputState(bOn=0) #Turn off Rigol CH2 (sweeping photonics) print("Turning Rigol FG off (stop photonics laser sweeping).") #Turn off laser #Change photonics laser freq to 195.162 THz ITLA.EnableWhisperMode(False) ITLA.EnableLaser(False) ## ITLA.SetFrequency(195.162) #THz site 1 ## ITLA.SetFrequency(194.9437) #THz magnetic sub group ITLA.SetFrequency(freq) #THz site 2 main peak ITLA.SetPower(1600) #dBm * 100 ITLA.EnableLaser(True) ITLA.EnableWhisperMode(True) #Burn site 1 for 5 s pb.Sequence([(['ch6'], 5 * s), (['ch5'], 5 * ms)], loop=False) sleep(5) filepath = hb.create_file( SpecAn, n=1, burn_time=0, filename=f_name) #Record spin pumping after site 1 burn pb.hole_burn(1) filepath = hb.record_trace(SpecAn, filepath, compensated='Y', sweep_again='Y', burn_time=1) fg.setOutputState( bOn=1) #Turns Channel 2 back on so we can spin pump again print("Turning Rigol FG on.")
def save_offset(avg_num, full_span='N'): #Allows for two offsets, one dedicated as a fully span off set and the other #for various spans/frequencies if full_span == 'N': save_file = "C:\\Users\\Milos\Desktop\\Er_Experiment_Interface_Code\\amplitude_offset.csv" elif full_span == 'Y': save_file = "C:\\Users\\Milos\Desktop\\Er_Experiment_Interface_Code\\amplitude_offset_full.csv" else: save_file = full_span [SpecAn, SpecAn_Bool] = Initialise_HP8560E_SpecAn() SpecAn.write("SRCPWR?") SpecAn_Power = SpecAn.read() print "Power is: " + str(SpecAn_Power) sweep = float(SpecAn.query('ST?')) #Traces are made up of 601 points (x axis) with a value from 0 to 610 #This can be converted into dB SpecAn.write('LG?') dB_div = float(SpecAn.read()) entire_depth = 10 * dB_div #how many dB in the entire display SpecAn.write('RL?') #Get the reference level ref_level = float(SpecAn.read()) lowest_point = ref_level - entire_depth #To convert Y data to dB -> y_data*entire_depth/610 + lowest_point offset_array = np.zeros((avg_num, 601), dtype=float) HP8560E_SpecAn_Trigger('EXT', 'CONTS', SpecAn) ## [SpecAn_track, SpecAn_Power] = HP8560E_SpecAn_RF(tracking_gen, RF_power, SpecAn) #now we collect the data trace for i in range(avg_num): pb.Sequence([(['ch2', 'ch5', 'ch4'], 1 * ms)], loop=False) sleep(sweep + 0.05) SpecAn.write("TRA?") binary_string = SpecAn.read_raw() hex_string = binascii.b2a_hex(binary_string) offset_data_temp = np.zeros(601) for j in range(601): offset_data_temp[j] = int('0x' + hex_string[j * 4:j * 4 + 4], 0) offset_array[i, :] = offset_data_temp[:] time.sleep(0.07) avg_offset_data = np.average(offset_array, 0) avg_offset_data = avg_offset_data * entire_depth / 610 + lowest_point #Convert to dB np.savetxt(save_file, avg_offset_data, fmt='%.10e', delimiter=",")
def burn_sequence_AWG_cust(burn, burn_freq, record='True', rec_freq='', rec_span=10 * MHz, f_name='', nu=2, sa='Y', rec_offs=True, opt_bac='offs1.txt'): ''' Same as burn_sequence_AWG, but uses save custom offset rather than hb.run_offset ''' filepath = '' if rec_freq == '': rec_freq = burn_freq if record == 'True': filepath = hb.create_file(SpecAn, n=1, burn_time=burn, filename=f_name) if rec_offs: save_offset_custom(SpecAn, 5, 'offs1.txt', freq=rec_freq, span=rec_span, res=30 * kHz, sweep=50 * ms) else: SpecAn.write("CF " + str(rec_freq)) SpecAn.write("SP " + str(rec_span)) arr1 = [([], 0.5 * s), (['ch1'], burn)] + [ (['ch5'], 100 * us), (['ch2', 'ch4', 'ch5'], 100 * ms) ] + [(['ch2', 'ch5'], 100 * ms)] pb.Sequence(arr1, loop=False) ## pb.hole_burn(burn) if record == 'True': filepath = hb.record_trace(SpecAn, filepath, compensated='Y', sweep_again=sa, burn_time=burn, opt_bac=opt_bac) sleep(0.5 * s) hb.full_sweep(SpecAn)
def record_dm_1(freq, f_ext='', tn=3): ''' Set up to record the anti-holes made by spin jumping by looking at three places on the Delta m = 1 ''' if freq > 1210 * MHz: print( 'WARNING: Freq set too high, might not be able to see the |5/2> on the Delta m = 1' ) rec_freq = np.array([1557 * MHz, 1472 * MHz, 1529 * MHz]) + freq span = np.array([270, 20, 20]) * MHz f_name = [ ' ' + f_ext + ' dm1', ' ' + f_ext + ' dm 12', ' ' + f_ext + ' dm13' ] opt = [ "C:\\Users\\Milos\Desktop\\Er_Experiment_Interface_Code\\1.txt", "C:\\Users\\Milos\Desktop\\Er_Experiment_Interface_Code\\2.txt", "C:\\Users\\Milos\Desktop\\Er_Experiment_Interface_Code\\3.txt" ] for i in range(1): SpecAn.write('SP ' + str(span[i])) SpecAn.write('CF ' + str(rec_freq[i])) sleep(0.01) filepath = hb.create_file(SpecAn, n=1, burn_time=1 * ms, filename=f_name[i]) pb.Sequence([([], 0.5 * s)] + [(['ch5'], 1000 * ms), (['ch2', 'ch4', 'ch5'], 100 * ms)] + [(['ch2', 'ch5'], 100 * ms)], loop=False) filepath = hb.record_trace(SpecAn, filepath, compensated='Y', sweep_again='N', burn_time=1 * ms, opt_bac=opt[i]) sleep(0.05)
def run_offset(SpecAn, freq=1.45 * GHz, span=2.9 * GHz, res=30 * kHz, sweep=50 * ms, full_span='Y', show_window='N', n=20): ''' Sets desired SpecAn settings and runs Milos's background and free run programs.''' SpecAn.write("CF " + str(freq)) SpecAn.write("SP " + str(span)) SpecAn.write("RB " + str(res)) SpecAn.write("ST " + str(sweep)) #This sequence ensures that atleast one sweep is taken once the Span and Center #Frequecies are changed, before the offsets are saved pb.Sequence([(['ch2', 'ch4', 'ch5'], 50 * ms), ([], 0.4 * s)], loop=False) sleep(0.5) SIH.save_offset(n, full_span) if show_window == 'Y': SIH.free_run_plot_window('Y', freq, span, full_span)
def spin_jump_time_measurement_faster(times, burn_f, state='5,2'): ''' Spin polarizes and spin jumps the ensemble to a given [state]. Then it records the anti-hole after a certain amount of time given by [times] This one is faster because it spin polarizes every n recordings rather than every recording.''' freq = burn_f count = 4 sp = 20 * MHz ## sp = 2.9*GHz state_dict = { '5,2': 0, '3,2': 1, '1,2': 2, '-1,2': 3, '-3,2': 4, '-5,2': 5, '-7,2': 6 } if state not in state_dict: #Check if variable state is valid print('Error, variable state must be in [5,2, 3,2... -5,2]') p = state_dict[state] e_gap = np.array([ -107.60, -218.09, -323.2, -415.50, -488.20, -535.89, 1453.5 ]) * MHz #Gaps in hyperfine energy levels pl.ioff() for i in range(len(times)): count += 1 if count == 5: count = 0 HP8560E_SpecAn_Trigger("FREE", 'CONTS', SpecAn) SpecAn.write('CF ' + str(1.45 * GHz)) SpecAn.write('SP ' + str(2.9 * GHz)) spin_pump_seq(spintime=10 * s, SpecAnSweep='Y', rec='N') #Record background measurements HP8560E_SpecAn_Trigger("FREE", 'CONTS', SpecAn) pb.Sequence([(['ch2', 'ch5'], 1 * ms)], loop=False) hb.run_offset(SpecAn, freq=freq + e_gap[p], span=sp, res=30 * kHz, sweep=50 * ms, full_span='N', show_window='N', n=5) ## hb.run_offset(SpecAn, freq = 1.45*GHz, span = 2.9*GHz, res = 30*kHz, sweep = 50*ms, full_span = 'N', show_window = 'N',n = 5) #Stop SpecAn sweeping over anti hole, burn final anti-hole and then suppresses carrier HP8560E_SpecAn_Trigger('EXT', 'SNGLS', SpecAn) #Spin Jump spin_jump(freq, state, rec='False', span=sp, teeth=1) #Take spectra at time '0' SpecAn.write("CF " + str(freq + e_gap[p])) SpecAn.write("SP " + str(sp)) ## SpecAn.write("CF " + str(1.45*GHz)) ## SpecAn.write("SP " + str(2.9*GHz)) f_name = ' ' + state + ' zero ' + str(times[i]) + 's' filepath = hb.create_file(SpecAn, compensated='Y', filename=f_name) pb.Sequence( [ (['ch5'], 1 * s), (['ch2', 'ch4', 'ch5' ], 70 * ms), #RF Switch, Trigger SpecAn, EOM Bias on ([], 100 * ms), #turn off ch2,ch5, suppress carrier/RF ], loop=False) hb.record_trace(SpecAn, filepath, compensated='Y', sweep_again='N', n=1, burn_time='') HP8560E_SpecAn_Trigger('EXT', 'SNGLS', SpecAn) print 'Waiting ' + str(times[i]) + ' seconds.' sleep(times[i]) #wait else: t = times[i] - times[i - 1] print 'Waiting ' + str(t) + ' seconds.' sleep(t) #Record f_name = ' ' + state + ' ' + str(times[i]) + 's' filepath = hb.create_file(SpecAn, compensated='Y', filename=f_name) pb.Sequence( [ (['ch5'], 1 * s), (['ch2', 'ch4', 'ch5' ], 70 * ms), #RF Switch, Trigger SpecAn, EOM Bias on ([], 100 * ms), ], loop=False) fName = hb.record_trace(SpecAn, filepath, compensated='Y', sweep_again='N', n=1, burn_time='') dat = np.loadtxt(fName, skiprows=10) pl.plot(*dat.T) #pl.draw() plt.pause(0.1) pl.show() sleep(1) HP8560E_SpecAn_Trigger("FREE", 'CONTS', SpecAn)
## rec_f = 1*GHz AFC.spin_pump_seq(spintime=10 * s, SpecAnSweep='Y', rec='Y') ## SIH.free_run_plot_window('Y', full_span = 'Y') ## burn_sequence_AWG(burn = burn_time, burn_freq, record = 'True', rec_freq = rec_f, rec_span = 50*MHz, f_name = 'ASE burn', nu = 2, sa = 'Y'): ## array = [([], 0.5*s),(['ch1'], burn_time)] + [(['ch5'], 1000*ms), (['ch2','ch4','ch5'], 100*ms)] + [(['ch2','ch5'], 100*ms)] ## pb.Sequence(array,loop=False) if __name__ == "__main__": # ============== WITHOUT SPEC AN ===================================== #pi = range(20) pi = 22 * us delay = 150 * us #array = [(['ch1','ch3'], pi/2)] + [([''], delay)] + [(['ch1'], pi)] #for i in range() from __builtin__ import sum arr = [(['ch1', 'ch3'], pi / 2), ([], delay), (['ch1'], pi), ([], 10 * ms)] pb.Sequence(arr, loop=True) ## AFC.spin_pump_seq(spintime = 10*s,SpecAnSweep = 'N',rec ='N') #Run first ## for i in range(1): ## AFC.spin_pump_seq(spintime = 0.5*s,SpecAnSweep = 'N',rec ='N') ## burn_time = 1*us ## array = [(['ch1','ch3'], burn_time) + ([], 100*ms)] ## pb.Sequence(array,loop=False)
def spin_jump_time_measurement(freq, times, state='5,2'): ''' OLDER SLOWER VERSION, USE ONLY IF NEW ONE BROKE Preforms spin jump to a certain hyperfine and then records the anti-hole a give time after the hole was originally burnt ''' HP8560E_SpecAn_Trigger('EXT', 'SNGLS', SpecAn) sp = 10 * MHz state_dict = { '5,2': 0, '3,2': 1, '1,2': 2, '-1,2': 3, '-3,2': 4, '-5,2': 5 } if state not in state_dict: #Check if variable state is valid print('Error, variable state must be in [5/2, 3/2... -5/2]') p = state_dict[state] e_gap = np.array([-107.64, -217.98, -323.19, -415.47, -488.22, -536.46 ]) * MHz #Gaps in hyperfine energy levels #Record background measurements HP8560E_SpecAn_Trigger("FREE", 'CONTS', SpecAn) pb.Sequence([(['ch2', 'ch5'], 1 * ms)], loop=False) hb.run_offset(SpecAn, freq=freq + e_gap[p], span=sp, res=30 * kHz, sweep=50 * ms, full_span='N', show_window='N', n=5) #Spin Jump HP8560E_SpecAn_Trigger('EXT', 'SNGLS', SpecAn) spin_jump(freq, state, rec='False', span=sp) #Stop SpecAn sweeping over anti hole, burn final anti-hole and then suppresses carrier #Take spectra at time '0' HP8560E_SpecAn_Trigger("FREE", 'CONTS', SpecAn) #Record SpecAn.write("CF " + str(freq + e_gap[p])) SpecAn.write("SP " + str(sp)) filepath = hb.create_file(SpecAn, compensated='Y', n=1, burn_time=0, filename=' ' + state + ' zero ' + str(time[i]) + 's') pb.Sequence( [ (['ch5'], 1 * s), (['ch2', 'ch4', 'ch5' ], 70 * ms), #RF Switch, Trigger SpecAn, EOM Bias on ([], 100 * ms), #turn off ch2,ch5, suppress carrier/RF ], loop=False) hb.record_trace(SpecAn, filepath, compensated='Y', sweep_again='Y', n=1, burn_time='') HP8560E_SpecAn_Trigger('EXT', 'SNGLS', SpecAn) sleep(times[i]) #wait HP8560E_SpecAn_Trigger("FREE", 'CONTS', SpecAn) #Record filepath = hb.create_file(SpecAn, compensated='Y', n=1, burn_time=0, filename=' ' + state + ' ' + str(time[i]) + 's') pb.Sequence( [ (['ch5'], 1 * s), (['ch2', 'ch4', 'ch5' ], 70 * ms), #RF Switch, Trigger SpecAn, EOM Bias on (['ch2', 'ch5'], 100 * ms), ], loop=False) hb.record_trace(SpecAn, filepath, compensated='Y', sweep_again='Y', n=1, burn_time='') HP8560E_SpecAn_Trigger('EXT', 'SNGLS', SpecAn)
def gatePump(gateFreq=30): t = 1. / (2 * gateFreq) pb.Sequence([(['ch6', 'ch7'], t), ([], t)], loop=True)
def laser_stability_measure(freq, t_space=100 * ms, t=4 * s, f_name='', show='Y'): [SpecAn, SpecAn_Bool] = Initialise_HP8560E_SpecAn() SpecAn.write('ST 0.05') #Sweep Time 50ms n = int(t / t_space) #Amount of times scans needed ## mc.setup(centerFreqL = freq, widthL = 10e4, sweepTimeL = 1e-4) if t_space < 50 * ms: raise RuntimeError, "SpecAn's fastest sweep time & reset is 100ms, t_space cannot be faster." file = make_file(f_name) span = 5 * MHz freq_sit = freq SpecAn.write('CF ' + str(freq_sit)) SpecAn.write('SP ' + str(span)) time.sleep(0.5) #Take Background measurement SIH.save_offset(10, 'n') #Burn a hole pb.Sequence([(['ch1'], 50 * ms), (['ch2', 'ch4', 'ch5'], 1 * ms)], loop=False) HP8560E_SpecAn_Trigger('EXT', 'CONTS', SpecAn) print "Recording for {}s at {} Hz".format(t, 1 / t_space) #Get raw data l = [] for k in range(n): l.append([time.time(), getTrace(SpecAn, t_space)]) HP8560E_SpecAn_Trigger('FREE', 'CONTS', SpecAn) t_init = l[0][0] t_arr = [] center = [] freq_arr = np.linspace(freq_sit - span / 2, freq_sit + span / 2, 601) for i in range(n): #Convert to dB and background subtract post data collection dat = SIH.convert2db(SpecAn, l[i][1]) dat = hb.compensate(dat, span) #Make time and freq peak array t_arr.append(l[i][0] - t_init) index = np.argmax( dat[50:]) #The carrier also makes a hole, this should ignore it center.append(freq_arr[index]) data = np.vstack([t_arr, center]).T np.savetxt(file, data, fmt='%.10e') ## pb.Sequence([(['ch2', 'ch5', 'ch4'], 1 * ms)], loop=False) #Plot if show == 'Y': plt.plot(t_arr, center) plt.show() return l, t_arr, center, data
def SpecAnUnfreeze(): pb.Sequence([(['ch4'], 2.5 * ms), (['ch2', 'ch5'], 2.5 * ms)], loop=False) HP8560E_SpecAn_Trigger('FREE', 'CONTS', SpecAn)
def burn_scan_image_VCO(sweep_array, direction): global Agilent_OSA global Agilent_OSA_bool global SpecAn global SpecAn_Bool global Stanford_Bool global Stanford_FG #initialise the equiptment #Arduino = Initialise_Arduino(arduino_comport) #[Burleigh_WM, Burleigh_WM_bool] = Initialise_Burleigh_WM() [Agilent_OSA, Agilent_OSA_bool] = Initialise_OSA() [SpecAn, SpecAn_Bool] = Initialise_HP8560E_SpecAn() #[Stanford_FG, Stanford_Bool] = Initialise_Stanford_FG() #get the laser wavelength #Burleigh_WM.write("FETC:SCAL:WAV?") #laser_wavelength = np.float(Burleigh_WM.read()) laser_wavelength = OSA_measure_wavelength(Agilent_OSA) #generate and upload the burn sweep to the Stanford and VCO #[num_array, waveform_length] = VCO_Sweep_backwards(sweep_array, Stanford_FG, Stanford_Bool) #Upload_to_Stanford_FG(num_array,waveform_length, Stanford_FG) #Arduino.write('0') #print Arduino.read() #wait some time for the arduino to start the pulse program before setting trigger on SpecAn #time.sleep(1) #upload pulse sequence to Pulse Blaster (Burn, wait, Trigger SpecAn) pb.Sequence([(['ch1'], 3 * s), ([], 100 * ms), (['ch1', 'ch2', 'ch3'], 50 * ms), (['ch5'], 1 * ms)], loop=False) #sends necessary pre-data collection settings to the Spectrum Analyser [SpecAn_BW, SpecAn_Sweeptime ] = HP8560E_SpecAn_Resbandwidth_Sweeptime(10 * kHz, sweeptime, SpecAn) [SpecAn_track, SpecAn_Power] = HP8560E_SpecAn_RF(tracking_gen, RF_power, SpecAn) [SpecAn_Centre, SpecAn_Span] = HP8560E_SpecAn_Centre_Span(centre, span, SpecAn) HP8560E_SpecAn_Trigger('EXT', 'SNGLS', SpecAn) #sets up registers to return interupt when sweep is complete SpecAn.write("CLEAR; RQS 4") #triggers spectrum analyser for data reading. it will no longer process input #untill the sweep has been triggered and completed SpecAn.write('TS') #Waits for Spectrum Analyser to finish Data sweep SpecAn.wait_for_srq(timeout=30000) #generate the array to compensate for the RF and Detector response amplitude_offset = np.loadtxt( "C:\\Users\\Milos\Desktop\\Er_Experiment_Interface_Code\\amplitude_offset.csv", delimiter=",") #collect trace data off spectrum analyser SpecAn.write("TRA?") binary_string = SpecAn.read_raw() hex_string = binascii.b2a_hex(binary_string) y_axis_data = np.zeros(601) for i in range(601): y_axis_data[i] = int('0x' + hex_string[i * 4:i * 4 + 4], 0) #divide by offset to compensate and generate an x_axis array y_axis_data = np.subtract(y_axis_data, amplitude_offset) x_axis_data = np.arange(centre - span / 2, centre + span / 2, span / 601) #speed of light c = 299792453 #generate absolute wavelength and frequency information based on direction of scan if direction == 'pos': wavelength_values = x_axis_data * ((laser_wavelength**2) / (c * 10**9)) + laser_wavelength frequency_values = -x_axis_data + (c * 10**9) / laser_wavelength else: wavelength_values = -x_axis_data * ((laser_wavelength**2) / (c * 10**9)) + laser_wavelength frequency_values = x_axis_data + (c * 10**9) / laser_wavelength filename = "blank" save_data(filename, folder_name, laser_wavelength, y_axis_data, wavelength_values, frequency_values) #turns off the RF and returns the spectrum analyser back to normal state. HP8560E_SpecAn_Trigger('FREE', 'CONTS', SpecAn) #[SpecAn_track, SpecAn_Power] = HP8560E_SpecAn_RF('OFF', RF_power, SpecAn) display_start = 1 display_end = 601 data_plot_window(x_axis_data, y_axis_data, display_start, display_end)
def view(): ## pb.Sequence([(['ch2','ch5'], 1*ms)], loop=False) pb.Sequence([(['ch2'], 1 * ms)], loop=False) SpecAn.write('LG 10') SIH.free_run_plot_window('N', full_span='Y')
def make_AFC(n, bjt, burn_f, hyperfine, f_ext='', record="False", shots=1): ''' Runs functions to make AFC and store / read out pulse n = number of teeth in comb bjt = burn jump time, time spent burning at each hyperfine (usually 500ms) hyperfine = hyperfine level to spin to (-7,2 for AFC) f_ext = end of each file name for data recording ''' #Prepare instruments pre-storage. #Write to the wf the freq and power needed, wf_24_cw(burn_f + 10e6 + 460.99e6, -10) #Freq offset from the pulses freq. #Spin pol crystal and record a refence pulse (through the non-existant AFC) spin_pump_seq(spintime=10 * s, SpecAnSweep='N', rec='Y') ## reference_pulse(f_ext) ## if record == "True": ## save_offset_custom(SpecAn, 5, "1.txt",freq = burn_f + 1443*MHz, span = 40*MHz, res = 30*kHz, sweep = 50*ms) ## ## #Make the AFC and record AFC at dm = 1 and 0. Also record initial comb holes ## spin_jump(burn_f,state = hyperfine,rec = record, span = 20*MHz, teeth = n) ## if record == "True": ## record_dm_1(burn_f, hyperfine, tn=n) ## save_offset_custom(SpecAn, 5, "1.txt",freq = burn_f + 1443*MHz, span = 40*MHz) ## spin_jump(burn_f,state = hyperfine ,rec = 'True', span = 20*MHz, teeth = teeth, f_ext = file_suff, bjt = 500) ## record_dm_1(burn_f, hyperfine + ' ' + file_suff, tn = teeth) #Set AWG to output storage pulse mc.setWvfmKey('Pulse') AWG_trig_out(1) #Set picoscope up to collect data and wait for external trigger t_s = 4 * ns r_l = 50 * us t_sample, res = pico.run_rapid_block(ps, Vrange=0.5, n_captures=shots, t_sample=t_s, record_length=r_l) n_data = r_l / t_s sleep(0.1) #CH3 trigger picoscope. #CH5 suppress carrier EOM. #CH1 Open RF switch for AWG. for i in range(shots): #1ms allows for a time gap between each shot pb.Sequence([(['ch5'], 0.5 * us), (['ch5'], 0.5 * us, WAIT), (['ch5'], 49.5 * us), (['ch3', 'ch5'], 0.5 * us), (['ch1', 'ch5'], 50 * us), (['ch5'], 1 * ms)], loop=False, bStart=False) sleep(0.1) #Get data from picoscope data = pico.get_data_from_rapid_block(ps) t = np.arange(data.shape[1]) * t_s data_total = np.vstack([t, data]) data_total = data_total.T AWG_trig_out(0) #Save formatted data. file_name = time.strftime("C:\Users\Milos\Desktop\James\\" + "%Y-%m-%d Pico " + f_ext + '.mat') sci.savemat(file_name, {'data': data_total}) plt.plot(t, data[0, :]) plt.show()
t = np.arange(data.size)*t_sample plt.plot(t , data) plt.show() else: #t = np.linspace(0,(len(data[:,1])-1)*t_sample,len(data[:,1])-1) t = np.arange(data.size)*t_sample #plt.imshow(data) #pdb.set_trace() #plt.plot(t,data[0,:]) plt.show() if __name__ == "__main__": import pulse_blaster as pb import scipy.io as sio try: ps = open_pico() data,t_sample = run_rapid_block(ps, Vrange = 1, n_captures = 2, t_sample = 1e-8, record_length = 10e-6, chB=[False,False]) pb.Sequence([([],1e-3),(['ch3'],1e-6),([],1e-3)],loop = False) data = get_data_from_rapid_block(ps) # ============================================================================= # pico_plot(data,t_sample) # ============================================================================= filenameMat = "C:\Users\Milos\Desktop\James\\test2ch.mat" sio.savemat(filenameMat,{'DataPico':data}) finally: ps.close()
def SpecAnUnfreeze(): ''' Triggers the Spectrum Analyser and sets it to continuous mode.''' pb.Sequence([(['ch4'], 2.5 * ms), (['ch2', 'ch5'], 2.5 * ms)], loop=False) HP8560E_SpecAn_Trigger('FREE', 'CONTS', SpecAn)