def period_sensitivity_becker( ode_func, params, j, percent,
y_init, t0, dt, tf):
params_star = copy.copy(params)
params_star[j] = (1+percent)*params[j]
t, sol = ode15s(ode_func, y_init, t0, dt, tf, params)
t_star, sol_star = ode15s(ode_func, y_init, t0, dt, tf, params_star)
per = get_period(t[:], np.add(np.add(sol[:,4],sol[:,5]),sol[:,6]))
per_star = get_period(t_star[:], np.add(np.add(sol_star[:,4],
sol_star[:,5]),sol_star[:,6]))
return (per_star-per)/percent
def amp_sensitivity( ode_func, params, j, percent,
y_init, t0, dt, tf, mid=True):
params_star = copy.copy(params)
params_star[j] = (1+percent)*params[j]
t, sol = ode15s(ode_func, y_init, t0, dt, tf, params)
t_star, sol_star = ode15s(ode_func, y_init, t0, dt, tf, params_star)
if(mid==True):
mid = int(len(t)/2)
amp = get_amps( sol[mid:] )
amp_star = get_amps( sol_star[mid:] )
else:
amp = get_amps( y )
amp_star = get_amps( y_star )
return (np.sum(amp_star)-np.sum(amp))/percent
def period_sensitivity( ode_func, params, j, percent,
y_init, t0, dt, tf, mid=True):
params_star = copy.copy(params)
params_star[j] = (1+percent)*params[j]
t, sol = ode15s(ode_func, y_init, t0, dt, tf, params)
t_star, sol_star = ode15s(ode_func, y_init, t0, dt, tf, params_star)
#ignore the first half of the simulation if mid is True (let the system settle)
if(mid==True):
mid = int(len(t)/2)
per = get_period(t[mid:], sol[mid:, 1])
per_star = get_period(t_star[mid:], sol_star[mid:, 1])
else:
per = get_period( t, y[0] )
per_star = get_period( t_star, y_star[0] )
return (per_star-per)/percent
def neg_feedback_loop(vd, vm):
# parameters
n = 4
k1 = 2
k2 = 2
k3 = 2
k4 = 2
km = .5
ks = .38
kd = .2
ki = 1
v1 = 3.2
v2 = 1.58
v3 = 5
v4 = 2.5
# vm = .65
# vd = .95
vs = .76
small_k1 = 1.9
small_k2 = 1.3
params = [n, k1, k2, k3, k4, km, ks, kd, ki, v1, v2, v3, v4, vm, vd, vs,
small_k1, small_k2]
# initial conditions
M = .5
P0 = 1
P1 = .4
P2 = .4
PN = .4
yinit = [M, P0, P1, P2, PN]
t0 = 0
dt = (72 / 3600)
tf = 72
t, sol = ode15s(neg_feedback, yinit, t0, dt, tf, params)
j = 2
plt.plot(t[:-j], sol[:-j, 0], 'b', label='M')
plt.plot(t[:-j], sol[:-j, 1], 'g', label='P0')
plt.plot(t[:-j], sol[:-j, 2], 'm', label='P1')
plt.plot(t[:-j], sol[:-j, 3], 'r', label='P2')
plt.plot(t[:-j], sol[:-j, 4], 'k', label='PN')
plt.plot(t[:-j], np.sum(sol[:-j, 1:4], axis=1), 'c', label='PT')
plt.legend(loc='best')
plt.xlabel('time / h')
plt.ylabel('PER forms or M')
plt.ylim(ymin=0, ymax=5.5)
plt.title('Oscillations in PER over Time (vd = ' + str(vd) + '), (vm = ' + str(vm) + ')')
plt.grid()
plt.show()
def explore_param_space_becker( ode_func, params, j, y_init, t0, dt, tf):
params_cp = copy.copy(params)
pers = []
values = []
for percent in np.arange(-.5, .5, .001):
params_cp[j] = (1+percent)*params[j]
values.append(params_cp[j])
t_star, sol_star = ode15s(ode_func, y_init, t0, dt, tf, params_cp)
mid = int(len(t_star)/2)
per = get_period(t_star[mid:], np.add(np.add(sol_star[mid:,4],
sol_star[mid:,5]),sol_star[mid:,6]))
pers.append(per)
return values, pers
def vdpCircadianError(params):
# Initial condition and time bounds
t0 = 0
y0 = [2, 0]
tend = 480
dt = .1
# Get the "true solution"
tm, ym = ode15s(vdp, y0, t0, dt, tend, params)
mid = round(len(tm) / 2)
per = get_period(ym[mid:, 1], tm[mid:])
perrval = math.pow(((per - 24) / 24), 2)
return perrval
def goldbeter_fly_cost_function(params):
# initial conditions
M = 1
P0 = 1
P1 = 1
P2 = 1
PN = 1
yinit = [M, P0, P1, P2, PN]
t0 = 0
tf = 800
dt = .1
RelTol = 1e-8
with warnings.catch_warnings():
warnings.filterwarnings('error')
try:
t, sol = ode15s(goldbeter_fly,
yinit,
t0,
dt,
tf,
params,
rtol=RelTol)
except (ValueError, UserWarning) as e:
cost = math.inf
return cost
mid = int(len(t) / 2)
desired_per = 23.6
desired_amp = .1
with warnings.catch_warnings():
warnings.filterwarnings('error')
try:
per = get_period(t[mid:], sol[mid:, 1])
amps = get_amps(sol[mid:])
except RuntimeWarning as e:
# something went wrong, most likely no oscillation was created
cost = math.inf
return cost
rate = math.log(.001) / .1
amperrvals = np.exp(np.multiply(amps, rate))
amperrval = np.sum(amperrvals)
perrval = math.pow(((per - desired_per) / desired_per), 2)
return (perrval + amperrval)
def gonzeGoodwinFullCircadianError2(params):
M0 = 1
P0 = 1
I0 = 1
yinit = [M0, P0, I0]
t0 = 0
tf = 800
dt = .1
# Simulate the model
RelTol = 1e-8
with warnings.catch_warnings():
warnings.filterwarnings('error')
try:
t, sol = ode15s(gonze_goodwin,
yinit,
t0,
dt,
tf,
params,
rtol=RelTol)
except (ValueError, UserWarning) as e:
cost = math.inf
return cost
mid = int(len(t) / 2)
with warnings.catch_warnings():
warnings.filterwarnings('error')
try:
per = get_period(t[mid:], sol[mid:, 1])
amps = get_amps(sol[mid:])
except RuntimeWarning as e:
# something went wrong, most likely no oscillation was created
cost = math.inf
return cost
perrval = math.pow((per - 24) / 24, 2)
# an amplitude larger than 0.1 is going to have low cost
rate = math.log(0.001) / 0.1
amp_errvals = np.exp(np.multiply(rate, amps))
errval = perrval + np.sum(amp_errvals)
return errval
# initial conditions
Y0 = 0
Z0 = 0
yinit = [Y0, Z0]
t0 = 0
dt = .01
tf = 150
# Input variable
for i in range(1, 5):
X_star = np.array([0] * 5000 + [i] * 10002).T
t, sol = ode15s(activator_cascade, yinit, t0, dt, tf, params, inputs=X_star)
plt.plot(t, X_star, 'b', label='X*')
plt.plot(t, sol[:, 0], 'g', label='Y')
plt.plot(t, sol[:, 1], 'm', label='Z')
plt.legend(loc='best')
plt.xlabel('time (s)')
plt.ylabel('concentrations (nM)')
plt.title('Activator Cascade (X* = ' + str(i) + ')')
plt.grid()
plt.show()
# Calculations to do response time:
z_fin = sol[-3, 1]
t_change = t[np.argwhere(X_star > 0)[0, 0]]
t_mid = t[find_nearest(sol[:, 1], z_fin / 2.)]
#
# initial conditions
if (run_type == 'calc'):
M = .5
P0 = 1
P1 = .4
P2 = .4
PN = .4
yinit = [M, P0, P1, P2, PN]
t0 = 0
tf = 800
dt = .1
t, sol = ode15s(goldbeter_fly, yinit, t0, dt, tf, params)
sols.append(sol)
j = 2
print(get_period(np.sum(sol[:-j, 1:4], axis=1), t[:-j]))
print(get_amps(sol[:-j], t[:-j]))
# plt.plot(t[:-j], sol[:-j, 0], 'b', label='M')
# plt.plot(t[:-j], sol[:-j, 1], 'g', label='P0')
# plt.plot(t[:-j], sol[:-j, 2], 'm', label='P1')
# plt.plot(t[:-j], sol[:-j, 3], 'r', label='P2')
# plt.plot(t[:-j], sol[:-j, 4], 'k', label='PN')
# plt.plot(t[:-j], np.sum(sol[:-j, 1:4], axis=1), 'c', label='PT')
# plt.legend(loc='best')
axs[0].plot(t_rk4_deg, sol_rk4_deg[:, 1], 'm', label='Y')
axs[0].legend(loc='best')
axs[0].set_title('Degradation')
axs[0].set_xlabel('time (s)')
axs[0].set_ylabel('concentrations (nM)')
axs[1].plot(t_rk4_lv, sol_rk4_lv[:, 0], 'b', label='X')
axs[1].plot(t_rk4_lv, sol_rk4_lv[:, 1], 'm', label='Y')
axs[1].legend(loc='best')
axs[1].set_title('Lotka-Volterra')
axs[1].set_xlabel('time (s)')
axs[1].set_ylabel('concentrations (nM)')
plt.grid()
plt.show()
# considered "correct", so very small dt
t, sol = ode15s(n_degrade, yinit, t0, .001, tf, params)
ts = []
sols = []
for dt in dts:
starttime = time.clock()
t_fe, sol_fe = ode_func(n_degrade, yinit, t0, dt, tf, params,
'explicit_trapezoid')
endtime = time.clock()
ts.append(t_fe)
sols.append(sol_fe)
print("forward euler runtime: {}".format(endtime - starttime))
# starttime = time.clock()
# t_et, sol_et = ode_func(lotka_volterra, yinit, t0, dt, tf, params, 'explicit_trapezoid')
# endtime = time.clock()
