Source code for cobra.flux_analysis.reaction

# cobra.flux_analysis.reaction.py
# functions for analyzing / creating objective functions
from ..core.Reaction import Reaction
from six import iteritems


[docs]def assess(model, reaction, flux_coefficient_cutoff=0.001, solver=None): """Assesses the capacity of the model to produce the precursors for the reaction and absorb the production of the reaction while the reaction is operating at, or above, the specified cutoff. model: A :class:`~cobra.core.Model` object reaction: A :class:`~cobra.core.Reaction` object flux_coefficient_cutoff: Float. The minimum flux that reaction must carry to be considered active. solver : String or solver name. If None, the default solver will be used. returns: True if the model can produce the precursors and absorb the products for the reaction operating at, or above, flux_coefficient_cutoff. Otherwise, a dictionary of {'precursor': Status, 'product': Status}. Where Status is the results from assess_precursors and assess_products, respectively. """ reaction = model.reactions.get_by_id(reaction.id) original_objective = model.objective model.objective = reaction model.optimize(solver=solver) model.objective = original_objective if model.solution.f >= flux_coefficient_cutoff: return True else: results = {} results['precursors'] = assess_precursors( model, reaction, flux_coefficient_cutoff) results['products'] = assess_products( model, reaction, flux_coefficient_cutoff) return results
[docs]def assess_precursors(model, reaction, flux_coefficient_cutoff=0.001, solver=None): """Assesses the ability of the model to provide sufficient precursors for a reaction operating at, or beyond, the specified cutoff. model: A :class:`~cobra.core.Model` object reaction: A :class:`~cobra.core.Reaction` object flux_coefficient_cutoff: Float. The minimum flux that reaction must carry to be considered active. solver : String or solver name. If None, the default solver will be used. returns: True if the precursors can be simultaneously produced at the specified cutoff. False, if the model has the capacity to produce each individual precursor at the specified threshold but not all precursors at the required level simultaneously. Otherwise a dictionary of the required and the produced fluxes for each reactant that is not produced in sufficient quantities. """ model = model.copy() reaction = model.reactions.get_by_id(reaction.id) original_objective = model.objective model.objective = reaction model.optimize(solver=solver) model.objective = original_objective if model.solution.f >= flux_coefficient_cutoff: return True # simulation_results = {} # build the sink reactions and add all at once sink_reactions = {} for the_component in reaction.reactants: # add in a sink reaction for each component sink_reaction = Reaction('test_sink_%s' % the_component.id) # then simulate production ability # then check it can exceed objective cutoff * component stoichiometric # coefficient. coefficient = reaction.get_coefficient(the_component) sink_reaction.add_metabolites({the_component: coefficient}) sink_reaction.upper_bound = 1000 sink_reactions[sink_reaction] = (the_component, coefficient) # First assess whether all precursors can pbe produced simultaneously super_sink = Reaction("super_sink") for reaction in sink_reactions: super_sink += reaction super_sink.id = 'super_sink' model.add_reactions(sink_reactions.keys() + [super_sink]) model.objective = super_sink model.optimize(solver=solver) model.objective = original_objective if flux_coefficient_cutoff <= model.solution.f: return True # Otherwise assess the ability of the model to produce each precursor # individually. Now assess the ability of the model to produce each # reactant for a reaction for sink_reaction, (component, coefficient) in iteritems(sink_reactions): # Calculate the maximum amount of the model.objective = sink_reaction model.optimize(solver=solver) model.objective = original_objective # metabolite that can be produced. if flux_coefficient_cutoff > model.solution.f: # Scale the results to a single unit simulation_results.update({ component: { 'required': flux_coefficient_cutoff / abs(coefficient), 'produced': model.solution.f / abs(coefficient) } }) if len(simulation_results) == 0: simulation_results = False return simulation_results
[docs]def assess_products(model, reaction, flux_coefficient_cutoff=0.001, solver=None): """Assesses whether the model has the capacity to absorb the products of a reaction at a given flux rate. Useful for identifying which components might be blocking a reaction from achieving a specific flux rate. model: A :class:`~cobra.core.Model` object reaction: A :class:`~cobra.core.Reaction` object flux_coefficient_cutoff: Float. The minimum flux that reaction must carry to be considered active. solver : String or solver name. If None, the default solver will be used. returns: True if the model has the capacity to absorb all the reaction products being simultaneously given the specified cutoff. False, if the model has the capacity to absorb each individual product but not all products at the required level simultaneously. Otherwise a dictionary of the required and the capacity fluxes for each product that is not absorbed in sufficient quantities. """ model = model.copy() reaction = model.reactions.get_by_id(reaction.id) original_objective = model.objective model.objective = reaction model.optimize(solver=solver) model.objective = original_objective if model.solution.f >= flux_coefficient_cutoff: return True # simulation_results = {} # build the sink reactions and add all at once source_reactions = {} for the_component in reaction.products: # add in a sink reaction for each component source_reaction = Reaction('test_source_%s' % the_component.id) # then simulate production ability # then check it can exceed objective cutoff * component stoichiometric # coefficient. coefficient = reaction.get_coefficient(the_component) source_reaction.add_metabolites({the_component: coefficient}) source_reaction.upper_bound = 1000 source_reactions[source_reaction] = (the_component, coefficient) # super_source = Reaction('super_source') for reaction in source_reactions: super_source += reaction super_source.id = 'super_source' model.add_reactions(source_reactions.keys() + [super_source]) model.objective = super_source model.optimize(solver=solver) model.objective = original_objective if flux_coefficient_cutoff <= model.solution.f: return True # Now assess the ability of the model to produce each reactant for a # reaction for source_reaction, (component, coefficient) in \ iteritems(source_reactions): # Calculate the maximum amount of the model.objective = source_reaction model.optimize(solver=solver) model.objective = original_objective # metabolite that can be produced. if flux_coefficient_cutoff > model.solution.f: # Scale the results to a single unit simulation_results.update({ component: { 'required': flux_coefficient_cutoff / abs(coefficient), 'capacity': model.solution.f / abs(coefficient)} } ) if len(simulation_results) == 0: simulation_results = False return simulation_results