def test_min_max_ints_real_raises(self): with pytest.raises(TypeError, match="min_value must be an instance " "of valid_types."): Arrays(valid_types=(np.floating,), min_value=1) with pytest.raises(TypeError, match="max_value must be an instance " "of valid_types."): Arrays(valid_types=(np.floating,), max_value=6)
def test_text_array_raises(): """Test that an array of text raises""" a = Arrays() with pytest.raises(TypeError, match=r"type of \['A' 'BC' 'CDF'\] is not any of " r"\(<class 'numpy.integer'>, <class " r"'numpy.floating'>\) it is <U3;"): a.validate(np.array(['A', 'BC', 'CDF']))
def test_min_max_real_ints_raises(): with pytest.raises(TypeError, match="min_value must be an instance " "of valid_types."): Arrays(valid_types=(np.integer, ), min_value=1.0) with pytest.raises(TypeError, match="max_value must be an instance " "of valid_types."): Arrays(valid_types=(np.integer, ), max_value=6.0)
def test_complex_default_raises(self): """Complex types should not validate by default""" a = Arrays() for dtype in complex_types: with pytest.raises(TypeError, match=r"is not any of \(<class " r"'numpy.integer'>, <class " r"'numpy.floating'>\) " r"it is complex"): a.validate(np.arange(10, dtype=dtype))
def test_repr(self): a = Arrays() assert str(a) == '<Arrays, shape: None>' b = Arrays(min_value=1, max_value=2) assert str(b) == '<Arrays 1<=v<=2, shape: None>' c = Arrays(shape=(2, 2)) assert str(c) == '<Arrays, shape: (2, 2)>' c = Arrays(shape=(lambda: 2, 2)) assert re.match(r"<Arrays, shape: \(<function TestArrays." r"test_repr.<locals>.<lambda> " r"at 0x[a-fA-f0-9]*>, 2\)>", str(c))
def test_shape(self): m = Arrays(min_value=-5, max_value=50, shape=(2, 2)) v = np.array([[2, 0], [1, 2], [2, 3]]) with self.assertRaises(ValueError): m.validate(v) # should pass if no shape specified m = Arrays(min_value=-5, max_value=50) m.validate(v) v = np.array([[2, 0], [1, 2]]) m.validate(v)
def __init__(self, parent: Instrument, name, channel, it_start=-1, ft_stop=1, in_points=501): super().__init__(parent, name) self.add_parameter('t_start', initial_value=it_start, unit='s', label='t start', vals=Numbers(-1e3, 1e3), get_cmd=None, set_cmd=None) self.add_parameter('t_stop', initial_value=ft_stop, unit='s', label='t stop', vals=Numbers(-1e3, 1e3), get_cmd=None, set_cmd=None) self.add_parameter('n_points', unit='', initial_value=in_points, vals=Numbers(1, 5e4), get_cmd=None, set_cmd=None) self.add_parameter('t_axis', unit='s', label='t Axis', parameter_class=GeneratedSetPoints, startparam=self.t_start, stopparam=self.t_stop, numpointsparam=self.n_points, vals=Arrays(shape=(self.n_points.get_latest, ))) self.add_parameter('wavesample', unit='V', setpoints=(self.t_axis, ), label='Wavesample', parameter_class=DummyArraySignal, vals=Arrays(shape=(self.n_points.get_latest, ))) self.channel = channel
def test_shape(self): m = Arrays(min_value=-5, max_value=50, shape=(2, 2)) v1 = np.array([[2, 0], [1, 2]]) v2 = np.array([[2, 0], [1, 2], [2, 3]]) # v1 is the correct shape but v2 is not m.validate(v1) with self.assertRaises(ValueError): m.validate(v2) # both should pass if no shape specified m = Arrays(min_value=-5, max_value=50) m.validate(v1) m.validate(v2)
def test_complex_min_max_raises(self): """ Min max is not implemented for complex types """ with pytest.raises(TypeError, match=r"min_value must be a real number\." r" It is \(1\+1j\) of type " r"<class 'complex'>"): Arrays(min_value=1+1j) with pytest.raises(TypeError, match=r"max_value must be a real number. " r"It is \(1\+1j\) of type " r"<class 'complex'>"): Arrays(max_value=1+1j) with pytest.raises(TypeError, match=r'Setting min_value or max_value is not ' r'supported for complex validators'): Arrays(max_value=1, valid_types=(np.complexfloating,))
def __init__(self, name, address, **kwargs): super().__init__(name, address, **kwargs) self.add_parameter('sweep_param', source=None, parameter_class=DelegateParameter) self.add_parameter('sweep_start', unit='', initial_value=0, get_cmd=None, set_cmd=None) self.add_parameter('sweep_stop', unit='', initial_value=1, get_cmd=None, set_cmd=None) self.add_parameter('sweep_n_points', unit='', initial_value=10, vals=Numbers(1, 1e3), get_cmd=None, set_cmd=None) self.add_parameter( 'setpoints', parameter_class=GeneratedSetPoints, startparam=self.sweep_start, stopparam=self.sweep_stop, numpointsparam=self.sweep_n_points, vals=Arrays(shape=(self.sweep_n_points.get_latest, ))) self.add_parameter('sweep_wait_time', unit='s', initial_value=0.1, get_cmd=None, set_cmd=None) self.add_parameter( name='trace', get_cmd=self._get_current_data, label='Signal', unit='V', vals=Arrays(shape=(self.sweep_n_points.get_latest, )), setpoints=(self.setpoints, ), parameter_class=ParameterWithSetpoints)
def test_text_type_raises(): """Text types are not supported """ with pytest.raises(TypeError, match="Arrays validator only supports " "numeric types: <class " "'numpy.str_'> is not supported."): Arrays(valid_types=(np.dtype('<U5').type, ))
def test_do1d_parameter_with_array_vals(_param_set): param = ArrayshapedParam(name='paramwitharrayval', vals=Arrays(shape=(10, ))) start = 0 stop = 1 num_points = 15 # make param delay = 0 results = do1d(_param_set, start, stop, num_points, delay, param, do_plot=False) expected_shapes = {'paramwitharrayval': (num_points, 10)} ds = results[0] assert ds.description.shapes == expected_shapes data = ds.get_parameter_data() for name, data in data.items(): for param_data in data.values(): assert param_data.shape == expected_shapes[name]
def test_get_shape_for_param_with_array_validator_from_shape(loop_shape): param = ArrayshapedParam(name='paramwitharrayval', vals=Arrays(shape=(10, ))) shapes = detect_shape_of_measurement((param, ), loop_shape) assert shapes == { "paramwitharrayval": tuple(loop_shape) + param.vals.shape }
def __init__(self, parent: 'Keithley2460', name: str, proper_function: str) -> None: super().__init__(parent, name) self._proper_function = proper_function range_vals = self.function_modes[self._proper_function]["range_vals"] unit = self.function_modes[self._proper_function]["unit"] self.function = self.parent.sense_function self.add_parameter( "four_wire_measurement", set_cmd=f":SENSe:{self._proper_function}:RSENse {{}}", get_cmd=f":SENSe:{self._proper_function}:RSENse?", val_mapping=create_on_off_val_mapping(on_val="1", off_val="0")) self.add_parameter( "range", set_cmd=f":SENSe:{self._proper_function}:RANGe {{}}", get_cmd=f":SENSe:{self._proper_function}:RANGe?", vals=range_vals, get_parser=float, unit=unit) self.add_parameter( "auto_range", set_cmd=f":SENSe:{self._proper_function}:RANGe:AUTO {{}}", get_cmd=f":SENSe:{self._proper_function}:RANGe:AUTO?", val_mapping=create_on_off_val_mapping(on_val="1", off_val="0")) self.add_parameter(self._proper_function, get_cmd=self._measure, get_parser=float, unit=unit, snapshot_value=False) self.add_parameter("sweep", label=self._proper_function, get_cmd=self._measure_sweep, unit=unit, vals=Arrays(shape=(self.parent.npts, )), parameter_class=ParameterWithSetpoints) self.add_parameter( "nplc", get_cmd=f":SENSe:{self._proper_function}:NPLCycles?", set_cmd=f":SENSe:{self._proper_function}:NPLCycles {{}}", vals=Numbers(0.001, 10)) self.add_parameter('user_number', get_cmd=None, set_cmd=None, vals=Ints(1, 5)) self.add_parameter("user_delay", get_cmd=self._get_user_delay, set_cmd=self._set_user_delay, vals=Numbers(0, 1e4))
def __init__(self, name: str, lockins: tuple, *args, **kwargs) -> None: super().__init__(name, *args, **kwargs) self.lockins = lockins for lockin in self.lockins: lockin.buffer_SR('Trigger') lockin.buffer_trig_mode.set('ON') self.add_parameter('sweep_start', unit='', initial_value=0, get_cmd=None, set_cmd=None) self.add_parameter('sweep_stop', unit='', initial_value=1, get_cmd=None, set_cmd=None) self.add_parameter('sweep_n_points', unit='', initial_value=10, vals=Numbers(1, 1e3), get_cmd=None, set_cmd=None) self.add_parameter( 'setpoints', parameter_class=GeneratedSetPoints, startparam=self.sweep_start, stopparam=self.sweep_stop, numpointsparam=self.sweep_n_points, vals=Arrays(shape=(self.sweep_n_points.get_latest, ))) for lockin in lockins: self.add_parameter( 'trace_{}'.format(lockin.name), label='Signal {}'.format(lockin.name), get_cmd=lockin.prepare_and_get_buffer, unit='V', vals=Arrays(shape=(self.sweep_n_points.get_latest, )), setpoints=(self.setpoints, ), parameter_class=ParameterWithSetpoints)
def __init__(self, parent: 'Keithley2450', name: str, proper_function: str) -> None: super().__init__(parent, name) self._proper_function = proper_function range_vals = self.function_modes[self._proper_function]["range_vals"] unit = self.function_modes[self._proper_function]["unit"] self.function = self.parent.source_function self._sweep_arguments: Dict[str, Union[float, int, str]] = {} self.add_parameter( "range", set_cmd=f":SOUR:{self._proper_function}:RANGe {{}}", get_cmd=f":SOUR:{self._proper_function}:RANGe?", vals=range_vals, get_parser=float, unit=unit ) self.add_parameter( "auto_range", set_cmd=f":SOURce:{self._proper_function}:RANGe:AUTO {{}}", get_cmd=f":SOURce:{self._proper_function}:RANGe:AUTO?", val_mapping=create_on_off_val_mapping(on_val="1", off_val="0") ) limit_cmd = {"current": "VLIM", "voltage": "ILIM"}[self._proper_function] self.add_parameter( "limit", set_cmd=f"SOUR:{self._proper_function}:{limit_cmd} {{}}", get_cmd=f"SOUR:{self._proper_function}:{limit_cmd}?", get_parser=float, unit=unit ) self.add_parameter( "limit_tripped", get_cmd=f":SOUR:{self._proper_function}:{limit_cmd}:TRIPped?", val_mapping={True: 1, False: 0} ) self.add_parameter( self._proper_function, set_cmd=f"SOUR:{self._proper_function} {{}}", get_cmd=f"SOUR:{self._proper_function}?", get_parser=float, unit=unit, snapshot_value=False ) self.add_parameter( "sweep_axis", label=self._proper_function, get_cmd=self.get_sweep_axis, vals=Arrays(shape=(self.parent.npts,)), unit=unit )
def test_shape_defered(self): m = Arrays(min_value=-5, max_value=50, shape=(lambda: 2, lambda: 2)) v1 = np.array([[2, 5], [3, 7]]) m.validate(v1) v2 = np.array([[2, 0], [1, 2], [2, 3]]) with self.assertRaises(ValueError): m.validate(v2)
def test_real_subtypes(): """ Test that validating a concrete real type into an array that only support other concrete types raises as expected """ types = list(numpy_concrete_ints + numpy_concrete_floats) randint = np.random.randint(0, len(types)) mytype = types.pop(randint) a = Arrays(valid_types=(mytype, )) a.validate(np.arange(10, dtype=mytype)) a = Arrays(valid_types=types) with pytest.raises(TypeError, match=r'is not any of'): a.validate(np.arange(10, dtype=mytype))
def __init__(self, parent: "DS1074Z", name: str, channel: int): super().__init__(parent, name) self.channel = channel self.add_parameter("vertical_scale", get_cmd=f":CHANnel{channel}:SCALe?", set_cmd=":CHANnel{}:SCALe {}".format(channel, "{}"), get_parser=float) self.add_parameter("trace", get_cmd=self._get_full_trace, vals=Arrays(shape=(self.parent.waveform_npoints, )), setpoints=(self.parent.time_axis, ), unit='V', parameter_class=ParameterWithSetpoints, snapshot_value=False)
def test_do1d_parameter_with_array_vals(_param_set): param = ArrayshapedParam(name='paramwitharrayval', vals=Arrays(shape=(10, ))) start = 0 stop = 1 num_points = 15 # make param delay = 0 results = do1d(_param_set, start, stop, num_points, delay, param, do_plot=False) expected_shapes = {'paramwitharrayval': (num_points, 10)} assert results[0].description.shapes == expected_shapes
def test_default_types(): """Arrays constructed with all concrete and abstract real number types should validate by default""" a = Arrays() integer_types = (int, ) + numpy_non_concrete_ints + numpy_concrete_ints for mytype in integer_types: a.validate(np.arange(10, dtype=mytype)) float_types = (float,) + numpy_non_concrete_floats \ + numpy_concrete_floats for mytype in float_types: a.validate(np.arange(10, dtype=mytype))
def __init__(self, name, address, terminator='\n', timeout=5, **kwargs): super().__init__(name, address, terminator=terminator, timeout=timeout, **kwargs) self.add_parameter('waveform_xorigin', get_cmd='WAVeform:XORigin?', unit='s', get_parser=float) self.add_parameter('waveform_xincrem', get_cmd=':WAVeform:XINCrement?', unit='s', get_parser=float) self.add_parameter('waveform_npoints', get_cmd='WAV:POIN?', set_cmd='WAV:POIN {}', unit='s', get_parser=int) self.add_parameter('waveform_yorigin', get_cmd='WAVeform:YORigin?', unit='V', get_parser=float) self.add_parameter('waveform_yincrem', get_cmd=':WAVeform:YINCrement?', unit='V', get_parser=float) self.add_parameter('waveform_yref', get_cmd=':WAVeform:YREFerence?', unit='V', get_parser=float) self.add_parameter('trigger_mode', get_cmd=':TRIGger:MODE?', set_cmd=':TRIGger:MODE {}', unit='V', vals=Enum('edge', 'pulse', 'video', 'pattern'), get_parser=str) # trigger source self.add_parameter('trigger_level', unit='V', get_cmd=self._get_trigger_level, set_cmd=self._set_trigger_level, vals=Numbers()) self.add_parameter('trigger_edge_source', label='Source channel for the edge trigger', get_cmd=':TRIGger:EDGE:SOURce?', set_cmd=':TRIGger:EDGE:SOURce {}', val_mapping={ 'ch1': 'CHAN1', 'ch2': 'CHAN2', 'ch3': 'CHAN3', 'ch4': 'CHAN4' }) self.add_parameter('trigger_edge_slope', label='Slope of the edge trigger', get_cmd=':TRIGger:EDGE:SLOPe?', set_cmd=':TRIGger:EDGE:SLOPe {}', vals=Enum('positive', 'negative', 'neither')) self.add_parameter('data_source', label='Waveform Data source', get_cmd=':WAVeform:SOURce?', set_cmd=':WAVeform:SOURce {}', val_mapping={ 'ch1': 'CHAN1', 'ch2': 'CHAN2', 'ch3': 'CHAN3', 'ch4': 'CHAN4' }) self.add_parameter('time_axis', unit='s', label='Time', set_cmd=False, get_cmd=self._get_time_axis, vals=Arrays(shape=(self.waveform_npoints, )), snapshot_value=False) channels = ChannelList(self, "channels", RigolDS1074ZChannel, snapshotable=False) for channel_number in range(1, 5): channel = RigolDS1074ZChannel(self, "ch{}".format(channel_number), channel_number) channels.append(channel) channels.lock() self.add_submodule('channels', channels) self.connect_message()
def test_min_max(self): m = Arrays(min_value=-5, max_value=50, shape=(2, 2)) v = np.array([[2, 0], [1, 2]]) m.validate(v) v = 100 * v with self.assertRaises(ValueError): m.validate(v) v = -1 * v with self.assertRaises(ValueError): m.validate(v) m = Arrays(min_value=-5, shape=(2, 2)) v = np.array([[2, 0], [1, 2]]) m.validate(v * 100)
def __init__( self, parent: 'Keithley7510', name: str, size: Optional[int] = None, style: str = '' ) -> None: super().__init__(parent, name) self._size = size self.style = style if self.short_name not in self.default_buffer: # when making a new buffer, the "size" parameter is required. if size is None: raise TypeError( "buffer() missing 1 required positional argument: 'size'" ) self.write( f":TRACe:MAKE '{self.short_name}', {self._size}, {self.style}" ) else: # when referring to default buffer, "size" parameter is not needed. if size is not None: self.log.warning( f"Please use method 'size()' to resize default buffer " f"{self.short_name} size to {self._size}." ) self.add_parameter( "size", get_cmd=f":TRACe:POINts? '{self.short_name}'", set_cmd=f":TRACe:POINts {{}}, '{self.short_name}'", get_parser=int, docstring="The number of readings a buffer can store." ) self.add_parameter( "number_of_readings", get_cmd=f":TRACe:ACTual? '{self.short_name}'", get_parser=int, docstring="Get the number of readings in the reading buffer." ) self.add_parameter( "last_index", get_cmd=f":TRACe:ACTual:END? '{self.short_name}'", get_parser=int, docstring="Get the last index of readings in the reading buffer." ) self.add_parameter( "first_index", get_cmd=f":TRACe:ACTual:STARt? '{self.short_name}'", get_parser=int, docstring="Get the starting index of readings in the reading " "buffer." ) self.add_parameter( "data_start", initial_value=1, get_cmd=None, set_cmd=None, docstring="First index of the data to be returned." ) self.add_parameter( "data_end", initial_value=1, get_cmd=None, set_cmd=None, docstring="Last index of the data to be returned." ) self.add_parameter( "elements", get_cmd=None, get_parser=self._from_scpi_to_name, set_cmd=None, set_parser=self._from_name_to_scpi, vals=Lists(Enum(*list(self.buffer_elements.keys()))), docstring="List of buffer elements to read." ) self.add_parameter( "setpoints_start", label="start value for the setpoints", source=None, parameter_class=DelegateParameter ) self.add_parameter( "setpoints_stop", label="stop value for the setpoints", source=None, parameter_class=DelegateParameter ) self.add_parameter( "n_pts", label="total n for the setpoints", get_cmd=self._get_n_pts ) self.add_parameter( "setpoints", parameter_class=GeneratedSetPoints, start=self.setpoints_start, stop=self.setpoints_stop, n_points=self.n_pts, vals=Arrays(shape=(self.n_pts.get_latest,)) ) self.add_parameter( "t_start", label="start time", unit="s", initial_value=0, get_cmd=None, set_cmd=None, set_parser=float ) self.add_parameter( "t_stop", label="stop time", unit="s", initial_value=1, get_cmd=None, set_cmd=None, set_parser=float ) self.add_parameter( "fill_mode", get_cmd=f":TRACe:FILL:MODE? '{self.short_name}'", set_cmd=f":TRACe:FILL:MODE {{}}, '{self.short_name}'", vals=Enum('CONT', 'continuous', 'ONCE', 'once'), docstring="if a reading buffer is filled continuously or is filled" " once and stops" )
def test_type(self): m = Arrays(min_value=0.0, max_value=3.2, shape=(2, 2)) for v in ['somestring', 4, 2, [[2, 0], [1, 2]]]: with self.assertRaises(TypeError): m.validate(v)
def __init__(self, parent, name, channel): super().__init__(parent, name) self._channel = channel # Add the various channel parameters self.add_parameter('temperature', parameter_class=Parameter, initial_value=0, label="Temperature_{}".format(channel), unit='K', vals=Numbers(0, 300), get_cmd=None, set_cmd=None) self.add_parameter(name='dummy_multi_parameter', parameter_class=MultiSetPointParam) self.add_parameter(name='dummy_scalar_multi_parameter', parameter_class=MultiScalarParam) self.add_parameter(name='dummy_2d_multi_parameter', parameter_class=Multi2DSetPointParam) self.add_parameter(name='dummy_array_parameter', parameter_class=ArraySetPointParam) self.add_parameter('dummy_start', initial_value=0, unit='some unit', label='f start', vals=Numbers(0, 1e3), get_cmd=None, set_cmd=None) self.add_parameter('dummy_stop', unit='some unit', label='f stop', vals=Numbers(1, 1e3), get_cmd=None, set_cmd=None) self.add_parameter('dummy_n_points', unit='', vals=Numbers(1, 1e3), get_cmd=None, set_cmd=None) self.add_parameter('dummy_sp_axis', unit='some unit', label='Dummy sp axis', parameter_class=GeneratedSetPoints, startparam=self.dummy_start, stopparam=self.dummy_stop, numpointsparam=self.dummy_n_points, vals=Arrays(shape=(self.dummy_n_points, ))) self.add_parameter(name='dummy_parameter_with_setpoints', label='Dummy Parameter with Setpoints', unit='some other unit', setpoints=(self.dummy_sp_axis, ), vals=Arrays(shape=(self.dummy_n_points, )), parameter_class=DummyParameterWithSetpoints1D) self.add_function(name='log_my_name', call_cmd=partial(log.debug, f'{name}'))
def test_do0d_parameter_with_array_vals(): param = ArrayshapedParam(name='paramwitharrayval', vals=Arrays(shape=(10, ))) results = do0d(param) expected_shapes = {'paramwitharrayval': (10, )} assert results[0].description.shapes == expected_shapes
def __init__(self, parent, name, channel): super().__init__(parent, name) self._channel = channel # Add the various channel parameters self.add_parameter('temperature', parameter_class=Parameter, initial_value=0, label=f"Temperature_{channel}", unit='K', vals=Numbers(0, 300), get_cmd=None, set_cmd=None) self.add_parameter(name='dummy_multi_parameter', parameter_class=MultiSetPointParam) self.add_parameter(name='dummy_scalar_multi_parameter', parameter_class=MultiScalarParam) self.add_parameter(name='dummy_2d_multi_parameter', parameter_class=Multi2DSetPointParam) self.add_parameter(name='dummy_2d_multi_parameter_2', parameter_class=Multi2DSetPointParam2Sizes) self.add_parameter(name='dummy_array_parameter', parameter_class=ArraySetPointParam) self.add_parameter(name='dummy_complex_array_parameter', parameter_class=ComplexArraySetPointParam) self.add_parameter('dummy_start', initial_value=0, unit='some unit', label='f start', vals=Numbers(0, 1e3), get_cmd=None, set_cmd=None) self.add_parameter( "dummy_stop", initial_value=100, unit="some unit", label="f stop", vals=Numbers(1, 1e3), get_cmd=None, set_cmd=None, ) self.add_parameter( "dummy_n_points", initial_value=101, unit="", vals=Numbers(1, 1e3), get_cmd=None, set_cmd=None, ) self.add_parameter('dummy_start_2', initial_value=0, unit='some unit', label='f start', vals=Numbers(0, 1e3), get_cmd=None, set_cmd=None) self.add_parameter( "dummy_stop_2", initial_value=100, unit="some unit", label="f stop", vals=Numbers(1, 1e3), get_cmd=None, set_cmd=None, ) self.add_parameter( "dummy_n_points_2", initial_value=101, unit="", vals=Numbers(1, 1e3), get_cmd=None, set_cmd=None, ) self.add_parameter('dummy_sp_axis', unit='some unit', label='Dummy sp axis', parameter_class=GeneratedSetPoints, startparam=self.dummy_start, stopparam=self.dummy_stop, numpointsparam=self.dummy_n_points, vals=Arrays(shape=(self.dummy_n_points, ))) self.add_parameter('dummy_sp_axis_2', unit='some unit', label='Dummy sp axis', parameter_class=GeneratedSetPoints, startparam=self.dummy_start_2, stopparam=self.dummy_stop_2, numpointsparam=self.dummy_n_points_2, vals=Arrays(shape=(self.dummy_n_points_2, ))) self.add_parameter(name='dummy_parameter_with_setpoints', label='Dummy Parameter with Setpoints', unit='some other unit', setpoints=(self.dummy_sp_axis, ), vals=Arrays(shape=(self.dummy_n_points, )), parameter_class=DummyParameterWithSetpoints1D) self.add_parameter(name='dummy_parameter_with_setpoints_2d', label='Dummy Parameter with Setpoints', unit='some other unit', setpoints=(self.dummy_sp_axis, self.dummy_sp_axis_2), vals=Arrays(shape=(self.dummy_n_points, self.dummy_n_points_2)), parameter_class=DummyParameterWithSetpoints2D) self.add_parameter(name='dummy_text', label='Dummy text', unit='text unit', initial_value='thisisastring', set_cmd=None, vals=Strings()) self.add_parameter(name='dummy_complex', label='Dummy complex', unit='complex unit', initial_value=1 + 1j, set_cmd=None, vals=ComplexNumbers()) self.add_parameter(name='dummy_parameter_with_setpoints_complex', label='Dummy Parameter with Setpoints complex', unit='some other unit', setpoints=(self.dummy_sp_axis, ), vals=Arrays(shape=(self.dummy_n_points, ), valid_types=(np.complexfloating, )), parameter_class=DummyParameterWithSetpointsComplex) self.add_function(name='log_my_name', call_cmd=partial(log.debug, f'{name}'))
def __init__(self, parent: "N9030B", name: str, *arg: Any, **kwargs: Any): super().__init__(parent, name, *arg, **kwargs) self._min_freq = -8e7 self._valid_max_freq: Dict[str, float] = { "503": 3.7e9, "508": 8.5e9, "513": 13.8e9, "526": 27e9, "544": 44.5e9 } opt: str for hw_opt_for_max_freq in self._valid_max_freq.keys(): if hw_opt_for_max_freq in self.root_instrument._options(): opt = hw_opt_for_max_freq self._max_freq = self._valid_max_freq[opt] self.add_parameter(name="start", unit="Hz", get_cmd=":SENSe:FREQuency:STARt?", set_cmd=self._set_start, get_parser=float, vals=Numbers(self._min_freq, self._max_freq - 10), docstring="start frequency for the sweep") self.add_parameter(name="stop", unit="Hz", get_cmd=":SENSe:FREQuency:STOP?", set_cmd=self._set_stop, get_parser=float, vals=Numbers(self._min_freq + 10, self._max_freq), docstring="stop frequency for the sweep") self.add_parameter(name="center", unit="Hz", get_cmd=":SENSe:FREQuency:CENTer?", set_cmd=self._set_center, get_parser=float, vals=Numbers(self._min_freq + 5, self._max_freq - 5), docstring="Sets and gets center frequency") self.add_parameter(name="span", unit="Hz", get_cmd=":SENSe:FREQuency:SPAN?", set_cmd=self._set_span, get_parser=float, vals=Numbers(10, self._max_freq - self._min_freq), docstring="Changes span of frequency") self.add_parameter(name="npts", get_cmd=":SENSe:SWEep:POINts?", set_cmd=self._set_npts, get_parser=int, vals=Ints(1, 20001), docstring="Number of points for the sweep") self.add_parameter(name="sweep_time", label="Sweep time", get_cmd=":SENSe:SWEep:TIME?", set_cmd=":SENSe:SWEep:TIME {}", get_parser=float, unit="s", docstring="gets sweep time") self.add_parameter(name="auto_sweep_time_enabled", get_cmd=":SENSe:SWEep:TIME:AUTO?", set_cmd=self._enable_auto_sweep_time, val_mapping=create_on_off_val_mapping( on_val="ON", off_val="OFF"), docstring="enables auto sweep time") self.add_parameter(name="auto_sweep_type_enabled", get_cmd=":SENSe:SWEep:TYPE:AUTO?", set_cmd=self._enable_auto_sweep_type, val_mapping=create_on_off_val_mapping( on_val="ON", off_val="OFF"), docstring="enables auto sweep type") self.add_parameter( name="sweep_type", get_cmd=":SENSe:SWEep:TYPE?", set_cmd=self._set_sweep_type, val_mapping={ "fft": "FFT", "sweep": "SWE", }, docstring="Sets up sweep type. Possible options are 'fft' and " "'sweep'.") self.add_parameter( name="freq_axis", label="Frequency", unit="Hz", start=self.start, stop=self.stop, npts=self.npts, vals=Arrays(shape=(self.npts.get_latest, )), parameter_class=FrequencyAxis, docstring="Creates frequency axis for the sweep from start, " "stop and npts values.") self.add_parameter(name="trace", label="Trace", unit="dB", number=1, vals=Arrays(shape=(self.npts.get_latest, )), setpoints=(self.freq_axis, ), parameter_class=Trace, docstring="Gets trace data.")
def __init__(self, parent: "N9030B", name: str, *arg: Any, **kwargs: Any): super().__init__(parent, name, *arg, **kwargs) self._min_freq = 1 self._valid_max_freq: Dict[str, float] = { "503": 3699999995, "508": 8499999995, "513": 13799999995, "526": 26999999995, "544": 44499999995 } opt: str for hw_opt_for_max_freq in self._valid_max_freq.keys(): if hw_opt_for_max_freq in self.root_instrument._options(): opt = hw_opt_for_max_freq self._max_freq = self._valid_max_freq[opt] self.add_parameter(name="npts", get_cmd=":SENSe:LPLot:SWEep:POINts?", set_cmd=":SENSe:LPLot:SWEep:POINts {}", get_parser=int, vals=Ints(601, 20001), docstring="Number of points for the sweep") self.add_parameter(name="start_offset", unit="Hz", get_cmd=":SENSe:LPLot:FREQuency:OFFSet:STARt?", set_cmd=self._set_start_offset, get_parser=float, vals=Numbers(self._min_freq, self._max_freq - 10), docstring="start frequency offset for the plot") self.add_parameter(name="stop_offset", unit="Hz", get_cmd=":SENSe:LPLot:FREQuency:OFFSet:STOP?", set_cmd=self._set_stop_offset, get_parser=float, vals=Numbers(self._min_freq + 99, self._max_freq), docstring="stop frequency offset for the plot") self.add_parameter( name="signal_tracking_enabled", get_cmd=":SENSe:FREQuency:CARRier:TRACk?", set_cmd=":SENSe:FREQuency:CARRier:TRACk {}", val_mapping=create_on_off_val_mapping(on_val="ON", off_val="OFF"), docstring="Gets/Sets signal tracking. When signal tracking is " "enabled carrier signal is repeatedly realigned. Signal " "Tracking assumes the new acquisition occurs repeatedly " "without pause.") self.add_parameter( name="freq_axis", label="Frequency", unit="Hz", start=self.start_offset, stop=self.stop_offset, npts=self.npts, vals=Arrays(shape=(self.npts.get_latest, )), parameter_class=FrequencyAxis, docstring="Creates frequency axis for the sweep from " "start_offset, stop_offset and npts values.") self.add_parameter(name="trace", label="Trace", unit="dB", number=3, vals=Arrays(shape=(self.npts.get_latest, )), setpoints=(self.freq_axis, ), parameter_class=Trace, docstring="Gets trace data.")