from __future__ import annotations
import time
from functools import partial
from typing import TYPE_CHECKING, Any, ClassVar
import numpy as np
from qcodes.instrument import VisaInstrument, VisaInstrumentKWArgs
from qcodes.parameters import (
ArrayParameter,
Parameter,
ParameterWithSetpoints,
ParamRawDataType,
)
from qcodes.validators import Arrays, ComplexNumbers, Enum, Ints, Numbers, Strings
if TYPE_CHECKING:
from collections.abc import Iterable
from typing_extensions import Unpack
class ChannelTrace(ParameterWithSetpoints):
"""
Parameter class for the two channel buffers
"""
def __init__(self, name: str, channel: int, **kwargs: Any) -> None:
"""
Args:
name: The name of the parameter
channel: The relevant channel (1 or 2). The name should
match this.
**kwargs: kwargs are forwarded to base class.
"""
super().__init__(name, **kwargs)
self._valid_channels = (1, 2)
if channel not in self._valid_channels:
raise ValueError('Invalid channel specifier. SR830 only has '
'channels 1 and 2.')
if not isinstance(self.root_instrument, SR830):
raise ValueError('Invalid parent instrument. ChannelBuffer '
'can only live on an SR830.')
self.channel = channel
self.update_unit()
def update_unit(self) -> None:
assert isinstance(self.root_instrument, SR830)
params = self.root_instrument.parameters
if params[f'ch{self.channel}_ratio'].get() != 'none':
self.unit = '%'
else:
disp = params[f'ch{self.channel}_display'].get()
if disp == 'Phase':
self.unit = 'deg'
else:
self.unit = 'V'
self.label = disp
def get_raw(self) -> ParamRawDataType:
"""
Get command. Returns numpy array
"""
assert isinstance(self.root_instrument, SR830)
N = self.root_instrument.buffer_npts()
if N == 0:
raise ValueError('No points stored in SR830 data buffer.'
' Can not poll anything.')
# poll raw binary data
self.root_instrument.write(f'TRCL ? {self.channel}, 0, {N}')
rawdata = self.root_instrument.visa_handle.read_raw()
# parse it
realdata = np.frombuffer(rawdata, dtype="<i2")
numbers = realdata[::2] * 2.0 ** (realdata[1::2] - 124)
return numbers
class ChannelBuffer(ArrayParameter):
"""
Parameter class for the two channel buffers
Currently always returns the entire buffer
TODO (WilliamHPNielsen): Make it possible to query parts of the buffer.
The instrument natively supports this in its TRCL call.
"""
def __init__(self, name: str, instrument: SR830, channel: int) -> None:
"""
Args:
name: The name of the parameter
instrument: The parent instrument
channel: The relevant channel (1 or 2). The name should
should match this.
"""
self._valid_channels = (1, 2)
if channel not in self._valid_channels:
raise ValueError('Invalid channel specifier. SR830 only has '
'channels 1 and 2.')
if not isinstance(instrument, SR830):
raise ValueError('Invalid parent instrument. ChannelBuffer '
'can only live on an SR830.')
super().__init__(
name,
shape=(1,), # dummy initial shape
unit="V", # dummy initial unit
setpoint_names=("Time",),
setpoint_labels=("Time",),
setpoint_units=("s",),
docstring="Holds an acquired (part of the) data buffer of one channel.",
instrument=instrument,
)
self.channel = channel
def prepare_buffer_readout(self) -> None:
"""
Function to generate the setpoints for the channel buffer and
get the right units
"""
assert isinstance(self.instrument, SR830)
N = self.instrument.buffer_npts() # problem if this is zero?
# TODO (WilliamHPNielsen): what if SR was changed during acquisition?
SR = self.instrument.buffer_SR()
if SR == 'Trigger':
self.setpoint_units = ('',)
self.setpoint_names = ('trig_events',)
self.setpoint_labels = ('Trigger event number',)
self.setpoints = (tuple(np.arange(0, N)),)
else:
dt = 1/SR
self.setpoint_units = ('s',)
self.setpoint_names = ('Time',)
self.setpoint_labels = ('Time',)
self.setpoints = (tuple(np.linspace(0, N*dt, N)),)
self.shape = (N,)
params = self.instrument.parameters
# YES, it should be: comparing to the string 'none' and not
# the None literal
if params[f'ch{self.channel}_ratio'].get() != 'none':
self.unit = '%'
else:
disp = params[f'ch{self.channel}_display'].get()
if disp == 'Phase':
self.unit = 'deg'
else:
self.unit = 'V'
if self.channel == 1:
self.instrument._buffer1_ready = True
else:
self.instrument._buffer2_ready = True
def get_raw(self) -> ParamRawDataType:
"""
Get command. Returns numpy array
"""
assert isinstance(self.instrument, SR830)
if self.channel == 1:
ready = self.instrument._buffer1_ready
else:
ready = self.instrument._buffer2_ready
if not ready:
raise RuntimeError('Buffer not ready. Please run '
'prepare_buffer_readout')
N = self.instrument.buffer_npts()
if N == 0:
raise ValueError('No points stored in SR830 data buffer.'
' Can not poll anything.')
# poll raw binary data
self.instrument.write(f"TRCL ? {self.channel}, 0, {N}")
rawdata = self.instrument.visa_handle.read_raw()
# parse it
realdata = np.frombuffer(rawdata, dtype="<i2")
numbers = realdata[::2] * 2.0 ** (realdata[1::2] - 124)
if self.shape[0] != N:
raise RuntimeError(
f"SR830 got {N} points in buffer expected {self.shape[0]}"
)
return numbers
[docs]
class SR830(VisaInstrument):
"""
QCoDeS driver for the Stanford Research Systems SR830 Lock-in Amplifier.
"""
_VOLT_TO_N: ClassVar[dict[float | int, int]] = {
2e-9: 0,
5e-9: 1,
10e-9: 2,
20e-9: 3,
50e-9: 4,
100e-9: 5,
200e-9: 6,
500e-9: 7,
1e-6: 8,
2e-6: 9,
5e-6: 10,
10e-6: 11,
20e-6: 12,
50e-6: 13,
100e-6: 14,
200e-6: 15,
500e-6: 16,
1e-3: 17,
2e-3: 18,
5e-3: 19,
10e-3: 20,
20e-3: 21,
50e-3: 22,
100e-3: 23,
200e-3: 24,
500e-3: 25,
1: 26,
}
_N_TO_VOLT: ClassVar[dict[int, float | int]] = {v: k for k, v in _VOLT_TO_N.items()}
_CURR_TO_N: ClassVar[dict[float, int]] = {
2e-15: 0,
5e-15: 1,
10e-15: 2,
20e-15: 3,
50e-15: 4,
100e-15: 5,
200e-15: 6,
500e-15: 7,
1e-12: 8,
2e-12: 9,
5e-12: 10,
10e-12: 11,
20e-12: 12,
50e-12: 13,
100e-12: 14,
200e-12: 15,
500e-12: 16,
1e-9: 17,
2e-9: 18,
5e-9: 19,
10e-9: 20,
20e-9: 21,
50e-9: 22,
100e-9: 23,
200e-9: 24,
500e-9: 25,
1e-6: 26,
}
_N_TO_CURR: ClassVar[dict[int, float]] = {v: k for k, v in _CURR_TO_N.items()}
_VOLT_ENUM = Enum(*_VOLT_TO_N.keys())
_CURR_ENUM = Enum(*_CURR_TO_N.keys())
_INPUT_CONFIG_TO_N: ClassVar[dict[str, int]] = {
'a': 0,
'a-b': 1,
'I 1M': 2,
'I 100M': 3,
}
_N_TO_INPUT_CONFIG: ClassVar[dict[int, str]] = {
v: k for k, v in _INPUT_CONFIG_TO_N.items()
}
def __init__(self, name: str, address: str, **kwargs: Unpack[VisaInstrumentKWArgs]):
super().__init__(name, address, **kwargs)
# Reference and phase
self.phase: Parameter = self.add_parameter(
"phase",
label="Phase",
get_cmd="PHAS?",
get_parser=float,
set_cmd="PHAS {:.2f}",
unit="deg",
vals=Numbers(min_value=-360, max_value=729.99),
)
"""Parameter phase"""
self.reference_source: Parameter = self.add_parameter(
"reference_source",
label="Reference source",
get_cmd="FMOD?",
set_cmd="FMOD {}",
val_mapping={
"external": 0,
"internal": 1,
},
vals=Enum("external", "internal"),
)
"""Parameter reference_source"""
self.frequency: Parameter = self.add_parameter(
"frequency",
label="Frequency",
get_cmd="FREQ?",
get_parser=float,
set_cmd="FREQ {:.4f}",
unit="Hz",
vals=Numbers(min_value=1e-3, max_value=102e3),
)
"""Parameter frequency"""
self.ext_trigger: Parameter = self.add_parameter(
"ext_trigger",
label="External trigger",
get_cmd="RSLP?",
set_cmd="RSLP {}",
val_mapping={
"sine": 0,
"TTL rising": 1,
"TTL falling": 2,
},
)
"""Parameter ext_trigger"""
self.harmonic: Parameter = self.add_parameter(
"harmonic",
label="Harmonic",
get_cmd="HARM?",
get_parser=int,
set_cmd="HARM {:d}",
vals=Ints(min_value=1, max_value=19999),
)
"""Parameter harmonic"""
self.amplitude: Parameter = self.add_parameter(
"amplitude",
label="Amplitude",
get_cmd="SLVL?",
get_parser=float,
set_cmd="SLVL {:.3f}",
unit="V",
vals=Numbers(min_value=0.004, max_value=5.000),
)
"""Parameter amplitude"""
# Input and filter
self.input_config: Parameter = self.add_parameter(
"input_config",
label="Input configuration",
get_cmd="ISRC?",
get_parser=self._get_input_config,
set_cmd="ISRC {}",
set_parser=self._set_input_config,
vals=Enum(*self._INPUT_CONFIG_TO_N.keys()),
)
"""Parameter input_config"""
self.input_shield: Parameter = self.add_parameter(
"input_shield",
label="Input shield",
get_cmd="IGND?",
set_cmd="IGND {}",
val_mapping={
"float": 0,
"ground": 1,
},
)
"""Parameter input_shield"""
self.input_coupling: Parameter = self.add_parameter(
"input_coupling",
label="Input coupling",
get_cmd="ICPL?",
set_cmd="ICPL {}",
val_mapping={
"AC": 0,
"DC": 1,
},
)
"""Parameter input_coupling"""
self.notch_filter: Parameter = self.add_parameter(
"notch_filter",
label="Notch filter",
get_cmd="ILIN?",
set_cmd="ILIN {}",
val_mapping={
"off": 0,
"line in": 1,
"2x line in": 2,
"both": 3,
},
)
"""Parameter notch_filter"""
# Gain and time constant
self.sensitivity: Parameter = self.add_parameter(
name="sensitivity",
label="Sensitivity",
get_cmd="SENS?",
set_cmd="SENS {:d}",
get_parser=self._get_sensitivity,
set_parser=self._set_sensitivity,
)
"""Parameter sensitivity"""
self.reserve: Parameter = self.add_parameter(
"reserve",
label="Reserve",
get_cmd="RMOD?",
set_cmd="RMOD {}",
val_mapping={
"high": 0,
"normal": 1,
"low noise": 2,
},
)
"""Parameter reserve"""
self.time_constant: Parameter = self.add_parameter(
"time_constant",
label="Time constant",
get_cmd="OFLT?",
set_cmd="OFLT {}",
unit="s",
val_mapping={
10e-6: 0,
30e-6: 1,
100e-6: 2,
300e-6: 3,
1e-3: 4,
3e-3: 5,
10e-3: 6,
30e-3: 7,
100e-3: 8,
300e-3: 9,
1: 10,
3: 11,
10: 12,
30: 13,
100: 14,
300: 15,
1e3: 16,
3e3: 17,
10e3: 18,
30e3: 19,
},
)
"""Parameter time_constant"""
self.filter_slope: Parameter = self.add_parameter(
"filter_slope",
label="Filter slope",
get_cmd="OFSL?",
set_cmd="OFSL {}",
unit="dB/oct",
val_mapping={
6: 0,
12: 1,
18: 2,
24: 3,
},
)
"""Parameter filter_slope"""
self.sync_filter: Parameter = self.add_parameter(
"sync_filter",
label="Sync filter",
get_cmd="SYNC?",
set_cmd="SYNC {}",
val_mapping={
"off": 0,
"on": 1,
},
)
"""Parameter sync_filter"""
def parse_offset_get(s: str) -> tuple[float, int]:
parts = s.split(',')
return float(parts[0]), int(parts[1])
# TODO: Parameters that can be set with multiple arguments
# For the OEXP command for example two arguments are needed
self.X_offset: Parameter = self.add_parameter(
"X_offset", get_cmd="OEXP? 1", get_parser=parse_offset_get
)
"""Parameter X_offset"""
self.Y_offset: Parameter = self.add_parameter(
"Y_offset", get_cmd="OEXP? 2", get_parser=parse_offset_get
)
"""Parameter Y_offset"""
self.R_offset: Parameter = self.add_parameter(
"R_offset", get_cmd="OEXP? 3", get_parser=parse_offset_get
)
"""Parameter R_offset"""
# Aux input/output
for i in [1, 2, 3, 4]:
self.add_parameter(f'aux_in{i}',
label=f'Aux input {i}',
get_cmd=f'OAUX? {i}',
get_parser=float,
unit='V')
self.add_parameter(f'aux_out{i}',
label=f'Aux output {i}',
get_cmd=f'AUXV? {i}',
get_parser=float,
set_cmd=f'AUXV {i}, {{}}',
unit='V')
# Setup
self.output_interface: Parameter = self.add_parameter(
"output_interface",
label="Output interface",
get_cmd="OUTX?",
set_cmd="OUTX {}",
val_mapping={
"RS232": "0\n",
"GPIB": "1\n",
},
)
"""Parameter output_interface"""
# Data transfer
self.X: Parameter = self.add_parameter(
"X", get_cmd="OUTP? 1", get_parser=float, unit="V"
)
"""Parameter X"""
self.Y: Parameter = self.add_parameter(
"Y", get_cmd="OUTP? 2", get_parser=float, unit="V"
)
"""Parameter Y"""
self.R: Parameter = self.add_parameter(
"R", get_cmd="OUTP? 3", get_parser=float, unit="V"
)
"""Parameter R"""
self.P: Parameter = self.add_parameter(
"P", get_cmd="OUTP? 4", get_parser=float, unit="deg"
)
"""Parameter P"""
self.complex_voltage: Parameter = self.add_parameter(
"complex_voltage",
label="Voltage",
get_cmd=self._get_complex_voltage,
unit="V",
docstring="Complex voltage parameter "
"calculated from X, Y phase using "
"Z = X +j*Y",
vals=ComplexNumbers(),
)
"""Complex voltage parameter calculated from X, Y phase using Z = X +j*Y"""
# Data buffer settings
self.buffer_SR: Parameter = self.add_parameter(
"buffer_SR",
label="Buffer sample rate",
get_cmd="SRAT ?",
set_cmd=self._set_buffer_SR,
unit="Hz",
val_mapping={
62.5e-3: 0,
0.125: 1,
0.250: 2,
0.5: 3,
1: 4,
2: 5,
4: 6,
8: 7,
16: 8,
32: 9,
64: 10,
128: 11,
256: 12,
512: 13,
"Trigger": 14,
},
get_parser=int,
)
"""Parameter buffer_SR"""
self.buffer_acq_mode: Parameter = self.add_parameter(
"buffer_acq_mode",
label="Buffer acquistion mode",
get_cmd="SEND ?",
set_cmd="SEND {}",
val_mapping={"single shot": 0, "loop": 1},
get_parser=int,
)
"""Parameter buffer_acq_mode"""
self.buffer_trig_mode: Parameter = self.add_parameter(
"buffer_trig_mode",
label="Buffer trigger start mode",
get_cmd="TSTR ?",
set_cmd="TSTR {}",
val_mapping={"ON": 1, "OFF": 0},
get_parser=int,
)
"""Parameter buffer_trig_mode"""
self.buffer_npts: Parameter = self.add_parameter(
"buffer_npts",
label="Buffer number of stored points",
get_cmd="SPTS ?",
get_parser=int,
)
"""Parameter buffer_npts"""
self.sweep_setpoints: GeneratedSetPoints = self.add_parameter(
"sweep_setpoints",
parameter_class=GeneratedSetPoints,
vals=Arrays(shape=(self.buffer_npts.get,)),
)
"""Parameter sweep_setpoints"""
# Channel setup
for ch in range(1, 3):
# detailed validation and mapping performed in set/get functions
self.add_parameter(f'ch{ch}_ratio',
label=f'Channel {ch} ratio',
get_cmd=partial(self._get_ch_ratio, ch),
set_cmd=partial(self._set_ch_ratio, ch),
vals=Strings())
self.add_parameter(f'ch{ch}_display',
label=f'Channel {ch} display',
get_cmd=partial(self._get_ch_display, ch),
set_cmd=partial(self._set_ch_display, ch),
vals=Strings())
self.add_parameter(f'ch{ch}_databuffer',
channel=ch,
parameter_class=ChannelBuffer)
self.add_parameter(f'ch{ch}_datatrace',
channel=ch,
vals=Arrays(shape=(self.buffer_npts.get,)),
setpoints=(self.sweep_setpoints,),
parameter_class=ChannelTrace)
# Auto functions
self.add_function('auto_gain', call_cmd='AGAN')
self.add_function('auto_reserve', call_cmd='ARSV')
self.add_function('auto_phase', call_cmd='APHS')
self.add_function('auto_offset', call_cmd='AOFF {0}',
args=[Enum(1, 2, 3)])
# Interface
self.add_function('reset', call_cmd='*RST')
self.add_function('disable_front_panel', call_cmd='OVRM 0')
self.add_function('enable_front_panel', call_cmd='OVRM 1')
self.add_function('send_trigger', call_cmd='TRIG',
docstring=("Send a software trigger. "
"This command has the same effect as a "
"trigger at the rear panel trigger"
" input."))
self.add_function('buffer_start', call_cmd='STRT',
docstring=("The buffer_start command starts or "
"resumes data storage. buffer_start"
" is ignored if storage is already in"
" progress."))
self.add_function('buffer_pause', call_cmd='PAUS',
docstring=("The buffer_pause command pauses data "
"storage. If storage is already paused "
"or reset then this command is ignored."))
self.add_function('buffer_reset', call_cmd='REST',
docstring=("The buffer_reset command resets the data"
" buffers. The buffer_reset command can "
"be sent at any time - any storage in "
"progress, paused or not, will be reset."
" This command will erase the data "
"buffer."))
# Initialize the proper units of the outputs and sensitivities
self.input_config()
# start keeping track of buffer setpoints
self._buffer1_ready = False
self._buffer2_ready = False
self.connect_message()
SNAP_PARAMETERS: ClassVar[dict[str, str]] = {
'x': '1',
'y': '2',
'r': '3',
'p': '4',
'phase': '4',
'θ': '4',
'aux1': '5',
'aux2': '6',
'aux3': '7',
'aux4': '8',
'freq': '9',
'ch1': '10',
'ch2': '11'
}
[docs]
def snap(self, *parameters: str) -> tuple[float, ...]:
"""
Get between 2 and 6 parameters at a single instant. This provides a
coherent snapshot of measured signals. Pick up to 6 from: X, Y, R, θ,
the aux inputs 1-4, frequency, or what is currently displayed on
channels 1 and 2.
Reading X and Y (or R and θ) gives a coherent snapshot of the signal.
Snap is important when the time constant is very short, a time constant
less than 100 ms.
Args:
*parameters: From 2 to 6 strings of names of parameters for which
the values are requested. including: 'x', 'y', 'r', 'p',
'phase' or 'θ', 'aux1', 'aux2', 'aux3', 'aux4', 'freq',
'ch1', and 'ch2'.
Returns:
A tuple of floating point values in the same order as requested.
Examples:
>>> lockin.snap('x','y') -> tuple(x,y)
>>> lockin.snap('aux1','aux2','freq','phase')
>>> -> tuple(aux1,aux2,freq,phase)
Note:
Volts for x, y, r, and aux 1-4
Degrees for θ
Hertz for freq
Unknown for ch1 and ch2. It will depend on what was set.
- If X,Y,R and θ are all read, then the values of X,Y are recorded
approximately 10 µs apart from R,θ. Thus, the values of X and Y
may not yield the exact values of R and θ from a single snap.
- The values of the Aux Inputs may have an uncertainty of
up to 32 µs.
- The frequency is computed only every other period or 40 ms,
whichever is longer.
"""
if not 2 <= len(parameters) <= 6:
raise KeyError(
'It is only possible to request values of 2 to 6 parameters'
' at a time.')
for name in parameters:
if name.lower() not in self.SNAP_PARAMETERS:
raise KeyError(f'{name} is an unknown parameter. Refer'
f' to `SNAP_PARAMETERS` for a list of valid'
f' parameter names')
p_ids = [self.SNAP_PARAMETERS[name.lower()] for name in parameters]
output = self.ask(f'SNAP? {",".join(p_ids)}')
return tuple(float(val) for val in output.split(','))
[docs]
def increment_sensitivity(self) -> bool:
"""
Increment the sensitivity setting of the lock-in. This is equivalent
to pushing the sensitivity up button on the front panel. This has no
effect if the sensitivity is already at the maximum.
Returns:
Whether or not the sensitivity was actually changed.
"""
return self._change_sensitivity(1)
[docs]
def decrement_sensitivity(self) -> bool:
"""
Decrement the sensitivity setting of the lock-in. This is equivalent
to pushing the sensitivity down button on the front panel. This has no
effect if the sensitivity is already at the minimum.
Returns:
Whether or not the sensitivity was actually changed.
"""
return self._change_sensitivity(-1)
def _change_sensitivity(self, dn: int) -> bool:
if self.input_config() in ['a', 'a-b']:
n_to = self._N_TO_VOLT
to_n = self._VOLT_TO_N
else:
n_to = self._N_TO_CURR
to_n = self._CURR_TO_N
n = to_n[self.sensitivity()]
if n + dn > max(n_to.keys()) or n + dn < min(n_to.keys()):
return False
self.sensitivity.set(n_to[n + dn])
return True
def _set_buffer_SR(self, SR: int) -> None:
self.write(f'SRAT {SR}')
self._buffer1_ready = False
self._buffer2_ready = False
self.sweep_setpoints.update_units_if_constant_sample_rate()
def _get_ch_ratio(self, channel: int) -> str:
val_mapping = {1: {0: 'none',
1: 'Aux In 1',
2: 'Aux In 2'},
2: {0: 'none',
1: 'Aux In 3',
2: 'Aux In 4'}}
resp = int(self.ask(f'DDEF ? {channel}').split(',')[1])
return val_mapping[channel][resp]
def _set_ch_ratio(self, channel: int, ratio: str) -> None:
val_mapping = {1: {'none': 0,
'Aux In 1': 1,
'Aux In 2': 2},
2: {'none': 0,
'Aux In 3': 1,
'Aux In 4': 2}}
vals = val_mapping[channel].keys()
if ratio not in vals:
raise ValueError(f'{ratio} not in {vals}')
ratio_int = val_mapping[channel][ratio]
disp_val = int(self.ask(f'DDEF ? {channel}').split(',')[0])
self.write(f'DDEF {channel}, {disp_val}, {ratio_int}')
self._buffer_ready = False
def _get_ch_display(self, channel: int) -> str:
val_mapping = {1: {0: 'X',
1: 'R',
2: 'X Noise',
3: 'Aux In 1',
4: 'Aux In 2'},
2: {0: 'Y',
1: 'Phase',
2: 'Y Noise',
3: 'Aux In 3',
4: 'Aux In 4'}}
resp = int(self.ask(f'DDEF ? {channel}').split(',')[0])
return val_mapping[channel][resp]
def _set_ch_display(self, channel: int, disp: str) -> None:
val_mapping = {1: {'X': 0,
'R': 1,
'X Noise': 2,
'Aux In 1': 3,
'Aux In 2': 4},
2: {'Y': 0,
'Phase': 1,
'Y Noise': 2,
'Aux In 3': 3,
'Aux In 4': 4}}
vals = val_mapping[channel].keys()
if disp not in vals:
raise ValueError(f'{disp} not in {vals}')
disp_int = val_mapping[channel][disp]
# Since ratio AND display are set simultaneously,
# we get and then re-set the current ratio value
ratio_val = int(self.ask(f'DDEF ? {channel}').split(',')[1])
self.write(f'DDEF {channel}, {disp_int}, {ratio_val}')
self._buffer_ready = False
# we update the unit of the datatrace
# according to the choice of channel
params = self.parameters
dataparam = params[f'ch{channel}_datatrace']
assert isinstance(dataparam, ChannelTrace)
dataparam.update_unit()
def _set_units(self, unit: str) -> None:
# TODO:
# make a public parameter function that allows to change the units
for param in [self.X, self.Y, self.R, self.sensitivity]:
param.unit = unit
def _get_complex_voltage(self) -> complex:
x, y = self.snap("X", "Y")
return x + 1.0j * y
def _get_input_config(self, s: int) -> str:
mode = self._N_TO_INPUT_CONFIG[int(s)]
if mode in ['a', 'a-b']:
self.sensitivity.vals = self._VOLT_ENUM
self._set_units('V')
else:
self.sensitivity.vals = self._CURR_ENUM
self._set_units('A')
return mode
def _set_input_config(self, s: str) -> int:
if s in ['a', 'a-b']:
self.sensitivity.vals = self._VOLT_ENUM
self._set_units('V')
else:
self.sensitivity.vals = self._CURR_ENUM
self._set_units('A')
return self._INPUT_CONFIG_TO_N[s]
def _get_sensitivity(self, s: int) -> float:
if self.input_config() in ['a', 'a-b']:
return self._N_TO_VOLT[int(s)]
else:
return self._N_TO_CURR[int(s)]
def _set_sensitivity(self, s: float) -> int:
if self.input_config() in ['a', 'a-b']:
return self._VOLT_TO_N[s]
else:
return self._CURR_TO_N[s]
[docs]
def autorange(self, max_changes: int = 1) -> None:
"""
Automatically changes the sensitivity of the instrument according to
the R value and defined max_changes.
Args:
max_changes: Maximum number of steps allowing the function to
automatically change the sensitivity (default is 1). The actual
number of steps needed to change to the optimal sensitivity may
be more or less than this maximum.
"""
def autorange_once() -> bool:
r = self.R()
sens = self.sensitivity()
if r > 0.9 * sens:
return self.increment_sensitivity()
elif r < 0.1 * sens:
return self.decrement_sensitivity()
return False
sets = 0
while autorange_once() and sets < max_changes:
sets += 1
time.sleep(self.time_constant())
[docs]
def set_sweep_parameters(
self,
sweep_param: Parameter,
start: float,
stop: float,
n_points: int = 10,
label: str | None = None,
) -> None:
self.sweep_setpoints.sweep_array = np.linspace(start, stop, n_points)
self.sweep_setpoints.unit = sweep_param.unit
if label is not None:
self.sweep_setpoints.label = label
elif sweep_param.label is not None:
self.sweep_setpoints.label = sweep_param.label
class GeneratedSetPoints(Parameter):
"""
A parameter that generates a setpoint array from start, stop and num points
parameters.
"""
def __init__(
self,
sweep_array: Iterable[float | int] = np.linspace(0, 1, 10),
*args: Any,
**kwargs: Any,
) -> None:
super().__init__(*args, **kwargs)
self.sweep_array = sweep_array
self.update_units_if_constant_sample_rate()
def update_units_if_constant_sample_rate(self) -> None:
"""
If the buffer is filled at a constant sample rate,
update the unit to "s" and label to "Time";
otherwise do nothing
"""
assert isinstance(self.root_instrument, SR830)
SR = self.root_instrument.buffer_SR.get()
if SR != 'Trigger':
self.unit = 's'
self.label = 'Time'
def set_raw(self, value: Iterable[float | int]) -> None:
self.sweep_array = value
def get_raw(self) -> ParamRawDataType:
assert isinstance(self.root_instrument, SR830)
SR = self.root_instrument.buffer_SR.get()
if SR == 'Trigger':
return self.sweep_array
else:
N = self.root_instrument.buffer_npts.get()
dt = 1/SR
return np.linspace(0, N*dt, N)