def run(self, cxn, context): dv_args = {'output_size': 1, 'experiment_name' : self.name, 'window_name': 'rotation_temps', 'dataset_name' : 'temperature_vs_frequency_ramp_time' } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) scan_param = self.parameters.Rotation.frequency_ramp_time_scan_interval self.scan = scan_methods.simple_scan(scan_param, 'ms') for i,ramp_time in enumerate(self.scan): #should_stop = self.pause_or_stop() #if should_stop: break replace = TreeDict.fromdict({ 'Rotation.frequency_ramp_time':ramp_time, 'Documentation.sequence':'scan_frequency_ramp_time', }) self.calibrate_temp.set_parameters(replace) #self.calibrate_temp.set_progress_limits(0, 33.0) (rsb_ex, bsb_ex) = self.calibrate_temp.run(cxn, context) fac = rsb_ex/bsb_ex nbar = fac/(1.0-fac) submission = [ramp_time['ms']] submission.extend([nbar]) #print nbar self.dv.add(submission, context = self.save_context)
def run(self, cxn, context): dv_args = {'output_size':self.rabi_flop.excite.output_size, 'experiment_name': self.name, 'window_name': 'MotionalRamseyTime', 'dataset_name': 'ramsey_time' } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) scan_param = self.parameters.Motion_Analysis.scan_ramsey_time self.scan = scan_methods.simple_scan(scan_param, 'us') for i,t in enumerate(self.scan): should_stop = self.pause_or_stop() if should_stop: break replace = TreeDict.fromdict({ 'Motion_Analysis.ramsey_time':t }) self.rabi_flop.set_parameters(replace) excitation = self.rabi_flop.run(cxn, context) if excitation is None: break submission = [t['us']] submission.extend([excitation]) self.dv.add(submission, context = self.save_context) self.update_progress(i)
def run(self, cxn, context): self.setup_sequence_parameters() dv_args = { 'output_size': 1, 'experiment_name': self.name, 'window_name': 'spectroscopy_397_frequency', 'dataset_name': 'linear_frequency_offset' } scan_methods.setup_data_vault(cxn, self.linear_scan_save_context, dv_args) t = [] ex = [] for i, offset in enumerate(self.scan): should_stop = self.pause_or_stop() if should_stop: break excitation = self.do_get_excitation(cxn, context, offset) if excitation is None: break submission = [offset['MHz']] submission.extend([10.0 * excitation[0]]) t.append(offset['MHz']) ex.append(excitation) self.dv.add(submission, context=self.linear_scan_save_context) self.update_progress(i) return np.array(t), np.array(ex)
def run(self, cxn, context): import time self.setup_sequence_parameters() dv_args = {'output_size': 1, 'experiment_name' : self.name, 'window_name': 'spectroscopy_397_frequency', 'dataset_name' : 'spectroscopy_397_frequency' } scan_methods.setup_data_vault(cxn, self.measure_866_lineshape_save_context, dv_args) freq_arr = [] exci = [] for i,freq in enumerate(self.scan): print freq should_stop = self.pause_or_stop() if should_stop: break excitation = self.do_get_excitation(cxn, context, freq) if excitation is None: break else: submission = [freq['MHz']] submission.extend(excitation) self.dv.add(submission, context = self.measure_866_lineshape_save_context) freq_arr.append(submission[0]) exci.append(excitation) freq_arr = np.array(freq_arr) exci = np.array(exci) exci = exci.flatten()
def run(self, cxn, context): import time self.setup_sequence_parameters() dv_args = {'output_size': 1, 'experiment_name' : self.name, 'window_name': 'spectroscopy_397_power', 'dataset_name' : 'eit_scan_397_power' } scan_methods.setup_data_vault(cxn, self.measure_eit_lineshape_save_context, dv_args) freq_arr = [] exci = [] for i,pwr in enumerate(self.scan): print pwr should_stop = self.pause_or_stop() if should_stop: break excitation = self.do_get_excitation(cxn, context, pwr) if excitation is None: break else: submission = [pwr['dBm']] submission.extend(excitation) self.dv.add(submission, context = self.measure_eit_lineshape_save_context) freq_arr.append(submission[0]) exci.append(excitation) freq_arr = np.array(freq_arr) exci = np.array(exci) exci = exci.flatten()
def run(self, cxn, context): dv_args = {'output_size': 1, 'experiment_name' : self.name, 'window_name': 'current', 'dataset_name' : 'Heating_Rate' } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) scan_param = self.parameters.CalibrationScans.heating_rate_scan_interval self.scan = scan_methods.simple_scan(scan_param, 'us') for i,heat_time in enumerate(self.scan): #should_stop = self.pause_or_stop() #if should_stop: break replace = TreeDict.fromdict({ 'Heating.background_heating_time':heat_time, 'Documentation.sequence':'calibrate_heating_rates', }) self.calibrate_temp.set_parameters(replace) #self.calibrate_temp.set_progress_limits(0, 33.0) (rsb_ex, bsb_ex) = self.calibrate_temp.run(cxn, context) fac = rsb_ex/bsb_ex nbar = fac/(1.0-fac) submission = [heat_time['us']] submission.extend([nbar]) #print nbar self.dv.add(submission, context = self.save_context)
def run(self, cxn, context): dv_args = {'output_size': 1, 'experiment_name' : self.name, 'window_name': 'sigma_ell', 'dataset_name' : 'Diffusion_Rate' } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) scan_param = self.parameters.Heating.additional_wait_time_scan self.scan = scan_methods.simple_scan(scan_param, 'us') for i,heat_time in enumerate(self.scan): #should_stop = self.pause_or_stop() #if should_stop: break initial_wait = self.parameters.Heating.background_heating_time replace = TreeDict.fromdict({ 'Heating.background_heating_time':initial_wait+heat_time, 'Documentation.sequence':'diffusion_with_ramsey', }) self.ramsey_gap.set_parameters(replace) #self.calibrate_temp.set_progress_limits(0, 33.0) sigma_ell = self.ramsey_gap.run(cxn, context) submission = [heat_time['us']] submission.extend([sigma_ell]) #print nbar self.dv.add(submission, context = self.save_context)
def run(self, cxn, context): dv_args = {'output_size':self.rabi_flop.excite.output_size, 'experiment_name': self.name, 'window_name': 'scan_854', 'dataset_name': '854_scan' } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) scan_param = self.parameters.CalibrationScans.sbc_854_scan self.scan = scan_methods.simple_scan(scan_param, 'dBm') for i,ampl in enumerate(self.scan): should_stop = self.pause_or_stop() if should_stop: break replace = TreeDict.fromdict({ 'SidebandCooling.sideband_cooling_amplitude_854':ampl }) self.rabi_flop.set_parameters(replace) excitation = self.rabi_flop.run(cxn, context) if excitation is None: break submission = [ampl['dBm']] submission.extend([excitation]) self.dv.add(submission, context = self.save_context) self.update_progress(i)
def run(self, cxn, context): dv_args = {'output_size':self.rabi_flop.excite.output_size, 'experiment_name': self.name, 'window_name': 'Motional397PulseWidth', 'dataset_name': 'pulse_width397' } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) scan_param = self.parameters.Motion_Analysis.scan_pulse_width_397 self.scan = scan_methods.simple_scan(scan_param, 'us') for i,t in enumerate(self.scan): should_stop = self.pause_or_stop() if should_stop: break replace = TreeDict.fromdict({ 'Motion_Analysis.pulse_width_397':t }) self.rabi_flop.set_parameters(replace) excitation = self.rabi_flop.run(cxn, context) if excitation is None: break submission = [t['us']] submission.extend([excitation]) self.dv.add(submission, context = self.save_context) self.update_progress(i)
def run(self, cxn, context): dv_args = {'output_size': 1, #self.rabi_flop.excite.output_size, 'experiment_name': self.name, 'window_name': 'other', 'dataset_name': 'det_scan' } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) start = 2 stop = 20 self.scan = np.arange(start, stop) for i, no_of_cycles in enumerate(self.scan): should_stop = self.pause_or_stop() if should_stop: break replace = TreeDict.fromdict({ 'SidebandCooling.sideband_cooling_cycles':no_of_cycles }) self.rabi_flop.set_parameters(replace) excitation_carr = self.rabi_flop.run(cxn, context) if excitation_carr is None: break # submit scan submission = [no_of_cycles] submission.extend([excitation_carr]) self.dv.add(submission, context = self.save_context) self.update_progress(i)
def run(self, cxn, context): dv_args = {'output_size': 1, 'experiment_name' : self.name, 'window_name': 'ramsey_contrast', 'dataset_name' : 'ladder_coherence_scan_rotating' } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) scan_param = self.parameters.RamseyScanGap.scangap self.scan = scan_methods.simple_scan(scan_param, 'us') for i,gap_time in enumerate(self.scan): #should_stop = self.pause_or_stop() #if should_stop: break replace = TreeDict.fromdict({ 'Ramsey.ramsey_time':gap_time, 'Documentation.sequence':'RamseyLadder_ScanGap_with_contrast', }) self.scan_phase.set_parameters(replace) #self.calibrate_temp.set_progress_limits(0, 33.0) contrast = self.scan_phase.run(cxn, context) submission = [gap_time['us']] submission.extend([contrast]) #print nbar self.dv.add(submission, context = self.save_context)
def run(self, cxn, context): dv_args = {'output_size':self.rabi_flop.excite.output_size, 'experiment_name': self.name, 'window_name': 'other_det', 'dataset_name': 'det_scan' } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) scan_param = self.parameters.CalibrationScans.sbc_ac_stark self.scan = scan_methods.simple_scan(scan_param, 'kHz') for i,freq in enumerate(self.scan): should_stop = self.pause_or_stop() if should_stop: break replace = TreeDict.fromdict({ 'SidebandCooling.stark_shift':freq }) self.rabi_flop.set_parameters(replace) excitation = self.rabi_flop.run(cxn, context) if excitation is None: break submission = [freq['kHz']] submission.extend([excitation]) self.dv.add(submission, context = self.save_context) self.update_progress(i)
def run(self, cxn, context): dv_args = { 'output_size': self.rabi_flop.excite.output_size, 'experiment_name': self.name, 'window_name': 'current', 'dataset_name': 'beam_position_scan' } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) picomotor = self.cxn.picomotorserver self.picomotor.mark_setpoint() axis = self.parameters.CalibrationScans.position_scan_axis for i, ampl in enumerate(self.scan): should_stop = self.pause_or_stop() if should_stop: break excitation = self.rabi_flop.run(cxn, context) if excitation is None: break submission = [ampl['dBm']] submission.extend([excitation]) self.dv.add(submission, context=self.save_context) self.update_progress(i) self.picomotor.return_to_setpoint()
def run(self, cxn, context): self.setup_sequence_parameters() dv_args = {'output_size': 1, 'experiment_name' : self.name, 'window_name': 'spectroscopy_397_frequency', 'dataset_name' : 'linear_frequency_offset' } scan_methods.setup_data_vault(cxn, self.linear_scan_save_context, dv_args) t = [] ex = [] for i,offset in enumerate(self.scan): should_stop = self.pause_or_stop() if should_stop: break excitation = self.do_get_excitation(cxn, context, offset) if excitation is None: break submission = [offset['MHz']] submission.extend([10.0*excitation[0]]) t.append(offset['MHz']) ex.append(excitation) self.dv.add(submission, context = self.linear_scan_save_context) self.update_progress(i) return np.array(t), np.array(ex)
def run(self, cxn, context): dv_args = { 'output_size': self.rabi_flop.excite.output_size, 'experiment_name': self.name, 'window_name': 'other', 'dataset_name': 'det_scan' } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) scan_param = self.parameters.CalibrationScans.sbc_ac_stark self.scan = scan_methods.simple_scan(scan_param, 'kHz') self.scan = np.arange(1, 31, 1) for i, number in enumerate(self.scan): should_stop = self.pause_or_stop() if should_stop: break replace = TreeDict.fromdict( {'SidebandCooling.sideband_cooling_cycles': number}) self.rabi_flop.set_parameters(replace) excitation = self.rabi_flop.run(cxn, context) if excitation is None: break submission = [number] submission.extend([excitation]) self.dv.add(submission, context=self.save_context) self.update_progress(i)
def run(self, cxn, context): dv_args = {'output_size': 1, #self.rabi_flop.excite.output_size, 'experiment_name': self.name, 'window_name': 'other_det', 'dataset_name': 'det_scan' } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) start = -7.0 stop = -22.0 steps = 45 doppler_cooling_freq = self.parameters.DopplerCooling.doppler_cooling_frequency_397 self.scan = np.linspace(start, stop, steps) for i, ampl_value in enumerate(self.scan): should_stop = self.pause_or_stop() if should_stop: break replace = TreeDict.fromdict({ 'DopplerCooling.doppler_cooling_amplitude_397':WithUnit(ampl_value, 'dBm'), 'DopplerCooling.doppler_cooling_frequency_397':doppler_cooling_freq }) self.rabi_flop.set_parameters(replace) excitation_carr = self.rabi_flop.run(cxn, context) if excitation_carr is None: break # submit scan submission = [ampl_value] submission.extend([excitation_carr]) self.dv.add(submission, context = self.save_context) self.update_progress(i)
def run(self, cxn, context): dv_args = {'output_size':self.rabi_flop.excite.output_size, 'experiment_name': self.name, 'window_name': 'other', 'dataset_name': 'parametric_resonanace_scan' } rp = self.parameters.Rotation frequency_ramp_time = rp.frequency_ramp_time # if self.parameters.SequentialSBCooling.enable: # extra_sbc_cycles = self.parameters.SequentialSBCooling.additional_stages # else: # extra_sbc_cycles = 0 # if self.parameters.StatePreparation.sideband_cooling_enable: # sideband_cooling_time = (self.parameters.SidebandCooling.sideband_cooling_optical_pumping_duration + self.parameters.SidebandCoolingContinuous.sideband_cooling_continuous_duration)*self.parameters.SidebandCooling.sideband_cooling_cycles*(1+extra_sbc_cycles) + WithUnit(1.0,'ms') # else: # sideband_cooling_time = WithUnit(0,'ms') # start_hold = self.parameters.DopplerCooling.doppler_cooling_duration + sideband_cooling_time + WithUnit(0.5,'ms') # start_phase = rp.start_phase # middle_hold = rp.middle_hold # end_hold = self.parameters.StateReadout.pmt_readout_duration + WithUnit(1,'ms') # voltage_pp = rp.voltage_pp start_hold = rp.start_hold start_phase = rp.start_phase middle_hold = rp.middle_hold end_hold = rp.end_hold voltage_pp = rp.voltage_pp scan_methods.setup_data_vault(cxn, self.save_context, dv_args) scan_param = self.parameters.Rotation.drive_frequency_scan_interval self.scan = scan_methods.simple_scan(scan_param, 'kHz') for i,freq in enumerate(self.scan): should_stop = self.pause_or_stop() if should_stop: break #prgroam AWG! drive_frequency = freq self.awg_rotation.program_awf(start_phase['deg'],start_hold['ms'],frequency_ramp_time['ms'],middle_hold['ms'],0.0,end_hold['ms'],voltage_pp['V'],drive_frequency['kHz'],'spin_up_spin_down_sin') heat_time = 2*frequency_ramp_time + middle_hold + WithUnit(0.5, 'ms') replace = TreeDict.fromdict({ 'Heating.background_heating_time':heat_time }) self.rabi_flop.set_parameters(replace) excitation = self.rabi_flop.run(cxn, context) if excitation is None: break submission = [freq['kHz']] submission.extend([excitation]) self.dv.add(submission, context = self.save_context) self.update_progress(i)
def run(self, cxn, context): dv_args = {'output_size':3, 'experiment_name': self.name, 'window_name': 'current', 'dataset_name': 'Two_Line_Rabi_Flop' } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) scan_param = self.parameters.RabiFlopping.manual_scan self.scan = scan_methods.simple_scan(scan_param, 'us') for i,duration in enumerate(self.scan): should_stop = self.pause_or_stop() if should_stop: break replace = TreeDict.fromdict({ 'RabiFlopping_Sit.sit_on_excitation':duration, 'RabiFlopping.frequency_selection':'auto', 'RabiFlopping.sideband_selection':[0,0,0,0], 'RabiFlopping.line_selection':'S-1/2D-1/2' }) self.rabi_flop.set_parameters(replace) excitation_delta_m0 = self.rabi_flop.run(cxn, context) if excitation_delta_m0 is None: break replace = TreeDict.fromdict({ 'RabiFlopping_Sit.sit_on_excitation':duration, 'RabiFlopping.frequency_selection':'auto', 'RabiFlopping.sideband_selection':[0,0,0,0], 'RabiFlopping.line_selection':'S-1/2D-3/2' }) self.rabi_flop.set_parameters(replace) excitation_delta_m1 = self.rabi_flop.run(cxn, context) if excitation_delta_m1 is None: break replace = TreeDict.fromdict({ 'RabiFlopping_Sit.sit_on_excitation':duration, 'RabiFlopping.frequency_selection':'auto', 'RabiFlopping.sideband_selection':[0,0,0,0], 'RabiFlopping.line_selection':'S-1/2D-5/2' }) self.rabi_flop.set_parameters(replace) excitation_delta_m2 = self.rabi_flop.run(cxn, context) if excitation_delta_m2 is None: break submission = [duration['us']] submission.extend([excitation_delta_m0, excitation_delta_m1, excitation_delta_m2]) self.dv.add(submission, context = self.save_context) self.update_progress(i)
def setup_data_vault(self,cxn): window_name = self.parameters.get('RamseyScanPhase.window_name', ['ramsey_phase_scan'])[0] if self.parameters.StateReadout.pmt_mode =='exci_and_parity': output_size = 2 else: output_size = 1 dv_args = {'output_size': output_size, 'experiment_name': self.name, 'window_name': window_name, 'dataset_name': self.name } scan_methods.setup_data_vault(cxn, self.data_save_context, dv_args)
def run(self, cxn, context): dv_args = {'output_size':self.rabi_flop.excite.output_size, 'experiment_name': self.name, 'window_name': 'RabiExcitationContinuous', 'dataset_name': 'rabi_excitation' } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) while True: should_stop = self.pause_or_stop() if should_stop: break excitation = self.rabi_flop.run(cxn, context) if excitation is None: break t = time.time() submission = [t] submission.extend([excitation]) self.dv.add(submission, context = self.save_context)
def run(self, cxn, context): dv_args = { 'output_size': self.rabi_flop.excite.output_size, 'experiment_name': self.name, 'window_name': 'RabiExcitationContinuous', 'dataset_name': 'rabi_excitation' } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) while True: should_stop = self.pause_or_stop() if should_stop: break excitation = self.rabi_flop.run(cxn, context) if excitation is None: break t = time.time() submission = [t] submission.extend([excitation]) self.dv.add(submission, context=self.save_context)
def run(self, cxn, context): ma = self.parameters.Motion_Analysis self.agi.set_frequency(self.parameters['TrapFrequencies.radial_frequency_1']+self.parameters['Motion_Analysis.ramsey_detuning']) time.sleep(1) print ma.rf_modulation_depth if ma.rf_modulation: if ma.rf_modulation_depth == 0: self.agi.set_output(False) else: self.agi.set_ranges(WithUnit(-ma.rf_modulation_depth/2.0,'V'),WithUnit(0.0,'V')) self.agi.set_output(True) else: self.agi.set_amplitude(WithUnit(18.0,'dBm')) self.agi.set_output(True) time.sleep(1) dv_args = {'output_size':self.rabi_flop.excite.output_size, 'experiment_name': self.name, 'window_name': 'MotionalRamseyTime', 'dataset_name': 'ramsey_time' } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) scan_param = self.parameters.Motion_Analysis.scan_ramsey_time self.scan = scan_methods.simple_scan(scan_param, 'us') for i,t in enumerate(self.scan): should_stop = self.pause_or_stop() if should_stop: break replace = TreeDict.fromdict({ 'Motion_Analysis.ramsey_time':t }) self.rabi_flop.set_parameters(replace) excitation = self.rabi_flop.run(cxn, context) if excitation is None: break submission = [t['us']] submission.extend([excitation]) self.dv.add(submission, context = self.save_context) self.update_progress(i)
def run(self, cxn, context): import time self.setup_sequence_parameters() dv_args = { 'output_size': 1, 'experiment_name': self.name, 'window_name': 'spectroscopy_397_frequency', 'dataset_name': 'spectroscopy_397_frequency' } scan_methods.setup_data_vault( cxn, self.calibration_397_frequency_save_context, dv_args) freq_arr = [] exci = [] for i, freq in enumerate(self.scan): print freq should_stop = self.pause_or_stop() if should_stop: break excitation = self.do_get_excitation(cxn, context, freq) if excitation is None: break else: submission = [2 * freq['MHz']] submission.extend(excitation) self.dv.add(submission, context=self.calibration_397_frequency_save_context) freq_arr.append(submission[0]) exci.append(excitation) freq_arr = np.array(freq_arr) exci = np.array(exci) exci = exci.flatten() alpha1 = self.fitter.fit( freq_arr, exci, self.parameters.Spectroscopy_397.readout_duration['us']) # print alpha1
def run(self, cxn, context): import time self.setup_sequence_parameters() dv_args = {'output_size': 1, 'experiment_name' : self.name, 'window_name': 'spectroscopy_397_power', 'dataset_name' : 'spectroscopy_397_power' } scan_methods.setup_data_vault(cxn, self.calibration_397_power_save_context, dv_args) pwr = [] exci = [] for i,power in enumerate(self.scan): print power should_stop = self.pause_or_stop() if should_stop: break excitation = self.do_get_excitation(cxn, context, power) if excitation is None: break else: submission = [power['dBm']] submission.extend(excitation) self.dv.add(submission, context = self.calibration_397_power_save_context) pwr.append(submission[0]) exci.append(excitation) pwr = np.array(pwr) exci = np.array(exci) exci = exci.flatten() alpha1 = self.fitter.fit(pwr, exci) # print alpha1
def run(self, cxn, context): dv_args = {'output_size': 3, #self.rabi_flop.excite.output_size, 'experiment_name': self.name, 'window_name': 'other', 'dataset_name': 'det_scan' } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) start = 170.0 stop = 220.0 steps = 40 #carrier_time = self.parameters.MicromotionCalibration.carrier_time doppler_cooling_power = self.parameters.DopplerCooling.doppler_cooling_amplitude_397 self.scan = np.linspace(start, stop, steps) for i, freq_value in enumerate(self.scan): should_stop = self.pause_or_stop() if should_stop: break replace = TreeDict.fromdict({ 'DopplerCooling.doppler_cooling_amplitude_397':doppler_cooling_power, 'DopplerCooling.doppler_cooling_frequency_397':WithUnit(freq_value, 'MHz') }) self.rabi_flop.set_parameters(replace) excitation_carr = self.rabi_flop.run(cxn, context) if excitation_carr is None: break # -3 dBm less power should_stop = self.pause_or_stop() if should_stop: break replace = TreeDict.fromdict({ 'DopplerCooling.doppler_cooling_amplitude_397':doppler_cooling_power - WithUnit(3.0, 'dBm'), 'DopplerCooling.doppler_cooling_frequency_397':WithUnit(freq_value, 'MHz') }) self.rabi_flop.set_parameters(replace) excitation_carr_m3 = self.rabi_flop.run(cxn, context) if excitation_carr_m3 is None: break # +3 dBm less power should_stop = self.pause_or_stop() if should_stop: break replace = TreeDict.fromdict({ 'DopplerCooling.doppler_cooling_amplitude_397':doppler_cooling_power + WithUnit(3.0, 'dBm'), 'DopplerCooling.doppler_cooling_frequency_397':WithUnit(freq_value, 'MHz') }) self.rabi_flop.set_parameters(replace) excitation_carr_p3 = self.rabi_flop.run(cxn, context) if excitation_carr_p3 is None: break # submit all three scans submission = [freq_value] submission.extend([excitation_carr, excitation_carr_m3, excitation_carr_p3]) self.dv.add(submission, context = self.save_context) self.update_progress(i)
def run(self, cxn, context): scan_param = self.parameters.Motion_Analysis.scan_frequency if self.parameters.Motion_Analysis.do_radial1_scan: #mode = self.parameters.Motion_Analysis.sideband_selection mode = 'radial_frequency_1' self.scan = scan_methods.simple_scan( scan_param, 'MHz', offset=self.parameters['TrapFrequencies.' + mode]) dv_args = { 'output_size': self.rabi_flop.excite.output_size, 'experiment_name': self.name, 'window_name': 'radial1', 'dataset_name': 'exc_freq', 'axis': self.scan, 'send_to_current': True, } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) self.rabi_flop.set_progress_limits(0, 50.0) for i, f in enumerate(self.scan): should_stop = self.pause_or_stop() if should_stop: break self.agi.set_frequency(f) time.sleep(1) replace = TreeDict.fromdict({ 'Motion_Analysis.excitation_enable': True, 'RabiFlopping.sideband_selection': [1, 0, 0, 0], }) self.rabi_flop.set_parameters(replace) excitation = self.rabi_flop.run(cxn, context) if excitation is None: break submission = [f['MHz']] submission.extend([excitation]) self.dv.add(submission, context=self.save_context) self.update_progress(i) self.rabi_flop.save_parameters(self.dv, cxn, self.cxnlab, self.save_context) self.rabi_flop.finalize(cxn, context) # secondary scan if self.parameters.Motion_Analysis.do_radial2_scan: mode = 'radial_frequency_2' self.scan = scan_methods.simple_scan( scan_param, 'MHz', offset=self.parameters['TrapFrequencies.' + mode]) dv_args = { 'output_size': self.rabi_flop.excite.output_size, 'experiment_name': self.name, 'window_name': 'radial2', 'dataset_name': 'exc_freq', 'axis': self.scan, 'send_to_current': True, } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) self.rabi_flop.set_progress_limits(50.0, 100.0) for i, f in enumerate(self.scan): should_stop = self.pause_or_stop() if should_stop: break self.agi.set_frequency(f) time.sleep(1) replace = TreeDict.fromdict({ 'Motion_Analysis.excitation_enable': True, 'RabiFlopping.sideband_selection': [0, 1, 0, 0], }) self.rabi_flop.set_parameters(replace) excitation = self.rabi_flop.run(cxn, context) if excitation is None: break submission = [f['MHz']] submission.extend([excitation]) self.dv.add(submission, context=self.save_context) self.update_progress(i) self.rabi_flop.save_parameters(self.dv, cxn, self.cxnlab, self.save_context) self.rabi_flop.finalize(cxn, context)
def run(self, cxn, context): dv_args = {'output_size': 1, 'experiment_name' : self.name, 'window_name': 'other', 'dataset_name' : 'Scan linear power' } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) #scan_which_parameter = 'EitCooling.eit_cooling_zeeman_splitting' #my_unit = 'MHz' #avg_value = 13.1517 #delta_value = 2.0 #min_value = avg_value - delta_value #max_value = avg_value + delta_value # #no_of_steps = 30 #scan_which_parameter = 'EitCooling.eit_cooling_amplitude_397_linear' #my_unit = 'dBm' #min_value = -40.0 #max_value = -5.0 #no_of_steps = 30.0 #scan_which_parameter = 'EitCooling.eit_cooling_amplitude_397_sigma' #my_unit = 'dBm' #min_value = -30.0 #max_value = -5.0 #no_of_steps = 30.0 scan_which_parameter = 'EitCooling.eit_cooling_linear_397_freq_offset' my_unit = 'MHz' min_value = -20.0 max_value = +20.0 no_of_steps = 50.0 my_linear_offset = 1.8 # define the frequency at which to take the spectrum points #spec_min_value = -6.869 #spec_max_value = spec_min_value my_729_amplitude = -18 my_729_duration = 160 spec_avg_value = -10.7237 spec_delta = 0.001 spec_no_of_points = 1 scan_param = [WithUnit(min_value, my_unit), WithUnit(max_value, my_unit), no_of_steps] self.scan = scan_methods.simple_scan(scan_param, my_unit) for i,vary_param in enumerate(self.scan): print vary_param should_stop = self.pause_or_stop() if should_stop: break replace = TreeDict.fromdict({ scan_which_parameter:vary_param, #'EitCooling.linear_offset_scan':WithUnit(my_linear_offset, 'MHz'), 'Documentation.sequence':scan_which_parameter, 'Spectrum.manual_scan':(WithUnit(spec_avg_value - spec_delta, 'MHz'), WithUnit(spec_avg_value + spec_delta, 'MHz'), spec_no_of_points), 'Spectrum.scan_selection':'manual', 'Spectrum.manual_amplitude_729':WithUnit(my_729_amplitude, 'dBm'), 'Spectrum.manual_excitation_time':WithUnit(my_729_duration, 'us') }) self.spectrum.set_parameters(replace) (fr, ex) = self.spectrum.run(cxn, context) #print ex fr = np.array(fr) ex = np.array(ex) ex = ex.flatten() ex = np.mean(ex) submission = [vary_param[my_unit]] submission.extend([ex]) self.dv.add(submission, context = self.save_context)
def run(self, cxn, context): dv_args = { 'output_size': 3, 'experiment_name': self.name, 'window_name': 'current', 'dataset_name': 'Two_Line_Rabi_Flop' } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) scan_param = self.parameters.RabiFlopping.manual_scan self.scan = scan_methods.simple_scan(scan_param, 'us') for i, duration in enumerate(self.scan): should_stop = self.pause_or_stop() if should_stop: break replace = TreeDict.fromdict({ 'RabiFlopping_Sit.sit_on_excitation': duration, 'RabiFlopping.frequency_selection': 'auto', 'RabiFlopping.sideband_selection': [0, 0, 0, 0], 'RabiFlopping.line_selection': 'S-1/2D-1/2' }) self.rabi_flop.set_parameters(replace) excitation_delta_m0 = self.rabi_flop.run(cxn, context) if excitation_delta_m0 is None: break replace = TreeDict.fromdict({ 'RabiFlopping_Sit.sit_on_excitation': duration, 'RabiFlopping.frequency_selection': 'auto', 'RabiFlopping.sideband_selection': [0, 0, 0, 0], 'RabiFlopping.line_selection': 'S-1/2D-3/2' }) self.rabi_flop.set_parameters(replace) excitation_delta_m1 = self.rabi_flop.run(cxn, context) if excitation_delta_m1 is None: break replace = TreeDict.fromdict({ 'RabiFlopping_Sit.sit_on_excitation': duration, 'RabiFlopping.frequency_selection': 'auto', 'RabiFlopping.sideband_selection': [0, 0, 0, 0], 'RabiFlopping.line_selection': 'S-1/2D-5/2' }) self.rabi_flop.set_parameters(replace) excitation_delta_m2 = self.rabi_flop.run(cxn, context) if excitation_delta_m2 is None: break submission = [duration['us']] submission.extend([ excitation_delta_m0, excitation_delta_m1, excitation_delta_m2 ]) self.dv.add(submission, context=self.save_context) self.update_progress(i)
def run(self, cxn, context): dv_args = { 'output_size': 1, 'experiment_name': self.name, 'window_name': 'other', 'dataset_name': 'Scan linear power' } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) #scan_which_parameter = 'EitCooling.eit_cooling_zeeman_splitting' #my_unit = 'MHz' #avg_value = 13.1517 #delta_value = 2.0 #min_value = avg_value - delta_value #max_value = avg_value + delta_value # #no_of_steps = 30 #scan_which_parameter = 'EitCooling.eit_cooling_amplitude_397_linear' #my_unit = 'dBm' #min_value = -40.0 #max_value = -5.0 #no_of_steps = 30.0 #scan_which_parameter = 'EitCooling.eit_cooling_amplitude_397_sigma' #my_unit = 'dBm' #min_value = -30.0 #max_value = -5.0 #no_of_steps = 30.0 scan_which_parameter = 'EitCooling.eit_cooling_linear_397_freq_offset' my_unit = 'MHz' min_value = -20.0 max_value = +20.0 no_of_steps = 50.0 my_linear_offset = 1.8 # define the frequency at which to take the spectrum points #spec_min_value = -6.869 #spec_max_value = spec_min_value my_729_amplitude = -18 my_729_duration = 160 spec_avg_value = -10.7237 spec_delta = 0.001 spec_no_of_points = 1 scan_param = [ WithUnit(min_value, my_unit), WithUnit(max_value, my_unit), no_of_steps ] self.scan = scan_methods.simple_scan(scan_param, my_unit) for i, vary_param in enumerate(self.scan): print vary_param should_stop = self.pause_or_stop() if should_stop: break replace = TreeDict.fromdict({ scan_which_parameter: vary_param, #'EitCooling.linear_offset_scan':WithUnit(my_linear_offset, 'MHz'), 'Documentation.sequence': scan_which_parameter, 'Spectrum.manual_scan': (WithUnit(spec_avg_value - spec_delta, 'MHz'), WithUnit(spec_avg_value + spec_delta, 'MHz'), spec_no_of_points), 'Spectrum.scan_selection': 'manual', 'Spectrum.manual_amplitude_729': WithUnit(my_729_amplitude, 'dBm'), 'Spectrum.manual_excitation_time': WithUnit(my_729_duration, 'us') }) self.spectrum.set_parameters(replace) (fr, ex) = self.spectrum.run(cxn, context) #print ex fr = np.array(fr) ex = np.array(ex) ex = ex.flatten() ex = np.mean(ex) submission = [vary_param[my_unit]] submission.extend([ex]) self.dv.add(submission, context=self.save_context)
def run(self, cxn, context): scan_param = self.parameters.Motion_Analysis.scan_ramsey_time if self.parameters.Motion_Analysis.do_radial1_scan: #mode = self.parameters.Motion_Analysis.sideband_selection self.scan = scan_methods.simple_scan(scan_param, 'us') #Creates linspace to scan over dv_args = {'output_size':self.rabi_flop.excite.output_size, 'experiment_name': self.name, 'window_name': 'ramsey', 'dataset_name': 'exc_freq', 'axis': self.scan, 'send_to_current': True, } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) freq=self.parameters.TrapFrequencies.radial_frequency_1+self.parameters.Motion_Analysis.ramsey_detuning self.rabi_flop.set_progress_limits(0, 50.0) for i,t in enumerate(self.scan): should_stop = self.pause_or_stop() if should_stop: break self.agi.set_frequency(freq) time.sleep(1) replace = TreeDict.fromdict({ 'Motion_Analysis.excitation_enable':True, 'RabiFlopping.sideband_selection':[1,0,0,0], 'Motion_Analysis.ramsey_time':t, }) self.rabi_flop.set_parameters(replace) excitation = self.rabi_flop.run(cxn, context) if excitation is None: break submission = [t['us']] submission.extend([excitation]) self.dv.add(submission, context = self.save_context) self.update_progress(i) self.rabi_flop.save_parameters(self.dv, cxn, self.cxnlab, self.save_context) self.rabi_flop.finalize(cxn, context) # secondary scan if self.parameters.Motion_Analysis.do_radial2_scan: self.scan = scan_methods.simple_scan(scan_param, 'us') #Creates linspace to scan over dv_args = {'output_size':self.rabi_flop.excite.output_size, 'experiment_name': self.name, 'window_name': 'ramsey', 'dataset_name': 'exc_freq', 'axis': self.scan, 'send_to_current': True, } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) freq=self.parameters.TrapFrequencies.radial_frequency_2+self.parameters.Motion_Analysis.ramsey_detuning self.rabi_flop.set_progress_limits(50.0, 100.0) for i,t in enumerate(self.scan): should_stop = self.pause_or_stop() if should_stop: break self.agi.set_frequency(freq) time.sleep(1) replace = TreeDict.fromdict({ 'Motion_Analysis.excitation_enable':True, 'RabiFlopping.sideband_selection':[0,1,0,0], 'Motion_Analysis.ramsey_time':t, }) self.rabi_flop.set_parameters(replace) excitation = self.rabi_flop.run(cxn, context) if excitation is None: break submission = [t['us']] submission.extend([excitation]) self.dv.add(submission, context = self.save_context) self.update_progress(i) self.rabi_flop.save_parameters(self.dv, cxn, self.cxnlab, self.save_context) self.rabi_flop.finalize(cxn, context)
def run(self, cxn, context): scan_param = self.parameters.Motion_Analysis.scan_frequency if self.parameters.Motion_Analysis.do_radial1_scan: #mode = self.parameters.Motion_Analysis.sideband_selection mode = 'radial_frequency_1' self.scan = scan_methods.simple_scan(scan_param, 'MHz', offset = self.parameters['TrapFrequencies.' + mode]) dv_args = {'output_size':self.rabi_flop.excite.output_size, 'experiment_name': self.name, 'window_name': 'radial1', 'dataset_name': 'exc_freq', 'axis': self.scan, 'send_to_current': True, } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) self.rabi_flop.set_progress_limits(0, 50.0) for i,f in enumerate(self.scan): should_stop = self.pause_or_stop() if should_stop: break ma = self.parameters.Motion_Analysis self.agi.set_frequency(f) time.sleep(1) print ma.rf_modulation_depth if ma.rf_modulation: if ma.rf_modulation_depth == 0: self.agi.set_output(False) else: self.agi.set_ranges(WithUnit(-ma.rf_modulation_depth/2.0,'V'),WithUnit(0.0,'V')) self.agi.set_output(True) else: self.agi.set_amplitude(WithUnit(18.0,'dBm')) self.agi.set_output(True) time.sleep(1) replace = TreeDict.fromdict({ 'Motion_Analysis.excitation_enable':True, 'RabiFlopping.sideband_selection':[-1,0,0,0], }) self.rabi_flop.set_parameters(replace) excitation = self.rabi_flop.run(cxn, context) if excitation is None: break submission = [f['MHz']] submission.extend([excitation]) self.dv.add(submission, context = self.save_context) self.update_progress(i) self.rabi_flop.save_parameters(self.dv, cxn, self.cxnlab, self.save_context) self.rabi_flop.finalize(cxn, context) # secondary scan if self.parameters.Motion_Analysis.do_radial2_scan: mode = 'radial_frequency_2' self.scan = scan_methods.simple_scan(scan_param, 'MHz', offset = self.parameters['TrapFrequencies.' + mode]) dv_args = {'output_size':self.rabi_flop.excite.output_size, 'experiment_name': self.name, 'window_name': 'radial2', 'dataset_name': 'exc_freq', 'axis': self.scan, 'send_to_current': True, } scan_methods.setup_data_vault(cxn, self.save_context, dv_args) self.rabi_flop.set_progress_limits(50.0, 100.0) for i,f in enumerate(self.scan): should_stop = self.pause_or_stop() if should_stop: break self.agi.set_frequency(f) time.sleep(1) replace = TreeDict.fromdict({ 'Motion_Analysis.excitation_enable':True, 'RabiFlopping.sideband_selection':[0,-1,0,0], }) self.rabi_flop.set_parameters(replace) excitation = self.rabi_flop.run(cxn, context) if excitation is None: break submission = [f['MHz']] submission.extend([excitation]) self.dv.add(submission, context = self.save_context) self.update_progress(i) self.rabi_flop.save_parameters(self.dv, cxn, self.cxnlab, self.save_context) self.rabi_flop.finalize(cxn, context)