def balance_multiple_reactions(graph, factors, rxns, mass_vector, lower, upper, logger):
options = OptionsManager()
sub = BipartiteMetabolicNetwork()
for rxn in rxns:
msg = "%s:\n" % rxn.identifier
sub.add_reaction(rxn)
for cmpd in graph.predecessors(rxn):
coefficient = random.choice(factors)
msg += " -%d%s" % (coefficient, cmpd)
sub.add_compound(cmpd)
sub.add_edge(cmpd, rxn, factor=coefficient)
graph[cmpd][rxn]["factor"] = coefficient
for cmpd in graph.successors(rxn):
coefficient = random.choice(factors)
msg += " +%d%s" % (coefficient, cmpd)
sub.add_compound(cmpd)
sub.add_edge(rxn, cmpd, factor=coefficient)
graph[rxn][cmpd]["factor"] = coefficient
msg += " = 0\n"
logger.debug(msg)
matrix = StoichiometricMatrix()
matrix.make_new_from_network(sub)
# objective function
objective = numpy.ones(matrix.num_compounds)
# equality constraints
A_eq = numpy.array(numpy.transpose(matrix.matrix), dtype=float, copy=False)
b_eq = numpy.zeros(matrix.num_reactions)
# lower boundary
lb = numpy.empty(matrix.num_compounds)
for (i, comp) in enumerate(matrix.compounds):
if mass_vector[comp] != 0.:
lb[i] = mass_vector[comp]
else:
lb[i] = lower
# upper boundary
ub = numpy.empty(matrix.num_compounds)
for (i, comp) in enumerate(matrix.compounds):
if mass_vector[comp] != 0.:
ub[i] = mass_vector[comp]
else:
ub[i] = upper
# starting guess
start = numpy.empty(matrix.num_compounds)
logger.debug(A_eq)
for (i, comp) in enumerate(matrix.compounds):
start[i] = 1. / float(sub.in_degree(comp) + sub.out_degree(comp))
problem = openopt.LP(f=objective, Aeq=A_eq, beq=b_eq, lb=lb, ub=ub, x0=start)
result = problem.solve(options.solver, iprint=-10)
if not result.isFeasible:
raise PyMetabolismError("Unable to balance reaction system.")
for (i, comp) in enumerate(matrix.compounds):
if mass_vector[comp] == 0.:
mass_vector[comp] = result.xf[i]
logger.debug(result.xf)
def random_metabolic_network2(compounds, reactions, reversible, p, seed=None):
"""
Creates a bipartite graph that models metabolism according to the principles
of an Erdos-Renyi-like random graph.
@param compounds: Integer specifying the number of compounds.
@param reactions: Integer, specifying the number of reactions.
@param p: Probability for an edge to be set (on average this is the density
of the graph).
@rtype: L{BipartiteMetabolicNetwork
<pyMetabolism.graph_view.BipartiteMetabolicNetwork>}
@raise ValueError: If either compounds or reactions are not integers.
"""
if seed:
random.seed(seed)
options = OptionsManager()
logger = logging.getLogger("%s.random_metabolic_network"\
% (options.main_logger_name))
graph = BipartiteMetabolicNetwork(name="random model")
for i in xrange(compounds):
graph.add_compound(Compound("%s%d" % (options.compound_prefix, i)))
# choose a number of reactions as reversible
reversibles = random.sample(xrange(reactions), reversible)
reversibles.sort()
for i in xrange(reactions):
if len(reversibles) > 0 and i == reversibles[0]:
del reversibles[0]
graph.add_reaction(Reaction("%s%d" % (options.reaction_prefix, i),\
(), (), (), reversible=True))
else:
graph.add_reaction(Reaction("%s%d" % (options.reaction_prefix, i),\
(), (), (), reversible=False))
for src in graph.compounds:
for tar in graph.reactions:
if not graph.has_edge(tar, src):
if random.random() < p:
logger.debug("Adding edge %s-%s.", src.identifier,\
tar.identifier)
graph.add_edge(src, tar, factor=0)
for src in graph.reactions:
for tar in graph.compounds:
if not graph.has_edge(tar, src):
if random.random() < p:
logger.debug("Adding edge %s-%s.", src.identifier,\
tar.identifier)
graph.add_edge(src, tar, factor=0)
prune_network(graph, logger)
return graph
def scale_free_metabolic_network(compounds, reactions, reversible, m, n):
"""
Uses a Barabasi-Alberts-like preferential attachment algorithm. Adopted from
the networkx implementation.
@param m: How many compounds a new reaction node links to
@param n: How many reactions a new compound node links to
"""
options = OptionsManager()
logger = logging.getLogger("%s.scale_free_metabolic_network"\
% (options.main_logger_name))
graph = BipartiteMetabolicNetwork(name="scale-free model")
# target nodes for reactions
rxn_targets = []
for i in xrange(m):
comp = Compound("%s%d" % (options.compound_prefix, i))
graph.add_compound(comp)
rxn_targets.append(comp)
# logger.debug("Targets for reactions: %s", rxn_targets)
# target nodes for compounds
comp_targets = []
# biased lists for preferential attachment
repeated_cmpds = []
repeated_rxns = []
# choose a number of reactions as reversible
reversibles = random.sample(xrange(reactions), reversible)
reversibles.sort()
for i in xrange(n):
if len(reversibles) > 0 and i == reversibles[0]:
del reversibles[0]
rxn = Reaction("%s%d" % (options.reaction_prefix, i),\
(), (), (), reversible=True)
else:
rxn = Reaction("%s%d" % (options.reaction_prefix, i),\
(), (), (), reversible=False)
graph.add_reaction(rxn)
comp_targets.append(rxn)
for comp in rxn_targets:
if random.random() < 0.5:
logger.debug("Adding edge %s -> %s.", rxn.identifier,\
comp.identifier)
graph.add_edge(rxn, comp, factor=0)
else:
logger.debug("Adding edge %s -> %s.", comp.identifier,\
rxn.identifier)
graph.add_edge(comp, rxn, factor=0)
repeated_cmpds.extend(rxn_targets)
repeated_rxns.extend([rxn] * m)
# logger.debug("Targets for compounds: %s", comp_targets)
# current vertices being added
current_rxn = n
current_comp = m
# to prevent reactions from consuming and producing the same compound
new_targets = list()
rm_targets = list()
while (current_comp < compounds or current_rxn < reactions):
if current_comp < compounds:
source = Compound("%s%d" % (options.compound_prefix, current_comp))
graph.add_compound(source)
for rxn in comp_targets:
if random.random() < 0.5:
logger.debug("Adding edge %s -> %s.", source.identifier,\
rxn.identifier)
graph.add_edge(source, rxn, factor=0)
else:
logger.debug("Adding edge %s -> %s.", rxn.identifier,\
source.identifier)
graph.add_edge(rxn, source, factor=0)
repeated_rxns.extend(comp_targets)
repeated_cmpds.extend([source] * n)
comp_targets = set()
while len(comp_targets) < n:
rxn = random.choice(repeated_rxns)
comp_targets.add(rxn)
current_comp += 1
if current_rxn < reactions:
if len(reversibles) > 0 and current_rxn == reversibles[0]:
del reversibles[0]
source = Reaction("%s%d" % (options.reaction_prefix,\
current_rxn), (), (), (), reversible=True)
else:
source = Reaction("%s%d" % (options.reaction_prefix,\
current_rxn), (), (), (), reversible=False)
graph.add_reaction(source)
new_targets = list()
rm_targets = list()
for comp in rxn_targets:
# same compound may not be in substrates and products
if (comp in graph.predecessors(source)) or (comp in graph.successors(source)):
cmpd = random.choice(repeated_cmpds)
while cmpd in graph.predecessors(source) or cmpd in graph.successors(source) or cmpd in new_targets or cmpd in rxn_targets:
cmpd = random.choice(repeated_cmpds)
new_targets.append(cmpd)
rm_targets.append(comp)
continue
if random.random() < 0.5:
logger.debug("Adding edge %s -> %s.", source.identifier,\
comp.identifier)
graph.add_edge(source, comp, factor=0)
else:
logger.debug("Adding edge %s -> %s.", comp.identifier,\
source.identifier)
graph.add_edge(comp, source, factor=0)
for comp in rm_targets:
rxn_targets.remove(comp)
for comp in new_targets:
rxn_targets.add(comp)
if random.random() < 0.5:
logger.debug("Adding edge %s -> %s.", source.identifier,\
comp.identifier)
graph.add_edge(source, comp, factor=0)
else:
logger.debug("Adding edge %s -> %s.", comp.identifier,\
source.identifier)
graph.add_edge(comp, source, factor=0)
repeated_cmpds.extend(rxn_targets)
repeated_rxns.extend([source] * m)
rxn_targets = set()
while len(rxn_targets) < m:
comp = random.choice(repeated_cmpds)
rxn_targets.add(comp)
current_rxn += 1
prune_network(graph, logger)
return graph