def test_validate(self): try: self.simulation_config.validate() except SimulatorError: self.fail( "self.simulation_config.validate() shouldn't raise SimulatorError" ) # validate with defaults simulation_config = SimulationConfig(self.time_max) try: simulation_config.validate() except SimulatorError: self.fail( "simulation_config.validate() shouldn't raise SimulatorError") self.simulation_config.time_max = self.time_init - 1 with self.assertRaisesRegex( SimulatorError, 'time_max .* must be greater than time_init .*'): self.simulation_config.validate() self.simulation_config.time_max = 10 self.simulation_config.profile = True self.simulation_config.object_memory_change_interval = 100 with self.assertRaisesRegex( SimulatorError, 'profile and object_memory_change_interval cannot both be active' ): self.simulation_config.validate()
def test_get_sim_config(self): self.assertEqual(SimulationConfig(5.), SimulationEngine._get_sim_config(time_max=5.)) config_dict = dict(time_max=5., time_init=2.) self.assertEqual( SimulationConfig(5., 2.), SimulationEngine._get_sim_config(config_dict=config_dict)) with self.assertRaisesRegex( SimulatorError, 'time_max, sim_config, or config_dict must be provided'): SimulationEngine._get_sim_config() config_dict = dict(time_init=2.) with self.assertRaisesRegex( SimulatorError, 'at most 1 of time_max, sim_config, or config_dict'): SimulationEngine._get_sim_config(100, config_dict=config_dict) simulation_config = SimulationConfig(10) with self.assertRaisesRegex( SimulatorError, 'sim_config is not provided, sim_config= is probably needed'): SimulationEngine._get_sim_config(simulation_config) config_dict = dict(time_init=2.) with self.assertRaisesRegex( SimulatorError, 'time_max must be provided in config_dict'): SimulationEngine._get_sim_config(config_dict=config_dict)
def test_semantically_equal(self): simulation_config = SimulationConfig(self.time_max, self.time_init, self.stop_condition, self.output_dir, self.progress) self.assertTrue( self.simulation_config.semantically_equal(simulation_config)) simulation_config.progress = not simulation_config.progress # progress is not semantically meaningful self.assertTrue( self.simulation_config.semantically_equal(simulation_config)) simulation_config.time_max += 1E-12 self.assertFalse( self.simulation_config.semantically_equal(simulation_config))
def test_setattr(self): # accept ints in float fields simulation_config = SimulationConfig(int(self.time_max)) self.assertEquals(simulation_config.time_max, self.time_max) time_max = 'no' with self.assertRaisesRegex(SimulatorError, 'time_max .* must be a float'): SimulationConfig(time_max) with self.assertRaisesRegex(SimulatorError, 'time_init .* must be a float'): SimulationConfig(self.time_max, time_init=set())
def test_semantically_equal(self): # RunMetadata.semantically_equal always returns True self.assertTrue(self.run.semantically_equal(self.run_equal)) self.assertTrue(self.run_equal.semantically_equal(self.run)) self.assertTrue(self.run_equal.semantically_equal(self.run_different)) # SimulationMetadata self.assertTrue(self.metadata.semantically_equal(self.metadata_equal)) self.assertTrue(self.metadata_equal.semantically_equal(self.metadata)) # run not used by SimulationMetadata.semantically_equal self.metadata_equal.run = self.run_different self.assertTrue(self.metadata_equal.semantically_equal(self.metadata)) # simulation_config used by semantically_equal self.metadata_equal.simulation_config = SimulationConfig(time_max=99) self.assertFalse(self.metadata_equal.semantically_equal(self.metadata)) self.assertFalse(self.metadata.semantically_equal(self.metadata_equal)) self.metadata_equal.simulation_config = self.simulation_config # author used by semantically_equal self.metadata_equal.author = self.author_different self.assertFalse(self.metadata_equal.semantically_equal(self.metadata)) self.assertFalse(self.metadata.semantically_equal(self.metadata_equal)) self.metadata_equal.author = self.author # simulator_repo used by semantically_equal self.metadata_equal.simulator_repo.url = self.simulator_repo_equal.url + 'xxx' self.assertFalse(self.metadata_equal.semantically_equal(self.metadata)) self.assertFalse(self.metadata.semantically_equal(self.metadata_equal)) self.metadata_equal.simulator_repo = self.simulator_repo # still semantically_equal with attributes reset self.assertTrue(self.metadata_equal.semantically_equal(self.metadata))
def setUp(self): self.tmp_dir = tempfile.mkdtemp() self.results_dir = tempfile.mkdtemp(dir=self.tmp_dir) self.models = ['static', 'one_reaction_linear', 'one_rxn_exponential', 'one_exchange_rxn_compt_growth', 'stop_conditions'] de_simulation_config = SimulationConfig(time_max=20, output_dir=tempfile.mkdtemp(dir=self.tmp_dir)) self.wc_sim_config = WCSimulationConfig(de_simulation_config, checkpoint_period=1)
def setUp(self): self.pickle_file_dir = tempfile.mkdtemp() simulator_repo, _ = get_repo_metadata( repo_type=RepoMetadataCollectionType.SCHEMA_REPO) self.simulator_repo = simulator_repo simulator_repo_equal, _ = get_repo_metadata( repo_type=RepoMetadataCollectionType.SCHEMA_REPO) self.simulator_repo_equal = simulator_repo_equal self.simulation_config = simulation_config = SimulationConfig( time_max=100, progress=False) self.author = author = AuthorMetadata(name='Test user', email='*****@*****.**', username='******', organization='Test organization') self.author_equal = copy.copy(author) self.author_different = author_different = copy.copy(author) author_different.name = 'Joe Smith' self.run = run = RunMetadata() run.record_start() run.record_ip_address() self.run_equal = copy.copy(run) self.run_different = copy.copy(run) self.run_different.record_run_time() self.metadata = SimulationMetadata(simulation_config, run, author, simulator_repo) self.metadata_equal = SimulationMetadata(simulation_config, run, author, simulator_repo_equal) self.metadata_different = SimulationMetadata(simulation_config, run, author_different, simulator_repo)
def make_sim_w_nrm_submodel(self, model, auto_initialize): wc_lang.transform.PrepForWcSimTransform().run(model) de_simulation_config = SimulationConfig(time_max=10) wc_sim_config = WCSimulationConfig(de_simulation_config) nrm_options = dict(auto_initialize=auto_initialize) options = {'NrmSubmodel': dict(options=nrm_options)} multialgorithm_simulation = MultialgorithmSimulation(model, wc_sim_config, options) return multialgorithm_simulation.build_simulation()
def test_init(self): self.assertTrue(isinstance(self.nrm_submodel.options, dict)) # test NrmSubmodel() with default options=None wc_sim_config = WCSimulationConfig(SimulationConfig(time_max=10)) _, dynamic_model = MultialgorithmSimulation(self.model, wc_sim_config).build_simulation() nrm_submodel = dynamic_model.dynamic_submodels['nrm_submodel'] self.assertEquals(nrm_submodel.options, None)
def test(self): self.assertEquals(self.simulation_config.time_max, self.time_max) self.assertEquals(self.simulation_config.time_init, self.time_init) self.assertEquals(self.simulation_config.stop_condition, self.stop_condition) self.assertEquals(self.simulation_config.progress, self.progress) self.assertEquals(self.simulation_config.output_dir, self.output_dir) # check defaults simulation_config = SimulationConfig(self.time_max) self.assertEquals(simulation_config.time_init, 0.0) self.assertEquals(simulation_config.stop_condition, None) self.assertEquals(simulation_config.progress, False) self.assertEquals(simulation_config.output_dir, None) # check keywords simulation_config = SimulationConfig(time_max=self.time_max) self.assertEquals(simulation_config.time_max, self.time_max)
def setUp(self): self.model_file = os.path.join(os.path.dirname(__file__), 'fixtures', 'test_dynamic_expressions.xlsx') self.model = Reader().run(self.model_file)[Model][0] de_simulation_config = SimulationConfig(time_max=10) wc_sim_config = WCSimulationConfig(de_simulation_config) multialgorithm_simulation = MultialgorithmSimulation( self.model, wc_sim_config) _, self.dynamic_model = multialgorithm_simulation.build_simulation()
def setUp(self): self.tmp_dir = tempfile.mkdtemp() self.results_dir = tempfile.mkdtemp(dir=self.tmp_dir) self.args = dict(results_dir=tempfile.mkdtemp(dir=self.tmp_dir), checkpoint_period=1) de_simulation_config = SimulationConfig( time_max=10, output_dir=tempfile.mkdtemp(dir=self.tmp_dir)) self.wc_sim_config = WCSimulationConfig(de_simulation_config, checkpoint_period=1)
def setUp(self): self.tmp_dir = tempfile.mkdtemp() self.time_max = 10.0 self.time_init = 3.5 class ExampleClass(object): def f(): pass ec = ExampleClass() self.stop_condition = ec.f self.progress = True self.output_dir = self.tmp_dir self.simulation_config = SimulationConfig(self.time_max, self.time_init, self.stop_condition, self.output_dir, self.progress)
def make_dynamic_model(self, model_filename): # read and initialize a model self.model = TestDynamicModel.models[model_filename] de_simulation_config = SimulationConfig(time_max=10) wc_sim_config = WCSimulationConfig(de_simulation_config) multialgorithm_simulation = MultialgorithmSimulation( self.model, wc_sim_config) multialgorithm_simulation.initialize_components() self.dynamic_model = DynamicModel( self.model, multialgorithm_simulation.local_species_population, multialgorithm_simulation.temp_dynamic_compartments)
def setUp(self): # read and initialize a model self.model = Reader().run(self.MODEL_FILENAME, ignore_extra_models=True)[Model][0] for conc in self.model.distribution_init_concentrations: conc.std = 0. PrepForWcSimTransform().run(self.model) de_simulation_config = SimulationConfig(time_max=10) self.wc_sim_config = WCSimulationConfig(de_simulation_config, dfba_time_step=1) self.multialgorithm_simulation = MultialgorithmSimulation(self.model, self.wc_sim_config) self.test_dir = tempfile.mkdtemp() self.results_dir = tempfile.mkdtemp(dir=self.test_dir)
def setUp(self): self.tempdir = tempfile.mkdtemp() self.time_max = 5 self.de_simulation_config = SimulationConfig(time_max=self.time_max) self.wc_sim_config = WCSimulationConfig(self.de_simulation_config) self.wc_simulation_metadata = WCSimulationMetadata(self.wc_sim_config) # fixtures to test obtaining git metadata self.test_repo_name = 'test_wc_sim_metadata' self.github_repo = GitHubRepoForTests(self.test_repo_name) self.repo_dir = tempfile.mkdtemp(dir=self.tempdir) self.github_repo.make_test_repo(self.repo_dir)
def test_simulation_stop_condition(self): simulator = SimulationEngine() # 1 event/sec: simulator.add_object(PeriodicSimulationObject('name', 1)) simulator.initialize() time_max = 10 # execute to time <= time_max, with 1st event at time = 1 self.assertEqual(simulator.simulate(time_max).num_events, time_max + 1) __stop_cond_end = 3 def stop_cond_eg(time): return __stop_cond_end <= time simulator = SimulationEngine() simulator.add_object(PeriodicSimulationObject('name', 1)) simulator.initialize() sim_config = SimulationConfig(time_max) sim_config.stop_condition = stop_cond_eg # because the simulation is executing one event / sec, the number of events should equal the stop time plus 1 self.assertEqual( simulator.simulate(sim_config=sim_config).num_events, __stop_cond_end + 1)
def test_initialize_infrastructure(self): self.multialgorithm_simulation.initialize_components() self.multialgorithm_simulation.initialize_infrastructure() self.assertTrue(isinstance(self.multialgorithm_simulation.dynamic_model, DynamicModel)) de_simulation_config = SimulationConfig(time_max=10, output_dir=self.results_dir) wc_sim_config = WCSimulationConfig(de_simulation_config, dfba_time_step=1, checkpoint_period=10) multialg_sim = MultialgorithmSimulation(self.model, wc_sim_config) multialg_sim.initialize_components() multialg_sim.initialize_infrastructure() self.assertEqual(multialg_sim.checkpointing_sim_obj.checkpoint_dir, self.results_dir) self.assertTrue(multialg_sim.checkpointing_sim_obj.access_state_object is not None) self.assertTrue(isinstance(multialg_sim.checkpointing_sim_obj, MultialgorithmicCheckpointingSimObj)) self.assertTrue(isinstance(multialg_sim.dynamic_model, DynamicModel))
def test_non_zero_time_init(self): for time_init in [-3, 2]: simulator = SimulationEngine() time_max = 5 period = 1 pso = SpecialPeriodicSimulationObject('pso', period, time_init) expected_times = list( np.linspace(time_init, time_max, time_max - time_init + 1)) simulator.add_objects([pso]) simulator.initialize() simulation_config = SimulationConfig(time_max, time_init) simulator.simulate(sim_config=simulation_config) self.assertEqual(expected_times, pso.times)
def make_dynamic_submodel_params(model, lang_submodel): de_simulation_config = SimulationConfig(time_max=10) wc_sim_config = WCSimulationConfig(de_simulation_config) multialgorithm_simulation = MultialgorithmSimulation(model, wc_sim_config) multialgorithm_simulation.initialize_components() multialgorithm_simulation.dynamic_model = \ DynamicModel(multialgorithm_simulation.model, multialgorithm_simulation.local_species_population, multialgorithm_simulation.temp_dynamic_compartments) return (lang_submodel.id, multialgorithm_simulation.dynamic_model, lang_submodel.reactions, lang_submodel.get_children(kind='submodel', __type=Species), multialgorithm_simulation.get_dynamic_compartments(lang_submodel), multialgorithm_simulation.local_species_population)
def make_ode_submodel(self, model, ode_time_step=1.0, submodel_name='submodel_1'): """ Make a MultialgorithmSimulation from a wc lang model """ # assume a single submodel # todo: test concurrent OdeSubmodels, perhaps self.ode_time_step = ode_time_step de_simulation_config = SimulationConfig(time_max=10) wc_sim_config = WCSimulationConfig(de_simulation_config, ode_time_step=ode_time_step) multialgorithm_simulation = MultialgorithmSimulation( model, wc_sim_config) simulation_engine, dynamic_model = multialgorithm_simulation.build_simulation( ) simulation_engine.initialize() submodel_1 = dynamic_model.dynamic_submodels[submodel_name] return submodel_1
def test_all_fields(self): profile = True kwargs = dict(time_max=self.time_max, time_init=self.time_init, stop_condition=self.stop_condition, output_dir=self.output_dir, progress=self.progress, profile=profile) simulation_config = SimulationConfig(self.time_max, self.time_init, self.stop_condition, self.output_dir, self.progress, profile) simulation_config.validate() for attr, value in kwargs.items(): self.assertEquals(getattr(simulation_config, attr), value) simulation_config = SimulationConfig(**kwargs) simulation_config.validate() for attr, value in kwargs.items(): self.assertEquals(getattr(simulation_config, attr), value)
def _get_sim_config(time_max=None, sim_config=None, config_dict=None): """ External simulate interface Legal combinations of the three parameters: 1. Just `time_max` 2. Just `sim_config`, which will contain an entry for `time_max` 3. Just `config_dict`, which must contain an entry for `time_max` Other combinations are illegal. Args: time_max (:obj:`float`, optional): the time of the end of the simulation sim_config (:obj:`SimulationConfig`, optional): the simulation run's configuration config_dict (:obj:`dict`, optional): a dictionary with keys chosen from the field names in :obj:`SimulationConfig`; note that `config_dict` is not a `kwargs` argument Returns: :obj:`SimulationConfig`: a validated simulation configuration Raises: :obj:`SimulatorError`: if no arguments are provided, or multiple arguments are provided, or `time_max` is missing from `config_dict` """ num_args = 0 if time_max is not None: num_args += 1 if sim_config is not None: num_args += 1 if config_dict: num_args += 1 if num_args == 0: raise SimulatorError('time_max, sim_config, or config_dict must be provided') if 1 < num_args: raise SimulatorError('at most 1 of time_max, sim_config, or config_dict may be provided') # catch common error generated when sim_config= is not used by SimulationEngine.simulate(sim_config) if isinstance(time_max, SimulationConfig): raise SimulatorError(f"sim_config is not provided, sim_config= is probably needed") # initialize sim_config if it is not provided if sim_config is None: if time_max is not None: sim_config = SimulationConfig(time_max) else: # config_dict must be initialized if 'time_max' not in config_dict: raise SimulatorError('time_max must be provided in config_dict') sim_config = SimulationConfig(**config_dict) sim_config.validate() return sim_config
def make_ssa_submodel(self, model, default_center_of_mass=None): PrepForWcSimTransform().run(model) de_simulation_config = SimulationConfig(time_max=10) wc_sim_config = WCSimulationConfig(de_simulation_config) multialgorithm_simulation = MultialgorithmSimulation( model, wc_sim_config) multialgorithm_simulation.build_simulation() # todo: don't call SsaSubmodel(); return dynamic_model.dynamic_submodels['submodel name here'] will work; see test_nrm.py wc_lang_ssa_submodel = model.submodels[0] ssa_submodel = SsaSubmodel( model.id, multialgorithm_simulation.dynamic_model, list(wc_lang_ssa_submodel.reactions), wc_lang_ssa_submodel.get_children(kind='submodel', __type=Species), multialgorithm_simulation.get_dynamic_compartments( wc_lang_ssa_submodel), multialgorithm_simulation.local_species_population, default_center_of_mass=default_center_of_mass) return ssa_submodel
def test_dynamic_model(self): self.make_dynamic_model(self.MODEL_FILENAME) self.assertEqual(len(self.dynamic_model.cellular_dyn_compartments), 1) self.assertEqual(self.dynamic_model.cellular_dyn_compartments[0].id, 'c') self.assertEqual(self.dynamic_model.get_num_submodels(), 2) model = TestDynamicModel.models[self.MODEL_FILENAME] for compartment in self.model.get_compartments(): compartment.biological_type = onto['WC:extracellular_compartment'] de_simulation_config = SimulationConfig(time_max=10) wc_sim_config = WCSimulationConfig(de_simulation_config) multialgorithm_simulation = MultialgorithmSimulation( model, wc_sim_config) multialgorithm_simulation.initialize_components() with self.assertRaisesRegex( MultialgorithmError, 'must have at least 1 cellular compartment'): DynamicModel(model, multialgorithm_simulation.local_species_population, multialgorithm_simulation.temp_dynamic_compartments)
def test_build_simulation(self): de_simulation_config = SimulationConfig(time_max=10, output_dir=self.results_dir) wc_sim_config = WCSimulationConfig(de_simulation_config, dfba_time_step=1, checkpoint_period=10) multialgorithm_simulation = MultialgorithmSimulation(self.model, wc_sim_config) simulation_engine, _ = multialgorithm_simulation.build_simulation() # 3 objects: 2 submodels, and the checkpointing obj: expected_sim_objs = set(['CHECKPOINTING_SIM_OBJ', 'submodel_1', 'submodel_2']) self.assertEqual(expected_sim_objs, set(list(simulation_engine.simulation_objects))) self.assertEqual(type(multialgorithm_simulation.checkpointing_sim_obj), MultialgorithmicCheckpointingSimObj) self.assertEqual(multialgorithm_simulation.dynamic_model.get_num_submodels(), 2) # check that submodels receive options dfba_options = dict(dfba='fast but inaccurate') ssa_options = dict(ssa='accurate but slow') options = {'DfbaSubmodel': dict(options=dfba_options), 'SsaSubmodel': dict(options=ssa_options) } multialgorithm_simulation = MultialgorithmSimulation(self.model, wc_sim_config, options) multialgorithm_simulation.build_simulation() dfba_submodel = multialgorithm_simulation.dynamic_model.dynamic_submodels['submodel_1'] ssa_submodel = multialgorithm_simulation.dynamic_model.dynamic_submodels['submodel_2'] self.assertEqual(dfba_submodel.options, dfba_options) self.assertEqual(ssa_submodel.options, ssa_options) # test skipped submodel submodels_to_skip = ['submodel_2'] self.wc_sim_config.submodels_to_skip = submodels_to_skip ma_sim = MultialgorithmSimulation(self.model, self.wc_sim_config) _, dynamic_model = ma_sim.build_simulation() expected_dynamic_submodels = set([sm.id for sm in self.model.get_submodels()]) - ma_sim.skipped_submodels() self.assertEqual(expected_dynamic_submodels, set(dynamic_model.dynamic_submodels)) submodel_1 = self.model.submodels.get(id='submodel_1')[0] # WC:modeling_framework is not an instance of a modeling framework submodel_1.framework = onto['WC:modeling_framework'] ma_sim = MultialgorithmSimulation(self.model, self.wc_sim_config) with self.assertRaisesRegex(MultialgorithmError, 'Unsupported lang_submodel framework'): ma_sim.build_simulation()
def test_calc_reaction_rates(self): # set standard deviation of initial conc. to 0 self.setUp(std_init_concentrations=0.) de_simulation_config = SimulationConfig(time_max=10) wc_sim_config = WCSimulationConfig(de_simulation_config, dfba_time_step=1) multialgorithm_simulation = MultialgorithmSimulation(self.model, wc_sim_config) _, dynamic_model = multialgorithm_simulation.build_simulation() # rate law for reaction_4-forward: k_cat_4_for * max(species_4[c], p_4) k_cat_4_for = 1 p_4 = 2 species_4_c_pop = \ multialgorithm_simulation.local_species_population.read_one(0, 'species_4[c]') expected_rate_reaction_4_forward = k_cat_4_for * max(species_4_c_pop, p_4) expected_rates = { 'reaction_2': 0.0, 'reaction_4': expected_rate_reaction_4_forward } for dynamic_submodel in multialgorithm_simulation.dynamic_model.dynamic_submodels.values(): rates = dynamic_submodel.calc_reaction_rates() for index, rxn in enumerate(dynamic_submodel.reactions): if rxn.id in expected_rates: self.assertAlmostEqual(list(rates)[index], expected_rates[rxn.id])
class TestPickleSimulationConfig(unittest.TestCase): def setUp(self): self.tmp_dir = tempfile.mkdtemp() def tearDown(self): shutil.rmtree(self.tmp_dir) simulation_config = SimulationConfig(10.0, 3.5, stop_condition=ec.f, output_dir=tempfile.mkdtemp(), progress=True) def test_prepare_to_pickle(self): self.simulation_config.validate() file = os.path.join(self.tmp_dir, 'test2.pickle') prepared_to_pickle = self.simulation_config.prepare_to_pickle() with open(file, 'wb') as fd: pickle.dump(prepared_to_pickle, fd) with open(file, 'rb') as fd: simulation_config = pickle.load(fd) self.assertEquals(prepared_to_pickle, simulation_config) shutil.rmtree(self.simulation_config.output_dir)
def read(file_name): """ Imports simulation configuration from SED-ML file Args: file_name (:obj:`str`): path to SED-ML file from which to import simulation configuration Returns: :obj:`WCSimulationConfig`: simulation configuration """ # initialize optional configuration opt_config = {} """ read SED-ML """ # read XML file cfg_ml = libsedml.readSedML(file_name) """ validate SED-ML """ # one model with # - zero or more attribute changes if cfg_ml.getNumModels() != 1: raise SedMlError('SED-ML configuration must have one model') mdl = cfg_ml.getModel(0) if mdl.getId() or mdl.getName() or mdl.getLanguage() or mdl.getSource( ): warnings.warn( 'SED-ML import ignoring all model metadata (id, name, language, source)', SedMlWarning) for change_ml in mdl.getListOfChanges(): if not isinstance(change_ml, libsedml.SedChangeAttribute): raise SedMlError( 'Cannot import model changes except attribute changes') # 1 simulation with #- Initial time = 0 #- Output start time = 0 #- Algorithm = KISAO_0000352 (hybrid) #- 1 algorithm parameters # - random_seed (KISAO_0000488): int if cfg_ml.getNumSimulations() != 1: raise SedMlError('SED-ML configuration must have 1 simulation') sim_ml = cfg_ml.getSimulation(0) if sim_ml.getInitialTime() != sim_ml.getOutputStartTime(): raise SedMlError( 'Simulation initial time and output start time must be equal') alg_ml = sim_ml.getAlgorithm() if alg_ml.getKisaoID() != 'KISAO_0000352': raise SedMlError( 'Unsupported algorithm. The only supported algorithm is KISAO_0000352 (hybrid)' ) param_kisao_ids = set( param_ml.getKisaoID() for param_ml in alg_ml.getListOfAlgorithmParameters()) if len(param_kisao_ids) < alg_ml.getNumAlgorithmParameters(): raise SedMlError('Algorithm parameter KISAO ids must be unique') unsupported_param_kisao_ids = param_kisao_ids - set(['KISAO_0000488']) if unsupported_param_kisao_ids: raise SedMlError( 'Algorithm parameters ({}) are not supported'.format( ', '.join(unsupported_param_kisao_ids))) # zero or more repeated tasks each with # - 1 set value task change # - math equal to constant floating point value # - 1 uniform or vector range of 1 value # - no subtasks for task_ml in cfg_ml.getListOfTasks(): if isinstance(task_ml, libsedml.SedRepeatedTask): if task_ml.getNumTaskChanges() != 1: raise SedMlError( 'Each repeated task must have one task change') change_ml = task_ml.getTaskChange(0) try: float(libsedml.formulaToString(change_ml.getMath())) except ValueError: raise SedMlError( 'Set value maths must be floating point values') if task_ml.getNumRanges() != 1: raise SedMlError('Each repeated task must have one range') range_ml = task_ml.getRange(0) if not isinstance( range_ml, (libsedml.SedUniformRange, libsedml.SedVectorRange)): raise SedMlError( 'Task ranges must be uniform or vector ranges') if isinstance(range_ml, libsedml.SedUniformRange ) and range_ml.getNumberOfPoints() != 2**31 - 1: raise SedMlError('Cannot import number of points') if isinstance(range_ml, libsedml.SedUniformRange ) and range_ml.getType() != 'linear': raise SedMlError('Only linear ranges are supported') if isinstance(range_ml, libsedml.SedVectorRange) and len( list(range_ml.getValues())) != 1: raise SedMlError('Task vector ranges must have length 1') if task_ml.getNumSubTasks() > 0: raise SedMlError('Cannot import subtasks') else: raise SedMlError('Cannot import tasks except repeated tasks') # no data generators if cfg_ml.getNumDataGenerators() > 0: raise SedMlError('Cannot import data generator information') # no data descriptions if cfg_ml.getNumDataDescriptions() > 0: raise SedMlError('Cannot import data description information') # no outputs if cfg_ml.getNumOutputs() > 0: raise SedMlError('Cannot import output information') """ Read simulation configuration information from SED-ML document """ # changes changes = [] mdl = cfg_ml.getModel(0) for change_ml in mdl.getListOfChanges(): target = change_ml.getTarget() change = Change() change.attr_path = Change.attr_path_from_str(change_ml.getTarget()) change.value = float(change_ml.getNewValue()) changes.append(change) # perturbations perturbations = [] for task_ml in cfg_ml.getListOfTasks(): change_ml = task_ml.getTaskChange(0) change = Change() change.attr_path = Change.attr_path_from_str(change_ml.getTarget()) change.value = float(libsedml.formulaToString(change_ml.getMath())) range_ml = task_ml.getRange(0) if isinstance(range_ml, libsedml.SedUniformRange): start_time = range_ml.getStart() end_time = range_ml.getEnd() else: start_time = range_ml.getValues()[0] end_time = float('nan') perturbations.append(Perturbation(change, start_time, end_time)) # time sim = cfg_ml.getSimulation(0) time_init = sim.getOutputStartTime() time_max = sim.getOutputEndTime() ode_time_step = (time_max - time_init) / sim.getNumberOfPoints() # algorithm parameters alg = sim.getAlgorithm() for param in alg.getListOfAlgorithmParameters(): if param.getKisaoID() == 'KISAO_0000488': try: opt_config['random_seed'] = float(param.getValue()) except ValueError: raise SedMlError('random_seed must be an integer') if opt_config['random_seed'] != math.ceil( opt_config['random_seed']): raise SedMlError('random_seed must be an integer') opt_config['random_seed'] = int(opt_config['random_seed']) """ build simulation configuration object """ de_simulation_config = SimulationConfig(time_max=time_max, time_init=time_init) cfg = WCSimulationConfig(de_simulation_config=de_simulation_config, ode_time_step=ode_time_step, changes=changes, perturbations=perturbations, **opt_config) return cfg
def setUp(self): self.results_dir = tempfile.mkdtemp() de_simulation_config = SimulationConfig(time_max=10, output_dir=self.results_dir) self.wc_sim_config = WCSimulationConfig(de_simulation_config, dfba_time_step=1, checkpoint_period=10) self.out_dir = tempfile.mkdtemp()