def chi_optimize(method='pso', parallel=False, N_ind=100, N_gen=30, iset=0, show_results=False, dir='../data/', file_name='chi_fit'): # Load experimental data N_set = 2 ca_data = svu.loaddata('../data/herzog_data.pkl')[0] po_data = svu.loaddata('../data/fit_po.pkl')[0] lr_data = svu.loaddata('../data/fit_lra.pkl')[0] # Get boundary dictionary bounds_dict = models.model_bounds(model='chi') # Save effective bounds and scaling bounds, scaling = bounds_for_exploration(bounds_dict, normalized=False) # Prepare model parameters c0 = 5.0 # c0 = 15.0 params = np.asarray(np.r_[po_data[[0, 1, 0, 2, 3]], lr_data[[0, 1]], c0, iset]) args = (params, ca_data) #----------------------------------------------------------------------------------------------------------- # Effective evolution #----------------------------------------------------------------------------------------------------------- # Size parameters # N_var = problem_dimension(model='lra') N_individuals = N_ind N_var = problem_dimension(model='chi') N_generations = N_gen * N_var # Tolerances FTOL = 1e-6 XTOL = 1e-6 # prob = pg.problem(fit_problem('lra',args)) prob = pg.problem(fit_problem('chi', args)) # Optimization # NOTE: We keep each algorithm self contained here because different setting of parameters for evolution are # needed depending on the chose algorithm if method == 'pso': algo = pg.algorithm( pg.pso(gen=N_generations, variant=5, neighb_type=4, max_vel=0.8)) elif method == 'bee': algo = pg.algorithm(pg.bee_colony(gen=N_generations, limit=2)) elif method == 'de': algo = pg.algorithm(pg.de(gen=N_generations, ftol=FTOL, tol=XTOL)) # Single-node optimation to run on local machine / laptop # N_individuals = 100 # N_generations = 40 * N_var # verbosity = 20 if not parallel: verbosity = 20 algo.set_verbosity(verbosity) pop = pg.population(prob, size=N_individuals) pop = algo.evolve(pop) best_fitness = pop.get_f()[pop.best_idx()] print(best_fitness) x_rescaled = rescale_vector(pop.champion_x, model='chi', normalized=True, bounds=bounds, scaling=scaling) # Show results of fit if show_results: astro = models.Astrocyte( model='chi', d1=po_data[0], d2=po_data[1], d3=po_data[0], d5=po_data[2], a2=po_data[3], c0=c0, c1=0.5, rl=0.1, Ker=0.1, rc=lr_data[0], ver=lr_data[1], vbeta=x_rescaled[0], vdelta=x_rescaled[1], v3k=x_rescaled[2], r5p=x_rescaled[3], ICs=np.asarray([x_rescaled[6], x_rescaled[4], x_rescaled[5]])) options = su.solver_opts(t0=ca_data['time'][iset][0], tfin=ca_data['time'][iset][-1], dt=1e-4, atol=1e-8, rtol=1e-6, method="gsl_msadams") astro.integrate(algparams=options, normalized=True) ca_trace = ca_data['smoothed'][iset] plt.plot(ca_data['time'][0], ca_trace, 'k-', astro.sol['ts'], astro.sol['ca'], 'r-') plt.show() else: # Parallel version to run on cluster N_evolutions = 100 N_islands = 10 # Initiate optimization algo = pg.algorithm( pg.pso(gen=N_generations, variant=5, neighb_type=4, max_vel=0.8)) archi = pg.archipelago(n=N_islands, algo=algo, prob=prob, pop_size=N_individuals) archi.evolve(N_evolutions) archi.wait() imin = np.argmin(archi.get_champions_f()) x_rescaled = rescale_vector(archi.get_champions_x()[imin], model='chi', normalized=True, bounds=bounds, scaling=scaling) print archi.get_champions_f()[imin] print x_rescaled svu.savedata([x_rescaled], dir + file_name + '.pkl')
def popen_optimize(method='de-simple'): # Load experimental data p_open = svu.loaddata('../data/p_open.pkl')[0] # Get boundary dictionary # bounds_dict = models.model_bounds(model='lra') bounds_dict = models.model_bounds(model='lra2') # Save effective bounds and scaling bounds, scaling = bounds_for_exploration(bounds_dict, normalized=False) args = (p_open['ca'], p_open['ip3']) #----------------------------------------------------------------------------------------------------------- # Effective evolution #----------------------------------------------------------------------------------------------------------- # Size parameters # N_var = problem_dimension(model='lra') N_var = problem_dimension(model='lra2') N_individuals = 100 N_generations = 500 * N_var N_evolutions = 50 # Tolerances FTOL = 1e-3 XTOL = 1e-3 # prob = pg.problem(fit_problem('lra',args)) prob = pg.problem(fit_problem('lra2', args)) # Optimization # NOTE: We keep each algorithm self contained here because different setting of parameters for evolution are # needed depending on the chose algorithm if method == 'de-simple': ##----------------- # # Single node ##----------------- # algo = pg.algorithm(pg.de(gen=N_generations,F=0.75,CR=0.9,variant=6,ftol=FTOL,xtol=XTOL)) # algo = pg.algorithm(pg.de(gen=N_generations, ftol=1e-12, tol=1e-6)) # algo = pg.algorithm(pg.pso(gen=N_generations)) algo = pg.algorithm(pg.bee_colony(gen=N_generations)) algo.set_verbosity(100) pop = pg.population(prob, size=N_individuals) pop = algo.evolve(pop) best_fitness = pop.get_f()[pop.best_idx()] print(best_fitness) x_rescaled = rescale_vector(pop.champion_x, model='lra2', normalized=True, bounds=bounds, scaling=scaling) astro = models.Astrocyte(model='lra2', d1=x_rescaled[0], d2=x_rescaled[1], d5=x_rescaled[2], a2=x_rescaled[3]) astro.popen(p_open['ca'][0], 1.0) po_ca = astro.po astro.popen(0.25, p_open['ip3'][0]) po_ip3 = astro.po print x_rescaled svu.savedata([x_rescaled], '../data/fit_po.pkl') plt.semilogx(p_open['ca'][0], p_open['ca'][1], 'k-', p_open['ca'][0], po_ca, 'ro', p_open['ip3'][0], p_open['ip3'][1], 'm-', p_open['ip3'][0], po_ip3, 'bo') plt.show()
def pkc_effect(sim=False): """ Shows ExGChI and compare with data from Codazzi et al (CON 2001) """ # Load relevant data ca_data = svu.loaddata('../data/codazzi_data.pkl')[0] po_data = svu.loaddata('../data/fit_po.pkl')[0] lr_data = svu.loaddata('../data/fit_lra.pkl')[0] chi_data = svu.loaddata('../data/chi_fit_0_bee.pkl')[0] if sim: print "1. Simulate PKC dynamics according to Codazzi" # yrel = 1.508 yrel = 1.48 # yrel = 1.448 c0 = 5.0 rc = 0.8 * lr_data[0] ver = lr_data[1] vbeta = 1.0 vdelta = chi_data[1] v3k = 1.4 * chi_data[2] r5p = chi_data[3] vk = 1.0 vkd = 0.28 OmegaKD = 0.33 vd = 0.45 OmegaD = 0.26 astro = models.Astrocyte(model='pkc', d1=po_data[0], d2=po_data[1], d3=po_data[0], d5=po_data[2], a2=po_data[3], c1=0.5, rl=0.01, Ker=0.1, rc=rc, ver=ver, Kkc=0.5, Kkd=0.1, Kdd=0.1, c0=c0, yrel=yrel, vbeta=vbeta, vdelta=vdelta, v3k=v3k, r5p=r5p, vk=vk, vkd=vkd, OmegaKD=OmegaKD, vd=vd, OmegaD=OmegaD, ICs=np.asarray( [0.0, 0.05, 0.05, 0.9, 0.0, 0.0])) # Preliminary integration to start from resting conditions options = su.solver_opts(t0=0.0, tfin=60., dt=1e-4, atol=1e-4, rtol=1e-4, method="gsl_msadams") astro.integrate(algparams=options, normalized=False) # Update model with new ICs and add pulse train options = su.solver_opts(t0=0.0, tfin=ca_data['time'][-1], dt=1e-4, atol=1e-4, rtol=1e-4, method="gsl_msadams") astro.ICs = np.r_[astro.sol['rec'][-1], astro.sol['ip3'][-1], astro.sol['ca'][-1], astro.sol['h'][-1], astro.sol['dag'], astro.sol['pkc']] astro.integrate(algparams=options, normalized=False) sol_fit = astro.sol # _,sol_0,sol_1,sol_2 = svu.loaddata('../data/pkc_qual_fit.pkl') # svu.savedata([sol_fit,sol_0,sol_1,sol_2],'../data/pkc_qual_fit.pkl') # Second simulation print "2. Show effect of O_K" # First standard astrocyte without astro.pars['yrel'] = 1.55 astro.pars['vkd'] = 0.0 astro.pars['vk'] = 0.0 options = su.solver_opts(t0=0.0, tfin=30, dt=1e-4, atol=1e-4, rtol=1e-4, method="gsl_msadams") astro.integrate(algparams=options, normalized=False) sol_0 = astro.sol astro.pars['vkd'] = 0.28 astro.pars['vk'] = 1.0 astro.integrate(algparams=options, normalized=False) sol_1 = astro.sol astro.pars['vk'] = 3.0 astro.integrate(algparams=options, normalized=False) sol_2 = astro.sol # Save data svu.savedata([sol_fit, sol_0, sol_1, sol_2], '../data/pkc_qual_fit.pkl') # # Third simulation (requires PyDSTool) print "3. Computing oscillation period (requires PyDSTool)" # Effective computation pkc0 = bif.compute_period(vkd=0.001, vk=0.001) svu.savedata([pkc0], '../data/pkc_period_Ok.pkl') pkc1 = bif.compute_period(vkd=0.28, vk=1.0) svu.savedata([pkc0, pkc1], '../data/pkc_period_Ok.pkl') pkc2 = bif.compute_period(vkd=0.28, vk=3.0) svu.savedata([pkc0, pkc1, pkc2], '../data/pkc_period_Ok.pkl') pkc3 = bif.compute_period(vkd=0.84, vk=1.0) svu.savedata([pkc0, pkc1, pkc2, pkc3], '../data/pkc_period_Ok.pkl') pkc4 = bif.compute_period(vkd=0.84, vk=3.0) svu.savedata([pkc0, pkc1, pkc2, pkc3, pkc4], '../data/pkc_period_Ok.pkl') #--------------------------------------------------------------------- # Plot figure #--------------------------------------------------------------------- # Load MPL default style plt.style.use('figures.mplstyle') # Load data sol, pkc0, pkc1, pkc2 = svu.loaddata('../data/pkc_qual_fit.pkl') colors = {'ctrl': '0.7'} #--------------------------------------------------------------------------------------------------------- # Fit with experimental data #--------------------------------------------------------------------------------------------------------- fig, ax = plt.subplots(nrows=2, ncols=1, figsize=(6, 5.5), sharex=False, gridspec_kw={ 'height_ratios': [1, 1], 'top': 0.96, 'bottom': 0.12, 'left': 0.15, 'right': 0.95 }) # # Plot experimental data ax[0].plot(ca_data['original']['ca'][:, 0], normalize(ca_data['original']['ca'][:, 1]), 'k-', label='Ca$^{2+}$') ax[0].plot(ca_data['original']['pkc'][:, 0], normalize(ca_data['original']['pkc'][:, 1]), 'r-', label='cPKC$^*$') # Plot solution tclip = [3, 27] # # Mask cmn, _ = fd.relextrema(sol['ca']) pmn, _ = fd.relextrema(sol['pkc']) cbase = (sol['ca'][cmn].max() - sol['ca'][cmn].min()) / 2 # pbase = (sol['pkc'][pmn].max() - sol['pkc'][pmn].min())/2 cbase += sol['ca'][cmn].min() pbase = sol['pkc'][pmn].min() cmask = np.where((tclip[0] <= sol['ts']) & (sol['ts'] < tclip[1]) & (sol['ca'] > cbase))[0] pmask = np.where((tclip[0] <= sol['ts']) & (sol['ts'] < tclip[1]) & (sol['pkc'] > pbase))[0] # # Effective plotting ax[1].plot(sol['ts'][cmask] - sol['ts'][cmask[0]], normalize(sol['ca'][cmask], min=cbase), 'k-') ax[1].plot(sol['ts'][pmask] - sol['ts'][cmask[0]], normalize(sol['pkc'][pmask], min=pbase), 'r-') # Fit Check # ax[1].plot(sol['ts'], normalize(sol['ca']), 'k-') # ax[1].plot(sol['ts'], normalize(sol['pkc']), 'r-') # ax[0].plot(sol['ts'], sol['ca'], 'k-', sol['ts'][cmn], sol['ca'][cmn], 'ko', sol['ts'][[0,-1]], [cbase, cbase], 'b-', ms=6) # ax[0].plot(sol['ts'], sol['pkc'], 'r-', sol['ts'][pmn], sol['pkc'][pmn], 'ro', ms=6) # Adjust axes pu.adjust_spines(ax[0], ['left', 'bottom']) ax[0].set(xlim=(0., 140), xticks=np.arange(0, 141, 35), ylim=(-0.02, 1.05), yticks=np.arange(0, 1.1, 0.5), ylabel='Experimental\nTraces (n.u.)') pu.adjust_spines(ax[1], ['left', 'bottom']) ax[1].set(xlim=(0., 20), xticks=np.arange(0., 30, 5), ylim=(-0.02, 1.05), yticks=np.arange(0, 1.1, 0.5), xlabel='Time (s)', ylabel='Simulated\nTraces (n.u.)') # # Final adjustment of y-labels pu.adjust_ylabels(ax, x_offset=-0.08) # Add legend ax[0].legend(loc='upper right', facecolor='w', edgecolor='none') # Save figure plt.savefig('../Figures/f4_pkc_model.eps', dpi=600) # --------------------------------------------------------------- # Build effect of O_k on period # --------------------------------------------------------------- fig, ax = plt.subplots(nrows=3, ncols=1, figsize=(6, 4.5), sharex=False, gridspec_kw={ 'height_ratios': [1, 1, 1], 'top': 0.96, 'bottom': 0.12, 'left': 0.17, 'right': 0.95 }) # C ax[0].plot(pkc0['ts'], pkc0['ca'], '-', color=colors['ctrl']) ax[0].plot(pkc1['ts'], pkc1['ca'], 'k-') ax[0].plot(pkc2['ts'], pkc2['ca'], 'k-.') # D # First line is a dummy one to add proper legend in this plot rather than on the top one # ax[1].plot(pkc0['ts'][[0,1]],pkc0['dag'][[0,1]],'-',color=colors['ctrl'],label='$O_{K}=0$') ax[1].plot(pkc0['ts'], pkc0['dag'], '-', color=colors['ctrl'], label='$O_{K}=0$') ax[1].plot(pkc1['ts'], pkc1['dag'], 'k-', label='$O_{K}=1.0$ $\mu$M$^{-1}$s$^{-1}$') ax[1].plot(pkc2['ts'], pkc2['dag'], 'k-.', label='$O_{K}=3.0$ $\mu$M$^{-1}$s$^{-1}$') # P ax[2].plot(pkc0['ts'], pkc0['pkc'], '-', color=colors['ctrl'], label='$O_{K}=0$') ax[2].plot(pkc1['ts'], pkc1['pkc'], 'k-', label='$O_{K}=1.0$ $\mu$M$^{-1}$s$^{-1}$') ax[2].plot(pkc2['ts'], pkc2['pkc'], 'k-.', label='$O_{K}=3.0$ $\mu$M$^{-1}$s$^{-1}$') # Adjust axes pu.adjust_spines(ax[0], ['left']) ax[0].set(xlim=(0., 30), xticks=[], ylim=(-0.02, 0.6), yticks=np.arange(0, 0.61, 0.2), ylabel='Ca$^{2+}$\n($\mu$M)') pu.adjust_spines(ax[1], ['left']) ax[1].set(xlim=(0., 30), xticks=[], ylim=(-0.02, 0.41), yticks=np.arange(0, 0.4, 0.1), ylabel='DAG\n($\mu$M)') pu.adjust_spines(ax[2], ['left', 'bottom']) ax[2].set( xlim=(0., 30), xticks=np.arange(0., 31, 10), ylim=(-0.01, 0.075), yticks=np.arange(0, 0.071, 0.02), yticklabels=[str(int(i * 1e3)) for i in np.arange(0, 0.071, 0.02)], xlabel='Time (s)', ylabel='cPKC$^{*}$\n(nM)') # # Final adjustment of y-labels pu.adjust_ylabels(ax, x_offset=-0.08) # Add legend ax[2].legend(loc='upper right', facecolor='w', edgecolor='none') # Save figure plt.savefig('../Figures/f4_pkc_osc_1.eps', dpi=600) #--------------------------------------------------------------- # Plot period of oscillations #--------------------------------------------------------------- p0, p1, p2, p3, p4 = svu.loaddata('../data/pkc_period_Ok.pkl') fig, ax = plt.subplots(nrows=2, ncols=1, figsize=(6, 4.5), sharex=False, gridspec_kw={ 'height_ratios': [1, 2], 'top': 0.96, 'bottom': 0.12, 'left': 0.17, 'right': 0.95 }) for i, p in enumerate([p0, p1, p2, p3, p4]): # idx = (p['T'] > 3.5) idx = np.argsort(p['T'][(p['T'] > 3.5)])[::-1] if i == 3: idx = idx[0:-2] p['T'] = p['T'][idx] p['yrel'] = p['yrel'][idx] mask = lambda period: np.argsort(1.0 / period) ax[1].plot(p0['yrel'][mask(p0['T'])], p0['T'][mask(p0['T'])], '-', color=colors['ctrl'], label='O$_{KD}$=0') ax[1].plot(p1['yrel'][mask(p1['T'])], p1['T'][mask(p1['T'])], 'k-', zorder=5, label='O$_{KD}$=0.28 $\mu$Ms$^{-1}$') ax[1].plot(p2['yrel'][mask(p2['T'])], p2['T'][mask(p2['T'])], 'b-', zorder=5, label='O$_{KD}$=0.84 $\mu$Ms$^{-1}$') ax[1].plot(p3['yrel'][mask(p3['T'])], p3['T'][mask(p3['T'])], 'k-.') ax[1].plot(p4['yrel'][mask(p4['T'])], p4['T'][mask(p4['T'])], 'b-.') # Adjust axes ax[0].set_visible(False) pu.adjust_spines(ax[1], ['left', 'bottom']) ax[1].set(xlim=(1.4, 1.9), xticks=np.arange(1.4, 1.95, 0.1), ylim=(3.5, 15), yticks=np.arange(4, 15.1, 3), xlabel='Glu ($\mu$M)', ylabel='Oscillation Period (s)') # Add Legend ax[1].legend(loc='upper right', facecolor='w', edgecolor='none') # Save figure plt.savefig('../Figures/f4_pkc_osc_2.eps', dpi=600) plt.show()
def gchi_threshold(sim=False): """ Simulation of the G-ChI model with some pulse function """ if sim: print "Control" tr_0, p = compute_thr() print "r5p" tr_5p, _ = compute_thr(r5p=1.5 * p['r5p']) print "v3k" tr_3k, _ = compute_thr(v3k=1.5 * p['v3k']) print "vbeta" tr_vb, _ = compute_thr(vbeta=1.5 * p['vbeta']) print "vdelta" tr_vd, _ = compute_thr(vdelta=1.5 * p['vbeta']) print "Saving data" svu.savedata([tr_0, tr_vb, tr_vd, tr_3k, tr_5p], '../data/cicr_thr.pkl') print "done!" #--------------------------------------------------------------------- # Plot figure #--------------------------------------------------------------------- # Load MPL default style plt.style.use('figures.mplstyle') # Load data tr_0, tr_vb, tr_vd, tr_3k, tr_5p = svu.loaddata('../data/cicr_thr.pkl') #--------------------------------------------------------------------------------------------------------- # Showing threshold #--------------------------------------------------------------------------------------------------------- fig, ax = plt.subplots(nrows=3, ncols=1, figsize=(6, 5.5), sharex=False, gridspec_kw={ 'height_ratios': [0.75, 2, 2], 'top': 0.96, 'bottom': 0.12, 'left': 0.14, 'right': 0.95 }) Nt = np.size(tr_0['yb']) t0 = -0.2 tfin = 5.0 mask = tr_0['ts'] < tfin maskb = tr_0['bias'][0][0] < tfin for i in xrange(10, 51, 5): # Plot adding some points on the left to show instant of stimulation ax[0].plot(np.r_[t0, 0, tr_0['bias'][i][0][maskb]], np.r_[0, 0, tr_0['bias'][i][1][maskb]]) ax[1].plot(np.r_[t0, tr_0['ts'][mask]], np.r_[tr_0['ip3'][i][0], tr_0['ip3'][i][mask]]) ax[2].plot(np.r_[t0, tr_0['ts'][mask]], np.r_[tr_0['ca'][i][0], tr_0['ca'][i][mask]]) # Annotate ax[0].plot(0., 3.6, 'v', color='k', ms=10, clip_on=False) ax[1].plot(0., 0.065, 'v', color='k', ms=10, clip_on=False) ax[2].plot(0., 0.25, 'v', color='k', ms=10, clip_on=False) # Adjust axes pu.adjust_spines(ax[0], ['left']) ax[0].set(xlim=(t0, tfin), xticks=[], ylim=(-0.05, 3.05), yticks=np.arange(0, 3.1, 1.0), ylabel='Glu\n($\mu$M)') pu.adjust_spines(ax[1], ['left']) ax[1].set(xlim=(t0, tfin), xticks=[], ylim=(0., 0.2), yticks=np.arange(0, 0.21, 0.1), ylabel='IP$_3$ ($\mu$M)') pu.adjust_spines(ax[2], ['left', 'bottom']) ax[2].set(xlim=(t0, tfin), xticks=np.arange(0, 5.1), ylim=(0., 2.5), yticks=np.arange(0, 2.51, 1.0), xlabel='Time (s)', ylabel='Ca$^{2+}$ ($\mu$M)') # Final adjustment of y-labels pu.adjust_ylabels(ax, x_offset=-0.07) # Save figure plt.savefig('../Figures/f3_gchi_thr_0.eps', dpi=600) #--------------------------------------------------------------------------------------------------------- # Compute latency and IP3 injected #--------------------------------------------------------------------------------------------------------- bv, latency, inj = {}, {}, {} # Control key = 'ctrl' bv[key], latency[key], inj[key] = compute_latency(tr_0, dthr=0.5) key = 'r5p' bv[key], latency[key], inj[key] = compute_latency(tr_5p, dthr=0.5) key = 'v3k' bv[key], latency[key], inj[key] = compute_latency(tr_3k, dthr=0.5) key = 'vb' bv[key], latency[key], inj[key] = compute_latency(tr_vb, dthr=0.5) key = 'vd' bv[key], latency[key], inj[key] = compute_latency(tr_vd, dthr=0.5) colors = { 'ctrl': 'k', 'vb': pu.hexc((255, 127, 14)), # Orange 'vd': pu.hexc((31, 119, 180)), # Tourquois 'v3k': pu.hexc((214, 39, 40)), # DarkRed 'r5p': pu.hexc((227, 119, 194)) # Magenta } fig, ax = plt.subplots(nrows=2, ncols=1, figsize=(5, 5.5), sharex=False, gridspec_kw={ 'height_ratios': [1, 1], 'top': 0.96, 'bottom': 0.12, 'left': 0.14, 'right': 0.95 }) plt.subplots_adjust(hspace=0.3) keys = ['ctrl', 'vb', 'vd', 'v3k', 'r5p'] label = [ 'reference', '$O_{\\beta} \uparrow$ ($\\times 1.5$)', '$O_\delta \uparrow$ ($\\times 1.5$)', '$O_{3K} \uparrow$ ($\\times 1.5$)', '$\Omega_{5P} \uparrow$ ($\\times 1.5$)' ] for _, k in enumerate(keys): if k == 'ctrl': ax[0].plot(bv[k], latency[k], color=colors[k], ls='--', label=label[_], zorder=10) ax[1].plot(latency[k], inj[k], color=colors[k], ls='--', zorder=10) else: ax[0].plot(bv[k], latency[k], color=colors[k], ls='-', label=label[_]) ax[1].plot(latency[k], inj[k], color=colors[k], ls='-') # Adjust axes pu.adjust_spines(ax[0], ['left', 'bottom']) ax[0].set(xlim=(0., 5.0), xticks=np.arange(0, 5.1), ylim=(0., 4.), yticks=np.arange(0, 4.1, 1.0), xlabel='Glu ($\mu$M)', ylabel='Latency (s)') ax[1].set(xlim=[0., 4.0], xticks=np.arange(0., 4.1, 1.0), ylim=[100, 10000], yscale='log', xlabel='Latency (s)', ylabel='IP$_3$ Time Integral (mM$\cdot$s)') pu.adjust_spines(ax[1], ['left', 'bottom']) ax[1].set(yticks=[100, 1000, 10000], yticklabels=[str(i) for i in [0.1, 1, 10]]) # # Final adjustment of y-labels pu.adjust_ylabels(ax, x_offset=-0.09) # Add legend ax[0].legend(loc='upper right', facecolor='w', edgecolor='none') # # Save figure plt.savefig('../Figures/f3_gchi_thr_1.eps', dpi=600) plt.show()
def compute_period(vkd=0.28, vk=1.0): """ Compute period of oscillations as a function of yrel for given value of O_K Return dictionary: {'yrel': ndarray, 'T': ndarray} """ # First check / Default set po_data = svu.loaddata('../data/fit_po.pkl')[0] lr_data = svu.loaddata('../data/fit_lra.pkl')[0] chi_data = svu.loaddata('../data/chi_fit_0_bee.pkl')[0] # yrel = 1.45 # yrel = 1.4715 # vk=0.5 # yrel = 1.448 # vk=0.2 # yrel = 2.0 yrel = 1.3 c0 = 5.0 rc = 0.8 * lr_data[0] ver = lr_data[1] vbeta = 1.0 vdelta = chi_data[1] v3k = 1.4 * chi_data[2] r5p = chi_data[3] # DAG metabolism parameters OmegaKD = 0.33 vd = 0.45 OmegaD = 0.26 pars = gchidp_pars(d1=po_data[0], d2=po_data[1], d3=po_data[0], d5=po_data[2], a2=po_data[3], c1=0.5, rl=0.01, KER=0.1, rc=rc, ver=ver, Kkc=0.5, Kkd=0.1, Kdd=0.1, c0=c0, yrel=yrel, vbeta=vbeta, vdelta=vdelta, v3k=v3k, r5p=r5p, vkd=vkd, vk=vk, OmegaKD=OmegaKD, vd=vd, OmegaD=OmegaD) # Generate ODE system DSargs = gchidp_model(pars) DSargs.tdomain = [0, 20] # set the range of integration ode = dst.Generator.Vode_ODEsystem( DSargs) # an instance of the 'Generator' class traj = ode.compute('steady') # Integrate ODE sol = traj.sample() # Retrieve solution # Intermediate plotting # plt.plot(sol['t'],sol['gammaa'],'k-') # plt.plot(sol['t'],sol['ca'],'k-') # plt.plot(sol['t'],sol['dag'],'r-') # plt.plot(sol['t'],sol['pkc'],'b-') # Prepare the system to start close to a steady state p0 = traj(DSargs.tdomain[1]) ode.set(pars={'yrel': yrel}) # Lower bound of the control parameter 'i' ode.set(ics=p0) # Start from steady-state # Generate PyCont object PC = dst.ContClass(ode) # Set up continuation class # EP-C PCargs = dst.args( name='EQ1', type='EP-C', force=True ) # 'EP-C' stands for Equilibrium Point Curve. The branch will be labeled 'EQ1'. PCargs.freepars = [ 'yrel' ] # control parameter(s) (it should be among those specified in DSargs.pars) PCargs.MaxNumPoints = 300 # The following 3 parameters are set after trial-and-error PCargs.MaxStepSize = 0.01 PCargs.MinStepSize = 1e-4 PCargs.StepSize = 1e-3 PCargs.VarTol = 1e-5 PCargs.FuncTol = 1e-5 PCargs.TestTol = 1e-5 PCargs.LocBifPoints = 'all' # detect limit points / saddle-node bifurcations PCargs.SaveEigen = True # to tell unstable from stable branches PC.newCurve(PCargs) # Compute equilibria print "Computing EQ-C" PC['EQ1'].forward() # PC['EQ1'].backward() print "done!" svu.savedata([PC], 'tmp_cont.pkl') PC = svu.loaddata('tmp_cont.pkl')[0] # LC-C PCargs = dst.args(name='LC1', type='LC-C', force=True) PCargs.initpoint = 'EQ1:H1' PCargs.freepars = ['yrel'] PCargs.MaxNumPoints = 200 PCargs.MaxStepSize = 0.05 PCargs.MinStepSize = 0.01 PCargs.StepSize = 1e-3 # PCargs.VarTol = 1e-6 # PCargs.FuncTol = 1e-4 # PCargs.TestTol = 1e-5 PCargs.LocBifPoints = 'all' #PCargs.NumSPOut = 50; #PCargs.SolutionMeasures = ['max','min'] PCargs.SolutionMeasures = 'all' PCargs.SaveEigen = True PC.newCurve(PCargs) # Compute Orbits print "Computing LC-C" PC['LC1'].forward() # PC['LC1'].backward() print "done!" # Retrieve solution T = PC['LC1'].sol['_T'] yrel = PC['LC1'].sol['yrel'] # Retrieve stabled and unstable branches idx = np.asarray([ PC['LC1'].sol.labels['LC'][i]['stab'] for i in PC['LC1'].sol.labels['LC'] ], 'S') plt.plot(yrel[idx == 'S'], T[idx == 'S'], 'ko') plt.show() return {'yrel': yrel[idx == 'S'], 'T': T[idx == 'S']}
PC['LC1'].forward() # PC['LC1'].backward() print "done!" # Retrieve solution T = PC['LC1'].sol['_T'] yrel = PC['LC1'].sol['yrel'] # Retrieve stabled and unstable branches idx = np.asarray([ PC['LC1'].sol.labels['LC'][i]['stab'] for i in PC['LC1'].sol.labels['LC'] ], 'S') plt.plot(yrel[idx == 'S'], T[idx == 'S'], 'ko') plt.show() return {'yrel': yrel[idx == 'S'], 'T': T[idx == 'S']} if __name__ == "__main__": # Effective computation pkc0 = compute_period(vkd=0.001, vk=0.001) svu.savedata([pkc0], '../data/pkc_period_Ok.pkl') pkc1 = compute_period(vkd=0.28, vk=1.0) svu.savedata([pkc0, pkc1], '../data/pkc_period_Ok.pkl') pkc2 = compute_period(vkd=0.28, vk=3.0) svu.savedata([pkc0, pkc1, pkc2], '../data/pkc_period_Ok.pkl') pkc0, pkc1, pkc2 = svu.loaddata('../data/pkc_period_Ok.pkl') pkc3 = compute_period(vkd=0.84, vk=1.0) svu.savedata([pkc0, pkc1, pkc2, pkc3], '../data/pkc_period_Ok.pkl') pkc4 = compute_period(vkd=0.84, vk=3.0) svu.savedata([pkc0, pkc1, pkc2, pkc3, pkc4], '../data/pkc_period_Ok.pkl')