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.")
