def add_reaction(model, id, name, sparse, lower_bound=0, upper_bound=1000): """ Adds a reaction to the model """ # convert the sparse representation using the metabolites in the model for key in sparse.keys(): if key not in model.metabolites: raise Exception("cannot find the cytoplasmic metabolite %s in the model" % key) r = dict([(model.metabolites[model.metabolites.index(key)], val) for key, val in sparse.iteritems()]) reaction = Reaction(name) reaction.id = id reaction.add_metabolites(r) reaction.lower_bound = lower_bound reaction.upper_bound = upper_bound model.add_reactions([reaction]) return reaction
def from_mat_struct(mat_struct, model_id=None, inf=inf): """create a model from the COBRA toolbox struct The struct will be a dict read in by scipy.io.loadmat """ m = mat_struct if m.dtype.names is None: raise ValueError("not a valid mat struct") if not {"rxns", "mets", "S", "lb", "ub"} <= set(m.dtype.names): raise ValueError("not a valid mat struct") if "c" in m.dtype.names: c_vec = m["c"][0, 0] else: c_vec = None warn("objective vector 'c' not found") model = Model() if model_id is not None: model.id = model_id elif "description" in m.dtype.names: description = m["description"][0, 0][0] if not isinstance(description, string_types) and len(description) > 1: model.id = description[0] warn("Several IDs detected, only using the first.") else: model.id = description else: model.id = "imported_model" for i, name in enumerate(m["mets"][0, 0]): new_metabolite = Metabolite() new_metabolite.id = str(name[0][0]) if all(var in m.dtype.names for var in ['metComps', 'comps', 'compNames']): comp_index = m["metComps"][0, 0][i][0] - 1 new_metabolite.compartment = m['comps'][0, 0][comp_index][0][0] if new_metabolite.compartment not in model.compartments: comp_name = m['compNames'][0, 0][comp_index][0][0] model.compartments[new_metabolite.compartment] = comp_name else: new_metabolite.compartment = _get_id_compartment(new_metabolite.id) if new_metabolite.compartment not in model.compartments: model.compartments[ new_metabolite.compartment] = new_metabolite.compartment try: new_metabolite.name = str(m["metNames"][0, 0][i][0][0]) except (IndexError, ValueError): pass try: new_metabolite.formula = str(m["metFormulas"][0][0][i][0][0]) except (IndexError, ValueError): pass try: new_metabolite.charge = float(m["metCharge"][0, 0][i][0]) int_charge = int(new_metabolite.charge) if new_metabolite.charge == int_charge: new_metabolite.charge = int_charge except (IndexError, ValueError): pass model.add_metabolites([new_metabolite]) new_reactions = [] coefficients = {} for i, name in enumerate(m["rxns"][0, 0]): new_reaction = Reaction() new_reaction.id = str(name[0][0]) new_reaction.lower_bound = float(m["lb"][0, 0][i][0]) new_reaction.upper_bound = float(m["ub"][0, 0][i][0]) if isinf(new_reaction.lower_bound) and new_reaction.lower_bound < 0: new_reaction.lower_bound = -inf if isinf(new_reaction.upper_bound) and new_reaction.upper_bound > 0: new_reaction.upper_bound = inf if c_vec is not None: coefficients[new_reaction] = float(c_vec[i][0]) try: new_reaction.gene_reaction_rule = str(m['grRules'][0, 0][i][0][0]) except (IndexError, ValueError): pass try: new_reaction.name = str(m["rxnNames"][0, 0][i][0][0]) except (IndexError, ValueError): pass try: new_reaction.subsystem = str(m['subSystems'][0, 0][i][0][0]) except (IndexError, ValueError): pass new_reactions.append(new_reaction) model.add_reactions(new_reactions) set_objective(model, coefficients) coo = scipy_sparse.coo_matrix(m["S"][0, 0]) for i, j, v in zip(coo.row, coo.col, coo.data): model.reactions[j].add_metabolites({model.metabolites[i]: v}) return model
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
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