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_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_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 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 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_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): 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_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_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_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_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 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 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 test_bed_height_proxy(self): # Make a view. Equivalent to view = ColumnView(model=self.model) model_view = self._get_model_view() range_units = self.model.bed_height_range.units # Check that the view got the initial values from the model: self.assertEqual(model_view.column_type_bed_height_min, UnitScalar(10, units=range_units)) self.assertEqual(model_view.column_type_bed_height_max, UnitScalar(30, units=range_units)) # Set model min/max values # FIXME: This min_val of 20.0 is required to avoid breaking tests in # test_simulation_from_experiment_builder. Somehow, this test is # setting CP_001's bed_height_actual to min_val, and other code then # try to add CP_001 with a bed_height_actual of 20 in the datasource, # provoking a DS collision. The connection is unclear at this point. min_val = 20.0 max_val = 21.22 min_val_unitted = UnitScalar(min_val, units=range_units) max_val_unitted = UnitScalar(max_val, units=range_units) # Set the view and make sure the model is updated model_view.column_type_bed_height_min = min_val_unitted model_view.column_type_bed_height_max = max_val_unitted # Check that model's range is updated self.assertEqual(self.model.bed_height_range, UnitArray([min_val, max_val], units=range_units))
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 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_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 update_product_assays(self): """ Returns a list of ProductAssays for all comps but strip It is constructed from the model's assay data. """ solution = self.model assay_values = solution.product_component_assay_values if assay_values is None: vals = [0.] * len(solution.product.product_component_assays) assay_values = UnitArray(vals, units=percent) num_comps = len(assay_values) product_assays = [] for i in range(num_comps): assay_name = solution.product.product_component_assays[i] # Exclude the strip, since it is handled separately: if assay_name == STRIP_COMP_NAME: continue prod_assay_data = { 'name': assay_name, 'proportion': UnitScalar(assay_values[i], units=assay_values.units) } product_assays.append(ProductAssay(**prod_assay_data)) self.product_assays = product_assays
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 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 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")