class TestSkeletonSubmodel(unittest.TestCase):
def setUp(self):
warnings.simplefilter("ignore")
self.MODEL_FILENAME = os.path.join(os.path.dirname(__file__), 'fixtures',
'test_submodel_no_shared_species.xlsx')
self.model = Reader().run(self.MODEL_FILENAME)[Model][0]
prepare_model(self.model)
def make_sim_w_skeleton_submodel(self, lang_submodel, behavior):
self.simulator = SimulationEngine()
# concatenate tuples in fn call for Py 2.7: see https://stackoverflow.com/a/12830036
skeleton_submodel = SkeletonSubmodel(
*(make_dynamic_submodel_params(self.model, lang_submodel) + (behavior,)))
self.simulator.add_object(skeleton_submodel)
self.simulator.initialize()
return skeleton_submodel
def test_skeleton_submodel(self):
behavior = {SkeletonSubmodel.INTER_REACTION_TIME: 2}
lang_submodel = self.model.get_submodels()[0]
for conc in self.model.distribution_init_concentrations:
conc.std = 0
time_max = 100
skeleton_submodel = self.make_sim_w_skeleton_submodel(lang_submodel, behavior)
self.assertEqual(self.simulator.simulate(time_max),
time_max / behavior[SkeletonSubmodel.INTER_REACTION_TIME])
behavior = {SkeletonSubmodel.INTER_REACTION_TIME: 2,
SkeletonSubmodel.REACTION_TO_EXECUTE: 0} # reaction #0 makes one more 'species_1[c]'
skeleton_submodel = self.make_sim_w_skeleton_submodel(lang_submodel, behavior)
interval = 10
pop_before = skeleton_submodel.local_species_population.read_one(0, 'species_1[c]')
for time_max in range(interval, 5 * interval, interval):
self.simulator.simulate(time_max)
pop_after = skeleton_submodel.local_species_population.read_one(time_max, 'species_1[c]')
delta = pop_after - pop_before
self.assertEqual(delta, interval / behavior[SkeletonSubmodel.INTER_REACTION_TIME])
pop_before = pop_after
class TestMultialgorithmSimulationStatically(unittest.TestCase):
MODEL_FILENAME = os.path.join(os.path.dirname(__file__), 'fixtures', 'test_model.xlsx')
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 tearDown(self):
shutil.rmtree(self.test_dir)
def test_init(self):
self.model.submodels = []
with self.assertRaises(MultialgorithmError):
MultialgorithmSimulation(self.model, self.wc_sim_config)
def test_prepare_skipped_submodels(self):
multialgorithm_simulation = MultialgorithmSimulation(self.model, self.wc_sim_config)
self.assertEqual(multialgorithm_simulation.skipped_submodels(), set())
submodels_to_skip = ['submodel_1']
self.wc_sim_config.submodels_to_skip = submodels_to_skip
multialgorithm_simulation = MultialgorithmSimulation(self.model, self.wc_sim_config)
self.assertEqual(multialgorithm_simulation.skipped_submodels(), set(submodels_to_skip))
submodels_to_skip = ['no_such_submodel']
self.wc_sim_config.submodels_to_skip = submodels_to_skip
with self.assertRaisesRegex(MultialgorithmError,
"'submodels_to_skip' contains submodels that aren't in the model:"):
MultialgorithmSimulation(self.model, self.wc_sim_config)
def test_molecular_weights_for_species(self):
multi_alg_sim = self.multialgorithm_simulation
expected = {
'species_6[c]': float('nan'),
'H2O[c]': 18.0152
}
actual = multi_alg_sim.molecular_weights_for_species(set(expected.keys()))
self.assertEqual(actual['H2O[c]'], expected['H2O[c]'])
self.assertTrue(np.isnan(actual['species_6[c]']))
# add a species_type without a structure
species_type_wo_structure = self.model.species_types.create(
id='st_wo_structure',
name='st_wo_structure')
cellular_compartment = self.model.compartments.get(**{'id': 'c'})[0]
species_wo_structure = self.model.species.create(
species_type=species_type_wo_structure,
compartment=cellular_compartment)
species_wo_structure.id = species_wo_structure.gen_id()
actual = multi_alg_sim.molecular_weights_for_species([species_wo_structure.id])
self.assertTrue(np.isnan(actual[species_wo_structure.id]))
# test obtain weights for all species
actual = multi_alg_sim.molecular_weights_for_species()
self.assertEqual(actual['H2O[c]'], expected['H2O[c]'])
self.assertTrue(np.isnan(actual['species_6[c]']))
self.assertEqual(len(actual), len(self.model.get_species()))
def test_create_dynamic_compartments(self):
self.multialgorithm_simulation.create_dynamic_compartments()
self.assertEqual(set(['c', 'e']), set(self.multialgorithm_simulation.temp_dynamic_compartments))
for id, dynamic_compartment in self.multialgorithm_simulation.temp_dynamic_compartments.items():
self.assertEqual(id, dynamic_compartment.id)
self.assertTrue(0 < dynamic_compartment.init_density)
def test_prepare_dynamic_compartments(self):
self.multialgorithm_simulation.create_dynamic_compartments()
self.multialgorithm_simulation.init_species_pop_from_distribution()
self.multialgorithm_simulation.local_species_population = \
self.multialgorithm_simulation.make_local_species_population(retain_history=False)
self.multialgorithm_simulation.prepare_dynamic_compartments()
for dynamic_compartment in self.multialgorithm_simulation.temp_dynamic_compartments.values():
self.assertTrue(dynamic_compartment._initialized())
self.assertTrue(0 < dynamic_compartment.accounted_mass())
self.assertTrue(0 < dynamic_compartment.mass())
def test_init_species_pop_from_distribution(self):
self.multialgorithm_simulation.create_dynamic_compartments()
self.multialgorithm_simulation.init_species_pop_from_distribution()
species_wo_init_conc = ['species_1[c]', 'species_3[c]']
for species_id in species_wo_init_conc:
self.assertEqual(self.multialgorithm_simulation.init_populations[species_id], 0)
for concentration in self.model.get_distribution_init_concentrations():
self.assertTrue(0 <= self.multialgorithm_simulation.init_populations[concentration.species.id])
# todo: statistically evaluate sampled population
# ensure that over multiple runs of init_species_pop_from_distribution():
# mean(species population) ~= mean(volume) * mean(concentration)
def test_make_local_species_population(self):
self.multialgorithm_simulation.create_dynamic_compartments()
self.multialgorithm_simulation.init_species_pop_from_distribution()
local_species_population = self.multialgorithm_simulation.make_local_species_population()
self.assertEqual(local_species_population._molecular_weights,
self.multialgorithm_simulation.molecular_weights_for_species())
# test the initial population slopes
# continuous adjustments are only allowed on species used by continuous submodels
used_by_continuous_submodels = \
['species_1[e]', 'species_2[e]', 'species_1[c]', 'species_2[c]', 'species_3[c]']
adjustments = {species_id: 0. for species_id in used_by_continuous_submodels}
self.assertEqual(local_species_population.adjust_continuously(1, adjustments), None)
not_in_a_reaction = ['H2O[e]', 'H2O[c]']
used_by_discrete_submodels = ['species_4[c]', 'species_5[c]', 'species_6[c]']
adjustments = {species_id: 0. for species_id in used_by_discrete_submodels + not_in_a_reaction}
with self.assertRaises(DynamicSpeciesPopulationError):
local_species_population.adjust_continuously(2, adjustments)
def test_set_simultaneous_execution_priorities(self):
expected_order_of_sim_obj_classes = [SsaSubmodel,
NrmSubmodel,
DsaSubmodel,
DfbaSubmodel,
OdeSubmodel,
MultialgorithmicCheckpointingSimObj]
self.multialgorithm_simulation.set_simultaneous_execution_priorities()
# ensure that expected_order_of_sim_obj_classes are arranged in decreasing priority
for i in range(len(expected_order_of_sim_obj_classes) - 1):
simulation_object_class = expected_order_of_sim_obj_classes[i]
next_simulation_object_class = expected_order_of_sim_obj_classes[i+1]
self.assertLess(simulation_object_class.metadata.class_priority,
next_simulation_object_class.metadata.class_priority)
def test_initialize_components(self):
self.multialgorithm_simulation.initialize_components()
self.assertTrue(isinstance(self.multialgorithm_simulation.local_species_population,
LocalSpeciesPopulation))
for dynamic_compartment in self.multialgorithm_simulation.temp_dynamic_compartments.values():
self.assertTrue(isinstance(dynamic_compartment.species_population, LocalSpeciesPopulation))
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_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_get_dynamic_compartments(self):
expected_compartments = dict(
submodel_1=['c', 'e'],
submodel_2=['c']
)
self.multialgorithm_simulation.build_simulation()
for submodel_id in ['submodel_1', 'submodel_2']:
submodel = self.model.submodels.get_one(id=submodel_id)
submodel_dynamic_compartments = self.multialgorithm_simulation.get_dynamic_compartments(submodel)
self.assertEqual(set(submodel_dynamic_compartments.keys()), set(expected_compartments[submodel_id]))
def test_str(self):
self.multialgorithm_simulation.create_dynamic_compartments()
self.multialgorithm_simulation.init_species_pop_from_distribution()
self.multialgorithm_simulation.local_species_population = \
self.multialgorithm_simulation.make_local_species_population(retain_history=False)
self.assertIn('species_1[e]', str(self.multialgorithm_simulation))
self.assertIn('model:', str(self.multialgorithm_simulation))
class TestDynamicSubmodelStatically(unittest.TestCase):
def setUp(self, std_init_concentrations=None):
self.MODEL_FILENAME = os.path.join(os.path.dirname(__file__), 'fixtures',
'test_submodel_no_shared_species.xlsx')
self.model = Reader().run(self.MODEL_FILENAME)[Model][0]
prepare_model(self.model)
if std_init_concentrations is not None:
for conc in self.model.distribution_init_concentrations:
conc.std = std_init_concentrations
self.misconfigured_dynamic_submodels = {}
self.dynamic_submodels = {}
for lang_submodel in self.model.get_submodels():
self.dynamic_submodels[lang_submodel.id] = DynamicSubmodel(
*make_dynamic_submodel_params(self.model, lang_submodel))
# create dynamic submodels that lack a dynamic compartment
id, dynamic_model, reactions, species, dynamic_compartments, local_species_pop = \
make_dynamic_submodel_params(self.model, lang_submodel)
dynamic_compartments.popitem()
self.misconfigured_dynamic_submodels[lang_submodel.id] = DynamicSubmodel(
id, None, reactions, species, dynamic_compartments, local_species_pop)
def test_get_state(self):
for dynamic_submodel in self.dynamic_submodels.values():
self.assertEqual(dynamic_submodel.get_state(), DynamicSubmodel.GET_STATE_METHOD_MESSAGE)
def test_get_num_submodels(self):
for dynamic_submodel in self.dynamic_submodels.values():
self.assertEqual(dynamic_submodel.get_num_submodels(), 2)
def expected_molar_conc(self, dynamic_submodel, species_id):
species = list(filter(lambda s: s.id == species_id, dynamic_submodel.species))[0]
init_volume = species.compartment.init_volume.mean
copy_num = ModelUtilities.sample_copy_num_from_concentration(species, init_volume, RandomStateManager.instance())
volume = dynamic_submodel.dynamic_compartments[species.compartment.id].volume()
return copy_num / (volume * Avogadro)
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])
expected_enabled = {
'submodel_1': set([
'reaction_1',
'reaction_2',
'__dfba_ex_submodel_1_species_1_e',
'__dfba_ex_submodel_1_species_2_e',
]),
'submodel_2': set([
'reaction_4',
'reaction_3_forward',
'reaction_3_backward',
]),
}
def test_enabled_reaction(self):
for dynamic_submodel in self.dynamic_submodels.values():
enabled = set()
for rxn in dynamic_submodel.reactions:
if dynamic_submodel.enabled_reaction(rxn):
enabled.add(rxn.id)
self.assertEqual(TestDynamicSubmodelStatically.expected_enabled[dynamic_submodel.id], enabled)
def test_identify_enabled_reactions(self):
for dynamic_submodel in self.dynamic_submodels.values():
expected_set = TestDynamicSubmodelStatically.expected_enabled[dynamic_submodel.id]
expected_array =\
numpy.asarray([r.id in expected_set for r in dynamic_submodel.reactions]).astype(int)
enabled = dynamic_submodel.identify_enabled_reactions()
self.assertTrue(numpy.array_equal(enabled, expected_array))
def test_execute_disabled_reactions(self):
# test exception by executing reactions that aren't enabled
enabled_rxn_ids = []
for set_rxn_ids in TestDynamicSubmodelStatically.expected_enabled.values():
enabled_rxn_ids.extend(list(set_rxn_ids))
enabled_reactions = [get_component_by_id(self.model.get_reactions(), rxn_id)
for rxn_id in enabled_rxn_ids]
for dynamic_submodel in self.dynamic_submodels.values():
for reaction in dynamic_submodel.reactions:
if reaction not in enabled_reactions:
with self.assertRaisesRegex(DynamicMultialgorithmError,
"dynamic submodel .* cannot execute reaction"):
dynamic_submodel.execute_reaction(reaction)
def do_test_execute_reaction(self, reaction_id, expected_adjustments):
rxn = self.model.get_reactions(id=reaction_id)[0]
dynamic_submodel = self.dynamic_submodels[rxn.submodel.id]
before = dynamic_submodel.get_species_counts()
dynamic_submodel.execute_reaction(rxn)
after = dynamic_submodel.get_species_counts()
for species_id, change in expected_adjustments.items():
self.assertEqual(change, after[species_id] - before[species_id])
def test_execute_reaction(self):
# test reactions 'by hand'
# reversible reactions have been split in two
self.do_test_execute_reaction('reaction_3_forward',
{'species_2[c]': -1, 'species_4[c]': -2, 'species_5[c]': 1})
# test reaction in which a species appears multiple times
self.do_test_execute_reaction('reaction_2', {'species_1[c]': 1, 'species_3[c]': 1})
from wc_lang.io import Reader
import wc_lang.sbml.io as sbml_io
from obj_model import utils
from wc_lang.prepare import PrepareModel
args = Namespace(end_time=1,
time_step=1,
test_submodel_id='Metabolism',
wc_lang_model="example-model.xlsx")
MODEL_FILENAME = path.join(path.dirname(__file__), '../../..', 'wc_lang/tests/fixtures',
args.wc_lang_model)
print('using:', MODEL_FILENAME)
model = Reader().run(MODEL_FILENAME)
PrepareModel(model).run()
submodel = utils.get_component_by_id(model.get_submodels(), args.test_submodel_id)
_, SBMLfile = tempfile.mkstemp()
def try_cobrapy(args):
time = 0
while time < args.end_time:
print('time:', time)
sbml_document = sbml_io.SBMLExchange.write_submodel(submodel)
if not writeSBMLToFile(sbml_document, SBMLfile):
raise ValueError("SBML document for submodel '{}' could not be written to '{}'.".format(
args.test_submodel_id, SBMLfile))
# cobra_model = cobra.io.read_sbml_model(SBMLfile)
cobra_model = cobra.io.sbml3.read_sbml_model(SBMLfile)
print('cobra_model', cobra_model)
print('cobra_model', cobra_model._repr_html_())
solution = cobra_model.optimize()
