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]))