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 to_simulation(self): """ Returns a new Simulation object from current builder. """ from kromatography.model.factories.method import \ build_sim_method_from_method sim_method = build_sim_method_from_method( self.method, self.first_simulated_step_name, self.last_simulated_step_name, initial_buffer=self.initial_buffer, ) simulation = Simulation( name=self.simulation_name, column=self.column, method=sim_method, first_simulated_step=self.first_simulated_step_name, last_simulated_step=self.last_simulated_step_name, transport_model=self.transport_model, binding_model=self.binding_model, solver=Solver(), discretization=Discretization(), sensitivity=Sensitivity(), ) # Product is a property of a simulation, which isn't set until we set # the method. if not is_has_traits_almost_equal(simulation.product, self.product): msg = ("The simulation's product (read in the method) doesn't " "match the selected product. Please review the product and" " method selected.") logger.info(msg) warning(None, msg, "Review simulation data") return simulation
def to_simulation(self): """ Export the current simulation to a regular simulation with its results data in memory. """ new_sim = Simulation(name=self.name) new_sim.copy_traits(self) new_sim.uuid = uuid4() if self.has_run: new_sim.output = self.output new_sim.set_as_run() return new_sim
def get_instance(self, constructor_data): from kromatography.model.simulation import Simulation kwargs = constructor_data['kwargs'] kwargs.pop("step_indices") instance = Simulation(**kwargs) # Back then, methods didn't store an initial buffer. Try to retrieve it if instance.method.initial_buffer is None: try: method = self.rebuild_method(instance) except Exception as e: msg = "Deserialized an old version of a Simulation and failed"\ " to rebuild the method: error was {}".format(e) logger.debug(msg) method = None if method: instance.method = method return instance
def setUp(self): # Manual construction column_type = ColumnType(**COLUMN_TYPE_DATA.copy()) resin = Resin(**RESIN_DATA.copy()) column = Column(column_type=column_type, resin=resin, **COLUMN_DATA.copy()) method = Method(**deepcopy(METHOD_DATA)) self.sim_from_scratch = Simulation(name='Sim1', column=column, method=method, output=None) self.expected_sec_times = array([0., 540., 1080., 1620., 7668.])
def to_simulations(self): """ Returns a list of simulations built from each experiment selected. """ fstep, lstep = (self.first_simulated_step_name, self.last_simulated_step_name) new_simulations = [] for exp_name, sim_name in zip(self.experiment_selected, self.simulation_names): experiment = self.target_study.search_experiment_by_name(exp_name) try: sim_method = build_sim_method_from_method( experiment.method, fstep, lstep, initial_buffer=self.initial_buffer, ) except StepLookupError as e: msg = "Failed to find the start/stop method steps for " \ "simulation {}. Its experiment doesn't seem to contain" \ " {} or {}. Please review these step names or treat " \ "this simulation separately from the others. Aborting..." msg = msg.format(sim_name, fstep, lstep) details = " Details: error was {}".format(e) logger.error(msg + details) warning(None, msg) return [] simulation = Simulation( name=sim_name, column=experiment.column.clone_traits(copy="deep"), method=sim_method, first_simulated_step=self.first_simulated_step_name, last_simulated_step=self.last_simulated_step_name, transport_model=self.transport_model, binding_model=self.binding_model, source_experiment=experiment, solver=Solver(), discretization=Discretization(), sensitivity=Sensitivity(), ) new_simulations.append(simulation) return new_simulations
def test_add_sim(self): from kromatography.model.simulation import Simulation sim = Simulation(name="foo") self.study.simulations.append(sim) self.assertFalse(self.study.is_blank)
def test_load_wrong_obj_type(self): obj = Simulation(name="dslkjf") save_object(self.filepath_temp, obj) task, legacy = load_project(self.filepath_temp) self.assertFalse(legacy) assert_has_traits_almost_equal(task, obj)
import logging from traits.api import Any, Callable, HasStrictTraits, Property, Str from app_common.pyface.monitored_actions import action_monitoring from kromatography.model.simulation import Simulation from kromatography.ui.gui_model_factory import DATASOURCE_OBJECT_FACTORIES, \ STUDY_DATASOURCE_OBJECT_FACTORIES from kromatography.model.chromatography_data import ChromatographyData BLANK_SIMULATION = Simulation(name="New simulation") logger = logging.getLogger(__name__) class BaseEntryCreator(HasStrictTraits): """ Generic object to request, create and add a new datasource entry to the datasource object_catalog dict. This might require to have access to the study to pull data like the chosen product or the user datasource. It might also request to select a product if not already set. """ #: Datsource being contributed to datasource = Any #: Type of object being contributed datasource_key = Str #: List of objects being contributed to data = Property
class TestSimulationCopy(TestCase, UnittestTools): @classmethod def setUpClass(cls): cls.real_study = make_sample_study2(add_transp_bind_models=True) cls.real_exp = cls.real_study.search_experiment_by_name('Run_1') cls.real_sim = build_simulation_from_experiment(cls.real_exp) cls.job_manager = create_start_job_manager(max_workers=1) @classmethod def tearDownClass(cls): cls.job_manager.shutdown() 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_copy_sim_from_scratch_not_run(self): new_sim1 = self.sim_from_scratch.copy() self.assertValidCopy(new_sim1, self.sim_from_scratch) def test_copy_sim_with_bind_transp_not_run(self): # Using utility will contain a binding and transport model new_sim2 = self.sim_from_std_exp.copy() self.assertValidCopy(new_sim2, self.sim_from_std_exp) def test_copy_complete_sim_not_run(self): # Build a simulation from an experiment and add a fake output sim3 = self.real_sim sim3.output = SimulationResults(name='fake output') sim3.editable = False new_sim3 = sim3.copy() self.assertValidCopy(new_sim3, sim3) def test_copy_sim_run(self): self.real_sim.run(self.job_manager, wait=True) self.assertIsNotNone(self.real_sim.output) self.assertTrue(self.real_sim.has_run) sim = self.real_sim.copy() self.assertIsNone(sim.output) self.assertFalse(sim.has_run) self.assertTrue(sim.editable) self.assertFalse(isfile(sim.cadet_filepath)) # Utilities --------------------------------------------------------------- def assertValidCopy(self, new_sim, orig_sim): """ Test that a copy leads to identical attributes except run related. """ self.assertIsInstance(new_sim, orig_sim.__class__) # copies have no output self.assertIsNone(new_sim.output) # Copies use the same buffer in every step self.assertTrue(new_sim.editable) # All uses of buffers are the same object buffers = {} for step in new_sim.method.method_steps: for solution in step.solutions: if isinstance(solution, Buffer): if solution.name in buffers: self.assertIs(solution, buffers[solution.name]) else: buffers[solution.name] = solution # All subobjects are equal except the outputs, the editable flag # and the events attributes. skip_attr = { "output", "editable", "has_run", "uuid", "cadet_filename", "cadet_filepath" } relevant_attrs = set(new_sim.trait_names()) - skip_attr for attr in relevant_attrs: if is_trait_event(orig_sim, attr): continue val1, val2 = getattr(new_sim, attr), getattr(orig_sim, attr) if isinstance(val1, HasTraits): assert_has_traits_almost_equal(val1, val2) else: assert_values_almost_equal(val1, val2) # The uuid and cadet input files on the other hand is guaranteed to be # different self.assertNotEqual(orig_sim.uuid, new_sim.uuid) self.assertNotEqual(orig_sim.cadet_filename, new_sim.cadet_filename) self.assertNotEqual(orig_sim.cadet_filepath, new_sim.cadet_filepath)