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()