def test_single_gene_deletion(self): cobra_model = self.model initialize_growth_medium(cobra_model, 'LB') # Expected growth rates for the salmonella model with deletions in LB the_loci = ['STM4081', 'STM0247', 'STM3867', 'STM2952'] the_genes = tpiA, metN, atpA, eno = map(cobra_model.genes.get_by_id, the_loci) id_to_name = dict([(x.id, x.name) for x in the_genes]) growth_dict = {'fba': {tpiA.id: 2.41, metN.id: 2.44, atpA.id: 1.87, eno.id: 1.81}, 'moma': {tpiA.id: 1.62, metN.id: 2.4, atpA.id: 1.40, eno.id: 0.33}} # MOMA requires cplex or gurobi try: get_solver_name(qp=True) except: growth_dict.pop('moma') for method, expected in growth_dict.items(): rates, statuses = single_gene_deletion(cobra_model, gene_list=expected.keys(), method=method) for gene, expected_value in iteritems(expected): self.assertEqual(statuses[gene], 'optimal') self.assertAlmostEqual(rates[gene], expected_value, places=2)
def test_flux_variability(self): fva_results = { "5DGLCNtex": {"minimum": 0.0, "maximum": 0.0}, "ABTA": {"minimum": 0.0, "maximum": 0.0}, "5DOAN": {"minimum": 0.0, "maximum": 0.0}, "A5PISO": {"minimum": 0.00692, "maximum": 0.00692}, "AACPS1": {"minimum": 0.0, "maximum": 0.0}, "AACPS2": {"minimum": 0.0, "maximum": 0.0}, "ACALDtex": {"minimum": 0.0, "maximum": 0.0}, "AACPS3": {"minimum": 0.0, "maximum": 0.0}, "AACPS4": {"minimum": 0.0, "maximum": 0.0}, "ABUTD": {"minimum": 0.0, "maximum": 0.0}, "AACPS5": {"minimum": 0.0, "maximum": 0.0}, "AACPS6": {"minimum": 0.0, "maximum": 0.0}, "AACPS7": {"minimum": 0.0, "maximum": 0.0}, "AACPS8": {"minimum": 0.0, "maximum": 0.0}, "AACPS9": {"minimum": 0.0, "maximum": 0.0}, "AACTOOR": {"minimum": 0.0, "maximum": 0.0}, "ABUTt2pp": {"minimum": 0.0, "maximum": 0.0}, "3OAS140": {"minimum": 0.50419, "maximum": 0.50419}, "3OAS141": {"minimum": 0.03748, "maximum": 0.03748}, "3OAS160": {"minimum": 0.41769, "maximum": 0.41769}, "3OAS161": {"minimum": 0.03748, "maximum": 0.03748}, "3OAS180": {"minimum": 0.01071, "maximum": 0.01071}, "3OAS181": {"minimum": 0.01606, "maximum": 0.01606}, "ABUTtex": {"minimum": 0.0, "maximum": 0.0}, "3OAS60": {"minimum": 0.54399, "maximum": 0.54399}, "3OAS80": {"minimum": 0.54399, "maximum": 0.54399}, "AAMYL": {"minimum": 0.0, "maximum": 0.0}, "3PEPTabcpp": {"minimum": 0.0, "maximum": 0.0}, "3PEPTtex": {"minimum": 0.0, "maximum": 0.0}, "3UMPtex": {"minimum": 0.0, "maximum": 0.0}, "4HOXPACDtex": {"minimum": 0.0, "maximum": 0.0}, "ACACtex": {"minimum": 0.0, "maximum": 0.0}, "4PCP": {"minimum": 0.0, "maximum": 0.0}, "4PCPpp": {"minimum": 0.0, "maximum": 0.0}, "AAMYLpp": {"minimum": 0.0, "maximum": 0.0}, "4PEPTabcpp": {"minimum": 0.0, "maximum": 0.0}, "4PEPTtex": {"minimum": 0.0, "maximum": 0.0}, "5DGLCNR": {"minimum": 0.0, "maximum": 0.0}, "5DGLCNt2rpp": {"minimum": 0.0, "maximum": 0.0}, "ACALD": {"minimum": 3.35702, "maximum": 7.49572}, } infeasible_model = create_test_model() infeasible_model.reactions.get_by_id("EX_glyc_e").lower_bound = 0 for solver in solver_dict: # esolver is really slow if solver == "esolver": continue cobra_model = create_test_model() initialize_growth_medium(cobra_model, "LB") fva_out = flux_variability_analysis( cobra_model, solver=solver, reaction_list=cobra_model.reactions[100:140:2] ) for the_reaction, the_range in iteritems(fva_out): for k, v in iteritems(the_range): self.assertAlmostEqual(fva_results[the_reaction][k], v, places=5) # ensure that an infeasible model does not run FVA self.assertRaises(ValueError, flux_variability_analysis, infeasible_model, solver=solver)
def test_double_deletion(self): """ """ from os import name as __name if __name == "java": warn("cobra.test.flux_analysis.test_double_deletion doesn't yet work with java") return cobra_model = self.model # turn into a double deletion unit test the_problem = "return" initialize_growth_medium(cobra_model, "LB") # Expected growth rates for the salmonella model with deletions in LB medium the_loci = ["STM4081", "STM0247", "STM3867", "STM2952"] the_genes = tpiA, metN, atpA, eno = map(cobra_model.genes.get_by_id, the_loci) growth_dict = {} growth_list = [ [2.41, 2.389, 1.775, 1.81], [2.389, 2.437, 1.86, 1.79], [1.775, 1.86, 1.87, 1.3269], [1.81, 1.79, 1.3269, 1.81], ] for the_gene, the_rates in zip(the_genes, growth_list): growth_dict[the_gene] = dict(zip(the_genes, the_rates)) the_solution = double_deletion( cobra_model, element_list_1=the_genes, element_list_2=the_genes, the_problem=the_problem ) # Potential problem if the data object doesn't have a tolist function s_data = the_solution["data"].tolist() s_x = the_solution["x"] s_y = the_solution["y"] for gene_x, rates_x in zip(s_x, s_data): for gene_y, the_rate in zip(s_y, rates_x): self.assertAlmostEqual(growth_dict[gene_x][gene_y], the_rate, places=2)
def test_double_deletion(self): cobra_model = self.model #turn into a double deletion unit test initialize_growth_medium(cobra_model, 'LB') #Expected growth rates for the salmonella model with deletions in LB medium the_loci = ['STM4081', 'STM0247', 'STM3867', 'STM2952'] the_genes = tpiA, metN, atpA, eno = list(map(cobra_model.genes.get_by_id, the_loci)) growth_dict = {} growth_list = [[2.41, 2.389, 1.775, 1.81], [2.389, 2.437, 1.86, 1.79], [1.775, 1.86, 1.87, 1.3269], [1.81, 1.79, 1.3269, 1.81]] for the_gene, the_rates in zip(the_genes, growth_list): growth_dict[the_gene] = dict(zip(the_genes, the_rates)) the_solution = double_deletion(cobra_model, element_list_1=the_genes, element_list_2=the_genes) #Potential problem if the data object doesn't have a tolist function s_data = the_solution['data'].tolist() s_x = the_solution['x'] s_y = the_solution['y'] for gene_x, rates_x in zip(s_x, s_data): for gene_y, the_rate in zip(s_y, rates_x): self.assertAlmostEqual(growth_dict[gene_x][gene_y], the_rate, places=2)
def test_double_deletion(self): cobra_model = self.model #turn into a double deletion unit test initialize_growth_medium(cobra_model, 'LB') #Expected growth rates for the salmonella model with deletions in LB medium the_loci = ['STM4081', 'STM0247', 'STM3867', 'STM2952'] the_genes = tpiA, metN, atpA, eno = list( map(cobra_model.genes.get_by_id, the_loci)) growth_dict = {} growth_list = [[2.41, 2.389, 1.775, 1.81], [2.389, 2.437, 1.86, 1.79], [1.775, 1.86, 1.87, 1.3269], [1.81, 1.79, 1.3269, 1.81]] for the_gene, the_rates in zip(the_genes, growth_list): growth_dict[the_gene] = dict(zip(the_genes, the_rates)) the_solution = double_deletion(cobra_model, element_list_1=the_genes, element_list_2=the_genes) #Potential problem if the data object doesn't have a tolist function s_data = the_solution['data'].tolist() s_x = the_solution['x'] s_y = the_solution['y'] for gene_x, rates_x in zip(s_x, s_data): for gene_y, the_rate in zip(s_y, rates_x): self.assertAlmostEqual(growth_dict[gene_x][gene_y], the_rate, places=2)
def test_single_deletion(self): cobra_model = self.model initialize_growth_medium(cobra_model, 'LB') #Expected growth rates for the salmonella model with deletions in LB medium the_loci = ['STM4081', 'STM0247', 'STM3867', 'STM2952'] the_genes = tpiA, metN, atpA, eno = map(cobra_model.genes.get_by_id, the_loci) id_to_name = dict([(x.id, x.name) for x in the_genes]) growth_dict = {'fba':{tpiA.id:2.41, metN.id:2.44, atpA.id:1.87, eno.id:1.81}, 'moma':{ tpiA.id:1.62, metN.id:2.4, atpA.id:1.40, eno.id:0.33}} #MOMA requires cplex or gurobi if get_solver_name(qp=True) is None: growth_dict.pop('moma') for method, the_growth_rates in growth_dict.items(): element_list = the_growth_rates.keys() results = single_deletion(cobra_model, element_list=element_list, method=method) rates = results[0] statuses = results[1] for the_gene in element_list: self.assertEqual(statuses[the_gene], 'optimal') self.assertAlmostEqual(rates[the_gene], the_growth_rates[the_gene], places=2)
def test_flux_variability(self): """ """ fva_results = { "5DGLCNtex": {"minimum": -1.9748300208638403e-05, "maximum": 0.0}, "ABTA": {"minimum": 0.0, "maximum": 0.00014811225541408996}, "5DOAN": {"minimum": 0.0, "maximum": 3.2227507421302166e-06}, "A5PISO": {"minimum": 0.006920856282000001, "maximum": 0.006922717378372606}, "AACPS1": {"minimum": 0.0, "maximum": 3.7028063376249126e-05}, "AACPS2": {"minimum": 0.0, "maximum": 3.7028063733878864e-05}, "ACALDtex": {"minimum": -0.00011848980305159615, "maximum": 0.0}, "AACPS3": {"minimum": 0.0, "maximum": 3.702806337623859e-05}, "AACPS4": {"minimum": 0.0, "maximum": 3.702806373387888e-05}, "ABUTD": {"minimum": 0.0, "maximum": 0.00014811225541406058}, "AACPS5": {"minimum": 0.0, "maximum": 2.8211857518389774e-05}, "AACPS6": {"minimum": 0.0, "maximum": 2.821185753295664e-05}, "AACPS7": {"minimum": 0.0, "maximum": 3.702806368868028e-05}, "AACPS8": {"minimum": 0.0, "maximum": 3.702806338788376e-05}, "AACPS9": {"minimum": 0.0, "maximum": 3.702806309933293e-05}, "AACTOOR": {"minimum": 0.0, "maximum": 1.5388286124597477e-05}, "ABUTt2pp": {"minimum": 0.0, "maximum": 0.0}, "3OAS140": {"minimum": 0.5041754136687804, "maximum": 0.5042009621703677}, "3OAS141": {"minimum": 0.037484893950000084, "maximum": 0.03750284695065363}, "3OAS160": {"minimum": 0.41767086529953557, "maximum": 0.41769641380045963}, "3OAS161": {"minimum": 0.03748489395, "maximum": 0.03750284695060761}, "3OAS180": {"minimum": 0.01069201669939239, "maximum": 0.010717565200387778}, "3OAS181": {"minimum": 0.01606495455, "maximum": 0.01608290755044158}, "ABUTtex": {"minimum": 0.0, "maximum": 0.0}, "3OAS60": {"minimum": 0.5439852127139995, "maximum": 0.5439896193596934}, "3OAS80": {"minimum": 0.5439852127140001, "maximum": 0.5439896193596934}, "AAMYL": {"minimum": 0.0, "maximum": 0.0}, "3PEPTabcpp": {"minimum": 0.0, "maximum": 5.808323730923103e-06}, "3PEPTtex": {"minimum": -3.4245609402880297e-06, "maximum": 0.0}, "3UMPtex": {"minimum": 0.0, "maximum": 0.0}, "4HOXPACDtex": {"minimum": 0.0, "maximum": 0.0}, "ACACtex": {"minimum": 0.0, "maximum": 0.0}, "4PCP": {"minimum": 0.0, "maximum": 6.171343917391756e-06}, "4PCPpp": {"minimum": 0.0, "maximum": 5.58914186256664e-06}, "AAMYLpp": {"minimum": 0.0, "maximum": 0.0}, "4PEPTabcpp": {"minimum": 0.0, "maximum": 5.696625084349692e-06}, "4PEPTtex": {"minimum": -3.2198316806921494e-06, "maximum": 0.0}, "5DGLCNR": {"minimum": -2.1942555793285538e-05, "maximum": 0.0}, "5DGLCNt2rpp": {"minimum": -1.9748300208638403e-05, "maximum": 0.0}, "ACALD": {"minimum": 3.356574143593833, "maximum": 7.4971939913624155}, } cobra_model = self.model the_problem = "return" initialize_growth_medium(cobra_model, "LB") the_problem = cobra_model.optimize(the_problem=the_problem) fva_out = flux_variability_analysis( cobra_model, the_problem=the_problem, the_reactions=cobra_model.reactions[100:140] ) for the_reaction, the_range in fva_out.iteritems(): for k, v in the_range.iteritems(): self.assertAlmostEqual(fva_results[the_reaction][k], v, places=3)
def test_flux_variability(self): fva_results = { '5DGLCNtex': {'minimum': 0.0, 'maximum': 0.0}, 'ABTA': {'minimum': 0.0, 'maximum': 0.0}, '5DOAN': {'minimum': 0.0, 'maximum': 0.0}, 'A5PISO': {'minimum': 0.00692, 'maximum': 0.00692}, 'AACPS1': {'minimum': 0.0, 'maximum': 0.0}, 'AACPS2': {'minimum': 0.0, 'maximum': 0.0}, 'ACALDtex': {'minimum': 0.0, 'maximum': 0.0}, 'AACPS3': {'minimum': 0.0, 'maximum': 0.0}, 'AACPS4': {'minimum': 0.0, 'maximum': 0.0}, 'ABUTD': {'minimum': 0.0, 'maximum': 0.0}, 'AACPS5': {'minimum': 0.0, 'maximum': 0.0}, 'AACPS6': {'minimum': 0.0, 'maximum': 0.0}, 'AACPS7': {'minimum': 0.0, 'maximum': 0.0}, 'AACPS8': {'minimum': 0.0, 'maximum': 0.0}, 'AACPS9': {'minimum': 0.0, 'maximum': 0.0}, 'AACTOOR': {'minimum': 0.0, 'maximum': 0.0}, 'ABUTt2pp': {'minimum': 0.0, 'maximum': 0.0}, '3OAS140': {'minimum': 0.50419, 'maximum': 0.50419}, '3OAS141': {'minimum': 0.03748, 'maximum': 0.03748}, '3OAS160': {'minimum': 0.41769, 'maximum': 0.41769}, '3OAS161': {'minimum': 0.03748, 'maximum': 0.03748}, '3OAS180': {'minimum': 0.01071, 'maximum': 0.01071}, '3OAS181': {'minimum': 0.01606, 'maximum': 0.01606}, 'ABUTtex': {'minimum': 0.0, 'maximum': 0.0}, '3OAS60': {'minimum': 0.54399, 'maximum': 0.54399}, '3OAS80': {'minimum': 0.54399, 'maximum': 0.54399}, 'AAMYL': {'minimum': 0.0, 'maximum': 0.0}, '3PEPTabcpp': {'minimum': 0.0, 'maximum': 0.0}, '3PEPTtex': {'minimum': 0.0, 'maximum': 0.0}, '3UMPtex': {'minimum': 0.0, 'maximum': 0.0}, '4HOXPACDtex': {'minimum': 0.0, 'maximum': 0.0}, 'ACACtex': {'minimum': 0.0, 'maximum': 0.0}, '4PCP': {'minimum': 0.0, 'maximum': 0.0}, '4PCPpp': {'minimum': 0.0, 'maximum': 0.0}, 'AAMYLpp': {'minimum': 0.0, 'maximum': 0.0}, '4PEPTabcpp': {'minimum': 0.0, 'maximum': 0.0}, '4PEPTtex': {'minimum': 0.0, 'maximum': 0.0}, '5DGLCNR': {'minimum': 0.0, 'maximum': 0.0}, '5DGLCNt2rpp': {'minimum': 0.0, 'maximum': 0.0}, 'ACALD': {'minimum': 3.35702, 'maximum': 7.49572}} infeasible_model = create_test_model() infeasible_model.reactions.get_by_id("EX_glyc_e").lower_bound = 0 for solver in solver_dict: cobra_model = create_test_model() initialize_growth_medium(cobra_model, 'LB') fva_out = flux_variability_analysis( cobra_model, solver=solver, reaction_list=cobra_model.reactions[100:140:2]) for the_reaction, the_range in iteritems(fva_out): for k, v in iteritems(the_range): self.assertAlmostEqual(fva_results[the_reaction][k], v, places=5) # ensure that an infeasible model does not run FVA self.assertRaises(ValueError, flux_variability_analysis, infeasible_model, solver=solver)
def test_flux_variability(self): fva_results = { '5DGLCNtex': {'minimum': -1.9748300208638403e-05, 'maximum': 0.0}, 'ABTA': {'minimum': 0.0, 'maximum': 0.00014811225541408996}, '5DOAN': {'minimum': 0.0, 'maximum': 3.2227507421302166e-06}, 'A5PISO': {'minimum': 0.006920856282000001, 'maximum': 0.006922717378372606}, 'AACPS1': {'minimum': 0.0, 'maximum': 3.7028063376249126e-05}, 'AACPS2': {'minimum': 0.0, 'maximum': 3.7028063733878864e-05}, 'ACALDtex': {'minimum': -0.00011848980305159615, 'maximum': 0.0}, 'AACPS3': {'minimum': 0.0, 'maximum': 3.702806337623859e-05}, 'AACPS4': {'minimum': 0.0, 'maximum': 3.702806373387888e-05}, 'ABUTD': {'minimum': 0.0, 'maximum': 0.00014811225541406058}, 'AACPS5': {'minimum': 0.0, 'maximum': 2.8211857518389774e-05}, 'AACPS6': {'minimum': 0.0, 'maximum': 2.821185753295664e-05}, 'AACPS7': {'minimum': 0.0, 'maximum': 3.702806368868028e-05}, 'AACPS8': {'minimum': 0.0, 'maximum': 3.702806338788376e-05}, 'AACPS9': {'minimum': 0.0, 'maximum': 3.702806309933293e-05}, 'AACTOOR': {'minimum': 0.0, 'maximum': 1.5388286124597477e-05}, 'ABUTt2pp': {'minimum': 0.0, 'maximum': 0.0}, '3OAS140': {'minimum': 0.5041754136687804, 'maximum': 0.5042009621703677}, '3OAS141': {'minimum': 0.037484893950000084, 'maximum': 0.03750284695065363}, '3OAS160': {'minimum': 0.41767086529953557, 'maximum': 0.41769641380045963}, '3OAS161': {'minimum': 0.03748489395, 'maximum': 0.03750284695060761}, '3OAS180': {'minimum': 0.01069201669939239, 'maximum': 0.010717565200387778}, '3OAS181': {'minimum': 0.01606495455, 'maximum': 0.01608290755044158}, 'ABUTtex': {'minimum': 0.0, 'maximum': 0.0}, '3OAS60': {'minimum': 0.5439852127139995, 'maximum': 0.5439896193596934}, '3OAS80': {'minimum': 0.5439852127140001, 'maximum': 0.5439896193596934}, 'AAMYL': {'minimum': 0.0, 'maximum': 0.0}, '3PEPTabcpp': {'minimum': 0.0, 'maximum': 5.808323730923103e-06}, '3PEPTtex': {'minimum': -3.4245609402880297e-06, 'maximum': 0.0}, '3UMPtex': {'minimum': 0.0, 'maximum': 0.0}, '4HOXPACDtex': {'minimum': 0.0, 'maximum': 0.0}, 'ACACtex': {'minimum': 0.0, 'maximum': 0.0}, '4PCP': {'minimum': 0.0, 'maximum': 6.171343917391756e-06}, '4PCPpp': {'minimum': 0.0, 'maximum': 5.58914186256664e-06}, 'AAMYLpp': {'minimum': 0.0, 'maximum': 0.0}, '4PEPTabcpp': {'minimum': 0.0, 'maximum': 5.696625084349692e-06}, '4PEPTtex': {'minimum': -3.2198316806921494e-06, 'maximum': 0.0}, '5DGLCNR': {'minimum': -2.1942555793285538e-05, 'maximum': 0.0}, '5DGLCNt2rpp': {'minimum': -1.9748300208638403e-05, 'maximum': 0.0}, 'ACALD': {'minimum': 3.356574143593833, 'maximum': 7.4957163478682105}} for solver in solver_dict: cobra_model = create_test_model() initialize_growth_medium(cobra_model, 'LB') fva_out = flux_variability_analysis(cobra_model, solver=solver, reaction_list=cobra_model.reactions[100:140]) for the_reaction, the_range in fva_out.iteritems(): for k, v in the_range.iteritems(): self.assertAlmostEqual(fva_results[the_reaction][k], v, places=3)
def setUp(self): self.solver = solvers.solver_dict[self.solver_name] self.model = create_test_model() initialize_growth_medium(self.model, 'MgM') self.old_solution = 0.320064 self.infeasible_model = Model() metabolite_1 = Metabolite("met1") reaction_1 = Reaction("rxn1") reaction_2 = Reaction("rxn2") reaction_1.add_metabolites({metabolite_1: 1}) reaction_2.add_metabolites({metabolite_1: 1}) reaction_1.lower_bound = 1 reaction_2.upper_bound = 2 self.infeasible_model.add_reactions([reaction_1, reaction_2])
def setUp(self): self.model = create_test_model() initialize_growth_medium(self.model, "MgM") self.old_solution = 0.320064 self.infeasible_model = Model() metabolite_1 = Metabolite("met1") # metabolite_2 = Metabolite("met2") reaction_1 = Reaction("rxn1") reaction_2 = Reaction("rxn2") reaction_1.add_metabolites({metabolite_1: 1}) reaction_2.add_metabolites({metabolite_1: 1}) reaction_1.lower_bound = 1 reaction_2.upper_bound = 2 self.infeasible_model.add_reactions([reaction_1, reaction_2])
def test_solvers(): from cPickle import load from time import time from numpy import round from cobra.manipulation import initialize_growth_medium from cobra.test import salmonella_pickle with open(salmonella_pickle) as in_file: cobra_model = load(in_file) initialize_growth_medium(cobra_model, 'M9') from cobra.manipulation import initialize_growth_medium the_growth_rate = 0.48 solver_dict = { 'glpk': _optimize_glpk, 'gurobi': _optimize_gurobi, 'cplex': _optimize_cplex } try: import glpk except: solver_dict.pop('glpk') try: from gurobipy import Model except: solver_dict.pop('gurobi') try: from cplex import Cplex except: solver_dict.pop('cplex') for the_solver, the_function in solver_dict.items(): print 'testing ' + the_solver start_time = time() the_result = the_function(cobra_model, the_problem='return', print_solver_time=True) the_problem = the_result['the_problem'] the_solution = the_result['the_solution'] print '%s cold start: %f' % (the_solver, time() - start_time) if round(the_solution.f, 2) != the_growth_rate: print 'Simulation failed %f to match expectation %f' % ( the_solution.f, the_growth_rate) the_solution = the_function(cobra_model, the_problem=the_problem, print_solver_time=True) the_problem = the_result['the_problem'] the_solution = the_result['the_solution'] print '%s hot start: %f' % (the_solver, time() - start_time) if round(the_solution.f, 2) != the_growth_rate: print 'Simulation failed %f to match expectation %f' % ( the_solution.f, the_growth_rate)
def test_single_deletion(self): cobra_model = self.model initialize_growth_medium(cobra_model, "LB") # Expected growth rates for the salmonella model with deletions in LB medium the_loci = ["STM4081", "STM0247", "STM3867", "STM2952"] the_genes = tpiA, metN, atpA, eno = map(cobra_model.genes.get_by_id, the_loci) id_to_name = dict([(x.id, x.name) for x in the_genes]) growth_dict = {"fba": {tpiA.id: 2.41, metN.id: 2.44, atpA.id: 1.87, eno.id: 1.81}} for method, the_growth_rates in growth_dict.items(): element_list = the_growth_rates.keys() rates, statuses, problems = single_deletion(cobra_model, element_list=element_list, method=method) for the_gene in element_list: self.assertEqual(statuses[the_gene], "optimal") self.assertAlmostEqual(rates[the_gene], the_growth_rates[the_gene], places=2)
def test_solvers(): from cPickle import load from time import time from numpy import round from cobra.manipulation import initialize_growth_medium from cobra.test import salmonella_pickle with open(salmonella_pickle) as in_file: cobra_model = load(in_file) initialize_growth_medium(cobra_model, 'M9') from cobra.manipulation import initialize_growth_medium the_growth_rate = 0.48 solver_dict = {'glpk': _optimize_glpk, 'gurobi': _optimize_gurobi, 'cplex': _optimize_cplex} try: import glpk except: solver_dict.pop('glpk') try: from gurobipy import Model except: solver_dict.pop('gurobi') try: from cplex import Cplex except: solver_dict.pop('cplex') for the_solver, the_function in solver_dict.items(): print 'testing ' + the_solver start_time = time() the_result = the_function(cobra_model, the_problem='return', print_solver_time=True) the_problem = the_result['the_problem'] the_solution = the_result['the_solution'] print '%s cold start: %f'%(the_solver, time() - start_time) if round(the_solution.f, 2) != the_growth_rate: print 'Simulation failed %f to match expectation %f'%(the_solution.f, the_growth_rate) the_solution = the_function(cobra_model, the_problem=the_problem, print_solver_time=True) the_problem = the_result['the_problem'] the_solution = the_result['the_solution'] print '%s hot start: %f'%(the_solver, time() - start_time) if round(the_solution.f, 2) != the_growth_rate: print 'Simulation failed %f to match expectation %f'%(the_solution.f, the_growth_rate)
def test_double_gene_deletion(self): cobra_model = self.model # turn into a double deletion unit test initialize_growth_medium(cobra_model, 'LB') # Expected growth rates for the salmonella model with deletions in LB genes = ['STM4081', 'STM0247', 'STM3867', 'STM2952'] growth_list = [[2.414, 2.390, 1.775, 1.810], [2.390, 2.437, 1.863, 1.795], [1.775, 1.863, 1.875, 1.327], [1.810, 1.795, 1.327, 1.813]] solution = double_gene_deletion(cobra_model, gene_list1=genes) self.assertEqual(solution["x"], genes) self.assertEqual(solution["y"], genes) self.compare_matrices(growth_list, solution["data"]) # test when lists differ slightly solution = double_gene_deletion(cobra_model, gene_list1=genes[:-1], gene_list2=genes) self.assertEqual(solution["x"], genes[:-1]) self.assertEqual(solution["y"], genes) self.compare_matrices(growth_list[:-1], solution["data"])
def test_single_deletion(self): cobra_model = self.model initialize_growth_medium(cobra_model, 'LB') #Expected growth rates for the salmonella model with deletions in LB medium the_loci = ['STM4081', 'STM0247', 'STM3867', 'STM2952'] the_genes = tpiA, metN, atpA, eno = map(cobra_model.genes.get_by_id, the_loci) id_to_name = dict([(x.id, x.name) for x in the_genes]) growth_dict = { 'fba': { tpiA.id: 2.41, metN.id: 2.44, atpA.id: 1.87, eno.id: 1.81 }, 'moma': { tpiA.id: 1.62, metN.id: 2.4, atpA.id: 1.40, eno.id: 0.33 } } #MOMA requires cplex or gurobi if get_solver_name(qp=True) is None: growth_dict.pop('moma') for method, the_growth_rates in growth_dict.items(): element_list = the_growth_rates.keys() results = single_deletion(cobra_model, element_list=element_list, method=method) rates = results[0] statuses = results[1] for the_gene in element_list: self.assertEqual(statuses[the_gene], 'optimal') self.assertAlmostEqual(rates[the_gene], the_growth_rates[the_gene], places=2)
def create_test_model(test_pickle=salmonella_pickle): """Returns a cobra model for testing. The default model is the version of the Salmonella enterica Typhimurium LT2 model published in Thiele et al. 2011 BMC Sys Bio 5:8, which has some updated metabolite KEGG id data for Schmidt et al. 2013 Bioinformatics test_pickle: The complete file name of a pickled cobra.Model or SBML XML file to be read. We currently provide Salmonella enterica Typhimurium and Escherichia coli core models whose paths are stored in cobra.test.salmonella_pickle and cobra.test.ecoli_pickle, respectively. """ from os import name as __name try: from cPickle import load except: from pickle import load with open(test_pickle, "rb") as infile: model = load(infile) initialize_growth_medium(model, 'LB') return model
matlab_struct.description = cobra_model.description return(matlab_struct) if __name__ == '__main__': from cPickle import load from time import time from numpy import round from cobra.manipulation import initialize_growth_medium try: matlab.changeCobraSolver('glpk','LP') except AttributeError: raise Exception('Could not run matlab function changeCobraSolver. Is the ' +\ 'COBRA Toolbox in your MATLAB path?') test_directory = '../test/data/' with open(test_directory + 'salmonella.pickle') as in_file: cobra_model = load(in_file) initialize_growth_medium(cobra_model, 'LPM') py_cobra_solution = repr(cobra_model.solution.f) matlab_struct = cobra_model_object_to_cobra_matlab_struct(cobra_model) matlab_result = matlab.optimizeCbModel(matlab_struct) matlab_solution = repr(float(matlab_result.f)) if py_cobra_solution[:4] == matlab_solution[:4]: print 'SUCCESS: growth rate match between pyCOBRA and COBRA Toolbox: %s ~ %s'%(py_cobra_solution, matlab_solution) else: print 'FAILURE: pyCOBRA and COBRA Toolbox do not match: %s !~ %s'%(py_cobra_solution, matlab_solution)
def test_flux_variability(self): fva_results = { '5DGLCNtex': { 'minimum': -1.9748300208638403e-05, 'maximum': 0.0 }, 'ABTA': { 'minimum': 0.0, 'maximum': 0.00014811225541408996 }, '5DOAN': { 'minimum': 0.0, 'maximum': 3.2227507421302166e-06 }, 'A5PISO': { 'minimum': 0.006920856282000001, 'maximum': 0.006922717378372606 }, 'AACPS1': { 'minimum': 0.0, 'maximum': 3.7028063376249126e-05 }, 'AACPS2': { 'minimum': 0.0, 'maximum': 3.7028063733878864e-05 }, 'ACALDtex': { 'minimum': -0.00011848980305159615, 'maximum': 0.0 }, 'AACPS3': { 'minimum': 0.0, 'maximum': 3.702806337623859e-05 }, 'AACPS4': { 'minimum': 0.0, 'maximum': 3.702806373387888e-05 }, 'ABUTD': { 'minimum': 0.0, 'maximum': 0.00014811225541406058 }, 'AACPS5': { 'minimum': 0.0, 'maximum': 2.8211857518389774e-05 }, 'AACPS6': { 'minimum': 0.0, 'maximum': 2.821185753295664e-05 }, 'AACPS7': { 'minimum': 0.0, 'maximum': 3.702806368868028e-05 }, 'AACPS8': { 'minimum': 0.0, 'maximum': 3.702806338788376e-05 }, 'AACPS9': { 'minimum': 0.0, 'maximum': 3.702806309933293e-05 }, 'AACTOOR': { 'minimum': 0.0, 'maximum': 1.5388286124597477e-05 }, 'ABUTt2pp': { 'minimum': 0.0, 'maximum': 0.0 }, '3OAS140': { 'minimum': 0.5041754136687804, 'maximum': 0.5042009621703677 }, '3OAS141': { 'minimum': 0.037484893950000084, 'maximum': 0.03750284695065363 }, '3OAS160': { 'minimum': 0.41767086529953557, 'maximum': 0.41769641380045963 }, '3OAS161': { 'minimum': 0.03748489395, 'maximum': 0.03750284695060761 }, '3OAS180': { 'minimum': 0.01069201669939239, 'maximum': 0.010717565200387778 }, '3OAS181': { 'minimum': 0.01606495455, 'maximum': 0.01608290755044158 }, 'ABUTtex': { 'minimum': 0.0, 'maximum': 0.0 }, '3OAS60': { 'minimum': 0.5439852127139995, 'maximum': 0.5439896193596934 }, '3OAS80': { 'minimum': 0.5439852127140001, 'maximum': 0.5439896193596934 }, 'AAMYL': { 'minimum': 0.0, 'maximum': 0.0 }, '3PEPTabcpp': { 'minimum': 0.0, 'maximum': 5.808323730923103e-06 }, '3PEPTtex': { 'minimum': -3.4245609402880297e-06, 'maximum': 0.0 }, '3UMPtex': { 'minimum': 0.0, 'maximum': 0.0 }, '4HOXPACDtex': { 'minimum': 0.0, 'maximum': 0.0 }, 'ACACtex': { 'minimum': 0.0, 'maximum': 0.0 }, '4PCP': { 'minimum': 0.0, 'maximum': 6.171343917391756e-06 }, '4PCPpp': { 'minimum': 0.0, 'maximum': 5.58914186256664e-06 }, 'AAMYLpp': { 'minimum': 0.0, 'maximum': 0.0 }, '4PEPTabcpp': { 'minimum': 0.0, 'maximum': 5.696625084349692e-06 }, '4PEPTtex': { 'minimum': -3.2198316806921494e-06, 'maximum': 0.0 }, '5DGLCNR': { 'minimum': -2.1942555793285538e-05, 'maximum': 0.0 }, '5DGLCNt2rpp': { 'minimum': -1.9748300208638403e-05, 'maximum': 0.0 }, 'ACALD': { 'minimum': 3.356574143593833, 'maximum': 7.4957163478682105 } } for solver in solver_dict: cobra_model = create_test_model() initialize_growth_medium(cobra_model, 'LB') fva_out = flux_variability_analysis( cobra_model, solver=solver, reaction_list=cobra_model.reactions[100:140]) for the_reaction, the_range in fva_out.iteritems(): for k, v in the_range.iteritems(): self.assertAlmostEqual(fva_results[the_reaction][k], v, places=3)
def test_flux_variability(self): fva_results = { '5DGLCNtex': { 'minimum': 0.0, 'maximum': 0.0 }, 'ABTA': { 'minimum': 0.0, 'maximum': 0.0 }, '5DOAN': { 'minimum': 0.0, 'maximum': 0.0 }, 'A5PISO': { 'minimum': 0.00692, 'maximum': 0.00692 }, 'AACPS1': { 'minimum': 0.0, 'maximum': 0.0 }, 'AACPS2': { 'minimum': 0.0, 'maximum': 0.0 }, 'ACALDtex': { 'minimum': 0.0, 'maximum': 0.0 }, 'AACPS3': { 'minimum': 0.0, 'maximum': 0.0 }, 'AACPS4': { 'minimum': 0.0, 'maximum': 0.0 }, 'ABUTD': { 'minimum': 0.0, 'maximum': 0.0 }, 'AACPS5': { 'minimum': 0.0, 'maximum': 0.0 }, 'AACPS6': { 'minimum': 0.0, 'maximum': 0.0 }, 'AACPS7': { 'minimum': 0.0, 'maximum': 0.0 }, 'AACPS8': { 'minimum': 0.0, 'maximum': 0.0 }, 'AACPS9': { 'minimum': 0.0, 'maximum': 0.0 }, 'AACTOOR': { 'minimum': 0.0, 'maximum': 0.0 }, 'ABUTt2pp': { 'minimum': 0.0, 'maximum': 0.0 }, '3OAS140': { 'minimum': 0.50419, 'maximum': 0.50419 }, '3OAS141': { 'minimum': 0.03748, 'maximum': 0.03748 }, '3OAS160': { 'minimum': 0.41769, 'maximum': 0.41769 }, '3OAS161': { 'minimum': 0.03748, 'maximum': 0.03748 }, '3OAS180': { 'minimum': 0.01071, 'maximum': 0.01071 }, '3OAS181': { 'minimum': 0.01606, 'maximum': 0.01606 }, 'ABUTtex': { 'minimum': 0.0, 'maximum': 0.0 }, '3OAS60': { 'minimum': 0.54399, 'maximum': 0.54399 }, '3OAS80': { 'minimum': 0.54399, 'maximum': 0.54399 }, 'AAMYL': { 'minimum': 0.0, 'maximum': 0.0 }, '3PEPTabcpp': { 'minimum': 0.0, 'maximum': 0.0 }, '3PEPTtex': { 'minimum': 0.0, 'maximum': 0.0 }, '3UMPtex': { 'minimum': 0.0, 'maximum': 0.0 }, '4HOXPACDtex': { 'minimum': 0.0, 'maximum': 0.0 }, 'ACACtex': { 'minimum': 0.0, 'maximum': 0.0 }, '4PCP': { 'minimum': 0.0, 'maximum': 0.0 }, '4PCPpp': { 'minimum': 0.0, 'maximum': 0.0 }, 'AAMYLpp': { 'minimum': 0.0, 'maximum': 0.0 }, '4PEPTabcpp': { 'minimum': 0.0, 'maximum': 0.0 }, '4PEPTtex': { 'minimum': 0.0, 'maximum': 0.0 }, '5DGLCNR': { 'minimum': 0.0, 'maximum': 0.0 }, '5DGLCNt2rpp': { 'minimum': 0.0, 'maximum': 0.0 }, 'ACALD': { 'minimum': 3.35702, 'maximum': 7.49572 } } infeasible_model = create_test_model() infeasible_model.reactions.get_by_id("EX_glyc_e").lower_bound = 0 for solver in solver_dict: cobra_model = create_test_model() initialize_growth_medium(cobra_model, 'LB') fva_out = flux_variability_analysis( cobra_model, solver=solver, reaction_list=cobra_model.reactions[100:140]) for the_reaction, the_range in iteritems(fva_out): for k, v in iteritems(the_range): self.assertAlmostEqual(fva_results[the_reaction][k], v, places=5) # ensure that an infeasible model does not run FVA self.assertRaises(ValueError, flux_variability_analysis, infeasible_model, solver=solver)
def assess_medium_component_essentiality(cobra_model, the_components=None, the_medium=None, medium_compartment='e', solver='glpk', the_condition=None, method='fba'): """Determines which components in an in silico medium are essential for growth in the context of the remaining components. cobra_model: A Model object. the_components: None or a list of external boundary reactions that will be sequentially disabled. the_medium: Is None, a string, or a dictionary. If a string then the initialize_growth_medium function expects that the_model has an attribute dictionary called media_compositions, which is a dictionary of dictionaries for various medium compositions. Where a medium composition is a dictionary of external boundary reaction ids for the medium components and the external boundary fluxes for each medium component. medium_compartment: the compartment in which the boundary reactions supplying the medium components exist NOTE: that these fluxes must be negative because the convention is backwards means something is feed into the system. solver: 'glpk', 'gurobi', or 'cplex' returns: essentiality_dict: A dictionary providing the maximum growth rate accessible when the respective component is removed from the medium. """ if method.lower() == 'moma': wt_model = cobra_model.copy() cobra_model = cobra_model.copy() if isinstance(the_medium, str): try: the_medium = cobra_model.media_compositions[the_medium] except: raise Exception( the_medium + " is not in cobra_model.media_compositions") if the_medium is not None: initialize_growth_medium(cobra_model, the_medium, medium_compartment) if the_components is None: the_components = the_medium.keys() if not the_components: raise Exception("You need to specify the_components or the_medium") essentiality_dict = {} for the_component in the_components: the_reaction = cobra_model.reactions.get_by_id(the_component) original_lower_bound = float(the_reaction.lower_bound) the_reaction.lower_bound = 0. if method.lower() == 'fba': cobra_model.optimize(solver=solver) objective_value = cobra_model.solution.f elif method.lower() == 'moma': objective_value = moma(wt_model, cobra_model, solver=solver)[ 'objective_value'] essentiality_dict[the_component] = objective_value the_reaction.lower_bound = original_lower_bound return(essentiality_dict)
fp = open(data_dir + "metabolomics_dict.pickle", "rb") metabolomics_dict = pickle.load(fp) fp.close() # Make models not informed by omics first by initializing the media import pickle fp = open(data_dir + "salmonella_gem.pickle", "rb") STM = pickle.load(fp) fp.close() if cobra_version == '0.2.0': STM_LB = deepcopy(STM) else: STM_LB = STM.copy() initialize_growth_medium(STM_LB, 'LB') ## This is how to set up LPM # if cobra_version == '0.2.0': # STM_LPM = deepcopy(STM) # else: # STM_LPM = STM.copy() # initialize_growth_medium(STM_LPM, 'LPM') ## Protons should only have a net positive diffusion ## from the extracellular space into the perplasm in LPM condition # STM_LPM.reactions.get_by_id('Htex').lower_bound = 0 # Required numeric tolerances were # determined previously from FVA # on model reactions selected_tolerance = 1E-8
def assess_medium_component_essentiality( cobra_model, the_components=None, the_medium=None, solver="glpk", the_problem="return", the_condition=None, method="fba", ): """Deterimes which components in an in silico medium are essential for growth in the context of the remaining components. cobra_model: A Model object. the_components: None or a list of exchange reactions that will be sequentially disabled. the_medium: Is None, a string, or a dictionary. If a string then the initialize_growth_medium function expects that the_model has an attribute dictionary called media_compositions, which is a dictionary of dictionaries for various medium compositions. Where a medium composition is a dictionary of exchange reaction ids for the medium components and the exchange fluxes for each medium component; note that these fluxes must be negative because they are being exchanged into the system. solver: 'glpk', 'gurobi', or 'cplex' the_problem: Is None, 'return', or an LP model object for the solver. the_condition: None or a String that provides a description of the medium simulation returns: essentiality_dict: A dictionary providing the minimum lower bounds for each component of the growth medium. """ warn("assess_medium_component_essentiality needs to be updated to " + "deal with new style reactions") from cobra.core.ArrayBasedModel import ArrayBasedModel if method.lower() == "moma": wt_model = ArrayBasedModel(cobra_model.copy()) if isinstance(cobra_model, tuple): if len(cobra_model) == 3: the_condition = cobra_model[2] the_components = cobra_model[1] cobra_model = cobra_model[0] cobra_model = ArrayBasedModel(cobra_model.copy()) if not the_components: if the_medium: if hasattr(the_medium, "keys") or ( hasattr(cobra_model, "media_compositions") and the_medium in cobra_model.media_compositions ): initialize_growth_medium(cobra_model, the_medium) the_components = cobra_model.media_compositions[the_medium] else: raise Exception("%s is not a dict and not in the model's media list" % the_medium) else: raise Exception("You need to specify the_components or the_medium") essentiality_dict = {} for the_component in the_components: component_index = cobra_model.reactions.index(the_component) tmp_lb = float(cobra_model.lower_bounds[component_index]) cobra_model.reactions[component_index].lower_bound = cobra_model.lower_bounds[component_index] = 0 if method.lower() == "fba": cobra_model.optimize(solver=solver, the_problem=the_problem) objective_value = cobra_model.solution.f elif method.lower() == "moma": objective_value = moma(wt_model, cobra_model, solver=solver)["objective_value"] essentiality_dict[the_component] = objective_value cobra_model.reactions[component_index].lower_bound = cobra_model.lower_bounds[component_index] = tmp_lb if the_condition: essentiality_dict["the_condition"] = the_condition return essentiality_dict
def deletion_analysis( cobra_model, the_medium=None, deletion_type="single", work_directory=None, growth_cutoff=0.001, the_problem="return", n_processes=6, element_type="gene", solver="glpk", error_reporting=None, method="fba", element_list=None, ): """Performs single and/or double deletion analysis on all the genes in the model. Provides an interface to parallelize the deletion studies. cobra_model: A Model object. the_medium: Is None, a string, or a dictionary. If a string then the initialize_growth_medium function expects that cobra_model has an attribute dictionary called media_compositions, which is a dictionary of dictionaries for various medium compositions. Where a medium composition is a dictionary of exchange reaction ids for the medium components and the exchange fluxes for each medium component; note that these fluxes must be negative because they are being exchanged into the system. deletion_type: 'single', 'double', or 'double-only' work_directory: None or String indicating where to save the output from the simulations. growth_cutoff: Float. Indiates the minimum growth rate that is considered viable. the_problem: Is None, 'return', or an LP model object for the solver. element_type: 'gene' or 'reaction' solver: 'glpk', 'gurobi', or 'cplex' n_processes: number of parallel processes to break the double deletion simulations into. error_reporting: None or True element_list: None or a list of genes to delete from the model. Returns: Nothing. However, the script will add attributes single_deletion_* and double_deletion_* to cobra_model containing the simulation results. """ if element_type == "reaction": warn("deletion_analysis is not perfect for element_type = 'reaction'") # When using ppmap, it's easier to feed in the parameters as a list, # if the defaults need to be changed if isinstance(cobra_model, list): tmp_model = cobra_model cobra_model = tmp_model[0] if len(tmp_model) > 1: the_medium = tmp_model[1] if len(tmp_model) > 2: deletion_type = tmp_model[2] if len(tmp_model) > 3: work_directory = tmp_model[3] if len(tmp_model) > 4: growth_cutoff = tmp_model[4] if the_medium is not None: initialize_growth_medium(cobra_model, the_medium) the_problem = cobra_model.optimize(the_problem=the_problem, solver=solver) # Store the basal model for the simulations if element_list is None: element_list = getattr(cobra_model, element_type + "s") if deletion_type != "double_only": cobra_model.single_deletion_growth_wt = cobra_model.solution.f growth_rate_dict, growth_solution_status_dict, problem_dict = single_deletion( deepcopy(cobra_model), element_list=element_list, the_problem=the_problem, element_type=element_type, solver=solver, error_reporting=error_reporting, method=method, ) del problem_dict cobra_model.single_deletion_growth_dict = growth_rate_dict cobra_model.single_deletion_solution_status_dict = growth_solution_status_dict setattr(cobra_model, "single_deletion_%ss" % element_type, deepcopy(growth_rate_dict.keys())) cobra_model.single_deletion_lethal = [x for x in growth_rate_dict.keys() if growth_rate_dict[x] < growth_cutoff] cobra_model.single_deletion_growth_medium = the_medium cobra_model.single_deletion_nonlethal = list( set(growth_rate_dict.keys()).difference(cobra_model.single_deletion_lethal) ) if work_directory is not None: if not path.lexists(work_directory): mkdir(work_directory) with open(work_directory + the_medium + "_single_" + cobra_model.description, "w") as out_file: dump(cobra_model, out_file) if deletion_type == "double" or deletion_type == "double_only": # It appears that the glpk interface no longer works will with sending # a glpk.LPX object through ppmap, so just set the basis to return if the_problem: the_problem = "return" cobra_model.double_deletion_growth_medium = the_medium cobra_model.double_deletion_growth_wt = cobra_model.solution.f if not __parallel_mode_available: if n_processes > 0: print "Couldn't import ppmap from cobra.external is parallel python installed?" return else: cobra_model = double_deletion_parallel( deepcopy(cobra_model), genes_of_interest=element_list, the_problem=the_problem, n_processes=n_processes, element_type=element_type, solver=solver, error_reporting=error_reporting, method=method, ) # This indicates the genes that were run through double deletion but # the x and y lists specify the order setattr(cobra_model, "double_deletion_%ss" % element_type, deepcopy(cobra_model.genes)) if work_directory is not None: with open(work_directory + the_medium + "_double_" + cobra_model.description, "w") as out_file: dump(cobra_model, out_file) return cobra_model
# This example demonstrates a single gene deletion simulation from time import time from cobra.flux_analysis.single_deletion import single_deletion from cobra.manipulation import initialize_growth_medium from cobra.test import create_test_model, salmonella_pickle # test filename cobra_model = create_test_model(salmonella_pickle) initialize_growth_medium(cobra_model, 'LB') target_genes = ['STM4081', 'STM0247', 'STM3867', 'STM2952'] # Expected growth rates for the salmonella model after a deletions in LB medium expected_growth_rates = { "STM4081": 2.41, "STM0247": 2.43, "STM3867": 1.87, "STM2952": 1.81} start_time = time() # start timer # Perform deletions for all genes in the list rates, statuses = single_deletion(cobra_model, target_genes) total_time = time() - start_time # stop timer # print out results passed_string = 'PASSED: %s simulation (%1.3f) ~= expectation (%1.2f)' failed_string = 'FAILED: %s simulation (%1.3f) != expectation (%1.2f)' for gene_locus, rate in rates.items(): # get gene name from gene locus (i.e. STM4081 -> tpiA) name = cobra_model.genes.get_by_id(gene_locus).name
def double_gene_deletion_parallel( cobra_model, n_processes=4, genes_of_interest=None, method="fba", the_medium=None, the_problem="return", solver="glpk", error_reporting=None, ): """Provides a wrapper to run the double_deletion function on multicore systems. cobra_model: a Model object n_processes: is the number of parallel processes to start genes_of_interest: Is None, a list of genes, or a list of two lists of genes. If None then double_deletion is run on all genes in cobra_model.genes. If a list of genes then double_deletion is run for all combinations of genes in double_deletion. If a list of of two lists of genes then double_deletion is run for each member of one list vs. each member of the second list. method: 'fba' or 'moma' to run flux balance analysis or minimization of metabolic adjustments. the_medium: Is None, a string, or a dictionary. If a string then the initialize_growth_medium function expects that cobra_model has an attribute dictionary called media_compositions, which is a dictionary of dictionaries for various medium compositions. Where a medium composition is a dictionary of exchange reaction ids for the medium components and the exchange fluxes for each medium component; note that these fluxes must be negative because they are being exchanged into the system. the_problem: Is None or 'reuse' solver: 'glpk', 'gurobi', or 'cplex'. error_reporting: None or True Adds the following attributes to the cobra_model: double_deletion_growth_rate: A numpy array of the simulation results double_deletion_genes_x: A list of the genes for the x dimension of double_deletion_growth_rate. double_deletion_genes_y: A list of the genes for the y dimension of double_deletion_growth_rate. """ if not __parallel_mode_available: print "Parallel mode not available is Parallel Python installed" return if the_problem: the_problem = "return" if the_medium: initialize_growth_medium(cobra_model, the_medium) if not genes_of_interest: # If no genes_of_interest are specified then assume we want to # compare all genetic interactions in the network all_genes = [x.id for x in cobra_model.genes] second_gene_list = all_genes elif isinstance(genes_of_interest[0], str): # If genes_of_interest is a list then assume the list be scanned # for interactions with all genes in the network all_genes = genes_of_interest second_gene_list = all_genes elif hasattr(genes_of_interest[0], "id"): # Make sure we're dealing with strings instead of objects because we # haven't audited this for thread safety second_gene_list = all_genes = [x.id for x in genes_of_interest] elif hasattr(genes_of_interest[0], "__iter__"): all_genes = genes_of_interest[0] if len(genes_of_interest) == 2: second_gene_list = genes_of_interest[1] else: second_gene_list = all_genes # Get basic numbers to guide how the problem should be divided for parallel execution. total_gene_count = len(all_genes) division_count = total_gene_count / n_processes the_rows = [] for i in range(n_processes - 1): the_rows.append( { "cobra_model": cobra_model.copy(), "method": method, "gene_list_1": deepcopy(all_genes[i * division_count : division_count * (i + 1)]), "gene_list_2": deepcopy(second_gene_list), "the_problem": the_problem, "solver": solver, "error_reporting": error_reporting, } ) the_rows.append( { "cobra_model": cobra_model.copy(), "method": method, "gene_list_1": deepcopy(all_genes[(n_processes - 1) * division_count :]), "gene_list_2": deepcopy(second_gene_list), "the_problem": the_problem, "solver": solver, "error_reporting": error_reporting, } ) tmp_pp = list(ppmap(n_processes, double_gene_deletion, the_rows)) gene_list_x = tmp_pp[0]["x"] gene_list_y = tmp_pp[0]["y"] double_deletion_data = tmp_pp[0]["data"] for the_result in tmp_pp[1:]: gene_list_x += the_result["x"] double_deletion_data = vstack((double_deletion_data, the_result["data"])) cobra_model.double_deletion_growth_rate = double_deletion_data cobra_model.double_deletion_genes_x = gene_list_x cobra_model.double_deletion_genes_y = gene_list_y return cobra_model