def request_new_component(datasource, kind="livemodal", **traits):
""" Build a new instance of a chemical component 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 Component", charge=UnitScalar(0.0, units='1'),
pKa=UnitScalar(0.0, units='1'))
defaults.update(traits)
model = Component(**defaults)
view = ComponentView(model=model)
return _show_view_and_return_model(view, kind)
def test_add_strip_to_product_pass_unitscalar(self):
ds = load_default_user_datasource()[0]
prod0 = ds.get_object_of_type("products", "Prod000")
new_prod, new_comp = add_strip_to_product(
prod0, UnitScalar(18.8e3, units=gram_per_mol),
UnitScalar(0.75, units=extinction_coefficient_unit))
self.assert_new_prod_valid(prod0, new_prod, new_comp)
def request_new_product_component(datasource, kind="livemodal", **traits):
""" Build a new instance of a ProdutComponent 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.
"""
ext_coef_units = chr_units.extinction_coefficient_unit
defaults = dict(
name="New_Component", target_product="Unknown",
molecular_weight=UnitScalar(0.0, units=chr_units.kilo_dalton),
extinction_coefficient=UnitScalar(0.0, units=ext_coef_units)
)
defaults.update(traits)
model = ProductComponent(**defaults)
view = ProductComponentView(model=model)
return _show_view_and_return_model(view, kind)
def test_calculate_pool_volume_no_time(self):
start_collect_time = UnitScalar(1, units="minute")
stop_collect_time = UnitScalar(1, units="minute")
flow_rate = UnitScalar(3, units="m**3/minute")
vol = calculate_pool_volume(start_collect_time, stop_collect_time,
flow_rate, self.column)
assert_unit_scalar_almost_equal(vol, UnitScalar(0.0, units="CV"))
def test_update_std_run_sim(self):
sim = make_sample_simulation(name='Run_1')
self.assertIsNone(sim.output)
# Contains data from the CADET run:
h5file = io_data_path("Sample_Sim_from_Run_1_cadet_simulation_run.h5")
with self.assertTraitChanges(sim, "perf_param_data_event", 1):
update_simulation_results(sim, h5file)
self.assertIsInstance(sim.output, SimulationResults)
perf_params = sim.output.performance_data
self.assertIsInstance(perf_params, PerformanceData)
self.assertIsInstance(perf_params.pool, SolutionWithProduct)
num_comp = len(sim.product.product_components)
self.assertEqual(
len(perf_params.pool.product_component_concentrations), # noqa
num_comp)
assert_unit_scalar_almost_equal(perf_params.pool_volume,
UnitScalar(1.727090, units="CV"),
eps=1.e-6)
assert_unit_scalar_almost_equal(perf_params.step_yield,
UnitScalar(95.814, units='%'),
eps=1.e-3)
assert_unit_scalar_almost_equal(perf_params.start_collect_time,
UnitScalar(200.946, units='minute'),
eps=1.e-3)
assert_unit_scalar_almost_equal(perf_params.stop_collect_time,
UnitScalar(227.9, units='minute'),
eps=1.e-3)
def compute_loaded_vol(self, tgt_units=column_volumes):
""" Compute the load step volume that would match the UV data at
constant load solution concentration.
Returns
-------
UnitScalar
Load step volume, in CV, that would be needed to match the UV data.
"""
if tgt_units not in [column_volumes, g_per_liter_resin]:
msg = "Supported target units are CV and g/Liter of resin but " \
"got {}.".format(tgt_units.label)
logger.debug(msg)
raise ValueError(msg)
target_mass = self.mass_from_uv
col_volume = self.target_experiment.column.volume
concentration = self.current_concentration
vol = target_mass / concentration / col_volume
# Test equality on the labels since CV and g_per_liter_resin are equal
# from a derivation point of view (dimensionless)
if tgt_units.label == g_per_liter_resin.label:
vol = float(vol * concentration)
vol = UnitScalar(vol, units=g_per_liter_resin)
else:
vol = UnitScalar(vol, units=column_volumes)
return vol
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 request_new_resin(datasource, kind="livemodal", **traits):
""" Build a new instance of a component 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 Resin", resin_type='CEX', ligand='SO3',
average_bead_diameter=UnitScalar(0.0, units='um'),
ligand_density=UnitScalar(0.0, units=chr_units.milli_molar),
settled_porosity=UnitScalar(0.0, units=chr_units.fraction)
)
defaults.update(traits)
model = Resin(**defaults)
view = ResinView(model=model)
return _show_view_and_return_model(view, kind)
def test_scalar_convert_units(self):
scalar_data = UnitScalar(1, units=chr_units.length.m)
conv_data = convert_units(scalar_data, chr_units.length.cm)
self.assertEqual(conv_data, UnitScalar(100, units=chr_units.length.cm))
# convert back to original units and check
conv_data_2 = convert_units(conv_data, scalar_data.units)
self.assertEqual(conv_data_2, scalar_data)
def test_offset_unit_computations():
""" Executing some basic computations with a basic custom unit with offset.
"""
my_u = unit(12, m.derivation, 14)
s1 = UnitScalar(3, units=my_u)
s2 = UnitScalar(5, units=my_u)
s3 = s1 + s2
assert_equal(s3, UnitScalar(8, units=my_u))
def test_vol_std_units_with_vol_flow(self):
volume = UnitScalar(1., units="liter")
time = vol_to_time(volume, self.flow_rate_vol)
self.assertAlmostEqual(time, 1.)
volume = UnitScalar(3., units="liter")
time = vol_to_time(volume, self.flow_rate_vol)
self.assertAlmostEqual(time, 3.)
def _bed_height_actual_default(self):
# return the minimum possible height if column_type is given, else 0.0
if self.column_type is not None:
bed_height_min, _ = self.column_type.bed_height_range
range_units = self.column_type.bed_height_range.units
bed_height_min = UnitScalar(bed_height_min, units=range_units)
return bed_height_min
return UnitScalar(0.0, units='cm')
def test_offset_unit_computations(self):
""" Basic computations with a basic custom unit with offset.
"""
my_u = unit(12, m.derivation, 14)
s1 = UnitScalar(3, units=my_u)
s2 = UnitScalar(5, units=my_u)
s3 = s1 + s2
self.assertEqual(s3, UnitScalar(8, units=my_u))
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_convert_with_unit_change(self):
expected_lin_flow = UnitScalar(1., units="cm/minute")
diam = UnitScalar(2 / np.sqrt(0.1 * np.pi), units="0.1*m")
vol_flow_rate = UnitScalar(1., units="liter/minute")
lin_flow = volumetric_flow_rate_to_linear(vol_flow_rate,
diam,
to_unit="cm/minute")
self.assertTrue(unit_scalars_almost_equal(lin_flow, expected_lin_flow))
def _strip_component_default(self):
ext_coef_units = chr_units.extinction_coefficient_unit
strip_comp = ProductComponent(
name=STRIP_COMP_NAME, target_product=self.name,
molecular_weight=UnitScalar(0.0, units=chr_units.kilogram_per_mol),
extinction_coefficient=UnitScalar(0.0, units=ext_coef_units),
)
return strip_comp
def test_modified_simple_datasource_via_list(self):
# FIXME: adding to the datasource currently means adding to the
# object_catalog, to the data catalog and the corresponding list
new_comp = Component(name="New Component",
charge=UnitScalar(0.0, units='1'),
pKa=UnitScalar(0.0, units='1'))
self.ds.set_object_of_type("components", new_comp)
self.ds.make_clean()
assert_file_roundtrip_identical(self.ds)
def test_set_flow_range(self):
model_view = self._get_model_view()
new_flow_range_min = UnitScalar(1, units=ml_per_min)
new_flow_range_max = UnitScalar(2, units=ml_per_min)
model_view.system_type_flow_range_max = new_flow_range_max
model_view.system_type_flow_range_min = new_flow_range_min
new_flow_range = UnitArray([1, 2], units=ml_per_min)
self.assertEqual(self.model.flow_range, new_flow_range)
def setUp(self):
self.flow_rate_vol = UnitScalar(1., units="liter/minute")
self.flow_rate_lin = UnitScalar(1., units="cm/minute")
column_type = ColumnType(**COLUMN_TYPE_DATA)
self.column = Column(column_type=column_type, **COLUMN_DATA)
self.column.column_type.diameter = UnitScalar(10, units='cm')
self.column.column_type.bed_height_range = UnitArray([10., 30.],
units="cm")
self.column.volume = UnitScalar(1, units='liter')
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_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 get_instance(self, constructor_data):
# Attribute was renamed: akta_settings -> import_settings
settings = constructor_data['kwargs'].pop("akta_settings")
# We used to store the value as a float: convert to UnitScalar
too = settings["time_of_origin"]
settings["time_of_origin"] = UnitScalar(too, units="minute")
settings["holdup_volume"] = UnitScalar(0., units="minute")
constructor_data['kwargs']["import_settings"] = settings
return super(experimentResultsDeSerializer,
self).get_instance(constructor_data)
def test_vol_std_units_with_lin_flow(self):
volume = UnitScalar(1., units="liter")
time = vol_to_time(volume,
flow_rate=self.flow_rate_lin,
column=self.column)
self.assertAlmostEqual(time, 40. / np.pi)
volume = UnitScalar(3., units="liter")
time = vol_to_time(volume, self.flow_rate_lin, column=self.column)
self.assertAlmostEqual(time, 120. / np.pi)
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_calculate_step_yield(self):
pool_concentration = UnitScalar(1, units="g/liter")
pool_volume = UnitScalar(1, units="CV")
step_volume = UnitScalar(1, units="CV")
step_flow_rate = UnitScalar(100, units="liter/minute")
sols = [
SolutionWithProduct(product_concentration=pool_concentration,
name="Sol")
]
load_step = MethodStep(step_type="Load",
name="Load",
solutions=sols,
flow_rate=step_flow_rate,
volume=step_volume)
step_yield = calculate_step_yield(pool_concentration, pool_volume,
load_step)
assert_unit_scalar_almost_equal(step_yield, UnitScalar(100, units="%"))
pool_concentration09 = UnitScalar(0.9, units="g/liter")
step_yield = calculate_step_yield(pool_concentration09, pool_volume,
load_step)
assert_unit_scalar_almost_equal(step_yield, UnitScalar(90, units="%"))
pool_volume = UnitScalar(0.9, units="CV")
step_yield = calculate_step_yield(pool_concentration, pool_volume,
load_step)
assert_unit_scalar_almost_equal(step_yield, UnitScalar(90, units="%"))
def _get_strip_mass_fraction(self):
# get the assay value for the Strip assay
if STRIP_COMP_NAME in self.product.product_component_assays:
strip_idx = self.product.product_component_assays.index(
STRIP_COMP_NAME)
else:
return UnitScalar(np.nan, units="%")
assay_values = self.product_component_assay_values
val = assay_values[strip_idx]
return UnitScalar(val, units=assay_values.units)
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_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)
