def test_self_displacement_02(self): complexes, reactions = read_pil(""" length x = 10 length y = 10 T = x( y x + ) y* x* T1 = x( y x + x* y* ) T2 = x y x( + ) y* x* T3 = x( y( x( + ) ) ) T4 = x y x( + x* y* ) """) T = complexes['T'] T1 = complexes['T1'] T2 = complexes['T2'] T3 = complexes['T3'] T4 = complexes['T4'] path1 = PepperReaction([T], [T1], 'branch-3way') path1r = PepperReaction([T1], [T], 'branch-3way') path2 = PepperReaction([T], [T2], 'branch-3way') path2r = PepperReaction([T2], [T], 'branch-3way') path3 = PepperReaction([T1], [T3], 'bind11') path4 = PepperReaction([T2], [T3], 'bind11') path5 = PepperReaction([T1], [T4], 'branch-3way') path5r = PepperReaction([T4], [T1], 'branch-3way') path6 = PepperReaction([T2], [T4], 'branch-3way') path6r = PepperReaction([T4], [T2], 'branch-3way') enum = Enumerator([T]) enum.max_helix = True enum.enumerate() self.assertEqual( sorted(enum.reactions), sorted([ path1, path1r, path2, path2r, path3, path4, path5, path5r, path6, path6r ]))
def test_self_displacement_03(self): complexes, reactions = read_pil(""" length x1 = 10 length x2 = 10 length y1 = 10 length y2 = 10 B1 = x1( x2( y1( y2( x1( x2( y1 y2 x1 x2 + ) ) ) ) ) ) B2 = x1 x2 y1 y2 x1( x2( y1( y2( x1( x2( + ) ) ) ) ) ) i1 = x1( x2( y1 y2 x1 x2 y1( y2( x1( x2( + ) ) ) ) ) ) i2 = x1( x2( y1( y2( x1 x2 y1 y2 x1( x2( + ) ) ) ) ) ) """) B1 = complexes['B1'] B2 = complexes['B2'] i1 = complexes['i1'] i2 = complexes['i2'] path1 = PepperReaction([B1], [i1], 'branch-3way') path1r = PepperReaction([i1], [B1], 'branch-3way') path1f = PepperReaction([i1], [B2], 'branch-3way') path2 = PepperReaction([B2], [i2], 'branch-3way') path2r = PepperReaction([i2], [B2], 'branch-3way') path2f = PepperReaction([i2], [B1], 'branch-3way') enum = Enumerator([B1]) enum.max_helix = True enum.enumerate() self.assertEqual( sorted(enum.reactions), sorted([path1, path1r, path1f, path2, path2r, path2f]))
def test_self_displacement_01(self): complexes, reactions = read_pil(""" length x = 10 length y = 10 B1 = x( y( x( y x + ) ) ) B2 = x y x( y( x( + ) ) ) B3 = x( y( x y x( + ) ) ) B4 = x( y x y( x( + ) ) ) """) B1 = complexes['B1'] B2 = complexes['B2'] B3 = complexes['B3'] B4 = complexes['B4'] path1 = PepperReaction([B1], [B4], 'branch-3way') path1r = PepperReaction([B4], [B1], 'branch-3way') path2 = PepperReaction([B4], [B2], 'branch-3way') path3 = PepperReaction([B2], [B3], 'branch-3way') path3r = PepperReaction([B3], [B2], 'branch-3way') path4 = PepperReaction([B3], [B1], 'branch-3way') enum = Enumerator([B1]) enum.max_helix = True enum.enumerate() self.assertEqual(sorted(enum.reactions), sorted([path1, path1r, path2, path3, path3r, path4]))
def test_simple(self): complexes, reactions = read_pil(""" length a = 6 length a1 = 2 length a2 = 2 length a3 = 2 length b = 24 length b1 = 8 length b2 = 8 length b3 = 8 length c = 24 length c1 = 8 length c2 = 8 length c3 = 8 I = a b c C = b( c( + ) ) a* J = a( b c + b( c( + ) ) ) D = a( b( c( + ) ) ) cI = a1 a2 a3 b1 b2 b3 c1 c2 c3 cC = b1( b2( b3( c1( c2( c3( + ) ) ) ) ) ) a3* a2* a1* cJ = a1( a2( a3( b1 b2 b3 c1 c2 c3 + b1( b2( b3( c1( c2( c3( + ) ) ) ) ) ) ) ) ) cD = a1( a2( a3( b1( b2( b3( c1( c2( c3( + ) ) ) ) ) ) ) ) ) """) enum = Enumerator( [complexes['I'], complexes['C'], complexes['J'], complexes['D']], named_complexes=list(complexes.values())) enum.k_fast = 0 enum.k_slow = 0 enum.max_helix = True enum.enumerate() enum2 = Enumerator([ complexes['cI'], complexes['cC'], complexes['cJ'], complexes['cD'] ], named_complexes=list(complexes.values())) enum.k_fast = 0 enum2.k_fast = 0 enum2.k_slow = 0 enum2.max_helix = True enum2.enumerate() self.assertEqual(len(list(enum2.reactions)), len(list(enum.reactions)))
def test_max_helix_02(self): complexes, reactions = read_pil(""" length d1 = 15 length d4 = 15 length d6 = 15 length d7 = 15 length h8 = 15 length t0 = 6 length t2 = 6 length t3 = 6 length t5 = 6 # Initial Complexes B2 = d7 t3 d4 t5 helper = t3 d7 t3 PR_FL_B2 = d1 t2( d6( + d7( t3( d4 t5 + ) ) t3* ) ) @ initial 0 M # Intermediate Complexes PR_FLh1B2 = d1 t2( d6( + t3( d7 t3 + d7( t3( d4 t5 + ) ) ) ) ) @ initial 0 M PR_FLh2B2 = d1 t2( d6( + t3 d7 t3( + d7( t3( d4 t5 + ) ) ) ) ) @ initial 0 M PR_FL_h1w = d1 t2( d6( + t3( d7( t3( + ) ) ) ) ) @ initial 0 M # sidestuff PR_FLB2B2 = d1 t2( d6( + d7 t3( d4 t5 + d7( t3( d4 t5 + ) ) ) ) ) @ initial 0 M # casey-semantics PR_FLh2B2_v2 = d1 t2( d6( + t3( d7( t3 + d7 t3( d4 t5 + ) ) ) ) ) @ initial 0 M PR_FLh2w = d1 t2( d6( + t3( d7( t3 + t3* ) ) ) ) @ initial 0 M """) B2 = complexes['B2'] helper = complexes['helper'] PR_FL_B2 = complexes['PR_FL_B2'] PR_FLh1B2 = complexes['PR_FLh1B2'] PR_FLh2B2 = complexes['PR_FLh2B2'] PR_FL_h1w = complexes['PR_FL_h1w'] PR_FLB2B2 = complexes['PR_FLB2B2'] PR_FLh2B2_v2 = complexes['PR_FLh2B2_v2'] PR_FLh2w = complexes['PR_FLh2w'] path1 = PepperReaction([PR_FL_B2, helper], [PR_FLh1B2], 'bind21') path1r = PepperReaction([PR_FLh1B2], [PR_FL_B2, helper], 'open') path2 = PepperReaction([PR_FL_B2, helper], [PR_FLh2B2], 'bind21') path2r = PepperReaction([PR_FLh2B2], [PR_FL_B2, helper], 'open') path3 = PepperReaction([PR_FLh1B2], [PR_FL_h1w, B2], 'branch-3way') path4 = PepperReaction([PR_FL_B2, B2], [PR_FLB2B2], 'bind21') path4r = PepperReaction([PR_FLB2B2], [PR_FL_B2, B2], 'open') path5 = PepperReaction([PR_FLh1B2], [PR_FLh2B2], 'branch-3way') path6 = PepperReaction([PR_FLh2B2], [PR_FLh1B2], 'branch-3way') enum = Enumerator([B2, helper, PR_FL_B2]) enum.max_helix = True enum.enumerate() assert sorted(enum.reactions) == sorted( [path1, path1r, path2, path2r, path3, path4, path4r, path5, path6])
def test_cooperative_binding(self): complexes, reactions = read_pil(""" length a = 5 length x = 10 length y = 10 length b = 5 C = x( y( + b* ) ) a* L = a x R = y b T = x y LC = a( x + x( y( + b* ) ) ) CR = x( y( + y b( + ) ) ) a* LCR = a( x + x( y( + y b( + ) ) ) ) LCF = a( x( + x y( + b* ) ) ) CRF = x( y + y( b( + ) ) ) a* LCRF1 = a( x( + x y( + y b( + ) ) ) ) LCRF2 = a( x + x( y + y( b( + ) ) ) ) LR = a( x( + y( b( + ) ) ) ) """) C = complexes['C'] L = complexes['L'] R = complexes['R'] T = complexes['T'] LC = complexes['LC'] LCF = complexes['LCF'] CR = complexes['CR'] CRF = complexes['CRF'] LCRF1 = complexes['LCRF1'] LR = complexes['LR'] path1 = PepperReaction([L, C], [LC], 'bind21') path1r = PepperReaction([LC], [L, C], 'open') path2 = PepperReaction([LC], [LCF], 'branch-3way') path3 = PepperReaction([R, LCF], [LCRF1], 'bind21') path4 = PepperReaction([LCRF1], [LR, T], 'branch-3way') enum = Enumerator(list(complexes.values())) enum.k_fast = float('inf') enum.k_slow = 0 enum.max_helix = True enum.enumerate() self.assertEqual(len(list(enum.reactions)), 22)
def test_interface_02(self): complexes, _ = read_pil(""" length a = 3 length n = 1 length b = 1 length c = 4 length ab = 4 X = a( b( c( + ) ) ) Y = ab( c( + ) ) Xf = a b( c( + ) ) a* Xff= a b c( + ) b* a* Xb = a( b( c + c* ) ) Y1 = ab c( + ) ab* Y2 = ab( c + c* ) """) X = complexes['X'] Y = complexes['Y'] Xf = complexes['Xf'] Xff = complexes['Xff'] Xb = complexes['Xb'] Y1 = complexes['Y1'] Y2 = complexes['Y2'] enum = Enumerator([X, Y], named_complexes=[X, Y, Xf, Xff, Xb, Y1, Y2]) enum.max_helix = False enum.dry_run() self.assertEqual(sorted(enum.complexes), sorted([X, Y])) self.assertEqual(sorted(enum.resting_complexes), sorted([X, Y])) self.assertEqual( sorted(r.representative for r in enum.resting_macrostates), sorted([X, Y])) enum.enumerate() assert len(list(enum.complexes)) == 16 with self.assertRaises(PeppercornUsageError) as e: enum.dry_run()
def test_max_helix_01(self): complexes, reactions = read_pil(""" length a = 15 length x = 15 length x1 = 15 length x2 = 15 length y = 15 length y1 = 15 length y2 = 15 length z = 15 length z1 = 15 length z2 = 15 # should be one reaction, is one A1 = x( y z + y( z( + ) ) ) A1_2 = x( y( z( + ) ) ) YZ = y z # should be one reactions, is one B1 = x1( x2( y1 y2 z1 z2 + y1( y2( z1( z2( + ) ) ) ) ) ) B1_2 = x1( x2( y1( y2( z1( z2( + ) ) ) ) ) ) YZ2 = y1 y2 z1 z2 # should be two reactions, is two A2 = x( y z + y( + z( + ) ) ) A2_1 = x( y( z + z( + ) ) ) #A2_2 = x( y( z( + ) ) ) # = A1_2 Y1 = y Z1 = z # should be two reactions, is two B2 = x1( x2( y1 y2 z1 z2 + y1( y2( + z1( z2( + ) ) ) ) ) ) B2_1 = x1( x2( y1( y2( z1 z2 + z1( z2( + ) ) ) ) ) ) Y2 = y1 y2 Z2 = z1 z2 # should be two reactions, is two C = x( y z + y( + a( + ) z( + ) ) ) C1 = x( y( z + a( + ) z( + ) ) ) r1 = a( + ) z """) A1 = complexes['A1'] A1_2 = complexes['A1_2'] YZ = complexes['YZ'] A2 = complexes['A2'] A2_1 = complexes['A2_1'] #A2_2 = complexes['A2_2'] Y1 = complexes['Y1'] Z1 = complexes['Z1'] enum = Enumerator([A1, A2]) enum.k_fast = 0 enum.k_slow = 0 enum.max_helix = True enum.enumerate() path1 = PepperReaction([A1], sorted([A1_2, YZ]), 'branch-3way') path2 = PepperReaction([A2], sorted([A2_1, Y1]), 'branch-3way') path3 = PepperReaction([A2_1], sorted([A1_2, Z1]), 'branch-3way') self.assertEqual(sorted(enum.reactions), sorted([path1, path2, path3])) B1 = complexes['B1'] B1_2 = complexes['B1_2'] YZ2 = complexes['YZ2'] B2 = complexes['B2'] B2_1 = complexes['B2_1'] Y2 = complexes['Y2'] Z2 = complexes['Z2'] enum = Enumerator([B1, B2]) enum.k_fast = 0 enum.k_slow = 0 enum.max_helix = True enum.enumerate() path1 = PepperReaction([B1], sorted([B1_2, YZ2]), 'branch-3way') path2 = PepperReaction([B2], sorted([B2_1, Y2]), 'branch-3way') path3 = PepperReaction([B2_1], sorted([B1_2, Z2]), 'branch-3way') self.assertEqual(sorted(enum.reactions), sorted([path1, path2, path3])) C = complexes['C'] enum = Enumerator([C]) enum.k_fast = 0 enum.k_slow = 0 enum.max_helix = True enum.enumerate() self.assertEqual(len(list(enum.reactions)), 2)