def find_sol(ap,am,bp,bm,kint,krec,kdegR,kintC,bmf,amf,kdegC,ksyn,krecC,mus, lambdas, kappas,taus,L0,Rs0,Ms,Ps0,Re0,Me0,Pe0,S0): # Duration of the simulation endTimeErk = 3601 # The coefficients (constants) in the equations odeconsErk = np.array([ap,am,bp,bm,kint,krec,kdegR,kintC,bmf,amf,kdegC,ksyn,krecC,mus, lambdas, kappas,taus]) # Initial conditions odeistErk = np.array([L0,Rs0,Ms,Ps0,Re0,Me0,Pe0,S0]) # Create an ode/dde object ode_egErk = p.dde() ode_egErk.initproblem(no_vars=8, no_cons=17, nlag=0, nsw=0,t0=0.0, t1=endTimeErk,initstate=odeistErk, c=odeconsErk, otimes=arange(0.0,endTimeErk,1),grad=odegradErk) odestscErk = np.array([L0,Rs0,0,0,Re0,0,0,0]) ode_egErk.initsolver(tol=1*10**(-8), hbsize=10**4,dt=0.1,statescale=odestscErk) ode_egErk.solve() dde_egErk = p.dde() ddeistErk = odeistErk ddeconsErk = odeconsErk ddestscErk = odestscErk dde_egErk.dde(y=ddeistErk, times=arange(0.0, endTimeErk, 1), func=ddegradErk, parms=ddeconsErk, tol=0.000005, dt=0.1, hbsize=10**4, nlag=1, ssc=ddestscErk) return(dde_egErk)
def simulate_system_dde(nn_controller,
d_state,
initial_state,
mass=1,
dt=0.01,
max_time=5.0,
delay_step=0,
err_tol=1e-8):
# restricting pydde import to function scope fixes bug when delay_step=0
from PyDDE import pydde
def odegrad(s, c, t):
time_delay = c[0]
if (t > time_delay):
state_delay = np.zeros_like(s)
for i in range(len(s)):
state_delay[i] = pydde.pastvalue(i, t - time_delay, 0)
controls = nn_controller.compute_control(state_delay)
else:
controls = nn_controller.compute_control(
initial_state) # np.zeros((2,))
return d_state(s, controls, mass)
ode_solver = pydde.dde()
time_delay = delay_step * dt
n_steps = int(max_time / dt) + 1
traj_sim = np.zeros((n_steps, 8))
states = ode_solver.dde(y=initial_state,
times=np.arange(
0, np.nextafter(max_time, max_time + 1), dt),
func=odegrad,
parms=np.array([time_delay]),
dt=dt,
nlag=1,
tol=err_tol)
controls = np.array([nn_controller.compute_control(states[i,1:]) \
for i in range(len(states))])
traj_sim = np.zeros((len(states), 8))
traj_sim[:, :6] = states
if delay_step > 0:
traj_sim[:delay_step, 6:] = nn_controller.compute_control(
initial_state) # np.zeros((2,))
traj_sim[delay_step:, 6:] = controls[:-delay_step]
else:
traj_sim[:, 6:] = controls
return traj_sim
def dde_integrate(x0, c=[1.7, 0.1], t=arange(0.0, 1000.0, 0.1)):
'''Solves a DDE for a species with delayed growth response and oscillating carrying capacity.
c[0] retard of the 1st species
c[1] oscillation amplitude
'''
dde_eg = pydde.dde()
# last constants in array are initial conditions
x0 = array([x0])
c = concatenate((array(c), x0))
dde_eg.dde(y=x0, times=t,
func=ddegrad, parms=c,
tol=1e-8, dt=t[1]-t[0], hbsize=1e6, nlag=1, ssc=array([0]))
return dde_eg.data
def solve(x0, c=[1.56, 0.9, 2.8, 0.9, 1.0], t=arange(0.0, 1000.0, 0.1)):
"""Solves a system of DDEs for 2 species competing and showing delayed growth response.
c[0] retard of the 1st species
c[1] competing coefficient for 1st sp.
c[2] retard of the 2nd sp.
c[3] competing coefficient for 2nd sp.
c[4] ratio of intrinsic growth r2/r1
"""
dde_eg = pydde.dde()
x0 = array(x0)
# last constants in array are initial conditions
c = concatenate((array(c), x0))
dde_eg.dde(y=x0, times=t, func=ddegrad, parms=c, tol=1e-8, dt=0.1, hbsize=1e6, nlag=2, ssc=array([0, 0]))
return dde_eg.data
Km = 4.0 * 5 # ug/ml for L-arabinose (Meyenburg, 1971)
Y = 3.85e5 # (Levin et al., 1977)
T = 0.5 #h-1 (Levin et al., 1977)
Xs0 = 1.0e4 # cells/ml starting levels of cells (Levin et al., 1977)
P0 = 0 # particles/ml starting levels of cells (Levin et al., 1977)
q = 0.35 # induction rate (...)
Pt0 = 1.0e5 # particles/ml of temperate phage
Xl = 0 # no lysogenic bacteria present at the start
Xi = 0 # no lytic bacteria present at the start
V = 3.0 # ml
sim_length = 39.0 # set the simulation length time
plyt_added = 1.0 # time after start when lytic phage is added
dde_camp = p.dde()
dde_camp2 = p.dde()
# Defining the gradient function
# s - state(Xs,P,Xl,etc), c - constant(ddecons), t - time
def ddegrad(s, c, t):
Xslag = 0.0
Plag = 0.0
Ptlag = 0.0
if (t > c[7] and t < plyt_added): # if t > T for lysogenic phage
Xslag = p.pastvalue(1, t - c[7], 0)
Ptlag = p.pastvalue(5, t - c[7], 0)
if (t > (c[7] + plyt_added)): # if t > T for both phages
# -*- coding: utf-8 -*-
from PyDDE import pydde as p
from numpy import array, arange, pi, transpose
# to save results
from pickle import dump
dde_eg = p.dde()
def ddegrad(s, c, t):
"""Retorna o gradiente de x, o lado direito da equação a ser integrada"""
# condição inicial constante
alag = 0.2
if t > c[0]:
# aqui entra o delay
alag = p.pastvalue(0,t-c[0],0)
r = 1.0
if t > 6000:
r -= r * 2e-3
elif t > 2000:
r -= r * 5e-7 * (t-2000)
return array([ r * s[0] * (1.0 - alag) ])
def ddesthist(g, s, c, t):
"""Função para guardar variáveis "históricas". Neste caso, não faz nada."""
return (s, g)
import PyDDE.pydde as p
import matplotlib.pyplot as plt
# Setting initial values
u = 0.738 # h-1 (Levin et al., 1977)
S0 = 3.0e1 # ug/ml(Levin et al., 1977)
Km = 4.0 # ug/ml (Levin et al., 1977)
Y = 3.85e5 #(Levin et al., 1977)
Xs0 = 1.0e4 # cells/ml starting levels of cells (Levin et al., 1977)
a = 0.22 # death related constant (Kumada et al., 1985)
k = -2.0e-4 # death related constant (Kumada et al., 1985)
C = 7.0e9 # max carrying capacity (OD600=7)
sim_length = 2500.0 # set the simulation length time
dde_camp = p.dde()
# Defining the gradient function
# s - state(Xs,P,Xl,etc), c - constant(ddecons), t - time
def ddegrad(s, c, t):
g = array([0.0, 0.0])
# s[0] = S(t), s[1] = Xs(t)
# S = Xs*u*S/(Km+S)*(1/Y)
g[0] = -s[1] * (c[0] * s[0]) / (c[5] + s[0]) * (1 / c[6])
# check if S is low or cells are over C
if (s[0] < 1 / c[6] or s[1] > c[7]):
# cells start to die
# X = k*X**(a+1)
timeit = 0
'''
ODE example from Solv95 distribution.
This model is a Lotka-Volterra predator-prey system.
'''
if timeit:
timing.start()
try:
del ode_eg
except:
print("DDE Test: Running for the first time...")
ode_eg = p.dde()
odegrad = (lambda s, c, t: array(
[c[2] * s[0] - c[3] * s[0] * s[1], c[0] * s[0] * s[1] - c[1] * s[1]]))
odecons = array([0.005, 0.2, 1.0, 0.02, 100.0, 100.0])
odeist = array([odecons[4], odecons[5]])
ode_eg.initproblem(no_vars=2,
no_cons=6,
nlag=0,
nsw=0,
t0=0.0,
t1=300.0,
initstate=odeist,
c=odecons,
def dde_sa (parameter, min, max, step):
result = {} # dictionary to save {percentage : [Xs_extinct, xixs_ratio]}
for percentage in arange(min,max,step):
# Changing the parameter
# modify_param(parameter,percentage)
plyt_added = percentage #
print('new plyt_added= ' + str(plyt_added))
# Defining the gradient function
# s - state(Xs or P?), c - constant(ddecons), t - time
def ddegrad(s, c, t):
Xslag = 0.0
Plag = 0.0
Xllag = 0.0
if (t>c[15] and t<plyt_added): # if t > T for lysogenic phage
Xllag = p.pastvalue(4, t - c[15], 0)
if (t>(c[7]+plyt_added)): # if t > T for both phages
Xslag = p.pastvalue(1,t-c[7],0)
Plag = p.pastvalue(3,t-c[7],0)
if (t>(c[15]+plyt_added)): # if t > T for both phages
Xllag = p.pastvalue(4,t-c[15],0)
if (s[1] < 1.0e-15):
# if concentration of Xs drops below 1.0e-15 add time to the array
Xs_extinction_times.append(t)
g = array([0.0,0.0,0.0,0.0,0.0,0.0])
# s[0] = S(t), s[1] = Xs(t), s[2] = Xi(t), s[3] = P(t), s[4] = Xl(t), s[5] = Pt(t)
# S = - Xs*u*S/(Km+S)*(1/Y) - Xi*ui*S/(Kmi+S)*(1/Yi) - Xl*ul*S/(Kml+S)*(1/Yl)
g[0] = - s[1]*(c[0]*s[0])/(c[5]+s[0])*(1/c[6]) - s[2]*(c[9]*s[0])/(c[11]+s[0])*(1/c[13]) - s[4]*(c[10]*s[0])/(c[12]+s[0])*(1/c[14])
# Xs = Xs*u*S/(Km+S)*(1/Y) - Ki*Xs*P - Kit*Xs*Pt
g[1] = s[1]*c[0]*s[0]/(c[5]+s[0]) - c[3]*s[1]*s[3] - c[16]*s[1]*s[5]
# Xi = Ki*Xs*P - Ki*Xs(t-T)P(t-T)
g[2] = 0
# P = b*Ki*Xs(t-T)P(t-T) - Ki*Xs*P
g[3] = 0
if (t>plyt_added): # after plyt_added hours lytic phage is added
# Xi = Ki*Xs*P - Ki*Xs(t-T)P(t-T)
g[2] = c[3]*s[1]*s[3] - c[3]*Xslag*Plag
# P = b*Ki*Xs(t-T)P(t-T) - Ki*Xs*P - Ki*Xl*P - Ki*Xi*P
g[3] = c[4]*c[3]*Xslag*Plag - c[3]*s[1]*s[3] - c[3]*s[4]*s[3] - c[3]*s[2]*s[3]
# Xl = Xl*ul*S/(Kml+S) + Kit*Xs*Pt - q*Xl(t-Tt)
g[4] = s[4]*(c[10]*s[0])/(c[12]+s[0]) + c[16]*s[1]*s[5] - c[8]*Xllag
# Pt = bt*q*Xl(t-Tt) - Kit*Xs*Pt - Kit*Xl*Pt - Kit*Xi*Pt
g[5] = c[17]*c[8]*Xllag - c[16]*s[1]*s[5] - c[16]*s[4]*s[5] - c[16]*s[2]*s[5]
return g
dde_camp = p.dde()
dde_camp2 = p.dde()
Xs_extinction_times = [] # stores times once Xs goes below 1.0e-15
# Definte function to store history variables: state and gradient
def ddesthist(g, s, c, t):
return (s, g)
#global Xs0, Xi, P0, Xl, Pt0
# Setting constants
ddecons = array([u,S0,D,Ki,b,Km,Y,T,q,ui,ul,Kmi,Kml,Yi,Yl,Tt,Kit,bt])
# Setting initial conditions S, Xs, Xi, P, Xl, Pt
S = ddecons[1]
ddeist = array([S0, Xs0, Xi, 0, Xl, Pt0])
# Setting a state-scaling array for use in error control when values are very close to 0
ddestsc = array([0,0,0,0,0,0])
# Time: 0-plyt_added (Lysogenic phage only)
dde_camp.initproblem(no_vars=6, no_cons=18, nlag=1, nsw=0, t0=0.0, t1=plyt_added+0.1, initstate=ddeist, c=ddecons, otimes= arange(0.0, plyt_added+0.1, 0.1), grad=ddegrad, storehistory=ddesthist)
dde_camp.initsolver(tol=0.000005, hbsize=10000, dt=1.0, statescale=ddestsc)
dde_camp.solve()
# Time: from plyt_added to sim_length (Lysogenic + Lytic phage)
# Setting initial conditions for the second simulation
S_endval = dde_camp.data[:, 1][-1]
Xs0_endval = dde_camp.data[:, 2][-1]
Xi_endval = dde_camp.data[:, 3][-1]
#P0_new = 1.0e4 # introduction of P lytic
Xl_endval = dde_camp.data[:, 5][-1]
Pt0_endval = dde_camp.data[:, 6][-1]
# Setting initial conditions S, Xs, Xi, P, Xl, Pt
ddeist = array([S_endval, Xs0_endval, Xi_endval, P0, Xl_endval, Pt0_endval])
# Setting a state-scaling array for use in error control when values are very close to 0
ddestsc = array([0,0,0,0,0,0])
dde_camp2.initproblem(no_vars=6, no_cons=18, nlag=1, nsw=0, t0=plyt_added, t1=sim_length, initstate=ddeist, c=ddecons, otimes= arange(plyt_added, sim_length, 0.1), grad=ddegrad, storehistory=ddesthist)
dde_camp2.initsolver(tol=0.000005, hbsize=10000, dt=1.0, statescale=ddestsc)
dde_camp2.solve()
# Print values at the joining point between two simulations
#print('At t= ' + str(dde_camp.data[:, 0][-1]) + ', Xs =' + str(dde_camp.data[:, 2][-1]))
#print('At t= ' + str(dde_camp2.data[:, 0][0]) + ', Xs =' +str(dde_camp2.data[:, 2][0]))
Xs_extinct = Xs_extinction_times[0]
#print('Xs went extinct at t= ' + str(Xs_extinct))
# Calculation of average concentration
def get_avg(values):
more = values > 1.0e-15 # select only values above threshold
#print(len(values[more]))
if len(values[more]) != 0:
return values[more].sum()/len(values[more])
else:
return 0
# Calculation of r value (ratio of xi/xs)
xs_avg = get_avg(concatenate((dde_camp.data[:, 2],dde_camp2.data[:, 2])))
#print('Average Xs = ' + str(xs_avg))
xi_avg = get_avg(concatenate((dde_camp.data[:, 3],dde_camp2.data[:, 3])))
#print('Average Xi = ' + str(xi_avg))
xixs_ratio = round(xi_avg/xs_avg, 4)
#print('Xi/Xs ratio is ' + str(xixs_ratio))
# Plot Test full figure of one simulation
# plt.style.use('ggplot') # set the global style
# xs, = plt.plot(concatenate((dde_camp.data[:, 0], dde_camp2.data[:, 0])), concatenate((dde_camp.data[:, 2],dde_camp2.data[:, 2])), label=r'$X_S$')
# xi, = plt.plot(concatenate((dde_camp.data[:, 0], dde_camp2.data[:, 0])), concatenate((dde_camp.data[:, 3],dde_camp2.data[:, 3])), label=r'$X_I$')
# plyt, = plt.plot(dde_camp2.data[:, 0], dde_camp2.data[:, 4], "r:", label=r'$P$') # no need to concatenate since previous values = 0
# xl, = plt.plot(concatenate((dde_camp.data[:, 0], dde_camp2.data[:, 0])), concatenate((dde_camp.data[:, 5],dde_camp2.data[:, 5])), label=r'$X_L$')
# pt, = plt.plot(concatenate((dde_camp.data[:, 0], dde_camp2.data[:, 0])), concatenate((dde_camp.data[:, 6],dde_camp2.data[:, 6])), "r--", label=r'$P_T$')
# f_size = 15 # set font size for plot labels
# plt.xlabel('Time (hours)', fontsize=f_size)
# plt.ylabel('Log concentration (particles/ml)', fontsize=f_size)
# plt.yscale('log')
# plt.axis([0,sim_length,1.0e-4,1.0e10])
# #plt.text(sim_length*0.2,8.0e8,'$P(t)$= '+str(plyt_added)+' h', fontsize=f_size) # display parameters
# plt.text(Xs_extinct,1.5e10,'$t=$ ' + str(round(Xs_extinct,3)), fontsize=f_size-1) # display parameters
# plt.text(0-0.5,1.5e10,'$r=$ ' + str(xixs_ratio), fontsize=f_size-1) # display parameters
# plt.tick_params(axis='both', labelsize=f_size)
# plt.vlines(Xs_extinct, 0,1.0e10, linewidth=0.5)
# # Plot substrate on the second y axis on top of the preivous figure
# plt2 = plt.twinx()
# plt2.grid(False)
# s, = plt.plot(concatenate((dde_camp.data[:, 0], dde_camp2.data[:, 0])), concatenate((dde_camp.data[:, 1],dde_camp2.data[:, 1])), 'black', label=r'$S$')
# plt2.set_ylabel(r'Substrate (${\mu}$g/ml)', fontsize=f_size)
# plt2.set_yticks(linspace(0,S0, 3))
# plt2.tick_params(axis='both', labelsize=f_size)
# # Join legends from two separate plots into one
# plots = [xs,xi,plyt,xl,pt,s]
# plt.legend(plots, [plots_.get_label() for plots_ in plots],loc='best', fontsize= 'small', prop={'size': f_size})
# plt.tight_layout()
# plt.show()
result[percentage]=[Xs_extinct,xixs_ratio]
modify_param(parameter, 100.0) # return parameeter to its nominal value before running another simulation
# # Plot figures for spyder plots
# percentages = list(result.keys())
# extinction_times = array(list(result.values()))[:,0]
# r_values = array(list(result.values()))[:,1]
# plt.style.use('ggplot') # set the global style
# # Plot only parameters that have an absolute elasticity over 0.01
# time_elasticity = (extinction_times[-1] - extinction_times[0])/extinction_times[0]
# r_elasticity = (r_values[-1] - r_values[0])/r_values[0]
# if r_elasticity > 0.01 or r_elasticity < -0.01:
# c=next(color) # pick next colour to avoid repetition
# temp_plot, = plt.plot(percentages,r_values, c=c, label=r'$'+parameter+'$')
# plts.append(temp_plot)
return result
dAdt = MJ - (1 + q2(s[1], t)) * dA(t) * s[1]
dSdt = s[2] * ((mat_J(t) / mat_J(t - s[3])) *
(q4(J_lag, t - s[3]) + 1) * dJ(t - s[3]) - dJ(t) *
(q4(s[0], t) + 1))
dtaudt = 1. - mat_J(t) / mat_J(t - s[3])
return array([dJdt, dAdt, dSdt, dtaudt])
## EXEC DDE SOLVER
dde_times = arange(0.0, max_years * yr, dde_tstep)
dde_eg = pydde.dde()
ddeist = array([0., .1, exp(-dJ(-1e-3) / mJTR), 1. / mJTR])
dde_eg.dde(y=ddeist,
times=dde_times,
func=ddegrad,
parms=(),
hbsize=dde_hbsize,
tol=tol,
nlag=2,
dt=dde_dt)
filename = sub_name + '/ddedata_' + spp + '_' + str(delta_ind) + '.txt'
outFile = open(filename, 'w')
outStr = str([0] + [
x for x in dde_eg.data[((max_years - keep_years) * 365. / dde_tstep):-1, 0]
def run_simulation(params):
constants = [
params['tau1'], # 0: tau1 [ms]
params['tau2'], # 1: tau2 [ms]
params['c11'], # 2: c11
params['c12'], # 3: c12
params['c21'], # 4: c21
params['c22'], # 5: c22 !
params['d11'], # 6: d11
params['d12'], # 7: d12 [ms]
params['d21'], # 8: d21 [ms]
params['d22'], # 9: d22 [ms]
params['m1'], # 10: m1 [spk/s]
params['b1'], # 11: b1 [spk/s]
params['m2'], # 12: m2 [spk/s]
params['b2'], # 13: b2 [spk/s]
params['u1'], # 14: u1 [spk/s] !
params['u2'], # 15: u2 [spk/s]
params['x10'], # 16: x1_0 [spk/s]
params['x20'], # 17: x2_0 [spk/s]
params['theta0'] # 18: theta_0
]
tstop = params['tstop']
dt = params['dt']
initial_state = np.array([constants[16], constants[17], constants[18]])
s1 = utils.create_activation_function(params['activation_function_1'])
s2 = utils.create_activation_function(params['activation_function_2'])
def ddegrad(s, c, t):
"""Equations defining time evolution of the system. Returns the value of the derivative at time t
:param s: state variables
:param c: constants
:param t: time
:return:
"""
max_delay = max(c[6:10])
if t > max_delay:
delayed_values = [
pydde.pastvalue(0, t - c[6], 0), # x1d11
pydde.pastvalue(1, t - c[7], 1), # x2d12
pydde.pastvalue(0, t - c[8], 2), # x1d21
pydde.pastvalue(1, t - c[9], 3) # x2d22
]
else:
# initial_state taken from the outer scope
delayed_values = [
initial_state[0], initial_state[1], initial_state[0],
initial_state[1]
]
inputs = [
c[2] * delayed_values[0] - c[3] * delayed_values[1] + c[14] -
s[0] * s[2],
c[4] * delayed_values[2] - c[5] * delayed_values[3] - c[15]
]
theta_dot = 0
return np.array([
1 / c[0] * (-s[0] + s1(inputs[0])),
1 / c[1] * (-s[1] + s2(inputs[1])), theta_dot
])
system = pydde.dde()
system.dde(y=initial_state,
times=np.arange(0.0, tstop, dt),
func=ddegrad,
parms=constants,
tol=10e-7,
dt=dt,
nlag=4,
hbsize=800000)
return copy.copy(system.data)
'''
ODE example from Solv95 distribution.
This model is a Lotka-Volterra predator-prey system.
'''
if timeit:
timing.start()
try:
del ode_eg
except:
print("DDE Test: Running for the first time...")
ode_eg = p.dde()
odegrad = (lambda s, c, t: array( [ c[2]*s[0]-c[3]*s[0]*s[1], c[0]*s[0]*s[1]-c[1]*s[1] ] ) )
odecons = array([0.005, 0.2, 1.0, 0.02, 100.0, 100.0])
odeist = array([odecons[4],odecons[5]])
ode_eg.initproblem(no_vars=2, no_cons=6, nlag=0, nsw=0,
t0=0.0, t1=300.0,
initstate=odeist, c=odecons, otimes=arange(0.0,300.0,1.0),
grad=odegrad)
odestsc = array([0,0])
ode_eg.initsolver(tol=1*10**(-8), hbsize=0,
dt=1.0,
