def setup_sequence_parameters(self):
p = self.parameters.Dephasing_Pulses
trap = self.parameters.TrapFrequencies
prep_line_frequency = cm.frequency_from_line_selection(
'auto', None, p.preparation_line_selection, self.drift_tracker)
frequency_preparation = cm.add_sidebands(
prep_line_frequency, p.preparation_sideband_selection, trap)
#if same line is selected, match the frequency exactly
same_line = p.preparation_line_selection == p.evolution_line_selection
same_sideband = p.preparation_sideband_selection.aslist == p.evolution_sideband_selection.aslist
print 'same line', same_line
print 'same sideband', same_sideband
if same_line and same_sideband:
frequency_evolution = frequency_preparation
else:
evo_line_frequency = cm.frequency_from_line_selection(
'auto', None, p.evolution_line_selection, self.drift_tracker)
frequency_evolution = cm.add_sidebands(
evo_line_frequency, p.evolution_sideband_selection, trap)
self.parameters[
'Dephasing_Pulses.preparation_pulse_frequency'] = frequency_preparation
self.parameters[
'Dephasing_Pulses.evolution_pulses_frequency'] = frequency_evolution
self.max_second_pulse = p.evolution_pulses_duration
minim, maxim, steps = self.parameters.Dephasing_Pulses.scan_interaction_duration
minim = minim['us']
maxim = maxim['us']
self.scan = linspace(minim, maxim, steps)
self.scan = [WithUnit(pt, 'us') for pt in self.scan]
def setup_sequence_parameters(self):
flop = self.parameters.Ramsey2ions_ScanGapParity
ion1_frequency1 = cm.frequency_from_line_selection(
'auto', WithUnit(0.00, 'MHz'), flop.ion1_pi_over_2_line_selection,
self.drift_tracker)
ion1_frequency2 = cm.frequency_from_line_selection(
'auto', WithUnit(0.00, 'MHz'), flop.ion1_pi_line_selection,
self.drift_tracker)
ion2_frequency1 = cm.frequency_from_line_selection(
'auto', WithUnit(0.00, 'MHz'), flop.ion2_pi_over_2_line_selection,
self.drift_tracker)
ion2_frequency2 = cm.frequency_from_line_selection(
'auto', WithUnit(0.00, 'MHz'), flop.ion2_pi_line_selection,
self.drift_tracker)
#trap = self.parameters.TrapFrequencies
#if flop.frequency_selection == 'auto':
# frequency = cm.add_sidebands(frequency, flop.sideband_selection, trap)
#frequency += self.parameters.RamseyScanGap.detuning
print ion1_frequency1
self.parameters[
'Ramsey_2ions.ion1_excitation_frequency1'] = ion1_frequency1
self.parameters[
'Ramsey_2ions.ion1_excitation_frequency2'] = ion1_frequency2
self.parameters[
'Ramsey_2ions.ion2_excitation_frequency1'] = ion2_frequency1
self.parameters[
'Ramsey_2ions.ion2_excitation_frequency2'] = ion2_frequency2
#self.parameters['Excitation_729.rabi_excitation_amplitude'] = flop.rabi_amplitude_729
#self.parameters['Ramsey.first_pulse_duration'] = self.parameters.Ramsey.rabi_pi_time / 2.0
#self.parameters['Ramsey.second_pulse_duration'] = self.parameters.Ramsey.rabi_pi_time / 2.0
minim, maxim, steps = self.parameters.Ramsey2ions_ScanGapParity.scangap
minim = minim['us']
maxim = maxim['us']
self.scan = linspace(minim, maxim, steps)
self.scan = [WithUnit(pt, 'us') for pt in self.scan]
def setup_sequence_parameters(self):
op = self.parameters.OpticalPumping
sp = self.parameters.StatePreparation
optical_pumping_frequency = cm.frequency_from_line_selection(op.frequency_selection, op.manual_frequency_729, op.line_selection, self.drift_tracker, sp.optical_pumping_enable)
self.parameters['OpticalPumping.optical_pumping_frequency_729'] = optical_pumping_frequency
aux = self.parameters.OpticalPumpingAux
aux_optical_pumping_frequency = cm.frequency_from_line_selection('auto', WithUnit(0,'MHz'), aux.aux_op_line_selection, self.drift_tracker, aux.aux_op_enable)
self.parameters['OpticalPumpingAux.aux_optical_frequency_729'] = aux_optical_pumping_frequency
sc = self.parameters.SidebandCooling
sideband_cooling_frequency = cm.frequency_from_line_selection(sc.frequency_selection, sc.manual_frequency_729, sc.line_selection, self.drift_tracker, sp.sideband_cooling_enable)
if sc.frequency_selection == 'auto':
trap = self.parameters.TrapFrequencies
sideband_cooling_frequency = cm.add_sidebands(sideband_cooling_frequency, sc.sideband_selection, trap)
self.parameters['SidebandCooling.sideband_cooling_frequency_729'] = sideband_cooling_frequency
sc2 = self.parameters.SequentialSBCooling
sc2freq = cm.frequency_from_line_selection(sc.frequency_selection, sc.manual_frequency_729, sc.line_selection, self.drift_tracker, sp.sideband_cooling_enable)
sc2freq = cm.add_sidebands(sc2freq, sc2.sideband_selection, trap)
self.parameters['SequentialSBCooling.frequency'] = sc2freq
# set state readout time
if self.use_camera:
self.parameters['StateReadout.state_readout_duration'] = self.parameters.StateReadout.camera_readout_duration
else:
self.parameters['StateReadout.state_readout_duration'] = self.parameters.StateReadout.pmt_readout_duration
def setup_sequence_parameters(self):
p = self.parameters.Dephasing_Pulses
trap = self.parameters.TrapFrequencies
#trap = trap + radial_frq_offset # Not sure. Ahmed
prep_line_frequency = cm.frequency_from_line_selection(
'auto', None, p.preparation_line_selection, self.drift_tracker)
frequency_preparation = cm.add_sidebands(
prep_line_frequency, p.preparation_sideband_selection, trap)
#if same line is selected, match the frequency exactly
same_line = p.preparation_line_selection == p.evolution_line_selection
same_sideband = p.preparation_sideband_selection.aslist == p.evolution_sideband_selection.aslist
print 'same line', same_line
print 'same sideband', same_sideband
if same_line and same_sideband:
frequency_evolution = frequency_preparation
else:
evo_line_frequency = cm.frequency_from_line_selection(
'auto', None, p.evolution_line_selection, self.drift_tracker)
frequency_evolution = cm.add_sidebands(
evo_line_frequency, p.evolution_sideband_selection, trap)
#frequency_evolution = frequency_evolution + radial_freq_offset #Ahmed, adding the offset here
self.parameters[
'Dephasing_Pulses.preparation_pulse_frequency'] = frequency_preparation
self.parameters[
'Dephasing_Pulses.evolution_pulses_frequency'] = frequency_evolution
self.max_second_pulse = p.evolution_pulses_duration
def setup_sequence_parameters(self):
op = self.parameters.OpticalPumping
sp = self.parameters.StatePreparation
optical_pumping_frequency = cm.frequency_from_line_selection(
op.frequency_selection, op.manual_frequency_729, op.line_selection,
self.drift_tracker, sp.optical_pumping_enable)
self.parameters[
'OpticalPumping.optical_pumping_frequency_729'] = optical_pumping_frequency
aux = self.parameters.OpticalPumpingAux
aux_optical_pumping_frequency = cm.frequency_from_line_selection(
'auto', WithUnit(0, 'MHz'), aux.aux_op_line_selection,
self.drift_tracker, aux.aux_op_enable)
self.parameters[
'OpticalPumpingAux.aux_optical_frequency_729'] = aux_optical_pumping_frequency
sc = self.parameters.SidebandCooling
sideband_cooling_frequency = cm.frequency_from_line_selection(
sc.frequency_selection, sc.manual_frequency_729, sc.line_selection,
self.drift_tracker, sp.sideband_cooling_enable)
if sc.frequency_selection == 'auto':
trap = self.parameters.TrapFrequencies
sideband_cooling_frequency = cm.add_sidebands(
sideband_cooling_frequency, sc.sideband_selection, trap)
self.parameters[
'SidebandCooling.sideband_cooling_frequency_729'] = sideband_cooling_frequency
sc2 = self.parameters.SequentialSBCooling
sc2freq = cm.frequency_from_line_selection(sc.frequency_selection,
sc.manual_frequency_729,
sc.line_selection,
self.drift_tracker,
sp.sideband_cooling_enable)
sc2freq = cm.add_sidebands(sc2freq, sc2.sideband_selection, trap)
self.parameters['SequentialSBCooling.frequency'] = sc2freq
### sideband precooling stuff ###
spc = self.parameters.SidebandPrecooling
sbc_carrier_frequency = cm.frequency_from_line_selection(
sc.frequency_selection, sc.manual_frequency_729, sc.line_selection,
self.drift_tracker, sp.sideband_cooling_enable)
frequency_1 = WithUnit(0.0, 'MHz')
frequency_2 = WithUnit(0.0, 'MHz')
if spc.mode_1 != 'off':
tf = self.parameters['TrapFrequencies.' + spc.mode_1]
frequency_1 = sbc_carrier_frequency - tf
if spc.mode_2 != 'off':
tf = self.parameters['TrapFrequencies.' + spc.mode_2]
frequency_2 = sbc_carrier_frequency - tf
self.parameters['SidebandPrecooling.frequency_1'] = frequency_1
self.parameters['SidebandPrecooling.frequency_2'] = frequency_2
# set state readout time
if self.use_camera:
self.parameters[
'StateReadout.state_readout_duration'] = self.parameters.StateReadout.camera_readout_duration
else:
self.parameters[
'StateReadout.state_readout_duration'] = self.parameters.StateReadout.pmt_readout_duration
def setup_sequence_parameters(self):
flop = self.parameters.RabiFlopping
frequency = cm.frequency_from_line_selection(flop.frequency_selection, flop.manual_frequency_729, flop.line_selection, self.drift_tracker)
trap = self.parameters.TrapFrequencies
if flop.frequency_selection == 'auto':
frequency = cm.add_sidebands(frequency, flop.sideband_selection, trap)
self.parameters['Excitation_729.rabi_excitation_frequency'] = frequency
self.parameters['Excitation_729.rabi_excitation_amplitude'] = flop.rabi_amplitude_729
tom = self.parameters.Tomography
frequency = cm.frequency_from_line_selection('auto', None, tom.line_selection, self.drift_tracker)
self.parameters['Tomography.tomography_excitation_frequency'] = frequency
def setup_sequence_parameters(self):
flop = self.parameters.RabiFlopping
frequency = cm.frequency_from_line_selection(flop.frequency_selection, flop.manual_frequency_729, flop.line_selection, self.drift_tracker)
trap = self.parameters.TrapFrequencies
if flop.frequency_selection == 'auto':
frequency = cm.add_sidebands(frequency, flop.sideband_selection, trap)
self.parameters['Excitation_729.rabi_excitation_frequency'] = frequency
self.parameters['Excitation_729.rabi_excitation_amplitude'] = flop.rabi_amplitude_729
tom = self.parameters.Tomography
frequency = cm.frequency_from_line_selection('auto', None, tom.line_selection, self.drift_tracker)
self.parameters['Tomography.tomography_excitation_frequency'] = frequency
def setup_sequence_parameters(self):
deph = self.parameters.RamseyDephaseCheckCoherence
trap = self.parameters.TrapFrequencies
frequency_1 = cm.frequency_from_line_selection('auto', None, deph.line_selection_1, self.drift_tracker)
frequency_1 = cm.add_sidebands(frequency_1, deph.sideband_selection_1, trap)
self.parameters['RamseyDephaseCheckCoherence.first_pulse_frequency'] = frequency_1
frequency_2 = cm.frequency_from_line_selection('auto', None, deph.line_selection_2, self.drift_tracker)
frequency_2 = cm.add_sidebands(frequency_2, deph.sideband_selection_2, trap)
self.parameters['RamseyDephaseCheckCoherence.second_pulse_frequency'] = frequency_2
tom = self.parameters.Tomography
frequency = cm.frequency_from_line_selection('auto', None, tom.line_selection, self.drift_tracker)
self.parameters['Tomography.tomography_excitation_frequency'] = frequency
def setup_sequence_parameters(self):
op = self.parameters.OpticalPumping
optical_pumping_frequency = cm.frequency_from_line_selection(op.frequency_selection, op.manual_frequency_729, op.line_selection, self.drift_tracker, op.optical_pumping_enable)
self.parameters['OpticalPumping.optical_pumping_frequency_729'] = optical_pumping_frequency
aux = self.parameters.OpticalPumpingAux
aux_optical_pumping_frequency = cm.frequency_from_line_selection('auto', WithUnit(0,'MHz'), aux.aux_op_line_selection, self.drift_tracker, aux.aux_op_enable)
self.parameters['OpticalPumpingAux.aux_optical_frequency_729'] = aux_optical_pumping_frequency
sc = self.parameters.SidebandCooling
sideband_cooling_frequency = cm.frequency_from_line_selection(sc.frequency_selection, sc.manual_frequency_729, sc.line_selection, self.drift_tracker, sc.sideband_cooling_enable)
if sc.frequency_selection == 'auto':
trap = self.parameters.TrapFrequencies
sideband_cooling_frequency = cm.add_sidebands(sideband_cooling_frequency, sc.sideband_selection, trap)
self.parameters['SidebandCooling.sideband_cooling_frequency_729'] = sideband_cooling_frequency
def load_frequency(self):
#reloads trap frequencyies and gets the latest information from the drift tracker
self.reload_some_parameters(self.trap_frequencies)
flop = self.parameters.RabiFlopping_2ions
frequency1 = cm.frequency_from_line_selection(flop.ion1_frequency_selection, flop.ion1_manual_frequency_729, flop.ion1_line_selection, self.drift_tracker)
frequency2 = cm.frequency_from_line_selection(flop.ion2_frequency_selection, flop.ion2_manual_frequency_729, flop.ion2_line_selection, self.drift_tracker)
trap = self.parameters.TrapFrequencies
if flop.ion1_frequency_selection == 'auto':
frequency1 = cm.add_sidebands(frequency1, flop.ion1_sideband_selection, trap)
if flop.ion2_frequency_selection == 'auto':
frequency2 = cm.add_sidebands(frequency2, flop.ion2_sideband_selection, trap)
self.parameters['Rabi_excitation_729_2ions.ion1_excitation_frequency'] = frequency1
self.parameters['Rabi_excitation_729_2ions.ion2_excitation_frequency'] = frequency2
def load_frequency(self):
#reloads trap frequencyies and gets the latest information from the drift tracker
self.reload_some_parameters(self.trap_frequencies)
flop = self.parameters.RabiPowerFlopping_2ions
frequency1 = cm.frequency_from_line_selection(flop.ion1_frequency_selection, flop.ion1_manual_frequency_729, flop.ion1_line_selection, self.drift_tracker)
frequency2 = cm.frequency_from_line_selection(flop.ion2_frequency_selection, flop.ion2_manual_frequency_729, flop.ion2_line_selection, self.drift_tracker)
trap = self.parameters.TrapFrequencies
if flop.ion1_frequency_selection == 'auto':
frequency1 = cm.add_sidebands(frequency1, flop.ion1_sideband_selection, trap)
if flop.ion2_frequency_selection == 'auto':
frequency2 = cm.add_sidebands(frequency2, flop.ion2_sideband_selection, trap)
self.parameters['Rabi_excitation_729_2ions.ion1_excitation_frequency'] = frequency1
self.parameters['Rabi_excitation_729_2ions.ion2_excitation_frequency'] = frequency2
def setup_sequence_parameters(self, phase_plus_pi):
### reload the phase ###
self.reload_some_parameters([('Parity_LLI', 'phase_mirror_state'),
('Parity_LLI', 'phase_mirror_state_short_time'),
('Parity_LLI', 'phase_no_mirror_state_short_time'),
('Parity_LLI', 'phase_no_mirror_state'),])
if self.parameters.Parity_LLI.mirror_state == True:
self.parameters['Ramsey_2ions.ion1_excitation_frequency1'] = cm.frequency_from_line_selection('auto', WithUnit(0.00, 'MHz'), 'S-1/2D-1/2', self.drift_tracker)
self.parameters['Ramsey_2ions.ion1_excitation_frequency2'] = cm.frequency_from_line_selection('auto', WithUnit(0.00, 'MHz'), 'S-1/2D-5/2', self.drift_tracker)
self.parameters['Ramsey_2ions.ion2_excitation_frequency1'] = cm.frequency_from_line_selection('auto', WithUnit(0.00, 'MHz'), 'S+1/2D+1/2', self.drift_tracker)
self.parameters['Ramsey_2ions.ion2_excitation_frequency2'] = cm.frequency_from_line_selection('auto', WithUnit(0.00, 'MHz'), 'S+1/2D+5/2', self.drift_tracker)
self.parameters['Ramsey_2ions.ion1_excitation_amplitude1'] = self.parameters['Parity_transitions.left_ionSm12Dm12_power']
self.parameters['Ramsey_2ions.ion1_excitation_amplitude2'] = self.parameters['Parity_transitions.left_ionSm12Dm52_power']
self.parameters['Ramsey_2ions.ion2_excitation_amplitude1'] = self.parameters['Parity_transitions.right_ionSp12Dp12_power']
self.parameters['Ramsey_2ions.ion2_excitation_amplitude2'] = self.parameters['Parity_transitions.right_ionSp12Dp52_power']
self.parameters['Ramsey_2ions.ion1_excitation_duration1'] = self.parameters['Parity_transitions.left_ionSm12Dm12_pi_time']/2.0
self.parameters['Ramsey_2ions.ion1_excitation_duration2'] = self.parameters['Parity_transitions.left_ionSm12Dm52_pi_time']
self.parameters['Ramsey_2ions.ion2_excitation_duration1'] = self.parameters['Parity_transitions.right_ionSp12Dp12_pi_time']/2.0
self.parameters['Ramsey_2ions.ion2_excitation_duration2'] = self.parameters['Parity_transitions.right_ionSp12Dp52_pi_time']
self.parameters['OpticalPumping.line_selection'] = 'S+1/2D-3/2'
self.parameters['OpticalPumpingAux.aux_op_line_selection'] = 'S-1/2D+3/2'
if self.parameters.Parity_LLI.use_short_ramsey_time:
self.parameters['Ramsey_2ions.ramsey_time'] = self.parameters['Parity_LLI.short_ramsey_time']
if phase_plus_pi:
self.parameters['Ramsey_2ions.ion2_excitation_phase1'] = self.parameters['Parity_LLI.phase_mirror_state_short_time']+WithUnit(180.0,'deg')
else:
self.parameters['Ramsey_2ions.ion2_excitation_phase1'] = self.parameters['Parity_LLI.phase_mirror_state_short_time']
else:
self.parameters['Ramsey_2ions.ramsey_time'] = self.parameters['Parity_LLI.long_ramsey_time']
if phase_plus_pi:
self.parameters['Ramsey_2ions.ion2_excitation_phase1'] = self.parameters['Parity_LLI.phase_mirror_state']+WithUnit(180.0,'deg')
else:
self.parameters['Ramsey_2ions.ion2_excitation_phase1'] = self.parameters['Parity_LLI.phase_mirror_state']
else:
self.parameters['Ramsey_2ions.ion1_excitation_frequency1'] = cm.frequency_from_line_selection('auto', WithUnit(0.00, 'MHz'), 'S+1/2D+1/2', self.drift_tracker)
self.parameters['Ramsey_2ions.ion1_excitation_frequency2'] = cm.frequency_from_line_selection('auto', WithUnit(0.00, 'MHz'), 'S+1/2D+5/2', self.drift_tracker)
self.parameters['Ramsey_2ions.ion2_excitation_frequency1'] = cm.frequency_from_line_selection('auto', WithUnit(0.00, 'MHz'), 'S-1/2D-1/2', self.drift_tracker)
self.parameters['Ramsey_2ions.ion2_excitation_frequency2'] = cm.frequency_from_line_selection('auto', WithUnit(0.00, 'MHz'), 'S-1/2D-5/2', self.drift_tracker)
self.parameters['Ramsey_2ions.ion1_excitation_amplitude1'] = self.parameters['Parity_transitions.left_ionSp12Dp12_power']
self.parameters['Ramsey_2ions.ion1_excitation_amplitude2'] = self.parameters['Parity_transitions.left_ionSp12Dp52_power']
self.parameters['Ramsey_2ions.ion2_excitation_amplitude1'] = self.parameters['Parity_transitions.right_ionSm12Dm12_power']
self.parameters['Ramsey_2ions.ion2_excitation_amplitude2'] = self.parameters['Parity_transitions.right_ionSm12Dm52_power']
self.parameters['Ramsey_2ions.ion1_excitation_duration1'] = self.parameters['Parity_transitions.left_ionSp12Dp12_pi_time']/2.0
self.parameters['Ramsey_2ions.ion1_excitation_duration2'] = self.parameters['Parity_transitions.left_ionSp12Dp52_pi_time']
self.parameters['Ramsey_2ions.ion2_excitation_duration1'] = self.parameters['Parity_transitions.right_ionSm12Dm12_pi_time']/2.0
self.parameters['Ramsey_2ions.ion2_excitation_duration2'] = self.parameters['Parity_transitions.right_ionSm12Dm52_pi_time']
self.parameters['OpticalPumping.line_selection'] = 'S-1/2D+3/2'
self.parameters['OpticalPumpingAux.aux_op_line_selection'] = 'S+1/2D-3/2'
if self.parameters.Parity_LLI.use_short_ramsey_time:
self.parameters['Ramsey_2ions.ramsey_time'] = self.parameters['Parity_LLI.short_ramsey_time']
if phase_plus_pi:
self.parameters['Ramsey_2ions.ion2_excitation_phase1'] = self.parameters['Parity_LLI.phase_no_mirror_state_short_time']+WithUnit(180.0,'deg')
else:
self.parameters['Ramsey_2ions.ion2_excitation_phase1'] = self.parameters['Parity_LLI.phase_no_mirror_state_short_time']
else:
self.parameters['Ramsey_2ions.ramsey_time'] = self.parameters['Parity_LLI.long_ramsey_time']
if phase_plus_pi:
self.parameters['Ramsey_2ions.ion2_excitation_phase1'] = self.parameters['Parity_LLI.phase_no_mirror_state']+WithUnit(180.0,'deg')
else:
self.parameters['Ramsey_2ions.ion2_excitation_phase1'] = self.parameters['Parity_LLI.phase_no_mirror_state']
def load_frequency(self):
#reloads trap frequencyies and gets the latest information from the drift tracker
self.reload_some_parameters(self.trap_frequencies)
gate = self.parameters.SZX
# set the double pass to the carrier frequency
frequency = cm.frequency_from_line_selection(gate.frequency_selection,
gate.manual_frequency_729,
gate.line_selection,
self.drift_tracker)
frequency = frequency - gate.ac_stark_shift / 2. # AC Stark Shift should be in the opposite direction on the double pass right??
flop = self.parameters.RabiFlopping
frequency_rabi = cm.frequency_from_line_selection(
flop.frequency_selection, flop.manual_frequency_729,
flop.line_selection, self.drift_tracker)
trap = self.parameters.TrapFrequencies
if flop.frequency_selection == 'auto':
frequency_rabi = cm.add_sidebands(frequency,
flop.sideband_selection, trap)
self.parameters[
'Excitation_729.rabi_excitation_frequency'] = frequency_rabi
#trap = self.parameters.TrapFrequencies
self.parameters['SZX.frequency'] = frequency
## now program the CW dds boards
# Ok so, because we are stupid the single pass AOMs all use the -1 order
# so if we make the single pass frequency 81 MHz, we're actually driving -red-
# of the carrier by 1 MHz. Keep that in mind until we change it.
mode = gate.sideband_selection
trap_frequency = self.parameters['TrapFrequencies.' + mode]
f_local = WithUnit(80.0, 'MHz') - WithUnit(0.2, 'MHz')
freq_blue = f_local - trap_frequency / 2. - gate.detuning + gate.ac_stark_shift
freq_red = f_local + trap_frequency / 2. + gate.ac_stark_shift
amp = WithUnit(-15., 'dBm')
amp_blue = self.parameters.SZX.amp_blue
amp_red = self.parameters.SZX.amp_red
self.dds_cw.frequency('3', freq_blue)
self.dds_cw.frequency('4', freq_red)
self.dds_cw.frequency('5', f_local) # for driving the carrier
self.dds_cw.amplitude('3', amp_blue)
self.dds_cw.amplitude('4', amp_red)
self.dds_cw.amplitude('5', amp)
self.dds_cw.output('3', True)
self.dds_cw.output('4', True)
self.dds_cw.output('5', True)
time.sleep(
0.5
) # just make sure everything is programmed before starting the sequence
def load_frequency(self, ac_stark_shift):
#reloads trap frequencyies and gets the latest information from the drift tracker
self.reload_some_parameters(self.trap_frequencies)
gate = self.parameters.SZX
# set the double pass to the carrier frequency
frequency = cm.frequency_from_line_selection(gate.frequency_selection, gate.manual_frequency_729, gate.line_selection, self.drift_tracker)
#trap = self.parameters.TrapFrequencies
self.parameters['SZX.frequency'] = frequency
## now program the CW dds boards
# Ok so, because we are stupid the single pass AOMs all use the -1 order
# so if we make the single pass frequency 81 MHz, we're actually driving -red-
# of the carrier by 1 MHz. Keep that in mind until we change it.
mode = gate.sideband_selection
trap_frequency = self.parameters['TrapFrequencies.' + mode]
freq_blue = WithUnit(80., 'MHz') - trap_frequency/2. - gate.detuning + ac_stark_shift
freq_red = WithUnit(80., 'MHz') + trap_frequency/2. + ac_stark_shift
amp = WithUnit(-15., 'dBm') # carrier amplitude
amp_blue = self.parameters.SZX.amp_blue
amp_red = self.parameters.SZX.amp_red
self.dds_cw.frequency('0', freq_blue)
self.dds_cw.frequency('1', freq_red)
self.dds_cw.frequency('2', WithUnit(80., 'MHz'))
self.dds_cw.amplitude('0', amp_blue)
self.dds_cw.amplitude('1', amp_red)
self.dds_cw.amplitude('2', amp)
self.dds_cw.output('0', True)
self.dds_cw.output('1', True)
self.dds_cw.output('2', True)
time.sleep(0.5) # make sure everything is set before starting the sequence
def setup_sequence_parameters(self):
flop = self.parameters.RabiFlopping
frequency = cm.frequency_from_line_selection(flop.frequency_selection,
flop.manual_frequency_729,
flop.line_selection,
self.drift_tracker)
trap = self.parameters.TrapFrequencies
if flop.frequency_selection == 'auto':
frequency = cm.add_sidebands(frequency, flop.sideband_selection,
trap)
self.parameters['Excitation_729.rabi_excitation_frequency'] = frequency
self.parameters[
'Excitation_729.rabi_excitation_amplitude'] = flop.rabi_amplitude_729
#import IPython
#IPython.embed()
#self.parameters['Ramsey.first_pulse_duration'] = self.parameters.Ramsey.rabi_pi_time / 2.0
#self.parameters['Ramsey.second_pulse_duration'] = self.parameters.Ramsey.rabi_pi_time / 2.0
minim, maxim, steps = self.parameters.RamseyScanPhase.scanphase
minim = minim['deg']
maxim = maxim['deg']
self.scan = linspace(minim, maxim, steps)
self.scan = [WithUnit(pt, 'deg') for pt in self.scan]
def load_frequency(self):
#reloads trap frequencies and gets the latest information from the drift tracker
self.reload_some_parameters(self.trap_frequencies)
ms = self.parameters.MolmerSorensen
szx = self.parameters.SZX
vaet = self.parameters.VAET
# set the double pass to the carrier frequency
frequency = cm.frequency_from_line_selection('auto', WithUnit(0, 'kHz'), vaet.line_selection, self.drift_tracker)
print frequency
#trap = self.parameters.TrapFrequencies
####### SET DOUBLE PASSES TO THE CARRIER FREQUENCY ########
self.parameters['VAET.frequency'] = frequency
self.parameters['LocalRotation.frequency'] = frequency
delta = self.parameters.VAET.detuning
## now program the CW dds boards
# Ok so, because we are stupid the single pass AOMs all use the -1 order
# so if we make the single pass frequency 81 MHz, we're actually driving -red-
# of the carrier by 1 MHz. Keep that in mind until we change it.
ms_mode = ms.sideband_selection
ms_trap_frequency = self.parameters['TrapFrequencies.' + ms_mode]
#szx_mode = szx.sideband_selection
szx_mode = 'radial_frequency_1'
szx_trap_frequency = self.parameters['TrapFrequencies.' + szx_mode]
### MOLMER SORENSEN FREQUENCIES AND AMPLITUDES ###
f_global = WithUnit(80.0, 'MHz') + WithUnit(0.15, 'MHz')
f_local = WithUnit(80.0, 'MHz') - WithUnit(0.2, 'MHz')
freq_blue = f_global - ms_trap_frequency - ms.detuning + ms.ac_stark_shift
freq_red = f_global + ms_trap_frequency + ms.detuning + ms.ac_stark_shift
amp_blue = self.parameters.MolmerSorensen.amp_blue
amp_red = self.parameters.MolmerSorensen.amp_red
self.dds_cw.frequency('0', freq_blue)
self.dds_cw.frequency('1', freq_red)
self.dds_cw.frequency('2', f_global)
self.dds_cw.amplitude('0', amp_blue)
self.dds_cw.amplitude('1', amp_red)
####### SZX PARAMETERS ##########
freq_blue = f_local - szx_trap_frequency/2. - delta + szx.ac_stark_shift
freq_red = f_local + szx_trap_frequency/2. + szx.ac_stark_shift
amp_blue = self.parameters.SZX.amp_blue
amp_red = self.parameters.SZX.amp_red
self.dds_cw.frequency('3', freq_blue)
self.dds_cw.frequency('4', freq_red)
self.dds_cw.frequency('5', f_local)
self.dds_cw.amplitude('3', amp_blue)
self.dds_cw.amplitude('4', amp_red)
[self.dds_cw.output(ch, True) for ch in ['0', '1', '2', '3', '4']]
self.dds_cw.output('5', True) # thermalization
time.sleep(1.0)
self.dds_cw.output('5', False)
time.sleep(0.1) # make sure everything is set before starting the sequence
def lookup_frequency(self, line_selection, sideband_selection):
frequency = cm.frequency_from_line_selection('auto', None,
line_selection,
self.drift_tracker)
frequency = cm.add_sidebands(frequency, sideband_selection,
self.parameters.TrapFrequencies)
return frequency
def setup_sequence_parameters(self):
sp = self.parameters.Spectrum
if sp.scan_selection == 'manual':
minim, maxim, steps = sp.manual_scan
duration = sp.manual_excitation_time
amplitude = sp.manual_amplitude_729
elif sp.scan_selection == 'auto':
center_frequency = cm.frequency_from_line_selection(
sp.scan_selection, None, sp.line_selection, self.drift_tracker)
center_frequency = cm.add_sidebands(
center_frequency, sp.sideband_selection,
self.parameters.TrapFrequencies)
span, resolution, duration, amplitude = sp[
sp.sensitivity_selection]
minim = center_frequency - span / 2.0
maxim = center_frequency + span / 2.0
steps = int(span / resolution)
else:
raise Exception("Incorrect Spectrum Scan Type")
#making the scan
self.parameters['Excitation_729.rabi_excitation_duration'] = duration
self.parameters['Excitation_729.rabi_excitation_amplitude'] = amplitude
minim = minim['MHz']
maxim = maxim['MHz']
self.scan = np.linspace(minim, maxim, steps)
self.scan = [WithUnit(pt, 'MHz') for pt in self.scan]
def load_frequency(self):
#reloads trap frequencyies and gets the latest information from the drift tracker
self.reload_some_parameters(self.trap_frequencies)
gate = self.parameters.SZX
# set the double pass to the carrier frequency
frequency = cm.frequency_from_line_selection('auto', WithUnit(0.0, 'MHz'), gate.line_selection, self.drift_tracker)
self.parameters['SZX.frequency'] = frequency
self.parameters['LocalRotation.frequency'] = frequency
## now program the CW dds boards
# Ok so, because we are stupid the single pass AOMs all use the -1 order
# so if we make the single pass frequency 81 MHz, we're actually driving -red-
# of the carrier by 1 MHz. Keep that in mind until we change it.
mode = gate.sideband_selection
trap_frequency = self.parameters['TrapFrequencies.' + mode]
f_local = WithUnit(80.0, 'MHz') - WithUnit(0.2, 'MHz')
freq_blue = f_local - trap_frequency/2. - gate.detuning + gate.ac_stark_shift
freq_red = f_local + trap_frequency/2. + gate.ac_stark_shift
amp = WithUnit(-15., 'dBm')
amp_blue = self.parameters.SZX.amp_blue
amp_red = self.parameters.SZX.amp_red
self.dds_cw.frequency('3', freq_blue)
self.dds_cw.frequency('4', freq_red)
self.dds_cw.frequency('5', f_local) # for driving the carrier
self.dds_cw.amplitude('3', amp_blue)
self.dds_cw.amplitude('4', amp_red)
self.dds_cw.amplitude('5', amp)
self.dds_cw.output('3', True)
self.dds_cw.output('4', True)
self.dds_cw.output('5', True)
time.sleep(0.5) # just make sure everything is programmed before starting the sequence
def run(self, cxn, context):
self.setup_data_vault()
dt = self.parameters.Sideband_tracker_ramsey
excitations = []
frequency = cm.frequency_from_line_selection('auto', None,
dt.line_selection,
self.drift_tracker)
frequency = frequency + dt.detuning
for iter, phase in enumerate(self.phases):
replace = TreeDict.fromdict({
'Ramsey.first_pulse_duration':
dt.pi_time / 2.0,
'Ramsey.second_pulse_duration':
dt.pi_time / 2.0,
'Ramsey.ramsey_time':
dt.gap_time,
'Ramsey.second_pulse_phase':
phase,
'Excitation_729.rabi_excitation_amplitude':
dt.amplitude,
'Excitation_729.rabi_excitation_frequency':
frequency,
'Tomography.iteration':
0.0,
'StateReadout.use_camera_for_readout':
dt.use_camera_for_readout,
'StateReadout.repeat_each_measurement':
dt.readouts,
'SidebandCooling.sideband_cooling_enable':
False,
'OpticalPumping.optical_pumping_enable':
dt.optical_pumping_enable_DT,
})
self.excitation.set_parameters(replace)
self.update_progress(iter)
if not self.parameters.StateReadout.use_camera_for_readout:
#using PMT
excitation_array, readout = self.excitation.run(cxn, context)
excitation = excitation_array[0]
else:
primary_ion = int(
self.parameters.StateReadout.camera_primary_ion)
excitation_array, readout = self.excitation.run(cxn, context)
import IPython
#IPython.embed()
excitation = excitation_array[primary_ion]
excitations.append(excitation)
print "exc"
print excitations
detuning, average_excitation = self.calculate_detuning(excitations)
corrected_frequency = frequency + detuning
# print corrected_frequency, average_excitation
return corrected_frequency, average_excitation
def load_frequency(self):
#reloads trap frequencyies and gets the latest information from the drift tracker
self.reload_some_parameters(self.trap_frequencies)
flop = self.parameters.RabiFlopping
frequency = cm.frequency_from_line_selection(flop.frequency_selection, flop.manual_frequency_729, flop.line_selection, self.drift_tracker)
trap = self.parameters.TrapFrequencies
if flop.frequency_selection == 'auto':
frequency = cm.add_sidebands(frequency, flop.sideband_selection, trap)
self.parameters['Excitation_729.rabi_excitation_frequency'] = frequency
def get_frequency(self):
""" We have to fool the rabi flopping experiment to let us put in
a detuning from the carrier. To do this we caculate the frequency
we want and then feed this to rabi flopping as a 'manual' frequency
"""
flop = self.parameters.RabiFlopping
frequency = cm.frequency_from_line_selection('auto', flop.manual_frequency_729, flop.line_selection, self.drift_tracker)
frequency = frequency + self.parameters.CalibrationScans.rabi_detuning
return frequency
def load_frequency(self):
#reloads trap frequencies and gets the latest information from the drift tracker
self.reload_some_parameters(self.trap_frequencies)
flop = self.parameters.RabiFlopping
frequency = cm.frequency_from_line_selection(flop.frequency_selection, flop.manual_frequency_729, flop.line_selection, self.drift_tracker)
trap = self.parameters.TrapFrequencies
if flop.frequency_selection == 'auto':
frequency = cm.add_sidebands(frequency, flop.sideband_selection, trap)
self.parameters['Excitation_729.rabi_excitation_frequency'] = frequency
def setup_sequence_parameters(self):
p = self.parameters.Dephasing_Pulses
trap = self.parameters.TrapFrequencies
prep_line_frequency = cm.frequency_from_line_selection('auto', None, p.preparation_line_selection, self.drift_tracker)
frequency_preparation = cm.add_sidebands(prep_line_frequency, p.preparation_sideband_selection, trap)
#if same line is selected, match the frequency exactly
same_line = p.preparation_line_selection == p.evolution_line_selection
same_sideband = p.preparation_sideband_selection.aslist == p.evolution_sideband_selection.aslist
print 'same line', same_line
print 'same sideband', same_sideband
if same_line and same_sideband:
frequency_evolution = frequency_preparation
else:
evo_line_frequency = cm.frequency_from_line_selection('auto', None, p.evolution_line_selection, self.drift_tracker)
frequency_evolution = cm.add_sidebands(evo_line_frequency, p.evolution_sideband_selection, trap)
frequency_evolution = frequency_evolution + radial_freq_offset #Ahmed
print 'Dsiplaced Sideband:', frequency_evolution #Ahmed
self.parameters['Dephasing_Pulses.preparation_pulse_frequency'] = frequency_preparation
self.parameters['Dephasing_Pulses.evolution_pulses_frequency'] = frequency_evolution
self.max_second_pulse = p.evolution_pulses_duration
def get_frequency(self):
""" We have to fool the rabi flopping experiment to let us put in
a detuning from the carrier. To do this we caculate the frequency
we want and then feed this to rabi flopping as a 'manual' frequency
"""
flop = self.parameters.RabiFlopping
frequency = cm.frequency_from_line_selection('auto',
flop.manual_frequency_729,
flop.line_selection,
self.drift_tracker)
frequency = frequency + self.parameters.CalibrationScans.rabi_detuning
return frequency
def setup_sequence_parameters(self):
flop = self.parameters.RabiFlopping
frequency = cm.frequency_from_line_selection(flop.frequency_selection, flop.manual_frequency_729, flop.line_selection, self.drift_tracker)
trap = self.parameters.TrapFrequencies
if flop.frequency_selection == 'auto':
frequency = cm.add_sidebands(frequency, flop.sideband_selection, trap)
self.parameters['Excitation_729.rabi_excitation_frequency'] = frequency
self.parameters['Excitation_729.rabi_excitation_amplitude'] = flop.rabi_amplitude_729
minim,maxim,steps = self.parameters.RamseyDephase.scan_dephase_duration
minim = minim['us']; maxim = maxim['us']
self.scan = linspace(minim,maxim, steps)
self.scan = [WithUnit(pt, 'us') for pt in self.scan]
def load_frequency(self):
#reloads trap frequencyies and gets the latest information from the drift tracker
self.reload_some_parameters(self.trap_frequencies)
gate = self.parameters.SZX
# set the double pass to the carrier frequency
frequency = cm.frequency_from_line_selection(gate.frequency_selection, gate.manual_frequency_729, gate.line_selection, self.drift_tracker)
frequency = frequency - gate.ac_stark_shift/2. # AC Stark Shift should be in the opposite direction on the double pass right??
flop = self.parameters.RabiFlopping
frequency_rabi = cm.frequency_from_line_selection(flop.frequency_selection, flop.manual_frequency_729, flop.line_selection, self.drift_tracker)
trap = self.parameters.TrapFrequencies
if flop.frequency_selection == 'auto':
frequency_rabi = cm.add_sidebands(frequency, flop.sideband_selection, trap)
self.parameters['Excitation_729.rabi_excitation_frequency'] = frequency_rabi
#trap = self.parameters.TrapFrequencies
self.parameters['SZX.frequency'] = frequency
## now program the CW dds boards
# Ok so, because we are stupid the single pass AOMs all use the -1 order
# so if we make the single pass frequency 81 MHz, we're actually driving -red-
# of the carrier by 1 MHz. Keep that in mind until we change it.
mode = gate.sideband_selection
trap_frequency = self.parameters['TrapFrequencies.' + mode]
f_local = WithUnit(80.0, 'MHz') - WithUnit(0.2, 'MHz')
freq_blue = f_local - trap_frequency/2. - gate.detuning + gate.ac_stark_shift
freq_red = f_local + trap_frequency/2. + gate.ac_stark_shift
amp = WithUnit(-15., 'dBm')
amp_blue = self.parameters.SZX.amp_blue
amp_red = self.parameters.SZX.amp_red
self.dds_cw.frequency('3', freq_blue)
self.dds_cw.frequency('4', freq_red)
self.dds_cw.frequency('5', f_local) # for driving the carrier
self.dds_cw.amplitude('3', amp_blue)
self.dds_cw.amplitude('4', amp_red)
self.dds_cw.amplitude('5', amp)
self.dds_cw.output('3', True)
self.dds_cw.output('4', True)
self.dds_cw.output('5', True)
time.sleep(0.5) # just make sure everything is programmed before starting the sequence
def setup_sequence_parameters(self):
op = self.parameters.OpticalPumping
sp = self.parameters.StatePreparation
optical_pumping_frequency = cm.frequency_from_line_selection(op.frequency_selection, op.manual_frequency_729, op.line_selection, self.drift_tracker, sp.optical_pumping_enable)
self.parameters['OpticalPumping.optical_pumping_frequency_729'] = optical_pumping_frequency
aux = self.parameters.OpticalPumpingAux
aux_optical_pumping_frequency = cm.frequency_from_line_selection('auto', WithUnit(0,'MHz'), aux.aux_op_line_selection, self.drift_tracker, aux.aux_op_enable)
self.parameters['OpticalPumpingAux.aux_optical_frequency_729'] = aux_optical_pumping_frequency
sc = self.parameters.SidebandCooling
sideband_cooling_frequency = cm.frequency_from_line_selection(sc.frequency_selection, sc.manual_frequency_729, sc.line_selection, self.drift_tracker, sp.sideband_cooling_enable)
if sc.frequency_selection == 'auto':
trap = self.parameters.TrapFrequencies
sideband_cooling_frequency = cm.add_sidebands(sideband_cooling_frequency, sc.sideband_selection, trap)
self.parameters['SidebandCooling.sideband_cooling_frequency_729'] = sideband_cooling_frequency
sc2 = self.parameters.SequentialSBCooling
sc2freq = cm.frequency_from_line_selection(sc.frequency_selection, sc.manual_frequency_729, sc.line_selection, self.drift_tracker, sp.sideband_cooling_enable)
sc2freq = cm.add_sidebands(sc2freq, sc2.sideband_selection, trap)
self.parameters['SequentialSBCooling.frequency'] = sc2freq
### sideband precooling stuff ###
spc = self.parameters.SidebandPrecooling
sbc_carrier_frequency = cm.frequency_from_line_selection(sc.frequency_selection, sc.manual_frequency_729, sc.line_selection, self.drift_tracker, sp.sideband_cooling_enable)
frequency_1 = WithUnit(0.0, 'MHz')
frequency_2 = WithUnit(0.0, 'MHz')
if spc.mode_1 != 'off':
tf = self.parameters['TrapFrequencies.' + spc.mode_1]
frequency_1 = sbc_carrier_frequency - tf
if spc.mode_2 != 'off':
tf = self.parameters['TrapFrequencies.' + spc.mode_2]
frequency_2 = sbc_carrier_frequency - tf
self.parameters['SidebandPrecooling.frequency_1'] = frequency_1
self.parameters['SidebandPrecooling.frequency_2'] = frequency_2
# set state readout time
if self.use_camera:
self.parameters['StateReadout.state_readout_duration'] = self.parameters.StateReadout.camera_readout_duration
else:
self.parameters['StateReadout.state_readout_duration'] = self.parameters.StateReadout.pmt_readout_duration
def setup_sequence_parameters(self):
p = self.parameters.Dephasing_Pulses
trap = self.parameters.TrapFrequencies
prep_line_frequency = cm.frequency_from_line_selection('auto', None, p.preparation_line_selection, self.drift_tracker)
frequency_preparation = cm.add_sidebands(prep_line_frequency, p.preparation_sideband_selection, trap)
#if same line is selected, match the frequency exactly
same_line = p.preparation_line_selection == p.evolution_line_selection
same_sideband = p.preparation_sideband_selection.aslist == p.evolution_sideband_selection.aslist
print 'same line', same_line
print 'same sideband', same_sideband
if same_line and same_sideband:
frequency_evolution = frequency_preparation
else:
evo_line_frequency = cm.frequency_from_line_selection('auto', None, p.evolution_line_selection, self.drift_tracker)
frequency_evolution = cm.add_sidebands(evo_line_frequency, p.evolution_sideband_selection, trap)
self.parameters['Dephasing_Pulses.preparation_pulse_frequency'] = frequency_preparation
self.parameters['Dephasing_Pulses.evolution_pulses_frequency'] = frequency_evolution
self.max_second_pulse = p.evolution_pulses_duration
minim,maxim,steps = self.parameters.Dephasing_Pulses.scan_interaction_duration
minim = minim['us']; maxim = maxim['us']
self.scan = linspace(minim,maxim, steps)
self.scan = [WithUnit(pt, 'us') for pt in self.scan]
def setup_sequence_parameters(self):
flop = self.parameters.Ramsey2ions_ScanGapParity
ion1_frequency1 = cm.frequency_from_line_selection('auto', WithUnit(0.00, 'MHz'), flop.ion1_pi_over_2_line_selection, self.drift_tracker)
ion1_frequency2 = cm.frequency_from_line_selection('auto', WithUnit(0.00, 'MHz'), flop.ion1_pi_line_selection, self.drift_tracker)
ion2_frequency1 = cm.frequency_from_line_selection('auto', WithUnit(0.00, 'MHz'), flop.ion2_pi_over_2_line_selection, self.drift_tracker)
ion2_frequency2 = cm.frequency_from_line_selection('auto', WithUnit(0.00, 'MHz'), flop.ion2_pi_line_selection, self.drift_tracker)
#trap = self.parameters.TrapFrequencies
#if flop.frequency_selection == 'auto':
# frequency = cm.add_sidebands(frequency, flop.sideband_selection, trap)
#frequency += self.parameters.RamseyScanGap.detuning
print ion1_frequency1
self.parameters['Ramsey_2ions.ion1_excitation_frequency1'] = ion1_frequency1
self.parameters['Ramsey_2ions.ion1_excitation_frequency2'] = ion1_frequency2
self.parameters['Ramsey_2ions.ion2_excitation_frequency1'] = ion2_frequency1
self.parameters['Ramsey_2ions.ion2_excitation_frequency2'] = ion2_frequency2
#self.parameters['Excitation_729.rabi_excitation_amplitude'] = flop.rabi_amplitude_729
#self.parameters['Ramsey.first_pulse_duration'] = self.parameters.Ramsey.rabi_pi_time / 2.0
#self.parameters['Ramsey.second_pulse_duration'] = self.parameters.Ramsey.rabi_pi_time / 2.0
minim,maxim,steps = self.parameters.Ramsey2ions_ScanGapParity.scangap
minim = minim['us']; maxim = maxim['us']
self.scan = linspace(minim,maxim, steps)
self.scan = [WithUnit(pt, 'us') for pt in self.scan]
def setup_sequence_parameters(self):
flop = self.parameters.RabiFlopping
frequency = cm.frequency_from_line_selection(flop.frequency_selection, flop.manual_frequency_729, flop.line_selection, self.drift_tracker)
trap = self.parameters.TrapFrequencies
if flop.frequency_selection == 'auto':
frequency = cm.add_sidebands(frequency, flop.sideband_selection, trap)
self.parameters['Excitation_729.rabi_excitation_frequency'] = frequency
self.parameters['Excitation_729.rabi_excitation_amplitude'] = flop.rabi_amplitude_729
#self.parameters['Ramsey.first_pulse_duration'] = self.parameters.Ramsey.rabi_pi_time / 2.0
#self.parameters['Ramsey.second_pulse_duration'] = self.parameters.Ramsey.rabi_pi_time / 2.0
minim,maxim,steps = self.parameters.RamseyScanPhase.scanphase
minim = minim['deg']; maxim = maxim['deg']
self.scan = linspace(minim,maxim, steps)
self.scan = [WithUnit(pt, 'deg') for pt in self.scan]
def setup_sequence_parameters(self):
deph = self.parameters.RamseyDephaseCheckCoherence
trap = self.parameters.TrapFrequencies
frequency_1 = cm.frequency_from_line_selection('auto', None,
deph.line_selection_1,
self.drift_tracker)
frequency_1 = cm.add_sidebands(frequency_1, deph.sideband_selection_1,
trap)
self.parameters[
'RamseyDephaseCheckCoherence.first_pulse_frequency'] = frequency_1
frequency_2 = cm.frequency_from_line_selection('auto', None,
deph.line_selection_2,
self.drift_tracker)
frequency_2 = cm.add_sidebands(frequency_2, deph.sideband_selection_2,
trap)
self.parameters[
'RamseyDephaseCheckCoherence.second_pulse_frequency'] = frequency_2
tom = self.parameters.Tomography
frequency = cm.frequency_from_line_selection('auto', None,
tom.line_selection,
self.drift_tracker)
self.parameters[
'Tomography.tomography_excitation_frequency'] = frequency
def setup_sequence_parameters(self):
sp = self.parameters.Sideband_tracker
center_frequency = cm.frequency_from_line_selection('auto', None , sp.line_selection, self.drift_tracker)
self.carrier_frequency = center_frequency
center_frequency = cm.add_sidebands(center_frequency, sp.sideband_selection, self.parameters.TrapFrequencies)
span, resolution, duration, amplitude = sp['sensitivity']
minim = center_frequency - span / 2.0
maxim = center_frequency + span / 2.0
steps = int(span / resolution )
self.parameters['Excitation_729.rabi_excitation_duration'] = duration
self.parameters['Excitation_729.rabi_excitation_amplitude'] = amplitude
minim = minim['MHz']; maxim = maxim['MHz']
self.scan = np.linspace(minim,maxim, steps)
self.scan = [WithUnit(pt, 'MHz') for pt in self.scan]
def setup_sequence_parameters(self):
flop = self.parameters.RabiFlopping
frequency = cm.frequency_from_line_selection(flop.frequency_selection, flop.manual_frequency_729, flop.line_selection, self.drift_tracker)
trap = self.parameters.TrapFrequencies
if flop.frequency_selection == 'auto':
frequency = cm.add_sidebands(frequency, flop.sideband_selection, trap)
frequency += self.parameters.RamseyScanGap.detuning
#print frequency
self.parameters['Excitation_729.rabi_excitation_frequency'] = frequency
self.parameters['Excitation_729.rabi_excitation_amplitude'] = flop.rabi_amplitude_729
minim,maxim,steps = self.parameters.RamseyScanGap.scangap
minim = minim['us']; maxim = maxim['us']
self.scan = linspace(minim,maxim, steps)
self.scan = [WithUnit(pt, 'us') for pt in self.scan]
def load_frequency(self):
#reloads trap frequencyies and gets the latest information from the drift tracker
self.reload_some_parameters(self.trap_frequencies)
gate = self.parameters.MolmerSorensen
# set the double pass to the carrier frequency
frequency = cm.frequency_from_line_selection(gate.frequency_selection,
gate.manual_frequency_729,
gate.line_selection,
self.drift_tracker)
#trap = self.parameters.TrapFrequencies
self.parameters['MolmerSorensen.frequency'] = frequency
self.parameters['LocalRotation.frequency'] = frequency
## now program the CW dds boards
# Ok so, because we are stupid the single pass AOMs all use the -1 order
# so if we make the single pass frequency 81 MHz, we're actually driving -red-
# of the carrier by 1 MHz. Keep that in mind until we change it.
mode = gate.sideband_selection
trap_frequency = self.parameters['TrapFrequencies.' + mode]
f_global = WithUnit(80.0, 'MHz') + WithUnit(0.15, 'MHz')
freq_blue = f_global - trap_frequency - gate.detuning + gate.ac_stark_shift
freq_red = f_global + trap_frequency + gate.detuning + gate.ac_stark_shift
#print "132 debuging "
#print trap_frequency , gate.detuning, gate.ac_stark_shift
#print freq_blue
#print freq_red
amp_blue = self.parameters.MolmerSorensen.amp_blue
amp_red = self.parameters.MolmerSorensen.amp_red
self.dds_cw.frequency('0', freq_blue)
self.dds_cw.frequency('1', freq_red)
self.dds_cw.frequency('2', f_global) # for driving the carrier
self.dds_cw.amplitude('0', amp_blue)
self.dds_cw.amplitude('1', amp_red)
#self.dds_cw.amplitude('2', amp)
self.dds_cw.output('0', True)
self.dds_cw.output('1', True)
self.dds_cw.output('2', True)
self.dds_cw.output('5', True) # time to thermalize the single pass
time.sleep(1.0)
self.dds_cw.output('5', False)
time.sleep(
0.5
) # just make sure everything is programmed before starting the sequence
def setup_sequence_parameters(self):
sp = self.parameters.Sideband_tracker
center_frequency = cm.frequency_from_line_selection(
'auto', None, sp.line_selection, self.drift_tracker)
self.carrier_frequency = center_frequency
center_frequency = cm.add_sidebands(center_frequency,
sp.sideband_selection,
self.parameters.TrapFrequencies)
span, resolution, duration, amplitude = sp['sensitivity']
minim = center_frequency - span / 2.0
maxim = center_frequency + span / 2.0
steps = int(span / resolution)
self.parameters['Excitation_729.rabi_excitation_duration'] = duration
self.parameters['Excitation_729.rabi_excitation_amplitude'] = amplitude
minim = minim['MHz']
maxim = maxim['MHz']
self.scan = np.linspace(minim, maxim, steps)
self.scan = [WithUnit(pt, 'MHz') for pt in self.scan]
def run(self, cxn, context):
self.setup_data_vault()
dt = self.parameters.Sideband_tracker_ramsey
excitations = []
frequency = cm.frequency_from_line_selection('auto', None , dt.line_selection, self.drift_tracker)
frequency = frequency + dt.detuning
for iter,phase in enumerate(self.phases):
replace = TreeDict.fromdict({
'Ramsey.first_pulse_duration':dt.pi_time / 2.0,
'Ramsey.second_pulse_duration':dt.pi_time / 2.0,
'Ramsey.ramsey_time':dt.gap_time,
'Ramsey.second_pulse_phase':phase,
'Excitation_729.rabi_excitation_amplitude':dt.amplitude,
'Excitation_729.rabi_excitation_frequency':frequency,
'Tomography.iteration':0.0,
'StateReadout.use_camera_for_readout':dt.use_camera_for_readout,
'StateReadout.repeat_each_measurement':dt.readouts,
'SidebandCooling.sideband_cooling_enable':False,
'OpticalPumping.optical_pumping_enable':dt.optical_pumping_enable_DT,
})
self.excitation.set_parameters(replace)
self.update_progress(iter)
if not self.parameters.StateReadout.use_camera_for_readout:
#using PMT
excitation_array, readout = self.excitation.run(cxn, context)
excitation = excitation_array[0]
else:
primary_ion = int(self.parameters.StateReadout.camera_primary_ion)
excitation_array, readout = self.excitation.run(cxn, context)
import IPython
#IPython.embed()
excitation = excitation_array[primary_ion]
excitations.append(excitation)
print "exc"
print excitations
detuning, average_excitation = self.calculate_detuning(excitations)
corrected_frequency = frequency + detuning
# print corrected_frequency, average_excitation
return corrected_frequency,average_excitation
def load_frequency(self):
#reloads trap frequencyies and gets the latest information from the drift tracker
self.reload_some_parameters(self.trap_frequencies)
gate = self.parameters.MolmerSorensen
# set the double pass to the carrier frequency
frequency = cm.frequency_from_line_selection(gate.frequency_selection, gate.manual_frequency_729, gate.line_selection, self.drift_tracker)
#trap = self.parameters.TrapFrequencies
self.parameters['MolmerSorensen.frequency'] = frequency
self.parameters['LocalRotation.frequency'] = frequency
## now program the CW dds boards
# Ok so, because we are stupid the single pass AOMs all use the -1 order
# so if we make the single pass frequency 81 MHz, we're actually driving -red-
# of the carrier by 1 MHz. Keep that in mind until we change it.
mode = gate.sideband_selection
trap_frequency = self.parameters['TrapFrequencies.' + mode]
f_global = WithUnit(80.0, 'MHz') + WithUnit(0.15, 'MHz')
freq_blue = f_global - trap_frequency - gate.detuning + gate.ac_stark_shift
freq_red = f_global + trap_frequency + gate.detuning + gate.ac_stark_shift
#print "132 debuging "
#print trap_frequency , gate.detuning, gate.ac_stark_shift
#print freq_blue
#print freq_red
amp_blue = self.parameters.MolmerSorensen.amp_blue
amp_red = self.parameters.MolmerSorensen.amp_red
self.dds_cw.frequency('0', freq_blue)
self.dds_cw.frequency('1', freq_red)
self.dds_cw.frequency('2', f_global) # for driving the carrier
self.dds_cw.amplitude('0', amp_blue)
self.dds_cw.amplitude('1', amp_red)
#self.dds_cw.amplitude('2', amp)
self.dds_cw.output('0', True)
self.dds_cw.output('1', True)
self.dds_cw.output('2', True)
self.dds_cw.output('5', True) # time to thermalize the single pass
time.sleep(1.0)
self.dds_cw.output('5', False)
time.sleep(0.5) # just make sure everything is programmed before starting the sequence
def setup_sequence_parameters(self):
sp = self.parameters.Spectrum
if sp.scan_selection == 'manual':
minim,maxim,steps = sp.manual_scan
duration = sp.manual_excitation_time
amplitude = sp.manual_amplitude_729
elif sp.scan_selection == 'auto':
center_frequency = cm.frequency_from_line_selection(sp.scan_selection, None , sp.line_selection, self.drift_tracker)
center_frequency = cm.add_sidebands(center_frequency, sp.sideband_selection, self.parameters.TrapFrequencies)
span, resolution, duration, amplitude = sp[sp.sensitivity_selection]
minim = center_frequency - span / 2.0
maxim = center_frequency + span / 2.0
steps = int(span / resolution )
else:
raise Exception("Incorrect Spectrum Scan Type")
#making the scan
self.parameters['Excitation_729.rabi_excitation_duration'] = duration
self.parameters['Excitation_729.rabi_excitation_amplitude'] = amplitude
minim = minim['MHz']; maxim = maxim['MHz']
self.scan = np.linspace(minim,maxim, steps)
self.scan = [WithUnit(pt, 'MHz') for pt in self.scan]
def setup_sequence_parameters(self):
if self.parameters.Parity_LLI.mirror_state == True:
self.parameters['Ramsey_2ions.ion1_excitation_frequency1'] = cm.frequency_from_line_selection('auto', WithUnit(0.00, 'MHz'), 'S-1/2D-1/2', self.drift_tracker)
self.parameters['Ramsey_2ions.ion1_excitation_frequency2'] = cm.frequency_from_line_selection('auto', WithUnit(0.00, 'MHz'), 'S-1/2D-5/2', self.drift_tracker)
self.parameters['Ramsey_2ions.ion2_excitation_frequency1'] = cm.frequency_from_line_selection('auto', WithUnit(0.00, 'MHz'), 'S+1/2D+1/2', self.drift_tracker)
self.parameters['Ramsey_2ions.ion2_excitation_frequency2'] = cm.frequency_from_line_selection('auto', WithUnit(0.00, 'MHz'), 'S+1/2D+5/2', self.drift_tracker)
self.parameters['Ramsey_2ions.ion1_excitation_amplitude1'] = self.parameters['Parity_transitions.left_ionSm12Dm12_power']
self.parameters['Ramsey_2ions.ion1_excitation_amplitude2'] = self.parameters['Parity_transitions.left_ionSm12Dm52_power']
self.parameters['Ramsey_2ions.ion2_excitation_amplitude1'] = self.parameters['Parity_transitions.right_ionSp12Dp12_power']
self.parameters['Ramsey_2ions.ion2_excitation_amplitude2'] = self.parameters['Parity_transitions.right_ionSp12Dp52_power']
self.parameters['Ramsey_2ions.ion1_excitation_duration1'] = self.parameters['Parity_transitions.left_ionSm12Dm12_pi_time']/2.0
self.parameters['Ramsey_2ions.ion1_excitation_duration2'] = self.parameters['Parity_transitions.left_ionSm12Dm52_pi_time']
self.parameters['Ramsey_2ions.ion2_excitation_duration1'] = self.parameters['Parity_transitions.right_ionSp12Dp12_pi_time']/2.0
self.parameters['Ramsey_2ions.ion2_excitation_duration2'] = self.parameters['Parity_transitions.right_ionSp12Dp52_pi_time']
self.parameters['OpticalPumping.line_selection'] = 'S+1/2D-3/2'
self.parameters['OpticalPumpingAux.aux_op_line_selection'] = 'S-1/2D+3/2'
else:
self.parameters['Ramsey_2ions.ion1_excitation_frequency1'] = cm.frequency_from_line_selection('auto', WithUnit(0.00, 'MHz'), 'S+1/2D+1/2', self.drift_tracker)
self.parameters['Ramsey_2ions.ion1_excitation_frequency2'] = cm.frequency_from_line_selection('auto', WithUnit(0.00, 'MHz'), 'S+1/2D+5/2', self.drift_tracker)
self.parameters['Ramsey_2ions.ion2_excitation_frequency1'] = cm.frequency_from_line_selection('auto', WithUnit(0.00, 'MHz'), 'S-1/2D-1/2', self.drift_tracker)
self.parameters['Ramsey_2ions.ion2_excitation_frequency2'] = cm.frequency_from_line_selection('auto', WithUnit(0.00, 'MHz'), 'S-1/2D-5/2', self.drift_tracker)
self.parameters['Ramsey_2ions.ion1_excitation_amplitude1'] = self.parameters['Parity_transitions.left_ionSp12Dp12_power']
self.parameters['Ramsey_2ions.ion1_excitation_amplitude2'] = self.parameters['Parity_transitions.left_ionSp12Dp52_power']
self.parameters['Ramsey_2ions.ion2_excitation_amplitude1'] = self.parameters['Parity_transitions.right_ionSm12Dm12_power']
self.parameters['Ramsey_2ions.ion2_excitation_amplitude2'] = self.parameters['Parity_transitions.right_ionSm12Dm52_power']
self.parameters['Ramsey_2ions.ion1_excitation_duration1'] = self.parameters['Parity_transitions.left_ionSp12Dp12_pi_time']/2.0
self.parameters['Ramsey_2ions.ion1_excitation_duration2'] = self.parameters['Parity_transitions.left_ionSp12Dp52_pi_time']
self.parameters['Ramsey_2ions.ion2_excitation_duration1'] = self.parameters['Parity_transitions.right_ionSm12Dm12_pi_time']/2.0
self.parameters['Ramsey_2ions.ion2_excitation_duration2'] = self.parameters['Parity_transitions.right_ionSm12Dm52_pi_time']
self.parameters['OpticalPumping.line_selection'] = 'S-1/2D+3/2'
self.parameters['OpticalPumpingAux.aux_op_line_selection'] = 'S+1/2D-3/2'
minim,maxim,steps = self.parameters.Parity_LLI.scangap
minim = minim['us']; maxim = maxim['us']
self.scan = linspace(minim,maxim, steps)
self.scan = [WithUnit(pt, 'us') for pt in self.scan]
def load_frequency(self):
#reloads trap frequencyies and gets the latest information from the drift tracker
self.reload_some_parameters(self.trap_frequencies)
gate = self.parameters.SZX
# set the double pass to the carrier frequency
frequency = cm.frequency_from_line_selection('auto',
WithUnit(0.0, 'MHz'),
gate.line_selection,
self.drift_tracker)
self.parameters['SZX.frequency'] = frequency
self.parameters['LocalRotation.frequency'] = frequency
## now program the CW dds boards
# Ok so, because we are stupid the single pass AOMs all use the -1 order
# so if we make the single pass frequency 81 MHz, we're actually driving -red-
# of the carrier by 1 MHz. Keep that in mind until we change it.
mode = gate.sideband_selection
trap_frequency = self.parameters['TrapFrequencies.' + mode]
f_local = WithUnit(80.0, 'MHz') - WithUnit(0.2, 'MHz')
freq_blue = f_local - trap_frequency / 2. - gate.detuning + gate.ac_stark_shift
freq_red = f_local + trap_frequency / 2. + gate.ac_stark_shift
amp = WithUnit(-15., 'dBm')
amp_blue = self.parameters.SZX.amp_blue
amp_red = self.parameters.SZX.amp_red
self.dds_cw.frequency('3', freq_blue)
self.dds_cw.frequency('4', freq_red)
self.dds_cw.frequency('5', f_local) # for driving the carrier
self.dds_cw.amplitude('3', amp_blue)
self.dds_cw.amplitude('4', amp_red)
self.dds_cw.amplitude('5', amp)
self.dds_cw.output('3', True)
self.dds_cw.output('4', True)
self.dds_cw.output('5', True)
time.sleep(
0.5
) # just make sure everything is programmed before starting the sequence
def load_frequency(self, ac_stark_shift):
#reloads trap frequencyies and gets the latest information from the drift tracker
self.reload_some_parameters(self.trap_frequencies)
gate = self.parameters.SZX
# set the double pass to the carrier frequency
frequency = cm.frequency_from_line_selection(gate.frequency_selection,
gate.manual_frequency_729,
gate.line_selection,
self.drift_tracker)
#trap = self.parameters.TrapFrequencies
self.parameters['SZX.frequency'] = frequency
## now program the CW dds boards
# Ok so, because we are stupid the single pass AOMs all use the -1 order
# so if we make the single pass frequency 81 MHz, we're actually driving -red-
# of the carrier by 1 MHz. Keep that in mind until we change it.
mode = gate.sideband_selection
trap_frequency = self.parameters['TrapFrequencies.' + mode]
freq_blue = WithUnit(
80., 'MHz') - trap_frequency / 2. - gate.detuning + ac_stark_shift
freq_red = WithUnit(80., 'MHz') + trap_frequency / 2. + ac_stark_shift
amp = WithUnit(-15., 'dBm') # carrier amplitude
amp_blue = self.parameters.SZX.amp_blue
amp_red = self.parameters.SZX.amp_red
self.dds_cw.frequency('0', freq_blue)
self.dds_cw.frequency('1', freq_red)
self.dds_cw.frequency('2', WithUnit(80., 'MHz'))
self.dds_cw.amplitude('0', amp_blue)
self.dds_cw.amplitude('1', amp_red)
self.dds_cw.amplitude('2', amp)
self.dds_cw.output('0', True)
self.dds_cw.output('1', True)
self.dds_cw.output('2', True)
time.sleep(
0.5) # make sure everything is set before starting the sequence
def setup_sequence_parameters(self):
if self.parameters.Parity_LLI.mirror_state == True:
self.parameters[
'Ramsey_2ions.ion1_excitation_frequency1'] = cm.frequency_from_line_selection(
'auto', WithUnit(0.00, 'MHz'), 'S-1/2D-1/2',
self.drift_tracker)
self.parameters[
'Ramsey_2ions.ion1_excitation_frequency2'] = cm.frequency_from_line_selection(
'auto', WithUnit(0.00, 'MHz'), 'S-1/2D-5/2',
self.drift_tracker)
self.parameters[
'Ramsey_2ions.ion2_excitation_frequency1'] = cm.frequency_from_line_selection(
'auto', WithUnit(0.00, 'MHz'), 'S+1/2D+1/2',
self.drift_tracker)
self.parameters[
'Ramsey_2ions.ion2_excitation_frequency2'] = cm.frequency_from_line_selection(
'auto', WithUnit(0.00, 'MHz'), 'S+1/2D+5/2',
self.drift_tracker)
self.parameters[
'Ramsey_2ions.ion1_excitation_amplitude1'] = self.parameters[
'Parity_transitions.left_ionSm12Dm12_power']
self.parameters[
'Ramsey_2ions.ion1_excitation_amplitude2'] = self.parameters[
'Parity_transitions.left_ionSm12Dm52_power']
self.parameters[
'Ramsey_2ions.ion2_excitation_amplitude1'] = self.parameters[
'Parity_transitions.right_ionSp12Dp12_power']
self.parameters[
'Ramsey_2ions.ion2_excitation_amplitude2'] = self.parameters[
'Parity_transitions.right_ionSp12Dp52_power']
self.parameters[
'Ramsey_2ions.ion1_excitation_duration1'] = self.parameters[
'Parity_transitions.left_ionSm12Dm12_pi_time'] / 2.0
self.parameters[
'Ramsey_2ions.ion1_excitation_duration2'] = self.parameters[
'Parity_transitions.left_ionSm12Dm52_pi_time']
self.parameters[
'Ramsey_2ions.ion2_excitation_duration1'] = self.parameters[
'Parity_transitions.right_ionSp12Dp12_pi_time'] / 2.0
self.parameters[
'Ramsey_2ions.ion2_excitation_duration2'] = self.parameters[
'Parity_transitions.right_ionSp12Dp52_pi_time']
self.parameters['OpticalPumping.line_selection'] = 'S+1/2D-3/2'
self.parameters[
'OpticalPumpingAux.aux_op_line_selection'] = 'S-1/2D+3/2'
else:
self.parameters[
'Ramsey_2ions.ion1_excitation_frequency1'] = cm.frequency_from_line_selection(
'auto', WithUnit(0.00, 'MHz'), 'S+1/2D+1/2',
self.drift_tracker)
self.parameters[
'Ramsey_2ions.ion1_excitation_frequency2'] = cm.frequency_from_line_selection(
'auto', WithUnit(0.00, 'MHz'), 'S+1/2D+5/2',
self.drift_tracker)
self.parameters[
'Ramsey_2ions.ion2_excitation_frequency1'] = cm.frequency_from_line_selection(
'auto', WithUnit(0.00, 'MHz'), 'S-1/2D-1/2',
self.drift_tracker)
self.parameters[
'Ramsey_2ions.ion2_excitation_frequency2'] = cm.frequency_from_line_selection(
'auto', WithUnit(0.00, 'MHz'), 'S-1/2D-5/2',
self.drift_tracker)
self.parameters[
'Ramsey_2ions.ion1_excitation_amplitude1'] = self.parameters[
'Parity_transitions.left_ionSp12Dp12_power']
self.parameters[
'Ramsey_2ions.ion1_excitation_amplitude2'] = self.parameters[
'Parity_transitions.left_ionSp12Dp52_power']
self.parameters[
'Ramsey_2ions.ion2_excitation_amplitude1'] = self.parameters[
'Parity_transitions.right_ionSm12Dm12_power']
self.parameters[
'Ramsey_2ions.ion2_excitation_amplitude2'] = self.parameters[
'Parity_transitions.right_ionSm12Dm52_power']
self.parameters[
'Ramsey_2ions.ion1_excitation_duration1'] = self.parameters[
'Parity_transitions.left_ionSp12Dp12_pi_time'] / 2.0
self.parameters[
'Ramsey_2ions.ion1_excitation_duration2'] = self.parameters[
'Parity_transitions.left_ionSp12Dp52_pi_time']
self.parameters[
'Ramsey_2ions.ion2_excitation_duration1'] = self.parameters[
'Parity_transitions.right_ionSm12Dm12_pi_time'] / 2.0
self.parameters[
'Ramsey_2ions.ion2_excitation_duration2'] = self.parameters[
'Parity_transitions.right_ionSm12Dm52_pi_time']
self.parameters['OpticalPumping.line_selection'] = 'S-1/2D+3/2'
self.parameters[
'OpticalPumpingAux.aux_op_line_selection'] = 'S+1/2D-3/2'
self.parameters['Ramsey_2ions.ramsey_time'] = self.parameters[
'Parity_LLI.ramsey_time']
minim, maxim, steps = self.parameters.Parity_LLI.scanphase
minim = minim['deg']
maxim = maxim['deg']
self.scan = linspace(minim, maxim, steps)
self.scan = [WithUnit(pt, 'deg') for pt in self.scan]
def setup_sequence_parameters(self, phase_plus_pi):
### reload the phase ###
self.reload_some_parameters([
('Parity_LLI', 'phase_mirror_state'),
('Parity_LLI', 'phase_mirror_state_short_time'),
('Parity_LLI', 'phase_no_mirror_state_short_time'),
('Parity_LLI', 'phase_no_mirror_state'),
])
if self.parameters.Parity_LLI.mirror_state == True:
self.parameters[
'Ramsey_2ions.ion1_excitation_frequency1'] = cm.frequency_from_line_selection(
'auto', WithUnit(0.00, 'MHz'), 'S-1/2D-1/2',
self.drift_tracker)
self.parameters[
'Ramsey_2ions.ion1_excitation_frequency2'] = cm.frequency_from_line_selection(
'auto', WithUnit(0.00, 'MHz'), 'S-1/2D-5/2',
self.drift_tracker)
self.parameters[
'Ramsey_2ions.ion2_excitation_frequency1'] = cm.frequency_from_line_selection(
'auto', WithUnit(0.00, 'MHz'), 'S+1/2D+1/2',
self.drift_tracker)
self.parameters[
'Ramsey_2ions.ion2_excitation_frequency2'] = cm.frequency_from_line_selection(
'auto', WithUnit(0.00, 'MHz'), 'S+1/2D+5/2',
self.drift_tracker)
self.parameters[
'Ramsey_2ions.ion1_excitation_amplitude1'] = self.parameters[
'Parity_transitions.left_ionSm12Dm12_power']
self.parameters[
'Ramsey_2ions.ion1_excitation_amplitude2'] = self.parameters[
'Parity_transitions.left_ionSm12Dm52_power']
self.parameters[
'Ramsey_2ions.ion2_excitation_amplitude1'] = self.parameters[
'Parity_transitions.right_ionSp12Dp12_power']
self.parameters[
'Ramsey_2ions.ion2_excitation_amplitude2'] = self.parameters[
'Parity_transitions.right_ionSp12Dp52_power']
self.parameters[
'Ramsey_2ions.ion1_excitation_duration1'] = self.parameters[
'Parity_transitions.left_ionSm12Dm12_pi_time'] / 2.0
self.parameters[
'Ramsey_2ions.ion1_excitation_duration2'] = self.parameters[
'Parity_transitions.left_ionSm12Dm52_pi_time']
self.parameters[
'Ramsey_2ions.ion2_excitation_duration1'] = self.parameters[
'Parity_transitions.right_ionSp12Dp12_pi_time'] / 2.0
self.parameters[
'Ramsey_2ions.ion2_excitation_duration2'] = self.parameters[
'Parity_transitions.right_ionSp12Dp52_pi_time']
self.parameters['OpticalPumping.line_selection'] = 'S+1/2D-3/2'
self.parameters[
'OpticalPumpingAux.aux_op_line_selection'] = 'S-1/2D+3/2'
if self.parameters.Parity_LLI.use_short_ramsey_time:
self.parameters['Ramsey_2ions.ramsey_time'] = self.parameters[
'Parity_LLI.short_ramsey_time']
if phase_plus_pi:
self.parameters[
'Ramsey_2ions.ion2_excitation_phase1'] = self.parameters[
'Parity_LLI.phase_mirror_state_short_time'] + WithUnit(
180.0, 'deg')
else:
self.parameters[
'Ramsey_2ions.ion2_excitation_phase1'] = self.parameters[
'Parity_LLI.phase_mirror_state_short_time']
else:
self.parameters['Ramsey_2ions.ramsey_time'] = self.parameters[
'Parity_LLI.long_ramsey_time']
if phase_plus_pi:
self.parameters[
'Ramsey_2ions.ion2_excitation_phase1'] = self.parameters[
'Parity_LLI.phase_mirror_state'] + WithUnit(
180.0, 'deg')
else:
self.parameters[
'Ramsey_2ions.ion2_excitation_phase1'] = self.parameters[
'Parity_LLI.phase_mirror_state']
else:
self.parameters[
'Ramsey_2ions.ion1_excitation_frequency1'] = cm.frequency_from_line_selection(
'auto', WithUnit(0.00, 'MHz'), 'S+1/2D+1/2',
self.drift_tracker)
self.parameters[
'Ramsey_2ions.ion1_excitation_frequency2'] = cm.frequency_from_line_selection(
'auto', WithUnit(0.00, 'MHz'), 'S+1/2D+5/2',
self.drift_tracker)
self.parameters[
'Ramsey_2ions.ion2_excitation_frequency1'] = cm.frequency_from_line_selection(
'auto', WithUnit(0.00, 'MHz'), 'S-1/2D-1/2',
self.drift_tracker)
self.parameters[
'Ramsey_2ions.ion2_excitation_frequency2'] = cm.frequency_from_line_selection(
'auto', WithUnit(0.00, 'MHz'), 'S-1/2D-5/2',
self.drift_tracker)
self.parameters[
'Ramsey_2ions.ion1_excitation_amplitude1'] = self.parameters[
'Parity_transitions.left_ionSp12Dp12_power']
self.parameters[
'Ramsey_2ions.ion1_excitation_amplitude2'] = self.parameters[
'Parity_transitions.left_ionSp12Dp52_power']
self.parameters[
'Ramsey_2ions.ion2_excitation_amplitude1'] = self.parameters[
'Parity_transitions.right_ionSm12Dm12_power']
self.parameters[
'Ramsey_2ions.ion2_excitation_amplitude2'] = self.parameters[
'Parity_transitions.right_ionSm12Dm52_power']
self.parameters[
'Ramsey_2ions.ion1_excitation_duration1'] = self.parameters[
'Parity_transitions.left_ionSp12Dp12_pi_time'] / 2.0
self.parameters[
'Ramsey_2ions.ion1_excitation_duration2'] = self.parameters[
'Parity_transitions.left_ionSp12Dp52_pi_time']
self.parameters[
'Ramsey_2ions.ion2_excitation_duration1'] = self.parameters[
'Parity_transitions.right_ionSm12Dm12_pi_time'] / 2.0
self.parameters[
'Ramsey_2ions.ion2_excitation_duration2'] = self.parameters[
'Parity_transitions.right_ionSm12Dm52_pi_time']
self.parameters['OpticalPumping.line_selection'] = 'S-1/2D+3/2'
self.parameters[
'OpticalPumpingAux.aux_op_line_selection'] = 'S+1/2D-3/2'
if self.parameters.Parity_LLI.use_short_ramsey_time:
self.parameters['Ramsey_2ions.ramsey_time'] = self.parameters[
'Parity_LLI.short_ramsey_time']
if phase_plus_pi:
self.parameters[
'Ramsey_2ions.ion2_excitation_phase1'] = self.parameters[
'Parity_LLI.phase_no_mirror_state_short_time'] + WithUnit(
180.0, 'deg')
else:
self.parameters[
'Ramsey_2ions.ion2_excitation_phase1'] = self.parameters[
'Parity_LLI.phase_no_mirror_state_short_time']
else:
self.parameters['Ramsey_2ions.ramsey_time'] = self.parameters[
'Parity_LLI.long_ramsey_time']
if phase_plus_pi:
self.parameters[
'Ramsey_2ions.ion2_excitation_phase1'] = self.parameters[
'Parity_LLI.phase_no_mirror_state'] + WithUnit(
180.0, 'deg')
else:
self.parameters[
'Ramsey_2ions.ion2_excitation_phase1'] = self.parameters[
'Parity_LLI.phase_no_mirror_state']
def lookup_frequency(self, line_selection, sideband_selection):
frequency = cm.frequency_from_line_selection('auto', None, line_selection, self.drift_tracker)
frequency = cm.add_sidebands(frequency, sideband_selection, self.parameters.TrapFrequencies)
return frequency
