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': '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.scan_phi = [WithUnit(x, 'deg') for x in [0.0, 90.0, 180.0, 270.0]] self.setup_data_vault() scan_time = scan_methods.simple_scan(self.parameters.SZX.duration_scan, 'us') self.scan = scan_time for i, t in enumerate(scan_time): should_stop = self.pause_or_stop() if should_stop: break p = [] for j, phi in enumerate(self.scan_phi): replace = TreeDict.fromdict({'SZX.duration':t}) replace['SZX.second_pulse_phase'] = phi self.excite.set_parameters(replace) p.extend( self.excite.run(cxn, context) ) submission = [t['us']] print p submission.extend(p) p0, p90, p180 = p[0], p[1], p[2] #print p0 k = p0 + p180 c = np.sqrt((2*p0 - k)**2 + (2*p90 - k)**2) submission.extend([c]) self.dv.add(submission, context = self.save_context) self.update_progress(i)
def run(self, cxn, context): self.scan_phi = [WithUnit(x, 'deg') for x in [0.0, 90.0, 180.0, 270.0]] self.setup_data_vault() scan_time = scan_methods.simple_scan(self.parameters.SZX.duration_scan, 'us') self.scan = scan_time for i, t in enumerate(scan_time): should_stop = self.pause_or_stop() if should_stop: break p = [] for j, phi in enumerate(self.scan_phi): replace = TreeDict.fromdict({'SZX.duration': t}) replace['SZX.second_pulse_phase'] = phi self.excite.set_parameters(replace) p.extend(self.excite.run(cxn, context)) submission = [t['us']] print p submission.extend(p) p0, p90, p180 = p[0], p[1], p[2] #print p0 k = p0 + p180 c = np.sqrt((2 * p0 - k)**2 + (2 * p90 - k)**2) submission.extend([c]) 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_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': 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', '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':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, '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': 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':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 run(self, cxn, context): self.scan_phi = [WithUnit(x, 'deg') for x in [0.0, 90.0, 180.0, 270.0]] self.setup_data_vault() scan_time = scan_methods.simple_scan(self.parameters.SZX.duration_scan, 'us') self.scan = scan_time for i, t in enumerate(scan_time): should_stop = self.pause_or_stop() if should_stop: break replace = TreeDict.fromdict({'SZX.duration':t}) replace['SZX.second_pulse_phase'] = WithUnit(0.0, 'deg') self.excite.set_parameters(replace) submission = [t['us']] submission.extend(self.excite.run(cxn, context)) self.dv.add(submission, context = self.save_context) self.update_progress(i)
def run(self, cxn, context): scan = scan_methods.simple_scan(self.parameters.MolmerSorensen.detuning_scan, 'kHz') self.scan = scan self.setup_data_vault() for i, freq in enumerate(scan): should_stop = self.pause_or_stop() if should_stop: break replace = TreeDict.fromdict({ 'MolmerSorensen.detuning':freq }) self.excite.set_parameters(replace) states = self.excite.run(cxn, context) if states is None: break submission = [freq['kHz']] submission.extend(states) self.dv.add(submission, context = self.save_context) self.update_progress(i)
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): 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': 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): 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): 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)