def assert_analyzed_state(self, mba, aligned=False):
self.assertIsInstance(mba.balance_threshold, float)
self.assertGreater(mba.balance_threshold, 0.)
assert_unit_scalar_almost_equal(mba.current_volume, self.load_volume)
assert_unit_scalar_almost_equal(mba.current_concentration,
self.load_concentration)
# We know this file is balanced
self.assertIsInstance(mba.mass_from_method, UnitScalar)
self.assertFalse(isnan(mba.mass_from_method))
self.assertIsInstance(mba.mass_from_uv, UnitScalar)
self.assertFalse(isnan(mba.mass_from_uv))
if aligned:
self.assertTrue(mba.balanced)
else:
self.assertFalse(mba.balanced)
# Can compute what values are needed to balance the data:
new_vol = mba.compute_loaded_vol(tgt_units=column_volumes)
self.assertEqual(new_vol.units.label, "CV")
if aligned:
self.assertAlmostEqual(float(new_vol),
float(self.load_volume),
places=4)
new_conc = mba.compute_concentration()
self.assertEqual(new_conc.units.label, "g/L")
if aligned:
self.assertAlmostEqual(float(new_conc),
float(self.load_concentration),
places=1)
def assert_initial_state(self, mba):
self.assertIsInstance(mba.balance_threshold, float)
self.assertGreater(mba.balance_threshold, 0.)
assert_unit_scalar_almost_equal(mba.current_volume, self.load_volume)
assert_unit_scalar_almost_equal(mba.current_concentration,
self.load_concentration)
self.assertFalse(mba.balanced)
def test_compute_with_volume_in_CV_units(self):
time = UnitScalar(1., units="minute")
volume = time_to_volume(time, self.flow_rate_vol, to_unit="liter")
assert_unit_scalar_almost_equal(volume, UnitScalar(1., units="liter"))
time = UnitScalar(3., units="minute")
volume = time_to_volume(time, self.flow_rate_vol, to_unit="liter")
assert_unit_scalar_almost_equal(volume, UnitScalar(3., units="liter"))
def test_time_std_units_with_vol_flow(self):
time = UnitScalar(1., units="minute")
volume = time_to_volume(time, self.flow_rate_vol, self.column)
assert_unit_scalar_almost_equal(volume, UnitScalar(1., units="CV"))
time = UnitScalar(3., units="minute")
volume = time_to_volume(time, self.flow_rate_vol, self.column)
assert_unit_scalar_almost_equal(volume, UnitScalar(3., units="CV"))
def test_change_strip_fraction_bad_value(self):
self.experim.strip_mass_fraction = UnitScalar(2, units="%")
load = self.experim.method.load.solutions[0]
self.assertAlmostEqual(load.product_component_assay_values[-1], 2.)
# This will fail by raising an exception, in the
self.experim.strip_mass_fraction = UnitScalar(3, units="cm")
self.assertAlmostEqual(load.product_component_assay_values[-1], 2.)
assert_unit_scalar_almost_equal(self.experim.strip_mass_fraction,
UnitScalar(2, units="%"))
def test_get_step_start_time_no_offline_steps(self):
self.experim.method.offline_steps = []
load_start = self.experim.get_step_start_time(self.experim.method.load)
expected = UnitScalar(self.load_time, units="min")
assert_unit_scalar_almost_equal(load_start, expected)
strip_step = self.experim.method.get_step_of_type(STRIP_STEP_TYPE)
strip_start = self.experim.get_step_start_time(strip_step)
expected = UnitScalar(self.strip_time, units="min")
assert_unit_scalar_almost_equal(strip_start, expected)
def test_g_per_liter_resin_to_cv_conc_units(self):
""" g/L_resin -> CV, passing concentration in different unit.
"""
concentration = UnitScalar(8030, units="g/m**3")
vol = UnitScalar(0.0635, units=chr_units.g_per_liter_resin)
expected = UnitScalar(0.0635 / 8.03, units="CV")
new_vol = convert_units(vol,
tgt_unit="CV",
concentration=concentration)
assert_unit_scalar_almost_equal(new_vol, expected)
def test_get_step_start_time_default_offline_steps(self):
self.assertEqual(self.experim.method.offline_steps,
['Pre-Equilibration', 'Equilibration'])
load_start = self.experim.get_step_start_time(self.experim.method.load)
expected = UnitScalar(0., units="min")
assert_unit_scalar_almost_equal(load_start, expected)
strip_step = self.experim.method.get_step_of_type(STRIP_STEP_TYPE)
strip_start = self.experim.get_step_start_time(strip_step)
expected = UnitScalar(self.strip_time - self.load_time, units="min")
assert_unit_scalar_almost_equal(strip_start, expected)
def test_time_std_units_with_lin_flow(self):
time = UnitScalar(10., units="minute")
volume = time_to_volume(time,
flow_rate=self.flow_rate_lin,
column=self.column)
self.assertAlmostEqual(volume, UnitScalar(np.pi / 4., units="CV"))
time = UnitScalar(30., units="minute")
volume = time_to_volume(time, self.flow_rate_lin, column=self.column)
assert_unit_scalar_almost_equal(volume,
UnitScalar(3 * np.pi / 4., units="CV"))
def test_g_per_liter_resin_to_cv(self):
concentration = UnitScalar(8.03, units="g/L")
vol = UnitScalar(0.0635, units=chr_units.g_per_liter_resin)
# without a concentration, the conversion is impossible:
with self.assertRaises(ValueError):
convert_units(vol, tgt_unit="CV")
new_vol = convert_units(vol,
tgt_unit="CV",
concentration=concentration)
expected = UnitScalar(0.0635 / 8.03, units="CV")
assert_unit_scalar_almost_equal(new_vol, expected)
def test_set_volume(self):
x = UnitScalar(1e-1, units="m**3")
with self.assertTraitChanges(self.column, "bed_height_actual", 1):
self.column.volume = x
assert_unit_scalar_almost_equal(self.column.volume, x)
# Do nothing if value is already set
with self.assertTraitDoesNotChange(self.column, "bed_height_actual"):
self.column.volume = x
# Different unit
x2 = UnitScalar(150, units="liter")
with self.assertTraitChanges(self.column, "bed_height_actual", 1):
self.column.volume = x2
assert_unit_scalar_almost_equal(self.column.volume, x2)
def test_parse_g_per_liter_resin_label(self):
vol = UnitScalar(1, units="g/Liter_resin")
vol2 = UnitScalar(1, units=chr_units.g_per_liter_resin)
assert_unit_scalar_almost_equal(vol, vol2)
def test_parse_column_volume_label(self):
vol = UnitScalar(1, units="CV")
vol2 = UnitScalar(1, units=chr_units.column_volumes)
assert_unit_scalar_almost_equal(vol, vol2)
def test_volume_calculation(self):
actual_col_vol = UnitScalar(157079.63, units=milliliter)
assert_unit_scalar_almost_equal(self.column.volume,
actual_col_vol,
eps=1e-2)
def test_set_strip_fraction(self):
self.load.strip_mass_fraction = UnitScalar(10.0, units='%')
assert_unit_scalar_almost_equal(self.load.strip_mass_fraction,
UnitScalar(10.0, units='%'))
