示例#1
0
文件: corda.py 项目: cmptrx/corda
    def cobra_model(self, name, reversible=True, bound=1000):
        """Constructs a cobra model for the reconstruction.

        Args:
            name (str): The name of the cobra model.
            reversible (Optiona[bool]): Whether the returned model should
                be reversible. Default is yes.
            bound (Optional[float]): The default flux bound for the reactions.

        Returns:
            A cobra model containing the reconstruction. The original objective
            will be conserved if it is still included in the model.
        """
        new_mod = Model(name)
        m = deepcopy(self.model)
        for rid in self.conf:
            r = m.reactions.get_by_id(rid)
            if self.conf[rid] == 3 and "mock" not in r.notes:
                if r not in new_mod.reactions:
                    r.upper_bound = bound
                    new_mod.add_reaction(r)
                if "reflection" in r.notes:
                    rev = m.reactions.get_by_id(r.notes["reflection"])
                    if rev not in new_mod.reactions:
                        rev.upper_bound = bound
                        new_mod.add_reaction(rev)

        if reversible:
            revert_to_reversible(new_mod)
        still_valid = True
        for r in self.objective:
            still_valid &= (self.conf[r.id] == 3)
        if still_valid:
            new_mod.change_objective(self.objective)
        return new_mod
示例#2
0
文件: iterations.py 项目: yseif/sbaas
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]);
示例#3
0
文件: iterations.py 项目: SBRG/sbaas
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]);
示例#4
0
 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)
示例#5
0
 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)
示例#6
0
    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)
示例#7
0
    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)
示例#8
0
    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)
示例#9
0
    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)
示例#10
0
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
copies_fL = pd.read_csv("../data/abundance[copies_fl].csv")
copies_fL = copies_fL[['bnumber', 'GLC_BATCH_mu=0.58_S']]
abundance = pd.DataFrame.from_csv("../data/g_gCDW.csv")
cu = CAPACITY_USAGE(flux, abundance)


uni_to_b = {row[48:54]:row[0:5].split(';')[0].strip()
            for row in open("../data/all_ecoli_genes.txt", 'r')}

id_mapper = pd.DataFrame.from_dict(uni_to_b.items())
id_mapper.columns = ["uniprot", "bnumber"]
TS = pd.read_csv("../data/thermoal_stability_ecoli.csv")
df = TS.merge(id_mapper, on=["uniprot"])
#%%
model = cu.model.copy()
revert_to_reversible(model)
def one2one_mapping():
    l = []
    for b in cu.model.genes:
        l+=(list(product([b.id], list(b.reactions))))
    df = pd.DataFrame(l)
    df.columns = ['bnumber', 'reaction']
    df.loc[:, '# genes in reaction'] = [len(r.genes) for r in df['reaction']]
    return df

b2r = one2one_mapping()
df = df.merge(b2r, on="bnumber", how='outer')
df = df.merge(copies_fL, on="bnumber", how='outer')
df['reaction'] = df['reaction'].map(str, )
kmax = cu.kmax
kmax.name='kmax'
def MergeRev(model, update_solution=True):
    modify.revert_to_reversible(model, update_solution=update_solution)