def test_bind_and_displace3way(self): complexes, reactions = read_pil(""" length a = 10 length b = 10 length c = 10 length t = 5 I = a b c J = b c C = b( c( + ) ) a* B = a( b c + b( c( + ) ) ) D = a( b( c( + ) ) ) """) I = complexes['I'] J = complexes['J'] C = complexes['C'] B = complexes['B'] D = complexes['D'] # DSD-pathway "bind21" path1 = PepperReaction([I, C], [B], 'bind21') # DSD-pathway "branch3way" path2 = PepperReaction([B], [D, J], 'branch-3way') enum = Enumerator(list(complexes.values())) enum.enumerate() self.assertEqual(sorted(enum.reactions), sorted([path1, path2]))
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_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 testLoop(self): complexes, _ = read_pil("C = 1 2 3() + 4") parts = [] domain_length = 0 complex = complexes['C'] # skip the closing helical domain for loc in [(0, 0), (0, 1), (0, 2), None, (1, 0)]: if loc is None: parts.append(None) continue domain = complex.get_domain(loc) parts.append((domain, complex.get_structure(loc), loc)) # we'll naively assume all domains have the same length for the # sake of this example domain_length = len(domain) # construct a loop from parts loop = Loop(parts) assert loop.bases == domain_length * 3 assert loop.stems == 1 assert loop.is_open
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_join_complexes_01(self): complexes, reactions = read_pil(""" length a = 10 length t = 5 S1 = a( + a t ) S2 = t* a* S3 = a( a( + t* a*( + ) ) + a( + ) ) X = a t a*( + ) + t* a* XB = a t( a*( + ) + ) a* Y = a( a( + a t a*( + ) + t* a*( + ) ) + a( + ) ) """) S1 = complexes['S1'] S2 = complexes['S2'] S3 = complexes['S3'] X = complexes['X'] Y = complexes['Y'] c, l1, l2 = join_complexes_21(S1, (1, 1), S2, (0, 0)) assert c is X assert l1 == (0, 1) assert l2 == (2, 0) n, n1, n2 = join_complexes_21(S2, (0, 0), S1, (1, 1)) assert n is c assert n1 == l1 assert n2 == l2 c, l1, l2 = join_complexes_21(S1, (1, 1), S3, (1, 0)) assert c is Y assert l1 == (1, 1) assert l2 == (3, 0) c, l1, l2 = join_complexes_21(S3, (1, 0), S1, (1, 1)) assert c is Y assert l1 == (1, 1) assert l2 == (3, 0)
def test_open1N_01(self): complexes, reactions = read_pil(""" length a = 8 length t = 5 X = a( t( + ) ) Y = a( t + t* ) Z = a t( + ) a* S1 = a t S2 = t* a* """) X = complexes['X'] Y = complexes['Y'] Z = complexes['Z'] S1 = complexes['S1'] S2 = complexes['S2'] rxnYS = PepperReaction([Y], [S1, S2], 'open') rxnXS = PepperReaction([X], [S1, S2], 'open') # max helix semantics ON -> no reactions vs dissociation out = open1N(Y, max_helix=True, release_11=7, release_1N=7) assert out == [] out = open1N(Y, max_helix=True, release_11=8, release_1N=8) assert out == [rxnYS] out = open1N(X, max_helix=True, release_11=13, release_1N=13) assert out == [rxnXS] rxnXY = PepperReaction([X], [Y], 'open') rxnXZ = PepperReaction([X], [Z], 'open') # max helix semantics OFF -> domains dissociate, but at most one at a time out = open1N(X, max_helix=False, release_11=7, release_1N=7) self.assertEqual(out, [rxnXY]) out = open1N(X, max_helix=False, release_11=8, release_1N=8) self.assertEqual(out, sorted([rxnXY, rxnXZ])) out = open1N(X, max_helix=False, release_11=13, release_1N=13) self.assertEqual(out, sorted([rxnXY, rxnXZ]))
def test_bind21_01(self): complexes, reactions = read_pil(""" length a = 10 length t = 5 S1 = a t S2 = t* a* X = a( t + t* ) Y = a t( + ) a* Z = a( t( + ) ) """) S1 = complexes['S1'] S2 = complexes['S2'] X = complexes['X'] Y = complexes['Y'] Z = complexes['Z'] singles = sorted([S1, S2]) rxn1 = PepperReaction([S2, S1], [X], 'bind21') rxn2 = PepperReaction([S1, S2], [Y], 'bind21') out = bind21(S1, S2, max_helix=False) #for o in out: print(o.kernel_string) self.assertEqual(out, sorted([rxn1, rxn2])) rxn3 = PepperReaction([S2, S1], [Z], 'bind21') out = bind21(S1, S2, max_helix=True) self.assertEqual(out, [rxn3])
def test_join_complexes_00(self): complexes, reactions = read_pil(""" length a = 10 length t = 5 S1 = a t S2 = t* a* """) S1 = complexes['S1'] S2 = complexes['S2'] c, l1, l2 = join_complexes_21(S1, (0, 1), S2, (0, 0)) assert c.kernel_string == 'a t + t* a*' assert l1 == (0, 1) assert l2 == (1, 0) n, n1, n2 = join_complexes_21(S2, (0, 0), S1, (0, 1)) assert n is c assert n1 == l1 assert n2 == l2 c, l1, l2 = join_complexes_21(S1, (0, 0), S2, (0, 1)) assert c.kernel_string == 'a t + t* a*' assert l1 == (0, 0) assert l2 == (1, 1) n, n1, n2 = join_complexes_21(S2, (0, 1), S1, (0, 0)) assert n is c assert n1 == l1 assert n2 == l2
def test_bind11_02(self): complexes, reactions = read_pil(""" length a = 10 length t = 5 S0 = a a t t* a* a* SG1 = a( a t t* ) a* SG2 = a a( t t* a* ) SG3 = a( a( t( ) ) ) SI1 = a( a t t* a* ) SI2 = a a( t t* ) a* SI3 = a a t( ) a* a* """) S0 = complexes['S0'] SG1 = complexes['SG1'] SG2 = complexes['SG2'] SG3 = complexes['SG3'] SI1 = complexes['SI1'] SI2 = complexes['SI2'] SI3 = complexes['SI3'] rg1 = PepperReaction([S0], [SG1], 'bind11') rg2 = PepperReaction([S0], [SG2], 'bind11') rg3 = PepperReaction([S0], [SG3], 'bind11') out = bind11(S0, max_helix=True) #for o in out: print(o.kernel_string) assert sorted(out) == sorted([rg1, rg2, rg3]) ri1 = PepperReaction([S0], [SI1], 'bind11') ri2 = PepperReaction([S0], [SI2], 'bind11') ri3 = PepperReaction([S0], [SI3], 'bind11') out = bind11(S0, max_helix=False) #for o in out: print(o.kernel_string) assert sorted(out) == sorted([rg1, rg2, ri1, ri2, ri3])
def test_4way_05(self): # Unconventional multi-state 4way junction, no end-dissociation complexes, reactions = read_pil(""" length a = 10 length b = 10 length c = 10 length x = 10 A1 = a( a*( b( + ) ) a*( x*( + ) ) b( c( + ) ) ) A2 = a( ) b( + ) a( a*( x*( + ) ) b( c( + ) ) ) A3 = a( a*( b( + ) a( ) x*( + ) ) b( c( + ) ) ) A4 = a( a*( b( + ) ) ) x*( + ) a( b( c( + ) ) ) """) A1 = complexes['A1'] A2 = complexes['A2'] A3 = complexes['A3'] A4 = complexes['A4'] path1 = PepperReaction([A1], [A2], 'branch-4way') path2 = PepperReaction([A1], [A3], 'branch-4way') path3 = PepperReaction([A1], [A4], 'branch-4way') output = branch_4way(A1, max_helix=False) self.assertEqual(output, sorted([path1, path2, path3])) path1 = PepperReaction([A1], [A2], 'branch-4way') path2 = PepperReaction([A1], [A3], 'branch-4way') path3 = PepperReaction([A1], [A4], 'branch-4way') output = branch_4way(A1, max_helix=True) self.assertEqual(output, sorted([path1, path2, path3]))
def test_named_complexes(self): complexes, reactions = read_pil(""" sequence t = GGAGCC sequence s = ATATAT sequence r = GCGCGC sequence d2 = GGCAAACAAG sequence d3 = CGGCAGAATT sequence a = CGCATTTGCC sequence b = TACCTTTTCC sequence c = CAAAGCCCTT A = t d2 s* d3 B = d2( d3( + ) s*( a* + a*( b*( c ) ) ) ) t* B2 = d2( d3( + ) s* a* + a*( b*( c ) ) s ) t* @ initial 0 M B3 = d2( d3( + ) s*( a*( + a* b*( c ) ) ) ) t* @ initial 0 M B4 = d2( d3( + ) s* a*( + a* b*( c ) ) s ) t* @ initial 0 M C = d2 d3( + ) s* a* @initial 0 M D = t( d2( s*( d3 + a*( b*( c ) ) ) ) ) @i 0 M E = d2 d3 @i 0 M F = t( d2( s*( d3( + ) s* a*( + a* b*( c ) ) ) ) ) @i 0 M G = t d2 s* d3( + ) s* a* @i 0 M """) A = complexes['A'] B = complexes['B'] F = complexes['F'] enum = Enumerator([A, B], named_complexes=[A, B, F]) enum.max_complex_count = 1000 enum.max_reaction_count = 5000 enum.enumerate() self.assertTrue( F in [rms.representative for rms in enum.resting_macrostates])
def peppercorn(kernelstring, name, condensed=True, conc='nM', max_complex_size = 10, release_cutoff = 13, k_fast=0): """ A wrapper for peppercorn. """ #print kernelstring complexes, reactions = read_pil(kernelstring) enum = Enumerator(complexes.values(), reactions) enum.release_cutoff = release_cutoff enum.max_complex_size = max_complex_size enum.k_fast = k_fast enum.enumerate() #condensed = False if condensed: enumRG = PepperCondensation(enum) enumRG.condense() detailed = not condensed #write_kernel(enum, sys.stdout, detailed, condensed) with open(name + '.crn', 'w') as crn: write_kernel(enum, crn, detailed, condensed, molarity=conc) if condensed: return enumRG, name + '.crn' else : return enum, name + '.crn'
def test_cooperative_binding_fail(self): complexes, reactions = read_pil(""" # File generated by peppercorn-v0.5.0 # Domain Specifications length a = 5 length b = 5 length x = 10 length y = 10 # Resting-set Complexes C = x( y( + b* ) ) a* CR = x( y( + y b( + ) ) ) a* CRF = x( y + y( b( + ) ) ) a* L = a x LC = a( x + x( y( + b* ) ) ) LCF = a( x( + x y( + b* ) ) ) LR = a( x( + y( b( + ) ) ) ) R = y b T = x y # Transient Complexes LCR = a( x + x( y( + y b( + ) ) ) ) LCRF1 = a( x( + x y( + y b( + ) ) ) ) LCRF2 = a( x + x( y + y( b( + ) ) ) ) # Detailed Reactions reaction [bind21 = 1.5e+06 /M/s ] C + L -> LC reaction [bind21 = 1.5e+06 /M/s ] C + R -> CR reaction [open = 20 /s ] CR -> C + R reaction [branch-3way = 30 /s ] CR -> CRF reaction [branch-3way = 30 /s ] CRF -> CR reaction [bind21 = 1.5e+06 /M/s ] L + CR -> LCR reaction [bind21 = 1.5e+06 /M/s ] L + CRF -> LCRF2 reaction [open = 20 /s ] LC -> C + L reaction [branch-3way = 30 /s ] LC -> LCF reaction [branch-3way = 30 /s ] LCF -> LC reaction [branch-3way = 30 /s ] LCR -> LCRF1 reaction [branch-3way = 30 /s ] LCR -> LCRF2 reaction [branch-3way = 30 /s ] LCRF1 -> LCR reaction [branch-3way = 30 /s ] LCRF1 -> T + LR reaction [branch-3way = 30 /s ] LCRF2 -> LCR reaction [branch-3way = 30 /s ] LCRF2 -> T + LR reaction [bind21 = 1.5e+06 /M/s ] R + LC -> LCR reaction [bind21 = 1.5e+06 /M/s ] R + LCF -> LCRF1 """) enum = Enumerator(complexes.values()) enum.enumerate() # or enum.dry_run() enumRG = PepperCondensation(enum) # TODO: It should raise an error here, saying that the condensed graph # is disconnected! #with self.assertRaises(c.CondensationError): enumRG.condense() self.assertEqual(enumRG.condensed_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_3way_remote(self): """ A remote 3way branch migration reaction. """ # INPUT complexes, reactions = read_pil(""" length a = 10 length b = 10 length c = 10 length x = 10 length y = 10 length z = 10 X = a( b x y z + x( y( z( c( + ) ) ) ) ) I1 = a( b x( y z + x y( z( c( + ) ) ) ) ) I2 = a( b x( y( z + x y z( c( + ) ) ) ) ) Y = a( b x( y( z( + x y z c( + ) ) ) ) ) """) reactant = complexes['X'] inter1 = complexes['I1'] inter2 = complexes['I2'] product = complexes['Y'] # ~~~~~~~~~~~~~ # # OUTPUT REMOTE # # ~~~~~~~~~~~~~ # forward = PepperReaction([reactant], [product], 'branch-3way') backward = PepperReaction([product], [reactant], 'branch-3way') output = branch_3way(reactant, max_helix=True, remote=True) self.assertEqual(output, [forward]) output = branch_3way(product, max_helix=True, remote=True) self.assertEqual(output, [backward]) forward = PepperReaction([inter1], [product], 'branch-3way') backward = PepperReaction([inter1], [reactant], 'branch-3way') output = branch_3way(inter1, max_helix=True, remote=True) self.assertEqual(sorted(output), sorted([backward, forward])) # ~~~~~~~~~~~~~~~~~~~~ # # OUTPUT REJECT REMOTE # # ~~~~~~~~~~~~~~~~~~~~ # backward = PepperReaction([product], [reactant], 'branch-3way') output = branch_3way(reactant, max_helix=True, remote=False) self.assertEqual(output, []) output = branch_3way(product, max_helix=True, remote=False) self.assertEqual(output, [backward]) forward = PepperReaction([inter1], [product], 'branch-3way') backward = PepperReaction([inter1], [reactant], 'branch-3way') output = branch_3way(inter1, max_helix=True, remote=False) self.assertEqual(sorted(output), sorted([forward, backward]))
def test_4way_01(self): complexes, reactions = read_pil(""" length t0 = short length d3 = long length d4 = long A1 = t0*( d3*( d4*( + ) ) + d3*( t0* d3*( d4*( + ) ) + ) ) A2 = t0*( d3*( d4*( + ) d3( + ) t0* d3*( d4*( + ) ) + ) ) """) A1 = complexes['A1'] A2 = complexes['A2'] rxn = PepperReaction([A1], [A2], 'branch-4way') out = branch_4way(A1, max_helix=True, remote=True) assert out == [rxn]
def test_condense_simple(self): complexes, reactions = read_pil(""" # File generated by peppercorn-v0.5.0 # Domain Specifications length d1 = 15 length t0 = 5 # Resting-set Complexes c1 = t0 d1 c2 = d1( + ) t0* c4 = t0( d1( + ) ) c5 = d1 # Transient Complexes c3 = t0( d1 + d1( + ) ) # Detailed Reactions reaction [bind21 = 100 /M/s ] c1 + c2 -> c3 reaction [open = 50 /s ] c3 -> c1 + c2 reaction [branch-3way = 50 /s ] c3 -> c4 + c5 """) # (rs1) c1 c4 (rs3) # \ / # <---> c3 ----> # / \ # (rs2) c2 c5 (rs4) enum = Enumerator(complexes.values(), reactions) enum.enumerate() enum.condense() for con in enum.condensed_reactions: assert con.rate_constant[0] == 50 del enum # old interface ... c1 = PepperMacrostate([complexes['c1']]) c2 = PepperMacrostate([complexes['c2']]) c4 = PepperMacrostate([complexes['c4']]) c5 = PepperMacrostate([complexes['c5']]) cond_react = PepperReaction([c1, c2], [c4, c5], 'condensed') cond_react.rate_constant = 20, None enum = Enumerator(complexes.values(), reactions) enum.dry_run() enumRG = PepperCondensation(enum) enumRG.condense() for con in enumRG.condensed_reactions: assert con.rate_constant[0] == 20
def test_3way_01(self): complexes, reaction = read_pil(""" length d11 = long length d12 = long length d7 = long length t6 = short length t8 = short A = d11 t6( d7 t8 + d12( t6( d7 t8 + ) ) ) d11*( t8*( + d7 ) ) B = d11( t6( d7 t8 + d12( t6( d7 t8 + ) ) ) ) t8*( + d7 ) d11 """) A = complexes['A'] B = complexes['B'] rxn = PepperReaction([A], [B], 'branch-3way') out = branch_3way(A, max_helix=True) assert out == [rxn]
def test_interface_01(self): PepperComplex.PREFIX = 'enum' complexes, reactions = read_pil(""" # Domain Specifications length a = 8 length b = 8 length c = 8 length d2 = 8 length d3 = 8 length t = 4 # Resting-set Complexes e0 = d2( d3( + ) a* + a*( b*( c ) ) ) t* e12 = d2 d3( + ) a* e13 = t( d2( d3 + a*( b*( c ) ) ) ) e21 = d2 d3 e22 = t( d2( d3( + ) a*( + a* b*( c ) ) ) ) e27 = t( d2( d3( + ) a* + a*( b*( c ) ) ) ) gate = d2( d3( + ) a*( + a* b*( c ) ) ) t* t23 = t d2 d3 # Transient Complexes e5 = t( d2 d3 + d2( d3( + ) a*( + a* b*( c ) ) ) ) e7 = t( d2 d3 + d2( d3( + ) a* + a*( b*( c ) ) ) ) e18 = t( d2( d3 + d2 d3( + ) a*( + a* b*( c ) ) ) ) # Detailed Reactions reaction [bind21 = 1.2e+06 /M/s ] e0 + t23 -> e7 reaction [branch-3way = 0.122307 /s ] e0 -> gate reaction [branch-3way = 41.6667 /s ] e5 -> e7 reaction [branch-3way = 41.6667 /s ] e5 -> e18 reaction [open = 306.345 /s ] e5 -> t23 + gate reaction [open = 306.345 /s ] e7 -> e0 + t23 reaction [branch-3way = 0.122307 /s ] e7 -> e5 reaction [branch-3way = 41.6667 /s ] e7 -> e12 + e13 reaction [branch-3way = 0.122307 /s ] e18 -> e5 reaction [branch-3way = 41.6667 /s ] e18 -> e12 + e13 reaction [branch-3way = 0.122307 /s ] e18 -> e22 + e21 reaction [branch-3way = 41.6667 /s ] e22 -> e27 reaction [branch-3way = 0.122307 /s ] e27 -> e22 reaction [branch-3way = 41.6667 /s ] gate -> e0 reaction [bind21 = 1.2e+06 /M/s ] t23 + gate -> e5 """) enum = Enumerator(complexes.values(), reactions) enum.release_cutoff = 7 enum.enumerate() self.assertEqual(sorted(enum.reactions), sorted(reactions))
def test_4way_reject_remote(self): # Standard 4way junction, no end-dissociation complexes, reactions = read_pil(""" length a = 10 length b = 10 length c = 10 length d = 10 length x = 10 length y = 10 length z = 10 A0 = a( x( y( z( b( + ) ) ) ) c*( + ) x( y( z( d( + ) ) ) ) ) A1 = a( x( y( z( b( + ) ) ) x*( c*( + ) ) y( z( d( + ) ) ) ) ) A2 = a( x( y( z( b( + ) ) y*( x*( c*( + ) ) ) z( d( + ) ) ) ) ) A3 = a( x( y( z( b( + ) z*( y*( x*( c*( + ) ) ) ) d( + ) ) ) ) ) """) A0 = complexes['A0'] A1 = complexes['A1'] A2 = complexes['A2'] A3 = complexes['A3'] path1 = PepperReaction([A1], [A3], 'branch-4way') path2 = PepperReaction([A1], [A0], 'branch-4way') output = branch_4way(A1, max_helix=True, remote=False) self.assertEqual(output, sorted([path1, path2])) path1 = PepperReaction([A2], [A0], 'branch-4way') path2 = PepperReaction([A2], [A3], 'branch-4way') output = branch_4way(A2, max_helix=True, remote=False) self.assertEqual(output, sorted([path1, path2])) path = PepperReaction([A3], [A0], 'branch-4way') output = branch_4way(A3, max_helix=True, remote=False) self.assertEqual(output, [path]) path1 = PepperReaction([A2], [A0], 'branch-4way') path2 = PepperReaction([A2], [A3], 'branch-4way') output = branch_4way(A2, max_helix=True, remote=False) self.assertEqual(output, sorted([path1, path2])) path1 = PepperReaction([A1], [A3], 'branch-4way') path2 = PepperReaction([A1], [A0], 'branch-4way') output = branch_4way(A1, max_helix=True, remote=True) self.assertEqual(output, sorted([path1, path2])) path = PepperReaction([A3], [A0], 'branch-4way') output = branch_4way(A3, max_helix=True, remote=False) self.assertEqual(output, [path])
def test_3way_02(self): complexes, reactions = read_pil(""" length b = 7 A = b( b*( b b*( + ) b* ) ) B = b( b*( b( ) + b b* ) ) C = b( b*( ) b*( + ) b* b ) D = b( b*( b b* + b( ) ) ) """) A = complexes['A'] B = complexes['B'] C = complexes['C'] D = complexes['D'] rxn1 = PepperReaction([A], [B], 'branch-3way') rxn2 = PepperReaction([A], [C], 'branch-3way') rxn3 = PepperReaction([A], [D], 'branch-3way') out = branch_3way(A, max_helix=False) assert sorted(out) == sorted([rxn1, rxn2, rxn3])
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_read_pil_01(self): complexes, reactions = read_pil( """ # Domains (12) sequence a = NNNNNN sequence b = NNNNNN sequence c = NNNNNN sequence x = NNNNNN sequence y = NNNNNN sequence z = NNNNNN # Resting complexes (8) A = a x( b( y( z* c* ) ) ) @i 1e-08 M B = b y( c( z( x* a* ) ) ) @i 1e-08 M C = c z( a( x( y* b* ) ) ) @i 1e-08 M I = y* b* x* a* @i 1e-08 M IA = a( x( b( y( z* c* y* b* x* + ) ) ) ) @i 0.0 M IAB = y*( b*( x*( a*( + ) ) ) ) z*( c*( y*( b*( x* + ) ) ) ) x* a* z* c* y* @i 0.0 M IABC = y*( b*( x*( a*( + ) ) ) ) z*( c*( y*( b*( x* + ) ) ) ) x*( a*( z*( c*( y* + ) ) ) ) y* b* x* a* z* @i 0.0 M ABC = a( x( b( y( z*( c*( y*( b*( x* + ) ) ) ) x*( a*( z*( c*( y* + ) ) ) ) ) ) ) ) z* @i 0.0 M # Resting macrostates (8) macrostate A = [A] macrostate B = [B] macrostate C = [C] macrostate I = [I] macrostate IA = [IA] macrostate IAB = [IAB] macrostate IABC = [IABC] macrostate ABC = [ABC] # Condensed reactions (10) reaction [condensed = 1.66666e+06 /M/s ] A + I -> IA reaction [condensed = 1.66666e+06 /M/s ] IA + B -> IAB reaction [condensed = 1.66646e+06 /M/s ] IAB + C -> IABC reaction [condensed = 0.0261637 /s ] IABC -> ABC + I """) # A preliminary interface to start testing prototype functions. #a, b, c = dom['a'], dom['b'], dom['c'] #assert a is PepperDomain('a') #assert b is PepperDomain('b') #assert c is PepperDomain('c') assert PepperComplex(None, None, 'IA').kernel_string == 'a( x( b( y( z* c* y* b* x* + ) ) ) )'
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_4way_03(self): complexes, reactions = read_pil(""" # Domain Specifications length d1 = 15 length d2 = 15 length d3 = 15 length d4 = 15 length d5 = 15 length d6 = 15 length t0 = 6 BUG = d4*( t0* + ) t0( + ) d4*( t0*( + ) ) FIX = d4*( t0* + d4( t0( + ) ) t0*( + ) ) """) BUG = complexes['BUG'] FIX = complexes['FIX'] rxn = PepperReaction([BUG], [FIX], 'branch-4way') output = branch_4way(BUG, max_helix=True, remote=True) self.assertEqual(output, [rxn])
def test_seesaw_leak(self): complexes, reactions = read_pil(""" # Domain specifications length c = 2 length s1 = 11 length s2 = 11 length s3 = 11 length s4 = 11 length t = 3 # Resting complexes G_g2_w2_3 = c s3 c( t( c( s2( c( + c* t* ) ) ) ) ) G_w4_2_g2 = c( s2( c( t( c( s4 c + ) ) ) ) ) t* c* I12_223 = c s2 c t( c( s1 c + ) ) c*( s2*( c*( t*( c*( + c s3 ) ) ) ) ) B12_223 = c( s2( c( t( c( s1 c + ) ) ) ) ) t*( c*( + c s3 ) ) c s2 c I12_422 = c s2 c( t( c s1 c + c( s2( c( t( c( s4 c + ) ) ) ) ) ) ) w1_2 = c s2 c t c s1 c w2_3 = c s3 c t c s2 c w4_2 = c s2 c t c s4 c """) G223 = complexes['G_g2_w2_3'] G422 = complexes['G_w4_2_g2'] w12 = complexes['w1_2'] w23 = complexes['w2_3'] w42 = complexes['w4_2'] I12_223 = complexes['I12_223'] I12_422 = complexes['I12_422'] out = bind21(w12, G223, max_helix=True) self.assertEqual(len(out), 4) self.assertTrue(I12_223 in r.products for r in out) out = bind21(w12, G422, max_helix=True) self.assertEqual(len(out), 4) self.assertTrue(I12_422 in r.products for r in out) out = branch_3way(I12_223, max_helix=True) self.assertEqual(len(out), 4) self.assertTrue(B12_422 in r.products for r in out) out = branch_3way(I12_422, max_helix=True) assert len(out) == 4
def test_open1N_02(self): # NOTE this used to be a test for breathing ... # Should release-cutoff of 4 mean: # "max-helix-semantics up to length 4"? complexes, reactions = read_pil(""" length a = 3 length b = 1 length c = 4 length ab = 4 X = a( b( c( + ) ) ) Y = ab( c( + ) ) S1 = a b c S2 = c* b* a* X1 = a b( c( + ) ) a* X2 = a( b c( + ) b* ) X3 = a( b( c + c* ) ) Y1 = ab c( + ) ab* Y2 = ab( c + c* ) """) X = complexes['X'] Y = complexes['Y'] S1 = complexes['S1'] S2 = complexes['S2'] X1 = complexes['X1'] X2 = complexes['X2'] X3 = complexes['X3'] Y1 = complexes['Y1'] Y2 = complexes['Y2'] rxn1 = PepperReaction([X], [X1], 'open') rxn2 = PepperReaction([X], [X2], 'open') rxn3 = PepperReaction([X], [X3], 'open') out = open1N(X, max_helix=False, release_11=6, release_1N=6) assert sorted(out) == sorted([rxn1, rxn2, rxn3]) rxn4 = PepperReaction([X], [S1, S2], 'open') out = open1N(X, max_helix=True, release_11=8, release_1N=8) assert out == [rxn4] out = open1N(Y, max_helix=True, release_11=6, release_1N=6) assert out == []
def testLoop_fail(self): complexes, _ = read_pil("C = 1 2 3() + 4") parts = [] domain_length = 0 complex = complexes['C'] # do NOT skip the closing helical domain for loc in [(0, 0), (0, 1), (0, 2), (0, 3), None, (1, 0)]: if loc is None: parts.append(None) continue domain = complex.get_domain(loc) parts.append((domain, complex.get_structure(loc), loc)) # construct a loop from parts with self.assertRaises(PeppercornUsageError): loop = Loop(parts)
def test_3way_multiple_choice_02(self): complexes, reactions = read_pil(""" length a = 10 length b = 10 length c = 10 length x = 10 length y = 10 length z = 10 N = a( x( b x y + y( z( + ) ) ) ) P1 = a( x b x( y + y( z( + ) ) ) ) P2 = a( x( b x y( + y z( + ) ) ) ) """) N = complexes['N'] P1 = complexes['P1'] P2 = complexes['P2'] forward1 = PepperReaction([N], [P1], 'branch-3way') forward2 = PepperReaction([N], [P2], 'branch-3way') output = branch_3way(N, max_helix=True, remote=True) self.assertEqual(sorted(output), sorted([forward1, forward2]))