def test_split_unit_str():
"""
util_fns: Tests that split_unit_str acts correctly.
"""
# Check that unit strings go through OK.
mag, units = split_unit_str("42 foobars")
eq_(mag, 42)
eq_(units, "foobars")
# Check that default units work.
mag, units = split_unit_str("42", default_units="foobars")
eq_(mag, 42)
eq_(units, "foobars")
# Check that default units are ignored if there's actual units.
mag, units = split_unit_str("42 snafus")
eq_(mag, 42)
eq_(units, "snafus")
# Finally, check that lookups work.
unit_dict = {
"FOO": "foobars",
"SNA": "snafus"
}
mag, units = split_unit_str("42 FOO", lookup=unit_dict.__getitem__)
eq_(mag, 42)
eq_(units, "foobars")
def test_split_unit_str_magnitude_with_decimal():
"""
split_unit_str: Given a string with magnitude containing a decimal, I
expect the function to correctly parse the magnitude.
"""
# Decimal and units
mag, units = split_unit_str("123.4 foobars")
assert mag == 123.4
assert units == "foobars"
# Decimal, units, and exponential
mag, units = split_unit_str("123.4E1 foobars")
assert mag == 1234
assert units == "foobars"
def test_split_unit_str_magnitude_with_decimal():
"""
split_unit_str: Given a string with magnitude containing a decimal, I
expect the function to correctly parse the magnitude.
"""
# Decimal and units
mag, units = split_unit_str("123.4 foobars")
assert mag == 123.4
assert units == "foobars"
# Decimal, units, and exponential
mag, units = split_unit_str("123.4E1 foobars")
assert mag == 1234
assert units == "foobars"
def test_split_unit_str_only_units():
"""
split_unit_str: Given a bad string containing only units (ie, no numbers),
I expect the function to raise a ValueError.
"""
with pytest.raises(ValueError):
_ = split_unit_str("foobars")
def test_split_unit_str_only_units():
"""
split_unit_str: Given a bad string containing only units (ie, no numbers),
I expect the function to raise a ValueError.
"""
with pytest.raises(ValueError):
_ = split_unit_str("foobars")
def test_split_unit_str_only_exponential():
"""
split_unit_str: Given a string with only an exponential, I expect the
function to raise a ValueError.
"""
with pytest.raises(ValueError):
_ = split_unit_str("E3")
def test_split_unit_str_empty_string():
"""
split_unit_str: Given an empty string, I expect the function to raise
a ValueError.
"""
with pytest.raises(ValueError):
_ = split_unit_str("")
def test_split_unit_str_only_exponential():
"""
split_unit_str: Given a string with only an exponential, I expect the
function to raise a ValueError.
"""
with pytest.raises(ValueError):
_ = split_unit_str("E3")
def test_split_unit_str_empty_string():
"""
split_unit_str: Given an empty string, I expect the function to raise
a ValueError.
"""
with pytest.raises(ValueError):
_ = split_unit_str("")
def quantity_constructor(loader, node):
"""
Constructs a `pq.Quantity` instance from a PyYAML
node tagged as ``!Q``.
"""
# Follows the example of http://stackoverflow.com/a/43081967/267841.
value = loader.construct_scalar(node)
return pq.Quantity(*split_unit_str(value))
def quantity_constructor(loader, node):
"""
Constructs a `pq.Quantity` instance from a PyYAML
node tagged as ``!Q``.
"""
# Follows the example of http://stackoverflow.com/a/43081967/267841.
value = loader.construct_scalar(node)
return pq.Quantity(*split_unit_str(value))
def window(self):
"""
Gets/sets the length of the coincidence window between the two signals.
:units: As specified (if a `~pint.Quantity`) or assumed to be
of units nanoseconds.
:type: `~pint.Quantity`
"""
return u.Quantity(*split_unit_str(self.query("WIND?"), "ns"))
def voltage(self):
"""
Gets/sets the output voltage of the source.
:units: As specified, or assumed to be :math:`\\text{V}` otherwise.
:type: `float` or `~pint.Quantity`
"""
raw = self.query("SOUR:VOLT?")
return u.Quantity(*split_unit_str(raw, u.volt)).to(u.volt)
def window(self):
"""
Gets/sets the length of the coincidence window between the two signals.
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of units nanoseconds.
:type: `~quantities.Quantity`
"""
return pq.Quantity(*split_unit_str(self.query("WIND?"), "ns"))
def dwell_time(self):
"""
Gets/sets the length of time before a clear signal is sent to the
counters.
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of units seconds.
:type: `~quantities.Quantity`
"""
return pq.Quantity(*split_unit_str(self.query("DWEL?"), "s"))
def test_split_unit_str_magnitude_and_units():
"""
split_unit_str: Given the input "42 foobars" I expect the output
to be (42, "foobars").
This checks that "[val] [units]" works where val is a non-scientific number
"""
mag, units = split_unit_str("42 foobars")
assert mag == 42
assert units == "foobars"
def delay(self):
"""
Get/sets the delay value (in nanoseconds) on Channel 1.
When setting, ``N`` may be ``0, 2, 4, 6, 8, 10, 12, or 14ns``.
:rtype: `~pint.Quantity`
:return: the delay value
"""
return u.Quantity(*split_unit_str(self.query("DELA?"), "ns"))
def dwell_time(self):
"""
Gets/sets the length of time before a clear signal is sent to the
counters.
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of units seconds.
:type: `~quantities.Quantity`
"""
return pq.Quantity(*split_unit_str(self.query("DWEL?"), "s"))
def temperature(self):
"""
Gets the current temperature of the specified channel.
:units: As specified by the instrument.
:rtype: `~quantities.quantity.Quantity`
"""
val, units = split_unit_str(self.query("TEMP?"))
units = "deg{}".format(units)
return pq.Quantity(val, units)
def delay(self):
"""
Get/sets the delay value (in nanoseconds) on Channel 1.
When setting, ``N`` may be ``0, 2, 4, 6, 8, 10, 12, or 14ns``.
:rtype: quantities.ns
:return: the delay value
"""
return pq.Quantity(*split_unit_str(self.query("DELA?"), "ns"))
def test_split_unit_str_magnitude_and_units():
"""
split_unit_str: Given the input "42 foobars" I expect the output
to be (42, "foobars").
This checks that "[val] [units]" works where val is a non-scientific number
"""
mag, units = split_unit_str("42 foobars")
assert mag == 42
assert units == "foobars"
def temperature(self):
"""
Gets the current temperature of the specified channel.
:units: As specified by the instrument.
:rtype: `~quantities.quantity.Quantity`
"""
val, units = split_unit_str(self.query("TEMP?"))
units = "deg{}".format(units)
return pq.Quantity(val, units)
def test_split_unit_str_ignore_default_units():
"""
split_unit_str: Given the input "42 snafus" and default_units="foobars"
I expect the output to be (42, "snafus").
This verifies that if the input has units, then any specified default_units
are ignored.
"""
mag, units = split_unit_str("42 snafus", default_units="foobars")
assert mag == 42
assert units == "snafus"
def test_split_unit_str_magnitude_and_default_units():
"""
split_unit_str: Given the input "42" and default_units="foobars"
I expect output to be (42, "foobars").
This checks that when given a string without units, the function returns
default_units as the units.
"""
mag, units = split_unit_str("42", default_units="foobars")
assert mag == 42
assert units == "foobars"
def test_split_unit_str_magnitude_and_default_units():
"""
split_unit_str: Given the input "42" and default_units="foobars"
I expect output to be (42, "foobars").
This checks that when given a string without units, the function returns
default_units as the units.
"""
mag, units = split_unit_str("42", default_units="foobars")
assert mag == 42
assert units == "foobars"
def test_split_unit_str_ignore_default_units():
"""
split_unit_str: Given the input "42 snafus" and default_units="foobars"
I expect the output to be (42, "snafus").
This verifies that if the input has units, then any specified default_units
are ignored.
"""
mag, units = split_unit_str("42 snafus", default_units="foobars")
assert mag == 42
assert units == "snafus"
def test_split_unit_str_lookups():
"""
split_unit_str: Given the input "42 FOO" and a dictionary for our units
lookup, I expect the output to be (42, "foobars").
This checks that the unit lookup parameter is correctly called, which can be
used to map between units as string and their pyquantities equivalent.
"""
unit_dict = {"FOO": "foobars", "SNA": "snafus"}
mag, units = split_unit_str("42 FOO", lookup=unit_dict.__getitem__)
assert mag == 42
assert units == "foobars"
def test_split_unit_str_scientific_notation():
"""
split_unit_str: Given inputs of scientific notation, I expect the output
to correctly represent the inputted magnitude.
This checks that inputs with scientific notation are correctly converted
to floats.
"""
# No signs, no units
mag, units = split_unit_str("123E1")
assert mag == 1230
assert units == pq.dimensionless
# Negative exponential, no units
mag, units = split_unit_str("123E-1")
assert mag == 12.3
assert units == pq.dimensionless
# Negative magnitude, no units
mag, units = split_unit_str("-123E1")
assert mag == -1230
assert units == pq.dimensionless
# No signs, with units
mag, units = split_unit_str("123E1 foobars")
assert mag == 1230
assert units == "foobars"
# Signs everywhere, with units
mag, units = split_unit_str("-123E-1 foobars")
assert mag == -12.3
assert units == "foobars"
# Lower case e
mag, units = split_unit_str("123e1")
assert mag == 1230
assert units == pq.dimensionless
def test_split_unit_str_scientific_notation():
"""
split_unit_str: Given inputs of scientific notation, I expect the output
to correctly represent the inputted magnitude.
This checks that inputs with scientific notation are correctly converted
to floats.
"""
# No signs, no units
mag, units = split_unit_str("123E1")
assert mag == 1230
assert units == u.dimensionless
# Negative exponential, no units
mag, units = split_unit_str("123E-1")
assert mag == 12.3
assert units == u.dimensionless
# Negative magnitude, no units
mag, units = split_unit_str("-123E1")
assert mag == -1230
assert units == u.dimensionless
# No signs, with units
mag, units = split_unit_str("123E1 foobars")
assert mag == 1230
assert units == "foobars"
# Signs everywhere, with units
mag, units = split_unit_str("-123E-1 foobars")
assert mag == -12.3
assert units == "foobars"
# Lower case e
mag, units = split_unit_str("123e1")
assert mag == 1230
assert units == u.dimensionless
def test_split_unit_str_lookups():
"""
split_unit_str: Given the input "42 FOO" and a dictionary for our units
lookup, I expect the output to be (42, "foobars").
This checks that the unit lookup parameter is correctly called, which can be
used to map between units as string and their pyquantities equivalent.
"""
unit_dict = {
"FOO": "foobars",
"SNA": "snafus"
}
mag, units = split_unit_str("42 FOO", lookup=unit_dict.__getitem__)
assert mag == 42
assert units == "foobars"
def dwell_time(self):
"""
Gets/sets the length of time before a clear signal is sent to the
counters.
:units: As specified (if a `~pint.Quantity`) or assumed to be
of units seconds.
:type: `~pint.Quantity`
"""
# the older versions of the firmware erroneously report the units of the
# dwell time as being seconds rather than ms
dwell_time = u.Quantity(*split_unit_str(self.query("DWEL?"), "s"))
if self.firmware[0] <= 2 and self.firmware[1] <= 1:
return dwell_time/1000.0
return dwell_time
def dwell_time(self):
"""
Gets/sets the length of time before a clear signal is sent to the
counters.
:units: As specified (if a `~quantities.Quantity`) or assumed to be
of units seconds.
:type: `~quantities.Quantity`
"""
# the older versions of the firmware erroneously report the units of the
# dwell time as being seconds rather than ms
dwell_time = pq.Quantity(*split_unit_str(self.query("DWEL?"), "s"))
if self.firmware[0] <= 2 and self.firmware[1] <= 1:
return dwell_time/1000.0
else:
return dwell_time
def voltage_range(self):
"""
Gets the voltage range for the current channel.
The MAX function SCPI command is designed in such a way
on this device that it always returns the largest absolute value.
There is no need to query MIN, as it is always 0., but one has to
order the values as MAX can be negative.
:units: :math:`\\text{V}`.
:type: array of `~pint.Quantity`
"""
value = u.Quantity(
*split_unit_str(self.query("SOUR:VOLT? MAX"), u.volt))
if value < 0.:
return value, 0.
return 0., value
def temperature(self):
val, units = split_unit_str(self._query("TEMP?"))
units = "deg{}".format(units)
return pq.Quantity(val, units)
def getter(self):
return pq.Quantity(*split_unit_str(
self._query("{}?".format(base_name)), default_units))
def max_getter(self):
return pq.Quantity(
*split_unit_str(self._query("{}:MAX?".format(base_name))))
def temperature(self):
val, units = split_unit_str(self._query("TEMP?"))
units = "deg{}".format(units)
return pq.Quantity(val, units)
def getter(self):
return pq.Quantity(*split_unit_str(
self._query("{}?".format(base_name)),
default_units
))
def max_getter(self):
return pq.Quantity(*split_unit_str(self._query("{}:MAX?".format(base_name))))
