def setUp(self):
# Register all views
BaseModelViewTestCase.setUp(self)
# This could be the manual creation of an instance of the ChromData to
# represent.
self.model = make_sample_simulation()
def setUp(self):
register_all_tree_node_adapters()
# Make a study and add all possible chromatography objects to the study
# Make a study with 1 experiment
self.study = make_sample_study(1)
simulation = make_sample_simulation()
self.study.simulations.append(simulation)
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 test_add_sim(self):
from kromatography.model.tests.sample_data_factories import \
make_sample_simulation
study = self.study2
sim = make_sample_simulation()
study.simulations.append(sim)
self.assertFalse(is_task_blank(self.task2))
def test_change_filename(self):
sim = make_sample_simulation()
new_fname = str(uuid4()) + FILENAME_SUFFIX
with self.assertTraitChanges(sim, "uuid", 1):
with self.assertTraitChanges(sim, "cadet_filepath", 1):
sim.cadet_filename = new_fname
self.assert_cadet_filename_consistent(sim)
def test_change_uuid(self):
sim = make_sample_simulation()
self.assert_cadet_filename_consistent(sim)
new_uuid = uuid4()
with self.assertTraitChanges(sim, "cadet_filename", 1):
with self.assertTraitChanges(sim, "cadet_filepath", 1):
sim.uuid = new_uuid
self.assert_cadet_filename_consistent(sim)
def setUp(self):
# Manual construction
column_type = ColumnType(**COLUMN_TYPE_DATA)
resin = Resin(**RESIN_DATA)
column = Column(column_type=column_type, resin=resin, **COLUMN_DATA)
method = Method(**METHOD_DATA)
self.sim_from_scratch = Simulation(name='Sim1',
column=column,
method=method,
output=None)
self.sim_from_std_exp = make_sample_simulation()
def test_create_cadet_file(self):
from kromatography.model.tests.sample_data_factories import \
make_sample_simulation
sim = make_sample_simulation()
self.assertFalse(isfile(sim.cadet_filepath))
res = sim.create_cadet_input_file()
try:
self.assertTrue(isfile(sim.cadet_filepath))
self.assertEqual(res, sim.cadet_filepath)
# Asking for it again just returns the filename
res2 = sim.create_cadet_input_file()
self.assertEqual(res, res2)
finally:
if isfile(sim.cadet_filepath):
os.remove(sim.cadet_filepath)
def setUp(self):
self.standard_actions = [
DeleteAction, RenameAction, CopyAction, CutAction
]
register_all_tree_node_adapters()
# Make a study and add all possible chromatography objects to the study
# Make a study with 1 experiment
self.study = make_sample_study(1)
simulation = make_sample_simulation()
self.study.simulations.append(simulation)
self.user_ds = make_sample_user_ds(with_bind_trans=True)
self.user_ds_entries = self.user_ds.object_catalog.keys()
self.user_ds_objects = [
getattr(self.user_ds, key) for key in self.user_ds_entries
]
self.study.study_datasource.binding_models.\
append(self.study.simulations[0].binding_model)
self.study.study_datasource.transport_models.\
append(self.study.simulations[0].transport_model)
in_study_ds = self.study.study_datasource
self.in_study_ds_entries = in_study_ds.object_catalog.keys()
self.in_study_objects = [
getattr(in_study_ds, key) for key in self.in_study_ds_entries
]
yield run_cadet_simulator, (output_file,), {"use_slurm": use_slurm}
if __name__ == "__main__":
from traits.api import Any, Button
from traitsui.api import View, Item
from kromatography.model.tests.sample_data_factories import \
make_sample_simulation, make_sample_simulation_group2
from kromatography.utils.app_utils import initialize_logging
from kromatography.model.factories.job_manager import \
create_start_job_manager
initialize_logging(verbose=True)
sim = make_sample_simulation(name='Run_1')
NUM_JOBS = 1
NUM_WORK_ITEMS_PER_JOB = 2
NUM_SIM = NUM_JOBS * NUM_WORK_ITEMS_PER_JOB
t0 = time()
# runner1 = sim.run()
# group = make_sample_simulation_group2(size=2)
# runner2 = group.run(wait=True)
class SimpleGroupUI(HasStrictTraits):
group = Any
job_manager = Any
button = Button("Run sims")
view = View(
Item("object.group.run_status"),
def setUp(self):
self.source_param = ParameterScanDescription(
name="binding_model.sma_nu[2]",
low=4, high=6, num_values=10
)
self.sim = make_sample_simulation()
def setUpClass(cls):
cls.sim = make_sample_simulation()
cls.num_comp = len(cls.sim.product.product_components)
def setUp(self):
self.simulation = make_sample_simulation(name='Run_1')
def setUp(self):
register_all_tree_node_adapters()
self.study = make_sample_study()
self.model = make_sample_simulation()
self.study.simulations.append(self.model)
editor=InstanceEditor(),
style="custom",
show_label=False),
show_border=True,
label="CADET Solver Parameters"),
VGroup(Item("discretization_view",
editor=InstanceEditor(),
style="custom",
show_label=False),
show_border=True,
label="Discretization Parameters"),
resizable=True,
buttons=OKCancelButtons,
)
def _get_solver_view(self):
return SolverView(model=self.solver)
def _get_discretization_view(self):
return DiscretizationView(model=self.discretization)
if __name__ == '__main__':
# setting up model
from kromatography.model.tests.sample_data_factories import \
make_sample_simulation
sim = make_sample_simulation()
solution_view = SimulationView(model=sim)
solution_view.configure_traits()
def setUp(self):
self.model = make_sample_simulation()
self.klass = Simulation
def _product_changed(self):
self.component_name_available = \
self._component_name_available_default()
self.component_selected = self._component_selected_default()
# Traits initialization methods -------------------------------------------
def _component_selected_default(self):
ignore = []
if self.ignore_strip_by_default:
ignore.append(STRIP_COMP_NAME)
return [
name for name in self.component_name_available
if name not in ignore
]
def _component_name_available_default(self):
if self.product is None:
return []
return self.product.product_component_names
if __name__ == "__main__":
from kromatography.model.tests.sample_data_factories import \
make_sample_simulation
prod = make_sample_simulation().product
ComponentSelector(product=prod).configure_traits()
def setUpClass(cls):
super(TestCreateRunSimulationGroup, cls).setUpClass()
cls.sim = make_sample_simulation()
cls.sim_class = Simulation
def test_simulation_with_results(self):
res_file = io_data_path("Chrom_Example_Run_1_cadet_simulation.h5")
model = make_sample_simulation(name='Run_1', result_file=res_file)
self.assertIsInstance(model, Simulation)
