Python TreeDict.fromdict方法代码示例

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import fromdict [as 别名]
    def sequence(self):
        r = self.parameters.Ramsey
        p = self.parameters.Excitation_729
        
        # Add the 6 us waits manually here before starting the ladder sequence
        frequency_advance_duration = WithUnit(6, 'us')
        ampl_off = WithUnit(-63.0, 'dBm')
        self.addDDS(r.ladder_blue_channel_729, self.start,                            frequency_advance_duration, r.ladder_blue_frequency, ampl_off)
        self.addDDS(r.ladder_red_channel_729,  self.start+frequency_advance_duration, frequency_advance_duration, r.ladder_red_frequency, ampl_off)
        ramsey_start = self.start+WithUnit(12, 'us')

        # First set of pulses
        self.addSequence(ladder_excitation_no_offset, position=ramsey_start)

        # Set of echo pulses
        if r.spin_echo_enable:
            # First calculate how much time the echo pulses will take
            n_blue_pulses = r.ladder_number_pi_steps + ((r.ladder_number_pi_steps+1)%2)
            n_red_pulses = r.ladder_number_pi_steps + (r.ladder_number_pi_steps%2)
            echo_time = n_blue_pulses*r.ladder_blue_pi_duration + n_red_pulses*r.ladder_red_pi_duration

            # Now add the pulses. Wait times will have half the echo time subtracted off.
            self.addSequence(empty_sequence, TreeDict.fromdict({'EmptySequence.empty_sequence_duration':(r.ramsey_time-echo_time)/2}))
            self.addSequence(ladder_excitation_reverse_no_offset, TreeDict.fromdict({'Ramsey.second_pulse_phase':WithUnit(0, 'deg')})) #There should be no extra phase on this pulse since it's just supposed to be the echo
            self.addSequence(ladder_excitation_no_offset)
            self.addSequence(empty_sequence, TreeDict.fromdict({'EmptySequence.empty_sequence_duration':(r.ramsey_time-echo_time)/2}))
        else:
            self.addSequence(empty_sequence, TreeDict.fromdict({'EmptySequence.empty_sequence_duration':r.ramsey_time}))
        
        # Final set of pulses
        self.addSequence(ladder_excitation_reverse_no_offset)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import fromdict [as 别名]
 def sequence(self):
     op = self.parameters.OpticalPumping
     
     if op.optical_pumping_type == 'continuous':
         continuous = True
     elif op.optical_pumping_type == 'pulsed':
         continuous = False
     else:
         raise Exception ('Incorrect optical pumping type {0}'.format(op.optical_pumping_type))
     if continuous:
         replace = {
                    'OpticalPumpingContinuous.optical_pumping_continuous_frequency_854':op.optical_pumping_frequency_854,
                    'OpticalPumpingContinuous.optical_pumping_continuous_amplitude_854':op.optical_pumping_amplitude_854,
                    'OpticalPumpingContinuous.optical_pumping_continuous_frequency_729':op.optical_pumping_frequency_729,
                    'OpticalPumpingContinuous.optical_pumping_continuous_amplitude_729':op.optical_pumping_amplitude_729,
                    'OpticalPumpingContinuous.optical_pumping_continuous_frequency_866':op.optical_pumping_frequency_866,
                    'OpticalPumpingContinuous.optical_pumping_continuous_amplitude_866':op.optical_pumping_amplitude_866,
                    }
         self.addSequence(optical_pumping_continuous, TreeDict.fromdict(replace))
     else:
         #pulsed
         replace = {
                    'OpticalPumpingPulsed.optical_pumping_pulsed_frequency_854':op.optical_pumping_frequency_854,
                    'OpticalPumpingPulsed.optical_pumping_pulsed_amplitude_854':op.optical_pumping_amplitude_854,
                    'OpticalPumpingPulsed.optical_pumping_pulsed_frequency_729':op.optical_pumping_frequency_729,
                    'OpticalPumpingPulsed.optical_pumping_pulsed_amplitude_729':op.optical_pumping_amplitude_729,
                    'OpticalPumpingPulsed.optical_pumping_pulsed_frequency_866':op.optical_pumping_frequency_866,
                    'OpticalPumpingPulsed.optical_pumping_pulsed_amplitude_866':op.optical_pumping_amplitude_866,
                    }
         self.addSequence(optical_pumping_pulsed, TreeDict.fromdict(replace))

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import fromdict [as 别名]
    def sequence(self):
        r = self.parameters.Ramsey
        
        # First ramsey pulse
        replace = TreeDict.fromdict({
                                     'Excitation_729.rabi_excitation_duration':r.first_pulse_duration,
                                     'Excitation_729.rabi_excitation_phase':WithUnit(0, 'deg'),
                                     'Excitation_729.channel_729':r.channel_729,
                                     })
        self.addSequence(rabi_excitation, replace)

        # EIT Cooling
        replace = TreeDict.fromdict({
                           'EitCooling.eit_cooling_amplitude_397_linear':WithUnit(-63.0, 'dBm'),
                           'EitCooling.eit_cooling_duration':r.ramsey_time
                           })
        self.addSequence(eit_cooling, replace)

        # Second ramsey pulse
        replace = TreeDict.fromdict({
                             'Excitation_729.rabi_excitation_duration':r.second_pulse_duration,
                             'Excitation_729.rabi_excitation_phase':r.second_pulse_phase,
                             'Excitation_729.channel_729':r.channel_729,
                             })
        self.addSequence(rabi_excitation_no_offset, replace)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import fromdict [as 别名]
    def sequence(self):
        p = self.parameters
        self.end = WithUnit(10, 'us')

        self.addSequence(turn_off_all)
        
        self.addSequence(repump_d)
        
        self.addSequence(rabi_excitation_select_channel)
        
        self.addSequence(state_readout)        
        
        self.addSequence(empty_sequence, TreeDict.fromdict({'EmptySequence.empty_sequence_duration':WithUnit(10,'ms')})) ##state readout has 2ms hangover.  It shouldn't. Ask Dylan
        
        self.addSequence(doppler_cooling)
        if p.OpticalPumping.optical_pumping_enable:
            self.addSequence(optical_pumping)
        if p.SidebandCooling.sideband_cooling_enable:
            self.addSequence(sideband_cooling)

        self.addSequence(ramp_voltage)

        self.addSequence(empty_sequence, TreeDict.fromdict({'EmptySequence.empty_sequence_duration':p.Heating.background_heating_time}))
        
        self.addSequence(empty_sequence, TreeDict.fromdict({'EmptySequence.empty_sequence_duration':WithUnit(1,'us')}))
        
        self.addSequence(ramp_voltage)

        self.addSequence(state_readout)
        
        self.addSequence(reset_dac)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import fromdict [as 别名]
 def sequence(self):
     p = self.parameters
     self.end = WithUnit(10, 'us')
     self.addSequence(turn_off_all)
     if p.DopplerCooling.mode_swapping_enable:
         self.addSequence(doppler_cooling_with_mode_coupling)
     else:
         self.addSequence(doppler_cooling_after_repump_d)
     if p.OpticalPumping.optical_pumping_enable:
         self.addSequence(optical_pumping)
     if p.SidebandCooling.sideband_cooling_enable:
         if p.SidebandPrecooling.sideband_precooling_enable:
             self.addSequence(sideband_precooling)
         self.addSequence(sideband_cooling)
     if p.PulsedHeating.pulsed_heating_enable:
         #self.addSequence(pulsed_heating)
         self.addSequence(pi_pulse)
         self.addSequence(repump_d)
         self.addSequence(optical_pumping)
     if p.ParametricCoupling.parametric_coupling_enable:
         self.addSequence(parametric_coupling, TreeDict.fromdict({'ParametricCoupling.parametric_coupling_phase':WithUnit(0, 'deg')}))
     if p.WireCharging.wire_charging_enable:
         self.addSequence(wire_charging, TreeDict.fromdict({'EmptySequence.empty_sequence_duration':p.WireCharging.wire_charging_duration}))
     self.addSequence(empty_sequence, TreeDict.fromdict({'EmptySequence.empty_sequence_duration':p.Heating.background_heating_time}))
     if p.ParametricCoupling.swap_after_heating:
         self.addSequence(parametric_coupling, TreeDict.fromdict({'ParametricCoupling.drive_frequency': p.ParametricCoupling.drive_frequency}))
     self.start_excitation_729 = self.end
     self.addSequence(rabi_excitation)
     self.addSequence(state_readout)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import fromdict [as 别名]
    def sequence(self):
        r = self.parameters.Ramsey
        replace = TreeDict.fromdict({
                                     'Excitation_729.rabi_excitation_duration':r.first_pulse_duration,
                                     'Excitation_729.rabi_excitation_phase':WithUnit(0, 'deg'),
                                     'Excitation_729.channel_729':r.channel_729,
                                     'Excitation_729.rabi_excitation_frequency':r.first_pulse_frequency
                                     }) 
        awg_wait_time = WithUnit(2,'ms')

        self.addTTL('awg_off',self.start,awg_wait_time+r.ramsey_time+r.first_pulse_duration+r.second_pulse_duration)
        #self.addTTL('awg_on',self.start,awg_wait_time+r.ramsey_time+r.first_pulse_duration+r.second_pulse_duration)
        self.addSequence(empty_sequence, TreeDict.fromdict({'EmptySequence.empty_sequence_duration':awg_wait_time}))
        self.addSequence(rabi_excitation, replace)
        if r.spin_echo_enable:
          self.addSequence(empty_sequence_with_echo, TreeDict.fromdict({'EmptySequence.empty_sequence_duration':r.ramsey_time}))
        else:
          self.addSequence(empty_sequence, TreeDict.fromdict({'EmptySequence.empty_sequence_duration':r.ramsey_time}))
        #self.addDDS('radial', self.end, r.ramsey_time, WithUnit(220.0,'MHz'), WithUnit(-13.0,'dBm'))
        #self.end = self.end + r.ramsey_time
        replace = TreeDict.fromdict({
                             'Excitation_729.rabi_excitation_duration':r.second_pulse_duration,
                             'Excitation_729.rabi_excitation_phase':r.second_pulse_phase,
                             'Excitation_729.channel_729':r.channel_729,
                             'Excitation_729.rabi_excitation_frequency':r.second_pulse_frequency
                             })
        self.addSequence(rabi_excitation_no_offset, replace)
        # self.addSequence(rabi_excitation_no_offset, replace) #this is technically correct but can't do pulses shorter than 6us
        # print(r.first_pulse_frequency,r.second_pulse_frequency,r.first_pulse_frequency-r.second_pulse_frequency)
        # print(r.second_pulse_duration,r.first_pulse_duration)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import fromdict [as 别名]
    def run(self, cxn, context):
        dt = self.parameters.DriftTracker
        ramsey_dt = self.parameters.DriftTrackerRamsey
        if dt.line_selection_1 == dt.line_selection_2:
            raise Exception ("The two Drift Tracking lines can not be the same")
        replace_1 = TreeDict.fromdict({
                                       'DriftTrackerRamsey.line_selection':dt.line_selection_1,
                                       'DriftTrackerRamsey.pi_time':ramsey_dt.line_1_pi_time,
                                       'DriftTrackerRamsey.amplitude':ramsey_dt.line_1_amplitude,
                                       'DriftTrackerRamsey.detuning':WithUnit(0,'Hz'),
                                       })
        replace_2 = TreeDict.fromdict({
                                       'DriftTrackerRamsey.line_selection':dt.line_selection_2,
                                       'DriftTrackerRamsey.pi_time':ramsey_dt.line_2_pi_time,
                                       'DriftTrackerRamsey.amplitude':ramsey_dt.line_2_amplitude,
                                       'DriftTrackerRamsey.detuning':WithUnit(0,'Hz')
                                       })
        

        self.ramsey_dt.set_parameters(replace_1)
        self.ramsey_dt.set_progress_limits(0, 50.0)
        frequency_1,excitation = self.ramsey_dt.run(cxn, context)
        self.ramsey_dt.set_parameters(replace_2)
        self.ramsey_dt.set_progress_limits(50.0, 100.0)
        frequency_2,excitation = self.ramsey_dt.run(cxn, context)
        self.submit_centers(frequency_1, frequency_2)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import fromdict [as 别名]
 def run(self, cxn, context):
     replace_no_mirror = TreeDict.fromdict({
                                    'Parity_LLI.mirror_state':False,
                                    'Parity_LLI.use_short_ramsey_time':False,
                                    })
     replace_mirror = TreeDict.fromdict({
                                    'Parity_LLI.mirror_state':True,
                                    'Parity_LLI.use_short_ramsey_time':False,
                                    })
     random_number = np.random.rand()
     
     if (random_number>0.5):
         self.parity_LLI.set_parameters(replace_no_mirror)
         phase_no_mirror = self.parity_LLI.run(cxn, context)
         self.parity_LLI.set_parameters(replace_mirror)
         phase_mirror = self.parity_LLI.run(cxn, context)
     else:
         self.parity_LLI.set_parameters(replace_mirror)
         phase_mirror = self.parity_LLI.run(cxn, context)            
         self.parity_LLI.set_parameters(replace_no_mirror)
         phase_no_mirror = self.parity_LLI.run(cxn, context)  
               
     average_phase = (phase_no_mirror+phase_mirror)/2.0
     difference_phase = (phase_no_mirror-phase_mirror)/2.0
     submission = [time.time(),phase_mirror['deg'],phase_no_mirror['deg'],average_phase['deg'],difference_phase['deg']]
     self.dv.add(submission,context=self.save_data)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import fromdict [as 别名]
    def setup_scan(self, sideband):

        if sideband == 'blue':
                       
            replace = TreeDict.fromdict({
                    'Spectrum.sensitivity_selection':'temperature',
                    'Spectrum.scan_selection':'auto',
                    'Spectrum.sideband_selection':self.bsb_sel,
                    'Spectrum.save_directory': self.bsb_scan_dir,
                    'Spectrum.dataset_name_append':self.datasetNameAppend,
                    'Spectrum.window_name': ['Blue sideband scan']
                    })

            self.spectrum.set_parameters(replace)

        elif sideband == 'red':
            temp = self.parameters.Temperature

            replace = TreeDict.fromdict({
                    'Spectrum.sensitivity_selection': 'temperature',
                    'Spectrum.scan_selection': 'auto',
                    'Spectrum.sideband_selection':self.rsb_sel,
                    'Spectrum.save_directory': self.rsb_scan_dir,
                    'Spectrum.dataset_name_append': self.datasetNameAppend,
                    'Spectrum.window_name': ['Red sideband scan']
                    })

            self.spectrum.set_parameters(replace)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import fromdict [as 别名]
 def run(self, cxn, context):
     dt = self.parameters.DriftTracker
     ramsey_dt = self.parameters.DriftTrackerRamsey
     if dt.line_selection_1 == dt.line_selection_2:
         raise Exception ("The two Drift Tracking lines can not be the same")
     replace_1 = TreeDict.fromdict({
                                    'DriftTrackerRamsey.line_selection':dt.line_selection_1,
                                    'DriftTrackerRamsey.pi_time':ramsey_dt.line_1_pi_time,
                                    'DriftTrackerRamsey.amplitude':ramsey_dt.line_1_amplitude,
                                    'DriftTrackerRamsey.detuning':WithUnit(0,'Hz'),
                                    })
     replace_2 = TreeDict.fromdict({
                                    'DriftTrackerRamsey.line_selection':dt.line_selection_2,
                                    'DriftTrackerRamsey.pi_time':ramsey_dt.line_2_pi_time,
                                    'DriftTrackerRamsey.amplitude':ramsey_dt.line_2_amplitude,
                                    'DriftTrackerRamsey.detuning':WithUnit(0,'Hz')
                                    })
     
     replace_1,replace_2 = np.random.permutation([replace_1,replace_2])
     self.ramsey_dt.set_parameters(replace_1)
     self.ramsey_dt.set_progress_limits(0, 50.0)
     frequency_1,excitation = self.ramsey_dt.run(cxn, context)
     error_sensitivity = ramsey_dt.error_sensitivity
     if not 0.5 - error_sensitivity <= excitation <= 0.5 + error_sensitivity:
         raise Exception("Incorrect Excitation {}".format(replace_1.DriftTrackerRamsey.line_selection)) 
     self.ramsey_dt.set_parameters(replace_2)
     self.ramsey_dt.set_progress_limits(50.0, 100.0)
     frequency_2,excitation = self.ramsey_dt.run(cxn, context)
     if not 0.5 - error_sensitivity <= excitation <= 0.5 + error_sensitivity:
         raise Exception("Incorrect Excitation {}".format(replace_2.DriftTrackerRamsey.line_selection)) 
     self.submit_centers(replace_1,frequency_1,replace_2,frequency_2)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import fromdict [as 别名]
 def sequence(self):
     t = self.parameters.Tomography
     iteration = int(t.iteration)
     print "iteration"
     print iteration
     if not iteration in range(3):
         raise Exception("Incorrect iteration of tomography {}".format(iteration))
     if iteration == 0:
         pass
     elif iteration == 1:
         replace = TreeDict.fromdict(
             {
                 "Excitation_729.rabi_excitation_frequency": t.tomography_excitation_frequency,
                 "Excitation_729.rabi_excitation_amplitude": t.tomography_excitation_amplitude,
                 "Excitation_729.rabi_excitation_duration": t.rabi_pi_time / 2.0,
                 "Excitation_729.rabi_excitation_phase": WithUnit(0, "deg"),
             }
         )
         self.addSequence(rabi_excitation, replace)
     elif iteration == 2:
         replace = TreeDict.fromdict(
             {
                 "Excitation_729.rabi_excitation_frequency": t.tomography_excitation_frequency,
                 "Excitation_729.rabi_excitation_amplitude": t.tomography_excitation_amplitude,
                 "Excitation_729.rabi_excitation_duration": t.rabi_pi_time / 2.0,
                 "Excitation_729.rabi_excitation_phase": WithUnit(90, "deg"),
             }
         )
         self.addSequence(rabi_excitation, replace)

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import fromdict [as 别名]
    def sequence(self):
        op = self.parameters.OpticalPumping

        if op.optical_pumping_type == "continuous":
            continuous = True
        elif op.optical_pumping_type == "pulsed":
            continuous = False
        else:
            raise Exception("Incorrect optical pumping type {0}".format(op.optical_pumping_type))
        if continuous:
            replace = {
                "OpticalPumpingContinuous.optical_pumping_continuous_frequency_854": op.optical_pumping_frequency_854,
                "OpticalPumpingContinuous.optical_pumping_continuous_amplitude_854": op.optical_pumping_amplitude_854,
                "OpticalPumpingContinuous.optical_pumping_continuous_frequency_729": op.optical_pumping_frequency_729,
                "OpticalPumpingContinuous.optical_pumping_continuous_amplitude_729": op.optical_pumping_amplitude_729,
                "OpticalPumpingContinuous.optical_pumping_continuous_frequency_866": op.optical_pumping_frequency_866,
                "OpticalPumpingContinuous.optical_pumping_continuous_amplitude_866": op.optical_pumping_amplitude_866,
            }
            self.addSequence(optical_pumping_continuous, TreeDict.fromdict(replace))
        else:
            # pulsed
            replace = {
                "OpticalPumpingPulsed.optical_pumping_pulsed_frequency_854": op.optical_pumping_frequency_854,
                "OpticalPumpingPulsed.optical_pumping_pulsed_amplitude_854": op.optical_pumping_amplitude_854,
                "OpticalPumpingPulsed.optical_pumping_pulsed_frequency_729": op.optical_pumping_frequency_729,
                "OpticalPumpingPulsed.optical_pumping_pulsed_amplitude_729": op.optical_pumping_amplitude_729,
                "OpticalPumpingPulsed.optical_pumping_pulsed_frequency_866": op.optical_pumping_frequency_866,
                "OpticalPumpingPulsed.optical_pumping_pulsed_amplitude_866": op.optical_pumping_amplitude_866,
            }
            self.addSequence(optical_pumping_pulsed, TreeDict.fromdict(replace))

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import fromdict [as 别名]
 def sequence(self):
     l = self.parameters.BareLineScan
     cycles = int(l.cycles_per_sequence)
     #turn off all the lights, then do doppler cooling
     self.end = WithUnit(10, 'us')
     self.addSequence(turn_off_all)
     self.addSequence(doppler_cooling)    
     
     frequency_advance_duration = WithUnit(6, 'us')
     ampl_off = WithUnit(-63.0, 'dBm')
     self.addDDS('397',self.end, frequency_advance_duration, l.frequency_397_pulse, ampl_off)
     self.addDDS('866',self.end, frequency_advance_duration, l.frequency_866_pulse, ampl_off) ###changed from radial to 866 :Hong
     self.end += frequency_advance_duration  
     #record timetags while switching while cycling 'wait, pulse 397, wait, pulse 866'
     start_recording_timetags = self.end
     for i in range(cycles):
         self.addSequence(empty_sequence, TreeDict.fromdict({'EmptySequence.empty_sequence_duration':l.between_pulses}))
         self.addDDS('397',self.end, l.duration_397_pulse, l.frequency_397_pulse, l.amplitude_397_pulse)
         self.end += l.duration_397_pulse
         self.addSequence(empty_sequence, TreeDict.fromdict({'EmptySequence.empty_sequence_duration':l.between_pulses}))
         self.addDDS('866',self.end, l.duration_866_pulse, l.frequency_866_pulse, l.amplitude_866_pulse) ###changed from radial to 866 :Hong
         self.end += l.duration_866_pulse
     stop_recording_timetags = self.end
     timetag_record_duration = stop_recording_timetags - start_recording_timetags
     #record timetags while cycling takes place
     self.addTTL('TimeResolvedCount',start_recording_timetags, timetag_record_duration)
     self.start_recording_timetags = start_recording_timetags
     self.timetag_record_cycle = l.between_pulses + l.duration_397_pulse + l.duration_866_pulse+l.between_pulses

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import fromdict [as 别名]
 def sequence(self):
     h = self.parameters.Heating
     self.addSequence(empty_sequence, TreeDict.fromdict({'EmptySequence.empty_sequence_duration':h.blue_heating_delay_before}))
     if h.blue_heating_type == 'global':
         self.addSequence(global_blue_heating)
     elif h.blue_heating_type =='local':
         self.addSequence(local_blue_heating)
     else:
         raise Exception("Incorrect Heating Type")
     self.addSequence(empty_sequence, TreeDict.fromdict({'EmptySequence.empty_sequence_duration':h.blue_heating_delay_after}))

# 需要导入模块: from treedict import TreeDict [as 别名]
# 或者: from treedict.TreeDict import fromdict [as 别名]
 def sequence(self):
     r = self.parameters.Ramsey
     replace = TreeDict.fromdict({
                                  'Excitation_729.rabi_excitation_duration':r.rabi_pi_time / 2.0,
                                  'Excitation_729.rabi_excitation_phase':WithUnit(0, 'deg'),
                                  })
     self.addSequence(rabi_excitation, replace)
     self.addSequence(empty_sequence, TreeDict.fromdict({'EmptySequence.empty_sequence_duration':r.ramsey_time}))
     replace = TreeDict.fromdict({
                          'Excitation_729.rabi_excitation_duration':r.rabi_pi_time / 2.0,
                          'Excitation_729.rabi_excitation_phase':r.second_pulse_phase,
                          })
     self.addSequence(rabi_excitation_no_offset, replace)