def solve_mb(reverse, N_points, K1, K2, K3, n_oligL, n_oligP, Pt, Lt):
"""
Solve mass balance equations for the Assembly AutoInhibition model.
Returns a tuple of arrays for the free protein and free ligand concentrations.
"""
p = np.zeros(N_points)
l = np.zeros(N_points)
# if reverse titration setup swap titrant and stationary
if (reverse):
tmp = Pt
Pt = Lt
Lt = tmp
p[0] = Pt[0]
l[0] = Lt[0]
for i in range(N_points - 1):
# mass balance equations
def equations(x):
p, l = x
return [p + K1*p*l + K1*K2*p*l**2. + n_oligP*(K3**(n_oligL+n_oligP-1))*p**n_oligP*l**n_oligL - Pt[i+1], \
l + K1*p*l + 2.*K1*K2*p*l**2. + n_oligL*(K3**(n_oligL+n_oligP-1))*p**n_oligP*l**n_oligL - Lt[i+1]]
sol = OptimizeResult(success=False)
ptmp = -1
ltmp = -1
j = 1.
# try to solve using previous free concentrations as initial guesses. Maximum number of iterations is large as gradient may be very shallow
sol = solve_mass_balance(equations, (p[i], l[i]),
method='lm',
options={'maxiter': 2000})
ptmp, ltmp = sol.x
# if no solution try to solve with different initial conditions and solver options
if (not sol.success):
sol = solve_mass_balance(equations, (Pt[i], Lt[i]),
method='lm',
options={
'factor': 1,
'maxiter': 8000
})
ptmp, ltmp = sol.x
# if still no solution...bugger
if (not sol.success):
print("ERROR: Could not find solution...")
l[i + 1] = ltmp
p[i + 1] = ptmp
return (p, l)
def solve_mb(N_points, K_AB, K_AL, K_BL, a, At, Bt, Lt):
"""
Solve mass balance equations for the model.
[A]t = [A] + K_AB*[A]*[B] + K_AL*[A]*[L] + a*K_AB*K_AL*K_BL*[A]*[B]*[L]
[B]t = [B] + K_AB*[A]*[B] + K_BL*[B]*[L] + a*K_AB*K_AL*K_BL*[A]*[B]*[L]
[L]t = [L] + K_AL*[A]*[L] + K_BL*[B]*[L] + a*K_AB*K_AL*K_BL*[A]*[B]*[L]
"""
A = np.zeros(N_points)
B = np.zeros(N_points)
L = np.zeros(N_points)
for i in range(N_points):
# mass balance equations
def equations(x):
A, B, L = x
return [A + K_AB*A*B + K_AL*A*L + a*K_AB*K_AL*K_BL*A*B*L - At[i], \
B + K_AB*A*B + K_BL*B*L + a*K_AB*K_AL*K_BL*A*B*L - Bt[i], \
L + K_AL*A*L + K_BL*B*L + a*K_AB*K_AL*K_BL*A*B*L - Lt[i]]
sol = OptimizeResult(success=False)
Atmp = -1
Btmp = -1
Ltmp = -1
j = 1.
# try to solve using total concentrations as initial guesses. Maximum number of iterations is large as gradient may be very shallow
sol = solve_mass_balance(equations, (At[i], Bt[i], Lt[i]),
method='lm',
options={'maxiter': 2000})
Atmp, Btmp, Ltmp = sol.x
# if no solution try to solve with different initial conditions and solver options
if (not sol.success and i != 0):
sol = solve_mass_balance(equations, (A[i - 1], B[i - 1], L[i - 1]),
method='lm',
options={
'factor': 1,
'maxiter': 8000
})
Atmp, Btmp, Ltmp = sol.x
# if still no solution...bugger
if (not sol.success):
print("ERROR: Could not find solution...")
A[i] = Atmp
B[i] = Btmp
L[i] = Ltmp
return (A, B, L)
def solve_mb(reverse, N_points, K1, K2, K3, m, n_oligL, n_oligP, Pt, Lt):
"""
Solve mass balance equations for the Assembly AutoInhibition model.
Returns a tuple of arrays for the free protein and free ligand concentrations.
"""
p = np.zeros(N_points)
l = np.zeros(N_points)
# if reverse titration setup swap titrant and stationary
if(reverse):
tmp = Pt
Pt = Lt
Lt = tmp
p[0] = Pt[0]
l[0] = Lt[0]
for i in range(N_points-1):
# mass balance equations
def equations(x):
p,l = x
return [p + K1*p*l + K1*K2**(m-1.)*p*l**m + n_oligP*(K3**(n_oligL+n_oligP-1))*p**n_oligP*l**n_oligL - Pt[i+1], \
l + K1*p*l + m*K1*K2**(m-1.)*p*l**m + n_oligL*(K3**(n_oligL+n_oligP-1))*p**n_oligP*l**n_oligL - Lt[i+1]]
sol = OptimizeResult(success=False)
ptmp = -1
ltmp = -1
j = 1.
# try to solve using previous free concentrations as initial guesses. Maximum number of iterations is large as gradient may be very shallow
sol = solve_mass_balance(equations,(p[i],l[i]),method='lm',options={'maxiter':2000})
ptmp,ltmp = sol.x
# if no solution try to solve with different initial conditions and solver options
if(not sol.success):
sol = solve_mass_balance(equations,(Pt[i],Lt[i]),method='lm',options={'factor':1,'maxiter':8000})
ptmp,ltmp = sol.x
# if still no solution...bugger
if(not sol.success):
print("ERROR: Could not find solution...")
l[i+1] = ltmp
p[i+1] = ptmp
return (p,l)
def solve_mb(N_points, K1, K2, At, BCt):
"""
Solve mass balance equations for the model.
[A]t = [A] + K1*K2*[BC]^2*[A]
[BC]t = [BC] + K1*[BC]^2 + K1*K2*[BC]^2*[A]
"""
A = np.zeros(N_points)
BC = np.zeros(N_points)
for i in range(N_points):
# mass balance equations
def equations(x):
A,BC = x
return [A + K1*K2*BC**2*A - At[i], \
BC + K1*BC**2 + K1*K2*BC**2*A - BCt[i]]
sol = OptimizeResult(success=False)
Atmp = -1
BCtmp = -1
j = 1.
# try to solve using total concentrations as initial guesses. Maximum number of iterations is large as gradient may be very shallow
sol = solve_mass_balance(equations,(At[i],BCt[i]),method='lm',options={'maxiter':2000})
Atmp,BCtmp = sol.x
# if no solution try to solve with different initial conditions and solver options
if(not sol.success and i!=0):
sol = solve_mass_balance(equations,(A[i-1],BC[i-1]),method='lm',options={'factor':1,'maxiter':8000})
Atmp,BCtmp = sol.x
# if still no solution...bugger
if(not sol.success):
print("ERROR: Could not find solution...")
A[i] = Atmp
BC[i] = BCtmp
return (A,BC)