def test_parse_reaction(self):
r, r_ = parse_reaction(
" a + 2b <->(k1*a*b**2/(k2 +a) ) 3 c ")
self.assertEqual(r.reactant, Complex({'a': 1, 'b': 2}))
self.assertEqual(r.product, Complex({'c': 3}))
self.assertEqual(r_.reactant, Complex({'c': 3}))
self.assertEqual(r_.product, Complex({'a': 1, 'b': 2}))
self.assertEqual(r.rate, parse_expr('k1*a*b**2/(k2+a)'))
Reaction('r1', Complex(A=1, B=2), Complex(C=1),
parse_expr('k1*A*B**2'))
r, r_ = parse_reactions(["a + 2b <->(k1/(k2+a)) 3c"])
self.assertEqual(r.reactant, Complex({'a': 1, 'b': 2}))
self.assertEqual(r.product, Complex({'c': 3}))
self.assertEqual(r_.reactant, Complex({'c': 3}))
self.assertEqual(r_.product, Complex({'a': 1, 'b': 2}))
self.assertEqual(r.rate, parse_expr('k1*a*b**2/(k2+a)'))
self.assertEqual(r_.kinetic_param, parse_expr('k_r0_rev'))
r, r_ = parse_reactions(["a + 2b <->(k1/(k2+a)) 3c"], rate=True)
self.assertEqual(r.rate, parse_expr('k1/(k2+a)'))
self.assertEqual(r_.kinetic_param, parse_expr('k_r0_rev/c**3'))
self.assertEqual(1, len(parse_reactions(['a -> b'])))
self.assertRaises(ValueError, parse_reactions, ['a b'])
self.assertRaises(ValueError, parse_reactions, 'a -> b')
def test_remove_react_prod(self):
reaction = parse_reactions(["5 a + b + 2 c -> 3 a + 2 b + d"])[0]
print(reaction)
reaction.remove_react_prod()
print(reaction)
self.assertEqual(reaction.reactant, Complex({"a": 2, "c": 2}))
self.assertEqual(reaction.product, Complex({"b": 1, "d": 1}))
reaction = parse_reactions(["5 a + b + 2 c -> 3 a + 2 b + d"])[0]
reaction.remove_react_prod('b')
print(reaction)
self.assertEqual(reaction.reactant, Complex({"a": 5, "c": 2}))
self.assertEqual(reaction.product, Complex({"a": 3, "b": 1, "d": 1}))
def test_empty_replace(self):
crn = CRN()
crn.reactions = parse_reactions(['a -> b', 'c + 2d <-> e', 'e -> a'])
self.assertEqual(5, crn.n_species)
self.assertEqual(('a', 'b', 'c', 'd', 'e'), crn.species)
self.assertEqual(4, crn.n_complexes)
self.assertEqual(['a', 'b', 'c + 2d', 'e'], list(map(str, crn.complexes)))
self.assertEqual(4, crn.n_reactions)
self.assertEqual(None, crn.model)
crn.update_model()
self.assertNotEqual(None, crn.model)
self.assertEqual(['a', 'b', 'c', 'd', 'e'], [crn.model.getSpecies(s).getId() for s in range(crn.model.getNumSpecies())])
self.assertEqual(4, crn.model.getNumReactions())
Y = sp.Matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 2, 0], [0, 0, 0, 1]])
self.assertEqual(Y, crn.complex_matrix)
Ia = sp.Matrix([[-1, 0, 0, 1], [1, 0, 0, 0], [0, -1, 1, 0], [0, 1, -1, -1]])
self.assertEqual(Ia, crn.incidence_matrix)
S = sp.Matrix([[-1, 0, 0, 1], [1, 0, 0, 0], [0, -1, 1, 0], [0, -2, 2, 0], [0, 1, -1, -1]])
self.assertEqual(S, crn.stoich_matrix)
k_r0, k_r1, k_r1_rev, k_r2 = crn.kinetic_params
L = sp.Matrix([[k_r0, 0, 0, -k_r2], [-k_r0, 0, 0, 0], [0, 0, k_r1, -k_r1_rev], [0, 0, -k_r1, k_r1_rev + k_r2]])
self.assertEqual(L, crn.laplacian)
g_1_1, g_3_2, g_4_2, g_5_3, g_5_4 = sp.symbols('g_1_1 g_3_2 g_4_2 g_5_3 g_5_4')
im = sp.Matrix([[g_1_1, 0, 0, 0], [0, 0, 0, 0], [0, g_3_2, 0, 0], [0, g_4_2, 0, 0], [0, 0, g_5_3, g_5_4]])
self.assertEqual(im, crn.influence_matrix())
def test_rids(self):
self.assertRaises(ValueError, parse_reactions,
["r1: a -> b", "c -> d", "e -> f", "r1: -> e"])
self.assertEqual(['r1', 'r2', 'r0', 'r3'], [
r.reactionid for r in parse_reactions(
["r1: a -> b", "c -> d", "r0: e -> f", " -> e"])
])
def test_fix_ma(self):
reaction = parse_reactions(["a ->(k1 * a * b**2 / (a + b**3)) c"])[0]
print(reaction)
print
reaction._fix_ma(['a', 'b', 'c'])
print(reaction)
self.assertEqual(reaction.reactant, Complex({"a": 2, "b": 2}))
self.assertEqual(reaction.product, Complex({"a": 1, "b": 2, "c": 1}))
def test_fix_denom(self):
reaction = parse_reactions(
["a + 2 b + c + d ->(k1 / ((a + b**3)*c*b**2*d)) 2 b + 2 c"])[0]
print(reaction)
print
reaction._fix_denom(['a', 'b', 'c'])
print(reaction)
self.assertEqual(reaction.reactant, Complex({"a": 1, "d": 1}))
self.assertEqual(reaction.product, Complex({"c": 1}))
def test_fix_denom(self):
reacts = ["a + b ->(k1/b) b", "a + 3 b ->(k2/b**2) c + 5b"]
reacts_fixed = ["r0: a ->(k1) ", "r1: a + b ->(k2) 3b + c"]
crn = from_reacts(parse_reactions(reacts))
for r in crn.reactions: print(r)
print
crn._fix_denom()
for r in crn.reactions: print(r)
print
self.assertEqual([str(r) for r in crn.reactions], reacts_fixed)
def test_fix_ma(self):
reacts = ["b ->(k1*b) c", "a ->(k2*b**2) c"]
reacts_fixed = ["r0: 2b ->(k1) b + c", "r1: a + 2b ->(k2) 2b + c"]
crn = from_reacts(parse_reactions(reacts))
for r in crn.reactions: print(r)
print
crn._fix_ma()
for r in crn.reactions: print(r)
print
self.assertEqual([str(r) for r in crn.reactions], reacts_fixed)
def test_rapid_eq4(self):
reacts = [
"2 a + b ->(kf) y", "y ->(kr) 2 a + b", "y ->(k) d",
"y + d ->(k1) a", "a ->(k2) y + d"
]
crn = from_react_strings(reacts)
crn.remove(rapid_eq=[('y', '2 * a + b')])
sol = parse_reactions(
["2a + b ->(k*kf/kr) d", "2a + b + d (k2)<->(k1*kf/kr) a"])
self.assertTrue(all(r in crn.reactions for r in sol))
self.assertTrue(all(r in sol for r in crn.reactions))
reacts = [
"a + 2 y ->(k1) b", "3a + c ->(k2) y", "y ->(k_2) 3a + c",
"y ->(k3) d"
]
crn = from_react_strings(reacts)
crn.remove(rapid_eq=[('y', '3*a + c')])
sol = parse_reactions(
["7a + 2c ->(k1*k2^2/k_2^2) b", "3a + c ->(k3*k2/k_2) d"])
self.assertTrue(all(r in crn.reactions for r in sol))
self.assertTrue(all(r in sol for r in crn.reactions))
def test_multi_product(self):
"""Test for the case of intermediate produced
with multiple stoichiometries."""
crn = from_react_file(path.join(input_reactions, "multi_product"))
origspecies = crn.species
origeqs = crn.equations()
self.assertEqual(
eqs_match(origeqs, origspecies, crn.removed_species,
crn.equations(), crn.species), 0)
crn._qss_generalised('y', no_rates=True)
reacts = parse_reactions([
"r0_3r1: a + 2d ->(k_r0_3r1) 3b + c",
"r0_3r4: a ->(k_r0_3r4) 3a + 6b + c + d",
"r2_r1: d + e + f ->(k_r2_r1) b",
"r2_r4: e + f ->(k_r2_r4) a + 2b",
"r3_2r1: 2d + 2e ->(k_r3_2r1) 2b + h",
"r3_2r4: 2e ->(k_r3_2r4) 2a + 4b + h"
])
self.assertTrue(
all(r in reacts for r in crn.reactions)
and all(r in crn.reactions for r in reacts))
def test_update(self):
crn = from_react_strings(['a ->(k1) b', 'b (k_2)<->(k2) c + d', 'c ->(k3) d'])
self.assertEqual(('a', 'b', 'c', 'd'), crn.species)
self.assertEqual(['a', 'b', 'c + d', 'c', 'd'], [str(c) for c in crn.complexes])
S = sp.Matrix([[-1, 0, 0, 0], [1, -1, 1, 0], [0, 1, -1, -1], [0, 1, -1, 1]])
k1, k2, k_2, k3, k4, k_4 = sp.symbols('k1 k2 k_2 k3 k4 k_4')
L = sp.Matrix([[k1, 0, 0, 0, 0], [-k1, k2, -k_2, 0, 0], [0, -k2, k_2, 0, 0],
[0, 0, 0, k3, 0], [0, 0, 0, -k3, 0]])
self.assertEqual(S, crn.stoich_matrix)
self.assertEqual(L, crn.laplacian)
crn.reactions = parse_reactions(['a ->(k1) b', 'c + e (k_4)<->(k4) f'])
self.assertEqual(('a', 'b', 'c', 'e', 'f'), crn.species)
self.assertEqual(None, crn.model)
crn.update_model()
self.assertNotEqual(None, crn.model)
self.assertEqual(['a', 'b', 'c', 'e', 'f'], [crn.model.getSpecies(s).getId() for s in range(crn.model.getNumSpecies())])
self.assertEqual(3, crn.model.getNumReactions())
self.assertEqual(['a', 'b', 'c + e', 'f'], [str(c) for c in crn.complexes])
S = sp.Matrix([[-1, 0, 0], [1, 0, 0], [0, -1, 1], [0, -1, 1], [0, 1, -1]])
L = sp.Matrix([[k1, 0, 0, 0], [-k1, 0, 0, 0], [0, 0, k4, -k_4], [0, 0, -k4, k_4]])
self.assertEqual(S, crn.stoich_matrix)
self.assertEqual(L, crn.laplacian)
def test_dynEq2(self):
reacts1 = ["A ->(k1) B", "B ->(k_1) A", "B ->(k2) C", "C ->(k_2) B"]
crn1 = from_reacts(parse_reactions(reacts1))
reacts2 = ["->(k_1*(A + B + C)) A", "A ->(k1 + k_1 + k_1 * C/A)", "->(k2*(A + B + C)) C", "C ->(k2 + k_2 + k2 * A/C)"]
crn2 = from_reacts(parse_reactions(reacts2))
self.assertFalse(crn1.is_dyn_eq(crn2))
def test_reaction_setter(self):
net = CRN()
net.reactions = parse_reactions(["A -> 2B", "B <-> C + D"])
self.assertEqual(("A", "B", "C", "D"), net.species)
self.assertEqual(4, net.n_species)
self.assertEqual(4, net.n_complexes)
self.assertEqual(3, net.n_reactions)
self.assertEqual(("r0", "r1", "r1_rev"), net.reactionids)
self.assertEqual(sorted(["A", "2B", "B", "C + D"]), sorted(list(map(str, net.complexes))))
self.assertEqual(("r0: A ->(k_r0) 2B", "r1: B ->(k_r1) C + D", "r1_rev: C + D ->(k_r1_rev) B"), tuple(map(str, net.reactions)))
self.assertEqual(sp.Matrix([parse_expr("k_r0*A"), parse_expr("k_r1*B"), parse_expr("k_r1_rev*C*D")]), net.rates)
S = sp.Matrix([[-1, 0, 0], [ 2, -1, 1], [ 0, 1, -1], [ 0, 1, -1]])
self.assertEqual(S, net.stoich_matrix)
Y = sp.Matrix([[1, 0, 0, 0], [0, 2, 1, 0], [0, 0, 0, 1], [0, 0, 0, 1]])
self.assertEqual(Y, net.complex_matrix)
Ia = sp.Matrix([[-1, 0, 0], [ 1, 0, 0], [ 0, -1, 1], [ 0, 1, -1]])
self.assertEqual(Ia, net.incidence_matrix)
k_r0, k_r1, k_r1_rev = sp.symbols("k_r0, k_r1, k_r1_rev")
self.assertEqual((k_r0, k_r1, k_r1_rev), net.kinetic_params)
L = sp.Matrix([[k_r0, 0, 0, 0], [-k_r0, 0, 0, 0], [0, 0, k_r1, -k_r1_rev], [0, 0, -k_r1, k_r1_rev]])
self.assertEqual(L, net.laplacian)
self.assertEqual((), net.removed_species)
net = from_react_strings(["A -> 2B", "B <-> C + D"])
self.assertEqual(None, net.model)
net.update_model()
self.assertNotEqual(None, net.model)
self.assertEqual(['A', 'B', 'C', 'D'], [net.model.getSpecies(s).getId() for s in range(net.model.getNumSpecies())])
self.assertEqual(("A", "B", "C", "D"), net.species)
self.assertEqual(4, net.n_species)
self.assertEqual(4, net.n_complexes)
self.assertEqual(3, net.n_reactions)
self.assertEqual(("r0", "r1", "r1_rev"), net.reactionids)
self.assertEqual(sorted(["A", "2B", "B", "C + D"]), sorted(list(map(str, net.complexes))))
self.assertEqual(("r0: A ->(k_r0) 2B", "r1: B ->(k_r1) C + D", "r1_rev: C + D ->(k_r1_rev) B"), tuple(map(str, net.reactions)))
self.assertEqual(sp.Matrix([parse_expr("k_r0*A"), parse_expr("k_r1*B"), parse_expr("k_r1_rev*C*D")]), net.rates)
S = sp.Matrix([[-1, 0, 0], [ 2, -1, 1], [ 0, 1, -1], [ 0, 1, -1]])
self.assertEqual(S, net.stoich_matrix)
Y = sp.Matrix([[1, 0, 0, 0], [0, 2, 1, 0], [0, 0, 0, 1], [0, 0, 0, 1]])
self.assertEqual(Y, net.complex_matrix)
Ia = sp.Matrix([[-1, 0, 0], [ 1, 0, 0], [ 0, -1, 1], [ 0, 1, -1]])
self.assertEqual(Ia, net.incidence_matrix)
k_r0, k_r1, k_r1_rev = sp.symbols("k_r0, k_r1, k_r1_rev")
L = sp.Matrix([[k_r0, 0, 0, 0], [-k_r0, 0, 0, 0], [0, 0, k_r1, -k_r1_rev], [0, 0, -k_r1, k_r1_rev]])
self.assertEqual(L, net.laplacian)
self.assertEqual((), net.removed_species)
net.reactions = parse_reactions(["r_id_1: E -> F", "r_id_2: F + A -> 3G"])
self.assertNotEqual(None, net.model)
self.assertEqual(('A', 'E', 'F', 'G'), net.species)
# check that model is updated
self.assertEqual(['A', 'E', 'F', 'G'], [net.model.getSpecies(s).getId() for s in range(net.model.getNumSpecies())])
self.assertEqual(4, net.n_species)
self.assertEqual(4, net.n_complexes)
self.assertEqual(2, net.n_reactions)
self.assertEqual(("r_id_1", "r_id_2"), net.reactionids)
self.assertEqual(sorted(["A + F", "E", "F", "3G"]), sorted(list(map(str, net.complexes))))
self.assertEqual(("r_id_1: E ->(k_r_id_1) F", "r_id_2: A + F ->(k_r_id_2) 3G"), tuple(map(str, net.reactions)))
k_r_id_1, k_r_id_2 = sp.symbols("k_r_id_1, k_r_id_2")
self.assertEqual((k_r_id_1, k_r_id_2), net.kinetic_params)
self.assertEqual(sp.Matrix([parse_expr("k_r_id_1*E"), parse_expr("k_r_id_2*A*F")]), net.rates)
S = sp.Matrix([[ 0, -1], [-1, 0], [ 1, -1], [ 0, 3]])
self.assertEqual(S, net.stoich_matrix)
Y = sp.Matrix([[0, 0, 1, 0], [1, 0, 0, 0], [0, 1, 1, 0], [0, 0, 0, 3]])
self.assertEqual(Y, net.complex_matrix)
Ia = sp.Matrix([[-1, 0], [ 1, 0], [ 0, -1], [ 0, 1]])
self.assertEqual(Ia, net.incidence_matrix)
L = sp.Matrix([[k_r_id_1, 0, 0, 0], [-k_r_id_1, 0, 0, 0], [0, 0, k_r_id_2, 0], [0, 0, -k_r_id_2, 0]])
self.assertEqual(L, net.laplacian)
self.assertEqual((), net.removed_species)
