def __init__(self, pulses: list = None, allow_untargeted_pulses: bool = True, allow_targeted_pulses: bool = True, allow_pulse_overlap: bool = True, final_delay: float = None): super().__init__(use_as_attributes=True, log_changes=False, simplify_snapshot=True) # For PulseSequence.satisfies_conditions, we need to separate conditions # into those relating to pulses and to connections. We perform an import # here because it otherwise otherwise leads to circular imports if self.connection_conditions is None or self.pulse_conditions is None: from silq.meta_instruments.layout import connection_conditions from silq.pulses import pulse_conditions PulseSequence.connection_conditions = connection_conditions PulseSequence.pulse_conditions = pulse_conditions self.allow_untargeted_pulses = Parameter( initial_value=allow_untargeted_pulses, set_cmd=None, vals=vals.Bool()) self.allow_targeted_pulses = Parameter( initial_value=allow_targeted_pulses, set_cmd=None, vals=vals.Bool()) self.allow_pulse_overlap = Parameter(initial_value=allow_pulse_overlap, set_cmd=None, vals=vals.Bool()) self.duration = Parameter(unit='s', set_cmd=None) self.final_delay = Parameter(unit='s', set_cmd=None, vals=vals.Numbers()) if final_delay is not None: self.final_delay = final_delay else: self.final_delay = self.default_final_delay self.t_list = Parameter(initial_value=[0]) self.t_start_list = Parameter(initial_value=[]) self.t_stop_list = Parameter() self.enabled_pulses = Parameter(initial_value=[], set_cmd=None, vals=vals.Lists()) self.disabled_pulses = Parameter(initial_value=[], set_cmd=None, vals=vals.Lists()) self.pulses = Parameter(initial_value=[], vals=vals.Lists(), set_cmd=None) self.duration = None # Reset duration to t_stop of last pulse # Perform a separate set to ensure set method is called self.pulses = pulses or []
def _initialize_parameters(self): """Add parameters to instrument upon initialization. """ v_limits = [] for axis in ['x', 'y', 'z']: lims = self.voltage_limits[self.temp][axis] lims_V = [lim.to('V').magnitude for lim in lims] v_limits += lims_V self.add_parameter( 'position', label='Scanner position', unit='V', vals=vals.Lists( elt_validator=vals.Numbers(min(v_limits), max(v_limits))), get_cmd=self.get_pos, set_cmd=self.goto) for i, axis in enumerate(['x', 'y', 'z']): lims = self.voltage_limits[self.temp][axis] lims_V = [lim.to('V').magnitude for lim in lims] self.add_parameter('position_{}'.format(axis), label='{} position'.format(axis), unit='V', vals=vals.Numbers(min(lims_V), max(lims_V)), get_cmd=(lambda idx=i: self.get_pos()[idx]), set_cmd=getattr(self, '_goto_{}'.format(axis)))
def __init__(self, name, **kw): super().__init__(name, **kw) trnsf_mat_docst = ('Converts dac voltages to virtual flux.' 'This matrix is defined as' 'flux = T dac_voltages' 'T is then d flux/ d dac') # Ramiro will expand this to include the proper equations self.add_parameter('transfer_matrix', label='Transfer Matrix', docstring=trnsf_mat_docst, parameter_class=ManualParameter, vals=vals.Arrays()) self._inv_transfer_matrix = None self.add_parameter('inv_transfer_matrix', label='Inverse transfer Matrix', docstring=('Returns the inverse of the transfer' ' matrix, unless explictly specified'), set_cmd=self._do_set_inv_transfer_matrix, get_cmd=self._do_get_inv_transfer_matrix, vals=vals.Arrays()) self.add_parameter( 'dac_mapping', label='mapping of flux channels to current/voltage channels', parameter_class=ManualParameter, vals=vals.Lists())
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 create_awg_parameters(self, channel_name_map): super().create_awg_parameters(channel_name_map) pulsar = self.pulsar name = self.awg.name # Override _min_length parameter created in base class # TODO: Check if this makes sense, it is a constant for the other AWGs # Furthermore, it does not really make sense to manually set the minimum # length which is a property of the instrument... del pulsar.parameters[f"{name}_min_length"] pulsar.add_parameter(f"{name}_min_length", initial_value=self.MIN_LENGTH, parameter_class=ManualParameter) pulsar.add_parameter(f"{name}_use_placeholder_waves", initial_value=False, vals=vals.Bool(), parameter_class=ManualParameter) pulsar.add_parameter(f"{name}_trigger_source", initial_value="Dig1", vals=vals.Enum("Dig1", "DIO", "ZSync"), parameter_class=ManualParameter, docstring="Defines for which trigger source the " "AWG should wait, before playing the " "next waveform. Allowed values are: " "'Dig1', 'DIO', 'ZSync'.") pulsar.add_parameter(f"{name}_prepend_zeros", initial_value=None, vals=vals.MultiType(vals.Enum(None), vals.Ints(), vals.Lists(vals.Ints())), parameter_class=ManualParameter) group = [] for ch_nr in range(8): id = f"ch{ch_nr + 1}" ch_name = channel_name_map.get(id, f"{name}_{id}") self.create_channel_parameters(id, ch_name, "analog") pulsar.channels.add(ch_name) group.append(ch_name) id = f"ch{ch_nr + 1}m" ch_name = channel_name_map.get(id, f"{name}_{id}") self.create_channel_parameters(id, ch_name, "marker") pulsar.channels.add(ch_name) group.append(ch_name) # channel pairs plus the corresponding marker channels are # considered as groups if (ch_nr + 1) % 2 == 0: for ch_name in group: pulsar.channel_groups.update({ch_name: group}) group = []
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) ZI_AcquisitionDevice.__init__(self, *args, **kwargs) self.n_acq_units = len(self.qachannels) self.lo_freqs = [None] * self.n_acq_units # re-create with correct length self.n_acq_int_channels = self.max_qubits_per_channel self._reset_acq_poll_inds() # Mode of the acquisition units ('readout' or 'spectroscopy') # This is different from self._acq_mode (allowed_modes) self._acq_units_modes = {} self._awg_program = [None]*self.n_acq_units self.seqtrigger = None self.timer = None self.awg_active = [False] * self.n_acq_units self.add_parameter( 'allowed_lo_freqs', initial_value=np.arange(1e9, 8.1e9, 100e6), parameter_class=ManualParameter, docstring='List of values that the center frequency (LO) is ' 'allowed to take. As of now this is limited to steps ' 'of 100 MHz.', set_parser=lambda x: list(np.atleast_1d(x).flatten()), vals=validators.MultiType(validators.Lists(), validators.Arrays(), validators.Numbers())) self.add_parameter( 'use_hardware_sweeper', initial_value=False, parameter_class=ManualParameter, docstring='Bool indicating whether the hardware sweeper should ' 'be used in spectroscopy mode', vals=validators.Bool()) self.add_parameter( 'acq_trigger_delay', initial_value=200e-9, parameter_class=ManualParameter, docstring='Delay between the pulse generation and acquisition. ' 'This is used both in the scope and the integration ' 'units for consistency.', vals=validators.Numbers())
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().__init__(name, **kw) self.add_parameter('channel', initial_value=1, vals=vals.Ints(), parameter_class=ManualParameter) self.add_parameter( 'kernel_list', initial_value=[], vals=vals.Lists(vals.Strings()), parameter_class=ConfigParameter, docstring='List of filenames of external kernels to be loaded') self.add_parameter('kernel_dir', initial_value='kernels/', vals=vals.Strings(), parameter_class=ManualParameter, docstring='Path for loading external kernels,' + 'such as room temperature correction kernels.') self.add_parameter('config_changed', vals=vals.Bool(), get_cmd=self._get_config_changed) self.add_parameter( 'kernel', vals=vals.Arrays(), get_cmd=self._get_kernel, docstring=('Returns the predistortion kernel. \n' + 'Recalculates if the parameters changed,\n' + 'otherwise returns a precalculated kernel.\n' + 'Kernel is based on parameters in kernel object \n' + 'and files specified in the kernel list.')) self.add_parameter('skineffect_alpha', unit='', parameter_class=ConfigParameter, initial_value=0, vals=vals.Numbers()) self.add_parameter('skineffect_length', unit='s', parameter_class=ConfigParameter, initial_value=600e-9, vals=vals.Numbers()) self.add_parameter('decay_amp_1', unit='', initial_value=0, parameter_class=ConfigParameter, vals=vals.Numbers()) self.add_parameter('decay_tau_1', unit='s', initial_value=1e-9, parameter_class=ConfigParameter, vals=vals.Numbers()) self.add_parameter('decay_length_1', unit='s', initial_value=100e-9, parameter_class=ConfigParameter, vals=vals.Numbers()) self.add_parameter('decay_amp_2', unit='', initial_value=0, parameter_class=ConfigParameter, vals=vals.Numbers()) self.add_parameter('decay_tau_2', unit='s', initial_value=1e-9, parameter_class=ConfigParameter, vals=vals.Numbers()) self.add_parameter('decay_length_2', unit='s', initial_value=100e-9, parameter_class=ConfigParameter, vals=vals.Numbers()) self.add_parameter('bounce_amp_1', unit='', initial_value=0, parameter_class=ConfigParameter, vals=vals.Numbers()) self.add_parameter('bounce_tau_1', unit='s', initial_value=0, parameter_class=ConfigParameter, vals=vals.Numbers()) self.add_parameter('bounce_length_1', unit='s', initial_value=1e-9, parameter_class=ConfigParameter, vals=vals.Numbers()) self.add_parameter('bounce_amp_2', unit='', initial_value=0, parameter_class=ConfigParameter, vals=vals.Numbers()) self.add_parameter('bounce_tau_2', unit='s', initial_value=0, parameter_class=ConfigParameter, vals=vals.Numbers()) self.add_parameter('bounce_length_2', unit='s', initial_value=1e-9, parameter_class=ConfigParameter, vals=vals.Numbers()) self.add_parameter('poly_a', unit='', initial_value=0, parameter_class=ConfigParameter, vals=vals.Numbers()) self.add_parameter('poly_b', unit='', initial_value=0, parameter_class=ConfigParameter, vals=vals.Numbers()) self.add_parameter('poly_c', unit='', initial_value=1, parameter_class=ConfigParameter, vals=vals.Numbers()) self.add_parameter('poly_length', unit='s', initial_value=600e-9, parameter_class=ConfigParameter, vals=vals.Numbers()) self.add_parameter('corrections_length', unit='s', parameter_class=ConfigParameter, initial_value=10e-6, vals=vals.Numbers()) self.add_parameter('sampling_rate', parameter_class=ManualParameter, initial_value=1e9, vals=vals.Numbers())
def __init__(self, instrument_name, **kwargs): super().__init__(instrument_name, **kwargs) self.pulse_sequence.allow_untargeted_pulses = True self.pulse_sequence.allow_pulse_overlap = True # Initialize channels self._acquisition_channels = { f'ch{k}': Channel(instrument_name=self.instrument_name(), name=f'ch{k}', id=k, input=True) for k in self.instrument.channel_idxs } self._pxi_channels = { f'pxi{k}': Channel(instrument_name=self.instrument_name(), name=f'pxi{k}', id=4000 + k, input_trigger=True, output=True, input=True) for k in range(self.instrument.n_triggers) } self._channels = { **self._acquisition_channels, **self._pxi_channels, 'trig_in': Channel(instrument_name=self.instrument_name(), name='trig_in', input=True), } self.add_parameter(name='acquisition_controller', set_cmd=None, snapshot_value=False, docstring='Acquisition controller for acquiring ' 'data with SD digitizer. ' 'Must be acquisition controller object.') self.add_parameter(name='acquisition_channels', initial_value=[], set_cmd=None, vals=vals.Lists(), docstring='Names of acquisition channels ' '[chA, chB, etc.]. Set by the layout') self.add_parameter('sample_rate', vals=vals.Numbers(), set_cmd=None, docstring='Acquisition sampling rate (Hz)') self.add_parameter('samples', vals=vals.Numbers(), set_cmd=None, 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('channel_selection', set_cmd=None, docstring='Active channel indices to acquire. ' 'Zero-based index (chA -> 0, etc.). ' 'Set during setup and should not be set' 'manually.') self.add_parameter( 'minimum_timeout_interval', unit='s', vals=vals.Numbers(), initial_value=5, set_cmd=None, docstring='Minimum value for timeout when acquiring ' 'data. If 2.1 * pulse_sequence.duration ' 'is lower than this value, it will be ' 'used instead') self.add_parameter( 'trigger_in_duration', unit='s', vals=vals.Numbers(), initial_value=15e-6, set_cmd=None, docstring="Duration for a receiving trigger signal. " "This is passed the the interface that is " "sending the triggers to this instrument.") 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.') # dict of raw unsegmented traces {ch_name: ch_traces} self.traces = {} # Segmented traces per pulse, {pulse_name: {channel_name: {ch_pulse_traces}} self.pulse_traces = {} # Set up the driver to a known default state self.initialize_driver()
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 _add_waveform_parameters(self): # mixer corrections are done globally, can be specified per resonator self.add_parameter('mixer_apply_predistortion_matrix', vals=vals.Bool(), parameter_class=ManualParameter, initial_value=False) self.add_parameter('gaussian_convolution', vals=vals.Bool(), parameter_class=ManualParameter, initial_value=False) self.add_parameter('gaussian_convolution_sigma', vals=vals.Numbers(), parameter_class=ManualParameter, initial_value=5.0e-9, unit='s') 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_offs_I', unit='V', parameter_class=ManualParameter, initial_value=0) self.add_parameter('mixer_offs_Q', unit='V', parameter_class=ManualParameter, initial_value=0) comb_msg = ( 'Resonator combinations specifies which pulses are uploaded to' 'the device. Given as a list of lists:' 'e.g. [[0], [2], [0, 2]] specifies that pulses for readout' 'of resonator 0, 2, and a pulse for mux readout on both should be' 'uploaded.') self.add_parameter('resonator_combinations', vals=vals.Lists(), docstring=comb_msg, set_cmd=self._set_resonator_combinations, get_cmd=self._get_resonator_combinations) self.add_parameter( 'pulse_type', vals=vals.Enum('M_up_down_down', 'M_simple', 'M_up_down_down_final'), set_cmd=self._set_pulse_type, get_cmd=self._get_pulse_type, docstring='defines sequence of segments of the pulse') self.add_parameter( 'pulse_primitive_shape', vals=vals.Enum('square', 'gaussian'), parameter_class=ManualParameter, docstring='defines the shape of the segments of the pulse', initial_value='square') for res in self._resonator_codeword_bit_mapping: self.add_parameter('M_modulation_R{}'.format(res), vals=vals.Numbers(), unit='Hz', parameter_class=ManualParameter, initial_value=20.0e6) self.add_parameter('M_length_R{}'.format(res), unit='s', vals=vals.Numbers(1e-9, 8000e-9), parameter_class=ManualParameter, initial_value=2000e-9) self.add_parameter('M_amp_R{}'.format(res), unit='V', vals=vals.Numbers(0, 1), parameter_class=ManualParameter, initial_value=0.1) self.add_parameter('M_final_amp_R{}'.format(res), unit='V', vals=vals.Numbers(0, 1), parameter_class=ManualParameter, initial_value=0.1) self.add_parameter('M_final_length_R{}'.format(res), unit='s', vals=vals.Numbers(1e-9, 8000e-9), parameter_class=ManualParameter, initial_value=1000e-9) self.add_parameter('M_final_delay_R{}'.format(res), unit='s', vals=vals.Numbers(1e-9, 8000e-9), parameter_class=ManualParameter, initial_value=200e-9) self.add_parameter('M_phi_R{}'.format(res), unit='deg', parameter_class=ManualParameter, initial_value=0.0) self.add_parameter('M_down_length0_R{}'.format(res), unit='s', vals=vals.Numbers(1e-9, 8000e-9), parameter_class=ManualParameter, initial_value=200.0e-9) self.add_parameter('M_down_length1_R{}'.format(res), unit='s', vals=vals.Numbers(1e-9, 8000e-9), parameter_class=ManualParameter, initial_value=200.0e-9) self.add_parameter('M_down_amp0_R{}'.format(res), unit='V', vals=vals.Numbers(-1, 1), parameter_class=ManualParameter, initial_value=0.1) self.add_parameter('M_down_amp1_R{}'.format(res), unit='V', vals=vals.Numbers(-1, 1), parameter_class=ManualParameter, initial_value=0.1) self.add_parameter('M_down_phi0_R{}'.format(res), unit='deg', parameter_class=ManualParameter, initial_value=180.0) self.add_parameter('M_down_phi1_R{}'.format(res), unit='deg', parameter_class=ManualParameter, initial_value=180.0)
def __init__(self, name: str, digitizer: Instrument, **kwargs): """ Initialises a generic Keysight digitizer and its parameters Args: name: Acquisition controller name digitizer: Keysight digitizer instrument """ super().__init__(name, digitizer, **kwargs) self.add_parameter( 'average_mode', set_cmd=None, initial_value='none', vals=vals.Enum('none', 'point', 'trace'), docstring= 'The averaging mode used for acquisition, either none, point or trace' ) self.add_parameter( 'channel_selection', set_cmd=None, vals=vals.Lists(), docstring='The list of channels on which to acquire data.') # Set_cmds are lambda to ensure current active_channels is used self.add_parameter( 'sample_rate', vals=vals.Numbers(min_value=1), set_parser=self._sample_rate_to_prescaler, set_cmd=lambda prescaler: self.active_channels.prescaler(prescaler ), docstring='Sets the sample rate for all channels. The sample rate ' 'will be converted to a prescaler, which must be an int, ' 'and could thus result in a modified sample rate') self.add_parameter( 'trigger_channel', vals=vals.Enum('trig_in', *[f'ch{k}' for k in range(8)], *[f'pxi{k}' for k in range(8)]), set_cmd=self.set_trigger_channel, docstring='The channel on which acquisition is triggered.') self.add_parameter( 'analog_trigger_edge', vals=vals.Enum('rising', 'falling', 'both'), initial_value='rising', set_cmd=lambda edge: self.active_channels.analog_trigger_edge(edge ), docstring= 'Sets the trigger edge sensitivity for the active acquisition controller.' ) self.add_parameter( 'analog_trigger_threshold', vals=vals.Numbers(-3, 3), initial_value=1, set_cmd=lambda threshold: self.active_channels. analog_trigger_threshold(threshold), docstring=f'the value in volts for the trigger threshold') self.add_parameter( 'digital_trigger_mode', vals=vals.Enum('active_high', 'active_low', 'rising', 'falling'), initial_value='rising', set_cmd=lambda mode: self.active_channels.digital_trigger_mode(mode ), docstring= 'Sets the digital trigger mode for the active trigger channel.') self.add_parameter( 'trigger_delay_samples', vals=vals.Numbers(), initial_value=0, set_parser=int, set_cmd=lambda delay: self.active_channels.trigger_delay_samples( delay), docstring='Sets the trigger delay before starting acquisition.') self.add_parameter( 'samples_per_trace', vals=vals.Multiples(divisor=2, min_value=2), set_parser=lambda val: int(round(val)), set_cmd=lambda samples: self.active_channels.points_per_cycle( samples), docstring='The number of points to capture per trace.') self.add_parameter( 'traces_per_acquisition', vals=vals.Numbers(min_value=1), set_parser=lambda val: int(round(val)), set_cmd=lambda n_cycles: self.active_channels.n_cycles(n_cycles), docstring='The number of traces to capture per acquisition. ' 'Must be set after channel_selection is modified.') self.add_parameter( 'traces_per_read', set_cmd=None, vals=vals.Numbers(min_value=1), set_parser=lambda val: int(round(val)), docstring='The number of traces to get per read. ' 'Can be use to break acquisition into multiple reads.') self.add_parameter( 'timeout', vals=vals.Numbers(min_value=0), set_cmd=None, unit='s', docstring= 'The maximum time (s) spent trying to read a single channel. ' 'An acquisition request is sent every timeout_interval. ' 'This must be set after channel_selection is modified.') self.add_parameter( 'timeout_interval', vals=vals.Numbers(min_value=0), set_cmd=lambda timeout: self.active_channels.timeout(timeout), unit='s', docstring= 'The maximum time (s) spent trying to read a single channel. ' 'This must be set after channel_selection is modified.') self.buffers = {} self.is_acquiring = False
def __init__(self, name, **kw): super().__init__(name, **kw) self.add_parameter( "channel", initial_value=1, vals=vals.Ints(), parameter_class=ManualParameter, ) self.add_parameter( "kernel_list", initial_value=[], vals=vals.Lists(vals.Strings()), parameter_class=ConfigParameter, docstring="List of filenames of external kernels to be loaded", ) self.add_parameter( "kernel_dir", initial_value="kernels/", vals=vals.Strings(), parameter_class=ManualParameter, docstring="Path for loading external kernels," + "such as room temperature correction kernels.", ) self.add_parameter("config_changed", vals=vals.Bool(), get_cmd=self._get_config_changed) self.add_parameter( "kernel", vals=vals.Arrays(), get_cmd=self._get_kernel, docstring=("Returns the predistortion kernel. \n" + "Recalculates if the parameters changed,\n" + "otherwise returns a precalculated kernel.\n" + "Kernel is based on parameters in kernel object \n" + "and files specified in the kernel list."), ) self.add_parameter( "skineffect_alpha", unit="", parameter_class=ConfigParameter, initial_value=0, vals=vals.Numbers(), ) self.add_parameter( "skineffect_length", unit="s", parameter_class=ConfigParameter, initial_value=600e-9, vals=vals.Numbers(), ) self.add_parameter( "decay_amp_1", unit="", initial_value=0, parameter_class=ConfigParameter, vals=vals.Numbers(), ) self.add_parameter( "decay_tau_1", unit="s", initial_value=1e-9, parameter_class=ConfigParameter, vals=vals.Numbers(), ) self.add_parameter( "decay_length_1", unit="s", initial_value=100e-9, parameter_class=ConfigParameter, vals=vals.Numbers(), ) self.add_parameter( "decay_amp_2", unit="", initial_value=0, parameter_class=ConfigParameter, vals=vals.Numbers(), ) self.add_parameter( "decay_tau_2", unit="s", initial_value=1e-9, parameter_class=ConfigParameter, vals=vals.Numbers(), ) self.add_parameter( "decay_length_2", unit="s", initial_value=100e-9, parameter_class=ConfigParameter, vals=vals.Numbers(), ) self.add_parameter( "bounce_amp_1", unit="", initial_value=0, parameter_class=ConfigParameter, vals=vals.Numbers(), ) self.add_parameter( "bounce_tau_1", unit="s", initial_value=0, parameter_class=ConfigParameter, vals=vals.Numbers(), ) self.add_parameter( "bounce_length_1", unit="s", initial_value=1e-9, parameter_class=ConfigParameter, vals=vals.Numbers(), ) self.add_parameter( "bounce_amp_2", unit="", initial_value=0, parameter_class=ConfigParameter, vals=vals.Numbers(), ) self.add_parameter( "bounce_tau_2", unit="s", initial_value=0, parameter_class=ConfigParameter, vals=vals.Numbers(), ) self.add_parameter( "bounce_length_2", unit="s", initial_value=1e-9, parameter_class=ConfigParameter, vals=vals.Numbers(), ) self.add_parameter( "poly_a", unit="", initial_value=0, parameter_class=ConfigParameter, vals=vals.Numbers(), ) self.add_parameter( "poly_b", unit="", initial_value=0, parameter_class=ConfigParameter, vals=vals.Numbers(), ) self.add_parameter( "poly_c", unit="", initial_value=1, parameter_class=ConfigParameter, vals=vals.Numbers(), ) self.add_parameter( "poly_length", unit="s", initial_value=600e-9, parameter_class=ConfigParameter, vals=vals.Numbers(), ) self.add_parameter( "corrections_length", unit="s", parameter_class=ConfigParameter, initial_value=10e-6, vals=vals.Numbers(), ) self.add_parameter( "sampling_rate", parameter_class=ManualParameter, initial_value=1e9, vals=vals.Numbers(), )
def __init__(self, name, qubits, connectivity_graph, **kw): """ Instantiates device instrument and adds its parameters. Args: name (str): name of the device qubits (list of QudevTransmon or names of QudevTransmon objects): qubits of the device connectivity_graph: list of elements of the form [qb1, qb2] with qb1 and qb2 QudevTransmon objects or names thereof. qb1 and qb2 should be physically connected on the device. """ super().__init__(name, **kw) qb_names = [qb if isinstance(qb, str) else qb.name for qb in qubits] qubits = [qb if not isinstance(qb, str) else self.find_instrument(qb) for qb in qubits] connectivity_graph = [[qb1 if isinstance(qb1, str) else qb1.name, qb2 if isinstance(qb2, str) else qb2.name] for [qb1, qb2] in connectivity_graph] self._two_qb_gates = [] for qb in qubits: setattr(self, qb.name, qb) self.qubits = qubits self.add_parameter('qb_names', vals=vals.Lists(), initial_value=qb_names, parameter_class=ManualParameter) self._operations = {} # dictionary containing dictionaries of operations with parameters # Instrument reference parameters self.add_parameter('instr_mc', parameter_class=InstrumentRefParameter) self.add_parameter('instr_pulsar', parameter_class=InstrumentRefParameter) self.add_parameter('instr_dc_source', parameter_class=InstrumentRefParameter) self.add_parameter('instr_trigger', parameter_class=InstrumentRefParameter) self.add_parameter('connectivity_graph', vals=vals.Lists(), label="Qubit Connectivity Graph", docstring="Stores the connections between the qubits " "in form of a list of lists [qbi_name, qbj_name]", parameter_class=ManualParameter, initial_value=connectivity_graph ) self.add_parameter('last_calib', vals=vals.Strings(), initial_value='', docstring='stores timestamp of last calibration', parameter_class=ManualParameter) self.add_parameter('operations', docstring='a list of operations on the device, without single QB operations.', get_cmd=self._get_operations) self.add_parameter('two_qb_gates', docstring='stores all two qubit gate names', get_cmd=lambda s=self: copy(s._two_qb_gates) ) self.add_parameter('relative_delay_graph', label='Relative Delay Graph', docstring='Stores the relative delays between ' 'drive and flux channels of the device.', initial_value=RelativeDelayGraph(), parameter_class=ManualParameter, set_parser=RelativeDelayGraph) self.add_parameter('flux_crosstalk_calibs', parameter_class=ManualParameter, ) # Pulse preparation parameters default_prep_params = dict(preparation_type='wait', post_ro_wait=1e-6, reset_reps=1) self.add_parameter('preparation_params', parameter_class=ManualParameter, initial_value=default_prep_params, vals=vals.Dict())
def __init__(self, parent, name, awg_model): super().__init__(parent, name) self.awg_model = awg_model self.channels = [] self.parameters['separation'] = self._parent.separation self.add_parameter('mixer_power', unit='dBm', set_cmd=None, get_parser=float, vals=vals.Numbers(-120, 16), docstring='Power output for mixer.') self.mixer_power(16.) self.add_parameter( 'sigma', unit='s', set_cmd=None, get_parser=float, vals=vals.Numbers(), docstring='Length unit of GaussianPulse and DRAGGaussPulse pulses.' ) self.sigma(2e-8) self.add_parameter( 'truncate', set_cmd=None, get_parser=float, vals=vals.Numbers(), docstring='Truncate GaussianPulse at truncate sigmas from centre.') self.truncate(2) self.add_parameter( 'qscale', set_cmd=None, get_parser=float, vals=vals.Numbers(), docstring='Quadrature scale factor of DRAGGaussPulse') self.qscale(0.5) self.add_parameter( 'anharmonicity', unit='rad/s', set_cmd=None, get_parser=float, vals=vals.Numbers(), docstring='Anharmonicity argument to DRAGGaussPulse') self.anharmonicity(2 * math.pi * 300e6) self.add_parameter('length', unit='s', set_cmd=None, get_parser=float, vals=vals.Numbers(), docstring='Default length of SquarePulse') self.length(20e-9) self.add_parameter('pulse_shape', set_cmd=None, docstring='Supported pulse shapes are:\n\t' + '\n\t'.join(PULSE_SHAPES.keys())) self.pulse_shape('GaussianPulse') self.add_parameter( 'pi_amp', set_cmd=None, get_parser=float, vals=vals.Numbers(), docstring='Amplitude of pi pulses created by pix() and piy().') self.pi_amp(0.9) self.add_parameter( 'pi_half_amp', set_cmd=None, get_parser=float, vals=vals.Numbers(), docstring= 'Amplitude of pi/2 pulses created by pihalfx() and pihalfy().') self.pi_half_amp(0.45) self.add_parameter('mixer_calibration', set_cmd=None, get_parser=list, vals=vals.Lists()) self.mixer_calibration([[1., math.pi / 2.], [1., 0.]]) self.add_parameter('if_freq', unit='rad/s', set_cmd=None, get_parser=float, vals=vals.Numbers()) self.if_freq(100e6)