Oxford Instruments Drivers

Classes:

OxfordMercuryWorkerPS(parent, name, UID, ...)	Class to hold a worker power supply for the Oxford MercuryiPS
OxfordMercuryiPS(name, address, *[, ...])	Driver class for the QCoDeS Oxford Instruments MercuryiPS magnet power supply
OxfordTriton(name[, address, port, ...])	Triton Driver

class qcodes.instrument_drivers.oxford.OxfordMercuryWorkerPS(parent: VisaInstrument, name: str, UID: str, **kwargs: Unpack[InstrumentBaseKWArgs])

Bases: InstrumentChannel

Class to hold a worker power supply for the Oxford MercuryiPS

Parameters:

• parent – The Instrument instance of the MercuryiPS

• name – The ‘colloquial’ name of the PS

• UID – The UID as used internally by the MercuryiPS, e.g. ‘GRPX’

• **kwargs – Forwarded to base class.

Attributes:

voltage	Parameter voltage
current	Parameter current
current_persistent	Parameter current_persistent
current_target	Parameter current_target
field_target	Parameter field_target
current_ramp_rate	Parameter current_ramp_rate
field_ramp_rate	Parameter field_ramp_rate
field	Parameter field
field_persistent	Parameter field_persistent
ATOB	Parameter ATOB
ramp_status	Parameter ramp_status

Methods:

ramp_to_target()

Unconditionally ramp this PS to its target

voltage: Parameter = self.add_parameter( "voltage", label="Output voltage", get_cmd=partial(self._param_getter, "SIG:VOLT"), unit="V", get_parser=partial(_signal_parser, 1), )

Parameter voltage

current: Parameter = self.add_parameter( "current", label="Output current", get_cmd=partial(self._param_getter, "SIG:CURR"), unit="A", get_parser=partial(_signal_parser, 1), )

Parameter current

current_persistent: Parameter = self.add_parameter( "current_persistent", label="Output persistent current", get_cmd=partial(self._param_getter, "SIG:PCUR"), unit="A", get_parser=partial(_signal_parser, 1), )

Parameter current_persistent

current_target: Parameter = self.add_parameter( "current_target", label="Target current", get_cmd=partial(self._param_getter, "SIG:CSET"), unit="A", get_parser=partial(_signal_parser, 1), )

Parameter current_target

field_target: Parameter = self.add_parameter( "field_target", label="Target field", get_cmd=partial(self._param_getter, "SIG:FSET"), set_cmd=partial(self._param_setter, "SIG:FSET"), unit="T", get_parser=partial(_signal_parser, 1), )

Parameter field_target

current_ramp_rate: Parameter = self.add_parameter( "current_ramp_rate", label="Ramp rate (current)", unit="A/s", get_cmd=partial(self._param_getter, "SIG:RCST"), get_parser=partial(_signal_parser, 1 / 60), )

Parameter current_ramp_rate

field_ramp_rate: Parameter = self.add_parameter( "field_ramp_rate", label="Ramp rate (field)", unit="T/s", set_cmd=partial(self._param_setter, "SIG:RFST"), get_cmd=partial(self._param_getter, "SIG:RFST"), get_parser=partial(_signal_parser, 1 / 60), set_parser=lambda x: x * 60, )

Parameter field_ramp_rate

field: Parameter = self.add_parameter( "field", label="Field strength", unit="T", get_cmd=partial(self._param_getter, "SIG:FLD"), get_parser=partial(_signal_parser, 1), )

Parameter field

field_persistent: Parameter = self.add_parameter( "field_persistent", label="Persistent field strength", unit="T", get_cmd=partial(self._param_getter, "SIG:PFLD"), get_parser=partial(_signal_parser, 1), )

Parameter field_persistent

ATOB: Parameter = self.add_parameter( "ATOB", label="Current to field ratio", unit="A/T", get_cmd=partial(self._param_getter, "ATOB"), get_parser=partial(_signal_parser, 1), set_cmd=partial(self._param_setter, "ATOB"), )

Parameter ATOB

ramp_status: Parameter = self.add_parameter( "ramp_status", label="Ramp status", get_cmd=partial(self._param_getter, "ACTN"), set_cmd=self._ramp_status_setter, get_parser=_response_preparser, val_mapping={ "HOLD": "HOLD", "TO SET": "RTOS", "CLAMP": "CLMP", "TO ZERO": "RTOZ", }, )

Parameter ramp_status

ramp_to_target() → None

Unconditionally ramp this PS to its target

parameters: dict[str, ParameterBase] = {}

All the parameters supported by this instrument. Usually populated via add_parameter().

functions: dict[str, Function] = {}

All the functions supported by this instrument. Usually populated via add_function().

submodules: dict[str, InstrumentModule | ChannelTuple] = {}

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules: dict[str, InstrumentModule] = {}

All the InstrumentModule of this instrument Usually populated via add_submodule().

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

metadata: dict[str, Any] = {}

class qcodes.instrument_drivers.oxford.OxfordMercuryiPS(name: str, address: str, *, field_limits: Callable[[float, float, float], bool] | None = None, **kwargs: Unpack[VisaInstrumentKWArgs])

Bases: VisaInstrument

Driver class for the QCoDeS Oxford Instruments MercuryiPS magnet power supply

Parameters:

• name – The name to give this instrument internally in QCoDeS

• address – The VISA resource of the instrument. Note that a socket connection to port 7020 must be made

• field_limits – A function describing the allowed field range (T). The function shall take (x, y, z) as an input and return a boolean describing whether that field value is acceptable.

• **kwargs – kwargs are forwarded to base class.

Attributes:

default_terminator	The default terminator to use if the terminator is not specified when creating the instrument.
field_target	Parameter field_target
field_measured	Parameter field_measured
field_ramp_rate	Parameter field_ramp_rate

Methods:

get_idn()	Parse the raw non-SCPI compliant IDN string into an IDN dict
update_field()	Update all the field components.
is_ramping()	Returns True if any axis has a ramp status that is either 'TO SET' or 'TO ZERO'
set_new_field_limits(limit_func)	Assign a new field limit function to the driver
ramp([mode])	Ramp the fields to their present target value
ask(cmd)	Since Oxford Instruments implement their own version of a SCPI-like language, we implement our own reader.

default_terminator: str | None = '\n'

The default terminator to use if the terminator is not specified when creating the instrument. None means use the default terminator from PyVisa.

field_target: Parameter = self.add_parameter( name="field_target", label="target field", unit="T", get_cmd=self._get_target_field, set_cmd=self._set_target_field, )

Parameter field_target

field_measured: Parameter = self.add_parameter( name="field_measured", label="measured field", unit="T", get_cmd=self._get_field, )

Parameter field_measured

field_ramp_rate: Parameter = self.add_parameter( name="field_ramp_rate", label="ramp rate", unit="T/s", get_cmd=self._get_ramp_rate, set_cmd=self._set_ramp_rate, )

Parameter field_ramp_rate

visabackend: str = visabackend

visa_handle: pyvisa.resources.MessageBasedResource = visa_handle

The VISA resource used by this instrument.

visalib: str | None = visalib

parameters: dict[str, ParameterBase] = {}

All the parameters supported by this instrument. Usually populated via add_parameter().

functions: dict[str, Function] = {}

All the functions supported by this instrument. Usually populated via add_function().

submodules: dict[str, InstrumentModule | ChannelTuple] = {}

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules: dict[str, InstrumentModule] = {}

All the InstrumentModule of this instrument Usually populated via add_submodule().

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

metadata: dict[str, Any] = {}

get_idn() → dict[str, str | None]

Parse the raw non-SCPI compliant IDN string into an IDN dict

Returns:

The normal IDN dict

update_field() → None

Update all the field components.

is_ramping() → bool

Returns True if any axis has a ramp status that is either ‘TO SET’ or ‘TO ZERO’

set_new_field_limits(limit_func: Callable[[float, float, float], bool]) → None

Assign a new field limit function to the driver

Parameters:

limit_func – must be a function mapping (Bx, By, Bz) -> True/False where True means that the field is INSIDE the allowed region

ramp(mode: str = 'safe') → None

Ramp the fields to their present target value

Parameters:

mode – how to ramp, either ‘simul’, ‘simul-block’ or ‘safe’. In ‘simul’ and ‘simul-block’ mode, the fields are ramping simultaneously in a non-blocking mode and blocking mode, respectively. There is no safety check that the safe zone is not exceeded. In ‘safe’ mode, the fields are ramped one-by-one in a blocking way that ensures that the total field stays within the safe region (provided that this region is convex).

ask(cmd: str) → str

Since Oxford Instruments implement their own version of a SCPI-like language, we implement our own reader. Note that this command is used for getting and setting (asking and writing) alike.

Parameters:

cmd – the command to send to the instrument

class qcodes.instrument_drivers.oxford.OxfordTriton(name: str, address: str | None = None, port: int | None = None, terminator: str = '\r\n', tmpfile: str | None = None, timeout: float = 20, **kwargs: Unpack[InstrumentBaseKWArgs])

Bases: IPInstrument

Triton Driver

Parameters:

• name – name of the cryostat.

• address – IP-address of the fridge computer. Defaults to None.

• port – port of the oxford program running on the fridge computer. The relevant port can be found in the manual for the fridge or looked up on the fridge computer. Defaults to None.

• terminator – Defaults to ‘rn’

• tmpfile – an exported windows registry file from the registry path: [HKEY_CURRENT_USERSoftwareOxford InstrumentsTriton System ControlThermometry] and is used to extract the available temperature channels.

• timeout – Defaults to 20.

• **kwargs – Forwarded to base class.

Status: beta-version.

Todo

fetch registry directly from fridge-computer

Attributes:

time	Parameter time
action	Parameter action
status	Parameter status
pid_control_channel	Parameter pid_control_channel
pid_mode	Parameter pid_mode
pid_ramp	Parameter pid_ramp
pid_setpoint	Parameter pid_setpoint
pid_p	Parameter pid_p
pid_i	Parameter pid_i
pid_d	Parameter pid_d
pid_rate	Parameter pid_rate
pid_range	Parameter pid_range
magnet_status	Parameter magnet_status
magnet_sweeprate	Parameter magnet_sweeprate
magnet_sweeprate_insta	Parameter magnet_sweeprate_insta
B	Parameter B
Bx	Parameter Bx
By	Parameter By
Bz	Parameter Bz
magnet_sweep_time	Parameter magnet_sweep_time
turb1_speed	Parameter turb1_speed

Methods:

set_B(x, y, z, s)
get_idn()	Return the Instrument Identifier Message

time: Parameter = self.add_parameter( name="time", label="System Time", get_cmd="READ:SYS:TIME", get_parser=self._parse_time, )

Parameter time

action: Parameter = self.add_parameter( name="action", label="Current action", get_cmd="READ:SYS:DR:ACTN", get_parser=self._parse_action, )

Parameter action

status: Parameter = self.add_parameter( name="status", label="Status", get_cmd="READ:SYS:DR:STATUS", get_parser=self._parse_status, )

Parameter status

pid_control_channel: Parameter = self.add_parameter( name="pid_control_channel", label="PID control channel", get_cmd=self._get_control_channel, set_cmd=self._set_control_channel, vals=Ints(1, 16), )

Parameter pid_control_channel

pid_mode: Parameter = self.add_parameter( name="pid_mode", label="PID Mode", get_cmd=partial(self._get_control_param, "MODE"), set_cmd=partial(self._set_control_param, "MODE"), val_mapping={"on": "ON", "off": "OFF"}, )

Parameter pid_mode

pid_ramp: Parameter = self.add_parameter( name="pid_ramp", label="PID ramp enabled", get_cmd=partial(self._get_control_param, "RAMP:ENAB"), set_cmd=partial(self._set_control_param, "RAMP:ENAB"), val_mapping={"on": "ON", "off": "OFF"}, )

Parameter pid_ramp

pid_setpoint: Parameter = self.add_parameter( name="pid_setpoint", label="PID temperature setpoint", unit="K", get_cmd=partial(self._get_control_param, "TSET"), set_cmd=partial(self._set_control_param, "TSET"), )

Parameter pid_setpoint

pid_p: Parameter = self.add_parameter( name="pid_p", label="PID proportionality", get_cmd=partial(self._get_control_param, "P"), set_cmd=partial(self._set_control_param, "P"), vals=Numbers(0, 1e3), )

Parameter pid_p

pid_i: Parameter = self.add_parameter( name="pid_i", label="PID intergral", get_cmd=partial(self._get_control_param, "I"), set_cmd=partial(self._set_control_param, "I"), vals=Numbers(0, 1e3), )

Parameter pid_i

pid_d: Parameter = self.add_parameter( name="pid_d", label="PID derivative", get_cmd=partial(self._get_control_param, "D"), set_cmd=partial(self._set_control_param, "D"), vals=Numbers(0, 1e3), )

Parameter pid_d

pid_rate: Parameter = self.add_parameter( name="pid_rate", label="PID ramp rate", unit="K/min", get_cmd=partial(self._get_control_param, "RAMP:RATE"), set_cmd=partial(self._set_control_param, "RAMP:RATE"), )

Parameter pid_rate

pid_range: Parameter = self.add_parameter( name="pid_range", label="PID heater range", # TODO: The units in the software are mA, how to # do this correctly? unit="mA", get_cmd=partial(self._get_control_param, "RANGE"), set_cmd=partial(self._set_control_param, "RANGE"), vals=Enum(*self._heater_range_curr), )

Parameter pid_range

magnet_status: Parameter = self.add_parameter( name="magnet_status", label="Magnet status", unit="", get_cmd=partial(self._get_control_B_param, "ACTN"), )

Parameter magnet_status

magnet_sweeprate: Parameter = self.add_parameter( name="magnet_sweeprate", label="Magnet sweep rate", unit="T/min", get_cmd=partial(self._get_control_B_param, "RVST:RATE"), set_cmd=partial(self._set_control_magnet_sweeprate_param), )

Parameter magnet_sweeprate

magnet_sweeprate_insta: Parameter = self.add_parameter( name="magnet_sweeprate_insta", label="Instantaneous magnet sweep rate", unit="T/min", get_cmd=partial(self._get_control_B_param, "RFST"), )

Parameter magnet_sweeprate_insta

B: Parameter = self.add_parameter( name="B", label="Magnetic field", unit="T", get_cmd=partial(self._get_control_B_param, "VECT"), )

Parameter B

Bx: Parameter = self.add_parameter( name="Bx", label="Magnetic field x-component", unit="T", get_cmd=partial(self._get_control_Bcomp_param, "VECTBx"), set_cmd=partial(self._set_control_Bx_param), )

Parameter Bx

By: Parameter = self.add_parameter( name="By", label="Magnetic field y-component", unit="T", get_cmd=partial(self._get_control_Bcomp_param, "VECTBy"), set_cmd=partial(self._set_control_By_param), )

Parameter By

Bz: Parameter = self.add_parameter( name="Bz", label="Magnetic field z-component", unit="T", get_cmd=partial(self._get_control_Bcomp_param, "VECTBz"), set_cmd=partial(self._set_control_Bz_param), )

Parameter Bz

magnet_sweep_time: Parameter = self.add_parameter( name="magnet_sweep_time", label="Magnet sweep time", unit="T/min", get_cmd=partial(self._get_control_B_param, "RVST:TIME"), )

Parameter magnet_sweep_time

turb1_speed: Parameter = self.add_parameter( name="turb1_speed", label=self.pump_label_dict["TURB1"] + " speed", unit="Hz", get_cmd="READ:DEV:TURB1:PUMP:SIG:SPD", get_parser=self._get_parser_pump_speed, )

Parameter turb1_speed

chan_alias: dict[str, str] = {}

chan_temp_names: dict[str, dict[str, str | None]] = {}

set_B(x: float, y: float, z: float, s: float) → None

get_idn() → dict[str, str | None]

Return the Instrument Identifier Message

parameters: dict[str, ParameterBase] = {}

All the parameters supported by this instrument. Usually populated via add_parameter().

functions: dict[str, Function] = {}

All the functions supported by this instrument. Usually populated via add_function().

submodules: dict[str, InstrumentModule | ChannelTuple] = {}

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules: dict[str, InstrumentModule] = {}

All the InstrumentModule of this instrument Usually populated via add_submodule().

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

metadata: dict[str, Any] = {}