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_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 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_peppercorn_interface(self):
""" Make sure peppercorn.utils did not change """
t0 = peputils.Domain('t0', 5, sequence='H'*5)
t0_ = peputils.Domain('t0', 5, sequence='D'*5, is_complement=True)
d1 = peputils.Domain('d1', 15, sequence='H'*15)
d1_ = peputils.Domain('d1', 15, sequence='D'*15, is_complement=True)
domains = [t0,t0_,d1,d1_]
s0 = peputils.Strand('s0', [t0, d1])
s1 = peputils.Strand('s1', [d1])
s2 = peputils.Strand('s2', [d1_, t0_])
strands = [s0,s1,s2]
c1s = peputils.parse_dot_paren('..')
c1 = peputils.Complex('c1', [s0], c1s)
c1.check_structure()
c2s = peputils.parse_dot_paren('(+).')
c2 = peputils.Complex('c2', [s1,s2], c2s)
c2.check_structure()
complexes = [c1,c2]
enum = Enumerator(domains, strands, complexes)
enum.enumerate()
###########################
# Get full output CRN
reactions = enum.reactions
self.assertEqual(len(reactions), 3)
r1_kernel = 't0 d1 + d1( + ) t0* -> t0( d1 + d1( + ) )'
r2_kernel = 't0( d1 + d1( + ) ) -> t0( d1( + ) ) + d1'
r3_kernel = 't0( d1 + d1( + ) ) -> t0 d1 + d1( + ) t0*'
p_cntr = Counter()
r_cntr = Counter()
for r in sorted(reactions):
#print r.kernel_string()
for cx in r.reactants :
p_cntr += Counter(map(str, cx.strands))
for cx in r.products:
r_cntr += Counter(map(str, cx.strands))
self.assertEqual(p_cntr, r_cntr)
self.assertTrue(r.kernel_string() in [r1_kernel, r2_kernel, r3_kernel])
###########################
# Get condensed output CRN
condensed = condense_resting_states(enum, compute_rates=True, k_fast = 0.)
reactions = condensed['reactions']
self.assertEqual(len(reactions), 1)
result_kernel = 't0 d1 + d1( + ) t0* -> t0( d1( + ) ) + d1'
self.assertEqual(reactions[0].kernel_string(), result_kernel)
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_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_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_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_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_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_fate_example(self):
# TODO: needs more testing, also remove the PREFIX part and replace with
# non-auto-prefix complex names...
PepperComplex.PREFIX = 'enum'
complexes, reactions = read_pil("""
# File generated by peppercorn-v0.5.0
# 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
""")
gate = complexes['gate']
t23 = complexes['t23']
enum = Enumerator(complexes.values())
enum.enumerate() # or enum.dry_run()
self.assertEqual(sorted(enum.reactions), sorted(reactions))
"""
# Resting sets
state re0 = [e0, gate]
state re12 = [e12]
state re13 = [e13]
state re21 = [e21]
state re22 = [e22, e27]
state rt23 = [t23]
reaction [condensed = 287342 /M/s ] re0 + rt23 -> re13 + re12
reaction [condensed = 2.45499 /M/s ] re0 + rt23 -> re21 + re22
"""
enumRG = PepperCondensation(enum)
enumRG.condense()
self.assertEqual(len(enumRG.resting_sets), 6)
self.assertEqual(len(enumRG.condensed_reactions), 2)
PepperComplex.PREFIX = 'e'
def test_sarma_fig4_v1(self):
complexes, reactions = read_pil("""
# File generated by peppercorn-v0.5.0
# Domain Specifications
length d1 = 15
length d2 = 15
length d3 = 5
length d4 = 15
length d5 = 5
length d6 = 15
length d7 = 5
# Resting-set Complexes
bot = d1*
com1 = d3*( d2*( d1*( d5 d6 + ) ) ) d4
com2 = d6( d7( + ) ) d5* d1 d2 d3
e6 = d1 d2 d3 d4
e11 = d6 d7
e17 = d7* d6*( d5*( d1( d2( d3( + ) ) ) ) )
e27 = d1*( + )
e29 = d1*( + d6( d7( + ) ) d5* ) d2 d3
e31 = d1*( + ) d2 d3 d4
top = d1
# Transient Complexes
e1 = d6( d7( + ) ) d5*( d1 d2 d3 + d1( d2( d3( d4 + ) ) ) ) d6
e7 = d6( d7( + ) ) d5*( d1( d2( d3( + ) ) ) ) d6
e8 = d6 d7( + ) d6*( d5*( d1 d2 d3 + d1( d2( d3( d4 + ) ) ) ) )
e10 = d7* d6*( d5*( d1 d2 d3 + d1( d2( d3( d4 + ) ) ) ) )
e15 = d6 d7( + ) d6*( d5*( d1( d2( d3( + ) ) ) ) )
e33 = d6( d7( + ) ) d5*( d1( d2 d3 + ) + d1( d2( d3( d4 + ) ) ) ) d6
e37 = d6 d7( + ) d6*( d5*( d1( d2 d3 + ) + d1( d2( d3( d4 + ) ) ) ) )
e38 = d6( d7( + ) ) d5*( d1( d2 d3 + d1*( + ) d2( d3( d4 + ) ) ) ) d6
e43 = d6 d7( + ) d6*( d5*( d1( d2 d3 + d1*( + ) d2( d3( d4 + ) ) ) ) )
e47 = d7* d6*( d5*( d1( d2 d3 + d1*( + ) d2( d3( d4 + ) ) ) ) )
e58 = d7* d6*( d5*( d1( d2 d3 + ) + d1( d2( d3( d4 + ) ) ) ) )
# Detailed Reactions
reaction [bind21 = 4.5e+06 /M/s ] bot + top -> e27
reaction [bind21 = 1.5e+06 /M/s ] com1 + e29 -> e33
reaction [bind21 = 4.5e+06 /M/s ] com2 + bot -> e29
reaction [bind21 = 1.5e+06 /M/s ] com2 + com1 -> e1
reaction [open = 21.7122 /s ] e1 -> com2 + com1
reaction [branch-3way = 9.52381 /s ] e1 -> e6 + e7
reaction [branch-3way = 22.2222 /s ] e1 -> e8
reaction [bind21 = 4.5e+06 /M/s ] e6 + bot -> e31
reaction [branch-3way = 22.2222 /s ] e7 -> e15
reaction [branch-3way = 22.2222 /s ] e8 -> e1
reaction [branch-3way = 9.52381 /s ] e8 -> e6 + e15
reaction [open = 21.7122 /s ] e8 -> e10 + e11
reaction [branch-3way = 9.52381 /s ] e10 -> e6 + e17
reaction [branch-3way = 22.2222 /s ] e15 -> e7
reaction [open = 21.7122 /s ] e15 -> e17 + e11
reaction [bind21 = 1.5e+06 /M/s ] e17 + e11 -> e15
reaction [open = 21.7122 /s ] e33 -> com1 + e29
reaction [branch-3way = 22.2222 /s ] e33 -> e37
reaction [branch-4way = 0.000623053 /s ] e33 -> e38
reaction [branch-3way = 22.2222 /s ] e37 -> e33
reaction [branch-4way = 0.000623053 /s ] e37 -> e43
reaction [open = 21.7122 /s ] e37 -> e58 + e11
reaction [branch-3way = 16.6667 /s ] e38 -> e7 + e31
reaction [branch-4way = 0.000623053 /s ] e38 -> e33
reaction [branch-3way = 22.2222 /s ] e38 -> e43
reaction [open = 21.7122 /s ] e43 -> e11 + e47
reaction [branch-3way = 16.6667 /s ] e43 -> e15 + e31
reaction [branch-4way = 0.000623053 /s ] e43 -> e37
reaction [branch-3way = 22.2222 /s ] e43 -> e38
reaction [branch-3way = 16.6667 /s ] e47 -> e17 + e31
reaction [branch-4way = 0.000623053 /s ] e47 -> e58
reaction [branch-4way = 0.000623053 /s ] e58 -> e47
""")
enum = Enumerator(complexes.values(), reactions)
enum.enumerate()
self.assertEqual(sorted(enum.reactions), sorted(reactions))
enumRG = PepperCondensation(enum)
enumRG.condense()
def test_zhang_cooperative_binding(self):
complexes, reactions = read_pil("""
# Figure 1 of David Yu Zhang, "Cooperative hybridization of oligonucleotides", JACS, 2012
# File generated by peppercorn-v0.5.0
# Domain Specifications
length d1 = 8
length d2 = 18
length d3 = 18
length d4 = 8
# Resting-set Complexes
C1 = d2( d3( + d4* ) ) d1*
L1 = d1( d2 + d2( d3( + d4* ) ) )
L2 = d1( d2( + d2 d3( + d4* ) ) )
Out = d2 d3
R1 = d2( d3( + d3 d4( + ) ) ) d1*
R2 = d2( d3 + d3( d4( + ) ) ) d1*
T1 = d1 d2
T2 = d3 d4
Waste = d1( d2( + d3( d4( + ) ) ) )
# Transient Complexes
L1R1 = d1( d2 + d2( d3( + d3 d4( + ) ) ) )
L1R2 = d1( d2 + d2( d3 + d3( d4( + ) ) ) )
L2R1 = d1( d2( + d2 d3( + d3 d4( + ) ) ) )
# Detailed Reactions
reaction [bind21 = 2.4e+06 /M/s ] C1 + T2 -> R1
reaction [bind21 = 2.4e+06 /M/s ] L1 + T2 -> L1R1
reaction [branch-3way = 18.5185 /s ] L1 -> L2
reaction [branch-3way = 18.5185 /s ] L1R1 -> L1R2
reaction [branch-3way = 18.5185 /s ] L1R1 -> L2R1
reaction [branch-3way = 18.5185 /s ] L1R2 -> L1R1
reaction [branch-3way = 18.5185 /s ] L1R2 -> Waste + Out
reaction [bind21 = 2.4e+06 /M/s ] L2 + T2 -> L2R1
reaction [branch-3way = 18.5185 /s ] L2 -> L1
reaction [branch-3way = 18.5185 /s ] L2R1 -> L1R1
reaction [branch-3way = 18.5185 /s ] L2R1 -> Waste + Out
reaction [branch-3way = 18.5185 /s ] R1 -> R2
reaction [branch-3way = 18.5185 /s ] R2 -> R1
reaction [bind21 = 2.4e+06 /M/s ] T1 + C1 -> L1
reaction [bind21 = 2.4e+06 /M/s ] T1 + R1 -> L1R1
reaction [bind21 = 2.4e+06 /M/s ] T1 + R2 -> L1R2
""")
enum = Enumerator(complexes.values(), reactions)
enum.k_fast = 0.01
enum.release_cutoff = 10
enum.enumerate() # or enum.dry_run()
enumRG = PepperCondensation(enum)
enumRG.condense()
"""
macrostate rC1 = [C1]
macrostate rL2 = [L2, L1]
macrostate rOut = [Out]
macrostate rR1 = [R1, R2]
macrostate rT1 = [T1]
macrostate rT2 = [T2]
macrostate rWaste = [Waste]
reaction [condensed = 2.4e+06 /M/s ] rT1 + rC1 -> rL2
reaction [condensed = 2.4e+06 /M/s ] rL2 + rT2 -> rWaste + rOut
reaction [condensed = 2.4e+06 /M/s ] rC1 + rT2 -> rR1
reaction [condensed = 2.4e+06 /M/s ] rT1 + rR1 -> rWaste + rOut
reaction [condensed = 0.00316623 /s ] rL2 -> rT1 + rC1
reaction [condensed = 0.00316623 /s ] rR1 -> rC1 + rT2
"""
try:
L1 = complexes['L1']
L2 = complexes['L2']
L = PepperMacrostate([L1, L2])
except SingletonError as err:
L = err.existing
O = PepperMacrostate([complexes['Out']])
W = PepperMacrostate([complexes['Waste']])
T = PepperMacrostate([complexes['T2']])
# calculated by hand...
cr1 = PepperReaction([L, T], [W, O], 'condensed')
assert cr1 in enumRG.condensed_reactions
assert cr1.rate_constant == (2.4e6, '/M/s')
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)