def create_dummy_reactions(model, model_fba, unit_flux=None):
""" Creates the dummy reactions.
This also creates the corresponding flux parameters and flux assignments.
:param model:
:param model_fba:
:param unit_flux:
:return:
"""
ex_rids = utils.find_exchange_reactions(model_fba)
objects = []
for ex_rid, sid in ex_rids.items():
pid_flux = FLUX_PARAMETER_PREFIX + sid
rid_flux = DUMMY_REACTION_PREFIX + sid
objects.append(
# flux parameter: fluxe from fba (rate of reaction)
fac.Parameter(sid=pid_flux, value=1.0, constant=True, unit=unit_flux, sboTerm=FLUX_PARAMETER_SBO),
)
# dummy reaction (pseudoreaction)
fac.create_reaction(model, rid=rid_flux, reversible=False,
products={DUMMY_SPECIES_ID: 1}, sboTerm=DUMMY_REACTION_SBO,
formula='0 {}'.format(unit_flux))
# flux assignment rule
objects.append(
fac.AssignmentRule(pid_flux, value=rid_flux, sboTerm=FLUX_ASSIGNMENTRULE_SBO),
)
fac.create_objects(model, objects)
def create_dfba_species(model, model_fba, compartment_id, hasOnlySubstanceUnits=False, unit_amount=None, create_port=True,
exclude_sids=[]):
""" Add DFBA species and compartments from fba model to model.
Creates the dynamic species and respetive compartments with
the necessary ports.
This is used in the bounds submodel, update submodel and the
and top model.
:param model:
:param model_fba:
:return:
"""
objects = []
port_sids = []
ex_rids = utils.find_exchange_reactions(model_fba)
for ex_rid in ex_rids:
r = model_fba.getReaction(ex_rid)
sid = r.getReactant(0).getSpecies()
if sid in exclude_sids:
continue
s = model_fba.getSpecies(sid)
# exchange species to create
objects.append(
fac.Species(sid=sid, name=s.getName(), initialConcentration=1.0, substanceUnit=unit_amount,
hasOnlySubstanceUnits=hasOnlySubstanceUnits, compartment=compartment_id)
)
# port of exchange species
port_sids.append(sid)
fac.create_objects(model, objects)
if create_port:
comp.create_ports(model, idRefs=port_sids)
def create_dynamic_bounds(model_bounds, model_fba, unit_flux=None):
""" Creates the dynamic bounds for the model.
It is necessary to create copies of the fixed bounds from the fba model
which are subsequently used in the dynamic bounds calculation.
:return:
"""
fba_suffix = "_fba"
objects = []
ex_rids = utils.find_exchange_reactions(model_fba)
for ex_rid, sid in ex_rids.items():
r = model_fba.getReaction(ex_rid)
r_fbc = r.getPlugin(SBML_FBC_NAME)
# get compartment from species
s = model_bounds.getSpecies(sid)
cid = s.getCompartment()
# upper bound parameter (export from FBA, i.e increase concentration)
ub_id = r_fbc.getUpperFluxBound()
fba_ub_id = ub_id + fba_suffix
ub_value = model_fba.getParameter(ub_id).getValue()
ub_formula = "{}".format(fba_ub_id)
objects.extend([
Parameter(sid=fba_ub_id,
value=ub_value,
unit=unit_flux,
constant=True,
sboTerm=FLUX_BOUND_SBO),
AssignmentRule(sid=ub_id,
value=ub_formula,
name="fba export bound ({})".format(sid)),
])
# lower bound parameter (import to FBA, i.e decrease concentration)
lb_id = r_fbc.getLowerFluxBound()
fba_lb_id = lb_id + fba_suffix
lb_value = model_fba.getParameter(lb_id).getValue()
# concentration/amount formula for import depending on available species
if s.getHasOnlySubstanceUnits():
lb_formula = "max({}, -{}/dt)".format(fba_lb_id, sid)
else:
lb_formula = "max({}, -{}*{}/dt)".format(fba_lb_id, cid, sid)
objects.extend([
# default bounds from fba
Parameter(sid=fba_lb_id,
value=lb_value,
unit=unit_flux,
constant=False,
sboTerm=FLUX_BOUND_SBO),
# uptake bounds (lower bound)
AssignmentRule(sid=lb_id,
value=lb_formula,
name="dfba import bound ({})".format(sid)),
])
factory.create_objects(model_bounds, objects)
def bounds_model(sbml_file, directory, doc_fba=None):
""""
Submodel for dynamically calculating the flux bounds.
The dynamically changing flux bounds are the input to the
FBA model.
"""
doc = builder.template_doc_bounds(settings.MODEL_ID)
model = doc.getModel()
bounds_notes = notes.format("""
<h2>BOUNDS submodel</h2>
<p>Submodel for dynamically calculating the flux bounds.
The dynamically changing flux bounds are the input to the
FBA model.</p>
""")
utils.set_model_info(model, notes=bounds_notes, creators=creators, units=units, main_units=main_units)
# dt
compartment_id = "blood"
builder.create_dfba_dt(model, time_unit=UNIT_TIME, create_port=True)
# compartment
builder.create_dfba_compartment(model, compartment_id=compartment_id, unit_volume=UNIT_VOLUME, create_port=True)
# dynamic species
model_fba = doc_fba.getModel()
builder.create_dfba_species(model, model_fba, compartment_id=compartment_id, unit_amount=UNIT_AMOUNT,
create_port=True)
# bounds
builder.create_exchange_bounds(model, model_fba=model_fba, unit_flux=UNIT_FLUX, create_ports=True)
# bounds
fba_prefix = "fba"
model_fba = doc_fba.getModel()
objects = []
ex_rids = utils.find_exchange_reactions(model_fba)
for ex_rid, sid in ex_rids.items():
r = model_fba.getReaction(ex_rid)
# lower & upper bound parameters
r_fbc = r.getPlugin(builder.SBML_FBC_NAME)
lb_id = r_fbc.getLowerFluxBound()
fba_lb_id = fba_prefix + lb_id
lb_value = model_fba.getParameter(lb_id).getValue()
objects.extend([
# default bounds from fba
mc.Parameter(sid=fba_lb_id, value=lb_value, unit=UNIT_FLUX, constant=False),
# uptake bounds (lower bound)
mc.AssignmentRule(sid=lb_id, value="max({}, -{}*{}/dt)".format(fba_lb_id, compartment_id, sid)),
])
mc.create_objects(model, objects)
sbmlio.write_sbml(doc, filepath=pjoin(directory, sbml_file), validate=True)
def bounds_model(sbml_file, directory, doc_fba=None):
""""
Submodel for dynamically calculating the flux bounds.
The dynamically changing flux bounds are the input to the
FBA model.
"""
doc = builder.template_doc_bounds(settings.MODEL_ID)
model = doc.getModel()
bounds_notes = notes.format("""
<h2>BOUNDS submodel</h2>
<p>Submodel for dynamically calculating the flux bounds.
The dynamically changing flux bounds are the input to the
FBA model.</p>
""")
utils.set_model_info(model, notes=bounds_notes, creators=creators, units=units, main_units=main_units)
# dt
compartment_id = "blood"
builder.create_dfba_dt(model, time_unit=UNIT_TIME, create_port=True)
# compartment
builder.create_dfba_compartment(model, compartment_id=compartment_id, unit_volume=UNIT_VOLUME, create_port=True)
# dynamic species
model_fba = doc_fba.getModel()
builder.create_dfba_species(model, model_fba, compartment_id=compartment_id, unit_amount=UNIT_AMOUNT,
create_port=True)
# bounds
builder.create_exchange_bounds(model, model_fba=model_fba, unit_flux=UNIT_FLUX, create_ports=True)
# bounds
fba_prefix = "fba"
model_fba = doc_fba.getModel()
objects = []
ex_rids = utils.find_exchange_reactions(model_fba)
for ex_rid, sid in ex_rids.items():
r = model_fba.getReaction(ex_rid)
# lower & upper bound parameters
r_fbc = r.getPlugin(builder.SBML_FBC_NAME)
lb_id = r_fbc.getLowerFluxBound()
fba_lb_id = fba_prefix + lb_id
lb_value = model_fba.getParameter(lb_id).getValue()
objects.extend([
# default bounds from fba
mc.Parameter(sid=fba_lb_id, value=lb_value, unit=UNIT_FLUX, constant=False),
# uptake bounds (lower bound)
mc.AssignmentRule(sid=lb_id, value="max({}, -{}*{}/dt)".format(fba_lb_id, compartment_id, sid)),
])
mc.create_objects(model, objects)
sbmlio.write_sbml(doc, filepath=pjoin(directory, sbml_file), validate=True)
def create_top_replacedBy(model, model_fba):
""" Creates the replacedBy Elements in the top model.
:param model:
:param model_fba:
:return:
"""
ex_rids = utils.find_exchange_reactions(model_fba)
for ex_rid, sid in ex_rids.items():
comp.replaced_by(model, DUMMY_REACTION_PREFIX + sid, ref_type=comp.SBASE_REF_TYPE_PORT,
submodel='fba', replaced_by="{}_port".format(EXCHANGE_REACTION_PREFIX + sid))
def create_top_replacements(model, model_fba, compartment_id):
""" Create all the replacements in the top model.
:param model:
:param model_fba:
:param compartment_id:
:return:
"""
# compartment
comp.replace_elements(model, compartment_id, ref_type=comp.SBASE_REF_TYPE_PORT,
replaced_elements={
'update': ['{}_port'.format(compartment_id)],
'bounds': ['{}_port'.format(compartment_id)]})
# dt
comp.replace_elements(model, 'dt', ref_type=comp.SBASE_REF_TYPE_PORT,
replaced_elements={'bounds': ['dt_port']})
# species dependent replacements
ex_rids = utils.find_exchange_reactions(model_fba)
for ex_rid, sid in ex_rids.items():
# flux parameters
comp.replace_elements(model, FLUX_PARAMETER_PREFIX + sid, ref_type=comp.SBASE_REF_TYPE_PORT,
replaced_elements={'update': ['{}_port'.format(FLUX_PARAMETER_PREFIX + sid)]})
# dynamic species
comp.replace_elements(model, sid, ref_type=comp.SBASE_REF_TYPE_PORT,
replaced_elements={
'bounds': ['{}_port'.format(sid)],
'update': ['{}_port'.format(sid)]})
# bounds of exchange reactions
for replace_id in [
UPPER_BOUND_PREFIX + EXCHANGE_REACTION_PREFIX + sid,
LOWER_BOUND_PREFIX + EXCHANGE_REACTION_PREFIX + sid]:
comp.replace_elements(model, replace_id, ref_type=comp.SBASE_REF_TYPE_PORT,
replaced_elements={
'bounds': ['{}_port'.format(replace_id)],
'fba': ['{}_port'.format(replace_id)]})
# replace units
for unit in model.getListOfUnitDefinitions():
uid = unit.getId()
comp.replace_element_in_submodels(model, uid, ref_type=comp.SBASE_REF_TYPE_UNIT,
submodels=['bounds', 'fba', 'update'])
def create_top_replacedBy(model, model_fba):
""" Creates the replacedBy Elements in the top model.
:param model:
:param model_fba:
:return:
"""
ex_rids = utils.find_exchange_reactions(model_fba)
for ex_rid, sid in ex_rids.items():
comp.replaced_by(
model,
DUMMY_REACTION_PREFIX + sid,
ref_type=comp.SBASE_REF_TYPE_PORT,
submodel='fba',
replaced_by="{}_port".format(EXCHANGE_REACTION_PREFIX + sid))
def create_update_reactions(model, model_fba, formula="-{}", unit_flux=None, modifiers=None):
""" Creates all update reactions with the given formula.
:param model:
:param model_fba:
:param formula:
:param unit_flux:
:param modifiers:
:return:
"""
if modifiers is None:
modifiers = []
ex_rids = utils.find_exchange_reactions(model_fba)
for ex_rid, sid in ex_rids.items():
create_update_parameter(model=model, sid=sid, unit_flux=unit_flux)
create_update_reaction(model=model, sid=sid, modifiers=modifiers, formula=formula)
def create_dynamic_bounds(model_bounds, model_fba, unit_flux=None):
""" Creates the dynamic bounds for the model.
It is necessary to create copies of the fixed bounds from the fba model
which are subsequently used in the dynamic bounds calculation.
:return:
"""
fba_suffix = "_fba"
objects = []
ex_rids = utils.find_exchange_reactions(model_fba)
for ex_rid, sid in ex_rids.items():
r = model_fba.getReaction(ex_rid)
r_fbc = r.getPlugin(SBML_FBC_NAME)
# get compartment from species
s = model_bounds.getSpecies(sid)
cid = s.getCompartment()
# upper bound parameter (export from FBA, i.e increase concentration)
ub_id = r_fbc.getUpperFluxBound()
fba_ub_id = ub_id + fba_suffix
ub_value = model_fba.getParameter(ub_id).getValue()
ub_formula = "{}".format(fba_ub_id)
objects.extend([
fac.Parameter(sid=fba_ub_id, value=ub_value, unit=unit_flux, constant=True, sboTerm=FLUX_BOUND_SBO),
fac.AssignmentRule(sid=ub_id, value=ub_formula, name="fba export bound ({})".format(sid)),
])
# lower bound parameter (import to FBA, i.e decrease concentration)
lb_id = r_fbc.getLowerFluxBound()
fba_lb_id = lb_id + fba_suffix
lb_value = model_fba.getParameter(lb_id).getValue()
# concentration/amount formula for import depending on available species
if s.getHasOnlySubstanceUnits():
lb_formula = "max({}, -{}/dt)".format(fba_lb_id, sid)
else:
lb_formula = "max({}, -{}*{}/dt)".format(fba_lb_id, cid, sid)
objects.extend([
# default bounds from fba
fac.Parameter(sid=fba_lb_id, value=lb_value, unit=unit_flux, constant=False, sboTerm=FLUX_BOUND_SBO),
# uptake bounds (lower bound)
fac.AssignmentRule(sid=lb_id, value=lb_formula, name="dfba import bound ({})".format(sid)),
])
fac.create_objects(model_bounds, objects)
def create_exchange_bounds(model_bounds,
model_fba,
unit_flux=None,
create_ports=True):
""" Creates the exchange reaction flux bounds in the bounds model.
:param model_bounds: the bounds model submodel
:param model_fba: the fba submodel
:param unit_flux: unit of fluxes
:param create_ports: should ports be created.
:return:
"""
ex_rids = utils.find_exchange_reactions(model_fba)
objects = []
port_sids = []
for ex_rid, sid in ex_rids.items():
r = model_fba.getReaction(ex_rid)
# lower & upper bound parameters
r_fbc = r.getPlugin(SBML_FBC_NAME)
lb_id = r_fbc.getLowerFluxBound()
lb_value = model_fba.getParameter(lb_id).getValue()
ub_id = r_fbc.getUpperFluxBound()
ub_value = model_fba.getParameter(ub_id).getValue()
# This creates the dynamical flux bound variables which are initialized with the
# constant fba bounds
objects.extend([
# for assignments
Parameter(sid=lb_id,
value=lb_value,
unit=unit_flux,
constant=False,
sboTerm=FLUX_BOUND_SBO),
Parameter(sid=ub_id,
value=ub_value,
unit=unit_flux,
constant=False,
sboTerm=FLUX_BOUND_SBO),
])
port_sids.extend([lb_id, ub_id])
# create bounds
factory.create_objects(model_bounds, objects)
# create ports
if create_ports:
comp.create_ports(model_bounds, idRefs=port_sids)
def create_dfba_species(model,
model_fba,
compartment_id,
hasOnlySubstanceUnits=False,
unit_amount=None,
create_port=True,
exclude_sids=[]):
""" Add DFBA species and compartments from fba model to model.
Creates the dynamic species and respetive compartments with
the necessary ports.
This is used in the bounds submodel, update submodel and the
and top model.
:param model:
:param model_fba:
:return:
"""
objects = []
ex_rids = utils.find_exchange_reactions(model_fba)
for ex_rid in ex_rids:
r = model_fba.getReaction(ex_rid)
sid = r.getReactant(0).getSpecies()
if sid in exclude_sids:
continue
# exchange species
s = model_fba.getSpecies(sid)
objects.append(
Species(sid=sid,
name=s.getName(),
initialConcentration=1.0,
substanceUnit=unit_amount,
hasOnlySubstanceUnits=hasOnlySubstanceUnits,
compartment=compartment_id,
port=create_port))
factory.create_objects(model, objects)
def create_update_reactions(model,
model_fba,
formula="-{}",
unit_flux=None,
modifiers=None):
""" Creates all update reactions with the given formula.
:param model:
:param model_fba:
:param formula:
:param unit_flux:
:param modifiers:
:return:
"""
if modifiers is None:
modifiers = []
ex_rids = utils.find_exchange_reactions(model_fba)
for ex_rid, sid in ex_rids.items():
create_update_parameter(model=model, sid=sid, unit_flux=unit_flux)
create_update_reaction(model=model,
sid=sid,
modifiers=modifiers,
formula=formula)
def create_dummy_reactions(model, model_fba, unit_flux=None):
""" Creates the dummy reactions.
This also creates the corresponding flux parameters and flux assignments.
:param model:
:param model_fba:
:param unit_flux:
:return:
"""
ex_rids = utils.find_exchange_reactions(model_fba)
objects = []
for ex_rid, sid in ex_rids.items():
pid_flux = FLUX_PARAMETER_PREFIX + sid
rid_flux = DUMMY_REACTION_PREFIX + sid
objects = [
# flux parameter: flux from fba (rate of reaction)
Parameter(sid=pid_flux,
value=1.0,
constant=True,
unit=unit_flux,
sboTerm=FLUX_PARAMETER_SBO),
# dummy reaction (pseudoreaction)
Reaction(sid=rid_flux,
reversible=False,
equation=" -> {}".format(DUMMY_SPECIES_ID),
sboTerm=DUMMY_REACTION_SBO,
formula=('0 {}'.format(unit_flux), unit_flux)),
# flux assignment rule
AssignmentRule(pid_flux,
value=rid_flux,
sboTerm=FLUX_ASSIGNMENTRULE_SBO),
]
factory.create_objects(model, objects)
def create_exchange_bounds(model_bounds, model_fba, unit_flux=None, create_ports=True):
""" Creates the exchange reaction flux bounds in the bounds model.
:param model_bounds: the bounds model submodel
:param model_fba: the fba submodel
:param unit_flux: unit of fluxes
:param create_ports: should ports be created.
:return:
"""
ex_rids = utils.find_exchange_reactions(model_fba)
objects = []
port_sids = []
for ex_rid, sid in ex_rids.items():
r = model_fba.getReaction(ex_rid)
# lower & upper bound parameters
r_fbc = r.getPlugin(SBML_FBC_NAME)
lb_id = r_fbc.getLowerFluxBound()
lb_value = model_fba.getParameter(lb_id).getValue()
ub_id = r_fbc.getUpperFluxBound()
ub_value = model_fba.getParameter(ub_id).getValue()
# This creates the dynamical flux bound variables which are initialized with the
# constant fba bounds
objects.extend([
# for assignments
fac.Parameter(sid=lb_id, value=lb_value, unit=unit_flux, constant=False, sboTerm=FLUX_BOUND_SBO),
fac.Parameter(sid=ub_id, value=ub_value, unit=unit_flux, constant=False, sboTerm=FLUX_BOUND_SBO),
])
port_sids.extend([lb_id, ub_id])
# create bounds
fac.create_objects(model_bounds, objects)
# create ports
if create_ports:
comp.create_ports(model_bounds, idRefs=port_sids)
def bounds_model(sbml_file, directory, doc_fba=None, annotations=None):
""""
Submodel for dynamically calculating the flux bounds.
The dynamically changing flux bounds are the input to the
FBA model.
"""
# TODO: the bounds model should be created based on the FBA model (i.e. use the exchange reactions
# to create the bounds info.
bounds_notes = notes.format("""
<h2>BOUNDS submodel</h2>
<p>Submodel for dynamically calculating the flux bounds.
The dynamically changing flux bounds are the input to the
FBA model.</p>
""")
doc = builder.template_doc_bounds(settings.MODEL_ID)
model = doc.getModel()
utils.set_model_info(model,
notes=bounds_notes,
creators=creators,
units=units,
main_units=main_units)
# dt
compartment_id = "bioreactor"
builder.create_dfba_dt(model, time_unit=UNIT_TIME, create_port=True)
# compartment
builder.create_dfba_compartment(model,
compartment_id=compartment_id,
unit_volume=UNIT_VOLUME,
create_port=True)
# dynamic species
model_fba = doc_fba.getModel()
builder.create_dfba_species(model,
model_fba,
compartment_id=compartment_id,
unit_amount=UNIT_AMOUNT,
create_port=True)
# bounds
builder.create_exchange_bounds(model,
model_fba=model_fba,
unit_flux=UNIT_FLUX,
create_ports=True)
# bounds
fba_infix = "fba_"
model_fba = doc_fba.getModel()
objects = []
ex_rids = utils.find_exchange_reactions(model_fba)
for ex_rid, sid in ex_rids.items():
r = model_fba.getReaction(ex_rid)
# lower & upper bound parameters
r_fbc = r.getPlugin(builder.SBML_FBC_NAME)
lb_id = r_fbc.getLowerFluxBound()
fba_lb_id = builder.LOWER_BOUND_PREFIX + fba_infix + ex_rid
lb_value = model_fba.getParameter(lb_id).getValue()
objects.extend([
# default bounds from fba
Parameter(sid=fba_lb_id,
value=lb_value,
unit=UNIT_FLUX,
constant=False),
])
factory.create_objects(model, objects)
objects = [
# kinetic lower bounds
Parameter(sid="lb_kin_EX_Glcxt",
value=builder.LOWER_BOUND_DEFAULT,
unit=UNIT_FLUX,
constant=False,
sboTerm="SBO:0000612"),
Parameter(sid="lb_kin_EX_O2",
value=builder.LOWER_BOUND_DEFAULT,
unit=UNIT_FLUX,
constant=False,
sboTerm="SBO:0000612"),
# parameters for kinetic bounds
Parameter(sid='Vmax_EX_O2', value=15, unit=UNIT_FLUX, constant=True),
Parameter(sid='Vmax_EX_Glcxt', value=10, unit=UNIT_FLUX,
constant=True),
Parameter(sid='Km_EX_Glcxt',
value=0.015,
unit=UNIT_CONCENTRATION,
name="Km_vGlcxt",
constant=True),
# kinetic bounds (unintuitive direction due to the identical concentrations in bioreactor and model)
AssignmentRule(sid="lb_kin_EX_Glcxt",
value="-Vmax_EX_Glcxt * Glcxt/(Km_EX_Glcxt + Glcxt)"),
AssignmentRule(sid="lb_kin_EX_O2", value="-Vmax_EX_O2"),
# exchange reaction bounds
# uptake bounds (lower bound)
# TODO: FIXME the X hack
# the bounds for the fba model have to be in mmol/h/gdw
AssignmentRule(
sid="lb_EX_Ac",
value="max(lb_fba_EX_Ac, -Ac/X/1 l_per_mmol*bioreactor/dt)"),
AssignmentRule(
sid="lb_EX_X",
value="max(lb_fba_EX_X, -X/X/1 l_per_mmol*bioreactor/dt)"),
AssignmentRule(
sid="lb_EX_Glcxt",
value="max(lb_kin_EX_Glcxt, -Glcxt/X/1 l_per_mmol*bioreactor/dt)"),
AssignmentRule(
sid="lb_EX_O2",
value="max(lb_kin_EX_O2, -O2/X/1 l_per_mmol*bioreactor/dt)"),
]
factory.create_objects(model, objects)
if annotations:
annotator.annotate_sbml_doc(doc, annotations)
sbmlio.write_sbml(doc, filepath=pjoin(directory, sbml_file), validate=True)
def update_exchange_reactions(model, flux_unit):
""" Updates existing exchange reaction in FBA model.
Sets all the necessary information and checks that correct.
This is mainly used to prepare the exchange reactions of metabolites.
:param flux_unit:
:param model:
:return:
"""
# mapping of bounds to reactions
bounds_dict = dict()
ex_rids = utils.find_exchange_reactions(model)
for ex_rid in ex_rids:
r = model.getReaction(ex_rid)
# make reversible
if not r.getReversible():
r.setReversible(True)
logging.info("Exchange reaction set reversible: {}".format(r.getId()))
# fix ids for exchange reactions
sref = r.getReactant(0)
sid = sref.getSpecies()
rid = r.getId()
if rid != EXCHANGE_REACTION_PREFIX + sid:
r.setId(EXCHANGE_REACTION_PREFIX + sid)
logging.warning("Exchange reaction fixd id: {} -> {}".format(rid, EXCHANGE_REACTION_PREFIX + sid))
# new lookup necessary, due to possible changed ids
ex_rids = utils.find_exchange_reactions(model)
for ex_rid in ex_rids:
r = model.getReaction(ex_rid)
fbc_r = r.getPlugin(SBML_FBC_NAME)
# store bounds in dictionary for value lookup
for f_bound in ["getLowerFluxBound", "getUpperFluxBound"]:
bound_id = getattr(fbc_r, f_bound).__call__()
bound = model.getParameter(bound_id)
bounds_dict[bound_id] = bound.getValue()
# create unique bounds for exchange reactions
for ex_rid in ex_rids:
r = model.getReaction(ex_rid)
fbc_r = r.getPlugin(SBML_FBC_NAME)
lb_value = model.getParameter(fbc_r.getLowerFluxBound()).getValue()
ub_value = model.getParameter(fbc_r.getUpperFluxBound()).getValue()
lb_id = LOWER_BOUND_PREFIX + ex_rid
ub_id = UPPER_BOUND_PREFIX + ex_rid
parameters = [
fac.Parameter(sid=lb_id,
value=lb_value,
unit=flux_unit, constant=True, sboTerm=FLUX_BOUND_SBO),
fac.Parameter(sid=ub_id,
value=ub_value,
unit=flux_unit, constant=True, sboTerm=FLUX_BOUND_SBO),
]
fac.create_objects(model, parameters)
# set bounds
fbc.set_flux_bounds(r, lb=lb_id, ub=ub_id)
# create ports for bounds and reaction
comp.create_ports(model, portType=comp.PORT_TYPE_PORT,
idRefs=[ex_rid, lb_id, ub_id])
# check all the exchange reactions
for ex_rid in ex_rids:
check_exchange_reaction(model, ex_rid)
def update_exchange_reactions(model, flux_unit):
""" Updates existing exchange reaction in FBA model.
Sets all the necessary information and checks that correct.
This is mainly used to prepare the exchange reactions of metabolites.
:param flux_unit:
:param model:
:return:
"""
# mapping of bounds to reactions
bounds_dict = dict()
ex_rids = utils.find_exchange_reactions(model)
for ex_rid in ex_rids:
r = model.getReaction(ex_rid)
# make reversible
if not r.getReversible():
r.setReversible(True)
logging.info("Exchange reaction set reversible: {}".format(
r.getId()))
# fix ids for exchange reactions
sref = r.getReactant(0)
sid = sref.getSpecies()
rid = r.getId()
if rid != EXCHANGE_REACTION_PREFIX + sid:
r.setId(EXCHANGE_REACTION_PREFIX + sid)
logging.warning("Exchange reaction fixd id: {} -> {}".format(
rid, EXCHANGE_REACTION_PREFIX + sid))
# new lookup necessary, due to possible changed ids
ex_rids = utils.find_exchange_reactions(model)
for ex_rid in ex_rids:
r = model.getReaction(ex_rid)
fbc_r = r.getPlugin(SBML_FBC_NAME)
# store bounds in dictionary for value lookup
for f_bound in ["getLowerFluxBound", "getUpperFluxBound"]:
bound_id = getattr(fbc_r, f_bound).__call__()
bound = model.getParameter(bound_id)
bounds_dict[bound_id] = bound.getValue()
# create unique bounds for exchange reactions
for ex_rid in ex_rids:
r = model.getReaction(ex_rid)
fbc_r = r.getPlugin(SBML_FBC_NAME)
lb_value = model.getParameter(fbc_r.getLowerFluxBound()).getValue()
ub_value = model.getParameter(fbc_r.getUpperFluxBound()).getValue()
lb_id = LOWER_BOUND_PREFIX + ex_rid
ub_id = UPPER_BOUND_PREFIX + ex_rid
parameters = [
Parameter(sid=lb_id,
value=lb_value,
unit=flux_unit,
constant=True,
sboTerm=FLUX_BOUND_SBO),
Parameter(sid=ub_id,
value=ub_value,
unit=flux_unit,
constant=True,
sboTerm=FLUX_BOUND_SBO),
]
factory.create_objects(model, parameters)
# set bounds
fbc.set_flux_bounds(r, lb=lb_id, ub=ub_id)
# create ports for bounds and reaction
comp.create_ports(model,
portType=comp.PORT_TYPE_PORT,
idRefs=[ex_rid, lb_id, ub_id])
# check all the exchange reactions
for ex_rid in ex_rids:
check_exchange_reaction(model, ex_rid)
def create_top_replacements(model, model_fba, compartment_id):
""" Create all the replacements in the top model.
:param model:
:param model_fba:
:param compartment_id:
:return:
"""
# compartment
comp.replace_elements(model,
compartment_id,
ref_type=comp.SBASE_REF_TYPE_PORT,
replaced_elements={
'update': ['{}_port'.format(compartment_id)],
'bounds': ['{}_port'.format(compartment_id)]
})
# dt
comp.replace_elements(model,
'dt',
ref_type=comp.SBASE_REF_TYPE_PORT,
replaced_elements={'bounds': ['dt_port']})
# species dependent replacements
ex_rids = utils.find_exchange_reactions(model_fba)
for ex_rid, sid in ex_rids.items():
# flux parameters
comp.replace_elements(
model,
FLUX_PARAMETER_PREFIX + sid,
ref_type=comp.SBASE_REF_TYPE_PORT,
replaced_elements={
'update': ['{}_port'.format(FLUX_PARAMETER_PREFIX + sid)]
})
# dynamic species
comp.replace_elements(model,
sid,
ref_type=comp.SBASE_REF_TYPE_PORT,
replaced_elements={
'bounds': ['{}_port'.format(sid)],
'update': ['{}_port'.format(sid)]
})
# bounds of exchange reactions
for replace_id in [
UPPER_BOUND_PREFIX + EXCHANGE_REACTION_PREFIX + sid,
LOWER_BOUND_PREFIX + EXCHANGE_REACTION_PREFIX + sid
]:
comp.replace_elements(model,
replace_id,
ref_type=comp.SBASE_REF_TYPE_PORT,
replaced_elements={
'bounds': ['{}_port'.format(replace_id)],
'fba': ['{}_port'.format(replace_id)]
})
# replace units
for unit in model.getListOfUnitDefinitions():
uid = unit.getId()
comp.replace_element_in_submodels(
model,
uid,
ref_type=comp.SBASE_REF_TYPE_UNIT,
submodels=['bounds', 'fba', 'update'])
def bounds_model(sbml_file, directory, doc_fba=None, annotations=None):
""""
Submodel for dynamically calculating the flux bounds.
The dynamically changing flux bounds are the input to the
FBA model.
"""
# TODO: the bounds model should be created based on the FBA model (i.e. use the exchange reactions
# to create the bounds info.
bounds_notes = notes.format("""
<h2>BOUNDS submodel</h2>
<p>Submodel for dynamically calculating the flux bounds.
The dynamically changing flux bounds are the input to the
FBA model.</p>
""")
doc = builder.template_doc_bounds(settings.MODEL_ID)
model = doc.getModel()
utils.set_model_info(model, notes=bounds_notes, creators=creators, units=units, main_units=main_units)
# dt
compartment_id = "bioreactor"
builder.create_dfba_dt(model, time_unit=UNIT_TIME, create_port=True)
# compartment
builder.create_dfba_compartment(model, compartment_id=compartment_id, unit_volume=UNIT_VOLUME, create_port=True)
# dynamic species
model_fba = doc_fba.getModel()
builder.create_dfba_species(model, model_fba, compartment_id=compartment_id, unit_amount=UNIT_AMOUNT,
create_port=True)
# bounds
builder.create_exchange_bounds(model, model_fba=model_fba, unit_flux=UNIT_FLUX, create_ports=True)
# bounds
fba_infix = "fba_"
model_fba = doc_fba.getModel()
objects = []
ex_rids = utils.find_exchange_reactions(model_fba)
for ex_rid, sid in ex_rids.items():
r = model_fba.getReaction(ex_rid)
# lower & upper bound parameters
r_fbc = r.getPlugin(builder.SBML_FBC_NAME)
lb_id = r_fbc.getLowerFluxBound()
fba_lb_id = builder.LOWER_BOUND_PREFIX + fba_infix + ex_rid
lb_value = model_fba.getParameter(lb_id).getValue()
objects.extend([
# default bounds from fba
mc.Parameter(sid=fba_lb_id, value=lb_value, unit=UNIT_FLUX, constant=False),
])
mc.create_objects(model, objects)
objects = [
# kinetic lower bounds
mc.Parameter(sid="lb_kin_EX_Glcxt", value=builder.LOWER_BOUND_DEFAULT, unit=UNIT_FLUX, constant=False,
sboTerm="SBO:0000612"),
mc.Parameter(sid="lb_kin_EX_O2", value=builder.LOWER_BOUND_DEFAULT, unit=UNIT_FLUX, constant=False,
sboTerm="SBO:0000612"),
# parameters for kinetic bounds
mc.Parameter(sid='Vmax_EX_O2', value=15, unit=UNIT_FLUX, constant=True),
mc.Parameter(sid='Vmax_EX_Glcxt', value=10, unit=UNIT_FLUX, constant=True),
mc.Parameter(sid='Km_EX_Glcxt', value=0.015, unit=UNIT_CONCENTRATION, name="Km_vGlcxt", constant=True),
# kinetic bounds (unintuitive direction due to the identical concentrations in bioreactor and model)
mc.AssignmentRule(sid="lb_kin_EX_Glcxt", value="-Vmax_EX_Glcxt * Glcxt/(Km_EX_Glcxt + Glcxt)"),
mc.AssignmentRule(sid="lb_kin_EX_O2", value="-Vmax_EX_O2"),
# exchange reaction bounds
# uptake bounds (lower bound)
# TODO: FIXME the X hack
# the bounds for the fba model have to be in mmol/h/gdw
mc.AssignmentRule(sid="lb_EX_Ac", value="max(lb_fba_EX_Ac, -Ac/X/1 l_per_mmol*bioreactor/dt)"),
mc.AssignmentRule(sid="lb_EX_X", value="max(lb_fba_EX_X, -X/X/1 l_per_mmol*bioreactor/dt)"),
mc.AssignmentRule(sid="lb_EX_Glcxt", value="max(lb_kin_EX_Glcxt, -Glcxt/X/1 l_per_mmol*bioreactor/dt)"),
mc.AssignmentRule(sid="lb_EX_O2", value="max(lb_kin_EX_O2, -O2/X/1 l_per_mmol*bioreactor/dt)"),
]
mc.create_objects(model, objects)
if annotations:
annotation.annotate_sbml_doc(doc, annotations)
sbmlio.write_sbml(doc, filepath=pjoin(directory, sbml_file), validate=True)