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)
