def __init__(self, name, **kwargs): super().__init__(name, **kwargs) channels = [1, 2, 3, 4] channel_functions = [ 'trigger_source', 'trigger_mode', 'clear_waveforms' ] # functions = ['load_waveforms', 'load_sequence'] # Initialize waveforms and sequences self._waveforms = [[] for k in channels] for ch in channels: for fn in channel_functions: self.add_parameter('ch{}_{}'.format(ch, fn), get_cmd=partial(self.print_function, ch=ch, function=fn, mode='get'), set_cmd=partial(self.print_function, ch=ch, function=fn, mode='set'), vals=vals.Anything()) self.add_function('ch{}_add_waveform'.format(ch), call_cmd=partial(self._add_waveform, ch), args=[vals.Anything()]) self.add_parameter('ch{}_sequence'.format(ch), parameter_class=ManualParameter, label='Channel {} Sequence'.format(ch), initial_value=[], vals=vals.Anything())
def __init__(self, name, alazar_name, **kwargs): super().__init__(name, **kwargs) self._alazar = self.find_instrument(alazar_name) self._acquisition_settings = {} functions = ['config', 'acquire'] for function in functions: self.add_function(function, call_cmd=partial(self.print_function, function=function), args=[vals.Anything()]) self.add_parameter('average_mode', parameter_class=ManualParameter, initial_value=None, vals=vals.Anything()) self.add_parameter(name='acquisition_settings', get_cmd=lambda: self._acquisition_settings) self.add_parameter(name='acquisition', names=['channel_signal'], shapes=((),), get_cmd=self._acquisition)
def __init__(self, name, **kwargs): super().__init__(name, **kwargs) functions = [ 'stop', 'start', 'start_programming', 'stop_programming', 'detect_boards' ] for function in functions: self.add_function(function, call_cmd=partial(self.print_function, function=function)) functions = ['select_board'] for function in functions: self.add_function(function, call_cmd=partial(self.print_function, function=function), args=[vals.Anything()]) self.add_parameter('core_clock', parameter_class=ManualParameter, initial_value=500) self.add_parameter('instructions', parameter_class=ManualParameter, initial_value=[], vals=vals.Anything())
def __init__(self, name, **kw): super().__init__(name, **kw) self.msmt_suffix = '_' + name # used to append to measurement labels self.add_parameter('qasm_config', docstring='used for generating qumis instructions', parameter_class=ManualParameter, vals=vals.Anything()) self.add_parameter('qubits', parameter_class=ManualParameter, initial_value=[], vals=vals.Lists(elt_validator=vals.Strings())) self.add_parameter('acquisition_instrument', parameter_class=InstrumentParameter) self.add_parameter('RO_acq_averages', initial_value=1024, vals=vals.Ints(), parameter_class=ManualParameter) self._sequencer_config = {} self.delegate_attr_dicts += ['_sequencer_config'] # Add buffer parameters for every pulse type pulse_types = ['MW', 'Flux', 'RO'] self.add_parameter('sequencer_config', get_cmd=self._get_sequencer_config, vals=vals.Anything()) for pt_a in pulse_types: for pt_b in pulse_types: self.add_parameter('Buffer_{}_{}'.format(pt_a, pt_b), unit='s', initial_value=0, parameter_class=ManualParameter) self.add_sequencer_config_param( self.parameters['Buffer_{}_{}'.format(pt_a, pt_b)]) self.add_parameter( 'RO_fixed_point', unit='s', initial_value=1e-6, docstring=('The Tektronix sequencer shifts all elements in a ' + 'sequence such that the first RO encountered in each ' + 'element is aligned with the fixpoint.\nIf the ' + 'sequence length is longer than the fixpoint, ' + 'it will shift such that the first RO aligns with a ' + 'multiple of the fixpoint.'), parameter_class=ManualParameter, vals=vals.Numbers(1e-9, 500e-6)) self.add_sequencer_config_param(self.RO_fixed_point) self.add_parameter( 'Flux_comp_dead_time', unit='s', initial_value=3e-6, docstring=('Used to determine the wait time between the end of a' + 'sequence and the beginning of Flux compensation' + ' pulses.'), parameter_class=ManualParameter, vals=vals.Numbers(1e-9, 500e-6)) self.add_sequencer_config_param(self.Flux_comp_dead_time)
def __init__(self, name, **kwargs): super().__init__(name, **kwargs) channels = ['A', 'B', 'C', 'D'] # Obtain a list of all valid ATS configuration settings self._configuration_settings_names = list( inspect.signature(self.config).parameters.keys()) # Obtain a list of all valid ATS acquisition settings self._acquisition_settings_names = list( inspect.signature(self.acquire).parameters.keys()) self._settings_names = self._acquisition_settings_names + \ self._configuration_settings_names self._configuration_settings = {} self._acquisition_settings = {} self.add_parameter(name='configuration_settings', get_cmd=lambda: self._configuration_settings) self.add_parameter(name='acquisition_settings', get_cmd=lambda: self._acquisition_settings) for param in [ 'clock_source', 'sample_rate', 'clock_edge', 'decimation', 'trigger_operation', 'external_trigger_coupling', 'external_trigger_range', 'trigger_delay', 'timeout_ticks', 'mode', 'sampled_per_record', 'records_per_buffer', 'bufers_per_acquisition', 'channel_selection', 'transfer_offset', 'external_startcapture', 'enable_record_headers', 'alloc_buffers', 'fifo_only_streaming', 'interleave_samples', 'get_processed_data', 'allocated_buffers', 'buffer_timeout' ]: self.add_parameter( name=param, get_cmd=partial(self.get_setting, param), # set_cmd=partial(self.set_setting, param), vals=vals.Anything()) for idx in ['1', '2']: for param in [ 'trigger_engine', 'trigger_source', 'trigger_slope', 'trigger_level' ]: self.add_parameter( name=param + idx, get_cmd=partial(self.get_setting, param + idx), # set_cmd=partial(self.set_setting, param+idx), vals=vals.Anything()) for idx, ch in enumerate(channels): for param in ['coupling', 'channel_range', 'impedance']: self.add_parameter( name=param + ch, get_cmd=partial(self.get_setting, param, idx=idx), # set_cmd=partial(self.set_setting, param), vals=vals.Anything())
def __init__(self, name, **kwargs): super().__init__(name=name, **kwargs) self.add_parameter(name='x_val', get_cmd=lambda: self.x, vals=vals.Anything()) self.add_parameter(name='pulse', parameter_class=ManualParameter, vals=vals.Anything()) self.add_parameter(name='pulse_sequence', parameter_class=ManualParameter, vals=vals.Anything())
def __init__(self, name, RF, LO, AWG=None, acquisition_instr=None, acquisition_instr_controller=None, single_sideband_demod=False, **kw): self.RF = RF self.common_init(name, LO, AWG, acquisition_instr, single_sideband_demod, **kw) self.add_parameter('RF_power', label='RF power', unit='dBm', vals=vals.Numbers(), set_cmd=self._set_RF_power, get_cmd=self._get_RF_power) self.add_parameter('acquisition_instr_controller', set_cmd=self._set_acquisition_instr_controller, get_cmd=self._get_acquisition_instr_controller, vals=vals.Anything()) self.acquisition_instr_controller(acquisition_instr_controller) self._RF_power = None
def __init__(self, name=None, label=None, unit=None, instrument=None, value=None, byte_to_value_dict=None, vals=None): if vals is None: if byte_to_value_dict is None: vals = validators.Anything() else: # TODO(damazter) (S) test this validator vals = validators.Enum(*byte_to_value_dict.values()) super().__init__(name=name, label=label, unit=unit, vals=vals, instrument=instrument) self.instrument = instrument self._byte = None self._uptodate_flag = False # TODO(damazter) (M) check this block if byte_to_value_dict is None: self._byte_to_value_dict = TrivialDictionary() self._value_to_byte_dict = TrivialDictionary() else: self._byte_to_value_dict = byte_to_value_dict self._value_to_byte_dict = { v: k for k, v in self._byte_to_value_dict.items()} self._set(value)
def add_parameter(self, name: str, **kw: Any) -> None: """Add a parameter. :param name: name of the parameter. if the name contains `.`s, then an element before a dot is interpreted as a submodule. multiple dots represent nested submodules. I.e., when we supply ``foo.bar.foo2`` we have a top-level submodule ``foo``, containing a submodule ``bar``, containing the parameter ``foo2``. Submodules are generated on demand. :param kw: Any keyword arguments will be passed on to qcodes.Instrument.add_parameter, except: - ``set_cmd`` is always set to ``None`` - ``parameter_class`` is ``qcodes.Parameter`` - ``vals`` defaults to ``qcodes.utils.validators.Anything()``. :return: None """ kw['parameter_class'] = Parameter if 'vals' not in kw: kw['vals'] = validators.Anything() kw['set_cmd'] = None parent = self._get_parent(name, create_parent=True) if parent is self: super().add_parameter(name.split('.')[-1], **kw) else: parent.add_parameter(name.split('.')[-1], **kw)
def __init__(self, name, **kw): super().__init__(name, **kw) # Instrument parameters for parname in ['x', 'y', 'z', 'x0', 'y0', 'z0']: self.add_parameter(parname, unit='m', parameter_class=ManualParameter, vals=vals.Numbers(), initial_value=0) self.add_parameter('noise', unit='V', label='white noise amplitude', parameter_class=ManualParameter, vals=vals.Numbers(), initial_value=0) self.add_parameter('delay', unit='s', label='Sampling delay', parameter_class=ManualParameter, vals=vals.Numbers(), initial_value=0) self.add_parameter('parabola', unit='V', get_cmd=self._measure_parabola) self.add_parameter('parabola_list', unit='V', get_cmd=self._measure_parabola_list) self.add_parameter('skewed_parabola', unit='V', get_cmd=self._measure_skewed_parabola) self.add_parameter('cos_mod_parabola', unit='V', get_cmd=self._measure_cos_mod_parabola) self.add_parameter('lorentz_dip', unit='V', get_cmd=self._measure_lorentz_dip) self.add_parameter('lorentz_dip_cos_mod', unit='V', get_cmd=self._measure_lorentz_dip_cos_mod) self.add_parameter('array_like', unit='a.u.', parameter_class=ManualParameter, vals=vals.Arrays()) self.add_parameter('dict_like', unit='a.u.', parameter_class=ManualParameter, vals=vals.Dict()) self.add_parameter('status', vals=vals.Anything(), parameter_class=ManualParameter)
def __init__(self, name=None, label=None, unit=None, instrument=None, value=None, byte_to_value_dict=None, vals=None): warnings.warn("AlazarParamater is deprecated. Please replace with " "Regular parameter or TraceParameter") if vals is None: if byte_to_value_dict is None: vals = validators.Anything() else: # TODO(damazter) (S) test this validator vals = validators.Enum(*byte_to_value_dict.values()) super().__init__(name=name, label=label, unit=unit, vals=vals, instrument=instrument) self._byte = None self._uptodate_flag = False # TODO(damazter) (M) check this block if byte_to_value_dict is None: self._byte_to_value_dict = TrivialDictionary() self._value_to_byte_dict = TrivialDictionary() else: self._byte_to_value_dict = byte_to_value_dict self._value_to_byte_dict = { v: k for k, v in self._byte_to_value_dict.items()} self._set(value)
def __init__(self, instrument_name: str, **kwargs): # TODO: pass along actual instrument instead of name super().__init__(name=instrument_name + '_interface', **kwargs) self.instrument = self.find_instrument(name=instrument_name) self._input_channels = {} self._output_channels = {} self._channels = {} self.pulse_sequence = PulseSequence(allow_untargeted_pulses=False, allow_pulse_overlap=False) self.input_pulse_sequence = PulseSequence( allow_untargeted_pulses=False, allow_pulse_overlap=False) self.add_parameter('instrument_name', set_cmd=None, initial_value=instrument_name, vals=vals.Anything()) self.add_parameter('is_primary', set_cmd=None, initial_value=False, vals=vals.Bool()) self.pulse_implementations = []
def paramTypeFromVals(vals: validators.Validator) -> Union[ParameterTypes, None]: if vals is None: vals = validators.Anything() for k, v in parameterTypes.items(): if isinstance(vals, v['validatorType']): return k return None
def __init__(self, name, board_number=0, **kwargs): super().__init__(name, **kwargs) # It seems that the core_clock is not the same as the sampling rate. # At core_clock(500), the PulseBlaster uses 1 ns per wait duration. # The wait duration is inversely proportional to the core clock, in contrast to the sampling rate self.add_parameter('core_clock', label='Core clock', unit='MHz', set_cmd=self.set_core_clock, vals=vals.Numbers(0, 500)) self.add_parameter('board_number', set_cmd=None, initial_value=board_number) self.add_function('initialize', call_cmd=self.initialize) self.add_function('detect_boards', call_cmd=self.detect_boards) self.add_function('select_board', call_cmd=api.pb_select_board, args=[vals.Enum(0, 1, 2, 3, 4)]) self.add_function('start_programming', call_cmd=self.start_programming) self.add_function( 'send_instruction', call_cmd=self.send_instruction, args=[vals.Ints(), vals.Strings(), vals.Ints(), vals.Ints()]) self.add_function('stop_programming', call_cmd=self.stop_programming) self.add_function('start', call_cmd=self.start) self.add_function('stop', call_cmd=self.stop) self.add_function('close', call_cmd=self.close) self.add_function('get_error', call_cmd=api.pb_get_error) self.add_parameter('instruction_sequence', set_cmd=None, initial_value=[], vals=vals.Anything(), snapshot_value=False) self.setup(initialize=True)
def __init__(self, name, UHFQC, **kw): logging.warning('The UHFQC_LookuptableManagerManager is deprecated') logging.info(__name__ + ' : Initializing instrument') super().__init__(name, **kw) self.UHFQC = UHFQC self.add_parameter('mixer_QI_amp_ratio', vals=vals.Numbers(), parameter_class=ManualParameter, initial_value=1.0) self.add_parameter('mixer_IQ_phase_skewness', vals=vals.Numbers(), unit='deg', parameter_class=ManualParameter, initial_value=0.0) # These parameters are added for mixer skewness correction. # They are intended to be renamed such that they can be combined with # mixer_QI_amp_ratio and mixer_IQ_phase_skewness. self.add_parameter('mixer_alpha', vals=vals.Numbers(), parameter_class=ManualParameter, initial_value=1.0) self.add_parameter('mixer_phi', vals=vals.Numbers(), unit='deg', parameter_class=ManualParameter, initial_value=0.0) self.add_parameter('mixer_apply_predistortion_matrix', vals=vals.Bool(), parameter_class=ManualParameter, initial_value=False) self.add_parameter('acquisition_delay', vals=vals.Numbers(), unit='s', parameter_class=ManualParameter, initial_value=270e-9) self.add_parameter('LutMans', vals=vals.Anything(), set_cmd=self._attach_lutmans_to_Lutmanman) self.add_parameter('sampling_rate', vals=vals.Numbers(), unit='Hz', parameter_class=ManualParameter, initial_value=1.8e9) # Set to a default because box is not expected to change self._voltage_min = -1.0 self._voltage_max = 1.0 - 1.0 / 2**13
def __init__(self, instrument_name, **kwargs): super().__init__(instrument_name, **kwargs) # Override untargeted pulse adding (measurement pulses can be added) self.pulse_sequence.allow_untargeted_pulses = True # Define instrument channels # - Two input channels (ch1 and ch2) # - One input trigger channel (trig_in) self._acquisition_channels = { f'ch{k}': Channel(instrument_name=self.instrument_name(), name=f'ch{k}', id=k, input=True) for k in [1,2] } self._channels = { **self._acquisition_channels, 'trig_in': Channel(instrument_name=self.instrument_name(), name='trig_in', input_trigger=True) } self.add_parameter(name='acquisition_channels', set_cmd=None, initial_value=[], vals=vals.Anything(), docstring='Names of acquisition channels ' '[chA, chB, etc.]. Set by the layout') self.add_parameter(name='samples', set_cmd=None, initial_value=1, docstring='Number of times to acquire the pulse ' 'sequence.') self.add_parameter(name='sample_rate', set_cmd=None, initial_value=1, docstring='Number of times to acquire the pulse ' 'sequence.') # Noise factor used when generating traces self.noise_factor = 0.6 self.blip_probability = 0.45 # Probability for fake blips during read pulse self.blip_start = 0.25 # Maximum fraction for blip to start self.blip_duration = 0.25 # Maximum duration for a blip self.blip_read_amplitude = 0.3 # Maximum read amplitude self.pulse_traces = {}
def __init__(self, parent, name, id, channel_api, **kwargs): super().__init__(parent, name, **kwargs) self.id = id self.channel_api = channel_api self._api = self.parent._api self.trigger_mode = Parameter( label=f"Channel {id} trigger mode", vals=vals.Enum("single", "continuous", "stepped", "burst"), ) self.trigger_source = Parameter( label=f"Channel {id} trigger source", vals=vals.Enum("stop", "start", "event_marker", "dc_trigger_in", "fp_trigger_in"), ) self.sampling_rate_prescaler = Parameter( label=f"Channel {id} sampling rate prescaler", vals=vals.MultiType(vals.Multiples(2), vals.Enum(1)), ) self.max_voltage = Parameter( label="Maximum waveform voltage", unit="V", set_cmd=None, initial_value=6, vals=vals.Numbers(), docstring="Maximum waveform voltage. Any waveform added cannot have" "a voltage higher than this.", ) self.sequence = Parameter( label=f"Channel {id} Sequence", set_cmd=None, initial_value=[], vals=vals.Anything(), log_changes=False, snapshot_value=False, ) # Can we test for an (int, int) tuple list? # Keep actual waveforms hidden so they cannot be directly set # i.e. arbstudio.waveforms = waveform_list # Raises an error # waveforms should be added via arbstudio.add_waveform self._waveforms = []
def __init__(self, name, address, **kwargs): super().__init__(name, address, terminator="\n\r", **kwargs) self.add_parameter("switch_setting", get_cmd="SWPORT?", set_cmd=self._set_switch, get_parser=dec_to_binstring, set_parser=binstring_to_dec, vals=vals.Anything()) # the device sends a single '\n' as a hello, messing everything up... self.visa_handle.read_termination = "\n" try: self.visa_handle.read_raw() except VisaIOError as e: print("Minicircuit Switch did not send telnet handshake") self.visa_handle.read_termination = "\n\r"
def __init__(self, name, address, min_delay=0.03, **kwargs): super().__init__(name, address, **kwargs) # The SIM900 has eight channels self.number_of_channels = 8 # Dictionary with (channel, module) elements self._modules = {} self._last_visa_command = None self.min_delay = min_delay # Start with empty list of channels. These are self.add_parameter( "channels", initial_value={}, set_cmd=None, vals=vals.Anything(), snapshot_value=False, )
def __init__(self, name, seq_mode='off'): if seq_mode is 'on': io_mode = 'AUX_IN_TRIGGER_ENABLE' io_param = 'TRIG_SLOPE_POSITIVE' elif seq_mode is 'off': io_mode = 'AUX_IN_AUXILIARY' io_param = 'NONE' else: raise ValueError('must set seq mode to "on" or ' '"off", received {}'.format(seq_mode)) super().__init__(name=name) self.config(clock_source='EXTERNAL_CLOCK_10MHz_REF', sample_rate=500000000, clock_edge='CLOCK_EDGE_RISING', decimation=1, coupling=['DC', 'DC'], channel_range=[.4, .4], impedance=[50, 50], trigger_operation='TRIG_ENGINE_OP_J', trigger_engine1='TRIG_ENGINE_J', trigger_source1='EXTERNAL', trigger_slope1='TRIG_SLOPE_POSITIVE', trigger_level1=140, trigger_engine2='TRIG_ENGINE_K', trigger_source2='DISABLE', trigger_slope2='TRIG_SLOPE_POSITIVE', trigger_level2=128, external_trigger_coupling='DC', external_trigger_range='ETR_2V5', trigger_delay=0, timeout_ticks=0, aux_io_mode=io_mode, aux_io_param=io_param ) self.add_parameter(name='seq_mode', get_cmd=self._get_seq_mod, set_cmd=self._set_seq_mode, vals=vals.Anything() )
def __init__(self, name, channels, **kwargs): super().__init__(name, **kwargs) self.add_parameter(name='channels', set_cmd=None, initial_value=channels, vals=vals.Anything())
def __init__(self, name, **kw): logging.info(__name__ + ' : Initializing instrument') super().__init__(name, **kw) self.add_parameter('QWG', parameter_class=InstrumentParameter) self.add_parameter('F_kernel_instr', parameter_class=InstrumentParameter) self.add_parameter('F_amp', unit='frac', docstring=('Amplitude of flux pulse as fraction of ' 'the peak amplitude. Beware of factor 2' ' with Vpp in the QWG'), initial_value=0.5, parameter_class=ManualParameter) self.add_parameter('F_length', unit='s', parameter_class=ManualParameter, initial_value=200e-9) self.add_parameter('F_ch', label='Flux channel', vals=vals.Ints(), parameter_class=ManualParameter) self.add_parameter('F_delay', label='Flux pulse delay', unit='s', initial_value=0, vals=vals.Numbers(), parameter_class=ManualParameter) self.add_parameter('F_compensation_delay', label='compens. pulse delay', unit='s', initial_value=4e-6, vals=vals.Numbers(), parameter_class=ManualParameter) self.add_parameter('F_lambda_1', docstring='first lambda coef. for martinis pulse', label='Lambda_1', unit='', initial_value=0, vals=vals.Numbers(), parameter_class=ManualParameter) self.add_parameter('F_lambda_2', docstring='second lambda coef. for martinis pulse', label='Lambda_2', unit='', initial_value=0, vals=vals.Numbers(), parameter_class=ManualParameter) self.add_parameter('F_lambda_3', docstring='third lambda coef. for martinis pulse', label='Lambda_3', unit='', initial_value=0, vals=vals.Numbers(), parameter_class=ManualParameter) self.add_parameter('F_theta_f', docstring='theta_f for martinis pulse', label='theta_f', unit='deg', initial_value=90, vals=vals.Numbers(), parameter_class=ManualParameter) self.add_parameter('F_J2', docstring='coupling between 11-02', label='J2', unit='Hz', initial_value=10e6, vals=vals.Numbers(), parameter_class=ManualParameter) self.add_parameter('F_f_interaction', label='interaction frequency', unit='Hz', initial_value=5e9, vals=vals.Numbers(), parameter_class=ManualParameter) self.add_parameter('F_dac_flux_coef', docstring='conversion factor AWG voltage to flux', label='dac flux coef', unit='(V^-1)', initial_value=1.0, vals=vals.Numbers(), parameter_class=ManualParameter) self.add_parameter('F_E_c', label='qubit E_c', unit='Hz', initial_value=250e6, vals=vals.Numbers(), parameter_class=ManualParameter) self.add_parameter('F_f_01_max', label='sweet spot freq', unit='Hz', initial_value=6e9, vals=vals.Numbers(), parameter_class=ManualParameter) self.add_parameter('F_asymmetry', label='qubit asymmetry', unit='Hz', initial_value=0.0, vals=vals.Numbers(), parameter_class=ManualParameter) self.add_parameter('codeword_dict', docstring='Dict assigning codewords to pulses', label='codeword dict', unit='', initial_value={}, vals=vals.Anything(), parameter_class=ManualParameter) self.add_parameter('sampling_rate', docstring='Sampling rate of the QWG', label='sampling rate', unit='Hz', initial_value=1.0e9, vals=vals.Numbers(), parameter_class=ManualParameter) self.add_parameter('Z_length', docstring=('Duration of single qubit Z pulse in' ' seconds'), label='Z length', unit='s', initial_value=10e-9, vals=vals.Numbers(), parameter_class=ManualParameter) self.add_parameter('Z_amp', docstring=('Amplitude of the single qubit phase ' 'correction in CZ pulses.'), label='Z amplitude', unit='frac', initial_value=0.0, vals=vals.Numbers(), parameter_class=ManualParameter) self.add_parameter('Z_amp_grover', docstring=('Amplitude of the single qubit phase ' 'correction for the second CZ pulse ' "used in Grover's algorithm."), label='Z amplitude 2', unit='frac', initial_value=0.0, vals=vals.Numbers(), parameter_class=ManualParameter) self.add_parameter('max_waveform_length', unit='s', parameter_class=ManualParameter, initial_value=30e-6) self.add_parameter('codeword_channels', parameter_class=ManualParameter, docstring='Channels used for triggering specific ' 'codewords.', vals=vals.Lists(vals.Ints())) self.add_parameter('disable_CZ', parameter_class=ManualParameter, vals=vals.Bool(), initial_value=False) self.add_parameter('pulse_map', initial_value={'cz': 'adiabatic_Z', 'cz_grover': 'adiabatic_Z_grover', 'square': 'square'}, parameter_class=ManualParameter, vals=vals.Dict()) self.add_parameter('wave_dict_unit', get_cmd=self._get_wave_dict_unit, set_cmd=self._set_wave_dict_unit, docstring='Unit in which the waveforms are ' 'specified.\n' '"frac" means "fraction of the maximum QWG ' 'range".\n' '"V" means volts.', vals=vals.Enum('frac', 'V')) self._wave_dict_unit = 'frac' # Initial value for wave_dict_unit self.add_parameter('V_offset', unit='V', label='V offset', docstring='pulsed sweet spot offset', parameter_class=ManualParameter, initial_value=0, vals=vals.Numbers()) self.add_parameter('V_per_phi0', unit='V', label='V per phi_0', docstring='pulsed voltage required for one phi0 ' 'of flux', parameter_class=ManualParameter, initial_value=1, vals=vals.Numbers()) self.add_parameter('S_gauss_sigma', unit='s', label='gauss sigma', docstring='Width (sigma) of Gaussian shaped flux ' 'pulse.', parameter_class=ManualParameter, initial_value=40e-9, vals=vals.Numbers()) self.add_parameter('S_amp', unit='frac', label='S_amp', docstring='Amplitude of scoping flux pulse.', parameter_class=ManualParameter, initial_value=0.5, vals=vals.Numbers()) self._wave_dict = {}
def __init__(self, name, **kw): super(CBox_driven_transmon, self).__init__(name, **kw) # Change this when inheriting directly from Transmon instead of # from CBox driven Transmon. # Adding instrument parameters self.add_parameter('LO', parameter_class=InstrumentParameter) self.add_parameter('cw_source', parameter_class=InstrumentParameter) self.add_parameter('td_source', parameter_class=InstrumentParameter) self.add_parameter('IVVI', parameter_class=InstrumentParameter) self.add_parameter('FluxCtrl', parameter_class=InstrumentParameter) self.add_parameter('AWG', parameter_class=InstrumentParameter) self.add_parameter('heterodyne_instr', parameter_class=InstrumentParameter) self.add_parameter('LutMan', parameter_class=InstrumentParameter) self.add_parameter('CBox', parameter_class=InstrumentParameter) self.add_parameter('MC', parameter_class=InstrumentParameter) self.add_parameter('RF_RO_source', parameter_class=InstrumentParameter) self.add_parameter('mod_amp_cw', label='RO modulation ampl cw', unit='V', initial_value=0.5, parameter_class=ManualParameter) self.add_parameter('RO_power_cw', label='RO power cw', unit='dBm', parameter_class=ManualParameter) self.add_parameter('spec_pow', label='spectroscopy power', unit='dBm', parameter_class=ManualParameter) self.add_parameter('spec_pow_pulsed', label='pulsed spectroscopy power', unit='dBm', parameter_class=ManualParameter) self.add_parameter('td_source_pow', label='Time-domain power', unit='dBm', parameter_class=ManualParameter) self.add_parameter('spec_pulse_type', label='Pulsed spec pulse type', parameter_class=ManualParameter, initial_value='SquarePulse', vals=vals.Enum('SquarePulse')) # , SSB_DRAG_pulse)) # we should also implement SSB_DRAG_pulse for pulsed spec self.add_parameter('spec_pulse_length', label='Pulsed spec pulse duration', unit='s', vals=vals.Numbers(1e-9, 20e-6), parameter_class=ManualParameter) self.add_parameter('spec_pulse_marker_channel', unit='s', vals=vals.Strings(), parameter_class=ManualParameter) self.add_parameter('spec_pulse_depletion_time', unit='s', vals=vals.Numbers(1e-9, 50e-6), parameter_class=ManualParameter) # Rename f_RO_mod # Time-domain parameters self.add_parameter('pulse_I_channel', initial_value='ch1', vals=vals.Strings(), parameter_class=ManualParameter) self.add_parameter('pulse_Q_channel', initial_value='ch2', vals=vals.Strings(), parameter_class=ManualParameter) self.add_parameter('pulse_I_offset', initial_value=0.0, vals=vals.Numbers(min_value=-0.1, max_value=0.1), parameter_class=ManualParameter) self.add_parameter('pulse_Q_offset', initial_value=0.0, vals=vals.Numbers(min_value=-0.1, max_value=0.1), parameter_class=ManualParameter) # readout parameters for time domain self.add_parameter('RO_acq_averages', initial_value=1024, vals=vals.Numbers(min_value=0, max_value=1e6), parameter_class=ManualParameter) self.add_parameter('RO_acq_integration_length', initial_value=1e-6, vals=vals.Numbers( min_value=10e-9, max_value=1000e-6), parameter_class=ManualParameter) self.add_parameter('RO_acq_weight_function_I', initial_value=0, vals=vals.Ints(0, 5), parameter_class=ManualParameter) self.add_parameter('RO_acq_weight_function_Q', initial_value=1, vals=vals.Ints(0, 5), parameter_class=ManualParameter) # These parameters are only relevant if using MW_IQmod_pulse type # RO self.add_parameter('RO_I_channel', initial_value='ch3', vals=vals.Strings(), parameter_class=ManualParameter) self.add_parameter('RO_Q_channel', initial_value='ch4', vals=vals.Strings(), parameter_class=ManualParameter) self.add_parameter('RO_I_offset', initial_value=0.0, vals=vals.Numbers(min_value=-0.1, max_value=0.1), parameter_class=ManualParameter) self.add_parameter('RO_Q_offset', initial_value=0.0, vals=vals.Numbers(min_value=-0.1, max_value=0.1), parameter_class=ManualParameter) self.add_parameter('RO_pulse_type', initial_value='MW_IQmod_pulse_tek', vals=vals.Enum('MW_IQmod_pulse_tek', 'MW_IQmod_pulse_UHFQC', 'Gated_MW_RO_pulse'), parameter_class=ManualParameter) # Relevant when using a marker channel to gate a MW-RO tone. self.add_parameter('RO_pulse_marker_channel', vals=vals.Strings(), parameter_class=ManualParameter) self.add_parameter('RO_pulse_power', unit='dBm', parameter_class=ManualParameter) self.add_parameter('f_pulse_mod', initial_value=-100e6, label='pulse-modulation frequency', unit='Hz', parameter_class=ManualParameter) self.add_parameter('f_RO_mod', label='Readout-modulation frequency', unit='Hz', initial_value=-2e7, parameter_class=ManualParameter) self.add_parameter('amp180', label='Pi-pulse amplitude', unit='V', initial_value=.25, vals=vals.Numbers(min_value=-2.25, max_value=2.25), parameter_class=ManualParameter) self.add_parameter('amp90_scale', label='pulse amplitude scaling factor', unit='', initial_value=.5, vals=vals.Numbers(min_value=0, max_value=1.0), parameter_class=ManualParameter) self.add_parameter('gauss_sigma', unit='s', initial_value=10e-9, parameter_class=ManualParameter) self.add_parameter('motzoi', label='Motzoi parameter', unit='', initial_value=0, parameter_class=ManualParameter) self.add_parameter('phi_skew', label='IQ phase skewness', unit='deg', vals=vals.Numbers(-180, 180), initial_value=0, parameter_class=ManualParameter) self.add_parameter('alpha', label='QI amplitude skewness', unit='', vals=vals.Numbers(.1, 2), initial_value=1, parameter_class=ManualParameter) # Single shot readout specific parameters self.add_parameter('RO_threshold', unit='dac-value', initial_value=0, parameter_class=ManualParameter) # CBox specific parameter self.add_parameter('signal_line', parameter_class=ManualParameter, vals=vals.Enum(0, 1), initial_value=0) self.add_parameter('acquisition_instr', set_cmd=self._do_set_acquisition_instr, get_cmd=self._do_get_acquisition_instr, vals=vals.Strings()) self.add_parameter('flux_pulse_buffer', label='Flux pulse buffer', unit='s', initial_value=0., vals=vals.Numbers(min_value=0., max_value=50e-6), parameter_class=ManualParameter) self.add_parameter('fluxing_channel', initial_value='ch1', vals=vals.Strings(), parameter_class=ManualParameter) self.add_parameter('fluxing_amp', label='SWAP resolution', unit='V', initial_value=.5, vals=vals.Numbers(min_value=-1., max_value=1.), parameter_class=ManualParameter) self.add_parameter('SWAP_amp', label='SWAP amplitude', unit='V', initial_value=0.02, vals=vals.Numbers(min_value=0.02, max_value=4.5), parameter_class=ManualParameter) self.add_parameter('SWAP_time', label='SWAP Time', unit='s', initial_value=0., vals=vals.Numbers(min_value=0., max_value=1e-6), parameter_class=ManualParameter) self.add_parameter('flux_dead_time', label='Time between flux pulse and comp.', unit='s', initial_value=0., vals=vals.Numbers(min_value=0., max_value=50e-6), parameter_class=ManualParameter) self.add_parameter('mw_to_flux_delay', label='time between and mw pulse and start of flux pulse', unit='s', initial_value=0., vals=vals.Numbers(min_value=0., max_value=50e-6), parameter_class=ManualParameter) self.add_parameter('dist_dict', get_cmd=self.get_dist_dict, set_cmd=self.set_dist_dict, vals=vals.Anything())
def __init__(self, name, **kw): t0 = time.time() super().__init__(name, **kw) # self._daq = zi.ziDAQServer(address, int(port), 5) # if device.lower() == 'auto': # self._device = zi_utils.autoDetect(self._daq) # else: # self._device = device # self._daq.connectDevice(self._device, interface) # #self._device = zi_utils.autoDetect(self._daq) # self._awgModule = self._daq.awgModule() # self._awgModule.set('awgModule/device', self._device) # self._awgModule.execute() self.acquisition_paths = [] s_node_pars = [] d_node_pars = [] path = os.path.abspath(__file__) dir_path = os.path.dirname(path) self._s_file_name = os.path.join(dir_path, 'zi_parameter_files', 's_node_pars.txt') self._d_file_name = os.path.join(dir_path, 'zi_parameter_files', 'd_node_pars.txt') init = True try: f = open(self._s_file_name).read() s_node_pars = json.loads(f) except Exception: print("parameter file for gettable parameters {} not found".format( self._s_file_name)) init = False try: f = open(self._d_file_name).read() d_node_pars = json.loads(f) except Exception: print("parameter file for settable parameters {} not found".format( self._d_file_name)) init = False self.add_parameter('timeout', unit='s', initial_value=10, parameter_class=ManualParameter) for parameter in s_node_pars: parname = parameter[0].replace("/", "_") if parameter[1] == 'float': self.add_parameter(parname, parameter_class=ManualParameter, vals=vals.Numbers(parameter[2], parameter[3])) elif parameter[1] == 'float_small': self.add_parameter(parname, parameter_class=ManualParameter, vals=vals.Numbers(parameter[2], parameter[3])) elif parameter[1] == 'int_8bit': self.add_parameter(parname, parameter_class=ManualParameter, vals=vals.Ints(int(parameter[2]), int(parameter[3]))) elif parameter[1] == 'int': self.add_parameter(parname, parameter_class=ManualParameter, vals=vals.Ints(int(parameter[2]), int(parameter[3]))) elif parameter[1] == 'int_64': self.add_parameter(parname, parameter_class=ManualParameter, vals=vals.Ints(int(parameter[2]), int(parameter[3]))) elif parameter[1] == 'bool': self.add_parameter(parname, parameter_class=ManualParameter, vals=vals.Ints(int(parameter[2]), int(parameter[3]))) else: print( "parameter {} type {} from from s_node_pars not recognized" .format(parname, parameter[1])) for parameter in d_node_pars: parname = parameter[0].replace("/", "_") if parameter[1] == 'float': self.add_parameter(parname, parameter_class=ManualParameter) elif parameter[1] == 'vector_g': self.add_parameter(parname, parameter_class=ManualParameter) elif parameter[1] == 'vector_s': self.add_parameter(parname, parameter_class=ManualParameter, vals=vals.Anything()) elif parameter[1] == 'vector_gs': self.add_parameter(parname, parameter_class=ManualParameter, vals=vals.Anything()) else: print("parameter {} type {} from d_node_pars not recognized". format(parname, parameter[1])) self.add_parameter('AWG_file', parameter_class=ManualParameter, vals=vals.Anything()) # storing an offset correction parameter for all weight functions, # this allows normalized calibration when performing cross-talk suppressed # readout for i in range(5): self.add_parameter( "quex_trans_offset_weightfunction_{}".format(i), unit='', # unit is adc value label='RO normalization offset', initial_value=0.0, parameter_class=ManualParameter) if init: self.load_default_settings() t1 = time.time() print('Initialized dummy UHFQC', self.name, 'in %.2fs' % (t1 - t0))
def __init__(self, name, device='auto', interface='USB', address='127.0.0.1', port=8004, DIO=True, nr_integration_channels=9, **kw): ''' Input arguments: name: (str) name of the instrument server_name: (str) qcodes instrument server address: (int) the address of the data server e.g. 8006 ''' # self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) # #suggestion W vlothuizen t0 = time.time() super().__init__(name, **kw) self.nr_integration_channels = nr_integration_channels self.DIO = DIO self._daq = zi.ziDAQServer(address, int(port), 5) # self._daq.setDebugLevel(5) if device.lower() == 'auto': self._device = zi_utils.autoDetect(self._daq) else: self._device = device self._daq.connectDevice(self._device, interface) #self._device = zi_utils.autoDetect(self._daq) self._awgModule = self._daq.awgModule() self._awgModule.set('awgModule/device', self._device) self._awgModule.execute() self.acquisition_paths = [] s_node_pars = [] d_node_pars = [] path = os.path.abspath(__file__) dir_path = os.path.dirname(path) self._s_file_name = os.path.join(dir_path, 'zi_parameter_files', 's_node_pars.txt') self._d_file_name = os.path.join(dir_path, 'zi_parameter_files', 'd_node_pars.txt') init = True try: f = open(self._s_file_name).read() s_node_pars = json.loads(f) except: print("parameter file for gettable parameters {} not found".format( self._s_file_name)) init = False try: f = open(self._d_file_name).read() d_node_pars = json.loads(f) except: print("parameter file for settable parameters {} not found".format( self._d_file_name)) init = False self.add_parameter('timeout', unit='s', initial_value=30, parameter_class=ManualParameter) for parameter in s_node_pars: parname = parameter[0].replace("/", "_") parfunc = "/" + self._device + "/" + parameter[0] if parameter[1] == 'float': self.add_parameter( parname, set_cmd=self._gen_set_func(self.setd, parfunc), get_cmd=self._gen_get_func(self.getd, parfunc), vals=vals.Numbers(parameter[2], parameter[3])) elif parameter[1] == 'float_small': self.add_parameter( parname, set_cmd=self._gen_set_func(self.setd, parfunc), get_cmd=self._gen_get_func(self.getd, parfunc), vals=vals.Numbers(parameter[2], parameter[3])) elif parameter[1] == 'int_8bit': self.add_parameter( parname, set_cmd=self._gen_set_func(self.seti, parfunc), get_cmd=self._gen_get_func(self.geti, parfunc), vals=vals.Ints(int(parameter[2]), int(parameter[3]))) elif parameter[1] == 'int': self.add_parameter( parname, set_cmd=self._gen_set_func(self.seti, parfunc), get_cmd=self._gen_get_func(self.geti, parfunc), vals=vals.Ints(int(parameter[2]), int(parameter[3]))) elif parameter[1] == 'int_64': self.add_parameter( parname, set_cmd=self._gen_set_func(self.seti, parfunc), get_cmd=self._gen_get_func(self.geti, parfunc), vals=vals.Ints(int(parameter[2]), int(parameter[3]))) elif parameter[1] == 'bool': self.add_parameter( parname, set_cmd=self._gen_set_func(self.seti, parfunc), get_cmd=self._gen_get_func(self.geti, parfunc), vals=vals.Ints(int(parameter[2]), int(parameter[3]))) else: print( "parameter {} type {} from from s_node_pars not recognized" .format(parname, parameter[1])) for parameter in d_node_pars: parname = parameter[0].replace("/", "_") parfunc = "/" + self._device + "/" + parameter[0] if parameter[1] == 'float': self.add_parameter(parname, get_cmd=self._gen_get_func( self.getd, parfunc)) elif parameter[1] == 'vector_g': self.add_parameter(parname, get_cmd=self._gen_get_func( self.getv, parfunc)) elif parameter[1] == 'vector_s': self.add_parameter(parname, set_cmd=self._gen_set_func( self.setv, parfunc), vals=vals.Anything()) elif parameter[1] == 'vector_gs': self.add_parameter( parname, set_cmd=self._gen_set_func(self.setv, parfunc), get_cmd=self._gen_get_func(self.getv, parfunc), vals=vals.Anything()) else: print("parameter {} type {} from d_node_pars not recognized". format(parname, parameter[1])) self.add_parameter('AWG_file', set_cmd=self._do_set_AWG_file, vals=vals.Anything()) # storing an offset correction parameter for all weight functions, # this allows normalized calibration when performing cross-talk suppressed # readout for i in range(self.nr_integration_channels): self.add_parameter( "quex_trans_offset_weightfunction_{}".format(i), unit='', # unit is adc value label='RO normalization offset', initial_value=0.0, parameter_class=ManualParameter) if init: self.load_default_settings() t1 = time.time() print('Initialized UHFQC', self._device, 'in %.2fs' % (t1 - t0))
def __init__(self, name, **kw): super().__init__(name, **kw) # Instrument parameters for parname in ["x", "y", "z", "x0", "y0", "z0"]: self.add_parameter( parname, unit="m", parameter_class=ManualParameter, vals=vals.Numbers(), initial_value=0., ) # Instrument integer parameters for parname in [ "x_int", "y_int", "z_int", "x0_int", "y0_int", "z0_int" ]: self.add_parameter( parname, unit="m", parameter_class=ManualParameter, vals=vals.Ints(), initial_value=0, ) self.add_parameter( "noise", unit="V", label="white noise amplitude", parameter_class=ManualParameter, vals=vals.Numbers(), initial_value=0, ) self.add_parameter( "delay", unit="s", label="Sampling delay", parameter_class=ManualParameter, vals=vals.Numbers(), initial_value=0, ) self.add_parameter("parabola", unit="V", get_cmd=self._measure_parabola) self.add_parameter("parabola_int", unit="V", get_cmd=self._measure_parabola_int) self.add_parameter("parabola_float_int", unit="V", get_cmd=self._measure_parabola_float_int) self.add_parameter("parabola_list", unit="V", get_cmd=self._measure_parabola_list) self.add_parameter("skewed_parabola", unit="V", get_cmd=self._measure_skewed_parabola) self.add_parameter("cos_mod_parabola", unit="V", get_cmd=self._measure_cos_mod_parabola) self.add_parameter("lorentz_dip", unit="V", get_cmd=self._measure_lorentz_dip) self.add_parameter("lorentz_dip_cos_mod", unit="V", get_cmd=self._measure_lorentz_dip_cos_mod) self.add_parameter( "array_like", unit="a.u.", parameter_class=ManualParameter, vals=vals.Arrays(), ) self.add_parameter("nested_lists_like", unit="a.u.", parameter_class=ManualParameter, vals=vals.Lists(elt_validator=vals.Lists())) self.add_parameter("dict_like", unit="a.u.", parameter_class=ManualParameter, vals=vals.Dict()) self.add_parameter("complex_like", unit="a.u.", parameter_class=ManualParameter, vals=vals.ComplexNumbers()) self.add_parameter("status", vals=vals.Anything(), parameter_class=ManualParameter)
def __init__(self, name, **kw): logging.info(__name__ + ' : Initializing instrument') super().__init__(name, **kw) logging.warning('The ControlBox_LookuptableManager is deprecated.') self.add_parameter('CBox', parameter_class=InstrumentParameter) self.add_parameter('awg_nr', vals=vals.Ints(0, 2), initial_value=0, parameter_class=ManualParameter) self.add_parameter('Q_amp180', unit='V', vals=vals.Numbers(-1, 1), parameter_class=ManualParameter, initial_value=0.1) self.add_parameter('Q_amp90', unit='V', vals=vals.Numbers(-1, 1), parameter_class=ManualParameter, initial_value=0.05) self.add_parameter('Q_ampCW', unit='V', vals=vals.Numbers(-1, 1), parameter_class=ManualParameter, initial_value=0.05) self.add_parameter('Q_block_length', unit='s', vals=vals.Numbers(1e-9, 640e-9), parameter_class=ManualParameter, initial_value=500e-9) self.add_parameter('Q_motzoi_parameter', vals=vals.Numbers(-2, 2), parameter_class=ManualParameter, initial_value=0.0) self.add_parameter('Q_gauss_width', vals=vals.Numbers(), unit='s', parameter_class=ManualParameter, initial_value=10e-9) self.add_parameter('mixer_QI_amp_ratio', vals=vals.Numbers(), parameter_class=ManualParameter, initial_value=1.0) self.add_parameter('mixer_IQ_phase_skewness', vals=vals.Numbers(), unit='deg', parameter_class=ManualParameter, initial_value=0.0) self.add_parameter('Q_modulation', vals=vals.Numbers(), unit='Hz', parameter_class=ManualParameter, initial_value=20.0e6) self.add_parameter('Q_Rphi', label='Phase of Rphi pulse', vals=vals.Numbers(), unit='deg', parameter_class=ManualParameter, initial_value=0) self.add_parameter('sampling_rate', vals=vals.Numbers(), unit='Hz', parameter_class=ManualParameter, initial_value=0.2e9) self.add_parameter('lut_mapping', parameter_class=ManualParameter, initial_value=['I', 'X180', 'Y180', 'X90', 'Y90', 'mX90', 'mY90', 'ModBlock'], vals=vals.Anything()) # These parameters are added for mixer skewness correction. # They are intended to be renamed such that they can be combined with # mixer_QI_amp_ratio and mixer_IQ_phase_skewness. self.add_parameter('mixer_alpha', vals=vals.Numbers(), parameter_class=ManualParameter, initial_value=1.0) self.add_parameter('mixer_phi', vals=vals.Numbers(), unit='deg', parameter_class=ManualParameter, initial_value=0.0) self.add_parameter('mixer_apply_predistortion_matrix', vals=vals.Bool(), parameter_class=ManualParameter, initial_value=False) self.add_parameter('M_modulation', vals=vals.Numbers(), unit='Hz', parameter_class=ManualParameter, initial_value=20.0e6) self.add_parameter('M_length', unit='s', vals=vals.Numbers(1e-9, 640e-9), parameter_class=ManualParameter, initial_value=300e-9) self.add_parameter('M_amp', unit='V', vals=vals.Numbers(0, 1), parameter_class=ManualParameter, initial_value=0.1) self.add_parameter('M_phi', unit='deg', parameter_class=ManualParameter, initial_value=0.0) self.add_parameter('M_up_length', unit='s', vals=vals.Numbers(1e-9, 640e-9), parameter_class=ManualParameter, initial_value=100.0e-9) self.add_parameter('M_up_amp', unit='V', vals=vals.Numbers(0, 1), parameter_class=ManualParameter, initial_value=0.1) self.add_parameter('M_up_phi', unit='deg', parameter_class=ManualParameter, initial_value=0.0) self.add_parameter('M_down_length', unit='s', vals=vals.Numbers(1e-9, 640e-9), parameter_class=ManualParameter, initial_value=200.0e-9) self.add_parameter('M_down_amp0', unit='V', vals=vals.Numbers(0, 1), parameter_class=ManualParameter, initial_value=0.1) self.add_parameter('M_down_amp1', unit='V', vals=vals.Numbers(0, 1), parameter_class=ManualParameter, initial_value=0.1) self.add_parameter('M_down_phi0', unit='deg', parameter_class=ManualParameter, initial_value=180.0) self.add_parameter('M_down_phi1', unit='deg', parameter_class=ManualParameter, initial_value=180.0) self.add_parameter('M0_modulation', vals=vals.Numbers(), unit='Hz', parameter_class=ManualParameter, initial_value=20.0e6) self.add_parameter('M1_modulation', vals=vals.Numbers(), unit='Hz', parameter_class=ManualParameter, initial_value=20.0e6) # Set to a default because box is not expected to change self._voltage_min = -1.0 self._voltage_max = 1.0-1.0/2**13
def __init__(self, instrument_name: str, acquisition_controller_names: List[str] = [], default_settings={}, **kwargs): # TODO: Change acquisition_controller_names to acquisition_controllers super().__init__(instrument_name, **kwargs) # Override untargeted pulse adding (measurement pulses can be added) self.pulse_sequence.allow_untargeted_pulses = True default_settings = { 'channel_range': 2, 'coupling': 'DC', **default_settings } # Define channels self._acquisition_channels = { 'ch' + idx: Channel(instrument_name=self.instrument_name(), name='ch' + idx, id=idx, input=True) for idx in ['A', 'B', 'C', 'D'] } self._aux_channels = { 'aux' + idx: Channel(instrument_name=self.instrument_name(), name='aux' + idx, input_TTL=True, output_TTL=(0, 5)) for idx in ['1', '2'] } self._channels = { **self._acquisition_channels, **self._aux_channels, 'trig_in': Channel(instrument_name=self.instrument_name(), name='trig_in', id='trig_in', input_trigger=True), 'software_trig_out': Channel(instrument_name=self.instrument_name(), name='software_trig_out') } self.pulse_implementations = [ SteeredInitializationImplementation(pulse_requirements=[]), TriggerWaitPulseImplementation(pulse_requirements=[]) ] # Organize acquisition controllers self.acquisition_controllers = {} for acquisition_controller_name in acquisition_controller_names: self.add_acquisition_controller(acquisition_controller_name) # Obtain a list of all valid ATS configuration settings self._configuration_settings_names = sorted( list(inspect.signature(AlazarTech_ATS.config).parameters.keys())) # Obtain a list of all valid ATS acquisition settings self._acquisition_settings_names = sorted( list(inspect.signature(AlazarTech_ATS.acquire).parameters.keys())) self._settings_names = sorted(self._acquisition_settings_names + self._configuration_settings_names) self.add_parameter(name='default_settings', get_cmd=None, set_cmd=None, initial_value=default_settings, docstring='Default settings to use when setting up ' 'ATS for a pulse sequence') initial_configuration_settings = { k: v for k, v in default_settings.items() if k in self._configuration_settings_names } self.add_parameter( name='configuration_settings', get_cmd=None, set_cmd=None, vals=vals.Dict(allowed_keys=self._configuration_settings_names), initial_value=initial_configuration_settings) initial_acquisition_settings = { k: v for k, v in default_settings.items() if k in self._acquisition_settings_names } self.add_parameter( name='acquisition_settings', get_cmd=None, set_cmd=None, vals=vals.Dict(allowed_keys=self._acquisition_settings_names), initial_value=initial_acquisition_settings) self.add_parameter(name="acquisition", parameter_class=ATSAcquisitionParameter) self.add_parameter(name='default_acquisition_controller', set_cmd=None, initial_value='None', vals=vals.Enum( None, 'None', *self.acquisition_controllers.keys())) self.add_parameter(name='acquisition_controller', set_cmd=None, vals=vals.Enum( 'None', *self.acquisition_controllers.keys())) # Names of acquisition channels [chA, chB, etc.] self.add_parameter(name='acquisition_channels', set_cmd=None, initial_value=[], vals=vals.Anything(), docstring='Names of acquisition channels ' '[chA, chB, etc.]. Set by the layout') self.add_parameter(name='samples', set_cmd=None, initial_value=1, docstring='Number of times to acquire the pulse ' 'sequence.') self.add_parameter( 'points_per_trace', get_cmd=lambda: self._acquisition_controller.samples_per_trace(), docstring='Number of points in a trace.') self.add_parameter(name='trigger_channel', set_cmd=None, initial_value='trig_in', vals=vals.Enum('trig_in', 'disable', *self._acquisition_channels.keys())) self.add_parameter(name='trigger_slope', set_cmd=None, vals=vals.Enum('positive', 'negative')) self.add_parameter(name='trigger_threshold', unit='V', set_cmd=None, vals=vals.Numbers()) self.add_parameter( name='sample_rate', unit='samples/sec', get_cmd=partial(self.setting, 'sample_rate'), set_cmd=lambda x: self.default_settings().update(sample_rate=x), vals=vals.Numbers(), docstring='Acquisition sampling rate (Hz)') self.add_parameter('capture_full_trace', initial_value=False, vals=vals.Bool(), set_cmd=None, docstring='Capture from t=0 to end of pulse ' 'sequence. False by default, in which ' 'case start and stop times correspond to ' 'min(t_start) and max(t_stop) of all ' 'pulses with the flag acquire=True, ' 'respectively.') self.traces = {} self.pulse_traces = {}