def test_add_compatible(self):
a = UnitArray([1, 2, 3], units=meters)
b = UnitArray([1, 2, 3], units=feet)
result = a + b
mplusf = (meters + feet).value
self.assertEqual(result[0], mplusf)
self.assertEqual(result.units, meters)
def test_gram_per_mol(self):
x = UnitArray([1000, 2000, 3000], units=chr_units.gram_per_mol)
expected = UnitArray([1000, 2000, 3000], units=mass.g / substance.mole)
assert_unit_array_almost_equal(x, expected)
y = UnitArray([1000, 2000, 3000], units="g/mol")
assert_unit_array_almost_equal(y, expected)
def test_subtract_compatible(self):
a = UnitArray([1, 2, 3], units=meters)
b = UnitArray([1, 2, 3], units=feet)
result = a - b
mminusf = (meters - feet).value
self.assertEqual(result[0], mminusf)
self.assertEqual(result.units, meters)
def test_index_name(self):
""" Can set and retreive the index_name?
"""
ary = numpy.array((1,2,3))
unit_ary = UnitArray(ary)
unit_ary.index_name = "depth"
self.assertEqual(unit_ary.index_name, "depth")
def test_unit_array_with_decorated_docstring_function(self):
"""Does has_units wrap with docstring work ?
"""
def addfunc(a, b):
return a + b
@has_units
def add(a, b):
''' Add two arrays in ft/s and convert them to m/s.
Parameters
----------
a : array : units=ft/s
An array
b : array : units=ft/s
Another array
Returns
-------
c : array : units=m/s
c = a + b
'''
return (a + b) * 0.3048
a = UnitArray(arange(100), units=feet / second)
b = UnitArray(arange(100)**2, units=feet / second)
self.assertTrue(
allclose(addfunc(a, b).as_units(meters / second), add(a, b)))
a = UnitArray(arange(100), units=meters / second)
b = UnitArray(arange(100)**2, units=meters / second)
self.assertTrue(
allclose(addfunc(a, b).as_units(meters / second), add(a, b)))
def test_unit_array_with_decorated_docstring_and_inputted_parameters(self):
"""Does has_units wrap with expanded docstring and inputting
parameters work the same ?
"""
@has_units(inputs="a:an array:units=ft/s;b:array:units=ft/s",
outputs="c:an array:units=m/s")
def add(a, b):
" Add two arrays in ft/s and convert them to m/s. "
return (a + b) * 0.3048
@has_units
def add_doc(a, b):
''' Add two arrays in ft/s and convert them to m/s.
Parameters
----------
a : array : units=ft/s
An array
b : array : units=ft/s
Another array
Returns
-------
c : array : units=m/s
c = a + b
'''
return (a + b) * 0.3048
a = UnitArray(arange(100), units=feet / second)
b = UnitArray(arange(100)**2, units=feet / second)
self.assertTrue(allclose(add_doc(a, b), add(a, b)))
a = UnitArray(arange(100), units=meters / second)
b = UnitArray(arange(100)**2, units=meters / second)
self.assertTrue(allclose(add_doc(a, b), add(a, b)))
def test_concatenate(self):
unit_ary_1 = UnitArray(numpy.array((1, 2, 3)), units=meters)
unit_ary_2 = UnitArray(numpy.array((4, 5, 6)), units=meters)
new_unit_ary = UnitArray.concatenate([unit_ary_1, unit_ary_2])
expected = UnitArray((1, 2, 3, 4, 5, 6), units=meters)
self.assertTrue(numpy.all(new_unit_ary == expected))
def test_index_name(self):
""" Can set and retreive the index_name?
"""
ary = numpy.array((1, 2, 3))
unit_ary = UnitArray(ary)
unit_ary.index_name = "depth"
self.assertEqual(unit_ary.index_name, "depth")
def test_kilo_dalton(self):
x = UnitArray([1, 2, 3], units=chr_units.kilo_dalton)
expected = UnitArray([1, 2, 3], units=chr_units.kilogram_per_mol)
assert_unit_array_almost_equal(x, expected)
# This unit is equal but distinct:
self.assertIsNot(chr_units.kilo_dalton, chr_units.kilogram_per_mol)
y = UnitArray([1, 2, 3], units="kDa")
assert_unit_array_almost_equal(y, expected)
def test_dalton(self):
x = UnitArray([1000, 2000, 3000], units=chr_units.gram_per_mol)
expected = UnitArray([1000, 2000, 3000], units=chr_units.dalton)
assert_unit_array_almost_equal(x, expected)
# This unit is equal but distinct:
self.assertIsNot(chr_units.dalton, chr_units.gram_per_mol)
y = UnitArray([1000, 2000, 3000], units="Da")
assert_unit_array_almost_equal(y, expected)
def setUp(self):
# Make some data to play with.
self.meter_array = UnitArray([1., 2, 3], units=meters)
self.second_array = UnitArray([3., 2, 1], units=second)
self.feet_array = UnitArray([4., 5, 6], units=feet)
self.meter_scalar = UnitScalar(1., units=meters)
self.second_scalar = UnitScalar(3., units=second)
self.feet_scalar = UnitScalar(4., units=feet)
unittest.TestCase.setUp(self)
def test_divide_pass(self):
a = UnitArray([1, 2, 3], units=meters / second)
result = a / 3.0
self.assertEqual(result.units, meters / second)
result = 3.0 / a
self.assertEqual(result.units, second / meters)
b = UnitArray([3, 2, 1], units=second)
result = a / b
self.assertEqual(result.units, meters / second**2)
def test_product_component_purity_calc(self):
load = self.load
load_conc_units = load.product_concentration.units
expt_concentrations = UnitArray([0.07896, 0.82908, 0.03195718],
units=load_conc_units)
expt_purities = expt_concentrations / load.product_concentration * 100
expt_purities = UnitArray(expt_purities, units=percent)
assert_unit_array_almost_equal(load.product_component_purities,
expt_purities,
atol=1e-5)
def test_array_convert_units(self):
array_data = UnitArray([1, 2, 3], units=chr_units.length.m)
conv_data = convert_units(array_data, chr_units.length.cm)
assert_allclose(conv_data.tolist(), (100 * array_data).tolist())
self.assertEqual(conv_data.units, chr_units.length.cm)
# convert back to original units and check
conv_data_2 = convert_units(conv_data, array_data.units)
assert_allclose(conv_data_2.tolist(), array_data.tolist())
self.assertEqual(conv_data_2.units, array_data.units)
def test_concatenate_keeps_attribute(self):
""" concatenating does not call __new__ on the result
so the attribute must be set correctly in __array_finalize__
"""
unit_ary_1 = UnitArray(numpy.array((1, 2, 3)), units=meters)
unit_ary_2 = UnitArray(numpy.array((1, 2, 3)), units=meters)
new_unit_ary = UnitArray.concatenate([unit_ary_1, unit_ary_2])
self.assertEqual(new_unit_ary.units, meters)
def test_product_component_purity_calc(self):
pool = self.pool
pool_conc_units = pool.product_concentration.units
sim_concentrations = UnitArray([0.1, 0.25, 0.05],
units=pool_conc_units)
pool.product_component_concentrations = sim_concentrations
sim_purities = sim_concentrations / pool.product_concentration * 100
sim_purities = UnitArray(sim_purities, units=percent)
assert_unit_array_almost_equal(pool.product_component_purities,
sim_purities,
atol=1e-5)
def test_pow_pass(self):
a = UnitArray([1, 2, 3], units=meters)
b = 0.5
result = a**b
self.assertEqual(result.units, meters**0.5)
c = array(0.5)
result = a**c
self.assertEqual(result.units, meters**0.5)
d = UnitArray(0.5, units=dimensionless)
result = a**d
self.assertEqual(result.units, meters**0.5)
def test_as_units(self):
""" Conversion from one unit system to another.
"""
ary = numpy.array((1,2,3))
unit_ary = UnitArray(ary, units=meters)
new_unit_ary = unit_ary.as_units(feet)
# Test the values are correct
desired_array = units.convert(ary, meters, feet)
self.assert_(numpy.all(desired_array==new_unit_ary))
# Also, make sure the units are correctly assigned.
self.assertEqual(new_unit_ary.units, feet)
def test_as_units(self):
""" Conversion from one unit system to another.
"""
ary = numpy.array((1, 2, 3))
unit_ary = UnitArray(ary, units=meters)
new_unit_ary = unit_ary.as_units(feet)
# Test the values are correct
desired_array = units.convert(ary, meters, feet)
self.assertTrue(numpy.all(desired_array == new_unit_ary))
# Also, make sure the units are correctly assigned.
self.assertEqual(new_unit_ary.units, feet)
def test_pickle(self):
'Pickling'
for a in (
UnitArray(0),
UnitArray([0, 1]),
UnitArray([0, 1], units=feet / seconds),
UnitArray([[0.5, 1.0], [10., 20.]], units=meters),
):
state = dumps(a)
b = loads(state)
self.assertTrue(all(b == a))
self.assertTrue(hasattr(b, 'units'))
self.assertEqual(b.units, a.units)
def test_concatenate_keeps_attribute_using_mixed_units(self):
""" concatenating does not call __new__ on the result
so the attribute must be set correctly in __array_finalize__.
This test creates another unit array with different units
before the concatenate to make sure the finalize method does not
assign the wrong units
"""
unit_ary_1 = UnitArray(numpy.array((1, 2, 3)), units=meters)
unit_ary_2 = UnitArray(numpy.array((1, 2, 3)), units=meters)
unit_ary_3 = UnitArray(numpy.array((1, 2, 3)), units=feet)
new_unit_ary = UnitArray.concatenate([unit_ary_1, unit_ary_2])
self.assertEqual(new_unit_ary.units, meters)
def test_repr(self):
""" Test output of repr()"""
a = UnitArray([1, 2, 3], units="cm")
self.assertEqual(repr(a), "UnitArray([1, 2, 3], units='0.01*m')")
# unit with no label
labelless_unit = cm * gram
a = UnitArray([1, 2, 3], units=labelless_unit)
self.assertEqual(repr(a), "UnitArray([1, 2, 3], units='1e-05*m*kg')")
# dimensionless quantity
dimensionless_unit = copy(dimensionless)
dimensionless_unit.label = "Cool unit"
a = UnitArray([1, 2, 3], units=dimensionless_unit)
self.assertEqual(repr(a), "UnitArray([1, 2, 3], units='1')")
def test_unit_array_with_units_decorated(self):
def func(value):
return value
@has_units(inputs="value: a value: units=m/s;")
def func_wrapped(value):
return value
a = UnitArray(arange(100), units=meters / second)
self.assertTrue(
allclose(func(a).as_units(meters / second), func_wrapped(a)))
a = UnitArray(arange(100), units=feet / second)
self.assertTrue(
allclose(func(a).as_units(meters / second), func_wrapped(a)))
def test_concatenate(self):
unit_ary_1 = UnitArray(numpy.array((1,2,3)), units=meters)
unit_ary_2 = UnitArray(numpy.array((4,5,6)), units=meters)
new_unit_ary = UnitArray.concatenate([unit_ary_1, unit_ary_2])
expected = UnitArray((1,2,3,4,5,6), units=meters)
self.assertTrue(numpy.all(new_unit_ary == expected))
def request_new_system_type(datasource, kind="livemodal", **traits):
""" Build a new instance of a SystemType invoking its UI editor.
Parameters
-----------
datasource : Instance(SimpleDataSource)
User datasource targeted to be contributed to.
kind : str
Should be set to None to make it non-blocking (only useful for testing
purposes).
traits : dict
Attributes of the created object. Used to override the defaults.
Returns
-------
Tuple with the object created and the data to create it since it is to be
contributed to the SimpleDataSource.
"""
defaults = dict(
name='New System Type', manufacturer='manufacturer',
manufacturer_name='New System Type',
flow_range=UnitArray([0., 0.], units=chr_units.ml_per_min)
)
defaults.update(traits)
model = SystemType(**defaults)
view = SystemTypeView(model=model)
return _show_view_and_return_model(view, kind)
def test_add(self):
""" Binary operation of array + UnitArray should return a UnitArray.
"""
ary = numpy.array((1, 2, 3))
unit_ary = UnitArray(ary)
res = unit_ary + ary
assert type(res) is UnitArray
def test_le(self):
a = UnitArray([1.0, 2.0, 3], units=dimensionless)
b = UnitArray([3.0, 1.0, 1], units=2.0 * dimensionless)
result = a <= b
self.assertEqual(result[0], True)
self.assertEqual(result[1], True)
self.assertEqual(result[2], False)
c = 2.0
result = b <= c
self.assertEqual(result[0], False)
self.assertEqual(result[1], True)
self.assertEqual(result[2], True)
self.assertEqual(result[0], False)
self.assertEqual(result[1], True)
self.assertEqual(result[2], True)
def calculate_step_start_times(sim):
""" Calculate all step start times and stop time of the last step in min
from the beginning of the method.
Parameters
----------
sim : _BaseExperiment (Experiment or Simulation)
Experiment-like object containing the method to analyze.
Returns
-------
UnitArray
Start times for all steps and stop time of last step in minutes.
"""
start_times = [0.]
for step in sim.method.method_steps:
step_time = vol_to_time(step.volume,
step.flow_rate,
column=sim.column,
to_unit="minute")
start_times.append(step_time)
start_times = np.cumsum(start_times)
return UnitArray(start_times, units="minute")
def test_subtract_dimensionless(self):
a = UnitArray([1, 2, 3], units=dimensionless)
b = 1
result = a - b
self.assertEqual(result.units, dimensionless)
assert_array_equal(result, UnitArray([0, 1, 2], units=dimensionless))
result = b - a
self.assertEqual(result.units, dimensionless)
assert_array_equal(result, UnitArray([0, -1, -2], units=dimensionless))
c = array([3, 2, 1])
result = a - c
self.assertEqual(result.units, dimensionless)
assert_array_equal(result, UnitArray([-2, 0, 2], units=dimensionless))
result = c - a
self.assertEqual(result.units, dimensionless)
assert_array_equal(result, UnitArray([2, 0, -2], units=dimensionless))
def request_new_column_type(datasource, kind="livemodal", **traits):
""" Build a new instance of a ColumnType invoking its UI editor.
Parameters
-----------
datasource : Instance(SimpleDataSource)
User datasource targeted to be contributed to.
kind : str
Should be set to None to make it non-blocking (only useful for testing
purposes).
traits : dict
Attributes of the created object. Used to override the defaults.
Returns
-------
Tuple with the object created and the data to create it since it is to be
contributed to the SimpleDataSource.
"""
defaults = dict(name='New Column Type', manufacturer='manufacturer',
manufacturer_name='New Column Type',
diameter=UnitScalar(0.0, units='cm'),
bed_height_range=UnitArray([0., 0.], units='cm'),
bed_height_adjust_method='None')
defaults.update(traits)
model = ColumnType(**defaults)
view = ColumnTypeView(model=model)
return _show_view_and_return_model(view, kind)
def test_str(self):
""" Test output of str() """
a = UnitArray([1, 2, 3], units="cm")
self.assertEqual(str(a), "UnitArray (cm): [1, 2, 3]")
# unit with no label
labelless_unit = cm * gram
a = UnitArray([1, 2, 3], units=labelless_unit)
# For units with no label, the repr of the unit is used.
self.assertEqual(str(a), "UnitArray (1e-05*m*kg): [1, 2, 3]")
# dimensionless quantity
dimensionless_unit = copy(dimensionless)
dimensionless_unit.label = "Cool unit"
a = UnitArray([1, 2, 3], units=dimensionless_unit)
self.assertEqual(str(a), "UnitArray (Cool unit): [1, 2, 3]")
def test_array_equality(self):
""" Rich comparison of array == UnitArray should compare the data
"""
ary = numpy.array((1, 2, 3))
unit_ary = UnitArray(ary)
res = unit_ary + ary
assert numpy.all(res == (ary + ary))
def setUp(self):
# Make some useful data.
self.unit_array = UnitArray((1, 2, 3), units=meters)
self.unit_scalar = UnitScalar(1, units=meters)
self.plain_array = array([1, 2, 3])
self.plain_scalar = 1
unittest.TestCase.setUp(self)
def test_adapt_getitem_converts_correctly(self):
""" Does getitem convert units correctly?
"""
context = None
old_log = UnitArray((1, 2, 3), units=meters)
getitem_units = {"depth": feet}
adapter = UnitConversionAdapter(getitem_units=getitem_units)
name, new_log = adapter.adapt_getitem(context, "depth", old_log)
# Did the values get converted correctly?
self.assert_(all(new_log == old_log.as_units(feet)))
# Are the units assigned correctly?
self.assert_(new_log.units == feet)
return
def test_get_set_converts_correctly(self):
""" Does get/set with different units convert correctly?
"""
context = None
meter_log = UnitArray((1, 2, 3), units=meters)
setitem_units = {"depth": inch}
getitem_units = {"depth": feet}
adapter = UnitConversionAdapter(getitem_units=getitem_units, setitem_units=setitem_units)
name, inch_log = adapter.adapt_setitem(context, "depth", meter_log)
self.assert_(all(inch_log == meter_log.as_units(inch)))
name, feet_log = adapter.adapt_getitem(context, "depth", inch_log)
# Did the values get converted correctly?
self.assert_(all(feet_log == meter_log.as_units(feet)))
# Are the units assigned correctly?
self.assert_(feet_log.units == feet)
return
def test_concatenate_keeps_attribute(self):
""" concatenating does not call __new__ on the result
so the attribute must be set correctly in __array_finalize__
"""
unit_ary_1 = UnitArray(numpy.array((1,2,3)), units=meters)
unit_ary_2 = UnitArray(numpy.array((1,2,3)), units=meters)
new_unit_ary = UnitArray.concatenate([unit_ary_1, unit_ary_2])
self.assertEqual(new_unit_ary.units, meters)
def test_getitem_converts_correctly(self):
""" Does getitem convert units correctly?
"""
getitem_units = {'depth':feet}
adapter = UnitConversionAdapter(getitem_units=getitem_units)
old_log = UnitArray((1,2,3),units=meters)
self.context['depth'] = old_log
self.context.push_adapter(adapter)
new_log = self.context['depth']
# Did the values get converted correctly?
self.assert_(all(new_log==old_log.as_units(feet)))
# Are the units assigned correctly?
self.assert_(new_log.units==feet)
return
def setUp(self):
unittest.TestCase.setUp(self)
# Put unit adapters on either side of a masking adapter to see if they
# cooperate. Store meters in the raw context, push fathoms through the
# mask, and expose feet to the outside world.
self.units = units = { 'in':meters, 'mid':fathom, 'out':feet }
# Set up data for the contexts
depth = UnitArray(linspace(0.0, 100.0, 11), units=units['in'])
lith = array(['sand']*len(depth), dtype=object)
# Create the contexts
self.context = AdaptedDataContext(subcontext=DataContext())
self.raw_context = self.context.subcontext
# Add data (before creating the adapters)
self.context.update(depth=depth, lith=lith)
# (This simplifies creating UnitConversionAdapters)
def always(value):
class C(dict):
def get(self, key, default=None):
return value
def __repr__(self):
return '{*:%r}' % value
return C()
# Layer multiple adapters
d = depth.view(ndarray)
self.mask = (15.0 < d) & (d < 55.0)
self.convert_out = lambda x: convert(x, units['in'], units['out'])
self.convert_in = lambda x: convert(x, units['out'], units['in'])
#self.context.push_adapter(
# UnitConversionAdapter(setitem_units=always(units['in']),
# getitem_units=always(units['mid'])))
self.context.push_adapter(MaskingAdapter(mask=self.mask))
self.context.push_adapter(
# UnitConversionAdapter(setitem_units=always(units['mid']),
UnitConversionAdapter(setitem_units=always(units['in']),
getitem_units=always(units['out'])))
def test_setitem_converts_correctly(self):
""" Does setitem convert units correctly?
"""
old_log = UnitArray((1,2,3),units=meters)
getitem_units = {'depth':feet}
adapter = UnitConversionAdapter(getitem_units=getitem_units)
self.context.push_adapter(adapter)
# pass the log into the conversion adapter as meters
self.context['depth'] = old_log
# Now retreive the log from the underlying context.
new_log = self.context['depth']
# Did the values get converted correctly?
self.assert_(all(new_log==old_log.as_units(feet)))
# Are the units assigned correctly?
self.assert_(new_log.units==feet)
return
def test_concatenate_keeps_attribute_using_mixed_units(self):
""" concatenating does not call __new__ on the result
so the attribute must be set correctly in __array_finalize__.
This test creates another unit array with different units
before the concatenate to make sure the finalize method does not
assign the wrong units
"""
unit_ary_1 = UnitArray(numpy.array((1,2,3)), units=meters)
unit_ary_2 = UnitArray(numpy.array((1,2,3)), units=meters)
unit_ary_3 = UnitArray(numpy.array((1,2,3)), units=feet)
new_unit_ary = UnitArray.concatenate([unit_ary_1, unit_ary_2])
self.assertEqual(new_unit_ary.units, meters)
