def figure4b1_continuation(): """Actual continuation analysis for 4B1. Contains commands to pyDSTool. Performs some formatting and continuation. Plotting commands are contained with continuation commands to keep pycont objects together :return: None """ # Set parameters and convert to symbolic representation parameters = default_parameters(i_app=0 * uA_PER_CM2) striped_parameters = {k: strip_dimension(v) for k, v in parameters.items()} v, h, i_app = symbols("v h i_app") striped_parameters["i_app"] = i_app dydt = ode_2d([v, h], 0, striped_parameters, exp=exp) DSargs_1 = PyDSTool.args(name="bifn_1") DSargs_1.pars = {"i_app": 0} DSargs_1.varspecs = { "v": PyDSTool.convertPowers(str(dydt[0])), "h": PyDSTool.convertPowers(str(dydt[1])), } DSargs_1.ics = {"v": 0, "h": 0} ode_1 = PyDSTool.Generator.Vode_ODEsystem(DSargs_1) ode_1.set(pars={"i_app": 0}) ode_1.set(ics={"v": -49, "h": 0.4}) PyCont_1 = PyDSTool.ContClass(ode_1) PCargs_1 = PyDSTool.args(name="EQ1_1", type="EP-C") PCargs_1.freepars = ["i_app"] PCargs_1.MaxNumPoints = 500 PCargs_1.MaxStepSize = 0.05 PCargs_1.MinStepSize = 1e-5 PCargs_1.StepSize = 1e-2 PCargs_1.LocBifPoints = "all" PCargs_1.SaveEigen = True PyCont_1.newCurve(PCargs_1) PyCont_1["EQ1_1"].backward() PyCont_1["EQ1_1"].forward() PyCont_1["EQ1_1"].backward() PyCont_1["EQ1_1"].display(["i_app", "v"], stability=True, figure=1) PCargs_1.name = "LC1_1" PCargs_1.type = "LC-C" PCargs_1.initpoint = "EQ1_1:H1" PCargs_1.freepars = ["i_app"] PCargs_1.MaxNumPoints = 500 PCargs_1.MaxStepSize = 0.1 PCargs_1.LocBifPoints = "all" PCargs_1.SaveEigen = True PyCont_1.newCurve(PCargs_1) PyCont_1["LC1_1"].backward() PyCont_1["LC1_1"].display(("i_app", "v_min"), stability=True, figure=1) PyCont_1["LC1_1"].display(("i_app", "v_max"), stability=True, figure=1) PyCont_1.plot.toggleLabels(visible="off", bytype=["P", "RG", "LP"]) PyCont_1.plot.togglePoints(visible="off", bytype=["P", "RG", "LP"]) plt.gca().set_title("")
def model(): K = 0.4 E = 7.0 M = 10.5 N = 15 Lambda = 0.9 Gamma = 12 R = 0.7 PP = 20 lamb_p = (K*Gamma)/M eta_p = E*K p_p = (Lambda*PP)/(K*Gamma*M) nu_p = N/M rho_p = R # Declare names and initial values for (symbolic) parameters lamb = dst.Par(lamb_p, 'lamb') eta = dst.Par(eta_p, 'eta') p = dst.Par(p_p, 'p') nu = dst.Par(nu_p, 'nu') rho = dst.Par(rho_p, 'rho') # Compute nontrivial boundary equilibrium initial condition from parameters (see reference) b_0 = 0.0 w_0 = p_p/nu_p # Declare symbolic variables b = dst.Var('b') w = dst.Var('w') t = dst.Var('t') # Create Symbolic Quantity objects for definitions brhs = dst.Fun(lamb*w*b*((1+eta*b)**2)*(1-b) - b,[b,w],'brhs') wrhs = dst.Fun(p - nu*w*(1-rho*b) - lamb*w*b*((1+eta*b)**2),[b,w],'wrhs') F = dst.Fun([brhs(b,w),wrhs(b,w)], [b,w], 'F') jac = dst.Fun(dst.Diff(F,[b,w]), [t,b,w], 'Jacobian') # Build Generator DSargs = dst.args(name='fairy_circles_ode') DSargs.fnspecs = [jac, brhs,wrhs] DSargs.varspecs = {b:brhs(b,w) , w:wrhs(b,w)} DSargs.pars = [lamb,eta,p,nu,rho] # Use eval method to get a float value from the symbolic definitions given in # terms of parameter values DSargs.ics = dst.args(b=b_0, w=w_0) return DSargs
def __figure4b2_continuation__(): parameters = default_parameters(i_app=-0.1) v, h, h_s, i_app = symbols('v h h_s i_app') parameters[0] = i_app dydt = ode_3d([v, h, h_s], 0, parameters, exp=exp) DSargs_2 = PyDSTool.args(name='bifn_2') DSargs_2.pars = {'i_app': 0} DSargs_2.varspecs = { 'v': PyDSTool.convertPowers(str(dydt[0])), 'h': PyDSTool.convertPowers(str(dydt[1])), 'h_s': PyDSTool.convertPowers(str(dydt[2])) } DSargs_2.ics = {'v': 0, 'h': 0, 'h_s': 0} ode_2 = PyDSTool.Generator.Vode_ODEsystem(DSargs_2) ode_2.set(pars={'i_app': -0.1}) ode_2.set(ics={'v': -67, "h": 0.77, "h_s": 1}) PyCont_2 = PyDSTool.ContClass(ode_2) PCargs_2 = PyDSTool.args(name='EQ1_2', type='EP-C') PCargs_2.freepars = ['i_app'] PCargs_2.MaxNumPoints = 300 PCargs_2.MaxStepSize = 0.1 PCargs_2.MinStepSize = 1e-5 PCargs_2.StepSize = 1e-2 PCargs_2.LocBifPoints = 'all' PCargs_2.SaveEigen = True PyCont_2.newCurve(PCargs_2) PyCont_2['EQ1_2'].backward() PyCont_2['EQ1_2'].display(['i_app', 'v'], stability=True, figure=1) PCargs_2.name = 'LC1_2' PCargs_2.type = 'LC-C' PCargs_2.initpoint = 'EQ1_2:H2' PCargs_2.freepars = ['i_app'] PCargs_2.MaxNumPoints = 400 PCargs_2.MaxStepSize = 0.1 PCargs_2.StepSize = 1e-2 PCargs_2.LocBifPoints = 'all' PCargs_2.SaveEigen = True PyCont_2.newCurve(PCargs_2) PyCont_2['LC1_2'].forward() PyCont_2['LC1_2'].display(('i_app', 'v_min'), stability=True, figure=1) PyCont_2['LC1_2'].display(('i_app', 'v_max'), stability=True, figure=1) PyCont_2.plot.toggleLabels(visible='off', bytype=['P', 'RG']) PyCont_2.plot.togglePoints(visible='off', bytype=['P', 'RG']) plt.gca().set_title('')
def __figure4b1_continuation__(): parameters = default_parameters(i_app=0) v, h, i_app = symbols('v h i_app') parameters[0] = i_app dydt = ode_2d([v, h], 0, parameters, exp=exp) DSargs_1 = PyDSTool.args(name='bifn_1') DSargs_1.pars = {'i_app': 0} DSargs_1.varspecs = { 'v': PyDSTool.convertPowers(str(dydt[0])), 'h': PyDSTool.convertPowers(str(dydt[1])) } DSargs_1.ics = {'v': 0, 'h': 0} ode_1 = PyDSTool.Generator.Vode_ODEsystem(DSargs_1) ode_1.set(pars={'i_app': 0}) ode_1.set(ics={'v': -49, "h": 0.4}) PyCont_1 = PyDSTool.ContClass(ode_1) PCargs_1 = PyDSTool.args(name='EQ1_1', type='EP-C') PCargs_1.freepars = ['i_app'] PCargs_1.MaxNumPoints = 500 PCargs_1.MaxStepSize = 0.05 PCargs_1.MinStepSize = 1e-5 PCargs_1.StepSize = 1e-2 PCargs_1.LocBifPoints = 'all' PCargs_1.SaveEigen = True PyCont_1.newCurve(PCargs_1) PyCont_1['EQ1_1'].backward() PyCont_1['EQ1_1'].forward() PyCont_1['EQ1_1'].backward() PyCont_1['EQ1_1'].display(['i_app', 'v'], stability=True, figure=1) PCargs_1.name = 'LC1_1' PCargs_1.type = 'LC-C' PCargs_1.initpoint = 'EQ1_1:H1' PCargs_1.freepars = ['i_app'] PCargs_1.MaxNumPoints = 500 PCargs_1.MaxStepSize = 0.1 PCargs_1.LocBifPoints = 'all' PCargs_1.SaveEigen = True PyCont_1.newCurve(PCargs_1) PyCont_1['LC1_1'].backward() PyCont_1['LC1_1'].display(('i_app', 'v_min'), stability=True, figure=1) PyCont_1['LC1_1'].display(('i_app', 'v_max'), stability=True, figure=1) PyCont_1.plot.toggleLabels(visible='off', bytype=['P', 'RG']) PyCont_1.plot.togglePoints(visible='off', bytype=['P', 'RG']) plt.gca().set_title('')
def simulate(args): modelname,ptargs,tdomain,captcnt,captincr,icdict,pardict,vardict,varspecdict,fnspecdict = args dsargs = pdt.args() dsargs.name = modelname dsargs.ics = icdict dsargs.pars = pardict dsargs.tdata = tdomain #dsargs.vars = vardict dsargs.varspecs = varspecdict #dsargs.fnspecs = fnspecdict dsargs.algparams = { 'init_step':captincr/10.0, 'atol':0.1, } dsys = pdt.Generator.Vode_ODEsystem(dsargs) #dsys = pdt.Generator.Radau_ODEsystem(dsargs) traj = dsys.compute('demo') pts = traj.sample() rshape = (len(ptargs),captcnt) result = numpy.zeros(shape = rshape,dtype = numpy.float) result[0,:] = numpy.arange(tdomain[0],tdomain[1]+0.000000001,captincr) for timedx in range(result.shape[1]): itraj = traj(result[0,timedx]) for targdx in range(1,result.shape[0]): result[targdx,timedx] = itraj[ptargs[targdx]] return result
def make_shooter(): # no friction # cos(atan(x)) = 1/(sqrt(1+x^2)) Fx_str = '0' # '-speed_fn()*cos(atan2(vy,vx))' Fy_str = '-10' DSargs = dst.args() DSargs.varspecs = { 'vx': Fx_str, 'x': 'vx', 'vy': Fy_str, 'y': 'vy', 'Fx_out': 'Fx(x,y)', 'Fy_out': 'Fy(x,y)', 'speed': 'speed_fn(vx, vy)', 'bearing': '90-180*atan2(vy,vx)/pi' } auxfndict = { 'Fx': (['x', 'y'], Fx_str), 'Fy': (['x', 'y'], Fy_str), 'speed_fn': (['vx', 'vy'], 'sqrt(vx*vx+vy*vy)'), } DSargs.auxvars = ['Fx_out', 'Fy_out', 'speed', 'bearing'] DSargs.fnspecs = auxfndict DSargs.algparams = { 'init_step': 0.001, 'max_step': 0.1, 'max_pts': 20000, 'maxevtpts': 2, 'refine': 5 } ground_event = dst.Events.makeZeroCrossEvent('y', -1, { 'name': 'ground', 'eventtol': 1e-3, 'precise': True, 'term': True }, varnames=['y'], targetlang='python') peak_event = dst.Events.makeZeroCrossEvent('vy', -1, { 'name': 'peak', 'eventtol': 1e-3, 'precise': True, 'term': False }, varnames=['vy'], targetlang='python') DSargs.events = [ground_event, peak_event] DSargs.checklevel = 2 DSargs.ics = {'x': 0, 'y': 0, 'vx': 0, 'vy': 0} DSargs.ics.update(make_vel_ics(5, 20)) DSargs.name = 'cannon' DSargs.tdomain = [0, 100000] DSargs.tdata = [0, 10] return dst.embed(dst.Generator.Vode_ODEsystem(DSargs))
def test_goal(mesh_pts, goal_tol=L2_tol): errors_array = error_pts(mesh_pts) max_error = np.max(errors_array) result = condition(max_error, goal_tol) return dst.args(result=result, errors=errors_array, max_error=max_error)
def get_pycont(param_dict): DSargs = dst.args(name='Whi5_Sbf_module') # parameters DSargs.pars = { "kasSW": 1.67, "kdisSW": 1.67e-4, "kPhWhi5": 1e-3, "kDphWhi5": 5e-4, "fac": 58, "kdCln12": 0.0015, "Sbft": 1.1, "Whi50": 65, "V": 20, "Cln3": 1.0 } DSargs.varspecs = { 'Cln12': 'kdCln12*fac*Sbf/Sbft - kdCln12*Cln12', 'Sbf': '-kasSW*(Whi50/V+Sbf-Sbft-Whi5P)*Sbf + (kdisSW + kPhWhi5*(Cln12+Cln3))*(Sbft-Sbf)', 'Whi5P': '(kPhWhi5*(Cln12+Cln3))*(Whi50/V-Whi5P) - kDphWhi5*Whi5P', } set_params_from_dict(DSargs.pars, param_dict) DSargs.ics = get_steady_states(param_dict) ode = dst.Generator.Vode_ODEsystem(DSargs) return dst.ContClass(ode)
def test_func_attr(x, eps=1e-8): """ mock function that would use a tolerance eps and return a numerical object that does contain reference to that tolerance """ res = dst.args(val=x, eps=eps) return res
def __figure3c_continuation__(): parameters = default_parameters(i_app=0.16) v, h, h_s = symbols('v h h_s') dydt = hs_clamp([v, h, h_s], 0, parameters) DSargs_3 = PyDSTool.args(name='bifn_3') DSargs_3.pars = {'h_s': 0} DSargs_3.varspecs = { 'v': PyDSTool.convertPowers(str(dydt[0])), 'h': PyDSTool.convertPowers(str(dydt[1])) } DSargs_3.ics = {'v': 0, 'h': 0} ode_3 = PyDSTool.Generator.Vode_ODEsystem(DSargs_3) ode_3.set(pars={'h_s': 0}) ode_3.set(ics={'v': -49, "h": 0.4}) PyCont_3 = PyDSTool.ContClass(ode_3) PCargs_3 = PyDSTool.args(name='EQ1_3', type='EP-C') PCargs_3.freepars = ['h_s'] PCargs_3.MaxNumPoints = 350 PCargs_3.MaxStepSize = 0.1 PCargs_3.MinStepSize = 1e-5 PCargs_3.StepSize = 1e-2 PCargs_3.LocBifPoints = 'all' PCargs_3.SaveEigen = True PyCont_3.newCurve(PCargs_3) PyCont_3['EQ1_3'].backward() PyCont_3['EQ1_3'].display(['h_s', 'v'], stability=True, figure=1) PCargs_3.name = 'LC1_3' PCargs_3.type = 'LC-C' PCargs_3.initpoint = 'EQ1_3:H2' PCargs_3.freepars = ['h_s'] PCargs_3.MaxNumPoints = 500 PCargs_3.MaxStepSize = 0.1 PCargs_3.LocBifPoints = 'all' PCargs_3.SaveEigen = True PyCont_3.newCurve(PCargs_3) PyCont_3['LC1_3'].backward() PyCont_3['LC1_3'].display(('h_s', 'v_min'), stability=True, figure=1) PyCont_3['LC1_3'].display(('h_s', 'v_max'), stability=True, figure=1) PyCont_3.plot.toggleLabels(visible='off', bytype=['P', 'RG']) PyCont_3.plot.togglePoints(visible='off', bytype=['P', 'RG']) plt.gca().set_title('')
def construct_system(I, alpha, init=(0, 0), T=10): theta0, w0 = init args = pd.args(name='Pendulum') args.pars = {'alpha': alpha, 'I': I} args.varspecs = {'theta': 'w', 'w': 'I - sin(theta) - alpha * w'} args.ics = {'theta': theta0, 'w': w0} args.tdomain = [-T, T] ode = pd.Generator.Vode_ODEsystem(args) return ode
def construct_system( I, alpha, init=(0,0), T = 10 ): theta0, w0 = init args = pd.args( name = 'Pendulum' ) args.pars = { 'alpha' : alpha, 'I' : I } args.varspecs = { 'theta' : 'w', 'w' : 'I - sin(theta) - alpha * w' } args.ics = { 'theta' : theta0, 'w' : w0 } args.tdomain = [-T, T ] ode = pd.Generator.Vode_ODEsystem( args ) return ode
def create_model(): pars = {'g': 9.8} #, 'pi': np.pi} #ODE ode_def = { 'x': 'vx', 'y': 'vy', 'vx': '-(pi**2)*x', 'vy': '-g', 'tt': '1.0', } event_bounce = dst.makeZeroCrossEvent( 'x-y', 1, { 'name': 'bounce', 'eventtol': 1e-3, 'term': True, 'active': True, 'eventinterval': 1, 'eventdelay': 1e-2, 'starttime': 0, 'precise': True }, varnames=['x', 'y'], targetlang='python') # targetlang is redundant (defaults to python) DSargs = dst.args(name='bball_sin') # struct-like data DSargs.events = [event_bounce] #DSargs.pars = pars #DSargs.tdata = [0, 10] #DSargs.algparams = {'max_pts': 3000, 'stiff': False} DSargs.algparams = {'stiff': False, 'init_step': 0.01} DSargs.varspecs = ode_def DSargs.pars = pars #DSargs.xdomain = {'y': [0, 100]} DS_fall = dst.embed(dst.Generator.Vode_ODEsystem(DSargs)) DS_fall_MI = dst.intModelInterface(DS_fall) # Reset ev_map = dst.EvMapping({ 'y': 'x+0.001', 'vy': '0.9*(vx-vy)' }, model=DS_fall) #ev_map = dst.EvMapping({'y': '10', 'x': '20'}, model=DS_fall) DS_BBall = dst.makeModelInfoEntry(DS_fall_MI, ['bball_sin'], [('bounce', ('bball_sin', ev_map))]) modelInfoDict = dst.makeModelInfo([DS_BBall]) bball_sin_model = dst.Model.HybridModel({ 'name': 'Bouncing_Ball_Sinusiodal', 'modelInfo': modelInfoDict }) return bball_sin_model
def outer_sne(PC): print("Computing Outer SNE") PCargs = PyDSTool.args(name='SNE2', type='LP-C') PCargs.initpoint = 'EQ1:LP2' PCargs.freepars = ['ox', 'oy'] PCargs.MaxStepSize = 1e-10 PCargs.LocBifPoints = ['BT'] PCargs.MaxNumPoints = 1000 PC.newCurve(PCargs) PC['SNE2'].forward() return PC
def inner_outer_init(PC): print("Initialising boundary") PCargs = PyDSTool.args(name='EQ1', type='EP-C') PCargs.freepars = ['ox'] PCargs.MaxNumPoints = 200 PCargs.MaxStepSize = 0.001 PCargs.LocBifPoints = 'LP' PC.newCurve(PCargs) PC['EQ1'].forward() return PC
def trace_zero_lower(PC): print("Computing tr0 loop lower") PCargs = PyDSTool.args(name='TR02', type='H-C2') PCargs.initpoint = 'SNE1:BT2' PCargs.freepars = ['ox', 'oy'] PCargs.MaxStepSize = 1e-10 PCargs.LocBifPoints = ['BT'] PCargs.MaxNumPoints = 1600 PC.newCurve(PCargs) PC['TR02'].forward() return PC
def bifurk(cont, maxval, freepar): label = "EQ{}".format(len(cont.curves)) PCargs = dst.args(name=label, type="EP-C") PCargs.freepars = [freepar] PCargs.MaxNumPoints = 50 PCargs.StepSize = 1e-2 PCargs.MaxStepSize = 0.5 PCargs.LocBifPoints = ["LP"] PCargs.SaveEigen = True cont.newCurve(PCargs) while cont[label].parsdict[freepar] < maxval: cont[label].forward()
def bifurcation(self, mode='ode'): """Code to generate bifuraction diagrams using PYDSTool, not working framework to be added to Args: mode (str, optional): ode for the ode model and pde for the travelling wave pde model """ if mode == 'ode': DSargs = dst.args(name='oligodendrocyte calcium model') DSargs.pars = self.params DSargs.fnspecs = {} DSargs.varspecs = {} DSargs.ics = {} DSargs.tdomain = [0, self.tend] ode = dst.Generator.Vode_ODEsystem(DSargs) ode.set(pars={}) ode.set(ics={}) PC = dst.args(name='EQ1', type='EP-C') PCargs.freepars = [] PCargs.MaNumPoints = 450 PCargs.MaxStepSize = 2 PCargs.MinStepSize = 1e-5 PCargs.StepSize = 2e-2 PCargs.LocBifPoints = 'LP' # detect limit points / saddle-node bifurcations PCargs.SaveEigen = True # to tell unstable from stable branches PC.newCurve(PCargs) PC['EQ1'].forward() PC.display([], stability=True, figure=3) PC['EQ1'].info() print(PC['EQ1'].getSpecialPoint('')) if mode == 'pde': pass
def create_model(): pars = {'g': 9.8}#, 'pi': np.pi} #ODE ode_def = { 'x': 'vx', 'y': 'vy', 'vx': '-(pi**2)*x', 'vy': '-g', 'tt': '1.0', } event_bounce = dst.makeZeroCrossEvent( 'x-y', 1, {'name': 'bounce', 'eventtol': 1e-3, 'term': True, 'active': True, 'eventinterval': 1, 'eventdelay': 1e-2, 'starttime': 0, 'precise': True }, varnames=['x', 'y'], targetlang='python') # targetlang is redundant (defaults to python) DSargs = dst.args(name='bball_sin') # struct-like data DSargs.events = [event_bounce] #DSargs.pars = pars #DSargs.tdata = [0, 10] #DSargs.algparams = {'max_pts': 3000, 'stiff': False} DSargs.algparams = {'stiff': False, 'init_step': 0.01} DSargs.varspecs = ode_def DSargs.pars = pars #DSargs.xdomain = {'y': [0, 100]} DS_fall = dst.embed(dst.Generator.Vode_ODEsystem(DSargs)) DS_fall_MI = dst.intModelInterface(DS_fall) # Reset ev_map = dst.EvMapping({'y': 'x+0.001', 'vy': '0.9*(vx-vy)'}, model=DS_fall) #ev_map = dst.EvMapping({'y': '10', 'x': '20'}, model=DS_fall) DS_BBall = dst.makeModelInfoEntry(DS_fall_MI, ['bball_sin'], [('bounce', ('bball_sin', ev_map))]) modelInfoDict = dst.makeModelInfo([DS_BBall]) bball_sin_model = dst.Model.HybridModel( {'name': 'Bouncing_Ball_Sinusiodal', 'modelInfo': modelInfoDict}) return bball_sin_model
def make_shooter(): # no friction # cos(atan(x)) = 1/(sqrt(1+x^2)) Fx_str = '0' # '-speed_fn()*cos(atan2(vy,vx))' Fy_str = '-10' DSargs = dst.args() DSargs.varspecs = {'vx': Fx_str, 'x': 'vx', 'vy': Fy_str, 'y': 'vy', 'Fx_out': 'Fx(x,y)', 'Fy_out': 'Fy(x,y)', 'speed': 'speed_fn(vx, vy)', 'bearing': '90-180*atan2(vy,vx)/pi'} auxfndict = {'Fx': (['x', 'y'], Fx_str), 'Fy': (['x', 'y'], Fy_str), 'speed_fn': (['vx', 'vy'], 'sqrt(vx*vx+vy*vy)'), } DSargs.auxvars = ['Fx_out', 'Fy_out', 'speed', 'bearing'] DSargs.fnspecs = auxfndict DSargs.algparams = {'init_step':0.001, 'max_step': 0.1, 'max_pts': 20000, 'maxevtpts': 2, 'refine': 5} ground_event = dst.Events.makeZeroCrossEvent('y', -1, {'name': 'ground', 'eventtol': 1e-3, 'precise': True, 'term': True}, varnames=['y'], targetlang='python') peak_event = dst.Events.makeZeroCrossEvent('vy', -1, {'name': 'peak', 'eventtol': 1e-3, 'precise': True, 'term': False}, varnames=['vy'], targetlang='python') DSargs.events = [ground_event, peak_event] DSargs.checklevel = 2 DSargs.ics = {'x': 0, 'y': 0, 'vx': 0, 'vy': 0} DSargs.ics.update(make_vel_ics(5,20)) DSargs.name = 'cannon' DSargs.tdomain = [0, 100000] DSargs.tdata = [0, 10] return dst.embed(dst.Generator.Vode_ODEsystem(DSargs))
def args(): """ This function creates a PyDSTool 'args' object for the 'vanderpol' vector field. """ DSargs = PyDSTool.args() DSargs.name = 'vanderpol' DSargs.pars = {'epsilon':2.0000000000000001e-01} DSargs.varspecs = {'x':'( x+y+-3.3333333333333331e-01*(x*x*x))/epsilon', 'y':'-x'} DSargs.fnspecs = {'Jacobian': (['t', 'x', 'y'], """[[(-(x*x)+1.0)/epsilon, 1.0/(epsilon)], [-1.0, 0.0]]""")} DSargs.ics = {'x':1.0000000000000000e-02, 'y':0.0} DSargs.tdomain = [0,10] return DSargs
def args(): """ This function creates a PyDSTool 'args' object for the 'MorrisLecar' vector field. """ DSargs = PyDSTool.args() DSargs.name = 'MorrisLecar' DSargs.pars = {'gca':5.5000000000000000e+00, 'gk':8.0000000000000000e+00, 'gl':2.0000000000000000e+00, 'vca':1.1500000000000000e+02, 'vk':-8.4000000000000000e+01, 'vl':-5.5000000000000000e+01, 'c':2.0000000000000000e+01, 'phi':2.2000000000000000e-01, 'ic':9.0000000000000000e+01, 'v1':-1.2000000000000000e+00, 'v2':1.8000000000000000e+01, 'v3':2.0000000000000000e+00, 'v4':3.0000000000000000e+01} DSargs.varspecs = {'v':'-(1.0/2.0)*1.0/c*( 2.0*( v-vl)*gl-( vca-v)*gca*( tanh(-1.0/v2*( v1-v))+1.0)+-2.0*ic+-2.0*( vk-v)*gk*w)', 'w':'(1.0/2.0)*cosh(-(1.0/2.0)*( v3-v)/v4)*phi*( tanh(-( v3-v)/v4)+-2.0*w+1.0)'} DSargs.fnspecs = {'Jacobian': (['t', 'v', 'w'], """[[-(1.0/2.0)*1.0/c*( 2.0*gk*w+gca*( tanh(-1.0/v2*( v1-v))+1.0)+( vca-v)*gca/v2*( pow(tanh(-1.0/v2*( v1-v)),2.0)-1.0)+2.0*gl), 1.0/c*( vk-v)*gk], [-cosh(-(1.0/2.0)*( v3-v)/v4)*phi*( pow(tanh(-( v3-v)/v4),2.0)-1.0)/v4/2.0+sinh(-(1.0/2.0)*( v3-v)/v4)*phi*( tanh(-( v3-v)/v4)+-2.0*w+1.0)/v4/4.0, -cosh(-(1.0/2.0)*( v3-v)/v4)*phi]]""")} DSargs.ics = {'v':0.0, 'w':0.0} DSargs.tdomain = [0,10] return DSargs
def create_model(): pars = {'g': 1} icdict = {'y': 5, 'vy': 0} y_str = 'vy' vy_str = '-g' event_bounce = dst.makeZeroCrossEvent( 'y', 0, { 'name': 'bounce', 'eventtol': 1e-3, 'term': True, 'active': True }, varnames=['y'], parnames=['g'], targetlang='python') # targetlang is redundant (defaults to python) DSargs = dst.args(name='bball') # struct-like data DSargs.events = [event_bounce] #DSargs.pars = pars #DSargs.tdata = [0, 10] #DSargs.algparams = {'max_pts': 3000, 'stiff': False} DSargs.algparams = {'stiff': False} DSargs.varspecs = {'y': y_str, 'vy': vy_str} DSargs.pars = pars #DSargs.xdomain = {'y': [0, 100], 'vy': [-100, 100]} DSargs.ics = icdict DS_fall = dst.embed(dst.Generator.Vode_ODEsystem(DSargs)) DS_fall_MI = dst.intModelInterface(DS_fall) ev_map = dst.EvMapping({'y': 0, 'vy': '-0.75*vy'}, model=DS_fall) DS_BBall = dst.makeModelInfoEntry(DS_fall_MI, ['bball'], [('bounce', ('bball', ev_map))]) modelInfoDict = dst.makeModelInfo([DS_BBall]) bball_model = dst.Model.HybridModel({ 'name': 'Bouncing_Ball', 'modelInfo': modelInfoDict }) return bball_model
def build_lin(): # make local linear system spec if can_cache: print("I'm not building this model twice!") DSargs = dst.args(name='lin') xfn_str = '(x0+yfx*y - x)/taux' yfn_str = '(y0+xfy*x - y)/tauy' DSargs.varspecs = {'x': xfn_str, 'y': yfn_str} DSargs.xdomain = {'x': xdom, 'y': ydom} DSargs.pars = {'x0': xdom_half, 'y0': ydom_half, 'xfy': 1, 'yfx': 1, 'taux': 1, 'tauy': 1} DSargs.algparams = {'init_step':0.001, 'max_step': 0.001, 'max_pts': 10000} DSargs.checklevel = 0 DSargs.tdata = [0, 10] DSargs.ics = {'x': xdom_half*1.1, 'y': ydom_half*1.1} DSargs.fnspecs = {'Jacobian': (['t', 'x', 'y'], """[[-1/taux, yfx/taux], [xfy/tauy, -1/tauy]]""")} return dst.embed(dst.Generator.Vode_ODEsystem(DSargs))
def create_model(): pars = {'g': 1} icdict = {'y': 5, 'vy': 0} y_str = 'vy' vy_str = '-g' event_bounce = dst.makeZeroCrossEvent('y', 0, {'name': 'bounce', 'eventtol': 1e-3, 'term': True, 'active': True}, varnames=['y'], parnames=['g'], targetlang='python') # targetlang is redundant (defaults to python) DSargs = dst.args(name='bball') # struct-like data DSargs.events = [event_bounce] #DSargs.pars = pars #DSargs.tdata = [0, 10] #DSargs.algparams = {'max_pts': 3000, 'stiff': False} DSargs.algparams = {'stiff': False} DSargs.varspecs = {'y': y_str, 'vy': vy_str} DSargs.pars = pars #DSargs.xdomain = {'y': [0, 100], 'vy': [-100, 100]} DSargs.ics = icdict DS_fall = dst.embed(dst.Generator.Vode_ODEsystem(DSargs)) DS_fall_MI = dst.intModelInterface(DS_fall) ev_map = dst.EvMapping({'y': 0, 'vy': '-0.75*vy'}, model=DS_fall) DS_BBall = dst.makeModelInfoEntry(DS_fall_MI, ['bball'], [('bounce', ('bball', ev_map))]) modelInfoDict = dst.makeModelInfo([DS_BBall]) bball_model = dst.Model.HybridModel({'name': 'Bouncing_Ball', 'modelInfo': modelInfoDict}) return bball_model
def cont(model, maxnum=450,maxstep=2.0,minstep=1e-5,stepsize=2e-2,direction="forward"): ode = dst.Generator.Vode_ODEsystem(model) # Prepare the system to start close to a steady state # ode.set(pars = {'p': 0.078} ) # Lower bound of the control parameter 'i' # ode.set(ics = {'b': 0.0, 'w': 0.0} ) # Close to one of the steady states present for i=-220 PC = dst.ContClass(ode) # Set up continuation class PCargs = dst.args(name='EQ1', type='EP-C') # 'EP-C' stands for Equilibrium Point Curve. The branch will be labeled 'EQ1'. PCargs.freepars = ['p'] # control parameter(s) (it should be among those specified in DSargs.pars) PCargs.MaxNumPoints = maxnum # The following 3 parameters are set after trial-and-error PCargs.MaxStepSize = maxstep PCargs.MinStepSize = minstep PCargs.StepSize = stepsize PCargs.LocBifPoints = 'LP' # detect limit points / saddle-node bifurcations PCargs.SaveEigen = True PC.newCurve(PCargs) if direction == "forward": PC['EQ1'].forward() elif direction=="backward": PC['EQ1'].backward() PC.display(['p','b'], stability=True, figure=3) # stable and unstable branches as solid and dashed curves, resp. return PC
def gchidp_model(pars): """Creates PyDSTool DSargs object for the 'ChI' model vector field """ auxfuncs = { 'hill': (['x', 'k', 'n'], 'pow(x,n)/(pow(x,n)+pow(k,n))'), 'minf': (['ip3'], 'hill(ip3,d1,1)'), 'ninf': (['ca'], 'hill(ca,d5,1)'), 'Jchan': (['ca', 'h', 'ip3'], 'rc*pow(minf(ip3)*ninf(ca)*h,3)*(c0-(1+c1)*ca)'), 'Jleak': (['ca'], 'rl*(c0-(1+c1)*ca)'), 'Jpump': (['ca'], 'ver*hill(ca,KER,2)'), 'vglu': (['gammaa'], 'vbeta*gammaa'), 'vplcd': (['ca', 'ip3'], 'vdelta/(1+ip3/kappad)*hill(ca,Kdelta,2)'), 'v3keff': (['ca', 'ip3'], 'v3k*hill(ca,Kd,4)*hill(ip3,K3,1)'), 'v5peff': (['ip3'], 'r5p*ip3'), 'vpkc': (['ca', 'dag'], 'vkd*dag*hill(ca,Kkc,1)'), 'vdagk': (['ca', 'dag'], 'vd*hill(ca,Kdc,2)*hill(dag,Kdd,2)') } rhs = { 'gammaa': 'Op*(1-gammaa)*yrel-OmegaP*(1+vk*pkc/OmegaP)*gammaa', 'ip3': 'vbias+vglu(gammaa)+vplcd(ca,ip3)-v3keff(ca,ip3)-v5peff(ip3)', 'ca': 'Jchan(ca,h,ip3)-Jpump(ca)+Jleak(ca)', 'h': '(a2*d2*(ip3+d1)/(ip3+d3))*(1-h)-a2*ca*h', 'dag': 'vbias+vglu(gammaa)+vplcd(ca,ip3)-vpkc(ca,dag)-vdagk(ca,dag)-OmegaD*dag', 'pkc': 'vpkc(ca,dag)-OmegaKD*pkc' } ICs = {'gammaa': 0, 'ip3': 0, 'ca': 0, 'h': 0.9, 'dag': 0, 'pkc': 0} DSargs = dst.args(name='GChIDP') DSargs.pars = pars DSargs.fnspecs = auxfuncs DSargs.varspecs = rhs DSargs.ics = ICs return DSargs
def SPoCK_plot_traj(alt_ics_dict, exp_num): pardict, fndict, vardict, icsdict = init_SPoCK() DSargs = dst.args() DSargs.pars = pardict DSargs.varspecs = vardict DSargs.fnspecs = fndict DSargs.ics = alt_ics_dict #Load initial conditions given my argument DSargs.name = 'SPoCK' DSargs.tdata = [0, 600] DSargs.xdomain = { 'X': [0, 10**9], 'Y': [0, 10**9], 'A': [0, 10**9], 'B': [0, 10**9], } spock_ode = dst.Vode_ODEsystem(DSargs) fixedpoints_csv_path = "/Users/behzakarkaria/Documents/UCL/Barnes Lab/PhD Project/research_code/SPoCK_model/parameter_csv/fixedponts.csv" plot_out_path = "/Users/behzakarkaria/Documents/UCL/Barnes Lab/PhD Project/research_code/SPoCK_model/parameter_csv/fixedpoint_plots/" traj = spock_ode.compute('traj_1') pts = traj.sample() with PdfPages(plot_out_path + "exp_" + str(exp_num) + ".pdf") as pdf: plt.figure(1) plt.plot(pts['t'], pts['X'], label="X") plt.plot(pts['t'], pts['Y'], label="Y") plt.xlabel("t") plt.ylabel("population") plt.yscale('log') plt.legend(loc=4) # bottom left location pdf.savefig(plt.figure(1)) plt.show() plt.close()
''' Created on Jul 18, 2016 @author: andrewkennedy ''' import PyDSTool as dst import numpy as np from matplotlib import pyplot as plt # we must give a name DSargs = dst.args(name='Calcium channel model') # parameters DSargs.pars = { 'vl': -60, 'vca': 120, 'i': 0, 'gl': 2, 'gca': 4, 'c': 20, 'v1': -1.2, 'v2': 18 } # auxiliary helper function(s) -- function name: ([func signature], definition) DSargs.fnspecs = {'minf': (['v'], '0.5 * (1 + tanh( (v-v1)/v2 ))') } # rhs of the differential equation, including dummy variable w DSargs.varspecs = {'v': '( i + gl * (vl - v) - gca * minf(v) * (v-vca) )/c', 'w': 'v-w' } # initial conditions DSargs.ics = {'v': 0, 'w': 0 } DSargs.tdomain = [0,30] # set the range of integration. ode = dst.Generator.Vode_ODEsystem(DSargs) # an instance of the 'Generator' class. traj = ode.compute('polarization') # integrate ODE
import PyDSTool as dst from PyDSTool.Toolbox import phaseplane as pp #initialize model parameters structure DSargs = dst.args(name='Decision_making_model') #model parameters DSargs.pars = {'tauS' : 0.06, 'gam' : 0.641, 'a' : 270.0, 'b' : 108.0, 'd' : 0.154, 'J11' : 0.3725, 'J12' : 0.1137, #'I0' : 0.3297, 'I1' : 0, 'I2' : 0 'I0' : 0.3297, 'I1' : 0.035, 'I2' : 0.0351 #'I0' : 0.3297, 'I1' : 0.03, 'I2' : 0.04 #'I0' : 0.3297, 'I1' : 0, 'I2' : 0.07 } # auxiliary functions: fI-curce and recurrent current DSargs.fnspecs = {'fRate' : (['I'], '(a*I-b)/(1.0-exp(-d*(a*I-b)))'), 'recCurr' : (['x','y'], 'J11*x-J12*y+I0') } # rhs of the differential equations DSargs.varspecs = { 's1': '-s1/tauS+(1-s1)*gam*fRate(recCurr(s1,s2)+I1)', 's2': '-s2/tauS+(1-s2)*gam*fRate(recCurr(s2,s1)+I2)'} # initial conditions DSargs.ics = {'s1': 0.06,
import PyDSTool from pylab import plot, show, linspace, xlabel, ylabel # we must give a name DSargs = PyDSTool.args(name='Calcium') # parameters DSargs.pars = { 'vl': -60, 'vca': 120, 'i': 0, 'gl': 2, 'gca': 4, 'c': 20, 'v1': -1.2, 'v2': 18 } # auxiliary helper function(s) DSargs.fnspecs = {'minf': (['v'], '0.5 * (1 + tanh( (v-v1)/v2 ))')} # rhs of the differential equation, including dummy variable w DSargs.varspecs = { 'v': '( i + gl * (vl - v) - gca * minf(v) * (v-vca) )/c', 'w': 'v-w' } # initial conditions DSargs.ics = {'v': 0, 'w': 0} DSargs.tdomain = [0, 40] # set the range of integration. ode = PyDSTool.Generator.Vode_ODEsystem( DSargs) # an instance of the 'Generator' class. traj = ode.compute('polarization') # pd = traj.sample() # Data for plotting
pl.rc('axes', linewidth=1) pl.rc('lines', markeredgewidth=1, antialiased=True) pl.rcParams['xtick.major.pad'] = '1' pl.rcParams['ytick.major.pad'] = '1' pl.rcParams['axes.labelpad'] = '1' pl.rcParams['xtick.labelsize'] = '7' pl.rcParams['ytick.labelsize'] = '7' pl.rcParams['font.size'] = '7' pl.rcParams['font.sans-serif'] = "Arial" pl.rcParams['font.family'] = 'sans-serif' pl.rcParams['pdf.fonttype'] = 42 pl.rcParams['ps.fonttype'] = 42 #==============================================================================# # we must give a name DSargs = dst.args(name='Two Cells Delta-Notch Model') sx = 2. sy = 1.5 tscale = 100. DSargs.pars = { 'g': 1e-1, 'gi': 5e-1, 'kc': 5e-4, 'kt': 2e-4, 's0': 2e2, 'n0': 5e2, 'd0': 1e3, 'i0': 0., 'ln': 2., 'ld': 0.,
# no1_ant = 20e3 k7 = 800.0 #0.74 k8 = 0.7 #0.05 k9 = 0.58 #0.37 k10 = 0.48#0.47 no_atp = 3800 #number of atphase cm = 3e3 #nr.of particles = 12mM #adp+atp = cm a12 = 24 a21 = 40.0 a23 = 4.0 a32 = 5e3 DSargs = PyDSTool.args(name='ex') DSargs.pars = { 'k1_on':'4.0',# #KDo 'k1_off':'100', # #KDo 'k2_on': '6.4',# #KTi 'k2_off':'40000.0',# #KTi 'k5_on':'0.4', #KTo 'k5_off':'200.0', #KTo 'k6_on':'4.0', #KDi 'k6_off':'40000.0', #KDi 'k7': k7, #kp 'k8': k8, #kcp 'k9': k9, #kt 'k10': k10, #kd 'no_ant': no1_ant, 'a12': a12, #s-1
def SPoCK_phase_plane(fixed_points_dict): pardict, fndict, vardict, icsdict = init_SPoCK() DSargs = dst.args() DSargs.pars = pardict DSargs.varspecs = vardict DSargs.fnspecs = fndict DSargs.ics = icsdict DSargs.name = 'SPoCK' DSargs.tdata = [0, 1500] DSargs.xdomain = { 'X': [0, 10**9], 'Y': [0, 10**9], 'A': [0, 10**9], 'B': [0, 10**9], } spock_ode = dst.Vode_ODEsystem(DSargs) print("loaded ode system") #pp.plot_PP_vf(spock_ode, 'X', 'Y', scale_exp=0, N=50, subdomain={'X':[X_lower ,X_Upper], 'Y':[Y_lower,Y_Upper]} ) #plot vector field #ax.quiver(X_quiv, Y_quiv, dxs, dys, angles='xy', pivot='middle', units='inches', ) plt.figure(1) fig, ax = plt.subplots(figsize=(18, 12.5)) ax.set_xscale('log', basex=10) ax.set_yscale('log', basey=10) ax.set_xlim(10**0, 10**8) ax.set_ylim(10**0, 10**9) ax = custom_PP_vf_2(spock_ode, 'X', 'Y', ax, scale_exp=-1, N=150, subdomain={ 'X': [0, 9], 'Y': [0, 9] }) #ax = custom_PP_vf_2(spock_ode, 'X', 'Y', ax, scale_exp=-1, N=50, subdomain={'X': [2, 4], 'Y': [2, 3]}) print("finished plotting vf") # subdomain = {'X': [0, 0.7e9], 'A': [0, 0.8e9] count = 0 for dict in fixed_points_dict: DSargs = dst.args() DSargs.pars = pardict DSargs.varspecs = vardict DSargs.fnspecs = fndict DSargs.ics = dict DSargs.name = 'SPoCK' DSargs.tdata = [0, 600] DSargs.xdomain = { 'X': [0, 10**9], 'Y': [0, 10**9], 'A': [0, 10**9], 'B': [0, 10**9], } spock_ode = dst.Vode_ODEsystem(DSargs) traj = spock_ode.compute('traj_1') try: pts = traj.sample() except AttributeError: print("No solution found") continue ax.plot(pts['X'], pts['Y']) #ax.plot(pts['t'], pts['B']) plt.xlabel('X') plt.ylabel('Y') print(count) count = count + 1 phase_plot_path = "/Users/behzakarkaria/Documents/UCL/Barnes Lab/PhD Project/research_code/SPoCK_model/parameter_csv/" pdf_page_obj = PdfPages(phase_plot_path + "phase_plots_5_fp" + ".pdf") pdf_page_obj.savefig(ax.get_figure()) pdf_page_obj.close() plt.show()
def SPoCK_find_fixedpoints(): pardict, fndict, vardict, icsdict = init_SPoCK() DSargs = dst.args() DSargs.pars = pardict DSargs.varspecs = vardict DSargs.fnspecs = fndict DSargs.ics = icsdict DSargs.name = 'SPoCK' DSargs.tdata = [0, 50000] DSargs.xdomain = { 'X': [0, 10**9], 'Y': [0, 10**9], 'A': [0, 10**9], 'B': [0, 10**9], } spock_ode = dst.Vode_ODEsystem(DSargs) jac_fun = make_jac_pydstool(spock_ode) fp_coords = pp.find_fixedpoints(spock_ode, n=10, eps=1e-50, jac=jac_fun, subdomain={ 'X': [0, 10**9], 'Y': [0, 10**9], 'A': [0, 10**9], 'B': [0, 10**9] }) fixedpoints_pdf_path = "/Users/behzakarkaria/Documents/UCL/Barnes Lab/PhD Project/research_code/SPoCK_model/parameter_csv/" plt.figure(1) fig, ax = plt.subplots(figsize=(18, 12.5)) ax.set_xscale('symlog', basex=10) ax.set_yscale('symlog', basey=10) ax.set_ylim(0, 10**9) ax.set_xlim(0, 10**9) good_coords = [] for fp in fp_coords: try: fp_obj = pp.fixedpoint_nD( spock_ode, dst.Point(fp), coords=fp, jac=jac_fun, eps=1e-20 ) #Does he tolerance here matter when we find the points above with a good tolerance? good_coords.append(fp) except: continue if fp_obj.stability == 'u': style = 'wo' elif fp_obj.stability == 'c': style = 'co' else: # 's' style = 'ko' print("") print(fp_obj.stability) print('X:', fp_obj.fp_coords['X']) print('Y:', fp_obj.fp_coords['Y']) print("") try: ax.plot(fp_obj.fp_coords['X'], fp_obj.fp_coords['Y'], style) except ValueError: continue plt.xlabel("X") plt.ylabel("Y") #plt.title('Fixed points \n w = 1*10**-2, D = 0.2 ') pdf_page_obj = PdfPages(fixedpoints_pdf_path + "fixedpoints_XY" + ".pdf") pdf_page_obj.savefig(ax.get_figure()) pdf_page_obj.close() fixedpoints_csv_path = "/Users/behzakarkaria/Documents/UCL/Barnes Lab/PhD Project/research_code/SPoCK_model/parameter_csv/fixedponts.csv" fieldnames = ('index', 'X', 'Y', 'A', 'B') index = 0 for fp_dict in good_coords: fp_dict['index'] = index index = index + 1 data_frame = pd.DataFrame.from_records(good_coords) data_frame.to_csv(fixedpoints_csv_path)
def build_sys(): # we must give a name DSargs = dst.args(name='M345_A3_Bead_on_a_rotating_hoop') # parameters DSargs.pars = {'g': 0, 'd': 0.3} # rhs of the differential equation DSargs.varspecs = { 'phi': 'nu', 'nu': '-d*nu + g*sin(phi)*cos(phi) - sin(phi)' } # initial conditions DSargs.ics = {'phi': 0, 'nu': 0} # set the domain of integration. # (increased domain size to explore around phi=-pi saddle) DSargs.xdomain = {'phi': [-2 * np.pi, 2 * np.pi], 'nu': [-4, 4]} # allow tdomain to be infinite, set default tdata here DSargs.tdata = [0, 50] # to avoid typos / bugs, use built-in Symbolic differentation! f = [DSargs.varspecs['phi'], DSargs.varspecs['nu']] Df = dst.Diff(f, ['phi', 'nu']) DSargs.fnspecs = { 'Jacobian': (['t', 'phi', 'nu'], str(Df.renderForCode())) } # yields """[[0, 1], [g*cos(phi)*cos(phi) - g*sin(phi)*sin(phi) - cos(phi), -d]]""")} print("Jacobian computed as:\n" + str(Df.renderForCode())) # Make auxiliary functions to define event lines near saddle res = pp.make_distance_to_line_auxfn('Gamma_out_plus', 'Gamma_out_plus_fn', ('phi', 'nu'), True) man_pars = res['pars'] man_auxfns = res['auxfn'] res = pp.make_distance_to_line_auxfn('Gamma_out_minus', 'Gamma_out_minus_fn', ('phi', 'nu'), True) man_pars.extend(res['pars']) man_auxfns.update(res['auxfn']) # update param values with defaults (0) for p in man_pars: DSargs.pars[p] = 0 if gentype in [ dst.Generator.Vode_ODEsystem, dst.Generator.Euler_ODEsystem ]: targetlang = 'python' else: targetlang = 'c' DSargs.fnspecs.update(man_auxfns) ev_plus = dst.Events.makeZeroCrossEvent(expr='Gamma_out_plus_fn(%s,%s)' % ('phi', 'nu'), dircode=0, argDict={ 'name': 'Gamma_out_plus', 'eventtol': 1e-5, 'eventdelay': 1e-3, 'starttime': 0, 'precise': False, 'active': False, 'term': True }, targetlang=targetlang, varnames=['phi', 'nu'], fnspecs=man_auxfns, parnames=man_pars) ev_minus = dst.Events.makeZeroCrossEvent(expr='Gamma_out_minus_fn(%s,%s)' % ('phi', 'nu'), dircode=0, argDict={ 'name': 'Gamma_out_minus', 'eventtol': 1e-5, 'eventdelay': 1e-3, 'starttime': 0, 'precise': False, 'active': False, 'term': True }, targetlang=targetlang, varnames=['phi', 'nu'], fnspecs=man_auxfns, parnames=man_pars) DSargs.events = [ev_plus, ev_minus] # an instance of the 'Generator' class. print "Initializing generator..." return gentype(DSargs)
import MorrisLecar # Use the function created by VFGEN to define the 'args' object for # the Morris-Lecar system. ds = MorrisLecar.args() # Set ics to (1.5,0). This is not an equilibrium point, but # with these values, the PyCont code will find one. ds.ics = {'v': 1.5, 'w': 0.0} ode = PyDSTool.Generator.Vode_ODEsystem(ds) cont = PyDSTool.ContClass(ode) print "Setting up for one parameter continuation of an equilibrium point." PCargs = PyDSTool.args(name='EQ1', type='EP-C') PCargs.freepars = ['ic'] PCargs.StepSize = 1e-3 PCargs.MaxNumPoints = 200 PCargs.MaxStepSize = 0.2 PCargs.LocBifPoints = ['LP', 'H', 'BP'] print "Computing the curve." cont.newCurve(PCargs) cont['EQ1'].forward() print "Setting up for two parameter continuation of the Hopf point." PCargs = PyDSTool.args(name='Hopf', type='H-C2') PCargs.initpoint = 'EQ1:H1' PCargs.freepars = ['ic', 'gca'] PCargs.MaxStepSize = 1.0
import PyDSTool from pylab import plot, show, linspace, xlabel, ylabel # we must give a name DSargs = PyDSTool.args(name='Calcium') # parameters DSargs.pars = { 'vl': -60, 'vca': 120, 'i': 0, 'gl': 2, 'gca': 4, 'c': 20, 'v1': -1.2, 'v2': 18 } # auxiliary helper function(s) DSargs.fnspecs = {'minf': (['v'], '0.5 * (1 + tanh( (v-v1)/v2 ))') } # rhs of the differential equation, including dummy variable w DSargs.varspecs = {'v': '( i + gl * (vl - v) - gca * minf(v) * (v-vca) )/c', 'w': 'v-w' } # initial conditions DSargs.ics = {'v': 0, 'w': 0 } DSargs.tdomain = [0,40] # set the range of integration. ode = PyDSTool.Generator.Vode_ODEsystem(DSargs) # an instance of the 'Generator' class. traj = ode.compute('polarization') # pd = traj.sample() # Data for plotting plot(pd['t'], pd['v']) xlabel('time') # Axes labels ylabel('voltage') # ... show()
def build_sys(): # we must give a name DSargs = dst.args(name='M345_A3_Bead_on_a_rotating_hoop') # parameters DSargs.pars = {'g': 0, 'd': 0.3} # rhs of the differential equation DSargs.varspecs = {'phi': 'nu', 'nu': '-d*nu + g*sin(phi)*cos(phi) - sin(phi)'} # initial conditions DSargs.ics = {'phi': 0, 'nu': 0} # set the domain of integration. # (increased domain size to explore around phi=-pi saddle) DSargs.xdomain = {'phi': [-2*np.pi, 2*np.pi], 'nu': [-4, 4]} # allow tdomain to be infinite, set default tdata here DSargs.tdata = [0, 50] # to avoid typos / bugs, use built-in Symbolic differentation! f = [DSargs.varspecs['phi'], DSargs.varspecs['nu']] Df=dst.Diff(f, ['phi', 'nu']) DSargs.fnspecs = {'Jacobian': (['t','phi','nu'], str(Df.renderForCode()))} # yields """[[0, 1], [g*cos(phi)*cos(phi) - g*sin(phi)*sin(phi) - cos(phi), -d]]""")} print("Jacobian computed as:\n" + str(Df.renderForCode())) # Make auxiliary functions to define event lines near saddle res = pp.make_distance_to_line_auxfn('Gamma_out_plus', 'Gamma_out_plus_fn', ('phi','nu'), True) man_pars = res['pars'] man_auxfns = res['auxfn'] res = pp.make_distance_to_line_auxfn('Gamma_out_minus', 'Gamma_out_minus_fn', ('phi','nu'), True) man_pars.extend(res['pars']) man_auxfns.update(res['auxfn']) # update param values with defaults (0) for p in man_pars: DSargs.pars[p] = 0 if gentype in [dst.Generator.Vode_ODEsystem, dst.Generator.Euler_ODEsystem]: targetlang = 'python' else: targetlang = 'c' DSargs.fnspecs.update(man_auxfns) ev_plus = dst.Events.makeZeroCrossEvent(expr='Gamma_out_plus_fn(%s,%s)'%('phi','nu'), dircode=0, argDict={'name': 'Gamma_out_plus', 'eventtol': 1e-5, 'eventdelay': 1e-3, 'starttime': 0, 'precise': False, 'active': False, 'term': True}, targetlang=targetlang, varnames=['phi','nu'], fnspecs=man_auxfns, parnames=man_pars ) ev_minus = dst.Events.makeZeroCrossEvent(expr='Gamma_out_minus_fn(%s,%s)'%('phi','nu'), dircode=0, argDict={'name': 'Gamma_out_minus', 'eventtol': 1e-5, 'eventdelay': 1e-3, 'starttime': 0, 'precise': False, 'active': False, 'term': True}, targetlang=targetlang, varnames=['phi','nu'], fnspecs=man_auxfns, parnames=man_pars ) DSargs.events = [ev_plus, ev_minus] # an instance of the 'Generator' class. print("Initializing generator...") return gentype(DSargs)
def SPoCK_bifurcation(alt_ics_dict): pardict, fndict, vardict, icsdict = init_SPoCK() DSargs = dst.args() DSargs.pars = pardict DSargs.varspecs = vardict DSargs.fnspecs = fndict DSargs.ics = alt_ics_dict DSargs.name = 'SPoCK' DSargs.tdata = [0, 10000] DSargs.xdomain = { 'X': [0, 10**9], 'Y': [0, 10**9], 'A': [0, 10**9], 'B': [0, 10**9], } spock_ode = dst.Vode_ODEsystem(DSargs) #spock_ode.set(pars = {'w': 1} ) # Lower bound of the control parameter 'i' #traj = spock_ode.compute('test_trj') # integrate ODE # setup continuation class PC = dst.ContClass(spock_ode) PCargs = dst.args(name='EQ1', type='EP-C') PCargs.freepars = ['A_c'] PCargs.StepSize = 10 PCargs.MaxNumPoints = 10000 PCargs.MaxStepSize = 20 PCargs.MinStepSize = 10 PCargs.MaxTestIters = 10000 PCargs.LocBifPoints = 'all' PCargs.SaveEigen = True PCargs.verbosity = 2 PC.newCurve(PCargs) PC['EQ1'].backward() print(PC['EQ1'].info()) PCargs = dst.args(name='EQ2', type='EP-C') PCargs.initpoint = 'EQ1:H1' PCargs.freepars = ['A_c'] PCargs.StopAtPoints = ['BP'] PCargs.MaxNumPoints = 10 PCargs.MaxStepSize = 20 PCargs.MinStepSize = 10 PCargs.StepSize = 10 PCargs.LocBifPoints = 'all' PCargs.SaveEigen = True PC.newCurve(PCargs) PC['EQ2'].forward() plot_out_path = "/Users/behzakarkaria/Documents/UCL/Barnes Lab/PhD Project/research_code/SPoCK_model/parameter_csv/fixedpoint_plots/" with PdfPages(plot_out_path + "bifurcation_Ac_X" + ".pdf") as pdf: fig1 = plt.figure(1) ax = fig1.add_subplot(figsize=(18, 12.5)) #ax.set_xlim(10**0, 10**9) #ax.set_ylim(10**0, 10**9) #ax.set_xscale('symlog', basex=10) #ax.set_yscale('symlog', basey=10) PC.display(('A_c', 'X'), stability=True) pdf.savefig(fig1) with PdfPages(plot_out_path + "bifurcation_Ac_Y" + ".pdf") as pdf: fig2 = plt.figure(2) fig2.add_subplot(figsize=(18, 12.5)) ax2 = plt.gca() #ax2.set_xlim(0, 10**9) #ax2.set_ylim(0, 10**9) #ax2.set_xscale('symlog', basex=10) #ax2.set_yscale('symlog', basey=10) PC.display(('A_c', 'X'), stability=True, figure=fig2) pdf.savefig(ax2.get_figure())
import PyDSTool as dst import numpy as np from matplotlib import pyplot as plt import time # we must give a name DSargs = dst.args(name='Calcium channel model') # parameters DSargs.pars = { 'vl': -60, 'vca': 120, 'i': 0, 'gl': 2, 'gca': 4, 'c': 20, 'v1': -1.2, 'v2': 18 } # auxiliary helper function(s) -- function name: ([func signature], definition) DSargs.fnspecs = {'minf': (['v'], '0.5 * (1 + tanh( (v-v1)/v2 ))')} # rhs of the differential equation, including dummy variable w DSargs.varspecs = { 'v': '( i + gl * (vl - v) - gca * minf(v) * (v-vca) )/c', 'w': 'v-w' } # initial conditions DSargs.ics = {'v': 0, 'w': 0} DSargs.tdomain = [0, 30] # set the range of integration. ode = dst.Generator.Vode_ODEsystem( DSargs) # an instance of the 'Generator' class.
DSargs.events = [ground_event, peak_event] DSargs.checklevel = 2 DSargs.ics = {'x': 0, 'y': 0, 'vx': 0, 'vy': 0} DSargs.ics.update(make_vel_ics(5,20)) DSargs.name = 'cannon' DSargs.tdomain = [0, 100000] DSargs.tdata = [0, 10] return dst.embed(dst.Generator.Vode_ODEsystem(DSargs)) shooter = make_shooter() # sim.model is a PyDSTool Model sim = dst.args(tracked_objects=[], model=shooter, name='sim_cannon_traj', pts=None) calc = cc.calc_context(sim, 'cannon_traj') w = calc.workspace shot_num = 0 def go(speed, angle, do_tracker=True): global shot_num, w shot_num += 1 w.angle = angle w.speed = speed sim.model.set(ics=make_vel_ics(speed, angle)) sim.model.compute('shot%i' % shot_num)
import PyDSTool as pd ######################################################################### # Test Models ######################################################################### # Fitzhugh Nagumo Model fhn_ds_args = pd.args() fhn_ds_args.name = 'Fitzhugh_Nagumo' fhn_ds_args.fnspecs = {'Jacobian': (['t', 'V', 'R'], """[[c*(V + pow(V, 2.)), c], [-1/c, -b/c]]"""), 'Vdot': (['V', 'R'], "c*(V - pow(V, 3.)/3. + R)"), 'Rdot': (['V', 'R'], "-(V + a - b*R)/c")} fhn_ds_args.varspecs = {'V': 'Vdot(V, R)', 'R': 'Rdot(V, R)'} fhn_ds_args.ics = {'V': -1., 'R': 1.} fhn_ds_args.pars = {'a': 0.2, 'b': 0.2, 'c': 3.0} fhn_ds_args.algparams = {'max_pts': 1000000} fhn_ds_args.tdata = [0., 20.] # Goodwin Oscillator (3 components) goodwin3_args = pd.args() goodwin3_args.name = 'Goodwin Oscillator (3 Components)' goodwin3_args.fnspecs = {'Jacobian': (['t', 'X1', 'X2', 'X3'], """[[ , , ] [ , , ] [ , , ]]"""), 'X1dot': (['X1', 'X2', 'X3'], "v0/(1 + pow(X3/Km, p) - k1*X1"),
def solve(self, time_points, terminate=None): # Common parts as superclass if terminate is None: terminate = lambda u, t, step_no: False self.t = np.asarray(time_points) self.initialize_for_solve() N = self.t.size - 1 # no of intervals self.validate_data() # As a main designing priciple of PyDSTool, most of data structures in # PyDSTool are index-free. That is, the numerical data are stored mainly # through Python dictionaries with string keys. # Start setting for PyDSTool import PyDSTool neq, f, u0 = self.neq, self.f, self.U0 # Initialize variables as trajectories in PyDSTOOL # Each item of u has to be defined separately: y0,y1,y2,... name_list = ["y%d" % i for i in range(neq)] y, t, ydot = [PyDSTool.Var(name) for name in name_list], PyDSTool.Var("t"), [] # f has to be wrapped from f(y,t) to f(y0,y1,y2,...,t) f_wrap = eval("lambda *args: f(args[:-1], args[-1])") # f_wrap = eval('lambda *args: f(args[:-1], args[-1])', locals()) # Error # f_wrap = lambda *args: f(args[:-1], args[-1]) # Error! # Define differiential functions in PyDSTOOL, item by item string2 = ",".join(["y[%d]" % i for i in range(neq)]) # y[0],y[1],y[2],... ydot = [eval('PyDSTool.Fun(f_wrap(%s,t)[%d],[%s],"ydot%d")' % (string2, i, string2, i)) for i in range(neq)] # Jacobian matrix if getattr(self, "jac") is None: # apply Diff() to calculate jacobian matrix approximately. # Diff will return a QuantSpecct object F = eval('PyDSTool.Fun(f_wrap(%s,t),[%s],"F")' % (string2, string2)) JAC = eval('PyDSTool.Fun(PyDSTool.Diff(F,[%s]),[t,%s],"JAC")' % (string2, string2)) else: jac = self.jac # Wrap user-supplied jacobian function in the same manner as f # jac_wrap = lambda *args: jac(args[1:],args[0]) # Error jac_wrap = eval("lambda *args: jac(args[1:],args[0])") JAC = eval('PyDSTool.Fun(jac_wrap(t,%s),[t,%s],"JAC")' % (string2, string2)) # Settings in PyDSTOOL DSargs = PyDSTool.args(name="pydstest", checklevel=2) # Function set is {JAC, ydot[0],ydot[1],...} string3 = ",".join(["ydot[%d]" % i for i in range(neq)]) DSargs.fnspecs = eval("[JAC,%s]" % string3) # Variable set is {y[i]:ydot[i](y[0],y[1]...)} for any i from 0 to neq-1 string4 = ",".join(["y[%d]: ydot[%d](%s)" % (i, i, string2) for i in range(neq)]) DSargs.varspecs = eval("{%s}" % string4) # Time domain DSargs.tdomain = [time_points[0], time_points[-1]] # Initial status {y[0]:self.U0[0],y[1]:self.U0[1],...} string5 = ",".join(["y[%d]:%g" % (i, self.U0[i]) for i in range(neq)]) DSargs.ics = eval("{%s}" % string5) # Optional parameters DSargs.algparams = getattr(self, "params_pydstool", {}) # Start computation test = eval(self._name_pydstool)(DSargs) result = test.compute("test", "c") # A trajectory returned # Extract and set values at points in time range self.u = np.asarray([[result(time)["y%d" % j] for j in range(neq)] for time in time_points]) return self.u, self.t
OMEGA = 2.0 # Forcing frequency omega0 = 1.0 # Stiffness coefficient (=squared natural freq. if omega02>0) beta = 0.1 # Damping coefficient # Set values of initial conditions theta0 = np.pi/10.0 # Angle at t = 0 v0 = 0.0 # Angular velocity at t = 0 # Set simulation parameters tstart = 0 # Start time for for the simulation tstop = 20.0*2.0*np.pi # Ending time for the simulation nSimTimeSteps = 100 # Number of timesteps per period of the excitation for timestep = 2*np.pi/OMEGA / nSimTimeSteps # name (no spaces allowed) DSargs = dst.args(name='Duffing_Oscillator') # parameters DSargs.pars = {'q': q, 'OMEGA': OMEGA, 'omega0': omega0, 'beta': beta} # rhs of the differential equation # pendulum eq (3.11) DSargs.varspecs = {'theta': 'v', 'v': '-2*beta*omega0*v\ -(omega0*omega0-q*OMEGA*OMEGA*cos(OMEGA*t))*sin(theta)'} # initial conditions
def solve(self, time_points, terminate=None): # Common parts as superclass if terminate is None: terminate = lambda u, t, step_no: False self.t = np.asarray(time_points) self.initialize_for_solve() N = self.t.size - 1 # no of intervals self.validate_data() # As a main designing priciple of PyDSTool, most of data structures in # PyDSTool are index-free. That is, the numerical data are stored mainly # through Python dictionaries with string keys. # Start setting for PyDSTool import PyDSTool neq, f, u0 = self.neq, self.f, self.U0 # Initialize variables as trajectories in PyDSTOOL # Each item of u has to be defined separately: y0,y1,y2,... name_list = ['y%d' % i for i in range(neq)] y, t, ydot = [PyDSTool.Var(name) for name in name_list], \ PyDSTool.Var('t'), [] # f has to be wrapped from f(y,t) to f(y0,y1,y2,...,t) f_wrap = eval('lambda *args: f(args[:-1], args[-1])') #f_wrap = eval('lambda *args: f(args[:-1], args[-1])', locals()) # Error #f_wrap = lambda *args: f(args[:-1], args[-1]) # Error! # Define differiential functions in PyDSTOOL, item by item string2 = ','.join(['y[%d]' % i for i in range(neq)]) # y[0],y[1],y[2],... ydot = [eval('PyDSTool.Fun(f_wrap(%s,t)[%d],[%s],\"ydot%d\")' \ % (string2, i,string2,i)) for i in range(neq)] # Jacobian matrix if getattr(self, 'jac') is None: # apply Diff() to calculate jacobian matrix approximately. # Diff will return a QuantSpecct object F = eval('PyDSTool.Fun(f_wrap(%s,t),[%s],\"F\")' \ % (string2,string2)) JAC = eval('PyDSTool.Fun(PyDSTool.Diff(F,[%s]),[t,%s],\"JAC\")' \ % (string2,string2)) else: jac = self.jac # Wrap user-supplied jacobian function in the same manner as f #jac_wrap = lambda *args: jac(args[1:],args[0]) # Error jac_wrap = eval('lambda *args: jac(args[1:],args[0])') JAC = eval('PyDSTool.Fun(jac_wrap(t,%s),[t,%s],\"JAC\")' \ % (string2,string2) ) # Settings in PyDSTOOL DSargs = PyDSTool.args(name='pydstest', checklevel=2) # Function set is {JAC, ydot[0],ydot[1],...} string3 = ','.join(['ydot[%d]' % i for i in range(neq)]) DSargs.fnspecs = eval('[JAC,%s]' % string3) # Variable set is {y[i]:ydot[i](y[0],y[1]...)} for any i from 0 to neq-1 string4 = ','.join(['y[%d]: ydot[%d](%s)' % (i, i, string2) \ for i in range(neq)]) DSargs.varspecs = eval('{%s}' % string4) # Time domain DSargs.tdomain = [time_points[0], time_points[-1]] # Initial status {y[0]:self.U0[0],y[1]:self.U0[1],...} string5 = ','.join(['y[%d]:%g' % (i, self.U0[i]) for i in range(neq)]) DSargs.ics = eval('{%s}' % string5) # Optional parameters DSargs.algparams = getattr(self, 'params_pydstool', {}) # Start computation test = eval(self._name_pydstool)(DSargs) result = test.compute('test', 'c') # A trajectory returned # Extract and set values at points in time range self.u = np.asarray([[result(time)['y%d' % j] for j in range(neq)] \ for time in time_points]) return self.u, self.t
# # Ariel Camacho # Doctorate Thesis # Guanajuato, Mexico, 2019 import PyDSTool import numpy as np import pylab as plt from mpl_toolkits.mplot3d import Axes3D import sympy as sp plt.rc('text', usetex=True) plt.rc('font', family='serif') # name of system DSargs = PyDSTool.args(name='ode') # parameters DSargs.pars = { #'aC': 3.2e-1, #farhat (check: OBs) 'aC': 3.0e0, #komarova #'aC': 1.0e-2, #---estimate---# #'aC': 2.0e-1, #---estimate---# 'bC': 3.0e-1, #farhat (same) #'bC': 2.0e-1, #komarova (same) #'bC': 5.0e-1, #--estimate--# #'bC': 1.0e0, #--estimate--# #'bCT': 1.2, #farhat (check: mass action) 'bCT': 1.3e-1, #ross #'bCT': 1.0e-3, #--estimate--#
- xM: cancer cell Scenarios: - Homeostasis - Osteoporosis - Oscillations """ import PyDSTool import numpy as np import pylab as plt plt.rc('text', usetex=True) plt.rc('font', family='serif') DSargs = PyDSTool.args(name='ode') #--- HOMEOSTASIS [p0,p1,p2,p3,p4,p5,p6,p7,p8,p9] = [ 2.72e-01, 1.9e-01, 8.18e-02, 9.38e-03, 9.37e-03, 5.88e-01, 1.51e+01, 1.0, 2.57e+01, 2.57e+01] # osteoclast #aCMpar = 1.0e0 #aBMpar = 0.0e-3 #bBMpar = 0.5
import PyDSTool as dst import numpy as np from matplotlib import pyplot as plt # we must give a name DSargs = dst.args(name='Calcium channel model') # parameters DSargs.pars = {'alpha': 0.1, 'beta': 0.01, 'k': 0.25, 'gamm': 0.01} # auxiliary helper function(s) -- function name: ([func signature], definition) #DSargs.fnspecs = {'minf': (['v'], '0.5 * (1 + tanh( (v-v1)/v2 ))') } DSargs.fnspecs = { 'growth': (['a'], '(beta + a*a)/(1 + a*a)'), 'suppression': (['b'], '1/(1+(b/k)**2)') } # rhs of the differential equation, including dummy variable w DSargs.varspecs = { 'a': 'alpha * growth(a) * suppression(b) - a', 'b': 'gamm * (a - b)', 'w': 'a-w' } # initial conditions DSargs.ics = {'a': 10, 'b': 0, 'w': 0} DSargs.tdomain = [0, 100] # set the range of integration. ode = dst.Generator.Vode_ODEsystem( DSargs) # an instance of the 'Generator' class. traj = ode.compute('polarization') # integrate ODE pts = traj.sample(dt=0.1) # Data for plotting # PyPlot commands plt.plot(pts['t'], pts['a'])
import PyDSTool as dst import matplotlib.pyplot as plt from PyDSTool.Toolbox import phaseplane as pp pars = {'mu': 1, 'alpha': -1, 'omega': 1, 'beta': 1} icdict = {'x': 0.5, 'y': 0.1} xstr = 'mu*x - omega*y + (alpha*x - beta*y)*(x*x + y*y)' ystr = 'omega*x + mu*y + (beta*x + alpha*y)*(x*x + y*y)' DSargs = dst.args(name='2D-System') DSargs.pars = pars DSargs.varspecs = {'x': xstr, 'y': ystr} DSargs.ics = icdict DSargs.tdomain = [0, 15] # set the range of integration. DSargs.xdomain = {'x': [-3, 3], 'y': [-3, 3]} DSargs.pdomain = {'mu': [-1, 1]} DSargs.algparams = {'max_pts': 3000, 'init_step': 0.02, 'stiff': True} ode = dst.Generator.Vode_ODEsystem(DSargs) traj = ode.compute('polarization') pts = traj.sample(dt=0.01) plt.plot(pts['t'], pts['x']) plt.xlabel('time') # Axes labels plt.ylabel('x') plt.show() plt.plot(pts['x'], pts['y']) plt.xlabel('x') # Axes labels