def test_species_concentration_units(self):
model = Model()
st_1 = model.species_types.create(id='st_1')
st_2 = model.species_types.create(id='st_2')
c_1 = model.compartments.create(id='c_1')
c_2 = model.compartments.create(id='c_2')
st_1_c_1 = model.species.create(species_type=st_1, compartment=c_1)
st_1_c_2 = model.species.create(species_type=st_1, compartment=c_2)
st_2_c_1 = model.species.create(species_type=st_2, compartment=c_1)
st_2_c_2 = model.species.create(species_type=st_2, compartment=c_2)
st_1_c_1.id = st_1_c_1.gen_id()
st_1_c_2.id = st_1_c_2.gen_id()
st_2_c_1.id = st_2_c_1.gen_id()
st_2_c_2.id = st_2_c_2.gen_id()
st_1_c_1.distribution_init_concentration = DistributionInitConcentration(units=unit_registry.parse_units('gram'))
st_1_c_2.distribution_init_concentration = DistributionInitConcentration(units=unit_registry.parse_units('hour'))
st_2_c_1.distribution_init_concentration = DistributionInitConcentration(units=unit_registry.parse_units('liter'))
st_2_c_2.distribution_init_concentration = DistributionInitConcentration(units=unit_registry.parse_units('second'))
st_1_c_1.distribution_init_concentration.id = st_1_c_1.distribution_init_concentration.gen_id()
st_1_c_2.distribution_init_concentration.id = st_1_c_2.distribution_init_concentration.gen_id()
st_2_c_1.distribution_init_concentration.id = st_2_c_1.distribution_init_concentration.gen_id()
st_2_c_2.distribution_init_concentration.id = st_2_c_2.distribution_init_concentration.gen_id()
ChangeValueTransform((('species', {'id': 'st_1[c_1]'}),
'distribution_init_concentration',
'units'), unit_registry.parse_units('meter')).run(model)
self.assertEqual(st_1_c_1.distribution_init_concentration.units, unit_registry.parse_units('meter'))
self.assertEqual(st_1_c_2.distribution_init_concentration.units, unit_registry.parse_units('hour'))
self.assertEqual(st_2_c_1.distribution_init_concentration.units, unit_registry.parse_units('liter'))
self.assertEqual(st_2_c_2.distribution_init_concentration.units, unit_registry.parse_units('second'))
def gen_distribution_init_concentrations(self):
""" Generate concentrations in model from knowledge base """
kb = self.knowledge_base
model = self.model
cytosol = model.compartments.get_one(id='c')
Avogadro = model.parameters.get_one(id='Avogadro')
for conc in kb.cell.concentrations:
species_comp_model = model.compartments.get_one(
id=conc.species.compartment.id)
species_type = model.species_types.get_or_create(
id=conc.species.species_type.id)
species = model.species.get_or_create(
species_type=species_type, compartment=species_comp_model)
species.id = species.gen_id()
if conc.units == unit_registry.parse_units('molecule'):
mean_concentration = conc.value
elif conc.units == unit_registry.parse_units('M'):
mean_concentration = conc.value * Avogadro.value * species_comp_model.init_volume.mean
else:
raise Exception('Unsupported units: {}'.format(
conc.units.name))
conc = model.distribution_init_concentrations.create(
species=species,
mean=mean_concentration,
units=unit_registry.parse_units('molecule'),
comments=conc.comments)
conc.id = conc.gen_id()
def test_SbmlExporter_error(self):
model = Model(id='model')
model.submodels.create(
id='Metabolism',
framework=onto['WC:dynamic_flux_balance_analysis'])
model.submodels.create(
id='Metabolism_2',
framework=onto['WC:dynamic_flux_balance_analysis'])
with self.assertRaisesRegex(ValueError,
'Only 1 submodel can be encoded'):
sbml_io.SbmlExporter.run(model)
model = Model(id='model')
submodel = model.submodels.create(
id='Metabolism',
framework=onto['WC:dynamic_flux_balance_analysis'])
model.reactions.create(
id='rxn_1',
submodel=submodel,
flux_bounds=FluxBounds(units=unit_registry.parse_units('M s^-1')))
model.reactions.create(
id='rxn_1',
submodel=submodel,
flux_bounds=FluxBounds(units=unit_registry.parse_units('M s^-1')))
with self.assertRaisesRegex(sbml_util.LibSbmlError,
'Document is invalid'):
with self.assertWarnsRegex(WcLangWarning, 'Model is invalid'):
sbml_io.SbmlExporter.run(model)
def gen_parameters(self):
""" Generate parameters for the model from knowledge base """
kb = self.knowledge_base
model = self.model
Avogadro = model.parameters.create(id='Avogadro',
type = None,
value = scipy.constants.Avogadro,
units = unit_registry.parse_units('molecule mol^-1'))
# Create parameters from kb
for param in kb.cell.parameters:
model_param = model.parameters.create(
id=param.id,
name=param.name,
value=param.value,
units=param.units)
if 'K_m' in param.id:
model_param.type = wc_ontology['WC:K_m']
elif 'k_cat' in param.id:
model_param.type = wc_ontology['WC:k_cat']
model_param.units = unit_registry.parse_units('molecule^-1 s^-1')
else:
model_param.type = None
if param.references:
for ref in param.references:
ref_model = model.references.get_or_create(
__type=wc_lang.Reference,
author=ref.authors,
title=ref.title,
publication=ref.journal,
volume=ref.volume,
issue=ref.issue,
pages=ref.pages,
year=ref.year,
comments=ref.comments,
type=wc_ontology['WC:article'])
if not ref_model.id:
ref_model.id = 'ref_'+str(len(model.references))
model_param.references.append(ref_model)
if param.identifiers:
for identifier in param.identifiers:
identifier_model = wc_lang.Identifier(
namespace=identifier.namespace, id=identifier.id)
model_param.identifiers.append(identifier_model)
# Standardize the units of doubling time
if model.parameters.get_one(id='mean_doubling_time'):
model_doubling_time = model.parameters.get_one(id='mean_doubling_time')
else:
raise ValueError('The cell object does not have the parameter mean_doubling_time')
expr = unit_registry.parse_expression(str(model_doubling_time.units))
scale = expr.to(unit_registry.parse_units('second'))
conversion_factor = scale.magnitude
model_doubling_time.value *= conversion_factor
model_doubling_time.units = unit_registry.parse_units('s')
def test_parameter_units(self):
model = Model()
p_1 = model.parameters.create(id='p_1', units=unit_registry.parse_units('M'))
p_2 = model.parameters.create(id='p_2', units=unit_registry.parse_units('l'))
ChangeValueTransform((('parameters', {'id': 'p_1'}), 'units'), unit_registry.parse_units('m^2')).run(model)
self.assertEqual(p_1.units, unit_registry.parse_units('m^2'))
self.assertEqual(p_2.units, unit_registry.parse_units('l'))
def setUp(self):
self.model = model = Model(id='test', version='0.1')
c = model.compartments.create(id='comp')
c.init_density = model.parameters.create(id='density_compartment_1', value=1100,
units=unit_registry.parse_units('g l^-1'))
t0 = model.species_types.create(id='s0', type=onto['WC:metabolite'])
t1 = model.species_types.create(id='s1', type=onto['WC:metabolite'])
t2 = model.species_types.create(id='s2', type=onto['WC:metabolite'])
s0 = model.species.create(id='s0[comp]', species_type=t0, compartment=c)
s1 = model.species.create(id='s1[comp]', species_type=t1, compartment=c)
s2 = model.species.create(id='s2[comp]', species_type=t2, compartment=c)
self.submodel = submodel = model.submodels.create(id='submodel',
framework=onto['WC:stochastic_simulation_algorithm'])
self.r0 = r0 = model.reactions.create(id='r0', reversible=True, submodel=submodel)
r0.participants.create(species=s0, coefficient=-2)
r0.participants.create(species=s1, coefficient=3)
r0_f = r0.rate_laws.create(id='r0-forward', direction=RateLawDirection.forward, model=model)
a = model.parameters.create(id='a', value=1., units=unit_registry.parse_units('s^-1'))
r0_f.expression, error = RateLawExpression.deserialize('a', {Parameter: {'a': a}})
assert error is None, str(error)
r0_b = r0.rate_laws.create(id='r0-backward', direction=RateLawDirection.backward,
model=model)
b = model.parameters.create(id='b', value=1., units=unit_registry.parse_units('s^-1'))
r0_b.expression, error = RateLawExpression.deserialize('b', {Parameter: {'b': b}})
assert error is None, str(error)
r0.references.create(id='ref_0', model=model)
r0.identifiers.create(namespace='x', id='y')
self.r1 = r1 = model.reactions.create(id='r1', reversible=False, submodel=submodel)
r1.participants.create(species=s1, coefficient=-3)
r1.participants.create(species=s2, coefficient=4)
r1_f = r1.rate_laws.create(id='r1-forward', direction=RateLawDirection.forward, model=model)
c = model.parameters.create(id='c', value=1., units=unit_registry.parse_units('s^-1'))
r1_f.expression, error = RateLawExpression.deserialize('c', {Parameter: {'c': c}})
assert error is None, str(error)
r1.references.create(id='ref_1', model=model)
r1.identifiers.create(namespace='xx', id='yy')
self.tempdir = tempfile.mkdtemp()
# check model's integrity by writing and reading with validate=True
filename = os.path.join(self.tempdir, 'model_for_tranformation.xlsx')
Writer().run(filename, model, data_repo_metadata=False)
# turn off validate_element_charge_balance validation so that simple species and reactions validate
with EnvironUtils.temp_config_env([(['wc_lang', 'validation', 'validate_element_charge_balance'],
'False')]):
model_read = Reader().run(filename, validate=True)[Model][0]
self.assertTrue(model_read.is_equal(model))
def gen_compartments(self):
# Create default compartments
kb = self.knowledge_base
model = self.model
# TODO: get volume from KB, talk to YH
c_init_volume = wc_lang.core.InitVolume(
distribution=wc_ontology['WC:normal_distribution'],
mean=1E-15,
std=0)
c = model.compartments.get_or_create(id='c',
name='Cytosol',
init_volume=c_init_volume)
c.init_density = model.parameters.create(
id='density_c',
value=1100.,
units=unit_registry.parse_units('g l^-1'))
volume_c = model.functions.create(id='volume_c',
units=unit_registry.parse_units('l'))
volume_c.expression, error = wc_lang.FunctionExpression.deserialize(
f'{c.id} / {c.init_density.id}', {
wc_lang.Compartment: {
c.id: c
},
wc_lang.Parameter: {
c.init_density.id: c.init_density
},
})
assert error is None, str(error)
# Extracellular space
e_init_volume = wc_lang.core.InitVolume(
distribution=wc_ontology['WC:normal_distribution'],
mean=1E-10,
std=0)
e = model.compartments.get_or_create(id='e',
name='Extracellular space',
init_volume=e_init_volume)
e.init_density = model.parameters.create(
id='density_e',
value=1000.,
units=unit_registry.parse_units('g l^-1'))
volume_e = model.functions.create(id='volume_e',
units=unit_registry.parse_units('l'))
volume_e.expression, error = wc_lang.FunctionExpression.deserialize(
f'{e.id} / {e.init_density.id}', {
wc_lang.Compartment: {
e.id: e
},
wc_lang.Parameter: {
e.init_density.id: e.init_density
},
})
assert error is None, str(error)
def test_create_parameter(self):
self.per_second_id = 'unit_1_per_second'
self.per_second = LibSbmlInterface.call_libsbml(
self.sbml_model.createUnitDefinition)
LibSbmlInterface.call_libsbml(self.per_second.setIdAttribute,
self.per_second_id)
LibSbmlInterface.create_base_unit('unit_1_per_second',
self.per_second,
'second',
exponent=-1)
id = 'id1'
name = 'name1'
value = 13.0
constant = False
parameter = LibSbmlInterface.create_parameter(
self.sbml_model,
id,
value,
unit_registry.parse_units('dimensionless'),
name=name,
constant=constant)
self.assertTrue(
LibSbmlInterface.call_libsbml(parameter.hasRequiredAttributes))
self.assertEqual(
LibSbmlInterface.call_libsbml(parameter.getIdAttribute), id)
self.assertEqual(LibSbmlInterface.call_libsbml(parameter.getName),
name)
self.assertTrue(LibSbmlInterface.call_libsbml(parameter.isSetValue))
self.assertTrue(LibSbmlInterface.call_libsbml(parameter.isSetUnits))
self.assertEqual(LibSbmlInterface.call_libsbml(parameter.getValue),
value)
self.assertEqual(LibSbmlInterface.call_libsbml(parameter.getConstant),
constant)
# test defaults
id = 'id2'
parameter = LibSbmlInterface.create_parameter(
self.sbml_model, id, value,
unit_registry.parse_units('dimensionless'))
self.assertEqual(
LibSbmlInterface.call_libsbml(parameter.getIdAttribute), id)
self.assertEqual(LibSbmlInterface.call_libsbml(parameter.getName), '')
self.assertEqual(LibSbmlInterface.call_libsbml(parameter.getConstant),
True)
# test units
id = 'id3'
parameter = LibSbmlInterface.create_parameter(
self.sbml_model, id, value, unit_registry.parse_units('s^-1'))
self.assertTrue(
LibSbmlInterface.call_libsbml(parameter.hasRequiredAttributes))
self.assertTrue(LibSbmlInterface.call_libsbml(parameter.isSetUnits))
self.assertEqual(LibSbmlInterface.call_libsbml(parameter.getUnits),
self.per_second_id)
def test_gen_unit_id(self):
self.assertEqual(
LibSbmlInterface.gen_unit_id(
unit_registry.parse_units('meter / second')),
'unit_meter_per_second')
self.assertEqual(
LibSbmlInterface.gen_unit_id(unit_registry.parse_units('second')),
'second')
with self.assertRaisesRegex(ValueError, 'Cannot generate SBML id'):
LibSbmlInterface.gen_unit_id(None)
def gen_submodel_0():
timestamp = datetime.datetime(2018, 1, 1, 12, 0, 0)
model = Model(id='model', version='0.0.1', wc_lang_version='0.0.2', created=timestamp, updated=timestamp)
submodel_0 = model.submodels.create(id='submodel_0')
model.compartments.create(id='c_0')
structure = ChemicalStructure(charge=0)
model.species_types.create(id='s_0', structure=structure)
model.species_types.create(id='s_1', structure=structure)
model.species.create(compartment=model.compartments[0], species_type=model.species_types[0])
model.species.create(compartment=model.compartments[0], species_type=model.species_types[1])
for species in model.species:
species.id = species.gen_id()
model.reactions.create(id='rxn_00', submodel=submodel_0)
model.reactions.create(id='rxn_01', submodel=submodel_0)
model.reactions[0].participants.create(species=model.species[0], coefficient=-1)
model.reactions[0].participants.create(species=model.species[1], coefficient=1)
model.reactions[1].participants.add(model.reactions[0].participants[0])
model.parameters.create(id='p_0', value=1., units=unit_registry.parse_units('molecule'))
model.parameters.create(id='p_1', value=1., units=unit_registry.parse_units('molecule'))
model.parameters.create(id='p_3', value=1., units=unit_registry.parse_units('g l^-1'))
model.compartments[0].init_density = model.parameters[2]
model.parameters.create(id='p_5', value=1., units=unit_registry.parse_units('s^-1'))
model.parameters.create(id='p_6', value=1., units=unit_registry.parse_units('s^-1'))
rl = model.rate_laws.create(reaction=model.reactions[0])
rl.expression, error = RateLawExpression.deserialize(f'{model.parameters[3].id}',
{Parameter: {model.parameters[3].id: model.parameters[3]}})
rl = model.rate_laws.create(reaction=model.reactions[1])
rl.expression, error = RateLawExpression.deserialize(f'{model.parameters[4].id}',
{Parameter: {model.parameters[4].id: model.parameters[4]}})
for rl in model.rate_laws:
rl.id = rl.gen_id()
objs = {
Species: {s.id: s for s in model.species},
Parameter: {p.id: p for p in model.parameters},
}
model.stop_conditions.create(id='sc_0')
model.stop_conditions.create(id='sc_1')
model.stop_conditions[0].expression, error = StopConditionExpression.deserialize(
f'{model.species[0].id} > {model.parameters[0].id}', objs)
assert error is None, str(error)
model.stop_conditions[1].expression, error = StopConditionExpression.deserialize(
f'{model.species[1].id} > {model.parameters[1].id}', objs)
assert error is None, str(error)
model.references.create(id='ref_0', submodels=[submodel_0])
model.references.create(id='ref_1', submodels=[submodel_0])
return model
def simple_activator(model, reaction_id, activator):
""" Generate the parameters and string expression of the regulation factor
derived in Bintu et al (2005) for the case of a simple activator
Args:
model (:obj:`wc_lang.Model`): model
reaction_id (:obj:`str`): reaction id
activator (:obj:`wc_lang.Species`): activator
Returns:
:obj:`str`: string expression of the regulation factor
:obj:`dict` of :obj:`wc_lang.Species`: dict of species in the expression
with the species ids as keys and the species objects as values
:obj:`dict` of :obj:`wc_lang.Parameter`: dict of parameters in the expression
with the parameter ids as keys and the parameter objects as values
:obj:`dict` of :obj:`wc_lang.Function`: dict of functions in the expression
with the function ids as keys and the function objects as values
"""
species = {}
parameters = {}
functions = {}
species[activator.id] = activator
avogadro = model.parameters.get_or_create(
id='Avogadro',
type=None,
value=scipy.constants.Avogadro,
units=unit_registry.parse_units('molecule mol^-1'))
parameters[avogadro.id] = avogadro
Ka = model.parameters.get_or_create(id='Ka_{}_{}'.format(
reaction_id, activator.species_type.id),
type=None,
units=unit_registry.parse_units('M'))
parameters[Ka.id] = Ka
f = model.parameters.get_or_create(id='f_{}_{}'.format(
reaction_id, activator.species_type.id),
type=None,
units=unit_registry.parse_units(''))
parameters[f.id] = f
volume = activator.compartment.init_density.function_expressions[
0].function
functions[volume.id] = volume
F_act = '((1 + {} / ({} * {} * {}) * {}) / (1 + {} / ({} * {} * {})))'.format(
activator.id, Ka.id, avogadro.id, volume.id, f.id, activator.id, Ka.id,
avogadro.id, volume.id)
return F_act, species, parameters, functions
def normalize_unit_kind(self):
self.assertEqual(
LibSbmlInterface.normalize_unit_kind(
unit_registry.parse_units('meter')), 'metre')
self.assertEqual(
LibSbmlInterface.normalize_unit_kind(
unit_registry.parse_units('liter')), 'litre')
self.assertEqual(
LibSbmlInterface.normalize_unit_kind(
unit_registry.parse_units('mole')), 'mole')
self.assertEqual(
LibSbmlInterface.normalize_unit_kind(
unit_registry.parse_units('item')), 'item')
def gen_compartments(self):
""" Generate compartments for the model from knowledge base """
kb = self.knowledge_base
model = self.model
if kb.cell.parameters.get_one(id='cell_volume'):
mean_cell_volume = kb.cell.parameters.get_one(id='cell_volume').value
else:
raise ValueError('The cell object does not have the parameter cell_volume')
culture_volume = self.options['culture_volume']
cell_density = self.options['cell_density']
membrane_density = self.options['membrane_density']
for comp in kb.cell.compartments:
c = model.compartments.get_or_create(
id=comp.id, name=comp.name)
c.init_density = model.parameters.create(
id='density_' + c.id,
units=unit_registry.parse_units('g l^-1'))
if comp.id=='e':
c.biological_type = wc_ontology['WC:extracellular_compartment']
c.init_density.value = 1000.
c.init_volume = wc_lang.core.InitVolume(distribution=wc_ontology['WC:normal_distribution'],
mean=culture_volume, std=0)
elif '_m' in comp.id:
c.physical_type = wc_ontology['WC:membrane_compartment']
c.init_density.value = membrane_density
organelle_fraction = kb.cell.compartments.get_one(id=comp.id[:comp.id.index('_')]).volumetric_fraction
c.init_volume = wc_lang.core.InitVolume(distribution=wc_ontology['WC:normal_distribution'],
mean=4.836E-09*(mean_cell_volume*organelle_fraction)**(2/3), std=0)
else:
c.init_density.value = cell_density
organelle_fraction = kb.cell.compartments.get_one(id=comp.id).volumetric_fraction
c.init_volume = wc_lang.core.InitVolume(distribution=wc_ontology['WC:normal_distribution'],
mean=mean_cell_volume*organelle_fraction - 4.836E-09*(mean_cell_volume*organelle_fraction)**(2/3), std=0)
volume = model.functions.create(id='volume_' + c.id, units=unit_registry.parse_units('l'))
volume.expression, error = wc_lang.FunctionExpression.deserialize(f'{c.id} / {c.init_density.id}', {
wc_lang.Compartment: {c.id: c},
wc_lang.Parameter: {c.init_density.id: c.init_density},
})
assert error is None, str(error)
def setUp(self):
# make a Compartment & use it to make a DynamicCompartment
comp_id = 'comp_id'
self.mean_init_volume = 1E-17
self.compartment = Compartment(id=comp_id,
name='name',
init_volume=InitVolume(
mean=self.mean_init_volume,
std=self.mean_init_volume / 40.))
self.compartment.init_density = Parameter(
id='density_{}'.format(comp_id),
value=1100.,
units=unit_registry.parse_units('g l^-1'))
self.random_state = RandomStateManager.instance()
self.dynamic_compartment = DynamicCompartment(None, self.random_state,
self.compartment)
self.abstract_compartment = Compartment(
id=comp_id,
name='name',
init_volume=InitVolume(mean=self.mean_init_volume, std=0),
physical_type=onto['WC:abstract_compartment'])
self.abstract_dynamic_compartment = DynamicCompartment(
None, self.random_state, self.abstract_compartment)
def gen_parameters(self):
kb = self.knowledge_base
model = self.model
# Create parameters
#model.parameters.get_or_create(id='mean_doubling_time',
# type=None,
# value=kb.cell.parameters.get_one(id='mean_doubling_time').value,
# units=unit_registry.parse_units('s'))
Avogadro = model.parameters.create(
id='Avogadro',
type=None,
value=scipy.constants.Avogadro,
units=unit_registry.parse_units('molecule mol^-1'))
for param in kb.cell.parameters:
model_param = model.parameters.create(id=param.id,
value=param.value,
units=param.units)
if 'K_m' in param.id:
model_param.type = wc_ontology['WC:K_m']
elif 'k_cat' in param.id:
model_param.type = wc_ontology['WC:k_cat']
else:
model_param.type = None
def calibrate_submodel(self):
""" Calibrate the submodel using data in the KB """
model = self.model
beta = self.options.get('beta')
Avogadro = model.parameters.get_or_create(
id='Avogadro',
type=None,
value=scipy.constants.Avogadro,
units=unit_registry.parse_units('molecule mol^-1'))
cytosol = model.compartments.get_one(id='c')
mean_doubling_time = self.knowledge_base.cell.parameters.get_one(
id='mean_doubling_time').value
init_species_counts = {}
modifier = model.observables.get_one(id='rna_polymerase_obs')
for species in modifier.expression.species:
init_species_counts[species.gen_id(
)] = species.distribution_init_concentration.mean
rnas_kb = self.knowledge_base.cell.species_types.get(
__type=wc_kb.prokaryote.RnaSpeciesType)
for rna_kb, reaction in zip(rnas_kb, self.submodel.reactions):
rna_product = model.species_types.get_one(
id=rna_kb.id).species.get_one(compartment=cytosol)
half_life = rna_kb.properties.get_one(
property='half_life').get_value()
mean_concentration = rna_product.distribution_init_concentration.mean
average_rate = utils.calc_avg_syn_rate(mean_concentration,
half_life,
mean_doubling_time)
for species in reaction.get_reactants():
init_species_counts[species.gen_id(
)] = species.distribution_init_concentration.mean
if model.parameters.get(id='K_m_{}_{}'.format(
reaction.id, species.species_type.id)):
model_Km = model.parameters.get_one(id='K_m_{}_{}'.format(
reaction.id, species.species_type.id))
model_Km.value = beta * species.distribution_init_concentration.mean \
/ Avogadro.value / species.compartment.init_volume.mean
model_kcat = model.parameters.get_one(
id='k_cat_{}'.format(reaction.id))
model_kcat.value = 1.
model_kcat.value = average_rate / reaction.rate_laws[
0].expression._parsed_expression.eval({
wc_lang.Species: init_species_counts,
wc_lang.Compartment: {
cytosol.id:
cytosol.init_volume.mean * cytosol.init_density.value
},
})
def test_write_parameter(self):
model = Model(id='model', version='0.0.1', wc_lang_version='0.0.1')
submodel = model.submodels.create(id='submodel')
species_type = model.species_types.create(id='st',
structure=ChemicalStructure(
molecular_weight=1.,
charge=0))
compartment = model.compartments.create(id='c')
species = model.species.create(species_type=species_type,
compartment=compartment)
species.id = species.gen_id()
reaction = submodel.reactions.create(id='reaction', model=model)
reaction.participants.create(species=species, coefficient=1.)
rate_law = reaction.rate_laws.create(
model=model, direction=RateLawDirection.forward)
rate_law.id = rate_law.gen_id()
rate_law_eq = rate_law.expression = RateLawExpression(
expression='parameter')
parameter = rate_law_eq.parameters.create(
id='parameter',
value=1.,
units=unit_registry.parse_units('dimensionless'),
model=model)
filename = os.path.join(self.tempdir, 'model.xlsx')
Writer().run(filename, model, data_repo_metadata=False)
parameter.model = Model(id='model2',
version='0.0.1',
wc_lang_version='0.0.1')
with self.assertRaisesRegex(ValueError,
'must be set to the instance of `Model`'):
Writer().run(filename, model, data_repo_metadata=False)
def test_concentrations(self):
cytosol = self.model.compartments.get_one(id='c')
for conc in self.kb.cell.concentrations:
model_species_type = self.model.species_types.get_one(id=conc.species.species_type.id)
model_specie = model_species_type.species.get_one(compartment=cytosol)
self.assertIsInstance(model_species_type, wc_lang.SpeciesType)
self.assertIsInstance(model_specie, wc_lang.Species)
self.assertTrue(conc.units, unit_registry.parse_units('M'))
def parse_unit_id(cls, sbml_unit_def_id):
""" Parse a unit from an SBML unit definition.
Args:
sbml_unit_def_id (:obj:`str`): id of SBML unit definition
Returns:
:obj:`unit_registry.Unit`: units
"""
if sbml_unit_def_id.startswith('unit_'):
return unit_registry.parse_units(
sbml_unit_def_id.partition('unit_')[2].replace(
'_per_', ' / ').replace('_times_',
' * ').replace('_pow_', ' ** '))
else:
if sbml_unit_def_id == 'mole':
return unit_registry.parse_units('molecule')
return unit_registry.parse_units(sbml_unit_def_id)
def test_generator(self):
kb = wc_kb.KnowledgeBase()
cell = kb.cell = wc_kb.Cell()
cell.taxon = 9606
cell.parameters.create(id='cell_volume', value=1E-15)
cell.parameters.create(id='mean_doubling_time',
value=20.,
units=unit_registry.parse_units('hour'))
compartments = {'c': 0.7, 'n': 0.3, 'e': None}
for k, v in compartments.items():
cell.compartments.create(id=k, volumetric_fraction=v)
test_component_generators = [initialize_model.InitializeModel]
gen = core.EukaryoteModelGenerator(
kb,
component_generators=test_component_generators,
options={
'id': 'h1_test',
'name': 'h1 model',
'version': '2.3.1',
'component': {
'InitializeModel': {
'cell_density': 1100.,
'gen_dna': False,
'gen_pre_rnas': False,
'gen_transcripts': False,
'gen_protein': False,
'gen_metabolites': False,
'gen_complexes': False,
'gen_distribution_init_concentrations': False,
'gen_observables': False,
'gen_kb_reactions': False,
'gen_kb_rate_laws': False,
}
}
})
model = gen.run()
self.assertEqual(model.id, 'h1_test')
self.assertEqual(model.name, 'h1 model')
self.assertEqual(model.version, '2.3.1')
self.assertEqual(
model.parameters.get_one(id='mean_doubling_time').value, 72000)
self.assertEqual(model.parameters.get_one(id='density_n').value, 1100)
self.assertEqual(model.parameters.get_one(id='density_e').value, 1000)
self.assertEqual(
model.compartments.get_one(id='n').init_volume.mean,
2.997832792664565e-16)
self.assertEqual(
model.compartments.get_one(id='e').init_volume.mean, 1.0)
def gen_core_model(extra_species=True):
timestamp = datetime.datetime(2018, 1, 1, 12, 0, 0)
model = Model(id='model', version='0.0.1', wc_lang_version='0.0.2', created=timestamp, updated=timestamp)
model.compartments.create(id='c_0')
model.compartments.create(id='c_1')
structure = ChemicalStructure(charge=0)
model.species_types.create(id='s_0', structure=structure)
model.species_types.create(id='s_1', structure=structure)
model.species.create(compartment=model.compartments[0], species_type=model.species_types[0])
model.species.create(compartment=model.compartments[0], species_type=model.species_types[1])
model.species.create(compartment=model.compartments[1], species_type=model.species_types[0])
if extra_species:
model.species.create(compartment=model.compartments[1], species_type=model.species_types[1])
for species in model.species:
species.id = species.gen_id()
model.parameters.create(id='p_0', value=1., units=unit_registry.parse_units('molecule'))
model.parameters.create(id='p_1', value=1., units=unit_registry.parse_units('molecule'))
model.parameters.create(id='p_2', value=1., units=unit_registry.parse_units('molecule'))
model.parameters.create(id='p_3', value=1., units=unit_registry.parse_units('g l^-1'))
model.parameters.create(id='p_4', value=1., units=unit_registry.parse_units('g l^-1'))
model.compartments[0].init_density = model.parameters[3]
model.compartments[1].init_density = model.parameters[4]
objs = {
Species: {s.id: s for s in model.species},
Parameter: {p.id: p for p in model.parameters},
}
model.stop_conditions.create(id='sc_0')
model.stop_conditions.create(id='sc_1')
model.stop_conditions.create(id='sc_2')
model.stop_conditions[0].expression, error = StopConditionExpression.deserialize(
f'{model.species[0].id} > {model.parameters[0].id}', objs)
assert error is None, str(error)
model.stop_conditions[1].expression, error = StopConditionExpression.deserialize(
f'{model.species[1].id} > {model.parameters[1].id}', objs)
assert error is None, str(error)
model.stop_conditions[2].expression, error = StopConditionExpression.deserialize(
f'{model.species[2].id} > {model.parameters[2].id}', objs)
assert error is None, str(error)
return model
def specify_init_accounted_fraction(self, desired_init_accounted_fraction):
# make a DynamicCompartment with accounted_fraction ~= desired_init_accounted_fraction
# without changing init_accounted_mass or init_volume
init_density = self.dynamic_compartment.init_accounted_mass / \
(desired_init_accounted_fraction * self.dynamic_compartment.init_volume)
self.compartment.init_density = Parameter(
id='density_x',
value=init_density,
units=unit_registry.parse_units('g l^-1'))
return DynamicCompartment(None, self.random_state, self.compartment)
def gen_components(self):
""" Construct knowledge base components """
# get options
options = self.options
# generate properties
cell = self.knowledge_base.cell
prop = cell.properties.get_or_create(id='mean_volume')
prop.value = options.get('mean_volume')
prop.units = unit_registry.parse_units('l')
prop = cell.properties.get_or_create(id='mean_doubling_time')
prop.value = options.get('mean_doubling_time')
prop.units = unit_registry.parse_units('s')
prop = cell.properties.get_or_create(id='mean_cell_density')
prop.value = options.get('mean_cell_density')
prop.units = unit_registry.parse_units('cells l^-1')
def test_parse_parameter(self):
units = unit_registry.parse_units('s^-1')
LibSbmlInterface.create_unit(units, self.sbml_model)
parameter = LibSbmlInterface.create_parameter(self.sbml_model,
'parameter_1', 1.5,
units)
id, name, value, units = LibSbmlInterface.parse_parameter(parameter)
self.assertEqual(id, 'parameter_1')
self.assertEqual(name, '')
self.assertEqual(value, 1.5)
self.assertEqual(units, unit_registry.parse_expression('s^-1'))
def test_validate_exception(self):
model = Model(id='model',
name='test model',
version='0.0.1a',
wc_lang_version='0.0.1')
model.parameters.append(
Parameter(id='param_1',
value=1.,
units=unit_registry.parse_units('dimensionless')))
model.parameters.append(
Parameter(id='param_1',
value=1.,
units=unit_registry.parse_units('dimensionless')))
self.assertNotEqual(Validator().run(model, get_related=True), None)
filename = path.join(self.tempdir, 'model.xlsx')
Writer().run(filename, model, data_repo_metadata=False)
with self.assertRaisesRegex(SystemExit, '^Model is invalid: '):
with __main__.App(argv=['validate', filename]) as app:
app.run()
def test_simple_activator(self):
model = wc_lang.Model()
init_volume = wc_lang.core.InitVolume(
distribution=wc_ontology['WC:normal_distribution'],
mean=0.5,
std=0)
c = wc_lang.Compartment(id='c', init_volume=init_volume)
c.init_density = wc_lang.Parameter(id='density_' + c.id, value=1.)
volume = wc_lang.Function(id='volume_' + c.id)
volume.expression, error = wc_lang.FunctionExpression.deserialize(
f'{c.id} / {c.init_density.id}', {
wc_lang.Compartment: {
c.id: c
},
wc_lang.Parameter: {
c.init_density.id: c.init_density
},
})
assert error is None, str(error)
tf_species_type = wc_lang.SpeciesType(id='Activator')
tf_species = wc_lang.Species(species_type=tf_species_type,
compartment=c)
tf_species.id = tf_species.gen_id()
wc_lang.DistributionInitConcentration(species=tf_species, mean=0.5)
F_act, species, parameters, functions = utils.simple_activator(
model, 'transcription_rna1', tf_species)
self.assertEqual(
F_act,
'((1 + Activator[c] / (Ka_transcription_rna1_Activator * Avogadro * volume_c) * f_transcription_rna1_Activator) / '
'(1 + Activator[c] / (Ka_transcription_rna1_Activator * Avogadro * volume_c)))'
)
self.assertEqual(species, {'Activator[c]': tf_species})
self.assertEqual(functions, {'volume_c': volume})
self.assertEqual(set(model.parameters), set(parameters.values()))
self.assertEqual(
sorted(list(parameters.keys())),
sorted([
'Avogadro', 'f_transcription_rna1_Activator',
'Ka_transcription_rna1_Activator'
]))
self.assertEqual(
model.parameters.get_one(
id='Ka_transcription_rna1_Activator').type, None)
self.assertEqual(
model.parameters.get_one(
id='Ka_transcription_rna1_Activator').units,
unit_registry.parse_units('M'))
def test_init_model(self):
model = Model()
model.parameters.create(units=unit_registry.parse_units('s^-1'))
model.parameters.create(units=unit_registry.parse_units('g / l'))
model.parameters.create(units=unit_registry.parse_units('m'))
sbml_model = LibSbmlInterface.init_model(model,
self.document,
packages={'fbc': 2})
# check the SBML document
LibSbmlInterface.verify_doc(self.document)
return_val = LibSbmlInterface.call_libsbml(
self.document.checkConsistency, returns_int=True)
self.assertEqual(return_val, 0)
LibSbmlInterface.verify_doc_is_compatible(self.document)
# check seconds unit
unit_def = LibSbmlInterface.call_libsbml(sbml_model.getUnitDefinition,
'unit_1_per_second')
units = LibSbmlInterface.call_libsbml(UnitDefinition.printUnits,
unit_def, True)
self.assertEqual(units, '(1 second)^-1')
def test_get_obj_units(self):
model = Model()
units = set([model.time_units])
self.assertEqual(set(obj_tables.sci.units.get_obj_units(model)), units)
model.compartments.create()
model.compartments.create()
for c in model.compartments:
units.add(c.mass_units)
if c.init_volume:
units.add(c.init_volume.units)
if c.ph:
units.add(c.ph.units)
self.assertEqual(set(obj_tables.sci.units.get_obj_units(model)), units)
model.species_types.create()
model.species_types.create()
self.assertEqual(set(obj_tables.sci.units.get_obj_units(model)), units)
for c in model.compartments:
for s in model.species_types:
model.species.create(compartment=c, species_type=s)
for s in model.species:
units.add(s.units)
self.assertEqual(set(obj_tables.sci.units.get_obj_units(model)), units)
model.distribution_init_concentrations.create(
species=model.species[0], units=unit_registry.parse_units('M'))
model.distribution_init_concentrations.create(
species=model.species[1],
units=unit_registry.parse_units('molecule'))
for o in model.distribution_init_concentrations:
units.add(o.units)
self.assertEqual(set(obj_tables.sci.units.get_obj_units(model)), units)
model.parameters.create(units=unit_registry.parse_units('g'))
model.parameters.create(units=unit_registry.parse_units('l'))
model.parameters.create(units=unit_registry.parse_units('s'))
for p in model.parameters:
units.add(p.units)
self.assertEqual(set(obj_tables.sci.units.get_obj_units(model)), units)
model.functions.create(units=unit_registry.parse_units('g / l'))
model.functions.create(units=unit_registry.parse_units('g / s'))
model.functions.create(units=unit_registry.parse_units('l / s'))
for f in model.functions:
units.add(f.units)
self.assertEqual(set(obj_tables.sci.units.get_obj_units(model)), units)
def setup_submodel_params(self, model_type, num_species, vol_mean,
vol_std):
# make Model
model = Model(id='test_model',
name=model_type,
version='0.0.0',
wc_lang_version='0.0.1')
# make SpeciesTypes
species_types = []
for i in range(num_species):
spec_type = model.species_types.create(id='spec_type_{}'.format(i))
species_types.append(spec_type)
initial_volume = InitVolume(mean=vol_mean,
std=vol_std,
units=unit_registry.parse_units('l'))
comp = model.compartments.create(
id='compt_1',
biological_type=onto['WC:cellular_compartment'],
init_volume=initial_volume)
comp.init_density = model.parameters.create(
id='density_compt_1',
value=1100,
units=unit_registry.parse_units('g l^-1'))
return (model, species_types, comp)
def test_dynamic_compartment_exceptions(self):
compartment = Compartment(id='id',
name='name',
init_volume=InitVolume(mean=0))
with self.assertRaises(MultialgorithmError):
DynamicCompartment(None, self.random_state, compartment)
self.compartment.init_density = Parameter(
id='density_{}'.format(self.compartment.id),
value=float('nan'),
units=unit_registry.parse_units('g l^-1'))
with self.assertRaises(MultialgorithmError):
DynamicCompartment(None, self.random_state, self.compartment)
self.compartment.init_density = Parameter(
id='density_{}'.format(self.compartment.id),
value=0.,
units=unit_registry.parse_units('g l^-1'))
with self.assertRaises(MultialgorithmError):
DynamicCompartment(None, self.random_state, self.compartment)
self.compartment.init_volume = None
with self.assertRaises(MultialgorithmError):
DynamicCompartment(None, self.random_state, self.compartment)
