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