def parameterize_full_model(self, I, param_LP=None, y0_LP=None,
LP_process_func=None):
"""Re-parameterizes the full model.
----
I : casadi-evaluable light input
param_LP : parameters for the full L and P model
"""
if LP_process_func is not None:
self.LP_process_func = LP_process_func
elif self.LP_process_func==None:
raise Exception("No model provided to parameterize.")
# creates the Oscillator
if param_LP is not None:
self.param_LP = param_LP
if y0_LP is not None:
self.y0_LP = y0_LP
self.LP_process = ctb.Oscillator(self.LP_process_func(I), self.param_LP,
self.y0_LP)
SSA_builder.SSA_MM('Reaction3','vd',
km=['kd'],Rct=['Pc'])
SSA_builder.SSA_MA_cytonuc('Reaction4','Pc',
'Pn','k1_','k2_')
return SSAmodel,state_names,param_names
if __name__=='__main__':
# runs and compares one stochastic trajectory with deterministic solution
import matplotlib.gridspec as gridspec
odes = ctb.Oscillator(ODEmodel(), param, y0in)
odes.calc_y0()
odes.limit_cycle()
odes.first_order_sensitivity()
odes.find_prc()
tf=500.
inc = 0.1
SSAnet,state_names,param_names = SSAmodel(ODEmodel(),
y0in,param)
traj = stk.stochkit(SSAnet,job_id='threestate',t=tf,
number_of_trajectories=300,increment=inc,
seed=11)
rxn4 = gillespy.Reaction(name='Y1_deg',
reactants={Y1: 2},
products={Y1: 1},
rate=c4)
rxn5 = gillespy.Reaction(name='Y3_to_Y2',
reactants={Y3: 1},
products={Y2: 1},
rate=c5x3)
self.add_reaction([rxn1, rxn2, rxn3, rxn4, rxn5])
if __name__ == "__main__":
import circadiantoolbox as ctb
oreg = ctb.Oscillator(model(), param, y0in)
dsol = oreg.int_odes(10, numsteps=1000)
oreg.calc_y0()
oreg.limit_cycle()
oreg.first_order_sensitivity()
oreg.find_prc()
ssa = oregonator_ssa(param=param)
trajectories = ssa.run(number_of_trajectories=1)
plt.plot(oreg.ts, dsol)
plt.plot(trajectories[0][:, 0], trajectories[0][:, 1:] / ssa.volume)
return bhat, nn
return bhat_func
'''
Bhat = np.asarray([G*alpha(ti)*(1-nn[i]) for i,ti in enumerate(t)])
# circadian modulation of photic sensitivity
Bhat_spline = UnivariateSpline(t, Bhat, k=3, ext=0)
return Bhat_spline
'''
if __name__ == "__main__":
import circadiantoolbox as ctb
# test the full model with light input--does it integrate?
kron = ctb.Oscillator(kronauer(), param, y0in)
kron.intoptions['constraints'] = None
# integrating with the test light input
dsol = kron.int_odes(100, numsteps=1000)
dts = kron.ts
plt.plot(dts, dsol)
kron.calc_y0()
kron.limit_cycle()
kron.first_order_sensitivity()
kron.find_prc()
fn.setOption("name", "kronauer_LP")
return fn
def null_I(t):
"""
Test light input function. No light.
"""
return 0
if __name__ == "__main__":
import circadiantoolbox as ctb
import light_functions as lf
# test the full model with light input--does it integrate?
krona = ctb.Oscillator(kronauer(null_I, param, y0in))
krona.intoptions['constraints'] = None
# integrating with the test light input
dsol = krona.int_odes(48, numsteps=4801)
dts = krona.ts
y0_dawn = dsol[800]
# parts that do not work
#kron.limit_cycle() # because it's discontinuous
#kron.first_order_sensitivity()
#kron.find_prc()
if __name__=="__main__":
import PlotOptions as plo
import matplotlib.pyplot as plt
import jha_utilities as jha
# reproduce the comparison from compare_kronauer_responses.py
from LocalModels import kronauer_model as km
from LocalModels import simplified_kronauer_model as skm
#set up Pprocess oscillator
Pprocess = ctb.Oscillator(skm.kronauer(), skm.param, skm.y0in)
Pprocess.intoptions['constraints']=None
#set up the Lprocess object
lproc = Lprocess(Pprocess, skm.process_L, skm.param_L)
# let's see how it responds to a perturbation of 1.0h at different times
end_ts=np.linspace(1.1,24.,100)
start_ts=np.linspace(0.1,23.,100)
errs = []
exact_shifts = []
approximated_shifts = []
timer = jha.laptimer()
for i,startt in enumerate(start_ts):
ode[5] = k3 * X2 - v4 * Y2 / (K4 + Y2)
ode[6] = k5 * Y2 - v6 * Z2 / (K6 + Z2)
ode[7] = k7 * X2 - v8 * V2 / (K8 + V2)
ode = cs.vertcat(ode)
fn = cs.SXFunction(cs.daeIn(t=t, x=state_set, p=param_set),
cs.daeOut(ode=ode))
fn.setOption("name", "gonze_model")
return fn
if __name__ == "__main__":
"""
Test suite for the model. We will run with both casadi deterministic
and gillespy stochastic simulations.
"""
import circadiantoolbox as ctb
# create deterministic circadian object
gonze_odes = ctb.Oscillator(gonze_model_ode(), param, y0in)
gonze_odes.burnTransient_sim()
gonze_odes.intODEs_sim(200)
# plot deterministic solutions
plt.plot(gonze_odes.ts, gonze_odes.sol[:, (0, 4)])
plt.show()
SSA_builder.SSA_MM('Cell'+str(indx)+'_Reaction3','vd',
km=['kd'],Rct=['Pc'+index])
#The complexing four:
SSA_builder.SSA_MA_cytonuc('Cell'+str(indx)+'_Reaction4','Pc'+index,
'Pn'+index,'k1_','k2_')
return SSAmodel,state_names,param_names
if __name__=='__main__':
print param
ODEsolC = ctb.Oscillator(ODEmodel(), np.asarray(param), y0in)
sol = ODEsolC.int_odes(y0in,100)
tsol = ODEsolC.ts
plt.plot(tsol,sol)
plt.show()
pdb.set_trace()
tf=10
inc = 0.05
cellcount=3
adjacency = np.array([[1,1,0],[0,1,1],[0,0,1]])#,
#[0,0.5,0.5,0],
#[0,0,0.5,0],
#[0,0,0,0]])
SSAnet,state_names,param_names = ssa_desync(ODEmodel(),
def interpolating_polynomial( ):
pass
if __name__ == "__main__":
import circadiantoolbox as ctb
from Models.tyson_model import model, param, y0in, period, EqCount
lap = jha.laptimer()
#get model run
tyson = ctb.Oscillator(model(), param, np.ones(EqCount))
tyson.calc_y0()
tyson.limit_cycle()
# say we are using collocation on the tyson model
coll = Collocation(model=model)
#attach some data from the Tyson model
time_steps = [0,10,13,40,70,130,165]
datat = tyson.ts[time_steps]
datay = tyson.sol[time_steps]
errors = 0.3*np.random.rand(*datay.shape)
# setup collocation problem