def get_log_point(self, which='next', units=None): """ Get a log data point from the instrument. :param str which: Which data point you want. Valid examples include ``first``, and ``next``. Consult the instrument manual for the complete list :param units: Units to attach to the returned data point. If left with the value of `None` then the instrument will be queried for the current units setting. :type units: `~quantities.UnitQuantity` :return: The log data point with units :rtype: `~quantities.Quantity` """ if units is None: units = self.units point = [ s.strip() for s in self._ctc.query( 'getLog.xy {}, {}'.format(self._chan_name, which) ).split(',') ] return u.Quantity(float(point[0]), 'ms'), \ u.Quantity(float(point[1]), units)
def test_lakeshore475_control_slope_limit(): """ Get / set slope limit, unitful and not. """ with expected_protocol( ik.lakeshore.Lakeshore475, [ "CPARAM?", "UNIT?", "CPARAM?", "UNIT?", "UNIT?", "CPARAM 1.0,10.0,42.0,42.0", "CPARAM?", "UNIT?", "UNIT?", "CPARAM 1.0,10.0,42.0,42.0", ], [ "+1.0E+0,+1.0E+1,+4.2E+1,+1.0E+2", "2", # teslas "+1.0E+0,+1.0E+1,+4.2E+1,+1.0E+2", "2", # teslas "2", "+1.0E+0,+1.0E+1,+4.2E+1,+1.0E+2", "2", "2" ], ) as lsh: assert lsh.control_slope_limit == u.Quantity(100.0, u.V / u.min) lsh.control_slope_limit = u.Quantity(42000.0, u.mV / u.min) lsh.control_slope_limit = 42.0
def test_apt_mc_motion_timeout(init_kdc101): """Set and get motion timeout.""" with expected_protocol(ik.thorlabs.APTMotorController, [init_kdc101[0]], [init_kdc101[1]], sep="") as apt: apt.channel[0].motion_timeout = u.Quantity(100, u.s) assert apt.channel[0].motion_timeout == u.Quantity(100, u.s)
def test_srsdg645_trigger_source(): with expected_protocol(ik.srs.SRSDG645, "DLAY?2\nDLAY 3,2,60.0\n", "0,42\n") as ddg: ref, t = ddg.channel["A"].delay assert ref == ddg.Channels.T0 assert abs((t - u.Quantity(42, "s")).magnitude) < 1e5 ddg.channel["B"].delay = (ddg.channel["A"], u.Quantity(1, "minute"))
def test_maui_time_div(init): """Get / Set time per division.""" with expected_protocol(ik.teledyne.MAUI, [init, 'TDIV?', 'TDIV 0.001'], ['1'], sep="\n") as osc: assert osc.time_div == u.Quantity(1, u.s) osc.time_div = u.Quantity(1, u.ms)
def get_log(self): """ Gets all of the log data points currently saved in the instrument memory. :return: Tuple of all the log data points. First value is time, second is the measurement value. :rtype: Tuple of 2x `~quantities.Quantity`, each comprised of a numpy array (`numpy.dnarray`). """ # Remember the current units. units = self.units # Find out how many points there are. n_points = int( self._ctc.query('getLog.xy? {}'.format(self._chan_name))) # Make an empty quantity that size for the times and for the channel # values. ts = u.Quantity(np.empty((n_points, )), 'ms') temps = u.Quantity(np.empty((n_points, )), units) # Reset the position to the first point, then save it. # pylint: disable=protected-access with self._ctc._error_checking_disabled(): ts[0], temps[0] = self.get_log_point('first', units) for idx in range(1, n_points): ts[idx], temps[idx] = self.get_log_point('next', units) # Do an actual error check now. if self._ctc.error_check_toggle: self._ctc.errcheck() return ts, temps
def test_maui_trigger_delay(init): """Get / Set trigger delay.""" with expected_protocol(ik.teledyne.MAUI, [init, 'TRDL?', 'TRDL 0.001', 'TRDL 1'], ['0.001'], sep="\n") as osc: assert osc.trigger_delay == u.Quantity(1, u.ms) osc.trigger_delay = u.Quantity(1, u.ms) osc.trigger_delay = 1
def test_srsdg645_burst_period(): """ SRSDG645: Checks getting/setting of enabling T0 output on first in burst mode. """ with expected_protocol(ik.srs.SRSDG645, ["BURP?", "BURP 13"], ["100E-9"]) as ddg: unit_eq(ddg.burst_period, u.Quantity(100, "ns").rescale(u.s)) ddg.burst_period = u.Quantity(13, "s")
def test_srsdg645_burst_delay(): """ SRSDG645: Checks getting/setting of enabling T0 output on first in burst mode. """ with expected_protocol(ik.srs.SRSDG645, ["BURD?", "BURD 42"], ["0"]) as ddg: unit_eq(ddg.burst_delay, u.Quantity(0, "s")) ddg.burst_delay = u.Quantity(42, "s")
def test_maui_channel_scale(init): """Get / Set MAUI Channel scale.""" with expected_protocol(ik.teledyne.MAUI, [init, 'C2:VDIV?', 'C1:VDIV 2.0', 'C2:VDIV 0.4'], ['1'], sep="\n") as osc: assert osc.channel[1].scale == u.Quantity(1, u.V) osc.channel[0].scale = u.Quantity(2000, u.mV) osc.channel[1].scale = 0.4
def test_maui_channel_offset(init): """Get / Set MAUI Channel offset.""" with expected_protocol(ik.teledyne.MAUI, [init, 'C1:OFST?', 'C1:OFST 0.2', 'C3:OFST 2'], ['1'], sep="\n") as osc: assert osc.channel[0].offset == u.Quantity(1, u.V) osc.channel[0].offset = u.Quantity(200, u.mV) osc.channel[2].offset = 2
def test_unitful_property_sendcmd_query(mock_inst): """Assert that unitful_property calls sendcmd, query of parent class.""" # getter assert mock_inst.unitful_property == u.Quantity(42, u.K) mock_inst.spy_query.assert_called() # setter value = 13 mock_inst.unitful_property = u.Quantity(value, u.K) assert mock_inst._sendcmd == f"42 {value:e}" mock_inst.spy_sendcmd.assert_called()
def test_channel_get_log(channel): """Get the full log of a channel. Leave error checking activated, because it is run at the end. """ # make some data times = [0, 1, 2, 3] values = [1.3, 2.4, 3.5, 4.6] # variables units = ik.srs.SRSCTC100._UNIT_NAMES[ch_name_unit_dict[channel]] n_points = len(values) # strings for error checking, sending and receiving err_check_send = "geterror?" err_check_reci = "0,NO ERROR" # stich together strings to read all the values str_log_next_send = "\n".join( [f"getLog.xy {channel}, next" for it in range(1, n_points)]) str_log_next_reci = "\n".join( [f"{times[it]},{values[it]}" for it in range(1, n_points)]) # make data to compare with ts = u.Quantity(np.empty((n_points, )), u.ms) temps = u.Quantity(np.empty((n_points, )), units) for it, time in enumerate(times): ts[it] = u.Quantity(time, u.ms) temps[it] = u.Quantity(values[it], units) with expected_protocol( ik.srs.SRSCTC100, [ ch_names_query, err_check_send, "getOutput.units?", err_check_send, ch_names_query, err_check_send, f"getLog.xy? {channel}", err_check_send, f"getLog.xy {channel}, first", # query first point str_log_next_send, err_check_send ], [ ch_names_str, err_check_reci, ",".join(ch_units), err_check_reci, ch_names_str, err_check_reci, f"{n_points}", err_check_reci, f"{times[0]},{values[0]}", str_log_next_reci, err_check_reci ]) as inst: ch = inst.channel[channel] ts_read, temps_read = ch.get_log() # assert the data is correct np.testing.assert_equal(ts, ts_read) np.testing.assert_equal(temps, temps_read)
def test_channel_offset(channel, val_read, val_unitless, val_millivolt): """Get / set offset.""" val_read = u.Quantity(val_read, u.V) val_unitful = u.Quantity(val_millivolt, u.mV) with expected_protocol(ik.tektronix.TekAWG2000, [ f"FG:CH{channel+1}:OFFS?", f"FG:CH{channel+1}:OFFS {val_unitless}", f"FG:CH{channel+1}:OFFS {val_unitful.rescale(u.V).magnitude}" ], [f"{val_read.magnitude}"]) as inst: assert inst.channel[channel].offset == val_read inst.channel[channel].offset = val_unitless inst.channel[channel].offset = val_unitful
def test_yaml_quantity_tag(): yaml_data = StringIO(u""" a: b: !Q 37 tesla c: !Q 41.2 inches d: !Q 98 """) data = yaml.load(yaml_data, Loader=yaml.Loader) assert data['a']['b'] == u.Quantity(37, 'tesla') assert data['a']['c'] == u.Quantity(41.2, 'inches') assert data['a']['d'] == 98
def test_channel_frequency(channel, val_read, val_unitless, val_kilohertz): """Get / set offset.""" val_read = u.Quantity(val_read, u.Hz) val_unitful = u.Quantity(val_kilohertz, u.kHz) with expected_protocol(ik.tektronix.TekAWG2000, [ f"FG:FREQ?", f"FG:FREQ {val_unitless}HZ", f"FG:FREQ {val_unitful.rescale(u.Hz).magnitude}HZ" ], [f"{val_read.magnitude}"]) as inst: assert inst.channel[channel].frequency == val_read inst.channel[channel].frequency = val_unitless inst.channel[channel].frequency = val_unitful
def test_get_log_point_with_unit(): """Get a log point and include a unit query.""" channel = ch_names[0] unit = ik.srs.SRSCTC100._UNIT_NAMES[ch_units[0]] values = (13, 42) which = "first" values_out = (u.Quantity(float(values[0]), u.ms), u.Quantity(float(values[1]), unit)) with expected_protocol(ik.srs.SRSCTC100, [ch_names_query, f"getLog.xy {channel}, {which}"], [ch_names_str, f"{values[0]},{values[1]}"]) as inst: with inst._error_checking_disabled(): assert (inst.channel[channel].get_log_point( which=which, units=unit) == values_out)
def test_maui_math_op_derivative(init): """Set math channel, derivative operator.""" with expected_protocol(ik.teledyne.MAUI, [ init, "F1:DEFINE EQN,'DERI(C1)',VERSCALE,1000000.0," "VEROFFSET,0,ENABLEAUTOSCALE,ON", "F1:DEFINE EQN,'DERI(C3)',VERSCALE,5.0," "VEROFFSET,1.0,ENABLEAUTOSCALE,OFF" ], [], sep="\n") as osc: osc.math[0].operator.derivative(0) osc.math[0].operator.derivative(2, vscale=u.Quantity(5000, u.mV / u.s), voffset=u.Quantity(60, u.V / u.min), autoscale=False)
def test_apt_mc_position_encoder(init_kdc101): """Get unitful position of encoder, in counts.""" with expected_protocol( ik.thorlabs.APTMotorController, [ init_kdc101[0], ThorLabsPacket( # read position message_id=ThorLabsCommands.MOT_REQ_ENCCOUNTER, param1=0x01, param2=0x00, dest=0x50, source=0x01, data=None).pack() ], [ init_kdc101[1], ThorLabsPacket(message_id=ThorLabsCommands.MOT_GET_ENCCOUNTER, param1=None, param2=None, dest=0x50, source=0x01, data=struct.pack('<Hl', 0x01, -20000)).pack() ], sep="") as apt: assert apt.channel[0].position_encoder == u.Quantity(-20000, 'counts')
def burst_period(self): """ Gets/sets the burst period. The burst period sets the time between delay cycles during a burst. The burst period may range from 100 ns to 2000 – 10 ns in 10 ns steps. """ return u.Quantity(float(self.query("BURP?")), u.s)
def test_cc1_dwell_new_firmware(): with expected_protocol(ik.qubitekk.CC1, [":ACKN OF", "FIRM?", "DWEL?", ":DWEL 2"], ["", "Firmware v2.010", "8"], sep="\n") as cc: unit_eq(cc.dwell_time, u.Quantity(8, "s")) cc.dwell_time = 2
def test_cc1_dwell_old_firmware(): with expected_protocol(ik.qubitekk.CC1, [":ACKN OF", "FIRM?", "DWEL?", ":DWEL 2"], ["Unknown Command", "Firmware v2.001", "8000", ""], sep="\n") as cc: unit_eq(cc.dwell_time, u.Quantity(8, "s")) cc.dwell_time = 2
def test_cc1_delay(): with expected_protocol(ik.qubitekk.CC1, [":ACKN OF", "FIRM?", "DELA?", ":DELA 2"], ["", "Firmware v2.010", "8", ""], sep="\n") as cc: unit_eq(cc.delay, u.Quantity(8, "ns")) cc.delay = 2
def max_travel(self): """ Gets the maximum travel for the specified piezo channel. :type: `~quantities.Quantity` :units: Nanometers """ pkt = _packets.ThorLabsPacket( message_id=_cmds.ThorLabsCommands.PZ_REQ_MAXTRAVEL, param1=self._idx_chan, param2=0x00, dest=self._apt.destination, source=0x01, data=None) resp = self._apt.querypacket(pkt) # Not all APT piezo devices support querying the maximum travel # distance. Those that do not simply ignore the PZ_REQ_MAXTRAVEL # packet, so that the response is empty. if resp is None: return NotImplemented # chan, int_maxtrav _, int_maxtrav = struct.unpack('<HH', resp.data) return int_maxtrav * u.Quantity(100, 'nm')
def burst_delay(self): """ Gets/sets the burst delay. When burst mode is enabled the DG645 delays the first burst pulse relative to the trigger by the burst delay. The burst delay may range from 0 ps to < 2000 s with a resolution of 5 ps. """ return u.Quantity(float(self.query("BURD?")), u.s)
def holdoff(self): """ Gets/sets the trigger holdoff time. :type: `~quantities.Quantity` or `float` :units: As passed, or s if not specified. """ return u.Quantity(float(self.query("HOLD?")), u.s)
def trigger_rate(self): """ Gets/sets the rate of the internal trigger. :type: `~quantities.Quantity` or `float` :units: As passed or Hz if not specified. """ return u.Quantity(float(self.query("TRAT?")), u.Hz)
def std_dev(self): """ Gets the standard deviation for the specified channel as determined by the statistics gathering. :type: `~quantities.Quantity` """ return u.Quantity(float(self._get('SD')), self.units)
def average(self): """ Gets the average measurement for the specified channel as determined by the statistics gathering. :type: `~quantities.Quantity` """ return u.Quantity(float(self._get('average')), self.units)
def test_lcc25_voltage2(): with expected_protocol(ik.thorlabs.LCC25, [ "volt2?", "volt2=10.0", ], ["volt2?", "20", ">volt2=10.0", ">"], sep="\r") as lcc: unit_eq(lcc.voltage2, u.Quantity(20, "V")) lcc.voltage2 = 10.0