def test_acr(self):
crn = from_react_file(path.join(input_reactions, "acr/acr_1"))
self.assertEqual(['yp'], crn.acr_species())
crn = from_react_file(path.join(input_reactions, "acr/acr_toy"))
self.assertEqual(['a'], crn.acr_species())
crn = from_react_file(path.join(input_reactions, "acr/acr_complex"))
self.assertEqual([parse_expr('A*B')], crn.acr_complexes())
self.assertEqual(['C'], crn.acr_species(subnets = True))
crn = from_react_file(path.join(input_reactions, "acr/neigenfind_ex1"))
self.assertEqual(['C'], crn.acr_species(subnets = True))
crn = from_react_file(path.join(input_reactions, "acr/neigenfind_ex2"))
self.assertEqual(['C', 'U'], crn.acr_species(subnets = True))
crn = from_react_strings(["A + B -> A + C", "A + B -> A + D", "C -> A", "D -> A", "A -> B"])
self.assertEqual([], crn.acr_species())
self.assertEqual([], crn.acr_species(subnets = True))
self.assertEqual([], crn.acr_complexes())
self.assertEqual([], crn.acr_complexes(subnets = True))
self.assertEqual([], crn.acr_species(subnets = True, same_ems = True))
self.assertTrue(sp.sympify("A*B/D") in crn.acr_complexes(subnets = True, same_ems = True))
self.assertTrue([1, 1, -1, 0] in crn.acr_same_ems(as_vectors = True) or
[-1, -1, 1, 0] in crn.acr_same_ems(as_vectors = True))
crn = from_react_strings(["A -> 2B", "B -> C", "2C -> A", "B + C -> A"])
self.assertEqual([], crn.acr_complexes(subnets = True, same_ems = True))
def test_intermediates(self):
reacts = ['a -> y', 'y + b -> c']
crn = from_react_strings(reacts)
self.assertTrue(crn.is_intermediate_species('y'))
self.assertTrue(crn.has_linear_equation('y'))
self.assertTrue('y' in crn.intermediate_species)
self.assertTrue('y' in crn.intermediate_stoich_1_species)
reacts = ['a -> y', 'y + b ->(k*y) c']
crn = from_react_strings(reacts)
self.assertTrue(crn.is_intermediate_species('y'))
self.assertFalse(crn.has_linear_equation('y'))
self.assertTrue('y' in crn.intermediate_species)
self.assertTrue('y' in crn.intermediate_stoich_1_species)
reacts = ['a -> y', 'y + b -> y + c']
crn = from_react_strings(reacts)
self.assertFalse(crn.is_intermediate_species('y'))
self.assertFalse(crn.has_linear_equation('y'))
self.assertFalse('y' in crn.intermediate_species)
self.assertFalse('y' in crn.intermediate_stoich_1_species)
reacts = ['a -> 2y', '2y + b -> c']
crn = from_react_strings(reacts)
self.assertTrue(crn.is_intermediate_species('y'))
self.assertFalse(crn.has_linear_equation('y'))
self.assertTrue('y' in crn.intermediate_species)
self.assertFalse('y' in crn.intermediate_stoich_1_species)
def test_qss_errors(self):
crn = from_react_strings(['a -> b', 'b + d ->(k*b) c + d', 'd -> '])
self.assertRaises(ValueError, crn.qss, 'a') # a not intermediate
self.assertRaises(ValueError, crn.qss, 'b') # nonlinear kinetics
self.assertRaises(ValueError, crn.qss, 'c') # c not intermediate
self.assertRaises(ValueError, crn.qss, 'd') # d not intermediate
self.assertRaises(ValueError, crn.qss, 'e') # e not in valid species
crn = from_react_strings(['a -> b', 'a + b -> 2a + c', 'd -> a'])
self.assertRaises(ValueError, crn.qss,
'a') # stoichiometry larger than 1
def test_is_ma(self):
crn = from_react_strings(['a ->(k1) b', '2a ->(k2) '])
self.assertTrue(crn.is_ma)
crn = from_react_strings(['a ->(k1*a) b'])
self.assertFalse(crn.is_ma)
crn = from_react_strings(['a ->(k1*a/a) b', '-> d'])
self.assertTrue(crn.is_ma)
crn = from_react_strings(['s ->(k1/(s+1)) p'])
self.assertFalse(crn.is_ma)
crn = from_react_strings(['s ->(1) p'])
self.assertTrue(crn.is_ma)
def test_is_rev(self):
crn = from_react_strings(["a <-> b + c", "b <-> 2d"])
self.assertTrue(crn.is_rev)
self.assertTrue(crn.is_weakly_rev)
crn = from_react_strings(["a <-> b + c", "b -> 2d", "2d -> b", "b + c -> a"])
self.assertTrue(crn.is_rev)
self.assertTrue(crn.is_weakly_rev)
crn = from_react_strings(["a -> b + c", "b -> 2d", "2d -> b", "b + c -> e", "e -> a"])
self.assertFalse(crn.is_rev)
self.assertTrue(crn.is_weakly_rev)
crn = from_react_strings(["a -> b + c", "b -> 2d", "2d -> b", "b + c -> e", "e -> "])
self.assertFalse(crn.is_rev)
self.assertFalse(crn.is_weakly_rev)
def test_re_errors(self):
crn = from_react_strings(
['a (k_0)<->(k0) b + c', 'b (k_1)<->(k1*c) c', 'd ->(k2) '])
self.assertRaises(TypeError, crn.rapid_eq, 'a') # invalid input
self.assertRaises(ValueError, crn.rapid_eq, 'a',
'f') # f not valid complex
self.assertRaises(ValueError, crn.rapid_eq, 'a + c',
'b') # a + c not valid species
self.assertRaises(ValueError, crn.rapid_eq, 'c',
'b') # unable to remove c
crn = from_react_strings(
['a (k_0)<->(k0) b + c', 'b (k_1)<->(k1*b) c', 'd ->(k2) '])
self.assertRaises(ValueError, crn.rapid_eq, 'b',
'c') # unable to remove b
def test_tree_constants3(self):
crn = from_react_strings(["2c1 (k21)<->(k12) c1+c2", "c1+c2 (k32)<->(k23) 2c2", "2c1 (k31)<->(k13) 2c2"])
k12, k21, k23, k32, k13, k31 = crn.kinetic_params
tcs = crn.tree_constants()
self.assertEqual((tcs[0]-(k21*k31 + k23*k31 + k21*k32)).simplify(), 0)
self.assertEqual((tcs[1]-(k12*k32 + k12*k31 + k13*k32)).simplify(), 0)
self.assertEqual((tcs[2]-(k13*k21 + k13*k23 + k12*k23)).simplify(), 0)
def test_derivative(self):
reacts = ['a -> b + c', '2c -> a + d']
crn = from_react_strings(reacts)
print
self.assertRaises(ValueError, crn.derivative, 'b + 3')
self.assertRaises(ValueError, crn.derivative, 'a**2 + b')
self.assertRaises(ValueError, crn.derivative, '2 a + f')
self.assertEqual(0, (parse_expr('k_r0*a + k_r1*c**2') - crn.derivative('a + 2b')).simplify())
def test_tree_constants(self):
crn = from_react_strings(['A1 (k2)<->(k1) A2', 'A2 (k4+k1*k5/k2)<->(k3) A3'])
tconstants = list(map(parse_expr, ['k2*k4+k1*k5', 'k1/k2*(k2*k4+k1*k5)', 'k1*k3']))
tree_consts = crn.tree_constants()
for i in range(crn.n_complexes):
self.assertEqual((crn.tree_constant(i) - tconstants[i]).simplify(), 0)
for i in range(crn.n_complexes):
self.assertEqual((tree_consts[i] - tconstants[i]).simplify(), 0)
def test_source_sink(self):
reacts = ['a -> y', 'b <-> y', 'd -> c', 'y + d -> c', 'd -> e + d']
crn = from_react_strings(reacts)
self.assertEqual(['a', 'd'], crn.source_species)
self.assertEqual(['c', 'e'], crn.sink_species)
self.assertEqual(['a', 'd', 'd + y'], list(map(str, crn.source_complexes)))
self.assertEqual(['c', 'd + e'], list(map(str, crn.sink_complexes)))
self.assertEqual(['y', 'b'], list(map(str, crn.intermediate_complexes)))
self.assertEqual(['b'], list(map(str, crn.intermediate_simple_complexes)))
def test_save_react_file(self):
crn = from_react_strings(["r_123: A -> B + C", "2A ->(0.0012345) E", "r_in: -> E"])
output1 = path.join(input_reactions, "test_save_reacts_1")
output2 = path.join(input_reactions, "test_save_reacts_2")
compare1 = path.join(input_reactions, "test_save_reacts_check_1")
compare2 = path.join(input_reactions, "test_save_reacts_check_2")
crn.save_reaction_file(output1)
self.assertTrue(cmp(output1, compare1))
crn.save_reaction_file(output2, rate = True, precision = 2)
self.assertTrue(cmp(output2, compare2))
def test_ems(self):
reacts = ["a -> b", "b + c -> d", "d <-> e", "e <-> a + c", "e -> b + c"]
crn = from_react_strings(reacts)
self.assertRaises(ValueError, crn.is_ss_flux, sp.Matrix([0, 0, 2, 2, 3, 3]))
self.assertTrue(crn.is_ss_flux(sp.Matrix([0, 0, 2, 2, 3, 3, 0])))
self.assertFalse(crn.is_ss_flux(sp.Matrix([1, 1, 1, 1, 1, 1, 1])))
self.assertRaises(ValueError, crn.is_cyclic_ss_flux, sp.Matrix([0, 0, 2, 2, 3, 3]))
self.assertTrue(crn.is_cyclic_ss_flux(sp.Matrix([0, 0, 2, 2, 3, 3, 0])))
self.assertFalse(crn.is_cyclic_ss_flux(sp.Matrix([1, 1, 1, 0, 3, 2, 0])))
self.assertEqual([False, True, True, True], [crn.is_cyclic_ss_flux(v) for v in crn.t_invariants.tolist()])
def test_split_by_ems(self):
reacts = ["a -> b", "b + c -> d", "d <-> e", "e <-> a + c", "e -> b + c",
"f <-> g", "a -> h", "h + l -> i", "i -> a + l", "l -> "]
crn = from_react_strings(reacts)
rss, rf = crn.split_by_ems()
self.assertEqual([['r0', 'r1', 'r2', 'r2_rev', 'r3', 'r3_rev', 'r4'], ['r5', 'r5_rev'], ['r6', 'r7', 'r8'], ['r9']],
[[r.reactionid for r in rs] for rs in rss] + [[r.reactionid for r in rf]])
rss, rf = crn.split_by_ems(same_react = True)
self.assertEqual([['r0', 'r1', 'r2', 'r2_rev', 'r3', 'r3_rev', 'r4', 'r6', 'r7', 'r8'], ['r5', 'r5_rev'], ['r9']],
[[r.reactionid for r in rs] for rs in rss] + [[r.reactionid for r in rf]])
reacts = ["a -> b", "b + c -> d", "d -> a + c", "a <-> e", "e -> f", "f + g -> d",
"d -> e + g", "g <-> h", "e + g -> b", "h + i -> k", "k -> l", "l -> g + i", "a -> l"]
crn = from_react_strings(reacts)
rss, rf = crn.split_by_ems()
self.assertEqual([['r0', 'r1', 'r2'], ['r3', 'r3_rev'], ['r4', 'r5', 'r6'], ['r7', 'r7_rev', 'r9', 'r10', 'r11'], ['r8', 'r12']],
[[r.reactionid for r in rs] for rs in rss] + [[r.reactionid for r in rf]])
rss, rf = crn.split_by_ems(same_react = True)
self.assertEqual([['r0', 'r1', 'r2', 'r3', 'r3_rev', 'r4', 'r5', 'r6', 'r12'], ['r7', 'r7_rev', 'r9', 'r10', 'r11'], ['r8']],
[[r.reactionid for r in rs] for rs in rss] + [[r.reactionid for r in rf]])
def test_qss_minimal(self):
reacts = ["a -> y + b", "y + b -> z", "z -> y", "y -> d"]
crn = from_react_strings(reacts)
# Removing z first
crn.qss('z')
crn.qss('y')
reactions = crn.reactions
crn = from_react_strings(reacts)
# Removing y first
crn.qss('y')
crn.qss('z')
crn = from_react_strings(reacts)
# Removing using minimal
crn.remove(qss=['y', 'z'], minimal=True)
self.assertEqual(len(reactions), len(crn.reactions))
self.assertTrue(
all(crn.reactions[i] in reactions for i in range(crn.n_reactions)))
def test_linkage_classes(self):
crn = from_react_strings(["X <-> A", "A -> Ap", "Ap <-> Xp",
"Xp + Y <-> B", "B -> Bp", "Bp <-> X + Yp",
"Yp + A <-> C", "C -> Cp", "Cp <-> A + Y"])
X, Y, A, B, C = Complex(X=1), Complex(Y=1), Complex(A=1), Complex(B=1), Complex(C=1)
Xp, Yp, Ap, Bp, Cp = Complex(Xp=1), Complex(Yp=1), Complex(Ap=1), Complex(Bp=1), Complex(Cp=1)
self.assertEqual(crn.strong_linkage_classes,
[[X, A], [Ap, Xp], [Xp + Y, B], [Bp, X + Yp], [A + Yp, C], [Cp, A + Y]])
self.assertEqual(crn.linkage_classes, [[X, A, Ap, Xp], [Xp + Y, B, Bp, X + Yp], [A + Yp, C, Cp, A + Y]])
self.assertEqual(crn.terminal_complexes, [Ap, Xp, Bp, X + Yp, Cp, A + Y])
self.assertEqual(crn.non_terminal_complexes, [X, A, Xp + Y, B, A + Yp, C])
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_qss_minimal2(self):
reacts = [
"r1: x -> y", "r1_rev: y -> x", "r2: e + x -> w",
"r2rev: w -> e + x", "r3: f + y -> z", "r3rev: z -> f + y",
"r4: w -> z", "r5: d + x -> c", "r5rev: c -> d + x",
"r6: b + y -> a", "r6rev: a -> b + y"
]
crn = from_react_strings(reacts)
crn.set_params(dict((k, 1) for k in crn.kinetic_params))
# Qss on y, z, w, x
crn.remove(qss=['y', 'z', 'w', 'x'], minimal=True)
self.assertTrue(len(crn.reactions) == 4)
for r in crn.reactions:
print(r)
print
crn = from_react_strings(reacts)
crn.set_params(dict((k, 1) for k in crn.kinetic_params))
# Qss on y, z, x, w
crn.remove(qss=['y', 'z', 'x', 'w'], minimal=True)
self.assertTrue(len(crn.reactions) == 4)
for r in crn.reactions:
print(r)
def test_set_params(self):
reacts = ["r1: a ->(k1) b", "r2: b + c ->(k2) d", "d (k_3)<->(k3) a + c"]
crn = from_react_strings(reacts)
k3,d = sp.symbols('k3,d')
crn.set_params({'k1': 0.001, 'k2': 1, 'k_3': k3**2/d})
self.assertEqual(str(crn.reactions[0]), "r1: a ->(1.000e-3) b")
self.assertEqual(str(crn.reactions[1]), "r2: b + c ->(1) d")
self.assertEqual(str(crn.reactions[2]), "r0: d ->(k3) a + c")
self.assertEqual(str(crn.reactions[3]), "r0_rev: a + c ->(k3**2/d) d")
crn.set_params({'k3': 5e7})
for r in crn.reactions: print(r)
self.assertEqual(str(crn.reactions[0]), "r1: a ->(1.000e-3) b")
self.assertEqual(str(crn.reactions[1]), "r2: b + c ->(1) d")
self.assertEqual(str(crn.reactions[2]), "r0: d ->(5.000e+7) a + c")
self.assertEqual(str(crn.reactions[3]), "r0_rev: a + c ->(2.5e+15/d) d")
def test_im(self):
crn = from_react_file(path.join(input_reactions, "dsr-graph/pos_loops_main"))
g_1_1, g_2_2, g_2_3, g_3_3, g_3_4 = sp.symbols('g_1_1 g_2_2 g_2_3 g_3_3 g_3_4')
I = sp.Matrix([[g_1_1, 0, 0, 0], [0, g_2_2, g_2_3, 0], [0, 0, g_3_3, g_3_4]])
self.assertEqual(I, crn.influence_matrix(state = {'x1': 2}))
crn.dsr_graph_adj()
crn = from_react_file(path.join(input_reactions, "dsr-graph/pos_loops_main_v2"))
I = sp.Matrix([[g_1_1, 0, 0, 0], [0, g_2_2, g_2_3, 0], [0, 0, 0, g_3_4]])
self.assertEqual(I, crn.influence_matrix(check = True))
crn.dsr_graph_adj()
a1_1, a2_2, a2_3, a3_3, a3_4 = sp.symbols('a1_1 a2_2 a2_3 a3_3 a3_4')
I = sp.Matrix([[a1_1, 0, 0, 0], [0, a2_2, a2_3, 0], [0, 0, 0, a3_4]])
self.assertEqual(I, crn.influence_matrix(var = "a", check = True, params = {'K': 7, 'k1': 3}))
crn = from_react_strings(["x ->(k/(2-x))"])
self.assertRaises(ValueError, crn.influence_matrix, check = True, state = {sp.Symbol('x'): 2})
def test_empty_crn(self):
for crn in [CRN(), from_reacts([]), from_react_strings([])]:
self.assertEqual(0, crn.n_species)
self.assertEqual((), crn.species)
self.assertEqual(0, crn.n_complexes)
self.assertEqual((), crn.complexes)
self.assertEqual(0, crn.n_reactions)
self.assertEqual((), crn.reactions)
self.assertEqual((), crn.cons_laws)
self.assertEqual((), crn.removed_species)
self.assertTrue(crn.is_ma)
self.assertEqual(sp.Matrix(), crn.complex_matrix)
self.assertEqual(sp.Matrix(), crn.incidence_matrix)
self.assertEqual(sp.Matrix(), crn.stoich_matrix)
self.assertEqual(sp.Matrix(), crn.laplacian)
self.assertEqual(sp.Matrix(), crn.influence_matrix())
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)
status = prob.solve(solver=CPLEX())
#print(prob)
# Problem successfully solved, report results
if status == 1:
# Get solutions to problem
Tsol = np.zeros((n, n))
Asol = np.zeros((m, m))
for i in col_range:
for j in col_range:
Asol[i - 1, j - 1] = value(A[i, j])
for i in row_range:
Tsol[i - 1, i - 1] = value(T[i])
print("\nA =\n", Asol)
print("\nT =\n", Tsol)
else:
print("No solution found")
crn = from_react_strings([
"X1 + 2 X2 ->(1.5) X1", "2 X1 + X2 ->(1) 3 X2", "X1 + 3 X2 ->(1) X1 + X2",
"X1 + X2 ->(1) 3 X1 + X2"
])
weak_rev_lin_con(crn, 0.6666, 20)
gammasol[i - 1, k - 1] = value(gamma[i, k])
for i in row_range:
Tsol[i - 1, i - 1] = value(T[i])
print("\nA =\n", Asol)
print("\ngamma =\n", gammasol)
print("\nT =\n", Tsol)
print("\nmin deficiency = ", value(prob.objective))
else:
print("No solution found")
crn1 = from_react_strings([
"0 ->(1) A1", "A1 ->(1) 0", "A1 ->(1) 2 A1", "2 A1 ->(1) A1",
"A1 ->(1) A2 + A3", "A2 + A3 ->(2) A1", "A2 + A3 ->(1) 2 A2",
"2 A2 ->(4) A2 + A3", "X2 + X3 ->(1) 2 X3", "2 X3 ->(1) X2 + X3"
])
crn2 = from_react_strings([
"2 T100 (1)<->(1) 2 T001", "2 T100 (1)<->(1) 2 T010",
"2 T001 (1)<->(1) 2 T010", "T100 + T001 (1)<->(1) T100 + T010",
"T100 + T001 (1)<->(1) T010 + T001", "T100 + T010 (1)<->(1) T010 + T001"
])
crn3 = from_react_strings(
["A (1)<->(8.5) 2 A", "A + B (1)<->(1) C", "C (1)<->(0.2) B"])
crn4 = from_react_strings([
"3 A ->(0.1) A + 2 B", "A + 2 B ->(1) 3 B", "3 B ->(0.1) 2 A + B",
"2 A + B ->(1) 3 A"
prob += Ah[j, j] <= 0
status = prob.solve(solver=CPLEX())
#print(prob)
# Problem successfully solved, report results
if status == 1:
# Get solutions to problem
Tsol = np.zeros((n, n))
Asol = np.zeros((m,m))
for i in col_range:
for j in col_range:
Asol[i-1, j-1] = value(A[i, j])
for i in row_range:
Tsol[i-1, i-1] = value(T[i])
print("\nA =\n", Asol)
print("\nT =\n", Tsol)
else:
print("No solution found")
crn = from_react_strings(["X1 + 2 X2 ->(1.5) X1",
"2 X1 + X2 ->(1) 3 X2",
"X1 + 3 X2 ->(1) X1 + X2",
"X1 + X2 ->(1) 3 X1 + X2"])
weak_rev_lin_con(crn, 0.6666, 20)
0, os.path.join(os.path.dirname(os.path.realpath(__file__)), '..'))
from crnpy.crn import CRN, from_react_strings
from simulation import simulate, plot_simulation
__author__ = "Elisa Tonello"
__copyright__ = "Copyright (c) 2016, Elisa Tonello"
__license__ = "BSD"
__version__ = "0.0.1"
if __name__ == "__main__":
# Simulation of one-substrate enzyme kinetics,
# before and after removal of the intermediate via qss.
crn = from_react_strings(['s + e (k_1)<->(k1) es', 'es ->(k2) p + e'])
start_t, end_t, incr = 0, 1, 0.01
initial = {'s': 5, 'e': 3, 'es': 0, 'p': 0}
params = {'comp': 1, 'k1': 15, 'k_1': 10, 'k2': 6}
colors = {'s': 'darkgreen', 'e': 'red', 'es': 'yellow', 'p': 'blue'}
data, t = simulate(crn, params, initial, start_t, end_t, incr)
title = "One-substrate enzyme kinetics\n $k_{1} = %s$, $k_{-1} = %s$, $k_{2} = %s$"%\
(params['k1'], params['k_1'], params['k2'])
plot_simulation("one-sub_enzyme_plt.png", data, t, colors, title)
crn.qss('es')
data, t = simulate(crn, params, initial, start_t, end_t, incr)
def test_tree_constants2(self):
crn = from_react_strings(['A ->(k1) B', 'B (k3)<->(k2) C', 'A ->(k4) D', 'D (k6)<->(k5) E'])
k1, k2, k3, k4, k5, k6 = crn.kinetic_params
self.assertEqual(crn.tree_constant(1), k3)
self.assertEqual(crn.tree_constants(), [None, k3, k2, k6, k5])
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)
def test_save_sbml(self):
crn = from_react_strings(["r_123: A -> B + C", "2A ->(0.0012345) E", "r_in: -> E"])
output = path.join(input_sbml, "test_save_sbml.xml")
compare = path.join(input_sbml, "test_save_sbml_check.xml")
crn.save_sbml(output)
self.assertTrue(cmp(output, compare))
def test_conn_comp(self):
reacts = ['a -> b', 'b -> c', 'c -> a', 'd <-> e', 'e -> f']
crn = from_react_strings(reacts)
self.assertEqual(2, crn.weak_conn_components()[0])
self.assertEqual(3, crn.strong_conn_components()[0])
self.assertEqual(2, len(crn.strong_terminal_conn_components()[0]))
