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):
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 'Displaced 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 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):
r = self.parameters.Ramsey
flop = self.parameters.RabiFlopping
blue_frequency = cm.frequency_from_line_selection(r.frequency_selection, r.ladder_blue_manual_frequency729, r.ladder_blue_line_selection, self.drift_tracker)
red_frequency = cm.frequency_from_line_selection(r.frequency_selection, r.ladder_red_manual_frequency729, r.ladder_red_line_selection, self.drift_tracker)
trap = self.parameters.TrapFrequencies
if r.frequency_selection == 'auto':
blue_frequency = cm.add_sidebands(blue_frequency, r.ladder_blue_sideband_selection, trap)
red_frequency = cm.add_sidebands(red_frequency, r.ladder_red_sideband_selection, trap)
self.parameters['Ramsey.ladder_blue_frequency'] = blue_frequency
self.parameters['Ramsey.ladder_red_frequency'] = red_frequency
# self.parameters['Excitation_729.rabi_excitation_amplitude'] = flop.rabi_amplitude_729
rp = self.parameters.Rotation
frequency_ramp_time = rp.frequency_ramp_time
start_hold = rp.start_hold
ramp_down_time = rp.ramp_down_time
start_phase = rp.start_phase
middle_hold = rp.middle_hold
end_hold = rp.end_hold
voltage_pp = rp.voltage_pp
drive_frequency = rp.drive_frequency
self.awg_rotation.program_awf(start_phase['deg'],start_hold['ms'],frequency_ramp_time['ms'],middle_hold['ms'],ramp_down_time['ms'],end_hold['ms'],voltage_pp['V'],drive_frequency['kHz'],'free_rotation_sin_spin')
#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 setup_sequence_parameters(self):
r = self.parameters.Ramsey
flop = self.parameters.RabiFlopping
first_pulse_frequency = cm.frequency_from_line_selection(r.frequency_selection, r.first_pulse_manual_frequency_729, r.first_pulse_line, self.drift_tracker)
second_pulse_frequency = cm.frequency_from_line_selection(r.frequency_selection, r.second_pulse_manual_frequency_729, r.second_pulse_line, self.drift_tracker)
trap = self.parameters.TrapFrequencies
if r.frequency_selection == 'auto':
first_pulse_frequency = cm.add_sidebands(first_pulse_frequency, r.first_pulse_sideband_selection, trap)
second_pulse_frequency = cm.add_sidebands(second_pulse_frequency, r.second_pulse_sideband_selection, trap)
self.parameters['Ramsey.second_pulse_frequency'] = second_pulse_frequency
self.parameters['Ramsey.first_pulse_frequency'] = first_pulse_frequency
self.parameters['Excitation_729.rabi_excitation_amplitude'] = flop.rabi_amplitude_729
r = self.parameters.Ramsey
echo_frequency = cm.frequency_from_line_selection(r.echo_frequency_selection, r.echo_manual_frequency_729, r.echo_line_selection, self.drift_tracker)
trap = self.parameters.TrapFrequencies
if r.frequency_selection == 'auto':
echo_frequency = cm.add_sidebands(echo_frequency, r.echo_sideband_selection, trap)
self.parameters['Ramsey.echo_frequency'] = echo_frequency
#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 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
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 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 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
self.carrier_frequency = WithUnit(0.0, 'MHz')
elif sp.scan_selection == 'auto':
center_frequency = cm.frequency_from_line_selection(sp.scan_selection, 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[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]
old_freq = self.pv.get_parameter('RotationCW','drive_frequency')['kHz']
old_phase = self.pv.get_parameter('RotationCW','start_phase')['deg']
old_amp =self.pv.get_parameter('RotationCW','voltage_pp')['V']
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 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.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 + ac_stark_shift
freq_red = f_global + trap_frequency + gate.detuning + 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)
#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 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??
#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):
r = self.parameters.Ramsey
flop = self.parameters.RabiFlopping
carrier_frequency = cm.frequency_from_line_selection(r.frequency_selection, r.ramsey_manual_frequency_729, r.ramsey_line, self.drift_tracker)
self.parameters['Ramsey.carrier_frequency'] = carrier_frequency
trap = self.parameters.TrapFrequencies
first_order_frequency = cm.add_sidebands(carrier_frequency, [0,0,0,0,1], trap)
self.parameters['Ramsey.first_order_frequency'] = first_order_frequency
second_order_frequency = cm.add_sidebands(carrier_frequency, [0,0,0,0,2], trap)
self.parameters['Ramsey.second_order_frequency'] = second_order_frequency
rp = self.parameters.Rotation
frequency_ramp_time = rp.frequency_ramp_time
start_hold = rp.start_hold
ramp_down_time = rp.ramp_down_time
start_phase = rp.start_phase
middle_hold = rp.middle_hold
end_hold = rp.end_hold
voltage_pp = rp.voltage_pp
drive_frequency = rp.drive_frequency
self.awg_rotation.program_awf(start_phase['deg'],start_hold['ms'],frequency_ramp_time['ms'],middle_hold['ms'],ramp_down_time['ms'],end_hold['ms'],voltage_pp['V'],drive_frequency['kHz'],'free_rotation_sin_spin')
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):
#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_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]
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
self.carrier_frequency = WithUnit(0.0, 'MHz')
elif sp.scan_selection == 'auto':
center_frequency = cm.frequency_from_line_selection(sp.scan_selection, 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[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 #these are overwritten later before they are used. How do you fix that...###!!!!!!!!!!!
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):
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):
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 setup_sequence_parameters(self):
r = self.parameters.Ramsey
flop = self.parameters.RabiFlopping
first_pulse_frequency = cm.frequency_from_line_selection(r.frequency_selection, r.first_pulse_manual_frequency_729, r.first_pulse_line, self.drift_tracker)
second_pulse_frequency = cm.frequency_from_line_selection(r.frequency_selection, r.second_pulse_manual_frequency_729, r.second_pulse_line, self.drift_tracker)
trap = self.parameters.TrapFrequencies
if r.frequency_selection == 'auto':
first_pulse_frequency = cm.add_sidebands(first_pulse_frequency, r.first_pulse_sideband_selection, trap)
second_pulse_frequency = cm.add_sidebands(second_pulse_frequency, r.second_pulse_sideband_selection, trap)
first_pulse_frequency += self.parameters.RamseyScanGap.detuning
second_pulse_frequency += self.parameters.RamseyScanGap.detuning
self.parameters['Ramsey.second_pulse_frequency'] = second_pulse_frequency
self.parameters['Ramsey.first_pulse_frequency'] = first_pulse_frequency
self.parameters['Excitation_729.rabi_excitation_amplitude'] = flop.rabi_amplitude_729
rp = self.parameters.Rotation
frequency_ramp_time = rp.frequency_ramp_time
start_hold = rp.start_hold
ramp_down_time = rp.ramp_down_time
start_phase = rp.start_phase
middle_hold = rp.middle_hold
end_hold = rp.end_hold
voltage_pp = rp.voltage_pp
drive_frequency = rp.drive_frequency
self.awg_rotation.program_awf(start_phase['deg'],start_hold['ms'],frequency_ramp_time['ms'],middle_hold['ms'],ramp_down_time['ms'],end_hold['ms'],voltage_pp['V'],drive_frequency['kHz'],'free_rotation')
r = self.parameters.Ramsey
echo_frequency = cm.frequency_from_line_selection(r.echo_frequency_selection, r.echo_manual_frequency_729, r.echo_line_selection, self.drift_tracker)
trap = self.parameters.TrapFrequencies
if r.frequency_selection == 'auto':
echo_frequency = cm.add_sidebands(echo_frequency, r.echo_sideband_selection, trap)
self.parameters['Ramsey.echo_frequency'] = echo_frequency
# 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.Ramsey.scan_echo_offset
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 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_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 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_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', False)
time.sleep(
0.1) # make sure everything is set before starting the sequence
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 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 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 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)
trap = self.parameters.TrapFrequencies
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
#print "sbc"
#print 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
#print 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 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):
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
r = self.parameters.Ramsey
echo_frequency = cm.frequency_from_line_selection(r.echo_frequency_selection, r.echo_manual_frequency_729, r.echo_line_selection, self.drift_tracker)
trap = self.parameters.TrapFrequencies
if r.frequency_selection == 'auto':
echo_frequency = cm.add_sidebands(echo_frequency, r.echo_sideband_selection, trap)
self.parameters['Ramsey.echo_frequency'] = echo_frequency
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 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):
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.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 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):
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)
import IPython
IPython.embed()
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,
sc.sideband_cooling_enable)
sc2freq = cm.add_sidebands(sc2freq, sc2.sideband_selection, trap)
self.parameters['SequentialSBCooling.frequency'] = sc2freq
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
self.carrier_frequency = WithUnit(0.0, 'MHz')
elif sp.scan_selection == 'auto':
center_frequency = cm.frequency_from_line_selection(sp.scan_selection, 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[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]
#set up the timing of the rotation awf
rp = self.parameters.Rotation
frequency_ramp_time = rp.frequency_ramp_time
if self.parameters.StatePreparation.sideband_cooling_enable:
sideband_cooling_time = 2*(self.parameters.SidebandCooling.sideband_cooling_optical_pumping_duration + self.parameters.SidebandCoolingContinuous.sideband_cooling_continuous_duration)*self.parameters.SidebandCooling.sideband_cooling_cycles + WithUnit(1.0,'ms')
else:
sideband_cooling_time = WithUnit(0,'ms')
start_hold = rp.start_hold
#start_hold = rp.start_hold
#ramp_down_time = rp.ramp_down_time
start_phase = rp.start_phase
middle_hold = rp.middle_hold
end_hold = self.parameters.StateReadout.pmt_readout_duration
#end_hold = rp.end_hold
voltage_pp = rp.voltage_pp
drive_frequency = rp.drive_frequency
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')
self.parameters['Heating.background_heating_time'] = 2*frequency_ramp_time + middle_hold + WithUnit(1.0, 'ms')
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 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):
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
self.carrier_frequency = WithUnit(0.0, 'MHz')
elif sp.scan_selection == 'auto':
center_frequency = cm.frequency_from_line_selection(
sp.scan_selection, 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[
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]
rp = self.parameters.Rotation
start_hold = rp.start_hold
freq_ramp_time = rp.frequency_ramp_time
amplitude_ramp_time = rp.amplitude_ramp_time
end_hold = rp.end_hold
voltage_pp = rp.voltage_pp
frequency = rp.frequency
self.awg.program_awf(start_hold['ms'], freq_ramp_time['ms'],
amplitude_ramp_time['ms'], end_hold['ms'],
voltage_pp['V'], frequency['kHz'])
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 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, 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 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]
