def print_gene_product_association(file_name):
doc = libsbml.readSBMLFromFile(file_name)
assert (isinstance(doc, libsbml.SBMLDocument))
if doc.getNumErrors(libsbml.LIBSBML_SEV_ERROR) > 0:
print("There were errors while reading, better to fix those first")
doc.printErrors()
sys.exit(1)
model = doc.getModel()
if model is None:
print("document has no model, bailing")
num_reactions = model.getNumReactions()
print(" Model: %s" % model.getName())
print("# reactions: %d" % num_reactions)
for reaction in model.getListOfReactions():
print(" Reaction: %s" % reaction.getId())
plugin = reaction.getPlugin('fbc')
if plugin is None:
# not relevant for us
continue
if not plugin.isSetGeneProductAssociation():
continue
gpa = plugin.getGeneProductAssociation()
association = gpa.getAssociation()
print (" Association: %s" % association.toInfix())
print("done")
def list_ports(model_path):
"""
:param model_path: path to sbml model
:return:
"""
""" List the ports in the given model.
:return:
"""
if not os.path.exists(model_path):
raise IOError("SBML path does not exist.")
doc = libsbml.readSBMLFromFile(model_path) # type: libsbml.SBMLDocument
model = doc.getModel() # type: libsbml.Model
model_comp = model.getPlugin("comp") # type: libsbml.CompModelPlugin
print(model_comp)
for port in model_comp.getListOfPorts(): # type: libsbml.Port
print("\tPort: ",
port.getId(),
port.getMetaId(),
port.getIdRef(),
port.getMetaIdRef(),
port.getUnitRef(),
port.getPortRef())
def renameSId (filename, oldSId, newSId, output_file):
if oldSId == newSId:
print("The Ids are identical, renaming stopped.")
return
if not libsbml.SyntaxChecker.isValidInternalSId(newSId):
print("The new SId '{0}' does not represent a valid SId.".format(newSId))
return
document = libsbml.readSBMLFromFile(filename)
errors = document.getNumErrors(libsbml.LIBSBML_SEV_ERROR)
if errors > 0:
document.printErrors()
return
# find elements for old id
element = document.getElementBySId(oldSId)
if element == None:
print("Found no element with SId '{0}'".format(oldSId))
return
# found element -> renaming
element.setId(newSId)
# update all references to this element
allElements = document.getListOfAllElements()
for i in range(allElements.getSize()):
allElements.get(i).renameSIdRefs(oldSId, newSId)
# write to file
libsbml.writeSBMLToFile(document, output_file)
def simulate_toy_model(tend=50.0, step_size=0.1):
# Run simulation of the hybrid model
from simsettings import top_level_file, flattened_file, out_dir
import os
os.chdir(out_dir)
df = simulate(mixed_sbml=top_level_file, tend=tend, step_size=step_size, debug=True)
# create plots (use ids from flattened model for plotting)
import libsbml
flat_doc = libsbml.readSBMLFromFile(flattened_file)
flat_model = flat_doc.getModel()
reaction_ids = [r.getId() for r in flat_model.getListOfReactions()]
species_ids = ["[{}]".format(s.getId()) for s in flat_model.getListOfSpecies()]
# plot reactions
print(reaction_ids)
ax_r = df.plot(x='time', y=reaction_ids + ['vR3'])
fig = ax_r.get_figure()
fig.savefig('reactions.png')
# plot species
print(species_ids)
ax_s = df.plot(x='time', y=species_ids)
fig = ax_s.get_figure()
fig.savefig('species.png')
df.to_csv("simulation.csv", sep="\t")
def main (args):
"""
Usage: printRenderInformation <input file>
prints a summary of the render information object.
"""
if (len(args) != 2):
print(main.__doc__)
return 1
inputFile = args[1];
doc = libsbml.readSBMLFromFile(inputFile)
print("Using libSBML: {0} supporting packages for:".format(libsbml.getLibSBMLDottedVersion()))
for i in range (libsbml.SBMLExtensionRegistry.getNumRegisteredPackages()):
print("\t" + libsbml.SBMLExtensionRegistry.getRegisteredPackageName(i))
print("\nThe document is: level {0}, version {1}".format(doc.getLevel(), doc.getVersion()))
for i in range(doc.getNumPlugins()):
print(" doc uses package: {0}".format(doc.getPlugin(i).getElementNamespace()))
print("\n")
numErrors = doc.getNumErrors(libsbml.LIBSBML_SEV_ERROR)
if numErrors > 0:
print("Encountered errors while reading the file. ")
print("Please correct the following errors and try again.")
doc.printErrors()
return 2
model = doc.getModel()
plugin = model.getPlugin("layout")
if plugin == None or plugin.getNumLayouts() == 0:
print("The loaded model contains no layout information, please add these first.")
return 3
lolPlugin = plugin.getListOfLayouts().getPlugin("render")
if (lolPlugin != None and lolPlugin.getNumGlobalRenderInformationObjects() > 0):
print("The loaded model contains global Render information: ")
for i in range ( 0, lolPlugin.getNumGlobalRenderInformationObjects()):
info = lolPlugin.getRenderInformation(i)
print_render_info(info)
# add render information to the first layout
layout = plugin.getLayout(0)
rPlugin = layout.getPlugin("render")
if (rPlugin != None and rPlugin.getNumLocalRenderInformationObjects() > 0):
print("The loaded model contains local Render information. ")
# here we would do the same as above for the local render information ...
return 0
def merge_models(model_paths, out_dir=None, merged_id="merged", validate=True):
""" Merge models in model path.
All models must be in the same subfolder.
Relative paths are set in the merged models.
Output directory must exist.
:param model_paths: absolute paths to models
:return:
"""
# necessary to convert models to SBML L3V1
# FIXME: the path should not be changed by functions (this will create problems if run concurrently)
cur_dir = os.getcwd()
os.chdir(out_dir)
base_dir = None
for model_id, path in model_paths.items():
if not os.path.exists(path):
logging.error('Path for SBML file does not exist: {}'.format(path))
# get base dir of all model files from first file
if base_dir is None:
base_dir = os.path.dirname(path)
else:
new_dir = os.path.dirname(path)
if new_dir != base_dir:
raise ValueError('All SBML files for merging must be in same '
'directory: {} != {}'.format(new_dir, base_dir))
# convert to L3V1
path_L3 = os.path.join(out_dir, "{}_L3.xml".format(model_id))
doc = libsbml.readSBMLFromFile(path)
if doc.getLevel() < SBML_LEVEL:
doc.setLevelAndVersion(SBML_LEVEL, SBML_VERSION)
libsbml.writeSBMLToFile(doc, path_L3)
model_paths[model_id] = path_L3
if validate is True:
for path in model_paths:
validation.check_sbml(path, name=path)
# create comp model
merged_doc = create_merged_doc(model_paths, merged_id=merged_id)
if validate is True:
validation.check_sbml(path, name=path)
# write merged doc
f_out = os.path.join(out_dir, '{}.xml'.format(merged_id))
libsbml.writeSBMLToFile(merged_doc, f_out)
os.chdir(cur_dir)
return merged_doc
def validation_example():
for p in model_paths:
for with_units in [False, True]:
t_start = time.time()
print("\n*** {} ***".format(p))
doc = libsbml.readSBMLFromFile(p)
t_read = time.time()
print('reading: {:.3} [s]'.format(t_read - t_start))
doc.setConsistencyChecks(libsbml.LIBSBML_CAT_UNITS_CONSISTENCY, with_units)
doc.checkConsistency()
t_check = time.time()
print('checkConsistency (units={}): {:.3} [s]'.format(with_units, t_check - t_read))
def __init__(self, graph, sbml_filepath):
self.path = sbml_filepath
self.graph = graph
# hashing for unique id
self.md5 = data.hash_for_file(sbml_filepath)
# sbml model
self.doc = libsbml.readSBMLFromFile(sbml_filepath)
self.model = self.doc.getModel()
self.model_id = self.model.getId()
# transaction
self.tx = None
def main (args):
"""Usage: setIdFromNames filename output
"""
if len(args) != 3:
print(main.__doc__)
sys.exit(1)
filename = args[1];
output = args[2];
# read the document
start = time.time() * 1000;
document = libsbml.readSBMLFromFile(filename);
stop = time.time() * 1000;
print ""
print " filename: {0}".format( filename);
print " read time (ms): {0}".format( stop - start);
# stop in case of serious errors
errors = document.getNumErrors(libsbml.LIBSBML_SEV_ERROR);
if (errors > 0):
print " error(s): {0}".format(errors);
document.printErrors();
sys.exit (errors);
# get a list of all elements, as we will need to know all identifiers
# so that we don't create duplicates.
allElements = document.getListOfAllElements();
# get a list of all ids
allIds = getAllIds(allElements);
# create the transformer with the ids
trans = SetIdFromNames(allIds);
# rename the identifiers (using the elements we already gathered before)
start = time.time() * 1000;
document.getModel().renameIDs(allElements, trans);
stop = time.time() * 1000;
print " rename time (ms): {0}".format(stop - start);
# write to file
start = time.time() * 1000;
libsbml.writeSBMLToFile(document, output);
stop = time.time() * 1000;
print " write time (ms): {0}".format(stop - start);
print "";
def main (args):
"""Usage: setIdFromNames filename output
"""
if len(args) != 3:
print(main.__doc__)
sys.exit(1)
filename = args[1];
output = args[2];
# read the document
start = time.time() * 1000;
document = libsbml.readSBMLFromFile(filename);
stop = time.time() * 1000;
print ""
print " filename: {0}".format( filename);
print " read time (ms): {0}".format( stop - start);
# stop in case of serious errors
errors = document.getNumErrors(libsbml.LIBSBML_SEV_ERROR);
if (errors > 0):
print " error(s): {0}".format(errors);
document.printErrors();
sys.exit (errors);
# get a list of all elements, as we will need to know all identifiers
# so that we don't create duplicates.
allElements = document.getListOfAllElements();
# get a list of all ids
allIds = getAllIds(allElements);
# create the transformer with the ids
trans = SetIdFromNames(allIds);
# rename the identifiers (using the elements we already gathered before)
start = time.time() * 1000;
document.getModel().renameIDs(allElements, trans);
stop = time.time() * 1000;
print " rename time (ms): {0}".format(stop - start);
# write to file
start = time.time() * 1000;
libsbml.writeSBMLToFile(document, output);
stop = time.time() * 1000;
print " write time (ms): {0}".format(stop - start);
print "";
def report(request, model_pk):
"""
Creates the report view for the given SBML model.
SBML has to be in the database.
"""
sbml_model = get_object_or_404(CompModel, pk=model_pk)
sbml_path = sbml_model.file.path # this is the absolute path in filesystem
doc = libsbml.readSBMLFromFile(str(sbml_path))
model = doc.getModel()
if not model:
print 'Model could not be read.'
raise Http404
# Create the value_dictionary
values = create_value_dictionary(model)
# Render the template with the data
# TODO: do the template rendering on model creation and only load the model report afterwards
template = loader.get_template('report/report.html')
context = RequestContext(request, {
'doc': doc,
'sbml_model': sbml_model,
'model': model,
'values': values,
'units': model.getListOfUnitDefinitions(),
'units_size': model.getListOfUnitDefinitions().size(),
'compartments': model.getListOfCompartments(),
'compartments_size': model.getListOfCompartments().size(),
'functions': model.getListOfFunctionDefinitions(),
'functions_size': model.getListOfFunctionDefinitions().size(),
'parameters': model.getListOfParameters(),
'parameters_size': model.getListOfParameters().size(),
'rules': model.getListOfRules(),
'rules_size': model.getListOfRules().size(),
'assignments': model.getListOfInitialAssignments(),
'assignments_size': model.getListOfInitialAssignments().size(),
'species': model.getListOfSpecies(),
'species_size': model.getListOfSpecies().size,
'reactions': model.getListOfReactions(),
'reactions_size': model.getListOfReactions().size(),
'constraints': model.getListOfConstraints(),
'constraints_size': model.getListOfConstraints().size(),
'events': model.getListOfEvents(),
'events_size': model.getListOfEvents().size(),
})
return HttpResponse(template.render(context))
def validation_example():
for p in model_paths:
for with_units in [False, True]:
t_start = time.time()
print("\n*** {} ***".format(p))
doc = libsbml.readSBMLFromFile(p)
t_read = time.time()
print('reading: {:.3} [s]'.format(t_read - t_start))
doc.setConsistencyChecks(libsbml.LIBSBML_CAT_UNITS_CONSISTENCY,
with_units)
doc.checkConsistency()
t_check = time.time()
print('checkConsistency (units={}): {:.3} [s]'.format(
with_units, t_check - t_read))
def validate_sbml_file(sbml_file, xpath_expressions=None):
doc = libsbml.readSBMLFromFile(sbml_file)
if doc.getNumErrors(libsbml.LIBSBML_SEV_ERROR) > 0:
logging.error(f"file {sbml_file} had errors: " +
doc.getErrorLog().toString())
return False
elif doc.getNumErrors(libsbml.LIBSBML_SEV_WARNING) > 0:
logging.warning(f"file {sbml_file} had warnings: " +
doc.getErrorLog().toString())
if xpath_expressions is not None:
return xpath_expressions_exist(doc, xpath_expressions)
return True
def test_mass_balance():
doc = libsbml.readSBMLFromFile(data.DEMO_SBML)
# add defaults
fbc.add_default_flux_bounds(doc)
import tempfile
f = tempfile.NamedTemporaryFile('w', suffix='xml')
libsbml.writeSBMLToFile(doc, f.name)
f.flush()
model = cobra.io.read_sbml_model(f.name)
# mass/charge balance
for r in model.reactions:
mb = r.check_mass_balance()
# all metabolites are balanced
assert len(mb) == 0
def load_kinetic_model(filename, kmap=None):
"""
Load the dynamic model present in a SBML file.
Args:
filename (str): SBML file.
kmap (dict): Dictionary with the parameters that can be used in the strain
optimization process for each reaction.{id_reaction: [param1, param2]}
Returns: KineticModel
Contains all information related with the dynamic model
(reactions, kinetic equations, metabolites, compartments, etc.)
"""
document = readSBMLFromFile(filename)
sbmlModel = document.getModel()
if sbmlModel is None:
raise IOError('Failed to load model.')
model = KineticModel(sbmlModel.getId())
_load_compartments(sbmlModel, model)
_load_metabolites(sbmlModel, model)
_load_reactions(sbmlModel, model)
_load_concentrations(sbmlModel, model)
_load_global_parameters(sbmlModel, model)
_load_local_parameters(sbmlModel, model)
_load_ratelaws(sbmlModel, model)
_load_assignment_rules(sbmlModel, model)
# parse rates, rules and xdot expressions
model._set_parsed_attr()
if isinstance(kmap, str):
aux = OrderedDict([(rId, re.findall(kmap, ratelaw))
for rId, ratelaw in model.ratelaws.items()])
# aux = OrderedDict([(rId , [rId+"_"+x for x in re.findall("(rmax\w*)", ratelaw)])
# for rId, ratelaw in model.ratelaws.items()]) # CHASSAGNOLE
model.reacParamsFactors = OrderedDict([(rId, params)
for rId, params in aux.items()
if len(params) > 0])
else:
model.set_reactions_parameters_factors(kmap)
return model
def _process_top(self):
""" Process the top model.
Reads top model and submodels.
:return:
"""
logging.debug('* _process_top')
self.doc_top = libsbml.readSBMLFromFile(self.sbml_top)
self.model_top = self.doc_top.getModel()
if self.model_top is None:
warnings.warn("No top level model found.")
self.framework_top = builder.get_framework(self.model_top)
if self.framework_top is not builder.MODEL_FRAMEWORK_ODE:
warnings.warn(
"The top level model framework is not ode: {}".format(
self.framework_top))
# get frameworks for submodels
doc_comp = self.doc_top.getPlugin(builder.SBML_COMP_NAME)
model_comp = self.model_top.getPlugin(builder.SBML_COMP_NAME)
# models are processed in the order they are listed in the listOfSubmodels
for submodel in model_comp.getListOfSubmodels():
modelRef = submodel.getModelRef()
# check if ExternalModelDefinition
emd = doc_comp.getExternalModelDefinition(modelRef)
if emd:
framework = builder.get_framework(emd.getReferencedModel())
else:
# Lookfor ModelDefinition
md = doc_comp.getModelDefinition(modelRef)
if md:
framework = builder.get_framework(md)
else:
raise ValueError(
"No (External)ModelDefinition for modelRef: {}".format(
modelRef))
# store the submodel under the given framework
self.submodels[framework].append(submodel)
def rename_restriced_sids(in_path,
out_path,
restricted={
"x": "x_",
"y": "y_",
"z": "z_",
"t": "t_"
}):
""" Rename restriced sids from given dictionary.
The new sids must not exist in the model!
:param in_path: sbml in file
:param out_path: sbml out file
:param restricted: dictionary of replacements
:return:
"""
print('-' * 80)
print('Renaming restricted ids')
print('-' * 80)
print('reading SBML')
# doc = sbmlio.read_sbml(in_path)
doc = libsbml.readSBMLFromFile(in_path)
model = doc.getModel()
for old_id, new_id in restricted:
element_x = model.getElementBySId(old_id)
if element_x is not None:
print("Renaming: ", old_id, '->', new_id)
element_x.setId(new_id)
elements = model.getListOfAllElements()
N = len(elements)
for k, element in enumerate(elements):
if k % int(round(N / 20)) == 0:
print("{:1.2f}".format(1.0 * k / N))
# element.renameSIdRefs(oldid="old_id", newid="new_id")
element.renameSIdRefs(old_id, new_id)
print('writing SBML')
# libsbml.writeSBMLToFile(doc, out_path)
sbmlio.write_sbml(doc, out_path, validate=validation.VALIDATION_NO_UNITS)
def prepare_rbc_model(model_path, name, target_dir):
""" Add ports to the RBC model.
:param model_path:
:param name:
:param target_dir:
:return:
"""
doc = libsbml.readSBMLFromFile(model_path) # type: libsbml.SBMLDocument
# add comp package
# sbmlns = libsbml.SBMLNamespaces(doc.getLevel(), doc.getVersion())
# sbmlns.addPackageNamespace("comp", 1)
doc.enablePackage("http://www.sbml.org/sbml/level3/version1/comp/version1",
"comp", True)
# doc.setNamespaces(sbmlns)
doc.setPackageRequired("comp", True)
model = doc.getModel()
model.setId(name)
print(model)
cmodel = model.getPlugin("comp") # type: libsbml.CompModelPlugin
def create_port(sid):
"""" Creates port for given SBase ID."""
p = cmodel.createPort() # type: libsbml.Port
port_sid = f'{sid}{PORT_SUFFIX}'
p.setId(port_sid)
p.setName(port_sid)
p.setMetaId(port_sid)
p.setSBOTerm(599) # port
p.setIdRef(sid)
return p
# add ports
cmodel = model.getPlugin("comp") # type: libsbml.CompModelPlugin
for sid in ['Vplasma', 'glcEXT', 'lacEXT', 'phosEXT', 'pyrEXT']:
create_port(sid)
output_path = os.path.join(target_dir, "{}.xml".format(name))
libsbml.writeSBMLToFile(doc, output_path)
return output_path
def parameters_for_sensitivity(r, model_path):
"""Get the parameter ids for the sensitivity analysis.
This includes all constant parameters (not changed via assignments),
excluding
- parameters with value=0 (no effect on model, dummy parameter)
- parameters which are physical constants, e.g., molecular weights
:param r:
:param model_path:
:return:
"""
doc = libsbml.readSBMLFromFile(model_path) # type: libsbml.SBMLDocument
model = doc.getModel() # type: libsbml.Model
# constant parameters in model
pids_const = []
for p in model.getListOfParameters():
if p.getConstant() == True:
pids_const.append(p.getId())
# print('constant parameters:', len(pids_const))
# filter parameters
parameters = {}
for pid in pids_const:
# dose parameters
if (pid.startswith("IVDOSE_")) or (pid.startswith("PODOSE_")):
continue
# physical parameters
if (pid.startswith("Mr_")) or pid in ["R_PDB"]:
continue
# zero parameters
value = r[pid]
if np.abs(value) < 1E-8:
continue
parameters[pid] = value
return parameters
def list_ports(model_path):
"""
:param model_path: path to sbml model
:return:
"""
""" List the ports in the given model.
:return:
"""
if not os.path.exists(model_path):
raise IOError("SBML path does not exist.")
doc = libsbml.readSBMLFromFile(model_path) # type: libsbml.SBMLDocument
model = doc.getModel() # type: libsbml.Model
model_comp = model.getPlugin("comp") # type: libsbml.CompModelPlugin
print(model_comp)
for port in model_comp.getListOfPorts(): # type: libsbml.Port
print("\tPort: ", port.getId(), port.getMetaId(), port.getIdRef(),
port.getMetaIdRef(), port.getUnitRef(), port.getPortRef())
def __init__(self, submodel, source, fba_rules):
self.source = source
self.submodel = submodel
# read the model
self.fba_doc = libsbml.readSBMLFromFile(source)
self.fba_model = self.fba_doc.getModel()
self.cobra_model = cobra.io.read_sbml_model(source)
# parameters to replace in top model
self.fba_rules = self.process_fba_rules(fba_rules)
# bounds are mappings from parameters to reactions
# parameter_id -> [rid1, rid2, ...]
self.ub_parameters = defaultdict(list)
self.lb_parameters = defaultdict(list)
self.ub_replacements = []
self.lb_replacements = []
self.flat_mapping = {}
self.process_bounds()
def __init__(self, test_dir, current_test_case, output_dir, sbml_lvl,
sbml_version):
# Inizializzo gli attributi standard della classe
self.working_dir = test_dir
self.current_test = osp.join(self.working_dir, current_test_case)
self.output_dir = osp.join(self.current_test, output_dir)
self.setting_file = osp.join(self.current_test,
f"{current_test_case}-settings.txt")
self.model = osp.join(self.current_test,
f"{current_test_case}-model.m")
self.sbml = osp.join(
self.current_test,
f"{current_test_case}-sbml-l{sbml_lvl}v{sbml_version}.xml")
self.test_id = current_test_case
# Prendo il nome del modello, direttamente dall'SBML
self.model_name = readSBMLFromFile(self.sbml).getModel().getName()
# Prendo la configurazione di simulazione
self.simul_conf = self.extract_simul_config()
def add_uncertainty_example(tmp: bool = False) -> None:
"""Add uncertainty to a model."""
output_dir = str(Path(__file__).parent)
doc = libsbml.readSBMLFromFile(os.path.join(
output_dir, "e_coli_core.xml")) # type: libsbml.SBMLDocument
# activate distrib
doc.enablePackage(
"http://www.sbml.org/sbml/level3/version1/distrib/version1", "distrib",
True)
doc.setPackageRequired("distrib", True)
model = doc.getModel() # type: libsbml.Model
model_fbc = model.getPlugin("fbc") # type: libsbml.FbcModelPlugin
# --------------------------------
# [2] write gene expression data
# --------------------------------
gp = model_fbc.getGeneProduct(0)
print(gp)
gp_distrib = gp.getPlugin("distrib") # type: libsbml.DistribSBasePlugin
print(gp_distrib)
if gp_distrib:
uncertainty = gp_distrib.createUncertainty(
) # type: libsbml.Uncertainty
up_mean = uncertainty.createUncertParameter(
) # type: libsbml.UncertParameter
up_mean.setType(libsbml.DISTRIB_UNCERTTYPE_MEAN)
up_mean.setValue(2.5)
else:
logging.error("DistribSBasePlugin not working for fbc:GeneProduct.")
# store model with gene expression data
if tmp:
with tempfile.NamedTemporaryFile(suffix=".xml") as f_sbml:
libsbml.writeSBMLToFile(doc, f_sbml.name)
else:
libsbml.writeSBMLToFile(
doc, os.path.join(output_dir, "e_coli_core_expression.xml"))
def parser(self, sbml_file, **kwargs):
from BioModelsDAG.utils import extract_model_data
with open("bto_lookup.json") as f:
bto_lookup = json.load(f)
pattern = re.compile("BTO:\d{7}")
model_data = extract_model_data(sbml_file)
model_data["color"] = "green"
model = libsbml.readSBMLFromFile(sbml_file.name).getModel()
for element in model.getListOfAllElements():
for bto_id in pattern.findall(element.getAnnotationString()):
if bto_id in bto_lookup:
yield model_data, "", {
"name": bto_lookup[bto_id],
"id": bto_id,
"color": "red"
}
else:
yield model_data, "", {"name": bto_id, "color": "red"}
def __init__(self, submodel, source, model_top=None):
""" Creates the FBAModel.
Processes the bounds for all reactions.
Reads the sbml and cobra model.
Processes the bound replacements and updates.
:param submodel:
:param source:
:param flux_rules:
"""
self.source = source
self.submodel = submodel
# read sbml and cobra model
self.doc = libsbml.readSBMLFromFile(source)
self.model = self.doc.getModel()
self.cobra_model = cobra.io.read_sbml_model(source)
# bounds are mappings from parameters to reactions
# parameter_id -> [rid1, rid2, ...]
self.ub_parameters = defaultdict(list)
self.lb_parameters = defaultdict(list)
self.fba2top_bounds = None
# reaction mapping (top <-> fba)
self.fba2top_reactions = None
self.top2flat_reactions = None
# objective sense
self._process_objective_direction()
# bounds
self.ub_pid2rid = None
self.lb_pid2rid = None
# process the top (ode) <-> fba connections (bounds & reaction replacements)
if model_top is not None:
self._process_bound_replacements(model_top)
self._process_fba2top_reactions(model_top)
self._process_top2flat_reactions(model_top)
def load_metabolic_model(model_name, species='homo_sapiens'):
"""
Loads the metabolic model from `file_name`, returning a Model object
"""
if model_name.endswith('_mat'):
model = importMATLAB.load(model_name, species)
else:
model_dir = os.path.join(MODEL_DIR, model_name)
model_file = [
x for x in os.listdir(model_dir)
if x.lower().endswith('.xml') or x.lower().endswith('.xml.gz')
]
if len(model_file) == 0:
raise Exception(
"Invalid model - could not find .xml or .xml.gz file in " +
model_dir)
else:
model_file = model_file[0]
full_path = os.path.join(model_dir, model_file)
sbmlDocument = libsbml.readSBMLFromFile(full_path)
level = sbmlDocument.getLevel()
if level == 3:
model = importSBML3.load(model_name, sbmlDocument)
elif level == 2:
model = importSBML2.load(model_name, sbmlDocument)
else:
raise Exception("Invalid level {} for model {}".format(
level, model_file))
resolve_genes(model)
convert_species(model, species)
clean_reactions(model)
limit_maximum_flux(model, 1000)
return model
def validate_model(filename, name=None, validate_consistency=True, config=None):
""" Check that a model is valid
Args:
filename (:obj:`str`): path to model
name (:obj:`str`, optional): name of model for use in error messages
validate_consistency (:obj:`str`, optional): whether to check the consistency of the model
config (:obj:`Config`, optional): whether to fail on missing includes
Returns:
:obj:`tuple`:
* nested :obj:`list` of :obj:`str`: nested list of errors (e.g., required ids missing or ids not unique)
* nested :obj:`list` of :obj:`str`: nested list of errors (e.g., required ids missing or ids not unique)
* :obj:`libsbml.SBMLDocument`: model
"""
errors = []
warnings = []
doc = None
if filename:
if os.path.isfile(filename):
doc = libsbml.readSBMLFromFile(filename)
if validate_consistency:
doc.checkConsistency()
for i_error in range(doc.getNumErrors()):
sbml_error = doc.getError(i_error)
if sbml_error.isInfo() or sbml_error.isWarning():
warnings.append([sbml_error.getMessage()])
else:
errors.append([sbml_error.getMessage()])
else:
errors.append(['`{}` is not a file.'.format(filename or '')])
else:
errors.append(['`filename` must be a path to a file, not `{}`.'.format(filename or '')])
return (errors, warnings, doc)
def __init__(self, submodel, source, model_top=None):
""" Creates the FBAModel.
Processes the bounds for all reactions.
Reads the sbml and cobra model.
Processes the bound replacements and updates.
:param submodel:
:param source:
:param flux_rules:
"""
self.source = source
self.submodel = submodel
# read sbml and cobra model
self.doc = libsbml.readSBMLFromFile(source)
self.model = self.doc.getModel()
self.cobra_model = cobra.io.read_sbml_model(source)
# bounds are mappings from parameters to reactions
# parameter_id -> [rid1, rid2, ...]
self.ub_parameters = defaultdict(list)
self.lb_parameters = defaultdict(list)
self.fba2top_bounds = None
# reaction mapping (top <-> fba)
self.fba2top_reactions = None
self.top2flat_reactions = None
# objective sense
self._process_objective_direction()
# bounds
self.ub_pid2rid = None
self.lb_pid2rid = None
# process the top (ode) <-> fba connections (bounds & reaction replacements)
if model_top is not None:
self._process_bound_replacements(model_top)
self._process_fba2top_reactions(model_top)
self._process_top2flat_reactions(model_top)
def readSBMLModel(sbml_model):
try:
sbml = getRoadrunnerSBML(sbml_model)
except TypeError:
if os.path.exists(sbml_model) and os.path.isfile(sbml_model):
# it's a file path
if os.path.splitext(sbml_model)[1] == '.sb':
# it's an Antimony file
with open(sbml_model) as f:
return libsbml.readSBML(antimonyConverter.antimonyToSBML(f.read()))
elif os.path.splitext(sbml_model)[1] == '.txt':
raise RuntimeError('File ending in ".txt" is ambiguous - pass an SBML file (.xml) or an Antimony file (.sb).')
else:
return libsbml.readSBMLFromFile(sbml_model)
else:
# check if it's Antimony source
try:
return libsbml.readSBML(antimonyConverter.antimonyToSBML(sbml_model))
except:
# it better be SBML
# this will throw if it's not SBML
return libsbml.readSBML(model)
def main(args):
"""Usage: stringInput filename
"""
if len(args) != 2:
print(main.__doc__)
sys.exit(2)
filename = args[1]
document = libsbml.readSBMLFromFile(filename)
errors = document.getNumErrors()
print("filename: " + filename + "\n")
if errors > 0:
document.printErrors()
return errors
# Model
m = document.getModel()
# testing ascii input, this should work for Python 2 and 3
ascii_name = str('new_ascii_name')
m.setName(ascii_name)
print(type(m.getName()))
# testing unicode input, this should also work for Python 3 and
# Python 2 if libSBML has been compiled with Swig version > 3.0.8
unicode_name = u'new_unicode_name'
m.setName(unicode_name)
print(type(m.getName()))
return errors
def inline_function_definitions(sbml_file, output_file=None):
""" Inlines all function definitions in the given SBML file
:param sbml_file: the sbml file to load
:param output_file: the output file where to write the SBML to
:return:
"""
doc = libsbml.readSBMLFromFile(sbml_file)
if doc.getNumErrors(libsbml.LIBSBML_SEV_ERROR) > 0:
logging.error("invalid SBML document " + doc.getErrorLog().toString())
return False
if convert_function_definitions(doc) != libsbml.LIBSBML_OPERATION_SUCCESS:
logging.error("Conversion failed with: " +
doc.getErrorLog().toString())
return False
if output_file is None:
output_file = sbml_file
libsbml.writeSBMLToFile(doc, output_file)
def main (args):
"""Usage: stringInput filename
"""
if len(args) != 2:
print(main.__doc__)
sys.exit(2)
filename = args[1]
document = libsbml.readSBMLFromFile(filename)
errors = document.getNumErrors()
print("filename: " + filename + "\n")
if errors > 0:
document.printErrors()
return errors
# Model
m = document.getModel()
# testing ascii input, this should work for Python 2 and 3
ascii_name = str('new_ascii_name')
m.setName(ascii_name)
print(type(m.getName()))
# testing unicode input, this should also work for Python 3 and
# Python 2 if libSBML has been compiled with Swig version > 3.0.8
unicode_name = u'new_unicode_name'
m.setName(unicode_name)
print(type(m.getName()))
return errors
def _process_top(self):
""" Process the top model.
Reads top model and submodels.
:return:
"""
logging.debug('* _process_top')
self.doc_top = libsbml.readSBMLFromFile(self.sbml_top)
self.model_top = self.doc_top.getModel()
if self.model_top is None:
warnings.warn("No top level model found.")
self.framework_top = builder.get_framework(self.model_top)
if self.framework_top is not builder.MODEL_FRAMEWORK_ODE:
warnings.warn("The top level model framework is not ode: {}".format(self.framework_top))
# get frameworks for submodels
doc_comp = self.doc_top.getPlugin(builder.SBML_COMP_NAME)
model_comp = self.model_top.getPlugin(builder.SBML_COMP_NAME)
# models are processed in the order they are listed in the listOfSubmodels
for submodel in model_comp.getListOfSubmodels():
modelRef = submodel.getModelRef()
# check if ExternalModelDefinition
emd = doc_comp.getExternalModelDefinition(modelRef)
if emd:
framework = builder.get_framework(emd.getReferencedModel())
else:
# Lookfor ModelDefinition
md = doc_comp.getModelDefinition(modelRef)
if md:
framework = builder.get_framework(md)
else:
raise ValueError("No (External)ModelDefinition for modelRef: {}".format(modelRef))
# store the submodel under the given framework
self.submodels[framework].append(submodel)
def __init__(self, top_level_file):
""" Create the simulator with the top level SBML file.
The models are resolved to their respective simulation framework.
The top level network must be an ode network.
"""
self.sbml_top = top_level_file
# read top level model
self.doc_top = libsbml.readSBMLFromFile(self.sbml_top)
self.model_top = self.doc_top.getModel()
self.framework_top = self.get_framework(self.model_top)
if self.framework_top is not MODEL_FRAMEWORK_ODE:
warnings.warn(
"The top level model framework is not ode: {}".format(
self.framework_top))
self.submodels = defaultdict(list)
self.rr_comp = None
self.fba_models = []
self._process_top_level()
self._prepare_models()
def rename_restriced_sids(in_path, out_path,
restricted={"x": "x_", "y": "y_", "z": "z_", "t": "t_"}):
""" Rename restriced sids from given dictionary.
The new sids must not exist in the model!
:param in_path: sbml in file
:param out_path: sbml out file
:param restricted: dictionary of replacements
:return:
"""
print('-' * 80)
print('Renaming restricted ids')
print('-' * 80)
print('reading SBML')
# doc = sbmlio.read_sbml(in_path)
doc = libsbml.readSBMLFromFile(in_path)
model = doc.getModel()
for old_id, new_id in restricted:
element_x = model.getElementBySId(old_id)
if element_x is not None:
print("Renaming: ", old_id, '->', new_id)
element_x.setId(new_id)
elements = model.getListOfAllElements()
N = len(elements)
for k, element in enumerate(elements):
if k % int(round(N/20)) == 0:
print("{:1.2f}".format(1.0*k/N))
# element.renameSIdRefs(oldid="old_id", newid="new_id")
element.renameSIdRefs(old_id, new_id)
print('writing SBML')
# libsbml.writeSBMLToFile(doc, out_path)
sbmlio.write_sbml(doc, out_path, validate=validation.VALIDATION_NO_UNITS)
def main (args):
"""Usage: getAllElementsWithNotes filename
"""
if len(args) != 2:
print(main.__doc__)
sys.exit(1)
filename = args[1];
# read the document
start = time.time() * 1000;
document = libsbml.readSBMLFromFile(filename);
stop = time.time() * 1000;
print ""
print " filename: {0}".format( filename);
print " read time (ms): {0}".format( stop - start);
# stop in case of serious errors
errors = document.getNumErrors(libsbml.LIBSBML_SEV_ERROR);
if (errors > 0):
print " error(s): {0}".format(errors);
document.printErrors();
sys.exit (errors);
# create the filter we want to use
filter = NotesFilter()
# get a list of all elements with notes
start = time.time() * 1000;
print " searching ......:"
allElements = document.getListOfAllElements(filter);
stop = time.time() * 1000;
print " search time (ms): {0}".format(stop - start);
print " elements with notes: {0}".format(allElements.getSize())
def main (args):
"""Usage: getAllElementsWithNotes filename
"""
if len(args) != 2:
print(main.__doc__)
sys.exit(1)
filename = args[1];
# read the document
start = time.time() * 1000;
document = libsbml.readSBMLFromFile(filename);
stop = time.time() * 1000;
print ""
print " filename: {0}".format( filename);
print " read time (ms): {0}".format( stop - start);
# stop in case of serious errors
errors = document.getNumErrors(libsbml.LIBSBML_SEV_ERROR);
if (errors > 0):
print " error(s): {0}".format(errors);
document.printErrors();
sys.exit (errors);
# create the filter we want to use
filter = NotesFilter()
# get a list of all elements with notes
start = time.time() * 1000;
print " searching ......:"
allElements = document.getListOfAllElements(filter);
stop = time.time() * 1000;
print " search time (ms): {0}".format(stop - start);
print " elements with notes: {0}".format(allElements.getSize())
def example(path):
"""
Example FBA with demo model.
:param path:
:type path:
:return:
:rtype:
"""
doc = libsbml.readSBMLFromFile(path)
# add defaults
fbc.add_default_flux_bounds(doc)
import tempfile
f = tempfile.NamedTemporaryFile('w', suffix='xml')
libsbml.writeSBMLToFile(doc, f.name)
f.flush()
model = cobra.io.read_sbml_model(f.name)
# mass/charge balance
for r in model.reactions:
mb = r.check_mass_balance()
print(r.id, mb)
def example(path):
"""
Example FBA with demo model.
:param path:
:type path:
:return:
:rtype:
"""
doc = libsbml.readSBMLFromFile(path)
# add defaults
fbc.add_default_flux_bounds(doc)
import tempfile
f = tempfile.NamedTemporaryFile('w', suffix='xml')
libsbml.writeSBMLToFile(doc, f.name)
f.flush()
model = cobra.io.read_sbml_model(f.name)
# mass/charge balance
for r in model.reactions:
mb = r.check_mass_balance()
print(r.id, mb)
def runSingleSBML(member_name, rpsbml_string, inSBML, isMerge, path_id):
#open one of the rp SBML files
input_rpsbml = rpSBML.rpSBML('inputMergeModel',
libsbml.readSBMLFromFile(inSBML))
rpsbml = rpSBML.rpSBML(member_name,
libsbml.readSBMLFromString(rpsbml_string))
#read the input GEM sbml model
#input_rpsbml = rpSBML.rpSBML('inputMergeModel', libsbml.readSBMLFromString(inSBML_string))
#print(input_rpsbml)
#print(input_rpsbml.model)
rpsbml.mergeModels(input_rpsbml.model)
rpfba = rpFBA.rpFBA(input_rpsbml)
rpfba.allObj(path_id)
if isMerge:
##### pass FBA results to the original model ####
groups = rpfba.rpsbml.model.getPlugin('groups')
rp_pathway = groups.getGroup(path_id)
for member in rp_pathway.getListOfMembers():
reacFBA = rpfba.rpsbml.model.getReaction(member.getIdRef())
reacIN = rpsbml.model.getReaction(member.getIdRef())
reacIN.setAnnotation(reacFBA.getAnnotation())
return libsbml.writeSBMLToString(rpsbml.document).encode('utf-8')
else:
return libsbml.writeSBMLToString(input_rpsbml.document).encode('utf-8')
def set_names_as_ids(f_in, f_out=None):
""" Sets the element as id on all elements in the model.
:param f_in: SBML input file
:param f_out:
:return:
"""
doc = libsbml.readSBMLFromFile(f_in)
model = doc.getModel()
model.populateAllElementIdList()
sid_list = model.getAllElementIdList()
for k in range(sid_list.size()):
sid = sid_list.at(k)
element = model.getElementBySId(sid)
if (element is not None) and hasattr(element, 'setName'):
print(element.getName(), '->', sid)
element.setName(sid)
if f_out is None:
suffix = '_copasi'
tokens = f_in.split('.')
if len(tokens) > 1:
f_out = ".".join(tokens[0:-1]) + suffix + "." + tokens[-1]
else:
f_out = tokens[0] + suffix
# write to output file
libsbml.writeSBMLToFile(doc, f_out)
print('*' * 60)
print('Names replaced with ids')
print('*' * 60)
print('f_in:\t', f_in)
print('f_out:\t', f_out)
print('*' * 60)
from __future__ import print_function from os.path import join as pjoin import libsbml directory = './emd_files/' in_file = pjoin(directory, 'diauxic_bounds.xml') out_file = pjoin(directory, 'diauxic_bounds_out.xml') doc = libsbml.readSBMLFromFile(in_file) sbml_str = libsbml.writeSBMLToString(doc) print(sbml_str)
from __future__ import absolute_import, print_function
import libsbml
import time
model_paths = ["rbc_top.xml"]
for p in model_paths:
for with_units in [False, True]:
t_start = time.time()
print("\n*** {} ***".format(p))
doc = libsbml.readSBMLFromFile(p)
t_read = time.time()
print('reading: {:.3} [s]'.format(t_read - t_start))
doc.setConsistencyChecks(libsbml.LIBSBML_CAT_UNITS_CONSISTENCY,
with_units)
doc.checkConsistency()
t_check = time.time()
print('checkConsistency (units={}): {:.3} [s]'.format(
with_units, t_check - t_read))
def __init__(self, path):
doc = libsbml.readSBMLFromFile(path)
self.model = doc.getModel()
from __future__ import absolute_import, print_function
import libsbml
import time
model_paths = ["rbc_top.xml"]
for p in model_paths:
for with_units in [False, True]:
t_start = time.time()
print("\n*** {} ***".format(p))
doc = libsbml.readSBMLFromFile(p)
t_read = time.time()
print('reading: {:.3} [s]'.format(t_read - t_start))
doc.setConsistencyChecks(libsbml.LIBSBML_CAT_UNITS_CONSISTENCY, with_units)
doc.checkConsistency()
t_check = time.time()
print('checkConsistency (units={}): {:.3} [s]'.format(with_units, t_check - t_read))
import sys
#sys.path.append('/opt/libsbml/lib/python2.7/site-packages/libsbml/')
import libsbml
doc=libsbml.readSBMLFromFile (sys.argv[1])
doc.setLevelAndVersion(2, 4, False)
#print doc.toSBML()
f = open(sys.argv[2], 'w')
f.write(doc.toSBML())
f.close()
# setting because it is required (if unlucky additional info required)
# but we can't set it because we can't access the FBCModelPlugins of the ModelDefinitions
if fbc_model is not None:
if not fbc_model.isSetStrict():
fbc_model.setStrict(False)
else:
print("WARNING: This should never happen. All ModelDefinitions should have a FBCModelPlugin")
doc.checkInternalConsistency()
doc.printErrors()
return doc
if __name__ == "__main__":
import libsbml
from os.path import join as pjoin
directory = './emd_files/'
top_file = pjoin(directory, 'diauxic_top.xml')
# replace the ExternalModelDefinitions with ModelDefinitions
doc_top = libsbml.readSBMLFromFile(top_file)
doc_no_emd = flattenExternalModelDefinitions(doc_top)
# write to file
libsbml.writeSBMLToFile(doc_no_emd, pjoin(directory, 'test_emd_flat.xml'))
print(libsbml.__version__)
def sbml_statistics(sbml_path):
"""Calculate dictionary of statistics for given SBML model
:param sbml_path:
:return: dict
"""
doc = libsbml.readSBMLFromFile(sbml_path) # type: libsbml.SBMLDocument
model = doc.getModel() # type: libsbml.Model
# core
s = {
"level_version": "L{}V{}".format(doc.getLevel(), doc.getVersion())
}
if model:
s["function_definitions"] = model.getNumFunctionDefinitions()
s["unit_definitions"] = model.getNumUnitDefinitions()
s["compartments"] = model.getNumCompartments()
s["species"] = model.getNumSpecies()
s["parameters"] = model.getNumParameters()
s["initial_assignments"] = model.getNumInitialAssignments()
s["rules"] = model.getNumRules()
s["reactions"] = model.getNumReactions()
s["constraints"] = model.getNumConstraints()
s["events"] = model.getNumEvents()
# kineticLaws & localParameters
s["kinetic_laws"] = 0
s["kinetic_laws_math"] = 0
s["parameters_local"] = 0
for reaction in model.getListOfReactions(): # type: libsbml.Reaction
if reaction.isSetKineticLaw():
s["kinetic_laws"] += 1
klaw = reaction.getKineticLaw() # type: libsbml.KineticLaw
if klaw.isSetMath():
# math must be set and cannot be a flux_value
# some fbc models abuse kinetic laws via FLUX_VALUE
math = klaw.getMath() # type: libsbml.ASTNode
formula = libsbml.formulaToL3String(math)
if formula != "FLUX_VALUE":
s["kinetic_laws_math"] += 1
s["parameters_local"] += klaw.getNumParameters()
# rule details
s["rules_assignment_rules"] = 0
s["rules_rate_rules"] = 0
s["rules_algebraic_rules"] = 0
for rule in model.getListOfRules(): # type: libsbml.Rule
if rule.isAssignment():
s["rules_assignment_rules"] += 1
elif rule.isRate():
s["rules_rate_rules"] += 1
elif rule.isAlgebraic():
s["rules_algebraic_rules"] += 1
# event details
s["events_trigger"] = 0
s["events_priority"] = 0
s["events_delay"] = 0
s["events_event_assignments"] = 0
for event in model.getListOfEvents(): # type: libsbml.Event
if event.isSetTrigger():
s["events_trigger"] += 1
if event.isSetPriority():
s["events_priority"] += 1
if event.isSetDelay():
s["events_delay"] += 1
s["events_event_assignments"] += event.getNumEventAssignments()
s["events_math"] = s["events_trigger"] + s["events_priority"] + s["events_delay"] + s["events_event_assignments"]
s["math"] = s["function_definitions"] + s["initial_assignments"] + s["constraints"] + s["rules"] + s["kinetic_laws_math"] + s["events_math"]
# FIXME: annotations & SBO terms
return s
for point in node.polygon_points:
print("point: ", point)
for code in node.polygon_codes:
print("code: ", code)
sll.drawNetwork()
sll.writeSBMLFile("simple_local_out.xml")
print(sll.getCompartmentEdgeColor("vol1"))
print(sll.getCompartmentFillColor("vol1"))
print(sll.getCompartmentLineWidth("vol1"))
# check libsbml API
doc = libsbml.readSBMLFromFile(str(model_file))
model = doc.getModel()
numCompartments = model.getNumCompartments()
print("numCompartments: ", numCompartments)
for index in range(numCompartments):
compartment = model.getCompartment(index)
print("id, name: ", compartment.getId(), ", ", compartment.getElementName())
for reaction in sll._SBMLlayout__network.reactions.values():
for curve in reaction.curves:
print("curve role: ", curve.role, curve.role_name, curve.role_name.lower()=="substrate")
def from_file(cls, sbml_file):
doc = libsbml.readSBMLFromFile(sbml_file) # type: libsbml.SBMLDocument
return cls(doc)
try:
import libsbml
except ImportError:
import tesbml as libsbml
doc = libsbml.readSBMLFromFile("limax_pkpd_39.xml")
for r in doc.model.reactions: # type: libsbml.Reaction
ud = r.getKineticLaw().getDerivedUnitDefinition() # type: libsbml.UnitDefinition
print(r, libsbml.UnitDefinition.printUnits(ud))
def __init__(self, path):
doc = libsbml.readSBMLFromFile(path)
self.model = doc.getModel()
def test_demo_annotation():
""" Annotate the demo network. """
f_tmp = tempfile.NamedTemporaryFile()
annotation.annotate_sbml_file(data.DEMO_SBML_NO_ANNOTATIONS, data.DEMO_ANNOTATIONS, f_sbml_annotated=f_tmp.name)
f_tmp.flush()
# document
doc = libsbml.readSBMLFromFile(f_tmp.name)
assert doc.getSBOTerm() == 293
assert doc.getSBOTermID() == "SBO:0000293"
cvterms = doc.getCVTerms()
# check: is one cv term with 3 resources in bag
assert len(cvterms) == 1
assert cvterms[0].getNumResources() == 1
# model
model = doc.getModel()
cvterms = model.getCVTerms()
assert len(cvterms) == 0
# compartments
ce = model.getCompartment('e')
assert ce.getSBOTerm() == 290
assert ce.getSBOTermID() == "SBO:0000290"
cvterms = ce.getCVTerms()
# check: is one cv term with 3 resources in bag
assert len(cvterms) == 1
assert cvterms[0].getNumResources() == 3
cm = model.getCompartment('m')
assert cm.getSBOTerm() == 290
assert cm.getSBOTermID() == "SBO:0000290"
cvterms = cm.getCVTerms()
assert len(cvterms) == 1
assert cvterms[0].getNumResources() == 3
cc = model.getCompartment('c')
assert cc.getSBOTerm() == 290
assert cc.getSBOTermID() == "SBO:0000290"
cvterms = cm.getCVTerms()
assert len(cvterms) == 1
assert cvterms[0].getNumResources() == 3
# parameters
for p in model.parameters:
cvterms = p.getCVTerms()
if re.match(r"^Km_\w+$", p.id):
assert p.getSBOTerm() == 27
assert p.getSBOTermID() == "SBO:0000027"
assert len(cvterms) == 1
if re.match(r"^Keq_\w+$", p.id):
assert p.getSBOTerm() == 281
assert p.getSBOTermID() == "SBO:0000281"
assert len(cvterms) == 1
if re.match(r"^Vmax_\w+$", p.id):
assert p.getSBOTerm() == 186
assert p.getSBOTermID() == "SBO:0000186"
assert len(cvterms) == 1
# species
for s in model.species:
cvterms = s.getCVTerms()
if re.match(r"^\w{1}__[ABC]$", s.id):
assert s.getSBOTerm() == 247
assert s.getSBOTermID() == "SBO:0000247"
assert len(cvterms) == 1
# reactions
for r in model.reactions:
cvterms = r.getCVTerms()
if re.match(r"^b\w{1}$", r.id):
assert r.getSBOTerm() == 185
assert r.getSBOTermID() == "SBO:0000185"
assert len(cvterms) == 1
if re.match(r"^v\w{1}$", r.id):
assert r.getSBOTerm() == 176
assert r.getSBOTermID() == "SBO:0000176"
assert len(cvterms) == 1
def simulate(mixed_sbml, tend=10.0, step_size=0.1, debug=False):
"""
Performs model simulation.
The simulator figures out based on the SBO terms in the list of submodels, which
simulation/modelling framework to use.
The passing of information between FBA and SSA/ODE is based on the list of replacements.
:param mixed_sbml: comp sbml model with multiple submodels
:param tend: end time of the simulation
:param step_size: step size for the integration, if None variable step size will be used
:param debug: additional information
:return: pandas solution data frame
"""
###############################
# Process FBA assignment rules
###############################
# Necessary to find the assignment rules in the top model
# These cannot be set in an hybrid approach.
doc = libsbml.readSBMLFromFile(mixed_sbml)
model = doc.getModel()
def _process_mixed_assignments(model):
"""
Find the assignment rules which assign to a variable a reaction rate.
"""
fba_rules = {}
for rule in model.getListOfRules():
if not rule.isAssignment():
continue
variable = rule.getVariable()
formula = rule.getFormula()
parameter = model.getParameter(variable)
if not parameter:
continue
reaction = model.getReaction(formula)
if not reaction:
continue
fba_rules[reaction.getId()] = parameter.getId()
return fba_rules
fba_rules = _process_mixed_assignments(model)
print('FBA rules:', fba_rules)
# remove the FBA assignment rules from the model, so they can be set via the simulator
for variable in fba_rules.values():
print(variable)
model.removeRuleByVariable(variable)
import tempfile
mixed_sbml_cleaned = tempfile.NamedTemporaryFile("w", suffix=".xml")
libsbml.writeSBMLToFile(doc, mixed_sbml_cleaned.name)
# mixed_sbml_cleaned.close()
###########################
# Load ODE model
###########################
# the roadrunner ode file is the flattend comp file.
# FBA subparts do not change change any of the kinetic subparts (only connections via replaced bounds
# and fluxes).
# Consequently the ode part can be solved as is, only the iterative update between ode and fba has
# to be performed
rr_comp = roadrunner.RoadRunner(mixed_sbml_cleaned.name)
sel = ['time'] \
+ ["".join(["[", item, "]"]) for item in rr_comp.model.getBoundarySpeciesIds()] \
+ ["".join(["[", item, "]"]) for item in rr_comp.model.getFloatingSpeciesIds()] \
+ rr_comp.model.getReactionIds() + fba_rules.values()
rr_comp.timeCourseSelections = sel
rr_comp.reset()
###########################
# Load FBA models
###########################
# via the submodels information it is decided which submodels are belonging to which
# modeling framework (SBOTerms on submodel)
doc = libsbml.readSBMLFromFile(mixed_sbml)
model_frameworks = comp.get_submodel_frameworks(doc)
model = doc.getModel()
# get top level reaction ids
# top_level_rids = frozenset([reaction.getId() for reaction in model.getListOfReactions()])
# assign submodels to FBA
fba_models = {}
for key, value in model_frameworks.iteritems():
if value["sbo"] == 624:
print('FBA model')
# get SBML file
modelRef = value["modelRef"]
mdoc = doc.getPlugin("comp")
emd = mdoc.getExternalModelDefinition(modelRef)
source = emd.getSource()
print(source)
fba_models[key] = {'cobra': cobra.io.read_sbml_model(source),
'doc': libsbml.readSBMLFromFile(source)}
elif value['sbo'] == 62:
print('ODE model')
# get the sbml file
modelRef = value["modelRef"]
mdoc = doc.getPlugin("comp")
emd = mdoc.getExternalModelDefinition(modelRef)
source = emd.getSource()
print(source)
else:
raise Exception("Modelling framework not supported, or not annotated on submodel: ", sbo)
# submodels handled by FBA
print(fba_models)
###########################
# Simulation
###########################
all_results = []
all_time = []
result = None
time = 0.0
while time <= tend:
if debug:
print("-" * 80)
print("Time: {}".format(time))
# --------------------------------------
# FBA
# --------------------------------------
# all fba submodels are simulated
for fba_key, fba_info in fba_models.iteritems():
cobra_model = fba_info['cobra']
sbml_model = fba_info['doc'].getModel()
# TODO: calculate once (not required in loop)
# which parameters are upper or lower bounds
from collections import defaultdict
ub_parameters = defaultdict(list)
lb_parameters = defaultdict(list)
for r in sbml_model.getListOfReactions():
mr = r.getPlugin("fbc")
rid = r.getId()
if mr.isSetUpperFluxBound():
ub_parameters[mr.getUpperFluxBound()].append(rid)
if mr.isSetLowerFluxBound():
lb_parameters[mr.getLowerFluxBound()].append(rid)
print(ub_parameters)
print(lb_parameters)
# search in global parameter replacements for replacements which replace the bounds
# of reactions
print("* set bounds *")
for p in model.getListOfParameters():
pid = p.getId()
mp = p.getPlugin("comp")
for rep_element in mp.getListOfReplacedElements():
# the submodel of the replacement belongs to the current model
if rep_element.getSubmodelRef() == fba_key:
# update upper and lower bounds
for rid in ub_parameters.get(pid, []):
print(rid, ': (upper) -> ', pid)
cobra_reaction = cobra_model.reactions.get_by_id(rid)
cobra_reaction.upper_bound = rr_comp[pid]
for rid in lb_parameters.get(pid, []):
print(rid, ': (lower) -> ', pid)
cobra_reaction = cobra_model.reactions.get_by_id(rid)
cobra_reaction.lower_bound = rr_comp[pid]
# [2] optimize
print("* optimize *")
# TODO: start with last solution (speed improvement)
cobra_model.optimize()
# [3] set fluxes in ODE part
print("* set fba fluxes in ode *")
# based on replacements the fluxes are written in the kinetic part
# set solution fluxes in parameters
for (rid, flux) in cobra_model.solution.x_dict.iteritems():
if rid in fba_rules:
rr_comp[fba_rules[rid]] = flux
print(rid, ':', fba_rules[rid], "=", flux)
else:
print(rid, "no boundary flux")
if debug:
print_flux_bounds(cobra_model)
print(cobra_model.solution.status)
print(cobra_model.solution.x_dict)
print("-" * 80)
# --------------------------------------
# ODE
# --------------------------------------
# With the updated fluxes from the FBA the kinetic part is
# calculated:
# simulate (1 step)
if step_size:
# constant step size
result = rr_comp.simulate(0, end=step_size, steps=1)
else:
# variable step size
result = rr_comp.simulate(0, steps=1, variableStep=True)
# store results
all_results.append(result[1])
# set the fba fluxes in the model)
# TODO: the fba fluxes are not set in the full kinetic result (shown as zero)
# these have to be set with the mapping between comp and flattened model
all_time.append(time)
# store simulation values & get time step
delta_time = result['time'][1]
time = time + delta_time
if debug:
print(result)
# create result matrix
df = pd.DataFrame(data=all_results, columns=result.colnames)
df.time = all_time
print(df)
return df
