def run_cobra_model(self):
cobra_model = load_json_model(data_dir_tests + '/mini.json')
convert_to_irreversible(cobra_model)
solution = cobra_model.optimize()
assert(solution.objective_value == 30.0)
assert(solution.fluxes['ENO'] == 20.0)
self.cobra_model = cobra_model
def isotopomer_model_iteration1():
'''iteration 1:
identification of reactions that can be lumped in pathways outside the model scope'''
cobra_model = load_ALEWt();
# Make the model irreversible for downstream manipulations:
convert_to_irreversible(cobra_model);
# Add lumped isotopomer reactions
add_net_reaction(cobra_model,isotopomer_rxns_net_irreversible);
# Find minimal flux solution:
pfba = optimize_minimal_flux(cobra_model,True,solver='gurobi');
# Write pfba solution to file
with open('data\\iteration1_140407_ijo1366_reduced_modified_pfba.csv',mode='wb') as outfile:
writer = csv.writer(outfile)
writer.writerow(['Reaction','Flux'])
for k,v in cobra_model.solution.x_dict.items():
writer.writerow([k,v]);
# Read in pfba solution
pfba_sol = {};
with open('data\\iteration1_140407_ijo1366_reduced_modified_pfba.csv',mode='r') as infile:
dictreader = csv.DictReader(infile)
for r in dictreader:
pfba_sol[r['Reaction']] = r['Flux'];
# Make net reactions for pathways outside of the scope
# of the isotopomer model
subs = ['Cell Envelope Biosynthesis',
'Glycerophospholipid Metabolism',
'Lipopolysaccharide Biosynthesis / Recycling',
'Membrane Lipid Metabolism',
'Murein Biosynthesis'
'Murein Recycling',
'Cofactor and Prosthetic Group Biosynthesis',
#'Transport, Inner Membrane',
#'Transport, Outer Membrane',
#'Transport, Outer Membrane Porin',
'tRNA Charging',
'Unassigned',
'Exchange',
'Inorganic Ion Transport and Metabolism',
'Nitrogen Metabolism'];
add_net_reaction_subsystem(cobra_model,pfba_sol,subs);
remove_noflux_reactions(cobra_model,pfba_sol,['Transport, Outer Membrane Porin','Transport, Inner Membrane','Transport, Outer Membrane'])
revert_to_reversible(cobra_model);
# write model to sbml
write_cobra_model_to_sbml_file(cobra_model,'data\\iteration1_140407_ijo1366_netrxn_irreversible.xml')
# Reduce model using FVA:
reduce_model(cobra_model,"data\\iteration1_140407_ijo1366_reduced.xml")
# Remove all reactions with 0 flux
remove_noflux_reactions(cobra_model);
with open('data\\iteration1_140407_ijo1366_reduced_netrxn_lbub.csv',mode='wb') as outfile:
writer = csv.writer(outfile)
writer.writerow(['Reaction','Formula','LB','UB','Subsystem'])
for r in cobra_model.reactions:
writer.writerow([r.id,
r.build_reaction_string(),
r.lower_bound,
r.upper_bound,
r.subsystem]);
def isotopomer_model_iteration1():
'''iteration 1:
identification of reactions that can be lumped in pathways outside the model scope'''
cobra_model = load_ALEWt();
# Make the model irreversible for downstream manipulations:
convert_to_irreversible(cobra_model);
# Add lumped isotopomer reactions
add_net_reaction(cobra_model,isotopomer_rxns_net_irreversible);
# Find minimal flux solution:
pfba = optimize_minimal_flux(cobra_model,True,solver='gurobi');
# Write pfba solution to file
with open('data/iteration1_140407_ijo1366_reduced_modified_pfba.csv',mode='wb') as outfile:
writer = csv.writer(outfile)
writer.writerow(['Reaction','Flux'])
for k,v in cobra_model.solution.x_dict.items():
writer.writerow([k,v]);
# Read in pfba solution
pfba_sol = {};
with open('data/iteration1_140407_ijo1366_reduced_modified_pfba.csv',mode='r') as infile:
dictreader = csv.DictReader(infile)
for r in dictreader:
pfba_sol[r['Reaction']] = r['Flux'];
# Make net reactions for pathways outside of the scope
# of the isotopomer model
subs = ['Cell Envelope Biosynthesis',
'Glycerophospholipid Metabolism',
'Lipopolysaccharide Biosynthesis / Recycling',
'Membrane Lipid Metabolism',
'Murein Biosynthesis'
'Murein Recycling',
'Cofactor and Prosthetic Group Biosynthesis',
#'Transport, Inner Membrane',
#'Transport, Outer Membrane',
#'Transport, Outer Membrane Porin',
'tRNA Charging',
'Unassigned',
'Exchange',
'Inorganic Ion Transport and Metabolism',
'Nitrogen Metabolism'];
add_net_reaction_subsystem(cobra_model,pfba_sol,subs);
remove_noflux_reactions(cobra_model,pfba_sol,['Transport, Outer Membrane Porin','Transport, Inner Membrane','Transport, Outer Membrane'])
revert_to_reversible(cobra_model);
# write model to sbml
write_cobra_model_to_sbml_file(cobra_model,'data/iteration1_140407_ijo1366_netrxn_irreversible.xml')
# Reduce model using FVA:
reduce_model(cobra_model,"data/iteration1_140407_ijo1366_reduced.xml")
# Remove all reactions with 0 flux
remove_noflux_reactions(cobra_model);
with open('data/iteration1_140407_ijo1366_reduced_netrxn_lbub.csv',mode='wb') as outfile:
writer = csv.writer(outfile)
writer.writerow(['Reaction','Formula','LB','UB','Subsystem'])
for r in cobra_model.reactions:
writer.writerow([r.id,
r.build_reaction_string(),
r.lower_bound,
r.upper_bound,
r.subsystem]);
def initialize(model_name='core',
carbon_sources={},
irreversible=False,
ATP_maintenance=False,
BM_lower_bound=0.1):
if model_name == 'core':
model = create_cobra_model_from_sbml_file('data/ecoli_core.xml',
old_sbml=True)
if irreversible:
convert_to_irreversible(model)
# the core model has these annoying '_b' metabolites that are used as
# 'ghost' metabolites that balance the exchange reactions. they should
# be ignored in the mass-balance equation and therefore the best way to
# deal with them is to remove them from all the reactions
for m in model.metabolites:
if str(m).endswith('_b'):
for r in m.get_reaction():
coeff = r.get_coefficient(m)
r.add_metabolites({m: -coeff})
rxns = dict([(r.id, r) for r in model.reactions])
if not ATP_maintenance:
rxns[
'ATPM'].lower_bound = 0 # remove the ATP maintenance requirement
rxns[
'EX_glc_e'].lower_bound = 0 # remove the default carbon source
elif model_name == 'full':
model = create_cobra_model_from_sbml_file('data/iJO1366.xml')
rxns = dict([(r.id, r) for r in model.reactions])
if not ATP_maintenance:
rxns[
'ATPM'].lower_bound = 0 # remove the ATP maintenance requirement
rxns[
'EX_glc_e'].lower_bound = 0 # remove the default carbon source
elif model_name == 'toy':
model = create_cobra_model_from_sbml_file('data/toymodel.xml')
for key, val in carbon_sources.items():
rxns['EX_' + key + '_e'].lower_bound = val
# set BM lower bound
for r in model.reactions:
if r.objective_coefficient != 0:
r.lower_bound = BM_lower_bound
m = Model()
m.cobra_model = model
if model_name == 'core':
# the ED pathway and exchange reactions are missing from the
# core model. Add them now.
m.knockin_reactions('EDD,EDA', 0, 1000)
m.knockin_reactions(
'EX_g6p,EX_f6p,EX_xu5p_D,EX_r5p,EX_dhap,'
'EX_2pg,EX_e4p,EX_6pgc', 0, 0)
return m
def test_modify_reversible(self):
model1 = self.model
model1.optimize()
model2 = create_test_model()
modify.convert_to_irreversible(model2)
model2.optimize()
self.assertAlmostEqual(model1.solution.f, model2.solution.f, places=3)
modify.revert_to_reversible(model2)
model2.optimize()
self.assertAlmostEqual(model1.solution.f, model2.solution.f, places=3)
def test_modify_reversible(self):
model1 = self.model
model1.optimize()
model2 = create_test_model()
modify.convert_to_irreversible(model2)
model2.optimize()
self.assertAlmostEqual(model1.solution.f, model2.solution.f, places=3)
modify.revert_to_reversible(model2)
model2.optimize()
self.assertAlmostEqual(model1.solution.f, model2.solution.f, places=3)
def construct_loopless_model(cobra_model):
"""Construct a loopless model.
This adds MILP constraints to prevent flux from proceeding in a loop, as
done in http://dx.doi.org/10.1016/j.bpj.2010.12.3707
Please see the documentation for an explanation of the algorithm.
This must be solved with an MILP capable solver.
"""
# copy the model and make it irreversible
model = cobra_model.copy()
convert_to_irreversible(model)
max_ub = max(model.reactions.list_attr("upper_bound"))
# a dict for storing S^T
thermo_stoic = {
"thermo_var_" + metabolite.id: {}
for metabolite in model.metabolites
}
# Slice operator is so that we don't get newly added metabolites
original_metabolites = model.metabolites[:]
for reaction in model.reactions[:]:
# Boundary reactions are not subjected to these constraints
if len(reaction._metabolites) == 1:
continue
# populate the S^T dict
bound_id = "thermo_bound_" + reaction.id
for met, stoic in iteritems(reaction._metabolites):
thermo_stoic["thermo_var_" + met.id][bound_id] = stoic
# I * 1000 > v --> I * 1000 - v > 0
reaction_ind = Reaction(reaction.id + "_indicator")
reaction_ind.variable_kind = "integer"
reaction_ind.upper_bound = 1
reaction_ub = Metabolite(reaction.id + "_ind_ub")
reaction_ub._constraint_sense = "G"
reaction.add_metabolites({reaction_ub: -1})
reaction_ind.add_metabolites({reaction_ub: max_ub})
# This adds a compensating term for 0 flux reactions, so we get
# S^T x - (1 - I) * 1001 < -1 which becomes
# S^T x < 1000 for 0 flux reactions and
# S^T x < -1 for reactions with nonzero flux.
reaction_bound = Metabolite(bound_id)
reaction_bound._constraint_sense = "L"
reaction_bound._bound = max_ub
reaction_ind.add_metabolites({reaction_bound: max_ub + 1})
model.add_reaction(reaction_ind)
for metabolite in original_metabolites:
metabolite_var = Reaction("thermo_var_" + metabolite.id)
metabolite_var.lower_bound = -max_ub
model.add_reaction(metabolite_var)
metabolite_var.add_metabolites({
model.metabolites.get_by_id(k): v
for k, v in iteritems(thermo_stoic[metabolite_var.id])
})
return model
def GeometricSol(model,
IncZeroes=True,
AsMtx=False,
tol=1e-6,
Print=False,
cobra=False):
state = model.GetState()
reacs = model.reactions
model.SetObjAsConstraint(name='FluxDiff' + str(0) + '_mindifffromflux')
### iteraion 1
model.SetObjDirec("Min")
it = 1
model.ZeroObjective()
modify.convert_to_irreversible(model)
model.SetObjective(model.Reactions())
model.Solve(False)
model.SetObjAsConstraint(name='FluxDiff' + str(it) + '_mindifffromflux')
fva = model.FVA(reaclist=reacs, tol=tol, PrintStatus=False, cobra=cobra)
meanflux = fva.GetReacsMeanFlux(fva.keys())
flux = dict(meanflux)
flux_id = {}
for reac in flux:
flux_id[reac.id] = flux[reac]
delta = fva.MaxDiff()
variablereacs = fva.Variable(tol)
variablereacs_id = [reac.id for reac in variablereacs]
if Print:
print("Iteration " + str(it) + ", " + str(len(variablereacs)) +
" varible reactions, Max difference = " + str(delta))
it += 1
### iteration n
print(variablereacs)
while (delta > tol):
model.MinDiffFromFlux(flux_id, variablereacs_id, it, cleanup=False)
model.SetObjAsConstraint(name='FluxDiff' + str(it) +
'_mindifffromflux')
fva = model.FVA(reaclist=variablereacs.keys(),
tol=0,
PrintStatus=False,
cobra=cobra)
meanflux = fva.GetReacsMeanFlux(fva.keys())
flux.update(meanflux)
variablereacs = fva.Variable(tol)
delta = fva.MaxDiff()
if Print:
print("Iteration " + str(it) + ", " + str(len(variablereacs)) +
" varible reactions, Max difference = " + str(delta))
it += 1
### cleanup
model.CleanUpTempVar("_mindifffromflux")
model.MergeRev()
model.SetState(state)
rv = model.GetSol(IncZeroes=True, AsMtx=False, sol=flux)
return rv
def construct_loopless_model(cobra_model):
"""Construct a loopless model.
This adds MILP constraints to prevent flux from proceeding in a loop, as
done in http://dx.doi.org/10.1016/j.bpj.2010.12.3707
Please see the documentation for an explanation of the algorithm.
This must be solved with an MILP capable solver.
"""
# copy the model and make it irreversible
model = cobra_model.copy()
convert_to_irreversible(model)
max_ub = max(model.reactions.list_attr("upper_bound"))
# a dict for storing S^T
thermo_stoic = {"thermo_var_" + metabolite.id: {}
for metabolite in model.metabolites}
# Slice operator is so that we don't get newly added metabolites
original_metabolites = model.metabolites[:]
for reaction in model.reactions[:]:
# Boundary reactions are not subjected to these constraints
if len(reaction._metabolites) == 1:
continue
# populate the S^T dict
bound_id = "thermo_bound_" + reaction.id
for met, stoic in iteritems(reaction._metabolites):
thermo_stoic["thermo_var_" + met.id][bound_id] = stoic
# I * 1000 > v --> I * 1000 - v > 0
reaction_ind = Reaction(reaction.id + "_indicator")
reaction_ind.variable_kind = "integer"
reaction_ind.upper_bound = 1
reaction_ub = Metabolite(reaction.id + "_ind_ub")
reaction_ub._constraint_sense = "G"
reaction.add_metabolites({reaction_ub: -1})
reaction_ind.add_metabolites({reaction_ub: max_ub})
# This adds a compensating term for 0 flux reactions, so we get
# S^T x - (1 - I) * 1001 < -1 which becomes
# S^T x < 1000 for 0 flux reactions and
# S^T x < -1 for reactions with nonzero flux.
reaction_bound = Metabolite(bound_id)
reaction_bound._constraint_sense = "L"
reaction_bound._bound = max_ub
reaction_ind.add_metabolites({reaction_bound: max_ub + 1})
model.add_reaction(reaction_ind)
for metabolite in original_metabolites:
metabolite_var = Reaction("thermo_var_" + metabolite.id)
metabolite_var.lower_bound = -max_ub
model.add_reaction(metabolite_var)
metabolite_var.add_metabolites(
{model.metabolites.get_by_id(k): v
for k, v in iteritems(thermo_stoic[metabolite_var.id])})
return model
def get_pfba_fluxes(cobra_model):
convert_to_irreversible(cobra_model)
pfba_sol = pfba(cobra_model, solver='cglpk', already_irreversible=True)
x_dict = dict(pfba_sol.x_dict.items())
print("FBA JSON: %s, %f" % (pfba_sol.status, x_dict[BM_RXN]))
# revert the solution to a reversible one:
reverse_reactions = [x for x in x_dict.keys() if x.endswith('_reverse')]
for rxn_id in reverse_reactions:
fwd_id = rxn_id.replace('_reverse', '')
x_dict[fwd_id] -= x_dict[rxn_id]
x_dict.pop(rxn_id)
return x_dict
def perform_pFBA(model, cs, gr, ur):
model = deepcopy(model)
convert_to_irreversible(model)
rxns = dict([(r.id, r) for r in model.reactions])
rxns['EX_glc_e'].lower_bound = 0 # uptake of carbon source reaction is initialized
try:
rxns['EX_' + cs + '_e'].lower_bound = -ur # redefine sole carbon source uptake reaction in mmol/gr/h
except:
print cs, ur
rxns['EX_glc_e'].lower_bound = -ur
rxns['Ec_biomass_iJO1366_core_53p95M'].upper_bound = gr
print "solving pFBA",
optimize_minimal_flux(model, already_irreversible=True)
flux_dist = pd.DataFrame(model.solution.x_dict.items()).set_index(0)
return flux_dist
def perform_pFBA(condition):
cs = gc['media_key'].loc[condition]
gr = gc['growth rate [h-1]'].loc[condition]
m = create_cobra_model_from_sbml_file('../data/iJO1366.xml')
m.reactions.get_by_id('EX_glc_e').lower_bound = 0
convert_to_irreversible(m)
reac = dict([(r.id, r) for r in m.reactions])
try:
reac['EX_' + cs + '_e'].lower_bound = -1000 # redefine sole carbon source uptake reaction in mmol/gr/h
except KeyError:
raise 'media key not in model'
reac['Ec_biomass_iJO1366_core_53p95M'].objective_coefficient = 0
reac['Ec_biomass_iJO1366_WT_53p95M'].objective_coefficient = 1
reac['Ec_biomass_iJO1366_WT_53p95M'].upper_bound = gr
print "solving pFBA for %s" %condition
optimize_minimal_flux(m, already_irreversible=True)
return pd.Series(m.solution.x_dict)
def __init__(self):
self.cobra_model = create_cobra_model_from_sbml_file(S.ECOLI_SBML_FNAME)
convert_to_irreversible(self.cobra_model)
self.met_conc_df = self.get_metabolite_data()
self.km_df = self.get_km_data()
self.enz_conc_df, self.enz_mw_df = self.get_enzyme_data()
self.flux_df = self.get_flux_data()
self.data_df = pd.merge(self.km_df, self.met_conc_df, on='bigg.metabolite')
self.data_df = pd.merge(self.data_df, self.enz_conc_df, on=['bigg.reaction', 'condition'])
self.data_df = pd.merge(self.data_df, self.enz_mw_df, on=['bigg.reaction'])
self.data_df = pd.merge(self.data_df, self.flux_df, on=['bigg.reaction', 'condition'])
# keep only rows with non-zero flux, non-zero enzyme, and stoichiometry coeff = 1
ind = (self.data_df['flux [mmol/gCDW/h]'] > 0) & \
(self.data_df['enzyme conc [M]'] > 0) & \
(self.data_df['stoichiometry'] == -1)
self.data_df = self.data_df[ind]
def test_modify_reversible(self):
model1 = create_test_model("textbook")
model1.optimize()
model2 = create_test_model("textbook")
modify.convert_to_irreversible(model2)
model2.optimize()
self.assertAlmostEqual(model1.solution.f, model2.solution.f, places=3)
modify.revert_to_reversible(model2)
model2.optimize()
self.assertAlmostEqual(model1.solution.f, model2.solution.f, places=3)
# Ensure revert_to_reversible is robust to solutions generated both
# before and after reversibility conversion, or not solved at all.
model3 = create_test_model("textbook")
model3.optimize()
modify.convert_to_irreversible(model3)
modify.revert_to_reversible(model3)
self.assertAlmostEqual(model1.solution.f, model3.solution.f, places=3)
# test reaction where both bounds are negative
model4 = create_test_model("textbook")
glc = model4.reactions.get_by_id("EX_glc__D_e")
glc.upper_bound = -1
modify.convert_to_irreversible(model4)
model4.optimize()
self.assertAlmostEqual(model1.solution.f, model4.solution.f, places=3)
glc_rev = model4.reactions.get_by_id(glc.notes["reflection"])
self.assertEqual(glc_rev.lower_bound, 1)
self.assertEqual(glc.upper_bound, 0)
modify.revert_to_reversible(model4)
self.assertEqual(glc.upper_bound, -1)
def test_modify_reversible(self):
model1 = create_test_model("textbook")
model1.optimize()
model2 = create_test_model("textbook")
modify.convert_to_irreversible(model2)
model2.optimize()
self.assertAlmostEqual(model1.solution.f, model2.solution.f, places=3)
modify.revert_to_reversible(model2)
model2.optimize()
self.assertAlmostEqual(model1.solution.f, model2.solution.f, places=3)
# Ensure revert_to_reversible is robust to solutions generated both
# before and after reversibility conversion, or not solved at all.
model3 = create_test_model("textbook")
model3.optimize()
modify.convert_to_irreversible(model3)
modify.revert_to_reversible(model3)
self.assertAlmostEqual(model1.solution.f, model3.solution.f, places=3)
# test reaction where both bounds are negative
model4 = create_test_model("textbook")
glc = model4.reactions.get_by_id("EX_glc__D_e")
glc.upper_bound = -1
modify.convert_to_irreversible(model4)
model4.optimize()
self.assertAlmostEqual(model1.solution.f, model4.solution.f, places=3)
glc_rev = model4.reactions.get_by_id(glc.notes["reflection"])
self.assertEqual(glc_rev.lower_bound, 1)
self.assertEqual(glc.upper_bound, 0)
modify.revert_to_reversible(model4)
self.assertEqual(glc.upper_bound, -1)
def __init__(self):
self.model = create_cobra_model_from_sbml_file("../data/iJO1366.xml")
# Modify model
convert_to_irreversible(self.model)
self.rxns = dict([(r.id, r) for r in self.model.reactions])
self.genes = dict([(g.id, g) for g in self.model.genes])
add_to_model(self.model)
self.include_specific_isozmyes()
self.gc = pd.DataFrame.from_csv("../data/growth_conditions.csv")
flux = pd.DataFrame.from_csv('../data/flux[mmol_gCDW_h].csv')
self.v = self._convert_mmol_gCDW_h_to_mmol_gCDW_s(flux)
# PPKr_reverse reaction is used for ATP generation from ADP
# in the FBA model. Nevertheless, acording to EcoCyc, it is used to
# to generate polyP (inorganic phosphate) chains from ATP and it is not
# part of the oxidative phosphorilation, thus removed from rate calculations
if 'PPKr_reverse' in self.v.index:
self.v.drop('PPKr_reverse', axis=0, inplace=True)
self.enzymatic_reactions = self._enzymatic_reactions()
self.homomeric_reactions = self.reactions_by_homomeric_enzymes()
proteins_copies_fL = pd.DataFrame.from_csv(
'../data/meta_abundance[copies_fL].csv')
self.proteins_mmol_gCDW = self._convert_copies_fL_to_mmol_gCDW(
proteins_copies_fL)
self.E = self.map_expression_by_reaction()
self.kapp = self.get_kapp() # per subunit
self.SA = self.get_specific_activity()
self.kcat = pd.DataFrame.from_csv("../data/kcat_data.csv")
self.p_per_as = (self.kcat['polypeptides per complex'] /
self.kcat['catalytic sites per complex'])
self.kmax = self.get_kmax(self.kapp)
self.SAmax = self.get_maximum_specific_activity(self.SA)
def init_wt_model(model_name, carbon_sources, reversible=False, ATP_maintenance=False, BM_lower_bound=0.1):
if model_name == 'core':
model = create_cobra_model_from_sbml_file('../shared_data/ecoli_core_model.xml', old_sbml=True)
if reversible:
convert_to_irreversible(model)
# the core model has these annoying '_b' metabolites that are used as
# 'ghost' metabolites that balance the exchange reactions. they should
# be ignored in the mass-balance equation and therefore the best way to
# deal with them is to remove them from all the reactions
## for m in model.metabolites: ## didn't work
for m in [r.id for r in model.metabolites]: ## Yinon
if m.endswith('_b'):
for r in m.get_reaction():
coeff = r.get_coefficient(m)
r.add_metabolites({m : -coeff})
rxns = dict([(r.id, r) for r in model.reactions])
if not ATP_maintenance:
rxns['ATPM'].lower_bound = 0 # remove the ATP maintenance requirement
rxns['EX_glc_e'].lower_bound = 0 # remove the default carbon source
elif model_name == 'full':
model = create_cobra_model_from_sbml_file('../shared_data/iJO1366.xml', old_sbml=True)
rxns = dict([(r.id, r) for r in model.reactions])
if not ATP_maintenance:
rxns['ATPM'].lower_bound = 0 # remove the ATP maintenance requirement
rxns['EX_glc_e'].lower_bound = 0 # remove the default carbon source
elif model_name == 'toy':
model = create_cobra_model_from_sbml_file('data/toymodel.xml')
for key, val in carbon_sources.iteritems():
rxns['EX_' + key + '_e'].lower_bound = val
# set BM lower bound
for r in model.reactions:
if r.objective_coefficient != 0:
r.lower_bound = BM_lower_bound
return model
def __init__(self, flux, abundance):
self.model = create_cobra_model_from_sbml_file("../data/iJO1366.xml")
convert_to_irreversible(self.model)
self.rxns = {r.id:r for r in self.model.reactions}
self._update_subsystems_for_reverse_direction()
g_gCDW = abundance
mmol_gCDW_h = flux
mmol_gCDW_h = mmol_gCDW_h[mmol_gCDW_h>1e-10]
self.conditions = pd.DataFrame.from_csv("../data/conditions.csv")
self.conditions.sort_values('growth rate Gerosa [h-1]', inplace=True)
self.conditions = self.conditions.loc[mmol_gCDW_h.columns &
g_gCDW.columns]
self.cs = self.conditions.index
self.gr = self.conditions["growth rate Gerosa [h-1]"]
self.cmap = plt.cm.viridis
colors = list(self.cmap(np.linspace(0,0.9,6))) + ['#ffd11a']
self.colors = dict(zip(list(self.cs), colors))
self.umol_gCDW_min = mmol_gCDW_h[self.cs] * 1e3 / 60
self.umol_gCDW_min.replace(np.nan, 0, inplace=True)
self.mg_gCDW = g_gCDW.loc[map(str, self.model.genes), self.cs] * 1e3
self.mg_gCDW.replace(np.nan, 0, inplace=True)
self.flux_carrying_rxns = self.flux_carrying_reactions()
self.E = self.map_enzyme_mass_to_reactions()
self.SA = self.specific_activity()
self.kmax = self.get_kmax()
self.vmax = self.get_vmax()
self.Emin = self.get_Emin()
self.CU = self.capacity_usage()
self.MCU = self.metabolic_capacity_usage()
self.kcat = self.load_kcats()
def __init__(self):
self.model = create_cobra_model_from_sbml_file("../data/iJO1366.xml")
# Modify model
convert_to_irreversible(self.model)
self.rxns = dict([(r.id, r) for r in self.model.reactions])
self.genes = dict([(g.id, g) for g in self.model.genes])
add_to_model(self.model)
self.include_specific_isozmyes()
self.gc = pd.DataFrame.from_csv("../data/growth_conditions.csv")
flux = pd.DataFrame.from_csv('../data/flux[mmol_gCDW_h].csv')
self.v = self._convert_mmol_gCDW_h_to_mmol_gCDW_s(flux)
# PPKr_reverse reaction is used for ATP generation from ADP
# in the FBA model. Nevertheless, acording to EcoCyc, it is used to
# to generate polyP (inorganic phosphate) chains from ATP and it is not
# part of the oxidative phosphorilation, thus removed from rate calculations
if 'PPKr_reverse' in self.v.index:
self.v.drop('PPKr_reverse', axis=0, inplace=True)
self.enzymatic_reactions = self._enzymatic_reactions()
self.homomeric_reactions = self.reactions_by_homomeric_enzymes()
proteins_copies_fL = pd.DataFrame.from_csv('../data/meta_abundance[copies_fL].csv')
self.proteins_mmol_gCDW = self._convert_copies_fL_to_mmol_gCDW(proteins_copies_fL)
self.E = self.map_expression_by_reaction()
self.kapp = self.get_kapp() # per subunit
self.SA = self.get_specific_activity()
self.kcat = pd.DataFrame.from_csv("../data/kcat_data.csv")
self.p_per_as = (self.kcat['polypeptides per complex']
/ self.kcat['catalytic sites per complex'])
self.kmax = self.get_kmax(self.kapp)
self.SAmax = self.get_maximum_specific_activity(self.SA)
def test_modify_reversible(self):
model1 = create_test_model("textbook")
model1.optimize()
model2 = create_test_model("textbook")
modify.convert_to_irreversible(model2)
model2.optimize()
self.assertAlmostEqual(model1.solution.f, model2.solution.f, places=3)
modify.revert_to_reversible(model2)
model2.optimize()
self.assertAlmostEqual(model1.solution.f, model2.solution.f, places=3)
# Ensure revert_to_reversible is robust to solutions generated both
# before and after reversibility conversion, or not solved at all.
model3 = create_test_model("textbook")
model3.optimize()
modify.convert_to_irreversible(model3)
modify.revert_to_reversible(model3)
self.assertAlmostEqual(model1.solution.f, model3.solution.f, places=3)
model4 = create_test_model("textbook")
modify.convert_to_irreversible(model4)
modify.revert_to_reversible(model4)
def test_modify_reversible(self):
model1 = self.model
model1.optimize()
model2 = create_test_model()
modify.convert_to_irreversible(model2)
model2.optimize()
self.assertAlmostEqual(model1.solution.f, model2.solution.f, places=3)
modify.revert_to_reversible(model2)
model2.optimize()
self.assertAlmostEqual(model1.solution.f, model2.solution.f, places=3)
# Ensure revert_to_reversible is robust to solutions generated both
# before and after reversibility conversion, or not solved at all.
model3 = create_test_model()
model3.optimize()
modify.convert_to_irreversible(model3)
modify.revert_to_reversible(model3)
self.assertAlmostEqual(model1.solution.f, model3.solution.f, places=3)
model4 = create_test_model()
modify.convert_to_irreversible(model4)
modify.revert_to_reversible(model4)
def check_thermodynamicConstraints(self,simulation_id_I,models_I,rxn_ids_I=[],
inconsistent_dG_f_I=[],inconsistent_concentrations_I=[],
measured_concentration_coverage_criteria_I=0.5,
measured_dG_f_coverage_criteria_I=0.99,
n_checks_I = 5,
diagnose_solver_I='glpk',diagnose_threshold_I=0.98,diagnose_break_I=0.1):
print('check_thermodynamicConstraints...')
# get simulation information
simulation_info_all = [];
simulation_info_all = self.get_rows_simulationID_dataStage03QuantificationSimulation(simulation_id_I);
if not simulation_info_all:
print('simulation not found!')
return;
simulation_info = simulation_info_all[0]; # unique constraint guarantees only 1 row will be returned
# get simulation parameters
simulation_parameters_all = [];
simulation_parameters_all = self.get_rows_simulationID_dataStage03QuantificationSimulationParameters(simulation_id_I);
if not simulation_parameters_all:
print('simulation not found!')
return;
simulation_parameters = simulation_parameters_all[0]; # unique constraint guarantees only 1 row will be returned
# get the cobra model
cobra_model = models_I[simulation_info['model_id']];
# copy the model
cobra_model_copy = cobra_model.copy();
# get rxn_ids
if rxn_ids_I:
rxn_ids = rxn_ids_I;
else:
rxn_ids = [];
rxn_ids = self.get_rows_experimentIDAndModelIDAndSampleNameAbbreviation_dataStage03QuantificationMeasuredFluxes(simulation_info['experiment_id'],simulation_info['model_id'],simulation_info['sample_name_abbreviation']);
for rxn in rxn_ids:
# constrain the model
cobra_model_copy.reactions.get_by_id(rxn['rxn_id']).lower_bound = rxn['flux_lb'];
cobra_model_copy.reactions.get_by_id(rxn['rxn_id']).upper_bound = rxn['flux_ub'];
# make the model irreversible
convert_to_irreversible(cobra_model_copy);
# get otherData
pH,temperature,ionic_strength = {},{},{}
pH,temperature,ionic_strength = self.get_rowsFormatted_experimentIDAndTimePointAndSampleNameAbbreviation_dataStage03QuantificationOtherData(simulation_info['experiment_id'],simulation_info['time_point'],simulation_info['sample_name_abbreviation']);
# load pH, ionic_strength, and temperature parameters
other_data = thermodynamics_otherData(pH_I=pH,temperature_I=temperature,ionic_strength_I=ionic_strength);
other_data.check_data();
# get dG_f data:
dG_f = {};
dG_f = self.get_rowsDict_experimentIDAndModelIDAndTimePointAndSampleNameAbbreviations_dataStage03QuantificationDGf(simulation_info['experiment_id'],simulation_info['model_id'],simulation_info['time_point'],simulation_info['sample_name_abbreviation']);
dG_f_data = thermodynamics_dG_f_data(dG_f_I=dG_f);
dG_f_data.format_dG_f();
dG_f_data.generate_estimated_dG_f(cobra_model)
dG_f_data.check_data();
# remove an inconsistent dGf values
if inconsistent_dG_f_I: dG_f_data.remove_measured_dG_f(inconsistent_dG_f_I)
# query metabolomicsData
concentrations = [];
concentrations = self.get_rowsDict_experimentIDAndTimePointAndSampleNameAbbreviations_dataStage03QuantificationMetabolomicsData(simulation_info['experiment_id'],simulation_info['time_point'],simulation_info['sample_name_abbreviation']);
# load metabolomicsData
metabolomics_data = thermodynamics_metabolomicsData(measured_concentrations_I=concentrations);
metabolomics_data.generate_estimated_metabolomics_data(cobra_model);
# remove an inconsistent concentration values
if inconsistent_concentrations_I: metabolomics_data.remove_measured_concentrations(inconsistent_concentrations_I);
# get dG0r, dGr, and tcc data
dG0_r = {};
dG0_r = self.get_rowsDict_experimentIDAndModelIDAndTimePointAndSampleNameAbbreviations_dataStage03QuantificationDG0r(simulation_info['experiment_id'],simulation_info['model_id'],simulation_info['time_point'],simulation_info['sample_name_abbreviation'])
measured_concentration_coverage,measured_dG_f_coverage,feasible = {},{},{};
measured_concentration_coverage,measured_dG_f_coverage,feasible = self.get_rowsDict_experimentIDAndModelIDAndTimePointAndSampleNameAbbreviations_dataStage03QuantificationTCC(simulation_info['experiment_id'],simulation_info['model_id'],simulation_info['time_point'],simulation_info['sample_name_abbreviation'],0,0)
tcc = thermodynamics_dG_r_data(dG0_r_I = dG0_r,
dG_r_coverage_I = measured_dG_f_coverage,
metabolomics_coverage_I = measured_concentration_coverage,
thermodynamic_consistency_check_I = feasible);
# apply tfba constraints
tfba = thermodynamics_tfba()
thermodynamic_constraints_check,diagnose_variables_1,diagnose_variables_2,diagnose_variables_3 = tfba.check_conc_ln_constraints_transport(cobra_model_copy,
metabolomics_data.measured_concentrations, metabolomics_data.estimated_concentrations,
tcc.dG0_r, other_data.pH,other_data.temperature,tcc.metabolomics_coverage,
tcc.dG_r_coverage, tcc.thermodynamic_consistency_check,
measured_concentration_coverage_criteria_I, measured_dG_f_coverage_criteria_I,
n_checks_I = 5,
diagnose_solver_I=None,diagnose_threshold_I=0.98,diagnose_break_I=0.1);
return thermodynamic_constraints_check,diagnose_variables_1,diagnose_variables_2,diagnose_variables_3;
def isotopomer_model_iteration2(pfba_filename,fva_reduced_model_filename,netrxn_irreversible_model_filename,reduced_lbub_filename):
'''iteration 2:
addition of finalized lumped reactions that are in pathways that are within the scope of the model
and reduction by removing reactions with zero optimal minimal flux outside the scope of the model'''
cobra_model = load_ALEWt();
# Make the model irreversible for downstream manipulations:
convert_to_irreversible(cobra_model);
cobra_model.optimize();
# Add lumped isotopomer reactions
add_net_reaction(cobra_model,isotopomer_rxns_net_irreversible,True);
cobra_model.optimize();
# Find minimal flux solution:
pfba = optimize_minimal_flux(cobra_model,True,solver='gurobi');
# Write pfba solution to file
with open(pfba_filename,mode='wb') as outfile:
writer = csv.writer(outfile)
writer.writerow(['Reaction','Flux','Subsystem'])
for k,v in cobra_model.solution.x_dict.items():
writer.writerow([k,v,cobra_model.reactions.get_by_id(k).subsystem]);
# Read in pfba solution
pfba_sol = {};
with open(pfba_filename,mode='r') as infile:
dictreader = csv.DictReader(infile)
for r in dictreader:
pfba_sol[r['Reaction']] = r['Flux'];
# remove noflux reactions for pathways outside of the scope
# of the isotopomer model
subs = ['Cell Envelope Biosynthesis',
'Glycerophospholipid Metabolism',
'Lipopolysaccharide Biosynthesis / Recycling',
'Membrane Lipid Metabolism',
'Murein Biosynthesis'
'Murein Recycling',
'Cofactor and Prosthetic Group Biosynthesis',
'Transport, Inner Membrane',
'Transport, Outer Membrane',
'Transport, Outer Membrane Porin',
'tRNA Charging',
'Unassigned',
#'Exchange',
'Inorganic Ion Transport and Metabolism',
'Nitrogen Metabolism',
'Alternate Carbon Metabolism'];
remove_noflux_reactions(cobra_model,pfba_sol,subs)
# Reduce model using FVA:
reduce_model(cobra_model,fva_reduced_model_filename)
# Reset secretion products that may have been turned off
secrete = ['EX_meoh_LPAREN_e_RPAREN_',
'EX_5mtr_LPAREN_e_RPAREN_',
'EX_h_LPAREN_e_RPAREN_',
'EX_co2_LPAREN_e_RPAREN_',
'EX_co_LPAREN_e_RPAREN_',
'EX_h2o_LPAREN_e_RPAREN_',
'EX_ac_LPAREN_e_RPAREN_',
'EX_fum_LPAREN_e_RPAREN_',
'EX_for_LPAREN_e_RPAREN_',
'EX_etoh_LPAREN_e_RPAREN_',
'EX_lac_DASH_L_LPAREN_e_RPAREN_',
'EX_pyr_LPAREN_e_RPAREN_',
'EX_succ_LPAREN_e_RPAREN_'];
for s in secrete:
cobra_model.reactions.get_by_id(s).upper_bound = 1000.0;
# Remove all reactions with 0 flux
r1,r2 = get_reactionsInfo(cobra_model);
while r2 !=0:
remove_noflux_reactions(cobra_model);
r1,r2 = get_reactionsInfo(cobra_model);
print(r1,r2);
# write model to sbml
write_cobra_model_to_sbml_file(cobra_model,netrxn_irreversible_model_filename)
with open(reduced_lbub_filename,mode='wb') as outfile:
writer = csv.writer(outfile)
writer.writerow(['Reaction','Formula','LB','UB','Subsystem'])
for r in cobra_model.reactions:
writer.writerow([r.id,
r.build_reaction_string(),
r.lower_bound,
r.upper_bound,
r.subsystem]);
def init_model(self):
cobra_model = load_json_model(data_dir_tests + '/mini.json')
convert_to_irreversible(cobra_model)
solution = cobra_model.optimize()
self.cobra_model = cobra_model
def execute_makeModel(self,
model_id_I=None,
model_file_name_I=None,
model_id_O=None,date_O=None,
ko_list=[],flux_dict={},rxn_include_list=[],
model_id_template_I='iJO1366',
description=None,convert2irreversible_I=False,revert2reversible_I=False):
'''make the model
INPUT:
model_id_I = existing model_id (if specified, an existing model in the database will be retrieved and modified)
model_file_name_I = new model from file (if specified, a new model from file will be retrieved and modified)
model_id_O = new model_id
date_O = date the model was made
description = description for the model
INPUT (constraints in order):
ko_list = list of reactions to constrain to zero flux
flux_dict = dictionary of fluxes to constrain the model
INPUT (model manipulation in order):
rxn_include_list = list of reactions to include in the new model
convert2irreversible_I = boolean, if True, the model will be converted to irreversible from reversible
revert2reversible_I = boolean, if True, the model will be revert to reversible from irreversible
Not yet implemented
#----
rxn_add_list = list of reactions to add from a different model
model_add = model to add reactions from
#----
'''
# retreive the model
if model_id_I and model_id_O and date_O: #modify an existing model in the database
cobra_model_sbml = None;
cobra_model_sbml = self.get_row_modelID_dataStage02PhysiologyModels(model_id_I);
cobra_model = self.writeAndLoad_modelTable(cobra_model_sbml);
elif model_file_name_I and model_id_O and date_O: #modify an existing model not in the database
# check for the file type
cobra_model = self.load_model(model_file_name_I);
else:
print('need to specify either an existing model_id or model_file_name!')
return;
# Constrain the model
self.constrain_modelModelVariables(cobra_model,
ko_list=ko_list,flux_dict=flux_dict);
# Use only a subset of reactions, if specified
if rxn_include_list:
remove_reactions=[];
for rxn in cobra_model.reactions:
if not rxn.id in rxn_include_list:
remove_reactions.append(rxn);
cobra_model.remove_reactions(remove_reactions,delete=True,remove_orphans=True);
if convert2irreversible_I: convert_to_irreversible(cobra_model);
if revert2reversible_I:
self.repair_irreversibleModel(cobra_model);
self.revert2reversible(cobra_model);
#revert_to_reversible(cobra_model,update_solution = False)
# Change description, if any:
if description:
cobra_model.description = description;
# test the model
if self.test_model(cobra_model):
# write the model to a temporary file
write_cobra_model_to_sbml_file(cobra_model, 'cobra_model_tmp.xml');
# upload the model to the database
self.import_dataStage02PhysiologyModel_sbml(model_id_O, date_O, 'cobra_model_tmp.xml');
def isotopomer_model_iteration2(pfba_filename, fva_reduced_model_filename,
netrxn_irreversible_model_filename,
reduced_lbub_filename):
'''iteration 2:
addition of finalized lumped reactions that are in pathways that are within the scope of the model
and reduction by removing reactions with zero optimal minimal flux outside the scope of the model'''
cobra_model = load_ALEWt()
# Make the model irreversible for downstream manipulations:
convert_to_irreversible(cobra_model)
cobra_model.optimize()
# Add lumped isotopomer reactions
add_net_reaction(cobra_model, isotopomer_rxns_net_irreversible, True)
cobra_model.optimize()
# Find minimal flux solution:
pfba = optimize_minimal_flux(cobra_model, True, solver='gurobi')
# Write pfba solution to file
with open(pfba_filename, mode='wb') as outfile:
writer = csv.writer(outfile)
writer.writerow(['Reaction', 'Flux', 'Subsystem'])
for k, v in cobra_model.solution.x_dict.items():
writer.writerow(
[k, v, cobra_model.reactions.get_by_id(k).subsystem])
# Read in pfba solution
pfba_sol = {}
with open(pfba_filename, mode='r') as infile:
dictreader = csv.DictReader(infile)
for r in dictreader:
pfba_sol[r['Reaction']] = r['Flux']
# remove noflux reactions for pathways outside of the scope
# of the isotopomer model
subs = [
'Cell Envelope Biosynthesis',
'Glycerophospholipid Metabolism',
'Lipopolysaccharide Biosynthesis / Recycling',
'Membrane Lipid Metabolism',
'Murein Biosynthesis'
'Murein Recycling',
'Cofactor and Prosthetic Group Biosynthesis',
'Transport, Inner Membrane',
'Transport, Outer Membrane',
'Transport, Outer Membrane Porin',
'tRNA Charging',
'Unassigned',
#'Exchange',
'Inorganic Ion Transport and Metabolism',
'Nitrogen Metabolism',
'Alternate Carbon Metabolism'
]
remove_noflux_reactions(cobra_model, pfba_sol, subs)
# Reduce model using FVA:
reduce_model(cobra_model, fva_reduced_model_filename)
# Reset secretion products that may have been turned off
secrete = [
'EX_meoh_LPAREN_e_RPAREN_', 'EX_5mtr_LPAREN_e_RPAREN_',
'EX_h_LPAREN_e_RPAREN_', 'EX_co2_LPAREN_e_RPAREN_',
'EX_co_LPAREN_e_RPAREN_', 'EX_h2o_LPAREN_e_RPAREN_',
'EX_ac_LPAREN_e_RPAREN_', 'EX_fum_LPAREN_e_RPAREN_',
'EX_for_LPAREN_e_RPAREN_', 'EX_etoh_LPAREN_e_RPAREN_',
'EX_lac_DASH_L_LPAREN_e_RPAREN_', 'EX_pyr_LPAREN_e_RPAREN_',
'EX_succ_LPAREN_e_RPAREN_'
]
for s in secrete:
cobra_model.reactions.get_by_id(s).upper_bound = 1000.0
# Remove all reactions with 0 flux
r1, r2 = get_reactionsInfo(cobra_model)
while r2 != 0:
remove_noflux_reactions(cobra_model)
r1, r2 = get_reactionsInfo(cobra_model)
print(r1, r2)
# write model to sbml
write_cobra_model_to_sbml_file(cobra_model,
netrxn_irreversible_model_filename)
with open(reduced_lbub_filename, mode='wb') as outfile:
writer = csv.writer(outfile)
writer.writerow(['Reaction', 'Formula', 'LB', 'UB', 'Subsystem'])
for r in cobra_model.reactions:
writer.writerow([
r.id,
r.build_reaction_string(), r.lower_bound, r.upper_bound,
r.subsystem
])
def _pfba_legacy(model,
solver,
already_irreversible=False,
fraction_of_optimum=1.0,
desired_objective_value=None,
**optimize_kwargs):
"""Perform basic pFBA (parsimonious FBA) and minimize total flux.
The function attempts to act as a drop-in replacement for optimize. It
will make the reaction reversible and perform an optimization, then
force the objective value to remain the same and minimize the total
flux. Finally, it will convert the reaction back to the irreversible
form it was in before. See http://dx.doi.org/10.1038/msb.2010.47
Parameters
----------
model : cobra.Model
The model
solver : solver
The solver object to use
already_irreversible : bool, optional
By default, the model is converted to an irreversible one.
However, if the model is already irreversible, this step can be
skipped
fraction_of_optimum : float, optional
Fraction of optimum which must be maintained. The original objective
reaction is constrained to be greater than maximal_value *
fraction_of_optimum. By default, this option is specified to be 1.0
desired_objective_value : float, optional
A desired objective value for the minimal solution that bypasses the
initial optimization result.
Updates everything in-place, returns model to original state at end.
"""
objective_reactions = linear_reaction_coefficients(model)
if len(objective_reactions) > 1:
raise ValueError('pfba only supports models with'
' a single objective function')
if 'objective_sense' in optimize_kwargs:
if optimize_kwargs['objective_sense'] == 'minimize':
raise ValueError('Minimization not supported in pfba')
optimize_kwargs.pop('objective_sense', None)
if not already_irreversible:
convert_to_irreversible(model)
lp = solver.create_problem(model, **optimize_kwargs)
if not desired_objective_value:
solver.solve_problem(lp, objective_sense='maximize')
status = solver.get_status(lp)
if status != "optimal":
revert_to_reversible(model)
raise ValueError(
"pFBA requires optimal solution status, not {}".format(status))
desired_objective_value = solver.get_objective_value(lp)
for i, reaction in enumerate(model.reactions):
if reaction.objective_coefficient != 0:
# Enforce a certain fraction of the original objective
target = (desired_objective_value * fraction_of_optimum /
reaction.objective_coefficient)
solver.change_variable_bounds(lp, i, target, reaction.upper_bound)
# Minimize all reaction fluxes (including objective?)
solver.change_variable_objective(lp, i, 1)
solver.solve_problem(lp, objective_sense='minimize', **optimize_kwargs)
solution = solver.format_solution(lp, model)
# Return the model to its original state
# model.solution = solution
revert_to_reversible(model)
# if solution.status == "optimal":
# model.solution.f = sum([coeff * reaction.x for reaction, coeff in
# iteritems(objective_reactions)])
return solution
import pandas as pd
from cobra.core import Metabolite, Reaction
from cobra.io.sbml import create_cobra_model_from_sbml_file
from cobra.manipulation.modify import convert_to_irreversible, revert_to_reversible
from cobra.flux_analysis.variability import flux_variability_analysis
gc = pd.DataFrame.from_csv('../data/growth_conditions.csv')
gc = gc[gc.media_key>0]
m = create_cobra_model_from_sbml_file('../data/iJO1366.xml')
convert_to_irreversible(m)
fake = Metabolite(id='fake')
m.add_metabolites(fake)
for r in m.reactions:
r.add_metabolites({fake:1})
flux_counter = Reaction(name='flux_counter')
flux_counter.add_metabolites(metabolites={fake:-1})
m.add_reaction(flux_counter)
m.change_objective(flux_counter)
m.reactions.get_by_id('EX_glc_e_reverse').upper_bound = 0
rxns = {r.id:r for r in m.reactions}
index = pd.MultiIndex.from_product([gc.index, ['maximum', 'minimum']])
fluxes = pd.DataFrame(index=index, columns=rxns.keys())
for i,c in enumerate(gc.index):
rxns['EX_'+gc['media_key'][c]+'_e'].lower_bound = -1000
from cobra.flux_analysis.parsimonious import optimize_minimal_flux
from cobra.manipulation.modify import convert_to_irreversible
from cobra.io.sbml import create_cobra_model_from_sbml_file
import pandas as pd
def perform_pFBA(model, cs, gr, ur):
model = deepcopy(model)
convert_to_irreversible(model)
rxns = dict([(r.id, r) for r in model.reactions])
rxns['EX_glc_e'].lower_bound = 0 # uptake of carbon source reaction is initialized
try:
rxns['EX_' + cs + '_e'].lower_bound = -ur # redefine sole carbon source uptake reaction in mmol/gr/h
except:
print cs, ur
rxns['EX_glc_e'].lower_bound = -ur
rxns['Ec_biomass_iJO1366_core_53p95M'].upper_bound = gr
print "solving pFBA",
optimize_minimal_flux(model, already_irreversible=True)
flux_dist = pd.DataFrame(model.solution.x_dict.items()).set_index(0)
return flux_dist
if __name__ == "__main__":
model_fname = "../data/iJO1366.xml"
model = create_cobra_model_from_sbml_file(model_fname)
convert_to_irreversible(model)
reactions = map(lambda x: x.id, model.reactions)
fluxes = perform_pFBA(model, 'glc', 0.5, 18.5)
def __init__(self,
cobra_model,
config_fname='data/stfba_config.tsv',
solver=settings.LP_SOLVER):
"""
construct a semi-thermodynamic model
This adds MILP constraints to prevent internal flux cycling and
energy generating cycles, as done in XXXXXX.
This must be solved with an MILP capable solver.
"""
sbtab = SBtabTools.openMultipleSBtab(config_fname)
formation_energy = sbtab[0].toDataFrame()
formation_energy.set_index('Compound', inplace=True)
formation_energy['Value'] = formation_energy['Value'].apply(float)
formation_energy.rename(columns={'Value': 'formation_energy'},
inplace=True)
concentrations = sbtab[1].toDataFrame()
concentrations.set_index('Compound', inplace=True)
concentrations['Concentration:Min'] = \
np.log(concentrations['Concentration:Min'].apply(float))
concentrations['Concentration:Max'] = \
np.log(concentrations['Concentration:Max'].apply(float))
df = pd.merge(formation_energy,
concentrations,
left_index=True,
right_index=True,
how='outer')
R = 8.314e-3 # kJ/mol/K
T = 298 # K
self.model = cobra_model.copy()
self.solver = solver
convert_to_irreversible(self.model)
max_ub = max(self.model.reactions.list_attr("upper_bound"))
kappa = 10000 # used for the 'kappa' parameter
# a dict for storing S^T
thermo_stoic = {
metabolite.id: {}
for metabolite in self.model.metabolites
}
# Slice operator is so that we don't get newly added metabolites
self.original_metabolites = self.model.metabolites[:]
self.original_objective = self.model.objective
for reaction in self.model.reactions[:]:
# Boundary reactions are not subjected to these constraints
if len(reaction._metabolites) == 1:
continue
# populate the S^T dict
bound_id = "thermo_bound_" + reaction.id
for met, stoic in iteritems(reaction._metabolites):
thermo_stoic[met.id][bound_id] = stoic
# encode the st-FBA constrainsts:
# 1) v <= z*v_max
# 2) S^T * dfG <= K - K*z
# first, we create the boolean variable (z), in the form of a
# special reactions that can have only two flux values (0 or 1)
reaction_ind = Reaction(reaction.id + "_indicator")
reaction_ind.variable_kind = "integer"
reaction_ind.upper_bound = 1
# For the first constraint we create a "fake" metabolite
# in the indicator reaction it has a stoichiometric coeff = v_max
# in the original reaction it has a stoichiometric coeff = -1
# The mass-balance constraint is set to be >= 0
# Mathematically, this translates to:
# -1 * v + v_max * z >= 0
reaction_ub = Metabolite(reaction.id + "_ind_ub")
reaction_ub._constraint_sense = "G"
reaction.add_metabolites({reaction_ub: -1})
reaction_ind.add_metabolites({reaction_ub: max_ub})
# For the second constraint we create anotehr "fake" metabolite and
# add it also to the indicator reaction with coefficint K
# The mass-balance constraint is set to be <= K.
# Mathematically, this translates to:
# K * z <= K
# Later, we will add the reaction Gibbs energy to the left side.
reaction_bound = Metabolite(bound_id)
reaction_bound._constraint_sense = "L"
reaction_bound._bound = kappa
reaction_ind.add_metabolites({reaction_bound: kappa})
self.model.add_reaction(reaction_ind)
# Now we create the thermodynamic variables (dfG), each will be a new
# reaction with the corresponding metabolite name.
for metabolite in self.original_metabolites:
metabolite_var = Reaction("thermo_var_" + metabolite.id)
if metabolite.id in df.index:
dfG0 = df.loc[metabolite.id, 'formation_energy']
lb = dfG0 + R * T * df.loc[metabolite.id,
'Concentration:Min'] - 1e-5
ub = dfG0 + R * T * df.loc[metabolite.id,
'Concentration:Max'] + 1e-5
if lb > ub:
raise ValueError('''lower concentration bound is higher
than upper bound''')
metabolite_var.bounds = (lb, ub)
else:
# if there are no specific bounds for this metabolite, use a very
# wide range for its formation energy
metabolite_var.bounds = (-kappa, kappa)
self.model.add_reaction(metabolite_var)
# Finally, we add the stoichiometric coefficients of each reaction that
# creates or uses this metabolite (i.e. the transposed stoichiometric
# matrix).
for k, v in iteritems(thermo_stoic[metabolite.id]):
m = self.model.metabolites.get_by_id(k)
metabolite_var.add_metabolites({m: v})
def _main_():
##PART 1: Working
#-------
# Read in the model sbml file and define the model conditions
# Aerobic specific changes
cobra_model_oxic = load_thermoModel(anoxic=False)
convert_to_irreversible(cobra_model_oxic)
##PART 2: Working
#-------
# make/load simulated data for aerobic conditions
data_fva_oxic = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_fva_irrev_oxic.json'
data_srd_oxic = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_srd_irrev_oxic.json'
simulated_data_oxic = thermodynamics_simulatedData()
# simulated_data_oxic.generate_sra_data(cobra_model_oxic) # perform single reaction deletion analysis
# simulated_data_oxic.generate_fva_data(cobra_model_oxic) # perform flux variability analysis
# simulated_data_oxic.export_sra_data(data_srd_oxic) # save results for later use
# simulated_data_oxic.export_fva_data(data_fva_oxic) # save results for later use
simulated_data_oxic.import_sra_data(data_srd_oxic)
simulated_data_oxic.import_fva_data(data_fva_oxic)
simulated_data_oxic.check_data()
##PART 3: Working
#-------
# load pH, ionic_strength, and temperature parameters
other_data = thermodynamics_otherData()
other_data.load_defaultData()
other_data.check_data()
# generate dG_f data for all model compounds
# calculate the dG_f for each compound in each compartment
# export/load and check the dG_f data
#data_dG0_transformed = 'thermodynamics_data/ijo1366_dG_f.json'
data_dG0_transformed = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_dG_f01.json'
dG_f_data = thermodynamics_dG_f_data(
id2KEGGID_filename_I=
'/home/user/code/thermodynamics/thermodynamics_data/id2KEGGID.csv')
# # # dG_f_data.make_dG0_f_pH0() # only if the data has not been generated previously!
# dG_f_data.get_transformed_dG_f('/home/user/code/thermodynamics/thermodynamics_data/compounds_dG0_f.json',cobra_model_oxic,other_data.pH,other_data.temperature,other_data.ionic_strength) # adjust the non-transformed dG0_f data to physiological pH, temperature, and ionic strength (this step has already been completed)
#dG_f_data.export_dG_f(data_dG0_transformed) # save results for later use
dG_f_data.import_dG_f(data_dG0_transformed)
dG_f_data.format_dG_f()
dG_f_data.generate_estimated_dG_f(cobra_model_oxic)
dG_f_data.check_data()
##PART 4: Working
#-------
# load metabolomics data for oxic conditions
data_concentrations_oxic = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_oxic_geo01.json'
metabolomics_data_oxic = thermodynamics_metabolomicsData()
metabolomics_data_oxic.import_metabolomics_data(data_concentrations_oxic)
metabolomics_data_oxic.format_metabolomics_data(
) # add compartment identifiers to metabolite ids
metabolomics_data_oxic.generate_estimated_metabolomics_data(
cobra_model_oxic)
##PART 5: Working
#-------
# calculate dG_r and perform a consistency check based on model simulations for oxic conditions
data_ta_oxic = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_oxic_irrev_ta.csv'
data_dG0_oxic = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_oxic_orrev_dG0.json'
data_dG_oxic = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_oxic_irrev_dG.json'
data_tcc_oxic = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_oxic_irrev_tcc.json'
tcc_oxic = thermodynamics_dG_r_data()
tcc_oxic.import_dG0_r_json(data_dG0_oxic)
tcc_oxic.import_dG_r_json(data_dG_oxic)
tcc_oxic.import_tcc_json(data_tcc_oxic)
# tcc_oxic.calculate_dG0_r(cobra_model_oxic, dG_f_data.measured_dG_f, dG_f_data.estimated_dG_f, other_data.temperature) # calculate the change in free energy of reaction without accounting for metabolite concentrations
# tcc_oxic.calculate_dG_r(cobra_model_oxic,metabolomics_data_oxic.measured_concentrations, metabolomics_data_oxic.estimated_concentrations,
# other_data.pH, other_data.ionic_strength, other_data.temperature) # adjust the change in free energy of reaction for intracellular metabolite concentrations
# tcc_oxic.check_thermodynamicConsistency(cobra_model_oxic,simulated_data_oxic.fva_data,
# metabolomics_data_oxic.measured_concentrations,
# metabolomics_data_oxic.estimated_concentrations,
# other_data.pH,other_data.ionic_strength,other_data.temperature) # check the thermodynamic consistency of the data
# tcc_oxic.export_dG0_r_json(data_dG0_oxic) # save for later use
# tcc_oxic.export_dG_r_json(data_dG_oxic) # save for later use
# tcc_oxic.export_tcc_json(data_tcc_oxic) # save for later use
# tcc_oxic.export_summary(cobra_model_oxic,simulated_data_oxic.fva_data,data_ta_oxic) # write summary of the analysis to csv file
##PART 8:
#-------
# Diagnose model variables and constraints prior to FBA, FVA, and sampling (Oxic condition only)
# identified inconsistent concentrations/dG_f/tcc values
inconsistent_concentrations_I = []
inconsistent_dG_f_I = []
inconsistent_tcc_I = ['EX_glc_LPAREN_e_RPAREN__reverse']
# remove an inconsistent dGf values
dG_f_data.remove_measured_dG_f(inconsistent_dG_f_I)
# remove an inconsistent concentration values
metabolomics_data_oxic.remove_measured_concentrations(
inconsistent_concentrations_I)
# remove an inconcsistent tcc
tcc_oxic.change_feasibleReactions(inconsistent_tcc_I)
# diagnose tfba constraints
tfba = thermodynamics_tfba()
# thermodynamic_constraints_check,\
# inconsistent_tcc,diagnose_variables_1,\
# diagnose_variables_2,\
# diagnose_variables_3 = tfba.check_conc_ln_constraints_transport(
# cobra_model_oxic,
# metabolomics_data_oxic.measured_concentrations, metabolomics_data_oxic.estimated_concentrations,
# tcc_oxic.dG0_r, other_data.pH,other_data.temperature,tcc_oxic.metabolomics_coverage,
# tcc_oxic.dG_r_coverage, tcc_oxic.thermodynamic_consistency_check,
# 0.5, 0.99,n_checks_I = 0,
# diagnose_solver_I=None,diagnose_threshold_I=0.98,diagnose_break_I=0.1)
# tfba._add_conc_ln_constraints_transport(cobra_model_oxic,
# metabolomics_data_oxic.measured_concentrations, metabolomics_data_oxic.estimated_concentrations,
# tcc_oxic.dG0_r, other_data.pH,other_data.temperature,tcc_oxic.metabolomics_coverage,
# tcc_oxic.dG_r_coverage, tcc_oxic.thermodynamic_consistency_check,
# 0.5, 0.99)
# # cobra_model_oxic.optimize()
# from cobra.flux_analysis import flux_variability_analysis
# fva_data = flux_variability_analysis(cobra_model_oxic, fraction_of_optimum=0.9,
# objective_sense='maximize',
# reaction_list=[cobra_model_oxic.reactions.get_by_id('conc_lnv_fum_c')],
# )
# #PART 9:
# -------
# perform thermodynamic FBA and FVA (Oxic condition only)
# # run TFBA
# cobra_model_copy = cobra_model_oxic.copy()
# tfba.tfba(cobra_model_copy,
# tcc_oxic.dG0_r,other_data.temperature,
# tcc_oxic.dG_r_coverage, tcc_oxic.thermodynamic_consistency_check,
# use_measured_dG_r=True, solver='glpk',)
# cobra_model_copy = cobra_model_oxic.copy()
# tfba.tfba_conc_ln(cobra_model_copy,
# metabolomics_data_oxic.measured_concentrations, metabolomics_data_oxic.estimated_concentrations,
# tcc_oxic.dG0_r,other_data.temperature,tcc_oxic.metabolomics_coverage,
# tcc_oxic.dG_r_coverage, tcc_oxic.thermodynamic_consistency_check,
# measured_concentration_coverage_criteria = 0.5, measured_dG_f_coverage_criteria = 0.99,
# use_measured_concentrations=True,use_measured_dG0_r=True, solver='glpk',)
# run TFVA
data_tfva_oxic = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_oxic_irrev_tfva.csv'
data_tfva_analysis_oxic = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_oxic_irrev_tfva_analysis.csv'
data_tfva_dG_r_oxic = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_oxic_orrev_tfva_dG_r.json'
data_tfva_concentrations_oxic = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_oxic_irrev_tfva_concentrations.json'
cobra_model_copy = cobra_model_oxic.copy()
tfba.tfva(cobra_model_copy,
tcc_oxic.dG0_r,
other_data.temperature,
tcc_oxic.dG_r_coverage,
tcc_oxic.thermodynamic_consistency_check,
use_measured_dG0_r=True,
reaction_list=None,
fraction_of_optimum=1.0,
solver='glpk',
objective_sense="maximize")
tfba.export_tfva_data(data_tfva_oxic)
tfba.analyze_tfva_results(flux_threshold=1e-6)
tfba.export_tfva_analysis(data_tfva_analysis_oxic)
cobra_model_copy = cobra_model_oxic.copy()
tfba.tfva_dG_r(cobra_model_copy,
tcc_oxic.dG0_r,
other_data.temperature,
tcc_oxic.dG_r_coverage,
tcc_oxic.thermodynamic_consistency_check,
use_measured_dG0_r=True,
fraction_of_optimum=1.0,
solver='glpk',
objective_sense="maximize")
tfba.export_tfva_dG_r_data(data_tfva_dG_r_oxic)
cobra_model_copy = cobra_model_oxic.copy()
tfba.tfva_concentrations(cobra_model_copy,
metabolomics_data_oxic.measured_concentrations,
metabolomics_data_oxic.estimated_concentrations,
tcc_oxic.dG0_r,
other_data.temperature,
tcc_oxic.metabolomics_coverage,
tcc_oxic.dG_r_coverage,
tcc_oxic.thermodynamic_consistency_check,
measured_concentration_coverage_criteria=0.5,
measured_dG_f_coverage_criteria=0.99,
use_measured_concentrations=True,
use_measured_dG0_r=True,
fraction_of_optimum=1.0,
solver='glpk',
objective_sense="maximize")
tfba.export_tfva_concentrations_data(data_tfva_concentrations_oxic)
# ##PART 10:
# #-------
# # perform thermodynamic Tsampling (Oxic condition only)
# # NOTE: requires optGpSampler
# # run Tsampling
# data_dir = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo'
# sampling = optGpSampler_sampling(data_dir_I = data_dir);
# simulation_id_I = 'aerobicAnaerobic01_oxic_tsampling'
# filename_model = simulation_id_I + '.json';
# filename_script = simulation_id_I + '.py';
# filename_points = simulation_id_I + '_points' + '.json';
# filename_warmup = simulation_id_I + '_warmup' + '.json';
# sampling.export_sampling_optGpSampler(cobra_model=cobra_model_oxic,
# filename_model=filename_model,
# filename_script=filename_script,
# filename_points=filename_points,
# filename_warmup=filename_warmup,
# solver_id_I = 'optGpSampler',
# n_points_I = 2*len(cobra_model_oxic.reactions),
# n_steps_I = 5000,
# n_threads_I = 2)
##PART 11:
#-------
# Analyze thermodynamic sampling (Oxic condition only)
sampling = optGpSampler_sampling(data_dir_I=data_dir,
model_I=cobra_model_oxic)
sampling.get_points_json(filename_points)
sampling.get_warmup_json(filename_warmup)
sampling.calculate_mixFraction()
# check if the model contains loops
#loops_bool = self.sampling.check_loops();
sampling.simulate_loops(
data_fva=
'/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/loops_fva_tmp.json',
solver_I='optGpSampler')
sampling.find_loops(
data_fva=
'/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/loops_fva_tmp.json'
)
sampling.remove_loopsFromPoints()
# calculate the flux descriptive statistics
sampling.descriptive_statistics(points_I='flux')
# calculate descriptive stats for metabolites
sampling.convert_points2MetabolitePoints()
sampling.descriptive_statistics(points_I='metabolite')
# calculate descriptive stats for subsystems
sampling.convert_points2SubsystemPoints()
sampling.descriptive_statistics(points_I='subsystem')
def execute_makeModel(self,experiment_id_I,model_id_I=None,model_id_O=None,date_I=None,model_file_name_I=None,ko_list=[],flux_dict={},description=None,convert2irreversible_I=False):
'''make the model'''
qio02 = stage02_physiology_io();
if model_id_I and model_id_O: #modify an existing model in the database
cobra_model_sbml = None;
cobra_model_sbml = self.stage02_physiology_query.get_row_modelID_dataStage02PhysiologyModels(model_id_I);
# write the model to a temporary file
if cobra_model_sbml['file_type'] == 'sbml':
with open(settings.workspace_data + '/cobra_model_tmp.xml','wb') as file:
file.write(cobra_model_sbml['model_file']);
cobra_model = None;
cobra_model = create_cobra_model_from_sbml_file(settings.workspace_data + '/cobra_model_tmp.xml', print_time=True);
elif cobra_model_sbml['file_type'] == 'json':
with open(settings.workspace_data + '/cobra_model_tmp.json','wb') as file:
file.write(cobra_model_sbml['model_file']);
cobra_model = None;
cobra_model = load_json_model(settings.workspace_data + '/cobra_model_tmp.json');
else:
print('file_type not supported')
if convert2irreversible_I: convert_to_irreversible(cobra_model);
# Apply KOs, if any:
for ko in ko_list:
cobra_model.reactions.get_by_id(ko).lower_bound = 0.0;
cobra_model.reactions.get_by_id(ko).upper_bound = 0.0;
# Apply flux constraints, if any:
for rxn,flux in flux_dict.items():
cobra_model.reactions.get_by_id(rxn).lower_bound = flux['lb'];
cobra_model.reactions.get_by_id(rxn).upper_bound = flux['ub'];
# Change description, if any:
if description:
cobra_model.description = description;
# test the model
if self.test_model(cobra_model):
# write the model to a temporary file
with open(settings.workspace_data + '/cobra_model_tmp.xml','wb') as file:
file.write(cobra_model);
# upload the model to the database
qio02.import_dataStage02PhysiologyModel_sbml(model_id_I, date_I, settings.workspace_data + '/cobra_model_tmp.xml');
elif model_file_name_I and model_id_O: #modify an existing model not in the database
# Read in the sbml file and define the model conditions
cobra_model = create_cobra_model_from_sbml_file(model_file_name_I, print_time=True);
if convert2irreversible_I: convert_to_irreversible(cobra_model);
# Apply KOs, if any:
for ko in ko_list:
cobra_model.reactions.get_by_id(ko).lower_bound = 0.0;
cobra_model.reactions.get_by_id(ko).upper_bound = 0.0;
# Apply flux constraints, if any:
for rxn,flux in flux_dict.items():
cobra_model.reactions.get_by_id(rxn).lower_bound = flux['lb'];
cobra_model.reactions.get_by_id(rxn).upper_bound = flux['ub'];
# Change description, if any:
if description:
cobra_model.description = description;
# test the model
if self.test_model(cobra_model):
# write the model to a temporary file
with open(settings.workspace_data + '/cobra_model_tmp.xml','wb') as file:
file.write(cobra_model);
# upload the model to the database
qio02.import_dataStage02PhysiologyModel_sbml(model_id_I, date_I, settings.workspace_data + '/cobra_model_tmp.xml');
else:
print('need to specify either an existing model_id or model_file_name!')
return
def SplitRev(model):
modify.convert_to_irreversible(model)
def construct_stfba_model(cobra_model, config_fname='stfba_config.tsv'):
"""construct a semi-thermodynamic model
This adds MILP constraints to prevent internal flux cycling and
energy generating cycles, as done in XXXXXX.
This must be solved with an MILP capable solver.
"""
config_df = pd.DataFrame.from_csv('stfba_config.csv')
config_df['ln_min_conc'] = np.log(config_df['min_concentration']) - 1e-5
config_df['ln_max_conc'] = np.log(config_df['max_concentration']) + 1e-5
R = 8.314e-3 # kJ/mol/K
T = 298 # K
model = cobra_model.copy()
convert_to_irreversible(model)
max_ub = max(model.reactions.list_attr("upper_bound"))
K = 10000 # used for the 'K' parameter
# a dict for storing S^T
thermo_stoic = {metabolite.id: {}
for metabolite in model.metabolites}
# Slice operator is so that we don't get newly added metabolites
original_metabolites = model.metabolites[:]
for reaction in model.reactions[:]:
# Boundary reactions are not subjected to these constraints
if len(reaction._metabolites) == 1:
continue
# populate the S^T dict
bound_id = "thermo_bound_" + reaction.id
for met, stoic in iteritems(reaction._metabolites):
thermo_stoic[met.id][bound_id] = stoic
# encode the st-FBA constrainsts:
# 1) v <= z*v_max
# 2) S^T * dfG <= K - K*z
# first, we create the boolean variable (z), in the form of a
# special reactions that can have only two flux values (0 or 1)
reaction_ind = Reaction(reaction.id + "_indicator")
reaction_ind.variable_kind = "integer"
reaction_ind.upper_bound = 1
# For the first constraint we create a "fake" metabolite
# in the indicator reaction it has a stoichiometric coeff = v_max
# in the original reaction it has a stoichiometric coeff = -1
# The mass-balance constraint is set to be >= 0
# Mathematically, this translates to:
# -1 * v + v_max * z >= 0
reaction_ub = Metabolite(reaction.id + "_ind_ub")
reaction_ub._constraint_sense = "G"
reaction.add_metabolites({reaction_ub: -1})
reaction_ind.add_metabolites({reaction_ub: max_ub})
# For the second constraint we create anotehr "fake" metabolite and
# add it also to the indicator reaction with coefficint K
# The mass-balance constraint is set to be <= K.
# Mathematically, this translates to:
# K * z <= K
# Later, we will add the reaction Gibbs energy to the left side.
reaction_bound = Metabolite(bound_id)
reaction_bound._constraint_sense = "L"
reaction_bound._bound = K
reaction_ind.add_metabolites({reaction_bound: K})
model.add_reaction(reaction_ind)
# Now we create the thermodynamic variables (dfG), each will be a new
# reaction with the corresponding metabolite name.
for metabolite in original_metabolites:
metabolite_var = Reaction("thermo_var_" + metabolite.id)
if metabolite.id in config_df.index:
dfG0 = config_df.loc[metabolite.id, 'formation_energy']
lb = dfG0 + R*T*config_df.loc[metabolite.id, 'min_concentration']
ub = dfG0 + R*T*config_df.loc[metabolite.id, 'max_concentration']
if lb > ub:
raise ValueError('''lower concentration bound is higher
than upper bound''')
metabolite_var.bounds = (lb, ub)
else:
# if there are no specific bounds for this metabolite, use a very
# wide range for its formation energy
metabolite_var.bounds = (-K, K)
model.add_reaction(metabolite_var)
# Finally, we add the stoichiometric coefficients of each reaction that
# creates or uses this metabolite (i.e. the transposed stoichiometric
# matrix).
for k, v in iteritems(thermo_stoic[metabolite.id]):
m = model.metabolites.get_by_id(k)
metabolite_var.add_metabolites({m: v})
return model
def execute_analyzeThermodynamicSamplingPoints(self,simulation_id_I,models_I,
data_dir_I,data_dir_O,rxn_ids_I=[],
inconsistent_dG_f_I=[],inconsistent_concentrations_I=[],
inconsistent_tcc_I=[],
measured_concentration_coverage_criteria_I=0.5,
measured_dG_f_coverage_criteria_I=0.99,
remove_pointsNotInSolutionSpace_I=True,
min_pointsInSolutionSpace_I=1000):
'''Load and analyze sampling points
Input:
inconsistent_dG_f_I = dG_f measured values to be substituted for estimated values
inconsistent_concentrations_I = concentration measured values to be substituted for estimated values
inconsistent_tcc_I = reactions considered feasible to be changed to infeasible so that dG0_r constraints do not break the model
measured_concentration_coverage_criteria_I = float, minimum concentration coverage to consider for feasibility
measured_dG_f_coveragea_criteria_I = float, minimum dG_f coverage to consider for feasibility
remove_pointsNotInSolutionSpace_I = boolean, remove points not in the solution space (i.e., within the lower/upper bounds)
min_pointsInSolutionSpace_I = int, minimum number of points in the solution space.
if the number of points is less that the minimum, the solution space will be increased by
(upper_bounds-lower_bounds)/4 until the minimum number of points is met
data_dir_I = directory of sampled points
data_dir_O = director to write QC'd sampled points
solver_I = string, solver name
'''
print('analyzing sampling points');
modelsCOBRA = models_COBRA_dependencies();
# get simulation information
simulation_info_all = [];
simulation_info_all = self.get_rows_simulationIDAndSimulationType_dataStage03QuantificationSimulation(simulation_id_I,'sampling')
if not simulation_info_all:
print('simulation not found!')
return;
simulation_info = simulation_info_all[0]; # unique constraint guarantees only 1 row will be returned
# get simulation parameters
simulation_parameters_all = [];
simulation_parameters_all = self.get_rows_simulationID_dataStage03QuantificationSimulationParameters(simulation_id_I);
if not simulation_parameters_all:
print('simulation not found!')
return;
simulation_parameters = simulation_parameters_all[0]; # unique constraint guarantees only 1 row will be returned
# get the cobra model
cobra_model = models_I[simulation_info['model_id']];
# copy the model
cobra_model_copy = cobra_model.copy();
# get rxn_ids
if rxn_ids_I:
rxn_ids = rxn_ids_I;
else:
rxn_ids = [];
rxn_ids = self.get_rows_experimentIDAndModelIDAndSampleNameAbbreviation_dataStage03QuantificationMeasuredFluxes(simulation_info['experiment_id'],simulation_info['model_id'],simulation_info['sample_name_abbreviation']);
for rxn in rxn_ids:
# constrain the model
cobra_model_copy.reactions.get_by_id(rxn['rxn_id']).lower_bound = rxn['flux_lb'];
cobra_model_copy.reactions.get_by_id(rxn['rxn_id']).upper_bound = rxn['flux_ub'];
# make the model irreversible
convert_to_irreversible(cobra_model_copy);
# get otherData
pH,temperature,ionic_strength = {},{},{}
pH,temperature,ionic_strength = self.get_rowsFormatted_experimentIDAndTimePointAndSampleNameAbbreviation_dataStage03QuantificationOtherData(simulation_info['experiment_id'],simulation_info['time_point'],simulation_info['sample_name_abbreviation']);
# load pH, ionic_strength, and temperature parameters
other_data = thermodynamics_otherData(pH_I=pH,temperature_I=temperature,ionic_strength_I=ionic_strength);
other_data.check_data();
# get dG_f data:
dG_f = {};
dG_f = self.get_rowsDict_experimentIDAndModelIDAndTimePointAndSampleNameAbbreviations_dataStage03QuantificationDGf(simulation_info['experiment_id'],simulation_info['model_id'],simulation_info['time_point'],simulation_info['sample_name_abbreviation']);
dG_f_data = thermodynamics_dG_f_data(dG_f_I=dG_f);
dG_f_data.format_dG_f();
dG_f_data.generate_estimated_dG_f(cobra_model)
dG_f_data.check_data();
# remove an inconsistent dGf values
if inconsistent_dG_f_I: dG_f_data.remove_measured_dG_f(inconsistent_dG_f_I)
# query metabolomicsData
concentrations = [];
concentrations = self.get_rowsDict_experimentIDAndTimePointAndSampleNameAbbreviations_dataStage03QuantificationMetabolomicsData(simulation_info['experiment_id'],simulation_info['time_point'],simulation_info['sample_name_abbreviation']);
# load metabolomicsData
metabolomics_data = thermodynamics_metabolomicsData(measured_concentrations_I=concentrations);
metabolomics_data.generate_estimated_metabolomics_data(cobra_model);
# remove an inconsistent concentration values
if inconsistent_concentrations_I: metabolomics_data.remove_measured_concentrations(inconsistent_concentrations_I);
# get dG0r, dGr, and tcc data
dG0_r = {};
dG0_r = self.get_rowsDict_experimentIDAndModelIDAndTimePointAndSampleNameAbbreviations_dataStage03QuantificationDG0r(simulation_info['experiment_id'],simulation_info['model_id'],simulation_info['time_point'],simulation_info['sample_name_abbreviation'])
measured_concentration_coverage,measured_dG_f_coverage,feasible = {},{},{};
measured_concentration_coverage,measured_dG_f_coverage,feasible = self.get_rowsDict_experimentIDAndModelIDAndTimePointAndSampleNameAbbreviations_dataStage03QuantificationTCC(simulation_info['experiment_id'],simulation_info['model_id'],simulation_info['time_point'],simulation_info['sample_name_abbreviation'],0,0)
tcc = thermodynamics_dG_r_data(dG0_r_I = dG0_r,
dG_r_coverage_I = measured_dG_f_coverage,
metabolomics_coverage_I = measured_concentration_coverage,
thermodynamic_consistency_check_I = feasible);
if inconsistent_tcc_I: tcc.change_feasibleReactions(inconsistent_tcc_I);
# apply tfba constraints
tfba = thermodynamics_tfba()
tfba._add_conc_ln_constraints_transport(cobra_model_copy, metabolomics_data.measured_concentrations, metabolomics_data.estimated_concentrations,
tcc.dG0_r, other_data.pH,other_data.temperature,tcc.metabolomics_coverage,
tcc.dG_r_coverage, tcc.thermodynamic_consistency_check,
measured_concentration_coverage_criteria_I, measured_dG_f_coverage_criteria_I,
use_measured_concentrations=True,use_measured_dG0_r=True);
# Test each model
if modelsCOBRA.test_model(cobra_model_I=cobra_model_copy):
sampling = cobra_sampling(data_dir_I = data_dir_I,model_I = cobra_model_copy);
if simulation_parameters['sampler_id']=='gpSampler':
# load the results of sampling
filename_points = simulation_id_I + '_points' + '.mat';
sampling.get_points_matlab(filename_points,'sampler_out');
# check if points were sampled outside the solution space
if remove_pointsNotInSolutionSpace_I:
pruned_reactions = sampling.remove_points_notInSolutionSpace(min_points_I=min_pointsInSolutionSpace_I);
## check if the model contains loops
#sampling.simulate_loops(data_fva=settings.workspace_data + '/loops_fva_tmp.json');
#sampling.find_loops(data_fva=settings.workspace_data + '/loops_fva_tmp.json');
#sampling.remove_loopsFromPoints();
sampling.descriptive_statistics();
elif simulation_parameters['sampler_id']=='optGpSampler':
return;
else:
print('sampler_id not recognized');
# add data to the database
row = {'simulation_id':simulation_id_I,
'simulation_dateAndTime':sampling.simulation_dateAndTime,
'mixed_fraction':sampling.mixed_fraction,
'data_dir':data_dir_I+'/'+filename_points,
'infeasible_loops':sampling.loops,
'used_':True,
'comment_':None
};
self.add_dataStage03QuantificationSampledPoints([row])
#row = None;
#row = data_stage03_quantification_sampledPoints(
# simulation_id_I,
# sampling.simulation_dateAndTime,
# sampling.mixed_fraction,
# data_dir_I+'/'+filename_points,
# sampling.loops,
# True,
# None);
#self.session.add(row);
# write points to json file
# add data to the database
sampledData_O = [];
for k,v in sampling.points_statistics.items():
type,units = tfba.get_variableTypeAndUnits(k);
row = {'simulation_id':simulation_id_I,
'simulation_dateAndTime':sampling.simulation_dateAndTime,
'variable_id':k,
'variable_type':type,
'variable_units':units,
'sampling_points':None, #v['points'],
'sampling_ave':v['ave'],
'sampling_var':v['var'],
'sampling_lb':v['lb'],
'sampling_ub':v['ub'],
'sampling_ci':0.95,
'sampling_min':v['min'],
'sampling_max':v['max'],
'sampling_median':v['median'],
'sampling_iq_1':v['iq_1'],
'sampling_iq_3':v['iq_3'],
'used_':True,
'comment_':None};
sampledData_O.append(row);
#row = None;
#row = data_stage03_quantification_sampledData(
# simulation_id_I,
# sampling.simulation_dateAndTime,
# k,
# type,
# units,
# None, #v['points'],
# v['ave'],
# v['var'],
# v['lb'],
# v['ub'],
# v['min'],
# 0.95,
# v['max'],
# v['median'],
# v['iq_1'],
# v['iq_3'],
# True,
# None);
#self.session.add(row);
self.add_dataStage03QuantificationSampledData(sampledData_O);
else:
print('no solution found!');
def create_minimal_fux_model(metabolic_model,
fraction_of_optimum_objective=0.8,
fraction_of_flux_minimum=2,
mutually_exclusive_directionality_constraint=True,
boundaries_precision=0.001,
label_model=None,
metabolite_list_file_name=None,
flux_penalty_dict={},
maximum_flux=None,
extra_constraints_dict={}):
print "creating irreversible model"
model = metabolic_model.copy()
for reaction_id in extra_constraints_dict:
reaction = model.reactions.get_by_id(reaction_id)
if "lb" in extra_constraints_dict[reaction_id]:
reaction.lower_bound = round_down(
extra_constraints_dict[reaction_id]["lb"], 6)
if "ub" in extra_constraints_dict[reaction_id]:
reaction.upper_bound = round_up(
extra_constraints_dict[reaction_id]["ub"], 6)
#original_objective=copy.deepcopy(model.objective)
for reaction in model.reactions:
if reaction.objective_coefficient != 0:
fva = flux_variability_analysis(
model,
reaction_list=[reaction.id],
fraction_of_optimum=fraction_of_optimum_objective)
if reaction.objective_coefficient > 0:
reaction.lower_bound = min(fva[reaction.id]["maximum"],
reaction.upper_bound)
reaction.upper_bound = min(fva[reaction.id]["maximum"],
reaction.upper_bound)
elif reaction.objective_coefficient < 0:
reaction.lower_bound = max(fva[reaction.id]["minimum"],
reaction.lower_bound)
reaction.upper_bound = max(fva[reaction.id]["minimum"],
reaction.lower_bound)
reaction.lower_bound -= boundaries_precision / 2.0
reaction.upper_bound += boundaries_precision / 2.0
reaction.objective_coefficient = 0
reversible_reactions = []
convert_to_irreversible(model)
for reaction in model.reactions:
if reaction.lower_bound < 0:
reversible_reactions.append(reaction.id)
#convert_to_irreversible_with_indicators(model,reversible_reactions,metabolite_list=[], mutually_exclusive_directionality_constraint = False)
if metabolite_list_file_name != None and metabolite_list_file_name != "":
metabolite_id_list = read_metabolomics_data(
model, metabolite_list_fname=metabolite_list_file_name)
else:
metabolite_id_list = []
add_turnover_metabolites(model,
metabolite_id_list=metabolite_id_list,
epsilon=1e-6,
label_model=label_model)
flux_reporter = Metabolite('flux_reporter_0',
formula='',
name='',
compartment='0')
for reaction in model.reactions:
if "IRRMILP_" in reaction.id or "RATIO_" in reaction.id or "RGROUP_" in reaction.id or "TMS_" in reaction.id:
continue
if reaction.id in flux_penalty_dict:
reporter_coef = flux_penalty_dict[reaction.id]
elif "reflection" in reaction.notes: #If a reversible reaction has no penalty assigned test if the reverse has a penalty
reflection = reaction.notes["reflection"]
if reflection in flux_penalty_dict:
reporter_coef = flux_penalty_dict[reflection]
else:
reporter_coef = 1
print "Warning: reaction " + reaction.id + " assigned default weight of 1"
else:
reporter_coef = 1
print "Warning: reaction " + reaction.id + " assigned default weight of 1"
if reporter_coef != 0:
reaction.add_metabolites({flux_reporter: reporter_coef})
total_flux_reaction = Reaction('total_flux')
total_flux_reaction.name = 'total_flux'
total_flux_reaction.subsystem = 'misc'
total_flux_reaction.lower_bound = 0
total_flux_reaction.upper_bound = 1000 * len(model.reactions)
total_flux_reaction.add_metabolites({flux_reporter: -1})
model.add_reaction(total_flux_reaction)
total_flux_reaction.objective_coefficient = -1
minimal_flux = -1 * model.optimize().f
if maximum_flux != None:
total_flux_reaction.upper_bound = maximum_flux
else:
total_flux_reaction.upper_bound = minimal_flux * fraction_of_flux_minimum
total_flux_reaction.objective_coefficient = 0.0
"""for objective in original_objective:
reaction=model.reactions.get_by_id(objective.id)
reaction.lower_bound=(fva[reaction.id]["minimum"]-boundaries_precision/2.0)
reaction.upper_bound=(fva[reaction.id]["maximum"]+boundaries_precision/2.0)"""
milp_reactions = model.reactions.query("IRRMILP_")
non_milp_reactions = []
for reaction in model.reactions:
if reaction not in milp_reactions:
non_milp_reactions.append(reaction)
return model, minimal_flux, non_milp_reactions
def execute_thermodynamicSampling(self,simulation_id_I,models_I,
data_dir_I,rxn_ids_I=[],
inconsistent_dG_f_I=[],inconsistent_concentrations_I=[],
inconsistent_tcc_I=[],
measured_concentration_coverage_criteria_I=0.5,
measured_dG_f_coverage_criteria_I=0.99,
solver_I='glpk'):
'''execute a thermodynamic analysis using the thermodynamic
module for cobrapy
Input:
inconsistent_dG_f_I = dG_f measured values to be substituted for estimated values
inconsistent_concentrations_I = concentration measured values to be substituted for estimated values
inconsistent_tcc_I = reactions considered feasible to be changed to infeasible so that dG0_r constraints do not break the model
measured_concentration_coverage_criteria_I = float, minimum concentration coverage to consider for feasibility
measured_dG_f_coveragea_criteria_I = float, minimum dG_f coverage to consider for feasibility
data_dir_I = directory of sampled points
solver_I = string, solver name
'''
modelsCOBRA = models_COBRA_dependencies();
print('execute_thermodynamicSampling...')
# get simulation information
simulation_info_all = [];
simulation_info_all = self.get_rows_simulationIDAndSimulationType_dataStage03QuantificationSimulation(simulation_id_I,'sampling')
if not simulation_info_all:
print('simulation not found!')
return;
simulation_info = simulation_info_all[0]; # unique constraint guarantees only 1 row will be returned
# get simulation parameters
simulation_parameters_all = [];
simulation_parameters_all = self.get_rows_simulationID_dataStage03QuantificationSimulationParameters(simulation_id_I);
if not simulation_parameters_all:
print('simulation not found!')
return;
simulation_parameters = simulation_parameters_all[0]; # unique constraint guarantees only 1 row will be returned
# get the cobra model
cobra_model = models_I[simulation_info['model_id']];
# copy the model
cobra_model_copy = cobra_model.copy();
# get rxn_ids
if rxn_ids_I:
rxn_ids = rxn_ids_I;
else:
rxn_ids = [];
rxn_ids = self.get_rows_experimentIDAndModelIDAndSampleNameAbbreviation_dataStage03QuantificationMeasuredFluxes(simulation_info['experiment_id'],simulation_info['model_id'],simulation_info['sample_name_abbreviation']);
for rxn in rxn_ids:
# constrain the model
cobra_model_copy.reactions.get_by_id(rxn['rxn_id']).lower_bound = rxn['flux_lb'];
cobra_model_copy.reactions.get_by_id(rxn['rxn_id']).upper_bound = rxn['flux_ub'];
# make the model irreversible
convert_to_irreversible(cobra_model_copy);
# get otherData
pH,temperature,ionic_strength = {},{},{}
pH,temperature,ionic_strength = self.get_rowsFormatted_experimentIDAndTimePointAndSampleNameAbbreviation_dataStage03QuantificationOtherData(simulation_info['experiment_id'],simulation_info['time_point'],simulation_info['sample_name_abbreviation']);
# load pH, ionic_strength, and temperature parameters
other_data = thermodynamics_otherData(pH_I=pH,temperature_I=temperature,ionic_strength_I=ionic_strength);
other_data.check_data();
# get dG_f data:
dG_f = {};
dG_f = self.get_rowsDict_experimentIDAndModelIDAndTimePointAndSampleNameAbbreviations_dataStage03QuantificationDGf(simulation_info['experiment_id'],simulation_info['model_id'],simulation_info['time_point'],simulation_info['sample_name_abbreviation']);
dG_f_data = thermodynamics_dG_f_data(dG_f_I=dG_f);
dG_f_data.format_dG_f();
dG_f_data.generate_estimated_dG_f(cobra_model)
dG_f_data.check_data();
# remove an inconsistent dGf values
if inconsistent_dG_f_I: dG_f_data.remove_measured_dG_f(inconsistent_dG_f_I)
# query metabolomicsData
concentrations = [];
concentrations = self.get_rowsDict_experimentIDAndTimePointAndSampleNameAbbreviations_dataStage03QuantificationMetabolomicsData(simulation_info['experiment_id'],simulation_info['time_point'],simulation_info['sample_name_abbreviation']);
# load metabolomicsData
metabolomics_data = thermodynamics_metabolomicsData(measured_concentrations_I=concentrations);
metabolomics_data.generate_estimated_metabolomics_data(cobra_model);
# remove an inconsistent concentration values
if inconsistent_concentrations_I: metabolomics_data.remove_measured_concentrations(inconsistent_concentrations_I);
# get dG0r, dGr, and tcc data
dG0_r = {};
dG0_r = self.get_rowsDict_experimentIDAndModelIDAndTimePointAndSampleNameAbbreviations_dataStage03QuantificationDG0r(simulation_info['experiment_id'],simulation_info['model_id'],simulation_info['time_point'],simulation_info['sample_name_abbreviation'])
measured_concentration_coverage,measured_dG_f_coverage,feasible = {},{},{};
measured_concentration_coverage,measured_dG_f_coverage,feasible = self.get_rowsDict_experimentIDAndModelIDAndTimePointAndSampleNameAbbreviations_dataStage03QuantificationTCC(simulation_info['experiment_id'],simulation_info['model_id'],simulation_info['time_point'],simulation_info['sample_name_abbreviation'],0,0)
tcc = thermodynamics_dG_r_data(dG0_r_I = dG0_r,
dG_r_coverage_I = measured_dG_f_coverage,
metabolomics_coverage_I = measured_concentration_coverage,
thermodynamic_consistency_check_I = feasible);
if inconsistent_tcc_I: tcc.change_feasibleReactions(inconsistent_tcc_I);
# apply tfba constraints
tfba = thermodynamics_tfba()
tfba._add_conc_ln_constraints_transport(cobra_model_copy, metabolomics_data.measured_concentrations, metabolomics_data.estimated_concentrations,
tcc.dG0_r, other_data.pH,other_data.temperature,tcc.metabolomics_coverage,
tcc.dG_r_coverage, tcc.thermodynamic_consistency_check,
measured_concentration_coverage_criteria_I, measured_dG_f_coverage_criteria_I,
use_measured_concentrations=True,use_measured_dG0_r=True);
# Test model
if modelsCOBRA.test_model(cobra_model_I=cobra_model_copy):
sampling = cobra_sampling(data_dir_I = data_dir_I);
if simulation_parameters['sampler_id']=='gpSampler':
filename_model = simulation_id_I + '.mat';
filename_script = simulation_id_I + '.m';
filename_points = simulation_id_I + '_points' + '.mat';
sampling.export_sampling_matlab(cobra_model=cobra_model_copy,filename_model=filename_model,filename_script=filename_script,filename_points=filename_points,\
solver_id_I = simulation_parameters['solver_id'],\
n_points_I = simulation_parameters['n_points'],\
n_steps_I = simulation_parameters['n_steps'],\
max_time_I = simulation_parameters['max_time']);
elif simulation_parameters['sampler_id']=='optGpSampler':
return;
else:
print('sampler_id not recognized');
else:
print('no solution found!');
def execute_makeModel(self,
experiment_id_I,
model_id_I=None,
model_id_O=None,
date_I=None,
model_file_name_I=None,
ko_list=[],
flux_dict={},
description=None,
convert2irreversible_I=False):
'''make the model'''
qio02 = stage02_physiology_io()
if model_id_I and model_id_O: #modify an existing model in the database
cobra_model_sbml = None
cobra_model_sbml = self.stage02_physiology_query.get_row_modelID_dataStage02PhysiologyModels(
model_id_I)
# write the model to a temporary file
if cobra_model_sbml['file_type'] == 'sbml':
with open(settings.workspace_data + '/cobra_model_tmp.xml',
'wb') as file:
file.write(cobra_model_sbml['model_file'])
cobra_model = None
cobra_model = create_cobra_model_from_sbml_file(
settings.workspace_data + '/cobra_model_tmp.xml',
print_time=True)
elif cobra_model_sbml['file_type'] == 'json':
with open(settings.workspace_data + '/cobra_model_tmp.json',
'wb') as file:
file.write(cobra_model_sbml['model_file'])
cobra_model = None
cobra_model = load_json_model(settings.workspace_data +
'/cobra_model_tmp.json')
else:
print('file_type not supported')
if convert2irreversible_I: convert_to_irreversible(cobra_model)
# Apply KOs, if any:
for ko in ko_list:
cobra_model.reactions.get_by_id(ko).lower_bound = 0.0
cobra_model.reactions.get_by_id(ko).upper_bound = 0.0
# Apply flux constraints, if any:
for rxn, flux in flux_dict.items():
cobra_model.reactions.get_by_id(rxn).lower_bound = flux['lb']
cobra_model.reactions.get_by_id(rxn).upper_bound = flux['ub']
# Change description, if any:
if description:
cobra_model.description = description
# test the model
if self.test_model(cobra_model):
# write the model to a temporary file
with open(settings.workspace_data + '/cobra_model_tmp.xml',
'wb') as file:
file.write(cobra_model)
# upload the model to the database
qio02.import_dataStage02PhysiologyModel_sbml(
model_id_I, date_I,
settings.workspace_data + '/cobra_model_tmp.xml')
elif model_file_name_I and model_id_O: #modify an existing model not in the database
# Read in the sbml file and define the model conditions
cobra_model = create_cobra_model_from_sbml_file(model_file_name_I,
print_time=True)
if convert2irreversible_I: convert_to_irreversible(cobra_model)
# Apply KOs, if any:
for ko in ko_list:
cobra_model.reactions.get_by_id(ko).lower_bound = 0.0
cobra_model.reactions.get_by_id(ko).upper_bound = 0.0
# Apply flux constraints, if any:
for rxn, flux in flux_dict.items():
cobra_model.reactions.get_by_id(rxn).lower_bound = flux['lb']
cobra_model.reactions.get_by_id(rxn).upper_bound = flux['ub']
# Change description, if any:
if description:
cobra_model.description = description
# test the model
if self.test_model(cobra_model):
# write the model to a temporary file
with open(settings.workspace_data + '/cobra_model_tmp.xml',
'wb') as file:
file.write(cobra_model)
# upload the model to the database
qio02.import_dataStage02PhysiologyModel_sbml(
model_id_I, date_I,
settings.workspace_data + '/cobra_model_tmp.xml')
else:
print(
'need to specify either an existing model_id or model_file_name!'
)
return
import pandas as pd
import numpy as np
from cobra.io.sbml import create_cobra_model_from_sbml_file
from cobra.flux_analysis.parsimonious import optimize_minimal_flux
from cobra.manipulation.modify import convert_to_irreversible
conditions = pd.DataFrame.from_csv("../data/conditions.csv")
conditions = conditions[conditions.media_key>0]
conditions.sort_values('growth rate Gerosa [h-1]', inplace=True)
cs = conditions.index
projections = pd.DataFrame.from_csv('../data/flux projections[mmol_gCDW_h].csv')
model = create_cobra_model_from_sbml_file('../source/iJO1366.xml')
convert_to_irreversible(model)
mmol_gCDW = pd.DataFrame(index = map(str, model.reactions),
columns = cs)
for c in projections.columns:
cobra_c = conditions.loc[c, 'media_key']
gr = conditions.loc[c, 'growth rate Gerosa [h-1]']
model = create_cobra_model_from_sbml_file('../source/iJO1366.xml')
convert_to_irreversible(model)
# redefine sole carbon source uptake reaction in mmol/gr/h
model.reactions.get_by_id('EX_glc_e').lower_bound = 0
model.reactions.get_by_id('EX_' + cobra_c + '_e').lower_bound = -1000
# set growth rate according to measurements
biomass = "Ec_biomass_iJO1366_WT_53p95M"
def load_ALEWt(self,anoxic = False, oxic = True, update_ampms2 = True, convert2irreversible = False):
'''load iJO1366 with the following changes:
1. update to AMPMS2 to account for carbon monoxide
2. changes to uptake bounds for glucose M9 media
3. constrain the model to use 'PFK' instead of 'F6PA', 'DHAPT' when grown on glucose
4. constrain the model to use the physiologically perferred glutamate synthesis enzymes
5. depending on oxygen availability, constrain the model to use the correct RNR enzymes
6. depending on oxygen availability, constrain the model to use the correct Dihydroorotate dehydrogenase (PyrD) enzymes
7. constrain fatty acid biosynthesis to use the physiologically preferred enzymes'''
ijo1366_sbml = settings.workspace_data+"/models/iJO1366.xml"
# Read in the sbml file and define the model conditions
cobra_model = create_cobra_model_from_sbml_file(ijo1366_sbml, print_time=True)
if update_ampms2:
# Update AMPMS2
coc = Metabolite('co_c','CO','carbon monoxide','c');
cop = Metabolite('co_p','CO','carbon monoxide','p');
coe = Metabolite('co_e','CO','carbon monoxide','e');
cobra_model.add_metabolites([coc,cop,coe])
ampms2_mets = {};
ampms2_mets[cobra_model.metabolites.get_by_id('air_c')] = -1;
ampms2_mets[cobra_model.metabolites.get_by_id('amet_c')] = -1;
ampms2_mets[cobra_model.metabolites.get_by_id('dad_DASH_5_c')] = 1;
ampms2_mets[cobra_model.metabolites.get_by_id('met_DASH_L_c')] = 1;
ampms2_mets[cobra_model.metabolites.get_by_id('4ampm_c')] = 1;
ampms2_mets[cobra_model.metabolites.get_by_id('h_c')] = 3;
ampms2_mets[cobra_model.metabolites.get_by_id('for_c')] = 1;
ampms2_mets[cobra_model.metabolites.get_by_id('co_c')] = 1;
ampms2 = Reaction('AMPMS3');
ampms2.add_metabolites(ampms2_mets);
copp_mets = {};
copp_mets[cobra_model.metabolites.get_by_id('co_c')] = -1;
copp_mets[cobra_model.metabolites.get_by_id('co_p')] = 1;
copp = Reaction('COtpp');
copp.add_metabolites(copp_mets);
coex_mets = {};
coex_mets[cobra_model.metabolites.get_by_id('co_p')] = -1;
coex_mets[cobra_model.metabolites.get_by_id('co_e')] = 1;
coex = Reaction('COtex');
coex.add_metabolites(coex_mets);
cotrans_mets = {};
cotrans_mets[cobra_model.metabolites.get_by_id('co_e')] = -1;
cotrans = Reaction('EX_co_LPAREN_e_RPAREN_');
cotrans.add_metabolites(cotrans_mets);
cobra_model.add_reactions([ampms2,copp,coex,cotrans]);
cobra_model.remove_reactions(['AMPMS2']);
# Define the model conditions:
system_boundaries = [x.id for x in cobra_model.reactions if x.boundary == 'system_boundary'];
for b in system_boundaries:
cobra_model.reactions.get_by_id(b).lower_bound = 0.0;
cobra_model.reactions.get_by_id(b).upper_bound = 0.0;
# Reset demand reactions
demand = ['DM_4CRSOL',
'DM_5DRIB',
'DM_AACALD',
'DM_AMOB',
'DM_MTHTHF',
'DM_OXAM'];
for d in demand:
cobra_model.reactions.get_by_id(d).lower_bound = 0.0;
cobra_model.reactions.get_by_id(d).upper_bound = 1000.0;
# Change the objective
update_objective(cobra_model,{'Ec_biomass_iJO1366_WT_53p95M':1.0})
# Assign KOs
# Specify media composition (M9 glucose):
cobra_model.reactions.get_by_id('EX_glc_LPAREN_e_RPAREN_').lower_bound = -10.0;
cobra_model.reactions.get_by_id('EX_o2_LPAREN_e_RPAREN_').lower_bound = -18.0;
#uptake = ['EX_cl_LPAREN_e_RPAREN_',
# 'EX_so4_LPAREN_e_RPAREN_',
# 'EX_ca2_LPAREN_e_RPAREN_',
# 'EX_pi_LPAREN_e_RPAREN_',
# 'EX_fe2_LPAREN_e_RPAREN_',
# 'EX_cu2_LPAREN_e_RPAREN_',
# 'EX_zn2_LPAREN_e_RPAREN_',
# 'EX_cbl1_LPAREN_e_RPAREN_',
# 'EX_mobd_LPAREN_e_RPAREN_',
# 'EX_ni2_LPAREN_e_RPAREN_',
# 'EX_mn2_LPAREN_e_RPAREN_',
# 'EX_k_LPAREN_e_RPAREN_',
# 'EX_nh4_LPAREN_e_RPAREN_',
# 'EX_cobalt2_LPAREN_e_RPAREN_',
# 'EX_mg2_LPAREN_e_RPAREN_'];
uptake = ['EX_ca2_LPAREN_e_RPAREN_',
'EX_cbl1_LPAREN_e_RPAREN_',
'EX_cl_LPAREN_e_RPAREN_',
'EX_co2_LPAREN_e_RPAREN_',
'EX_cobalt2_LPAREN_e_RPAREN_',
'EX_cu2_LPAREN_e_RPAREN_',
'EX_fe2_LPAREN_e_RPAREN_',
'EX_fe3_LPAREN_e_RPAREN_',
'EX_h_LPAREN_e_RPAREN_',
'EX_h2o_LPAREN_e_RPAREN_',
'EX_k_LPAREN_e_RPAREN_',
'EX_mg2_LPAREN_e_RPAREN_',
'EX_mn2_LPAREN_e_RPAREN_',
'EX_mobd_LPAREN_e_RPAREN_',
'EX_na1_LPAREN_e_RPAREN_',
'EX_nh4_LPAREN_e_RPAREN_',
'EX_ni2_LPAREN_e_RPAREN_',
'EX_pi_LPAREN_e_RPAREN_',
'EX_sel_LPAREN_e_RPAREN_',
'EX_slnt_LPAREN_e_RPAREN_',
'EX_so4_LPAREN_e_RPAREN_',
'EX_tungs_LPAREN_e_RPAREN_',
'EX_zn2_LPAREN_e_RPAREN_'];
for u in uptake:
cobra_model.reactions.get_by_id(u).lower_bound = -1000.0;
# Specify allowed secretion products
secrete = ['EX_meoh_LPAREN_e_RPAREN_',
'EX_5mtr_LPAREN_e_RPAREN_',
'EX_h_LPAREN_e_RPAREN_',
'EX_co2_LPAREN_e_RPAREN_',
'EX_co_LPAREN_e_RPAREN_',
'EX_h2o_LPAREN_e_RPAREN_',
'EX_ac_LPAREN_e_RPAREN_',
'EX_fum_LPAREN_e_RPAREN_',
'EX_for_LPAREN_e_RPAREN_',
'EX_etoh_LPAREN_e_RPAREN_',
'EX_lac_DASH_L_LPAREN_e_RPAREN_',
'EX_pyr_LPAREN_e_RPAREN_',
'EX_succ_LPAREN_e_RPAREN_'];
for s in secrete:
cobra_model.reactions.get_by_id(s).upper_bound = 1000.0;
# Constrain specific reactions
noFlux = ['F6PA', 'DHAPT'];
ammoniaExcess = ['GLUDy']; # PMCID: 196288
# RNR control (DOI:10.1111/j.1365-2958.2006.05493.x)
# Dihydroorotate dehydrogenase (PyrD) (DOI:10.1016/S0076-6879(78)51010-0, PMID: 199252, DOI:S0969212602008316 [pii])
aerobic = ['RNDR1', 'RNDR2', 'RNDR3', 'RNDR4', 'DHORD2', 'ASPO6','LCARR','PFL','FRD2','FRD3']; # see DOI:10.1111/j.1365-2958.2011.07593.x; see DOI:10.1089/ars.2006.8.773 for a review
anaerobic = ['RNTR1c2', 'RNTR2c2', 'RNTR3c2', 'RNTR4c2', 'DHORD5', 'ASPO5','PDH','SUCDi']; # see DOI:10.1074/jbc.274.44.31291, DOI:10.1128/JB.00440-07
if anoxic:
rxnList = noFlux + ammoniaExcess + anaerobic;
for rxn in rxnList:
cobra_model.reactions.get_by_id(rxn).lower_bound = 0.0;
cobra_model.reactions.get_by_id(rxn).upper_bound = 0.0;
elif oxic:
rxnList = noFlux + ammoniaExcess + aerobic;
for rxn in rxnList:
cobra_model.reactions.get_by_id(rxn).lower_bound = 0.0;
cobra_model.reactions.get_by_id(rxn).upper_bound = 0.0;
else:
rxnList = noFlux + ammoniaExcess;
for rxn in rxnList:
cobra_model.reactions.get_by_id(rxn).lower_bound = 0.0;
cobra_model.reactions.get_by_id(rxn).upper_bound = 0.0;
# Set the direction for specific reactions
# Fatty acid biosynthesis: DOI: 10.1016/j.ymben.2010.10.007, PMCID: 372925
fattyAcidSynthesis = ['ACCOAC', 'ACOATA', 'HACD1', 'HACD2', 'HACD3', 'HACD4', 'HACD5', 'HACD6', 'HACD7', 'HACD8', 'KAS14', 'KAS15', 'MACPD', 'MCOATA', '3OAR100', '3OAR120', '3OAR121', '3OAR140', '3OAR141', '3OAR160', '3OAR161', '3OAR180', '3OAR181', '3OAR40', '3OAR60', '3OAR80']
fattyAcidOxidation = ['ACACT1r', 'ACACT2r', 'ACACT3r', 'ACACT4r', 'ACACT5r', 'ACACT6r', 'ACACT7r', 'ACACT8r', 'ACOAD1f', 'ACOAD2f', 'ACOAD3f', 'ACOAD4f', 'ACOAD5f', 'ACOAD6f', 'ACOAD7f', 'ACOAD8f', 'CTECOAI6', 'CTECOAI7', 'CTECOAI8', 'ECOAH1', 'ECOAH2', 'ECOAH3', 'ECOAH4', 'ECOAH5', 'ECOAH6', 'ECOAH7', 'ECOAH8']
ndpk = ['NDPK1','NDPK2','NDPK3','NDPK4','NDPK5','NDPK7','NDPK8'];
rxnList = fattyAcidSynthesis + fattyAcidOxidation;
for rxn in rxnList:
cobra_model.reactions.get_by_id(rxn).lower_bound = 0.0;
cobra_model.reactions.get_by_id(rxn).upper_bound = 1000.0;
# convert to irreversible
if convert2irreversible: convert_to_irreversible(cobra_model);
return cobra_model;
def __init__(self,
model,
confidence,
met_prod=None,
n=5,
penalty_factor=100,
support=5,
solver=None,
**solver_kwargs):
"""Initialize parameters and model"""
self.model = deepcopy(model)
self.objective = model.objective.copy()
# Add metabolic targets as mock reactions
arrow_re = re.compile("<?(-+|=+)>")
if met_prod:
if type(met_prod) != list:
met_prod = [met_prod]
for i, mid in enumerate(met_prod):
r = Reaction("EX_CORDA_" + str(i))
r.notes["mock"] = mid
r.upper_bound = UPPER
self.model.add_reaction(r)
if type(mid) == str:
if arrow_re.search(mid):
r.build_reaction_from_string(mid)
else:
r.add_metabolites({mid: -1})
elif type(mid) == dict:
r.add_metabolites(mid)
else:
raise TypeError("metabolite test not string or dictionary")
confidence[r.id] = 3
convert_to_irreversible(self.model)
# Map confidences from forward to backward reactions
self.conf = {}
for r in self.model.reactions:
r.objective_coefficient = 0
r.upper_bound = UPPER
if r.id in confidence:
if confidence[r.id] not in [-1, 0, 1, 2, 3]:
raise ValueError("Not a valid confidence value!")
else:
self.conf[r.id] = confidence[r.id]
elif "reflection" in r.notes:
rev = self.model.reactions.get_by_id(r.notes["reflection"])
if confidence[rev.id] not in [-1, 0, 1, 2, 3]:
raise ValueError("Not a valid confidence value!")
self.conf[r.id] = confidence[rev.id]
else:
raise ValueError("{} missing from confidences!".format(r.id))
self.__conf_old = self.conf.copy()
self.built = False
self.tflux = 1
self.impossible = []
self.n = n
self.support = support
self.pf = penalty_factor
self.solver = solver_dict[get_solver_name(
) if solver is None else solver]
self.sargs = solver_kwargs
def _main_():
##PART 1: Working
#-------
# Read in the model sbml file and define the model conditions
# Aerobic specific changes
cobra_model_oxic = load_thermoModel(anoxic = False)
convert_to_irreversible(cobra_model_oxic)
##PART 2: Working
#-------
# make/load simulated data for aerobic conditions
data_fva_oxic = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_fva_irrev_oxic.json'
data_srd_oxic = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_srd_irrev_oxic.json'
simulated_data_oxic = thermodynamics_simulatedData()
# simulated_data_oxic.generate_sra_data(cobra_model_oxic) # perform single reaction deletion analysis
# simulated_data_oxic.generate_fva_data(cobra_model_oxic) # perform flux variability analysis
# simulated_data_oxic.export_sra_data(data_srd_oxic) # save results for later use
# simulated_data_oxic.export_fva_data(data_fva_oxic) # save results for later use
simulated_data_oxic.import_sra_data(data_srd_oxic)
simulated_data_oxic.import_fva_data(data_fva_oxic)
simulated_data_oxic.check_data()
##PART 3: Working
#-------
# load pH, ionic_strength, and temperature parameters
other_data = thermodynamics_otherData()
other_data.load_defaultData()
other_data.check_data()
# generate dG_f data for all model compounds
# calculate the dG_f for each compound in each compartment
# export/load and check the dG_f data
#data_dG0_transformed = 'thermodynamics_data/ijo1366_dG_f.json'
data_dG0_transformed = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_dG_f01.json'
dG_f_data = thermodynamics_dG_f_data(id2KEGGID_filename_I='/home/user/code/thermodynamics/thermodynamics_data/id2KEGGID.csv')
# # # dG_f_data.make_dG0_f_pH0() # only if the data has not been generated previously!
# dG_f_data.get_transformed_dG_f('/home/user/code/thermodynamics/thermodynamics_data/compounds_dG0_f.json',cobra_model_oxic,other_data.pH,other_data.temperature,other_data.ionic_strength) # adjust the non-transformed dG0_f data to physiological pH, temperature, and ionic strength (this step has already been completed)
#dG_f_data.export_dG_f(data_dG0_transformed) # save results for later use
dG_f_data.import_dG_f(data_dG0_transformed)
dG_f_data.format_dG_f()
dG_f_data.generate_estimated_dG_f(cobra_model_oxic)
dG_f_data.check_data()
##PART 4: Working
#-------
# load metabolomics data for oxic conditions
data_concentrations_oxic = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_oxic_geo01.json'
metabolomics_data_oxic = thermodynamics_metabolomicsData()
metabolomics_data_oxic.import_metabolomics_data(data_concentrations_oxic)
metabolomics_data_oxic.format_metabolomics_data() # add compartment identifiers to metabolite ids
metabolomics_data_oxic.generate_estimated_metabolomics_data(cobra_model_oxic)
##PART 5: Working
#-------
# calculate dG_r and perform a consistency check based on model simulations for oxic conditions
data_ta_oxic = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_oxic_irrev_ta.csv'
data_dG0_oxic = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_oxic_orrev_dG0.json'
data_dG_oxic = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_oxic_irrev_dG.json'
data_tcc_oxic = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_oxic_irrev_tcc.json'
tcc_oxic = thermodynamics_dG_r_data()
tcc_oxic.import_dG0_r_json(data_dG0_oxic)
tcc_oxic.import_dG_r_json(data_dG_oxic)
tcc_oxic.import_tcc_json(data_tcc_oxic)
# tcc_oxic.calculate_dG0_r(cobra_model_oxic, dG_f_data.measured_dG_f, dG_f_data.estimated_dG_f, other_data.temperature) # calculate the change in free energy of reaction without accounting for metabolite concentrations
# tcc_oxic.calculate_dG_r(cobra_model_oxic,metabolomics_data_oxic.measured_concentrations, metabolomics_data_oxic.estimated_concentrations,
# other_data.pH, other_data.ionic_strength, other_data.temperature) # adjust the change in free energy of reaction for intracellular metabolite concentrations
# tcc_oxic.check_thermodynamicConsistency(cobra_model_oxic,simulated_data_oxic.fva_data,
# metabolomics_data_oxic.measured_concentrations,
# metabolomics_data_oxic.estimated_concentrations,
# other_data.pH,other_data.ionic_strength,other_data.temperature) # check the thermodynamic consistency of the data
# tcc_oxic.export_dG0_r_json(data_dG0_oxic) # save for later use
# tcc_oxic.export_dG_r_json(data_dG_oxic) # save for later use
# tcc_oxic.export_tcc_json(data_tcc_oxic) # save for later use
# tcc_oxic.export_summary(cobra_model_oxic,simulated_data_oxic.fva_data,data_ta_oxic) # write summary of the analysis to csv file
##PART 8:
#-------
# Diagnose model variables and constraints prior to FBA, FVA, and sampling (Oxic condition only)
# identified inconsistent concentrations/dG_f/tcc values
inconsistent_concentrations_I = []
inconsistent_dG_f_I = []
inconsistent_tcc_I = ['EX_glc_LPAREN_e_RPAREN__reverse']
# remove an inconsistent dGf values
dG_f_data.remove_measured_dG_f(inconsistent_dG_f_I)
# remove an inconsistent concentration values
metabolomics_data_oxic.remove_measured_concentrations(inconsistent_concentrations_I)
# remove an inconcsistent tcc
tcc_oxic.change_feasibleReactions(inconsistent_tcc_I)
# diagnose tfba constraints
tfba = thermodynamics_tfba()
# thermodynamic_constraints_check,\
# inconsistent_tcc,diagnose_variables_1,\
# diagnose_variables_2,\
# diagnose_variables_3 = tfba.check_conc_ln_constraints_transport(
# cobra_model_oxic,
# metabolomics_data_oxic.measured_concentrations, metabolomics_data_oxic.estimated_concentrations,
# tcc_oxic.dG0_r, other_data.pH,other_data.temperature,tcc_oxic.metabolomics_coverage,
# tcc_oxic.dG_r_coverage, tcc_oxic.thermodynamic_consistency_check,
# 0.5, 0.99,n_checks_I = 0,
# diagnose_solver_I=None,diagnose_threshold_I=0.98,diagnose_break_I=0.1)
# tfba._add_conc_ln_constraints_transport(cobra_model_oxic,
# metabolomics_data_oxic.measured_concentrations, metabolomics_data_oxic.estimated_concentrations,
# tcc_oxic.dG0_r, other_data.pH,other_data.temperature,tcc_oxic.metabolomics_coverage,
# tcc_oxic.dG_r_coverage, tcc_oxic.thermodynamic_consistency_check,
# 0.5, 0.99)
# # cobra_model_oxic.optimize()
# from cobra.flux_analysis import flux_variability_analysis
# fva_data = flux_variability_analysis(cobra_model_oxic, fraction_of_optimum=0.9,
# objective_sense='maximize',
# reaction_list=[cobra_model_oxic.reactions.get_by_id('conc_lnv_fum_c')],
# )
# #PART 9:
# -------
# perform thermodynamic FBA and FVA (Oxic condition only)
# # run TFBA
# cobra_model_copy = cobra_model_oxic.copy()
# tfba.tfba(cobra_model_copy,
# tcc_oxic.dG0_r,other_data.temperature,
# tcc_oxic.dG_r_coverage, tcc_oxic.thermodynamic_consistency_check,
# use_measured_dG_r=True, solver='glpk',)
# cobra_model_copy = cobra_model_oxic.copy()
# tfba.tfba_conc_ln(cobra_model_copy,
# metabolomics_data_oxic.measured_concentrations, metabolomics_data_oxic.estimated_concentrations,
# tcc_oxic.dG0_r,other_data.temperature,tcc_oxic.metabolomics_coverage,
# tcc_oxic.dG_r_coverage, tcc_oxic.thermodynamic_consistency_check,
# measured_concentration_coverage_criteria = 0.5, measured_dG_f_coverage_criteria = 0.99,
# use_measured_concentrations=True,use_measured_dG0_r=True, solver='glpk',)
# run TFVA
data_tfva_oxic = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_oxic_irrev_tfva.csv'
data_tfva_analysis_oxic = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_oxic_irrev_tfva_analysis.csv'
data_tfva_dG_r_oxic = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_oxic_orrev_tfva_dG_r.json'
data_tfva_concentrations_oxic = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/aerobicAnaerobic01_oxic_irrev_tfva_concentrations.json'
cobra_model_copy = cobra_model_oxic.copy()
tfba.tfva(cobra_model_copy,
tcc_oxic.dG0_r,other_data.temperature,
tcc_oxic.dG_r_coverage, tcc_oxic.thermodynamic_consistency_check,
use_measured_dG0_r=True, reaction_list=None,fraction_of_optimum=1.0, solver='glpk',
objective_sense="maximize")
tfba.export_tfva_data(data_tfva_oxic)
tfba.analyze_tfva_results(flux_threshold=1e-6)
tfba.export_tfva_analysis(data_tfva_analysis_oxic)
cobra_model_copy = cobra_model_oxic.copy()
tfba.tfva_dG_r(cobra_model_copy,
tcc_oxic.dG0_r,other_data.temperature,
tcc_oxic.dG_r_coverage, tcc_oxic.thermodynamic_consistency_check,
use_measured_dG0_r=True, fraction_of_optimum=1.0, solver='glpk',
objective_sense="maximize")
tfba.export_tfva_dG_r_data(data_tfva_dG_r_oxic)
cobra_model_copy = cobra_model_oxic.copy()
tfba.tfva_concentrations(cobra_model_copy,
metabolomics_data_oxic.measured_concentrations, metabolomics_data_oxic.estimated_concentrations,
tcc_oxic.dG0_r,other_data.temperature,tcc_oxic.metabolomics_coverage,
tcc_oxic.dG_r_coverage, tcc_oxic.thermodynamic_consistency_check,
measured_concentration_coverage_criteria = 0.5, measured_dG_f_coverage_criteria = 0.99,
use_measured_concentrations=True,use_measured_dG0_r=True,fraction_of_optimum=1.0, solver='glpk',
objective_sense="maximize")
tfba.export_tfva_concentrations_data(data_tfva_concentrations_oxic)
# ##PART 10:
# #-------
# # perform thermodynamic Tsampling (Oxic condition only)
# # NOTE: requires optGpSampler
# # run Tsampling
# data_dir = '/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo'
# sampling = optGpSampler_sampling(data_dir_I = data_dir);
# simulation_id_I = 'aerobicAnaerobic01_oxic_tsampling'
# filename_model = simulation_id_I + '.json';
# filename_script = simulation_id_I + '.py';
# filename_points = simulation_id_I + '_points' + '.json';
# filename_warmup = simulation_id_I + '_warmup' + '.json';
# sampling.export_sampling_optGpSampler(cobra_model=cobra_model_oxic,
# filename_model=filename_model,
# filename_script=filename_script,
# filename_points=filename_points,
# filename_warmup=filename_warmup,
# solver_id_I = 'optGpSampler',
# n_points_I = 2*len(cobra_model_oxic.reactions),
# n_steps_I = 5000,
# n_threads_I = 2)
##PART 11:
#-------
# Analyze thermodynamic sampling (Oxic condition only)
sampling = optGpSampler_sampling(
data_dir_I = data_dir,
model_I=cobra_model_oxic);
sampling.get_points_json(filename_points);
sampling.get_warmup_json(filename_warmup);
sampling.calculate_mixFraction();
# check if the model contains loops
#loops_bool = self.sampling.check_loops();
sampling.simulate_loops(
data_fva='/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/loops_fva_tmp.json',
solver_I = 'optGpSampler');
sampling.find_loops(data_fva='/home/user/code/thermodynamics/thermodynamics_data/aerobicAnaerobic01_geo/loops_fva_tmp.json');
sampling.remove_loopsFromPoints();
# calculate the flux descriptive statistics
sampling.descriptive_statistics(points_I='flux');
# calculate descriptive stats for metabolites
sampling.convert_points2MetabolitePoints();
sampling.descriptive_statistics(points_I='metabolite');
# calculate descriptive stats for subsystems
sampling.convert_points2SubsystemPoints();
sampling.descriptive_statistics(points_I='subsystem');
# visualize the results
##TODO: methods are defined, but an example is not yet given
def create_minimal_fux_model(metabolic_model,fraction_of_optimum_objective=0.8, fraction_of_flux_minimum=2,mutually_exclusive_directionality_constraint=True,boundaries_precision=0.001,label_model=None,metabolite_list_file_name=None,flux_penalty_dict={},maximum_flux=None,extra_constraints_dict={}):
print "creating irreversible model"
model=metabolic_model.copy()
for reaction_id in extra_constraints_dict:
reaction=model.reactions.get_by_id(reaction_id)
if "lb" in extra_constraints_dict[reaction_id]:
reaction.lower_bound=round_down(extra_constraints_dict[reaction_id]["lb"],6)
if "ub" in extra_constraints_dict[reaction_id]:
reaction.upper_bound=round_up(extra_constraints_dict[reaction_id]["ub"],6)
#original_objective=copy.deepcopy(model.objective)
for reaction in model.reactions:
if reaction.objective_coefficient!=0:
fva=flux_variability_analysis(model,reaction_list=[reaction.id], fraction_of_optimum=fraction_of_optimum_objective)
if reaction.objective_coefficient>0:
reaction.lower_bound=min(fva[reaction.id]["maximum"],reaction.upper_bound)
reaction.upper_bound=min(fva[reaction.id]["maximum"],reaction.upper_bound)
elif reaction.objective_coefficient<0:
reaction.lower_bound=max(fva[reaction.id]["minimum"],reaction.lower_bound)
reaction.upper_bound=max(fva[reaction.id]["minimum"],reaction.lower_bound)
reaction.lower_bound-=boundaries_precision/2.0
reaction.upper_bound+=boundaries_precision/2.0
reaction.objective_coefficient=0
reversible_reactions=[]
convert_to_irreversible(model)
for reaction in model.reactions:
if reaction.lower_bound<0:
reversible_reactions.append(reaction.id)
#convert_to_irreversible_with_indicators(model,reversible_reactions,metabolite_list=[], mutually_exclusive_directionality_constraint = False)
if metabolite_list_file_name!=None and metabolite_list_file_name!="":
metabolite_id_list=read_metabolomics_data(model,metabolite_list_fname=metabolite_list_file_name)
else:
metabolite_id_list=[]
add_turnover_metabolites(model, metabolite_id_list=metabolite_id_list, epsilon=1e-6,label_model=label_model)
flux_reporter = Metabolite('flux_reporter_0',formula='',name='',compartment='0')
for reaction in model.reactions:
if "IRRMILP_" in reaction.id or "RATIO_" in reaction.id or "RGROUP_" in reaction.id or "TMS_" in reaction.id:
continue
if reaction.id in flux_penalty_dict:
reporter_coef=flux_penalty_dict[reaction.id]
elif "reflection" in reaction.notes: #If a reversible reaction has no penalty assigned test if the reverse has a penalty
reflection=reaction.notes["reflection"]
if reflection in flux_penalty_dict:
reporter_coef=flux_penalty_dict[reflection]
else:
reporter_coef=1
print "Warning: reaction "+reaction.id+" assigned default weight of 1"
else:
reporter_coef=1
print "Warning: reaction "+reaction.id+" assigned default weight of 1"
if reporter_coef!=0:
reaction.add_metabolites({flux_reporter:reporter_coef})
total_flux_reaction = Reaction('total_flux')
total_flux_reaction.name = 'total_flux'
total_flux_reaction.subsystem = 'misc'
total_flux_reaction.lower_bound = 0
total_flux_reaction.upper_bound = 1000*len(model.reactions)
total_flux_reaction.add_metabolites({flux_reporter:-1})
model.add_reaction(total_flux_reaction)
total_flux_reaction.objective_coefficient=-1
minimal_flux=-1*model.optimize().f
if maximum_flux!=None:
total_flux_reaction.upper_bound = maximum_flux
else:
total_flux_reaction.upper_bound = minimal_flux*fraction_of_flux_minimum
total_flux_reaction.objective_coefficient=0.0
"""for objective in original_objective:
reaction=model.reactions.get_by_id(objective.id)
reaction.lower_bound=(fva[reaction.id]["minimum"]-boundaries_precision/2.0)
reaction.upper_bound=(fva[reaction.id]["maximum"]+boundaries_precision/2.0)"""
milp_reactions=model.reactions.query("IRRMILP_")
non_milp_reactions=[]
for reaction in model.reactions:
if reaction not in milp_reactions:
non_milp_reactions.append(reaction)
return model,minimal_flux,non_milp_reactions
def make_modelFromRxnsAndMetsTables(self,
model_id_I=None,model_id_O=None,date_O=None,description=None,
ko_list=[],flux_dict={},rxn_include_list=[],
convert2irreversible_I=False,revert2reversible_I=False,
convertPathway2individualRxns_I=False,
model_id_template_I='iJO1366',pathway_model_id_I=None
):
'''make/update the model using the modelReactions and modelMetabolites table
INPUT:
model_id_I = existing model_id (if specified, an existing model in the database will be retrieved and modified)
model_file_name_I = new model from file (if specified, a new model form file will be retrieved and modified)
model_id_O = new model_id
date_O = date the model was made
description = description for the model
INPUT (constraints in order):
ko_list = list of reactions to constrain to zero flux
flux_dict = dictionary of fluxes to constrain the model
INPUT (model manipulation in order):
rxn_include_list = list of reactions to include in the new model
convertPathway2individualRxns_I = boolean, if True, lumped rxns will be converted to individual rxns
template_model_id_I = model_id to use as a template when adding in new reactions
pathway_model_id_I = model_id for the pathway
convert2irreversible_I = boolean, if True, the model will be converted to irreversible from reversible
revert2reversible_I = boolean, if True, the model will be revert to reversible from irreversible
'''
# get the model reactions and metabolites from the database
reactions = [];
metabolites = [];
reactions = self.get_rows_modelID_dataStage02PhysiologyModelReactions(model_id_I);
metabolites = self.get_rows_modelID_dataStage02PhysiologyModelMetabolites(model_id_I);
# break apart lumped reactions
if convertPathway2individualRxns_I:
metabolites_O = [];
reactions,metabolites_O = self.convert_lumpedRxns2IndividualRxns(
model_id_template_I=model_id_template_I,
pathway_model_id_I=pathway_model_id_I,
reactions_I=reactions);
# add in any new metabolites that may have been found
met_ids = [x['met_id'] for x in metabolites];
for met in metabolites_O:
if not met['met_id'] in met_ids:
metabolites.append(met);
# create the model
cobra_model = self.create_modelFromReactionsAndMetabolitesTables(reactions,metabolites)
# Constrain the model
self.constrain_modelModelVariables(cobra_model,
ko_list=ko_list,flux_dict=flux_dict);
# Use only a subset of reactions, if specified
if rxn_include_list:
remove_reactions=[];
for rxn in cobra_model.reactions:
if not rxn.id in rxn_include_list:
remove_reactions.append(rxn);
cobra_model.remove_reactions(remove_reactions,delete=True,remove_orphans=True);
if convert2irreversible_I: convert_to_irreversible(cobra_model);
if revert2reversible_I:
self.repair_irreversibleModel(cobra_model);
self.revert2reversible(cobra_model);
# Change description, if any:
if description:
cobra_model.description = description;
# test the model
if self.test_model(cobra_model):
# write the model to a temporary file
save_json_model(cobra_model,'cobra_model_tmp.json')
# add the model information to the database
dataStage02PhysiologyModelRxns_data = [];
dataStage02PhysiologyModelMets_data = [];
dataStage02PhysiologyModels_data,\
dataStage02PhysiologyModelRxns_data,\
dataStage02PhysiologyModelMets_data = self._parse_model_json(model_id_O, date_O, 'cobra_model_tmp.json')
if model_id_I and model_id_O: #make a new model based off of a modification of an existing model in the database
self.add_dataStage02PhysiologyModelMetabolites(dataStage02PhysiologyModelMets_data);
self.add_dataStage02PhysiologyModelReactions(dataStage02PhysiologyModelRxns_data);
self.add_dataStage02PhysiologyModels(dataStage02PhysiologyModels_data);
elif model_id_I and not model_id_O: #update an existing model in the database
self.update_data_stage02_isotopomer_models(dataStage02PhysiologyModels_data);
else:
print('need to specify either an existing model_id!')
return
