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 run(self):
""" Generate a :obj:`wc_lang` model from a :obj:`wc_kb` knowledge base
Returns:
:obj:`wc_lang.Model`: model
"""
model = wc_lang.Model()
model.id = self.options.get('id')
model.name = self.options.get('name')
model.version = self.options.get('version')
component_options = self.options.get('component', {})
for component_generator in self.component_generators:
options = component_options.get(component_generator.__name__, {})
component_generator(self.knowledge_base, model,
options=options).run()
return model
def setUp(self):
# make model
self.model = wc_lang.Model(id='model')
comp = self.model.compartments.create(id='comp')
self.species = []
self.num_species = 20
for i in range(1, self.num_species+1):
spec_type = self.model.species_types.create(id=self.sp_id(i),
type=onto['WC:metabolite']) # metabolite
species = wc_lang.Species(
species_type=spec_type,
compartment=comp)
species.id = species.gen_id()
self.species.append(species)
self.dfba_submodel = self.model.submodels.create(
id='metabolism',
framework=onto['WC:dynamic_flux_balance_analysis'])
self.id_idx = 0
self.model_analysis = wc_analysis.model.fba.FbaModelAnalysis(self.model)
def setUp(self):
# Create KB content
self.tmp_dirname = tempfile.mkdtemp()
self.sequence_path = os.path.join(self.tmp_dirname, 'test_seq.fasta')
with open(self.sequence_path, 'w') as f:
f.write('>chr1\nGCGTGCGATGAT\n'
'>chrM\nNGCGTGCGATGAT\n'
'>chrX\nATGtgaGCGtgatga\n')
self.kb = wc_kb.KnowledgeBase()
cell = self.kb.cell = wc_kb.Cell()
chr1 = wc_kb.core.DnaSpeciesType(cell=cell,
id='chr1',
sequence_path=self.sequence_path)
gene1 = wc_kb.eukaryote.GeneLocus(cell=cell,
id='gene1',
polymer=chr1,
start=1,
end=12)
chrM = wc_kb.core.DnaSpeciesType(cell=cell,
id='chrM',
sequence_path=self.sequence_path)
geneM = wc_kb.eukaryote.GeneLocus(cell=cell,
id='geneM',
polymer=chrM,
start=2,
end=13)
chrX = wc_kb.core.DnaSpeciesType(cell=cell,
id='chrX',
sequence_path=self.sequence_path)
geneX1 = wc_kb.eukaryote.GeneLocus(cell=cell,
id='geneX1',
polymer=chrX,
start=1,
end=15)
geneX2 = wc_kb.eukaryote.GeneLocus(cell=cell,
id='geneX2',
polymer=chrX,
start=1,
end=15)
locus1 = wc_kb.eukaryote.GenericLocus(start=1, end=6)
transcript1 = wc_kb.eukaryote.TranscriptSpeciesType(cell=cell,
gene=gene1,
exons=[locus1])
prot1 = wc_kb.eukaryote.ProteinSpeciesType(cell=cell,
id='prot1',
name='protein1',
transcript=transcript1,
coding_regions=[locus1])
prot1_half_life = wc_kb.core.SpeciesTypeProperty(
property='half-life',
species_type=prot1,
value='40000.0',
value_type=wc_ontology['WC:float'])
locus2 = wc_kb.eukaryote.GenericLocus(start=4, end=9)
transcript2 = wc_kb.eukaryote.TranscriptSpeciesType(cell=cell,
gene=gene1,
exons=[locus2])
prot2 = wc_kb.eukaryote.ProteinSpeciesType(cell=cell,
id='prot2',
name='protein2',
transcript=transcript2,
coding_regions=[locus2])
prot2_half_life = wc_kb.core.SpeciesTypeProperty(
property='half-life',
species_type=prot2,
value='40000.0',
value_type=wc_ontology['WC:float'])
locus3 = wc_kb.eukaryote.GenericLocus(start=7, end=12)
transcript3 = wc_kb.eukaryote.TranscriptSpeciesType(cell=cell,
gene=gene1,
exons=[locus3])
prot3 = wc_kb.eukaryote.ProteinSpeciesType(cell=cell,
id='prot3',
name='protein3',
transcript=transcript3,
coding_regions=[locus3])
prot3_half_life = wc_kb.core.SpeciesTypeProperty(
property='half-life',
species_type=prot3,
value='25000.0',
value_type=wc_ontology['WC:float'])
locusM = wc_kb.eukaryote.GenericLocus(start=8, end=13)
transcriptM = wc_kb.eukaryote.TranscriptSpeciesType(cell=cell,
gene=geneM,
exons=[locusM])
protM = wc_kb.eukaryote.ProteinSpeciesType(cell=cell,
id='protM',
name='proteinM',
transcript=transcriptM,
coding_regions=[locusM])
protM_half_life = wc_kb.core.SpeciesTypeProperty(
property='half-life',
species_type=protM,
value='25000.0',
value_type=wc_ontology['WC:float'])
locusX1 = wc_kb.eukaryote.GenericLocus(start=1, end=15)
transcriptX1 = wc_kb.eukaryote.TranscriptSpeciesType(cell=cell,
gene=geneX1,
exons=[locusX1])
protX1 = wc_kb.eukaryote.ProteinSpeciesType(cell=cell,
id='protX1',
name='proteinX1',
transcript=transcriptX1,
coding_regions=[locusX1])
protX1_half_life = wc_kb.core.SpeciesTypeProperty(
property='half-life',
species_type=protX1,
value='25000.0',
value_type=wc_ontology['WC:float'])
locusX2 = wc_kb.eukaryote.GenericLocus(start=1, end=15)
transcriptX2 = wc_kb.eukaryote.TranscriptSpeciesType(cell=cell,
gene=geneX2,
exons=[locusX2])
protX2 = wc_kb.eukaryote.ProteinSpeciesType(cell=cell,
id='protX2',
name='proteinX2',
transcript=transcriptX2,
coding_regions=[locusX2])
protX2_half_life = wc_kb.core.SpeciesTypeProperty(
property='half-life',
species_type=protX2,
value='25000.0',
value_type=wc_ontology['WC:float'])
# Create initial model content
self.model = model = wc_lang.Model()
model.parameters.create(
id='Avogadro',
value=scipy.constants.Avogadro,
units=unit_registry.parse_units('molecule mol^-1'))
compartments = {
'n': ('nucleus', 5E-14),
'c': ('cytoplasm', 1E-13),
'm': ('mitochondria', 2.5E-14),
'l': ('lysosome', 1.5E-14),
'c_m': ('membrane', 5E-15)
}
for k, v in compartments.items():
init_volume = wc_lang.core.InitVolume(
distribution=wc_ontology['WC:normal_distribution'],
mean=v[1],
std=0)
c = model.compartments.create(id=k,
name=v[0],
init_volume=init_volume)
c.init_density = model.parameters.create(
id='density_' + k,
value=1000,
units=unit_registry.parse_units('g l^-1'))
volume = model.functions.create(
id='volume_' + k, 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)
proteins = {
'prot1': ['n', 'c'],
'prot2': ['c', 'l'],
'prot3': ['l'],
'protM': ['m', 'c_m'],
'protX1': ['l'],
'protX2': ['l']
}
for k, v in proteins.items():
kb_protein = cell.species_types.get_one(id=k)
model_species_type = model.species_types.create(
id=kb_protein.id,
name=kb_protein.name,
type=wc_ontology['WC:protein'])
for comp in v:
model_compartment = model.compartments.get_one(id=comp)
model_species = model.species.create(
species_type=model_species_type,
compartment=model_compartment)
model_species.id = model_species.gen_id()
conc_model = model.distribution_init_concentrations.create(
species=model_species,
mean=10,
units=unit_registry.parse_units('molecule'))
conc_model.id = conc_model.gen_id()
model.distribution_init_concentrations.get_one(
id='dist-init-conc-protM[m]').mean = 0.
complexes = {
'comp_1': ('26S proteasome', ['n', 'c']),
'comp_2': ('lonp1', ['m']),
'comp_3': ('clpp', ['m']),
'comp_4': ('cathepsin B', ['l']),
'comp_5': ('cathepsin D', ['l'])
}
for k, v in complexes.items():
model_species_type = model.species_types.create(
id=k, name=v[0], type=wc_ontology['WC:pseudo_species'])
for comp in v[1]:
model_compartment = model.compartments.get_one(id=comp)
model_species = model.species.create(
species_type=model_species_type,
compartment=model_compartment)
model_species.id = model_species.gen_id()
conc_model = model.distribution_init_concentrations.create(
species=model_species,
mean=2,
units=unit_registry.parse_units('molecule'))
conc_model.id = conc_model.gen_id()
metabolic_participants = [
'Ala', 'Cys', 'Asp', 'Glu', 'Met', 'Selcys', 'h2o'
]
metabolic_compartments = ['l', 'm']
for i in metabolic_participants:
for c in metabolic_compartments:
model_species_type = model.species_types.get_or_create(
id=i, type=wc_ontology['WC:metabolite'])
model_compartment = model.compartments.get_one(id=c)
model_species = model.species.get_or_create(
species_type=model_species_type,
compartment=model_compartment)
model_species.id = model_species.gen_id()
def main(examples_dir=os.path.join(os.path.dirname(__file__), 'examples')):
################################################################
# This code is used by literalinclude commands in wc_lang_tutorial.rst
# It contains many separate examples, each prefixed by a comment that delineates the
# start of the example and is used by a start-after option in a literalinclude.
# The line before each of these comments is:
# Don't change the next comment - it's used by a literalinclude
# Changes to these comments should be synchronized with changes to wc_lang_tutorial.rst
################################################################
# save the results of example commands so this function can be unit-tested
results = []
################################################
# Reading and writing models to/from files
################################################
model_filename = os.path.join(examples_dir, 'example_model.xlsx')
# Don't change the next comment - it's used by a literalinclude
# This example illustrates how to read a model from an Excel file
# 'model_filename' is the name of an Excel file storing a model
model = wc_lang.io.Reader().run(model_filename)[wc_lang.Model][0]
results.append("read model: '{}'".format(model.name))
if not os.path.isdir(examples_dir):
os.makedirs(examples_dir)
# Don't change the next comment - it's used by a literalinclude
# This example illustrates how to write a model to a set of .tsv files
# 'examples_dir' is a directory
model_filename_pattern = os.path.join(examples_dir, 'example_model-*.tsv')
wc_lang.io.Writer().run(model_filename_pattern, model, data_repo_metadata=False)
results.append("write a model to a set of .tsv files: '{}'".format(model_filename_pattern))
# Don't change the next comment - it's used by a literalinclude
# This example illustrates how to read a model from a set of .tsv files
model_from_tsv = wc_lang.io.Reader().run(model_filename_pattern)[wc_lang.Model][0]
results.append("read a model from a set of .tsv files: '{}'".format(model_from_tsv.name))
################################################
# Accessing model properties
################################################
# Don't change the next comment - it's used by a literalinclude
# ``wc_lang`` models have many attributes
model.id # the model's unique identifier
model.name # its human readable name
model.version # its version number
model.taxon # the taxon of the organism being modeled
model.submodels # a list of the model's submodels
model.compartments # " " " the model's compartments
model.species_types # " " " its species types
model.parameters # " " " its parameters
model.references # " " " publication sources for the model instance
model.identifiers # " " " identifiers in external namespaces for the model instance
results.append("referenced model attributes")
# Don't change the next comment - it's used by a literalinclude
# ``wc_lang`` also provides many convenience methods
model.get_compartments()
model.get_species_types()
model.get_submodels()
model.get_species()
model.get_distribution_init_concentrations()
model.get_reactions()
model.get_dfba_obj_reactions()
model.get_rate_laws()
model.get_parameters()
model.get_references()
results.append("referenced model convenience methods")
# Don't change the next comment - it's used by a literalinclude
# ``get_reactions()`` returns a list of all of the reactions in a model's submodels
reaction_identification = []
for reaction in model.get_reactions():
reaction_identification.append('submodel name: {}, reaction id: {}'.format(
reaction.submodel.name, reaction.id))
results.append("get_reactions entry 0: '{}'".format(reaction_identification[0]))
#################################################
# Building models and editing model properties
#################################################
# Don't change the next comment - it's used by a literalinclude
# The following illustrates how to program a trivial model
# create a model with one submodel and one compartment
prog_model = wc_lang.Model(id='programmatic_model', name='Programmatic model')
submodel = wc_lang.Submodel(id='submodel_1', model=prog_model)
cytosol = wc_lang.Compartment(id='c', name='Cytosol')
# create 5 species types
atp = wc_lang.SpeciesType(id='atp', name='ATP', model=prog_model)
adp = wc_lang.SpeciesType(id='adp', name='ADP', model=prog_model)
pi = wc_lang.SpeciesType(id='pi', name='Pi', model=prog_model)
h2o = wc_lang.SpeciesType(id='h2o', name='H2O', model=prog_model)
h = wc_lang.SpeciesType(id='h', name='H+', model=prog_model)
# create an 'ATP hydrolysis' reaction that uses these species types
atp_hydrolysis = wc_lang.Reaction(id='atp_hydrolysis', name='ATP hydrolysis')
# add two reactants, which have negative stoichiometric coefficients
atp_hydrolysis.participants.create(
species=wc_lang.Species(id='atp[c]', species_type=atp, compartment=cytosol), coefficient=-1)
atp_hydrolysis.participants.create(
species=wc_lang.Species(id='h2o[c]', species_type=h2o, compartment=cytosol), coefficient=-1)
# add three products, with positive stoichiometric coefficients
atp_hydrolysis.participants.create(
species=wc_lang.Species(id='adp[c]', species_type=adp, compartment=cytosol), coefficient=1)
atp_hydrolysis.participants.create(
species=wc_lang.Species(id='pi[c]', species_type=pi, compartment=cytosol), coefficient=1)
atp_hydrolysis.participants.create(
species=wc_lang.Species(id='h[c]', species_type=h, compartment=cytosol), coefficient=1)
# The previous illustrates how to program a trivial model
# Don't change the previous comment - it's used by a literalinclude
results.append("created model: '{}'".format(prog_model.name))
# Don't change the next comment - it's used by a literalinclude
# so that this assertion holds
assert(atp in prog_model.get_species_types())
# Don't change the next comment - it's used by a literalinclude
# these assertions hold
# 5 participants were added to the reaction
assert(len(atp_hydrolysis.participants) == 5)
first_reaction_participant = atp_hydrolysis.participants[0]
assert(first_reaction_participant.reactions[0] is atp_hydrolysis)
# Don't change the next comment - it's used by a literalinclude
# The attribues that can be initialized when a ``wc_lang.BaseModel`` class is instantiated
wc_lang.Model.Meta.attributes.keys()
wc_lang.Submodel.Meta.attributes.keys()
wc_lang.SpeciesType.Meta.attributes.keys()
wc_lang.Compartment.Meta.attributes.keys()
# Don't change the next comment - it's used by a literalinclude
# The following illustrates how to edit a model programmatically
atp_hydrolysis.comments = 'example comments'
atp_hydrolysis.reversible = False
#################################################
# Viewing Models and their attributes
#################################################
# pprint example
atp_hydrolysis.participants[0].pprint(max_depth=1)
#################################################
# Finding model components
#################################################
#################################################
# Completing and validating models
#################################################
# Don't change the next comment - it's used by a literalinclude
# This example illustrates how to validate ``prog_model``
prog_model.validate()
rv = prog_model.validate()
results.append("validate model: '{}'".format(rv))
# TODO: make this work: print(atp_hydrolysis.participants[0].reaction)
# TODO: make this work: print('len(atp_hydrolysis.participants)', len(atp_hydrolysis.participants))
#################################################
# Comparing and differencing models
#################################################
# Don't change the next comment - it's used by a literalinclude
# compare the semantic equality of ``model`` and ``model_from_tsv``
assert(model.is_equal(model_from_tsv) == True)
# Don't change the next comment - it's used by a literalinclude
# produces a textual description of the differences between two models
assert(model.difference(model_from_tsv) == '')
#################################################
# Normalizing models into a reproducible order
#################################################
# Don't change the next comment - it's used by a literalinclude
# The following code excerpt will normalize ``model`` into a reproducible order
model.normalize()
rv = model.normalize()
results.append("normalize model: '{}'".format(rv))
return results
def gen_model(self):
""" Generate this model:
* One compartment, comp
* Two submodels, submodel_synthesis and submodel_degradation
* Two species types
* Two species
* One whose copy number increases at a constant rate, st_constant[comp]
* One whose copy number changes dynamically, st_dynamic[comp]
* Four reactions which produce and consume the dynamically changing species
* In submodel_synthesis
* rxn_synthesis_constant: -> st_constant[comp]; k_syn_constant
* rxn_synthesis_dynamic: -> st_dynamic[comp]; k_syn_dynamic
* In submodel_degradation
* rxn_degradation_constant: st_constant[comp] -> ; k_deg_constant * st_constant[comp]
* rxn_degradation_dynamic: st_dynamic[comp] -> ; k_deg_dynamic * st_dynamic[comp]
* Default values
* k_syn_constant = 0
* k_deg_constant = 0
"""
model = wc_lang.Model(id='model',
version='0.0.1',
wc_lang_version='0.0.1')
# species, compartment and initial concentrations
st_constant = model.species_types.create(
id='st_constant',
structure=wc_lang.ChemicalStructure(charge=0.,
molecular_weight=1.))
st_dynamic = model.species_types.create(
id='st_dynamic',
structure=wc_lang.ChemicalStructure(charge=0.,
molecular_weight=0.))
comp = model.compartments.create(
id='comp', init_volume=wc_lang.InitVolume(std=0.))
spec_constant = model.species.create(species_type=st_constant,
compartment=comp)
spec_dynamic = model.species.create(species_type=st_dynamic,
compartment=comp)
spec_constant.id = spec_constant.gen_id()
spec_dynamic.id = spec_dynamic.gen_id()
conc_constant = model.distribution_init_concentrations.create(
species=spec_constant,
std=0.,
units=unit_registry.parse_units('molecule'))
conc_dynamic = model.distribution_init_concentrations.create(
species=spec_dynamic,
std=0.,
units=unit_registry.parse_units('molecule'))
conc_constant.id = conc_constant.gen_id()
conc_dynamic.id = conc_dynamic.gen_id()
# density and volume
density = comp.init_density = model.parameters.create(
id='density', value=1., units=unit_registry.parse_units('g l^-1'))
volume = model.functions.create(id='volume',
units=unit_registry.parse_units('l'))
volume.expression, error = wc_lang.FunctionExpression.deserialize(
f'{comp.id} / {density.id}', {
wc_lang.Compartment: {
comp.id: comp
},
wc_lang.Parameter: {
density.id: density
}
})
assert error is None, str(error)
# submodels
submdl_syn = model.submodels.create(
id='submodel_synthesis',
framework=onto['WC:stochastic_simulation_algorithm'])
submdl_deg = model.submodels.create(
id='submodel_degradation',
framework=onto['WC:stochastic_simulation_algorithm'])
# reactions
rxn_syn_constant = model.reactions.create(id='rxn_synthesis_constant',
submodel=submdl_syn)
rxn_syn_constant.participants.create(species=spec_constant,
coefficient=1)
rl_syn_constant = model.rate_laws.create(reaction=rxn_syn_constant)
rl_syn_constant.id = rl_syn_constant.gen_id()
k_syn_constant = model.parameters.create(
id='k_syn_constant',
value=0.,
units=unit_registry.parse_units('s^-1'))
rl_syn_constant.expression, error = wc_lang.RateLawExpression.deserialize(
k_syn_constant.id, {
wc_lang.Parameter: {
k_syn_constant.id: k_syn_constant,
},
})
assert error is None, str(error)
rxn_deg_constant = model.reactions.create(
id='rxn_degradation_constant', submodel=submdl_deg)
rxn_deg_constant.participants.create(species=spec_constant,
coefficient=-1)
rl_deg_constant = model.rate_laws.create(reaction=rxn_deg_constant)
rl_deg_constant.id = rl_deg_constant.gen_id()
k_deg_constant = model.parameters.create(
id='k_deg_constant',
value=0.,
units=unit_registry.parse_units('s^-1 molecule^-1'))
rl_deg_constant.expression, error = \
wc_lang.RateLawExpression.deserialize(f'{k_deg_constant.id} * {spec_constant.id}', {
wc_lang.Parameter: {
k_deg_constant.id: k_deg_constant,
},
wc_lang.Species: {
spec_constant.id: spec_constant,
}
})
assert error is None, str(error)
rxn_syn_dynamic = model.reactions.create(id='rxn_synthesis_dynamic',
submodel=submdl_syn)
rxn_syn_dynamic.participants.create(species=spec_dynamic,
coefficient=1)
rl_syn_dynamic = model.rate_laws.create(reaction=rxn_syn_dynamic)
rl_syn_dynamic.id = rl_syn_dynamic.gen_id()
k_syn_dynamic = model.parameters.create(
id='k_syn_dynamic', units=unit_registry.parse_units('s^-1'))
rl_syn_dynamic.expression, error = wc_lang.RateLawExpression.deserialize(
k_syn_dynamic.id, {
wc_lang.Parameter: {
k_syn_dynamic.id: k_syn_dynamic,
},
})
assert error is None, str(error)
rxn_deg_dynamic = model.reactions.create(id='rxn_degradation_dynamic',
submodel=submdl_deg)
rxn_deg_dynamic.participants.create(species=spec_dynamic,
coefficient=-1)
rl_deg_dynamic = model.rate_laws.create(reaction=rxn_deg_dynamic)
rl_deg_dynamic.id = rl_deg_dynamic.gen_id()
k_deg_dynamic = model.parameters.create(
id='k_deg_dynamic',
units=unit_registry.parse_units('s^-1 molecule^-1'))
rl_deg_dynamic.expression, error = \
wc_lang.RateLawExpression.deserialize(f'{k_deg_dynamic.id} * {spec_dynamic.id}', {
wc_lang.Parameter: {
k_deg_dynamic.id: k_deg_dynamic,
},
wc_lang.Species: {
spec_dynamic.id: spec_dynamic,
}
})
assert error is None, str(error)
# other parameter
model.parameters.create(
id='Avogadro',
value=NA,
units=unit_registry.parse_units('molecule mol^-1'))
return model
def setUp(self):
# Create KB content
self.tmp_dirname = tempfile.mkdtemp()
self.sequence_path = os.path.join(self.tmp_dirname, 'test_seq.fasta')
with open(self.sequence_path, 'w') as f:
f.write('>chr1\nTTTATGACTCTAGTTTAT\n'
'>chrM\nTTTatgaCTCTAGTTTAT\n')
self.kb = wc_kb.KnowledgeBase()
cell = self.kb.cell = wc_kb.Cell()
nucleus = cell.compartments.create(id='n')
mito = cell.compartments.create(id='m')
cytoplasm = cell.compartments.create(id='c')
chr1 = wc_kb.core.DnaSpeciesType(cell=cell,
id='chr1',
sequence_path=self.sequence_path)
gene1 = wc_kb.eukaryote.GeneLocus(cell=cell,
id='gene1',
polymer=chr1,
start=1,
end=18)
exon1 = wc_kb.eukaryote.GenericLocus(start=4, end=18)
transcript1 = wc_kb.eukaryote.TranscriptSpeciesType(cell=cell,
id='trans1',
name='transcript1',
gene=gene1,
exons=[exon1])
transcript1_half_life = wc_kb.core.SpeciesTypeProperty(
property='half-life',
species_type=transcript1,
value='36000.0',
value_type=wc_ontology['WC:float'])
transcript1_spec = wc_kb.core.Species(species_type=transcript1,
compartment=cytoplasm)
transcript1_conc = wc_kb.core.Concentration(cell=cell,
species=transcript1_spec,
value=10.)
chrM = wc_kb.core.DnaSpeciesType(cell=cell,
id='chrM',
sequence_path=self.sequence_path)
gene2 = wc_kb.eukaryote.GeneLocus(cell=cell,
id='gene2',
polymer=chrM,
start=1,
end=18)
exon2 = wc_kb.eukaryote.GenericLocus(start=1, end=10)
transcript2 = wc_kb.eukaryote.TranscriptSpeciesType(cell=cell,
id='trans2',
name='transcript2',
gene=gene2,
exons=[exon2])
transcript2_half_life = wc_kb.core.SpeciesTypeProperty(
property='half-life',
species_type=transcript2,
value='15000.0',
value_type=wc_ontology['WC:float'])
transcript2_spec = wc_kb.core.Species(species_type=transcript2,
compartment=mito)
transcript2_conc = wc_kb.core.Concentration(cell=cell,
species=transcript2_spec,
value=10.)
transcript3 = wc_kb.eukaryote.TranscriptSpeciesType(cell=cell,
id='trans3',
name='transcript3',
gene=gene2,
exons=[exon2])
transcript3_half_life = wc_kb.core.SpeciesTypeProperty(
property='half-life',
species_type=transcript3,
value='36000.0',
value_type=wc_ontology['WC:float'])
transcript3_spec = wc_kb.core.Species(species_type=transcript3,
compartment=mito)
transcript3_conc = wc_kb.core.Concentration(cell=cell,
species=transcript3_spec,
value=10.)
transcript4 = wc_kb.eukaryote.TranscriptSpeciesType(cell=cell,
id='trans4',
name='transcript4',
gene=gene2,
exons=[exon2])
transcript4_half_life = wc_kb.core.SpeciesTypeProperty(
property='half-life',
species_type=transcript4,
value='36000.0',
value_type=wc_ontology['WC:float'])
transcript4_spec = wc_kb.core.Species(species_type=transcript4,
compartment=mito)
transcript4_conc = wc_kb.core.Concentration(cell=cell,
species=transcript4_spec,
value=0.)
transcript5 = wc_kb.eukaryote.TranscriptSpeciesType(cell=cell,
id='trans5',
name='transcript5',
gene=gene2)
transcript5_half_life = wc_kb.core.SpeciesTypeProperty(
property='half-life',
species_type=transcript5,
value='36000.0',
value_type=wc_ontology['WC:float'])
transcript5_spec = wc_kb.core.Species(species_type=transcript5,
compartment=mito)
transcript5_conc = wc_kb.core.Concentration(cell=cell,
species=transcript5_spec,
value=0.)
# Create initial model content
self.model = model = wc_lang.Model()
model.parameters.create(
id='Avogadro',
value=scipy.constants.Avogadro,
units=unit_registry.parse_units('molecule mol^-1'))
compartments = {
'n': ('nucleus', 5E-14),
'm': ('mitochondria', 2.5E-14),
'c': ('cytoplasm', 9E-14)
}
for k, v in compartments.items():
init_volume = wc_lang.core.InitVolume(
distribution=wc_ontology['WC:normal_distribution'],
mean=v[1],
std=0)
c = model.compartments.create(id=k,
name=v[0],
init_volume=init_volume)
c.init_density = model.parameters.create(
id='density_' + k,
value=1000,
units=unit_registry.parse_units('g l^-1'))
volume = model.functions.create(
id='volume_' + k, 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)
for i in cell.species_types.get(
__type=wc_kb.eukaryote.TranscriptSpeciesType):
model_species_type = model.species_types.create(id=i.id,
name=i.name)
model_compartment = model.compartments.get_one(
id='m' if 'M' in i.gene.polymer.id else 'c')
model_species = model.species.get_or_create(
species_type=model_species_type, compartment=model_compartment)
model_species.id = model_species.gen_id()
conc_model = model.distribution_init_concentrations.create(
species=model_species,
mean=10.,
units=unit_registry.parse_units('molecule'))
conc_model.id = conc_model.gen_id()
model.distribution_init_concentrations.get_one(
id='dist-init-conc-trans4[m]').mean = 0.
ribo_site_species_type = model.species_types.create(
id='trans2_ribosome_binding_site')
mitochondria = model.compartments.get_one(id='m')
ribo_site_species = model.species.create(
species_type=ribo_site_species_type, compartment=mitochondria)
ribo_site_species.id = ribo_site_species.gen_id()
conc_ribo_site_species = model.distribution_init_concentrations.create(
species=ribo_site_species,
mean=20,
units=unit_registry.parse_units('molecule'))
conc_ribo_site_species.id = conc_ribo_site_species.gen_id()
complexes = {
'complex1': ('Exosome', ['c', 'n']),
'complex2': ('Exosome variant', ['c', 'n']),
'complex3': ('Mitochondrial Exosome', ['m']),
'complex4': ('Mitochondrial Exosome variant', ['m'])
}
for k, v in complexes.items():
model_species_type = model.species_types.get_or_create(id=k,
name=v[0])
for comp in v[1]:
model_compartment = model.compartments.get_one(id=comp)
model_species = model.species.get_or_create(
species_type=model_species_type,
compartment=model_compartment)
model_species.id = model_species.gen_id()
conc_model = model.distribution_init_concentrations.create(
species=model_species,
mean=100.,
units=unit_registry.parse_units('molecule'))
conc_model.id = conc_model.gen_id()
metabolic_participants = ['amp', 'cmp', 'gmp', 'ump', 'h2o', 'h']
for i in metabolic_participants:
model_species_type = model.species_types.create(id=i)
for c in ['n', 'm', 'c']:
model_compartment = model.compartments.get_one(id=c)
model_species = model.species.get_or_create(
species_type=model_species_type,
compartment=model_compartment)
model_species.id = model_species.gen_id()
conc_model = model.distribution_init_concentrations.create(
species=model_species,
mean=1500.,
units=unit_registry.parse_units('molecule'))
conc_model.id = conc_model.gen_id()
def setUp(self):
# Create KB content
self.tmp_dirname = tempfile.mkdtemp()
self.sequence_path = os.path.join(self.tmp_dirname, 'test_seq.fasta')
with open(self.sequence_path, 'w') as f:
f.write('>chr1\nGCGTGCGATGATtgatga\n')
self.kb = wc_kb.KnowledgeBase()
cell = self.kb.cell = wc_kb.Cell()
nucleus = cell.compartments.create(id='n')
mito = cell.compartments.create(id='m')
lysosome = cell.compartments.create(id='l')
membrane = cell.compartments.create(id='c_m')
chr1 = wc_kb.core.DnaSpeciesType(cell=cell, id='chr1', sequence_path=self.sequence_path)
gene1 = wc_kb.eukaryote.GeneLocus(cell=cell, id='gene1', polymer=chr1, start=1, end=18)
locus1 = wc_kb.eukaryote.GenericLocus(start=1, end=6)
transcript1 = wc_kb.eukaryote.TranscriptSpeciesType(cell=cell, gene=gene1, exons=[locus1])
prot1 = wc_kb.eukaryote.ProteinSpeciesType(cell=cell, id='prot1', name='protein1', transcript=transcript1, coding_regions=[locus1])
prot1_half_life = wc_kb.core.SpeciesTypeProperty(property='half-life', species_type=prot1,
value='40000.0', value_type=wc_ontology['WC:float'])
prot1_spec = wc_kb.core.Species(species_type=prot1, compartment=nucleus)
locus2 = wc_kb.eukaryote.GenericLocus(start=4, end=9)
transcript2 = wc_kb.eukaryote.TranscriptSpeciesType(cell=cell, gene=gene1, exons=[locus2])
prot2 = wc_kb.eukaryote.ProteinSpeciesType(cell=cell, id='prot2', name='protein2', transcript=transcript2, coding_regions=[locus2])
prot2_half_life = wc_kb.core.SpeciesTypeProperty(property='half-life', species_type=prot2,
value='20000.0', value_type=wc_ontology['WC:float'])
prot2_spec = wc_kb.core.Species(species_type=prot2, compartment=nucleus)
locus3 = wc_kb.eukaryote.GenericLocus(start=7, end=12)
transcript3 = wc_kb.eukaryote.TranscriptSpeciesType(cell=cell, gene=gene1, exons=[locus3])
prot3 = wc_kb.eukaryote.ProteinSpeciesType(cell=cell, id='prot3', name='protein3', transcript=transcript3, coding_regions=[locus3])
prot3_half_life = wc_kb.core.SpeciesTypeProperty(property='half-life', species_type=prot3,
value='25000.0', value_type=wc_ontology['WC:float'])
prot3_spec1 = wc_kb.core.Species(species_type=prot3, compartment=nucleus)
prot3_spec2 = wc_kb.core.Species(species_type=prot3, compartment=mito)
prot3_spec3 = wc_kb.core.Species(species_type=prot3, compartment=membrane)
locus4 = wc_kb.eukaryote.GenericLocus(start=10, end=18)
transcript4 = wc_kb.eukaryote.TranscriptSpeciesType(cell=cell, gene=gene1, exons=[locus4])
prot4 = wc_kb.eukaryote.ProteinSpeciesType(cell=cell, id='prot4', name='protein4', transcript=transcript4, coding_regions=[locus4])
prot4_half_life = wc_kb.core.SpeciesTypeProperty(property='half-life', species_type=prot4,
value='40000.0', value_type=wc_ontology['WC:float'])
prot4_spec = wc_kb.core.Species(species_type=prot4, compartment=nucleus)
met1 = wc_kb.core.MetaboliteSpeciesType(cell=cell, id='met1', name='metabolite1')
for i in cell.compartments:
met1_species = wc_kb.core.Species(species_type=met1, compartment=i)
complex1 = wc_kb.core.ComplexSpeciesType(cell=cell, id='complex_1', subunits=[
wc_kb.core.SpeciesTypeCoefficient(species_type=prot1, coefficient=1),
wc_kb.core.SpeciesTypeCoefficient(species_type=prot2, coefficient=2),
wc_kb.core.SpeciesTypeCoefficient(species_type=prot3, coefficient=0),
])
complex2 = wc_kb.core.ComplexSpeciesType(cell=cell, id='complex_2', subunits=[
wc_kb.core.SpeciesTypeCoefficient(species_type=prot3, coefficient=2),
wc_kb.core.SpeciesTypeCoefficient(species_type=met1, coefficient=2),
])
complex3 = wc_kb.core.ComplexSpeciesType(cell=cell, id='complex_3', subunits=[
wc_kb.core.SpeciesTypeCoefficient(species_type=prot4, coefficient=2),
])
# Create initial model content
self.model = model = wc_lang.Model()
model.parameters.create(id='Avogadro', value = scipy.constants.Avogadro,
units = unit_registry.parse_units('molecule mol^-1'))
compartments = {'n': ('nucleus', 5E-14), 'm': ('mitochondria', 2.5E-14), 'l': ('lysosome', 2.5E-14), 'c_m': ('membrane', 5E-15)}
for k, v in compartments.items():
init_volume = wc_lang.core.InitVolume(distribution=wc_ontology['WC:normal_distribution'],
mean=v[1], std=0)
c = model.compartments.create(id=k, name=v[0], init_volume=init_volume)
c.init_density = model.parameters.create(id='density_' + k, value=1000,
units=unit_registry.parse_units('g l^-1'))
volume = model.functions.create(id='volume_' + k, 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)
for i in cell.species_types.get(__type=wc_kb.eukaryote.ProteinSpeciesType):
model_species_type = model.species_types.get_or_create(id=i.id, name=i.name, type=wc_ontology['WC:protein'])
model_compartment = model.compartments.get_one(id='n')
model_species = model.species.get_or_create(species_type=model_species_type, compartment=model_compartment)
model_species.id = model_species.gen_id()
conc_model = model.distribution_init_concentrations.get_or_create(species=model_species,
mean=10, units=unit_registry.parse_units('molecule'))
conc_model.id = conc_model.gen_id()
model_species_type = model.species_types.get_or_create(id='prot3', name='protein3', type=wc_ontology['WC:protein'])
model_mito = model.compartments.get_one(id='m')
model_species = model.species.get_or_create(species_type=model_species_type, compartment=model_mito)
model_species.id = model_species.gen_id()
conc_model = model.distribution_init_concentrations.create(species=model_species,
mean=20, units=unit_registry.parse_units('molecule'))
conc_model.id = conc_model.gen_id()
model_membrane = model.compartments.get_one(id='c_m')
model_species = model.species.get_or_create(species_type=model_species_type, compartment=model_membrane)
model_species.id = model_species.gen_id()
conc_model = model.distribution_init_concentrations.create(species=model_species,
mean=20, units=unit_registry.parse_units('molecule'))
conc_model.id = conc_model.gen_id()
model_species_type = model.species_types.get_or_create(id='met1', name='metabolite1', type=wc_ontology['WC:metabolite'])
for compartment in model.compartments:
model_species = model.species.get_or_create(species_type=model_species_type, compartment=compartment)
model_species.id = model_species.gen_id()
for compl in [complex1, complex2, complex3]:
model_species_type = model.species_types.create(id=compl.id, type=wc_ontology['WC:pseudo_species'])
subunit_compartments = [[s.compartment.id for s in sub.species_type.species]
for sub in compl.subunits]
if len(subunit_compartments) == 1:
shared_compartments = set(subunit_compartments[0])
else:
shared_compartments = set([])
for i in range(len(subunit_compartments)):
shared_compartments = (set(subunit_compartments[i])
if i==0 else shared_compartments).intersection(
set(subunit_compartments[i+1]) if i<(len(subunit_compartments)-1) else shared_compartments)
compartment_ids = set(list(shared_compartments))
for compartment_id in compartment_ids:
model_compartment = model.compartments.get_one(id=compartment_id)
model_species = model.species.get_or_create(species_type=model_species_type, compartment=model_compartment)
model_species.id = model_species.gen_id()
metabolic_participants = ['Ala', 'Cys', 'Asp', 'Glu', 'Selcys', 'h2o']
metabolic_compartments = ['l', 'm']
for i in metabolic_participants:
for c in metabolic_compartments:
model_species_type = model.species_types.get_or_create(id=i, type=wc_ontology['WC:metabolite'])
model_compartment = model.compartments.get_one(id=c)
model_species = model.species.get_or_create(species_type=model_species_type, compartment=model_compartment)
model_species.id = model_species.gen_id()
def test_gen_mass_action_rate_law(self):
model = wc_lang.Model()
c = wc_lang.Compartment(id='c',
init_volume=wc_lang.InitVolume(mean=0.5))
c.init_density = wc_lang.Parameter(id='density_' + c.id, value=1.)
kinetic_parameter = wc_lang.Parameter(id='this_parameter', 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)
species_types = {}
species = {}
for i in range(1, 7):
Id = 's' + str(i)
species_types[Id] = wc_lang.SpeciesType(id=Id)
species[Id + '_c'] = wc_lang.Species(
species_type=species_types[Id], compartment=c)
wc_lang.DistributionInitConcentration(species=species[Id + '_c'],
mean=0.5)
Id = 'e'
species_types[Id] = wc_lang.SpeciesType(id=Id)
species[Id + '_c'] = wc_lang.Species(species_type=species_types[Id],
compartment=c)
wc_lang.DistributionInitConcentration(species=species[Id + '_c'],
mean=0.5)
# ob_exp1, error = wc_lang.ObservableExpression.deserialize('s4[c] + s5[c]', {
# wc_lang.Species:{species['s4_c'].gen_id(): species['s4_c'],
# species['s5_c'].gen_id(): species['s5_c']}})
# assert error is None, str(error)
# modifier1 = wc_lang.Observable(id='e1', expression=ob_exp1)
# ob_exp2, error = wc_lang.ObservableExpression.deserialize('2 * s6[c]', {
# wc_lang.Species:{species['s6_c'].gen_id(): species['s6_c']}})
# assert error is None, str(error)
# modifier2 = wc_lang.Observable(id='e2', expression=ob_exp2)
participant1 = wc_lang.SpeciesCoefficient(species=species['s1_c'],
coefficient=-1)
participant2 = wc_lang.SpeciesCoefficient(species=species['s2_c'],
coefficient=-1)
participant3 = wc_lang.SpeciesCoefficient(species=species['s3_c'],
coefficient=1)
participant4 = wc_lang.SpeciesCoefficient(species=species['s4_c'],
coefficient=1)
enzyme_lhs = wc_lang.SpeciesCoefficient(species=species['e_c'],
coefficient=-1)
enzyme_rhs = wc_lang.SpeciesCoefficient(species=species['e_c'],
coefficient=1)
reaction = wc_lang.Reaction(
id='Assosication',
participants=[participant1, participant2, participant3])
rate_law, parameters = utils.gen_mass_action_rate_law(
model, reaction, kinetic_parameter)
self.assertTrue(
rate_law.expression == 'this_parameter * s1[c] * s2[c]'
or rate_law.expression == 'this_parameter * s2[c] * s1[c]')
self.assertEqual(set([i.gen_id() for i in rate_law.species]),
set(['s1[c]', 's2[c]']))
# self.assertEqual(set(rate_law.observables), set([modifier1, modifier2]))
self.assertEqual(set(rate_law.parameters), set(parameters))
# self.assertEqual(rate_law.parameters.get_one(id='k_r1').type, wc_ontology['WC:k_cat'])
self.assertEqual(
rate_law.parameters.get_one(id='this_parameter').units,
unit_registry.parse_units('s^-1 * molecule^-1'))
# self.assertEqual(rate_law.parameters.get_one(id='K_m_r1_s2').type, wc_ontology['WC:K_m'])
# self.assertEqual(rate_law.parameters.get_one(id='K_m_r1_s2').units, unit_registry.parse_units('M'))
reaction = wc_lang.Reaction(
id='Dissociation',
participants=[participant1, participant3, participant4])
rate_law, parameters = utils.gen_mass_action_rate_law(
model, reaction, kinetic_parameter)
self.assertEqual(rate_law.expression, 'this_parameter * s1[c]')
self.assertEqual(set([i.gen_id() for i in rate_law.species]),
set(['s1[c]']))
self.assertEqual(
rate_law.parameters.get_one(id='this_parameter').units,
unit_registry.parse_units('s^-1'))
reaction = wc_lang.Reaction(id='Degradation1',
participants=[participant1])
rate_law, parameters = utils.gen_mass_action_rate_law(
model, reaction, kinetic_parameter)
self.assertEqual(rate_law.expression, 'this_parameter * s1[c]')
self.assertEqual(set([i.gen_id() for i in rate_law.species]),
set(['s1[c]']))
self.assertEqual(
rate_law.parameters.get_one(id='this_parameter').units,
unit_registry.parse_units('s^-1'))
reaction = wc_lang.Reaction(
id='Degradation2',
participants=[participant1, enzyme_lhs, enzyme_rhs])
rate_law, parameters = utils.gen_mass_action_rate_law(
model, reaction, kinetic_parameter)
self.assertTrue(
rate_law.expression, 'this_parameter * s1[c] * e[c]'
or 'this_parameter * e[c] * s1[c]')
self.assertEqual(set([i.gen_id() for i in rate_law.species]),
set(['s1[c]', 'e[c]']))
self.assertEqual(
rate_law.parameters.get_one(id='this_parameter').units,
unit_registry.parse_units('s^-1 * molecule^-1'))
reaction = wc_lang.Reaction(id='Synthesis1',
participants=[participant3])
rate_law, parameters = utils.gen_mass_action_rate_law(
model, reaction, kinetic_parameter)
self.assertEqual(rate_law.expression, 'this_parameter')
self.assertEqual(set([i.gen_id() for i in rate_law.species]), set([]))
self.assertEqual(
rate_law.parameters.get_one(id='this_parameter').units,
unit_registry.parse_units('s^-1 * molecule'))
reaction = wc_lang.Reaction(
id='Synthesis2',
participants=[enzyme_lhs, enzyme_rhs, participant3])
rate_law, parameters = utils.gen_mass_action_rate_law(
model, reaction, kinetic_parameter)
self.assertEqual(rate_law.expression, 'this_parameter * e[c]')
self.assertEqual(set([i.gen_id() for i in rate_law.species]),
set(['e[c]']))
self.assertEqual(
rate_law.parameters.get_one(id='this_parameter').units,
unit_registry.parse_units('s^-1'))
reaction = wc_lang.Reaction(
id='Conversion',
participants=[participant1, enzyme_lhs, enzyme_rhs, participant3]
) # Ask Yin Hoon why I can add as many copies of participant2 as I want.
rate_law, parameters = utils.gen_mass_action_rate_law(
model, reaction, kinetic_parameter)
self.assertTrue(
rate_law.expression == 'this_parameter * s1[c] * e[c]'
or rate_law.expression == 'this_parameter * e[c] * s1[c]')
self.assertEqual(set([i.gen_id() for i in rate_law.species]),
set(['s1[c]', 'e[c]']))
self.assertEqual(
rate_law.parameters.get_one(id='this_parameter').units,
unit_registry.parse_units('s^-1 * molecule^-1'))
def test_gen_response_functions(self):
model = wc_lang.Model()
beta = 2
init_volume = wc_lang.core.InitVolume(
distribution=wc_ontology['WC:normal_distribution'],
mean=0.5,
std=0)
c = wc_lang.Compartment(id='c',
name='cytosol',
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)
reaction = wc_lang.Reaction()
species_types = {}
species = {}
for i in range(1, 5):
Id = 's' + str(i)
species_types[Id] = wc_lang.SpeciesType(
model=model, id=Id, name='species_type_{}'.format(i))
model_species = wc_lang.Species(model=model,
species_type=species_types[Id],
compartment=c)
model_species.id = model_species.gen_id()
species[Id + '_c'] = model_species
wc_lang.DistributionInitConcentration(species=species[Id + '_c'],
mean=0.5)
factors = [['s1', 'species_type_2'], ['s3'], ['species_type_4']]
factor_exp, all_species, all_parameters, all_volumes, all_observables = utils.gen_response_functions(
model, beta, 'reaction_id', 'reaction_class', c, factors)
self.assertEqual(factor_exp, [
'(reaction_class_factors_c_1 / (reaction_class_factors_c_1 + K_m_reaction_class_reaction_class_factors_c_1 * Avogadro * volume_c))',
'(s3[c] / (s3[c] + K_m_reaction_id_s3 * Avogadro * volume_c))',
'(s4[c] / (s4[c] + K_m_reaction_id_s4 * Avogadro * volume_c))'
])
self.assertEqual(
all_species, {
's1[c]': species['s1_c'],
's2[c]': species['s2_c'],
's3[c]': species['s3_c'],
's4[c]': species['s4_c']
})
self.assertEqual(len(all_parameters), 4)
self.assertEqual(all_parameters['Avogadro'].value,
scipy.constants.Avogadro)
self.assertEqual(all_parameters['Avogadro'].units,
unit_registry.parse_units('molecule mol^-1'))
self.assertEqual(
all_parameters['K_m_reaction_class_reaction_class_factors_c_1'].
value, beta * 1. / scipy.constants.Avogadro / c.init_volume.mean)
self.assertEqual(
all_parameters['K_m_reaction_class_reaction_class_factors_c_1'].
comments,
'The value was assumed to be 2 times the value of reaction_class_factors_c_1'
)
self.assertEqual(
all_parameters['K_m_reaction_id_s3'].value,
beta * 0.5 / scipy.constants.Avogadro / c.init_volume.mean)
self.assertEqual(all_parameters['K_m_reaction_id_s4'].type,
wc_ontology['WC:K_m'])
self.assertEqual(all_parameters['K_m_reaction_id_s4'].units,
unit_registry.parse_units('M'))
self.assertEqual(
all_parameters['K_m_reaction_id_s4'].comments,
'The value was assumed to be 2 times the concentration of s4 in cytosol'
)
self.assertEqual(all_volumes, {'volume_c': volume})
self.assertEqual(len(all_observables), 1)
self.assertEqual(len(model.observables), 1)
self.assertEqual(all_observables['reaction_class_factors_c_1'].name,
'factor for reaction_class in cytosol')
self.assertEqual(all_observables['reaction_class_factors_c_1'].units,
unit_registry.parse_units('molecule'))
self.assertEqual(
all_observables['reaction_class_factors_c_1'].expression.
expression, 's1[c] + s2[c]')
for i in range(5, 9):
Id = 's' + str(i)
species_types[Id] = wc_lang.SpeciesType(
model=model, id=Id, name='species_type_{}'.format(i))
model_species = wc_lang.Species(model=model,
species_type=species_types[Id],
compartment=c)
model_species.id = model_species.gen_id()
species[Id + '_c'] = model_species
wc_lang.DistributionInitConcentration(species=species[Id + '_c'],
mean=0.)
factors = [['s5', 'species_type_6'], ['s7'], ['species_type_8']]
factor_exp, all_species, all_parameters, all_volumes, all_observables = utils.gen_response_functions(
model, beta, 'reaction_id', 'reaction_class', c, factors)
self.assertEqual(len(model.observables), 2)
self.assertEqual(
all_parameters['K_m_reaction_class_reaction_class_factors_c_2'].
value, 1e-05)
self.assertEqual(
all_parameters['K_m_reaction_class_reaction_class_factors_c_2'].
comments,
'The value was assigned to 1e-05 because the value of reaction_class_factors_c_2 was zero'
)
self.assertEqual(all_parameters['K_m_reaction_id_s7'].value, 1e-05)
self.assertEqual(
all_parameters['K_m_reaction_id_s8'].comments,
'The value was assigned to 1e-05 because the concentration of s8 in cytosol was zero'
)
factors = [['s5', 'species_type_6']]
factor_exp, all_species, all_parameters, all_volumes, all_observables = utils.gen_response_functions(
model, beta, 'reaction_id2', 'reaction_class2', c, factors)
self.assertEqual(len(model.observables), 2)
self.assertEqual(
all_parameters['K_m_reaction_class2_reaction_class_factors_c_2'].
value, 1e-05)
def test_gen_michaelis_menten_like_propensity_function(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)
species_types = {}
species = {}
for i in range(1, 7):
Id = 's' + str(i)
species_types[Id] = wc_lang.SpeciesType(id=Id)
model_species = wc_lang.Species(species_type=species_types[Id],
compartment=c)
model_species.id = model_species.gen_id()
species[Id + '_c'] = model_species
wc_lang.DistributionInitConcentration(species=species[Id + '_c'],
mean=0.5)
participant1 = wc_lang.SpeciesCoefficient(species=species['s1_c'],
coefficient=-1)
participant2 = wc_lang.SpeciesCoefficient(species=species['s2_c'],
coefficient=-1)
participant3 = wc_lang.SpeciesCoefficient(species=species['s3_c'],
coefficient=-1)
participant4 = wc_lang.SpeciesCoefficient(species=species['s4_c'],
coefficient=-1)
participant5 = wc_lang.SpeciesCoefficient(species=species['s5_c'],
coefficient=1)
participant6 = wc_lang.SpeciesCoefficient(species=species['s6_c'],
coefficient=1)
reaction = wc_lang.Reaction(id='r1',
participants=[
participant1, participant2,
participant3, participant4,
participant5, participant6
])
with self.assertRaises(ValueError):
rate_law1, parameters = utils.gen_michaelis_menten_like_propensity_function(
model, reaction)
rate_law2, parameters = utils.gen_michaelis_menten_like_propensity_function(
model, reaction, substrates_as_modifiers=[species['s3_c']])
self.assertEqual(
rate_law2.expression, 'k_cat_r1 * s3[c] * '
'(s1[c] / (s1[c] + K_m_r1_s1 * Avogadro * volume_c)) * '
'(s2[c] / (s2[c] + K_m_r1_s2 * Avogadro * volume_c)) * '
'(s4[c] / (s4[c] + K_m_r1_s4 * Avogadro * volume_c))')
self.assertEqual(set([i.gen_id() for i in rate_law2.species]),
set(['s1[c]', 's2[c]', 's3[c]', 's4[c]']))
self.assertEqual(set(rate_law2.parameters), set(parameters))
self.assertEqual(
rate_law2.parameters.get_one(id='k_cat_r1').type,
wc_ontology['WC:k_cat'])
self.assertEqual(
rate_law2.parameters.get_one(id='k_cat_r1').units,
unit_registry.parse_units('s^-1 molecule^-1'))
self.assertEqual(
rate_law2.parameters.get_one(id='K_m_r1_s2').type,
wc_ontology['WC:K_m'])
self.assertEqual(
rate_law2.parameters.get_one(id='K_m_r1_s2').units,
unit_registry.parse_units('M'))
rate_law3, parameters = utils.gen_michaelis_menten_like_propensity_function(
model,
reaction,
substrates_as_modifiers=[species['s3_c']],
exclude_substrates=[species['s1_c']])
self.assertEqual(
rate_law3.expression, 'k_cat_r1 * s3[c] * '
'(s2[c] / (s2[c] + K_m_r1_s2 * Avogadro * volume_c)) * '
'(s4[c] / (s4[c] + K_m_r1_s4 * Avogadro * volume_c))')
self.assertEqual(set([i.gen_id() for i in rate_law3.species]),
set(['s2[c]', 's3[c]', 's4[c]']))
self.assertEqual(set(rate_law3.parameters), set(parameters))
def test_test_metabolite_production(self):
model = wc_lang.Model()
submodel = wc_lang.Submodel(model=model, id='metabolism')
compartment = model.compartments.create(id='c')
for i in ['o2', 'h2o', 'atp']:
st = model.species_types.create(id=i)
species = model.species.create(species_type=st,
compartment=compartment)
species.id = species.gen_id()
R1 = model.reactions.create(submodel=submodel, id='Ex_o2')
R1.participants.add(
model.species.get_one(
id='o2[c]').species_coefficients.get_or_create(
coefficient=1.0))
R2 = model.reactions.create(submodel=submodel, id='Ex_h2o')
R2.participants.add(
model.species.get_one(
id='h2o[c]').species_coefficients.get_or_create(
coefficient=1.0))
R3 = model.reactions.create(submodel=submodel, id='Ex_atp')
R3.participants.add(
model.species.get_one(
id='atp[c]').species_coefficients.get_or_create(
coefficient=-1.0))
biomass_reaction = model.reactions.create(submodel=submodel,
id='biomass_reaction')
biomass_reaction.participants.add(
model.species.get_one(
id='o2[c]').species_coefficients.get_or_create(
coefficient=-1.0))
biomass_reaction.participants.add(
model.species.get_one(
id='h2o[c]').species_coefficients.get_or_create(
coefficient=-1.0))
biomass_reaction.participants.add(
model.species.get_one(
id='atp[c]').species_coefficients.get_or_create(
coefficient=1.0))
submodel.dfba_obj = wc_lang.DfbaObjective(model=model)
submodel.dfba_obj.id = submodel.dfba_obj.gen_id()
obj_expression = biomass_reaction.id
dfba_obj_expression, error = wc_lang.DfbaObjectiveExpression.deserialize(
obj_expression,
{wc_lang.Reaction: {
biomass_reaction.id: biomass_reaction
}})
assert error is None, str(error)
submodel.dfba_obj.expression = dfba_obj_expression
reaction_bounds = {i.id: (0., 1000.) for i in model.reactions}
unproducibles, unrecyclables = utils.test_metabolite_production(
submodel, reaction_bounds, pseudo_reactions=['biomass_reaction'])
self.assertEqual(unproducibles, [])
self.assertEqual(unrecyclables, [])
unproducibles, unrecyclables = utils.test_metabolite_production(
submodel, reaction_bounds)
self.assertEqual(unproducibles, [])
self.assertEqual(unrecyclables, [])
mock1 = model.species.create(id='mock1')
mock2 = model.species.create(id='mock2')
biomass_reaction.participants.add(
mock1.species_coefficients.get_or_create(coefficient=1.0))
biomass_reaction.participants.add(
mock2.species_coefficients.get_or_create(coefficient=-1.0))
unproducibles, unrecyclables = utils.test_metabolite_production(
submodel, reaction_bounds)
self.assertEqual(unproducibles, ['mock2'])
self.assertEqual(unrecyclables, ['mock1'])
unproducibles, unrecyclables = utils.test_metabolite_production(
submodel,
reaction_bounds,
pseudo_reactions=['biomass_reaction'],
test_producibles=['mock1'],
test_recyclables=['mock2'])
self.assertEqual(unproducibles, ['mock1'])
self.assertEqual(unrecyclables, ['mock2'])
unproducibles, unrecyclables = utils.test_metabolite_production(
submodel,
reaction_bounds,
test_producibles=['mock1'],
test_recyclables=['mock2'])
self.assertEqual(unproducibles, [])
self.assertEqual(unrecyclables, [])
R4 = model.reactions.create(submodel=submodel, id='Ex_mock1')
R4.participants.add(
mock1.species_coefficients.get_or_create(coefficient=-1.0))
R5 = model.reactions.create(submodel=submodel, id='Ex_mock2')
R5.participants.add(
mock2.species_coefficients.get_or_create(coefficient=1.0))
reaction_bounds = {i.id: (0., 1000.) for i in model.reactions}
unproducibles, unrecyclables = utils.test_metabolite_production(
submodel, reaction_bounds)
self.assertEqual(unproducibles, [])
self.assertEqual(unrecyclables, [])
def test_gen_michaelis_menten_like_rate_law(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)
species_types = {}
species = {}
for i in range(1, 7):
Id = 's' + str(i)
species_types[Id] = wc_lang.SpeciesType(id=Id)
species[Id + '_c'] = wc_lang.Species(
species_type=species_types[Id], compartment=c)
wc_lang.DistributionInitConcentration(species=species[Id + '_c'],
mean=0.5)
ob_exp1, error = wc_lang.ObservableExpression.deserialize(
's4[c] + s5[c]', {
wc_lang.Species: {
species['s4_c'].gen_id(): species['s4_c'],
species['s5_c'].gen_id(): species['s5_c']
}
})
assert error is None, str(error)
modifier1 = wc_lang.Observable(id='e1', expression=ob_exp1)
ob_exp2, error = wc_lang.ObservableExpression.deserialize(
'2 * s6[c]',
{wc_lang.Species: {
species['s6_c'].gen_id(): species['s6_c']
}})
assert error is None, str(error)
modifier2 = wc_lang.Observable(id='e2', expression=ob_exp2)
participant1 = wc_lang.SpeciesCoefficient(species=species['s1_c'],
coefficient=-1)
participant2 = wc_lang.SpeciesCoefficient(species=species['s2_c'],
coefficient=-1)
participant3 = wc_lang.SpeciesCoefficient(species=species['s3_c'],
coefficient=1)
participant4 = wc_lang.SpeciesCoefficient(species=species['s4_c'],
coefficient=-1)
participant5 = wc_lang.SpeciesCoefficient(species=species['s4_c'],
coefficient=1)
participant6 = wc_lang.SpeciesCoefficient(species=species['s6_c'],
coefficient=-1)
participant7 = wc_lang.SpeciesCoefficient(species=species['s6_c'],
coefficient=-1)
participant8 = wc_lang.SpeciesCoefficient(species=species['s6_c'],
coefficient=1)
reaction = wc_lang.Reaction(id='r1',
participants=[
participant1, participant2,
participant3, participant4,
participant5, participant6,
participant7, participant8
])
rate_law, parameters = utils.gen_michaelis_menten_like_rate_law(
model,
reaction,
modifiers=[modifier1, modifier2],
modifier_reactants=[species['s6_c']])
self.assertEqual(
rate_law.expression, 'k_cat_r1 * e1 * e2 * '
'(s1[c] / (s1[c] + K_m_r1_s1 * Avogadro * volume_c)) * '
'(s2[c] / (s2[c] + K_m_r1_s2 * Avogadro * volume_c)) * '
'(s6[c] / (s6[c] + K_m_r1_s6 * Avogadro * volume_c))')
self.assertEqual(set([i.gen_id() for i in rate_law.species]),
set(['s1[c]', 's2[c]', 's6[c]']))
self.assertEqual(set(rate_law.observables), set([modifier1,
modifier2]))
self.assertEqual(set(rate_law.parameters), set(parameters))
self.assertEqual(
rate_law.parameters.get_one(id='k_cat_r1').type,
wc_ontology['WC:k_cat'])
self.assertEqual(
rate_law.parameters.get_one(id='k_cat_r1').units,
unit_registry.parse_units('s^-1 molecule^-2'))
self.assertEqual(
rate_law.parameters.get_one(id='K_m_r1_s2').type,
wc_ontology['WC:K_m'])
self.assertEqual(
rate_law.parameters.get_one(id='K_m_r1_s2').units,
unit_registry.parse_units('M'))
reaction = wc_lang.Reaction(id='r1',
participants=[
participant1, participant2,
participant4, participant8
])
rate_law, parameters = utils.gen_michaelis_menten_like_rate_law(
model, reaction)
self.assertEqual(
rate_law.expression, 'k_cat_r1 * '
'(s1[c] / (s1[c] + K_m_r1_s1 * Avogadro * volume_c)) * '
'(s2[c] / (s2[c] + K_m_r1_s2 * Avogadro * volume_c)) * '
'(s4[c] / (s4[c] + K_m_r1_s4 * Avogadro * volume_c))')
reaction = wc_lang.Reaction(id='r1', participants=[participant3])
rate_law, parameters = utils.gen_michaelis_menten_like_rate_law(
model, reaction)
self.assertEqual(rate_law.expression, 'k_cat_r1')
reaction = wc_lang.Reaction(id='r1',
participants=[participant3, participant6])
rate_law, parameters = utils.gen_michaelis_menten_like_rate_law(
model, reaction, modifiers=[modifier1, species['s6_c']])
self.assertEqual(rate_law.expression, 'k_cat_r1 * e1 * s6[c]')
reaction = wc_lang.Reaction(id='r1',
participants=[
participant1, participant2,
participant4, participant8
])
rate_law, parameters = utils.gen_michaelis_menten_like_rate_law(
model, reaction, exclude_substrates=[species['s1_c']])
self.assertEqual(
rate_law.expression, 'k_cat_r1 * '
'(s2[c] / (s2[c] + K_m_r1_s2 * Avogadro * volume_c)) * '
'(s4[c] / (s4[c] + K_m_r1_s4 * Avogadro * volume_c))')
with self.assertRaises(TypeError) as ctx:
rate_law, parameters = utils.gen_michaelis_menten_like_rate_law(
model, reaction, modifiers=['s6_c'])
self.assertEqual(
'The modifiers contain element(s) that is not an observable or a species',
str(ctx.exception))
def setUp(self):
# Create KB content
self.tmp_dirname = tempfile.mkdtemp()
self.sequence_path = os.path.join(self.tmp_dirname, 'test_seq.fasta')
with open(self.sequence_path, 'w') as f:
f.write('>chr1\nATGCATGACTCTAGTTTAT\n'
'>chrM\nTTTatgaCTCTAGTTTACNNN\n')
self.kb = wc_kb.KnowledgeBase()
cell = self.kb.cell = wc_kb.Cell()
nucleus = cell.compartments.create(id='n')
mito = cell.compartments.create(id='m')
cytoplasm = cell.compartments.create(id='c')
chr1 = wc_kb.core.DnaSpeciesType(cell=cell,
id='chr1',
sequence_path=self.sequence_path)
gene1 = wc_kb.eukaryote.GeneLocus(cell=cell,
id='gene1',
polymer=chr1,
start=1,
end=19)
exon1 = wc_kb.eukaryote.GenericLocus(start=5, end=19)
transcript1 = wc_kb.eukaryote.TranscriptSpeciesType(
cell=cell,
id='trans1',
name='transcript1',
gene=gene1,
exons=[exon1],
type=wc_kb.eukaryote.TranscriptType.mRna)
transcript1_half_life = wc_kb.core.SpeciesTypeProperty(
property='half-life',
species_type=transcript1,
value='36000.0',
value_type=wc_ontology['WC:float'])
transcript1_spec = wc_kb.core.Species(species_type=transcript1,
compartment=cytoplasm)
transcript1_conc = wc_kb.core.Concentration(cell=cell,
species=transcript1_spec,
value=10.)
chrM = wc_kb.core.DnaSpeciesType(cell=cell,
id='chrM',
sequence_path=self.sequence_path)
gene2 = wc_kb.eukaryote.GeneLocus(cell=cell,
id='gene2',
polymer=chrM,
start=1,
end=19)
exon2 = wc_kb.eukaryote.GenericLocus(start=1, end=10)
transcript2 = wc_kb.eukaryote.TranscriptSpeciesType(
cell=cell,
id='trans2',
name='transcript2',
gene=gene2,
exons=[exon2],
type=wc_kb.eukaryote.TranscriptType.mRna)
transcript2_half_life = wc_kb.core.SpeciesTypeProperty(
property='half-life',
species_type=transcript2,
value='15000.0',
value_type=wc_ontology['WC:float'])
transcript2_spec = wc_kb.core.Species(species_type=transcript2,
compartment=mito)
transcript2_conc = wc_kb.core.Concentration(cell=cell,
species=transcript2_spec,
value=10.)
gene3 = wc_kb.eukaryote.GeneLocus(cell=cell,
id='gene3',
polymer=chr1,
start=1,
end=19)
exon3 = wc_kb.eukaryote.GenericLocus(start=1, end=15)
transcript3 = wc_kb.eukaryote.TranscriptSpeciesType(cell=cell,
id='trans3',
name='transcript3',
gene=gene3,
exons=[exon3])
transcript3_half_life = wc_kb.core.SpeciesTypeProperty(
property='half-life',
species_type=transcript3,
value='36000.0',
value_type=wc_ontology['WC:float'])
transcript3_spec = wc_kb.core.Species(species_type=transcript3,
compartment=cytoplasm)
transcript3_conc = wc_kb.core.Concentration(cell=cell,
species=transcript3_spec,
value=10.)
gene4 = wc_kb.eukaryote.GeneLocus(cell=cell,
id='gene4',
polymer=chr1,
start=1,
end=3)
exon4 = wc_kb.eukaryote.GenericLocus(start=1, end=3)
transcript4 = wc_kb.eukaryote.TranscriptSpeciesType(cell=cell,
id='trans4',
name='transcript4',
gene=gene4,
exons=[exon4])
transcript4_half_life = wc_kb.core.SpeciesTypeProperty(
property='half-life',
species_type=transcript4,
value='36000.0',
value_type=wc_ontology['WC:float'])
transcript4_spec = wc_kb.core.Species(species_type=transcript4,
compartment=cytoplasm)
transcript4_conc = wc_kb.core.Concentration(cell=cell,
species=transcript4_spec,
value=10.)
gene5 = wc_kb.eukaryote.GeneLocus(cell=cell,
id='gene5',
polymer=chr1,
start=1,
end=3)
exon5 = wc_kb.eukaryote.GenericLocus(start=1, end=3)
transcript5 = wc_kb.eukaryote.TranscriptSpeciesType(cell=cell,
id='trans5',
name='transcript5',
gene=gene5,
exons=[exon5])
transcript5_half_life = wc_kb.core.SpeciesTypeProperty(
property='half-life',
species_type=transcript5,
value='36000.0',
value_type=wc_ontology['WC:float'])
transcript5_spec = wc_kb.core.Species(species_type=transcript5,
compartment=cytoplasm)
transcript5_conc = wc_kb.core.Concentration(cell=cell,
species=transcript5_spec,
value=0.)
gene6 = wc_kb.eukaryote.GeneLocus(cell=cell,
id='gene6',
polymer=chr1,
start=1,
end=3)
exon6 = wc_kb.eukaryote.GenericLocus(start=1, end=3)
transcript6 = wc_kb.eukaryote.TranscriptSpeciesType(cell=cell,
id='trans6',
name='transcript6',
gene=gene6,
exons=[exon6])
transcript6_half_life = wc_kb.core.SpeciesTypeProperty(
property='half-life',
species_type=transcript6,
value='36000.0',
value_type=wc_ontology['WC:float'])
transcript6_spec = wc_kb.core.Species(species_type=transcript6,
compartment=cytoplasm)
transcript6_conc = wc_kb.core.Concentration(cell=cell,
species=transcript6_spec,
value=0.)
transcript7 = wc_kb.eukaryote.TranscriptSpeciesType(
cell=cell,
id='trans7',
name='transcript7',
gene=gene6,
type=wc_kb.eukaryote.TranscriptType.mRna)
transcript7_spec = wc_kb.core.Species(species_type=transcript7,
compartment=cytoplasm)
transcript7_conc = wc_kb.core.Concentration(cell=cell,
species=transcript7_spec,
value=10.)
transcript8 = wc_kb.eukaryote.TranscriptSpeciesType(cell=cell,
id='trans8',
name='transcript8',
gene=gene6)
activator = wc_kb.eukaryote.ProteinSpeciesType(cell=cell,
id='activator')
repressor = wc_kb.eukaryote.ProteinSpeciesType(cell=cell,
id='repressor')
gene2_reg1 = gene2.regulatory_modules.create(
transcription_factor_regulation=[
wc_kb.eukaryote.TranscriptionFactorRegulation(
transcription_factor=activator,
direction=wc_kb.eukaryote.RegulatoryDirection.activation)
])
gene2_reg2 = gene2.regulatory_modules.create(
transcription_factor_regulation=[
wc_kb.eukaryote.TranscriptionFactorRegulation(
transcription_factor=repressor,
direction=wc_kb.eukaryote.RegulatoryDirection.repression)
])
activator2 = wc_kb.eukaryote.ProteinSpeciesType(cell=cell,
id='activator2')
repressor2 = wc_kb.eukaryote.ProteinSpeciesType(cell=cell,
id='repressor2')
gene6_reg1 = gene6.regulatory_modules.create(
transcription_factor_regulation=[
wc_kb.eukaryote.TranscriptionFactorRegulation(
transcription_factor=activator2,
direction=wc_kb.eukaryote.RegulatoryDirection.activation)
])
gene6_reg2 = gene6.regulatory_modules.create(
transcription_factor_regulation=[
wc_kb.eukaryote.TranscriptionFactorRegulation(
transcription_factor=repressor2,
direction=wc_kb.eukaryote.RegulatoryDirection.repression)
])
# Create initial model content
self.model = model = wc_lang.Model()
model.parameters.create(id='mean_doubling_time',
value=20 * 3600,
units=unit_registry.parse_units('s'))
model.parameters.create(
id='Avogadro',
value=scipy.constants.Avogadro,
units=unit_registry.parse_units('molecule mol^-1'))
compartments = {
'n': ('nucleus', 5E-14),
'm': ('mitochondria', 2.5E-14),
'c': ('cytoplasm', 1E-13)
}
for k, v in compartments.items():
init_volume = wc_lang.core.InitVolume(
distribution=wc_ontology['WC:normal_distribution'],
mean=v[1],
std=0)
c = model.compartments.create(id=k,
name=v[0],
init_volume=init_volume)
c.init_density = model.parameters.create(
id='density_' + k,
value=1000,
units=unit_registry.parse_units('g l^-1'))
volume = model.functions.create(
id='volume_' + k, 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)
for i in cell.species_types.get(
__type=wc_kb.eukaryote.TranscriptSpeciesType):
model_species_type = model.species_types.create(id=i.id)
model_compartment = model.compartments.get_one(
id='m' if 'M' in i.gene.polymer.id else 'c')
model_species = model.species.get_or_create(
species_type=model_species_type, compartment=model_compartment)
model_species.id = model_species.gen_id()
conc_model = model.distribution_init_concentrations.create(
species=model_species,
mean=10,
units=unit_registry.parse_units('molecule'))
conc_model.id = conc_model.gen_id()
model.distribution_init_concentrations.get_one(
id='dist-init-conc-trans5[c]').mean = 0.
complexes = {
'complex1': ('RNA Polymerase I', 'n'),
'complex2': ('RNA Polymerase II', 'n'),
'complex3': ('RNA Polymerase mitochondria', 'm'),
'complex4': ('RNA Polymerase III', 'n')
}
for k, v in complexes.items():
model_species_type = model.species_types.create(
id=k,
name=v[0],
structure=wc_lang.ChemicalStructure(
empirical_formula=EmpiricalFormula('H'),
molecular_weight=1.018,
charge=1))
model_compartment = model.compartments.get_one(id=v[1])
model_species = model.species.get_or_create(
species_type=model_species_type, compartment=model_compartment)
model_species.id = model_species.gen_id()
conc_model = model.distribution_init_concentrations.create(
species=model_species,
mean=2500 if k == 'complex2' else 100,
units=unit_registry.parse_units('molecule'))
conc_model.id = conc_model.gen_id()
metabolic_participants = [
'atp', 'ctp', 'gtp', 'utp', 'ppi', 'amp', 'cmp', 'gmp', 'ump',
'h2o', 'h', 'adp', 'pi'
]
for i in metabolic_participants:
model_species_type = model.species_types.create(id=i,
name=i.upper())
for c in ['n', 'm']:
model_compartment = model.compartments.get_one(id=c)
model_species = model.species.get_or_create(
species_type=model_species_type,
compartment=model_compartment)
model_species.id = model_species.gen_id()
conc_model = model.distribution_init_concentrations.create(
species=model_species,
mean=1500,
units=unit_registry.parse_units('molecule'))
conc_model.id = conc_model.gen_id()
for i in ['activator', 'repressor']:
model_species_type = model.species_types.create(id=i,
name=i.upper())
model_compartment = model.compartments.get_one(id='m')
model_species = model.species.get_or_create(
species_type=model_species_type, compartment=model_compartment)
model_species.id = model_species.gen_id()
conc_model = model.distribution_init_concentrations.create(
species=model_species,
mean=3,
units=unit_registry.parse_units('molecule'))
conc_model.id = conc_model.gen_id()
for i in ['activator2', 'repressor2']:
model_species_type = model.species_types.create(id=i,
name=i.upper())
model_compartment = model.compartments.get_one(id='n')
model_species = model.species.get_or_create(
species_type=model_species_type, compartment=model_compartment)
model_species.id = model_species.gen_id()
conc_model = model.distribution_init_concentrations.create(
species=model_species,
mean=0,
units=unit_registry.parse_units('molecule'))
conc_model.id = conc_model.gen_id()
factors = [
'pol1_init_factor1', 'pol1_el_factor1', 'pol2_init_factor1',
'pol2_el_factor1', 'pol2_neg_factor1', 'pol3_init_factor1',
'pol3_el_factor1', 'polm_init_factor1', 'polm_el_factor1'
]
for i in factors:
model_species_type = model.species_types.create(id=i,
name=i.upper())
model_compartment = model.compartments.get_one(
id='m' if 'polm' in i else 'n')
model_species = model.species.get_or_create(
species_type=model_species_type, compartment=model_compartment)
model_species.id = model_species.gen_id()
conc_model = model.distribution_init_concentrations.create(
species=model_species,
mean=2,
units=unit_registry.parse_units('molecule'))
conc_model.id = conc_model.gen_id()
def test_sample_copy_num_from_concentration(self):
model = wc_lang.Model()
submodel = model.submodels.create(
id='submodel',
framework=onto['WC:stochastic_simulation_algorithm'])
compartment_c = model.compartments.create(
id='c', init_volume=wc_lang.InitVolume(mean=1.))
structure = wc_lang.ChemicalStructure(molecular_weight=10.)
species_types = {}
cus_species_types = {}
for cu in wc_lang.DistributionInitConcentration.units.choices:
id = str(cu).replace(' ', '_')
species_types[id] = model.species_types.create(id=id,
structure=structure)
cus_species_types[id] = cu
for other in ['no_units', 'no_concentration', 'no_std']:
species_types[other] = model.species_types.create(
id=other, structure=structure)
species = {}
for key, species_type in species_types.items():
species[key] = wc_lang.Species(species_type=species_type,
compartment=compartment_c)
species[key].id = species[key].gen_id()
conc_value = 2_000.
std_value = 0.
for key, sp in species.items():
if key in cus_species_types:
wc_lang.DistributionInitConcentration(
species=sp,
mean=conc_value,
std=std_value,
units=cus_species_types[key])
elif key == 'no_units':
wc_lang.DistributionInitConcentration(species=sp,
mean=conc_value,
std=std_value)
elif key == 'no_std':
wc_lang.DistributionInitConcentration(
species=sp,
mean=conc_value,
std=float('NaN'),
units=cus_species_types['molecule'])
elif key == 'no_concentration':
continue
conc_to_molecules = ModelUtilities.sample_copy_num_from_concentration
random_state = numpy.random.RandomState()
copy_number = conc_to_molecules(
species['molecule'],
species['molecule'].compartment.init_volume.mean, random_state)
self.assertEqual(copy_number, conc_value)
copy_number = conc_to_molecules(
species['molar'], species['molar'].compartment.init_volume.mean,
random_state)
self.assertEqual(copy_number, conc_value * Avogadro)
copy_number = conc_to_molecules(
species['no_units'],
species['no_units'].compartment.init_volume.mean, random_state)
self.assertEqual(copy_number, conc_value * Avogadro)
copy_number = conc_to_molecules(
species['millimolar'],
species['millimolar'].compartment.init_volume.mean, random_state)
self.assertEqual(copy_number, 10**-3 * conc_value * Avogadro)
copy_number = conc_to_molecules(
species['micromolar'],
species['micromolar'].compartment.init_volume.mean, random_state)
self.assertEqual(copy_number, 10**-6 * conc_value * Avogadro)
copy_number = conc_to_molecules(
species['nanomolar'],
species['nanomolar'].compartment.init_volume.mean, random_state)
self.assertEqual(copy_number, 10**-9 * conc_value * Avogadro)
copy_number = conc_to_molecules(
species['picomolar'],
species['picomolar'].compartment.init_volume.mean, random_state)
self.assertEqual(copy_number, 10**-12 * conc_value * Avogadro)
copy_number = conc_to_molecules(
species['femtomolar'],
species['femtomolar'].compartment.init_volume.mean, random_state)
self.assertAlmostEqual(copy_number,
10**-15 * conc_value * Avogadro,
delta=1)
copy_number = conc_to_molecules(
species['attomolar'],
species['attomolar'].compartment.init_volume.mean, random_state)
self.assertAlmostEqual(copy_number,
10**-18 * conc_value * Avogadro,
delta=1)
copy_number = conc_to_molecules(
species['no_concentration'],
species['no_concentration'].compartment.init_volume.mean,
random_state)
self.assertEqual(copy_number, 0)
conc = species['no_std'].distribution_init_concentration
copy_number = conc_to_molecules(
species['no_std'], species['no_std'].compartment.init_volume.mean,
random_state)
self.assertNotEqual(copy_number, conc_value)
with self.assertRaises(KeyError):
conc_to_molecules(
species['mol dm^-2'],
species['no_concentration'].compartment.init_volume.mean,
random_state)
species_tmp = wc_lang.Species(species_type=species_type,
compartment=compartment_c)
species_tmp.id = species_tmp.gen_id()
wc_lang.DistributionInitConcentration(
species=species_tmp,
mean=conc_value,
std=std_value,
units='not type(unit_registry.Unit)')
with self.assertRaisesRegex(ValueError, 'Unsupported unit type'):
conc_to_molecules(species_tmp,
species_tmp.compartment.init_volume.mean,
random_state)
species_tmp2 = wc_lang.Species(species_type=species_type,
compartment=compartment_c)
species_tmp2.id = species_tmp2.gen_id()
wc_lang.DistributionInitConcentration(
species=species_tmp2,
mean=conc_value,
std=std_value,
units=wc_lang.InitVolume.units.choices[0])
with self.assertRaisesRegex(ValueError, 'Unsupported unit'):
conc_to_molecules(species_tmp2,
species_tmp2.compartment.init_volume.mean,
random_state)
