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):
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)
self.parameters['OpticalPumping.optical_pumping_frequency_729'] = optical_pumping_frequency
sc = self.parameters.SidebandCooling
sp = self.parameters.SidebandPrecooling
sideband_cooling_frequency = cm.frequency_from_line_selection(sc.frequency_selection, sc.manual_frequency_729, sc.line_selection, self.drift_tracker)
# always want to precool on the same line as sideband cooling
sideband_precooling_frequency = cm.frequency_from_line_selection(sp.frequency_selection, sp.manual_frequency_729, sc.line_selection, self.drift_tracker)
if sc.frequency_selection == 'auto':
trap = self.parameters.TrapFrequencies
sideband_cooling_frequency = cm.add_sidebands(sideband_cooling_frequency, sc.sideband_selection, trap)
sideband_precooling_frequency = cm.add_sidebands(sideband_precooling_frequency, sp.sideband_selection, trap)
self.parameters['SidebandCooling.sideband_cooling_frequency_729'] = sideband_cooling_frequency
self.parameters['SidebandPrecooling.sideband_precooling_frequency_729'] = sideband_precooling_frequency
def run(self, cxn, context):
self.setup_data_vault()
dt = self.parameters.DriftTrackerRamsey
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.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)
excitation = excitation_array[primary_ion]
excitations.append(excitation)
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):
coupling = self.parameters.ParametricCoupling
piPulse = self.parameters.PiPulse
flop = self.parameters.RabiFlopping
analysis_frequency = cm.frequency_from_line_selection(flop.frequency_selection, flop.manual_frequency_729, flop.line_selection, self.drift_tracker)
pi_frequency = cm.frequency_from_line_selection('auto', flop.manual_frequency_729, flop.line_selection, self.drift_tracker) # do pi pulse on same line as rabi flop
trap = self.parameters.TrapFrequencies
if flop.frequency_selection == 'auto':
analysis_frequency = cm.add_sidebands(analysis_frequency, flop.sideband_selection, trap)
pi_frequency = cm.add_sidebands(pi_frequency, piPulse.sideband_selection, trap)
self.parameters['Excitation_729.rabi_excitation_frequency'] = analysis_frequency + flop.offset_frequency
self.parameters['Excitation_729.rabi_excitation_amplitude'] = flop.rabi_amplitude_729
self.parameters['PiPulse.rabi_excitation_frequency'] = pi_frequency
minim,maxim,steps = coupling.manual_scan
minim = minim['us']; maxim = maxim['us']
self.scan = linspace(minim,maxim, steps)
self.scan = [WithUnit(pt, 'us') for pt in self.scan]
def load_frequency(self):
#reloads trap frequencyies and gets the latest information from the drift tracker
self.reload_some_parameters(self.trap_frequencies)
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):
flop = self.parameters.Ramsey2ions_ScanGapParity
trap = self.parameters.TrapFrequencies
excitation_frequency = cm.frequency_from_line_selection('auto', WithUnit(0.00, 'MHz'), flop.line_selection, self.drift_tracker)
excitation_frequency = cm.add_sidebands(ion1_frequency1, flop.ion1_sideband_selection, trap)
print excitaton_frequency
self.parameters['Ramsey_2ions.excitation_frequency'] = excitaton_frequency
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
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):
sp = self.parameters.Sideband_tracker
center_frequency = cm.frequency_from_line_selection('auto', None , sp.line_selection, self.drift_tracker)
self.carrier_frequency = center_frequency
center_frequency = cm.add_sidebands(center_frequency, sp.sideband_selection, self.parameters.TrapFrequencies)
span, resolution, duration, amplitude = sp['sensitivity']
minim = center_frequency - span / 2.0
maxim = center_frequency + span / 2.0
steps = int(span / resolution )
self.parameters['Excitation_729.rabi_excitation_duration'] = duration
self.parameters['Excitation_729.rabi_excitation_amplitude'] = amplitude
minim = minim['MHz']; maxim = maxim['MHz']
self.scan = np.linspace(minim,maxim, steps)
self.scan = [WithUnit(pt, 'MHz') for pt in self.scan]
def setup_sequence_parameters(self):
flop = self.parameters.RabiFlopping
frequency = cm.frequency_from_line_selection(flop.frequency_selection, flop.manual_frequency_729, flop.line_selection, self.drift_tracker)
trap = self.parameters.TrapFrequencies
if flop.frequency_selection == 'auto':
frequency = cm.add_sidebands(frequency, flop.sideband_selection, trap)
frequency += self.parameters.RamseyScanGap.detuning
print self.parameters.Ramsey.rabi_pi_time
self.parameters['Excitation_729.rabi_excitation_frequency'] = frequency
self.parameters['Excitation_729.rabi_excitation_amplitude'] = flop.rabi_amplitude_729
self.parameters['Ramsey.first_pulse_duration'] = self.parameters.Ramsey.rabi_pi_time / 2.0
self.parameters['Ramsey.second_pulse_duration'] = self.parameters.Ramsey.rabi_pi_time / 2.0
minim,maxim,steps = self.parameters.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.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]
