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):
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):
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):
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):
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):
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 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)
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):
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 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_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 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):
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)
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 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):
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):
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):
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
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.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 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
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 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]
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 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
