def bistability_analysis(): f2_range = linspace(0, 0.4, 41) t = linspace(0, 50000, 1000) ion() ss_aBax_vals_up = [] ss_aBax_vals_down = [] for f2 in f2_range: model.parameters['Bid_0'].value = f2 * 1e-1 bax_total = 2e-1 # Do "up" portion of hysteresis plot model.parameters['aBax_0'].value = 0 model.parameters['cBax_0'].value = bax_total x = odesolve(model, t) figure('up') plot(t, x['aBax_']/bax_total) ss_aBax_vals_up.append(x['aBax_'][-1]/bax_total) # Do "down" portion of hysteresis plot model.parameters['aBax_0'].value = bax_total model.parameters['cBax_0'].value = 0 x = odesolve(model, t) figure('down') plot(t, x['aBax_']/bax_total) ss_aBax_vals_down.append(x['aBax_'][-1]/bax_total) figure() plot(f2_range, ss_aBax_vals_up, 'r') plot(f2_range, ss_aBax_vals_down, 'g')
def bistability_analysis(): f2_range = linspace(0, 0.4, 41) t = linspace(0, 50000, 1000) ion() ss_aBax_vals_up = [] ss_aBax_vals_down = [] for f2 in f2_range: model.parameters['Bid_0'].value = f2 * 1e-1 bax_total = 2e-1 # Do "up" portion of hysteresis plot model.parameters['aBax_0'].value = 0 model.parameters['cBax_0'].value = bax_total x = odesolve(model, t) figure('up') plot(t, x['aBax_'] / bax_total) ss_aBax_vals_up.append(x['aBax_'][-1] / bax_total) # Do "down" portion of hysteresis plot model.parameters['aBax_0'].value = bax_total model.parameters['cBax_0'].value = 0 x = odesolve(model, t) figure('down') plot(t, x['aBax_'] / bax_total) ss_aBax_vals_down.append(x['aBax_'][-1] / bax_total) figure() plot(f2_range, ss_aBax_vals_up, 'r') plot(f2_range, ss_aBax_vals_down, 'g')
def time_dep_sensitivity(model, t, results = None, delta=0.1, parameters=[]): if not parameters: return all_param_results = {} if results is None: results = odesolve(model, t) print 'Solving time-dependent sensitivity analysis for %d parameters' % len(parameters) for param in parameters: if param.name.startswith('__'): continue print 'Solving for', param.name oldval = param.value newval_left = param.value * (1. + 0.5 * delta) model.parameters[param.name].value = newval_left new_results_left = odesolve(model, t) newval_right = param.value * (1. - 0.5 * delta) model.parameters[param.name].value = newval_right new_results_right = odesolve(model, t) model.parameters[param.name].value = oldval all_param_results[param.name] = sens_res(param.name, new_results_left, new_results_right, delta * param.value) return all_param_results
def plot_effect_of_pore_reverse_rate(): ci = color_iter() pore_reverse_rates = [1e-2, 1e-4, 1e-6] t = np.linspace(0, 5000, 500) plt.figure() for pore_reverse_rate in pore_reverse_rates: params_dict = {'Bax_0': 50., 'Vesicles_0': 50., 'pore_reverse_rate_k': pore_reverse_rate} b = one_cpt.Builder(params_dict=params_dict) b.build_model_bax_schwarz_reversible() x = odesolve(b.model, t) avg_pores = x['pores']/b.model.parameters['Vesicles_0'].value col = ci.next() plt.plot(t, avg_pores, color=col, linestyle='-', label="Pores, reverse rate %g" % pore_reverse_rate) plt.plot(t, 1 - np.exp(-avg_pores), color=col, linestyle='--', label="Dye release, reverse rate %g" % pore_reverse_rate) plt.legend(loc='upper left') plt.xlabel('Time (sec)') plt.ylabel('Dye release/Avg. pores') plt.title('Dye release/pore formation with varying reverse rates') plt.show()
def plot_fraction_bax_bound(model, figure_id=None): bax_concs = np.logspace(0, 4, 40) t = np.linspace(0, 3000, 1000) #plt.figure() ss_mBax_values = [] for bax_conc in bax_concs: model.parameters['Bax_0'].value = bax_conc x = odesolve(model, t) mBax_frac = x['mBax'] / model.parameters['Bax_0'].value ss_mBax_value = mBax_frac[-1] ss_mBax_values.append(ss_mBax_value) #plt.plot(t, mBax_frac) #plt.show() ss_mBax_values = np.array(ss_mBax_values) if figure_id is not None: plt.figure(figure_id) else: plt.figure() plt.semilogx(bax_concs, ss_mBax_values, linewidth=2) plt.xlabel('Bax concentration (nM)') plt.ylabel('Pct. Bax at liposomes') plt.ylim([0, 1]) plt.title('Frac Bax bound vs. Bax conc') plt.show()
def plot_liposome_titration(builder=one_cpt.Builder()): b = builder b.translocate_Bax() b.model.parameters['Bax_0'].value = 100 t = np.linspace(0, 3000, 1000) lipo_concs = np.logspace(-2, 4, 40) ss_mBax_values = [] # Plot timecourses plt.ion() #plt.figure() for lipo_conc in lipo_concs: b.model.parameters['Vesicles_0'].value = lipo_conc x = odesolve(b.model, t) mBax_frac = x['mBax'] / b.model.parameters['Bax_0'].value plt.plot(t, mBax_frac) ss_mBax_value = mBax_frac[-1] ss_mBax_values.append(ss_mBax_value) plt.show() ss_mBax_values = np.array(ss_mBax_values) # Plot liposome titration plt.figure() plt.plot(lipo_concs, ss_mBax_values) plt.xlabel('Liposome concentration (nM)') plt.ylabel('Pct. Bax at liposomes (Bax_0 = %d nM)' % b.model.parameters['Bax_0'].value) plt.title('Bax/Liposome binding curve') plt.show()
def sensitivity(self,tspan=None, parameters_ref=None, sp_SA=None, sampling_method = 'saltelli', analyze_method='sobol',N=1 , verbose=True): ana_meth = importlib.import_module('SALib.analyze.%s'%analyze_method) if tspan is not None: self.tspan = tspan elif self.tspan is None: raise Exception("'time t' must be defined.") if sp_SA is None: raise Exception("A species to do the sensitivity analysis on must be defined") if sp_SA not in [str(sp) for sp in self.model.species] and sp_SA not in [str(obs.name) for obs in self.model.observables]: raise Exception("Species is not in model species") ref = odesolve(self.model, self.tspan, param_values=parameters_ref) if verbose: print "Getting parameters information" self.pars_info(parameters_ref, sampling_method=sampling_method, N=N) if verbose: print "Simulating with parameters from sampling" p=multiprocessing.Pool(2) func = partial(self.sim_model,sp_SA=sp_SA) self.sim = p.map(func, self.param_sets) self.output = [sum((r - ref[sp_SA])**2) for r in self.sim] if verbose: print "Sensitivity analysis" self.sa_result = ana_meth.analyze(self.problem, numpy.array(self.output), print_to_console=True)
def test_integrate_with_expression(): Monomer('s1') Monomer('s9') Monomer('s16') Monomer('s20') Parameter('ka',2e-5) Parameter('ka20', 1e5) Initial(s9(), Parameter('s9_0', 10000)) Observable('s1_obs', s1()) Observable('s9_obs', s9()) Observable('s16_obs', s16()) Observable('s20_obs', s20()) Expression('keff', (ka*ka20)/(ka20+s9_obs)) Rule('R1', None >> s16(), ka) Rule('R2', None >> s20(), ka) Rule('R3', s16() + s20() >> s16() + s1(), keff) time = linspace(0, 40, 100) x = odesolve(model, time)
def test_simulation(): time = np.linspace(0, 18000, 1801) x = odesolve(model, time) expectedx_final = {'IkBan_obs': 3145.8443053128276, 'NFkBn_obs': 178.06326194655537, 'IkBap_NFkBc_obs': 1.3899039187480429e-07, 'IkBa_on_obs': 0.045201392272254615, 'IKKKa_obs': 0.00054704675357157236, 'A20_off_obs': 1.9547986077277453, 'A20t_obs': 6.2762670477040663, 'IkBan_NFkBn_obs': 28.012691613691331, 'IKKn_obs': 199999.9951281352, 'IKKa_obs': 2.3395704210536575e-08, 'TNFR1a_obs': 5.3362282855621739e-06, 'IkBa_off_obs': 1.9547986077277459, 'TNF_ext_obs': 9.5649122910157076e-08, 'A20_on_obs': 0.045201392272254573, 'IkBap_obs': 2.3942600622297971e-09, 'IKKii_obs': 0.0045466692017435365, 'IKKKn_obs': 99999.999452953241, 'IKKi_obs': 0.00032517206132429724, 'TNFR1i_obs': 1999.9999946637713, 'IkBat_obs': 6.2762670477040681, 'NFkBc_obs': 139.40965738805579, 'IkBac_obs': 8607.2535257899253, 'A20_obs': 5714.7212868294837, 'IkBa_NFkB_obs': 99655.514388905125} for i in expectedx_final.keys(): final_obs = x[i][-1] if abs(final_obs - expectedx_final[i]) > 1e-3: raise ValueError("%s: Expected %f, got %f, diff %e" % (i, expectedx_final[i], final_obs, final_obs - expectedx_final[i]))
def tropicalize(self, tspan=None, param_values=None, diff_par=1, ignore=1, epsilon=1, find_passengers_by='imp_nodes', plot_imposed_trace=False, verbose=False): """ tropicalization of driver species :param diff_par: :param find_passengers_by: Option to find passenger species. 'imp_nodes' finds the nodes that only have one edge. 'qssa' finds passenger species using the quasi steady state approach :param plot_imposed_trace: Option to plot imposed trace :param tspan: Time span :param param_values: PySB model parameter values :param ignore: Initial time points to ignore :param epsilon: Order of magnitude difference between solution of ODE and imposed trace to consider species as passenger :param verbose: Verbose :return: """ if verbose: print("Solving Simulation") if tspan is not None: self.tspan = tspan else: raise SimulatorException("'tspan' must be defined.") if param_values is not None: # accept vector of parameter values as an argument if len(param_values) != len(self.model.parameters): raise Exception("param_values must be the same length as model.parameters") if not isinstance(param_values, numpy.ndarray): param_values = numpy.array(param_values) else: # create parameter vector from the values in the model param_values = numpy.array([p.value for p in self.model.parameters]) # convert model parameters into dictionary self.param_values = dict((p.name, param_values[i]) for i, p in enumerate(self.model.parameters)) self.y = odesolve(self.model, self.tspan, self.param_values) if verbose: print("Getting Passenger species") if find_passengers_by == 'qssa': if plot_imposed_trace: self.find_passengers(self.y[ignore:], epsilon, plot=plot_imposed_trace) else: self.find_passengers(self.y[ignore:], epsilon) elif find_passengers_by == 'imp_nodes': self.find_nonimportant_nodes() else: raise Exception("equations to tropicalize must be chosen") if verbose: print("equation to tropicalize") self.equations_to_tropicalize() if verbose: print("Getting signatures") self.signal_signature(self.y[ignore:], diff_par=diff_par) return
def synthetic_data(model, tspan, obs_list=None, sigma=0.1, seed=None): from pysb.integrate import odesolve random = numpy.random.RandomState(seed) ysim = odesolve(model, tspan) ysim_array = ysim.view().reshape(len(tspan), len(ysim.dtype)) ysim_array *= (random.randn(*ysim_array.shape) * sigma + 1) return ysim
def test_build_models(): model_names = [#'t', 'ta', 'tai', 'taid', 'taidt', 'tair', 'taird', #'tairdt', 'tad', 'tadt', 'tar', 'tard', 'tardt', #--- #'bax_heat', #'bax_heat_reversible', #'bax_heat_dimer', #'bax_heat_dimer_reversible', #'bax_heat_auto1', #'bax_heat_auto2', #--- #'bax_heat_bh3_auto2', #'bax_heat_auto1_reversible_activation', #'bax_heat_auto2_reversible_activation', #'bax_heat_auto1_reversible', #'bax_heat_auto2_reversible', #'bax_heat_auto1_dimer', #'bax_heat_auto2_dimer', #'bax_heat_auto1_dimer_reversible', #'bax_heat_auto2_dimer_reversible', #'bax_heat_bh3_exposure_auto2', #'bax_schwarz', #'bax_schwarz_reversible', #'bax_schwarz_dimer', #'bax_schwarz_dimer_reversible', #'bax_schwarz_tetramer_reversible', ] for model_name in model_names: print "Running model %s" % model_name b = Builder() eval("b.build_model_%s()" % model_name) x = odesolve(b.model, t) plot_model(t, x, 'build_model_%s' % model_name)
def run_figure_sim(model): """Run the C8 dose-response series shown in Fig. 11 of [Albeck2008]_. Returns ------- [t, outputs] : list containing two numpy.array objects t: The time coordinates of each timepoint, in seconds, from 0 to 60,000 seconds (15 hours), at 60-second intervals. outputs: A 901 x 7 array. Each row corresponds to the fraction of Smac released into the cytosol at each timepoint. Each column correspond to a distinct caspase 8 dose, from lowest to highest: [1, 5, 10, 50, 100, 500, 1000], in molecules per cell. """ # Set timepoints and c8 doses tf = 15 * 3600 # 15 hours t = np.linspace(0, tf, (tf / 60) + 1) c8_doses = [0.01e2, 0.05e2, 0.1e2, 0.5e2, 1e2, 5e2, 10e2] outputs = np.empty((len(t), len(c8_doses))) for i, c8_dose in enumerate(c8_doses): model.parameters['C8_0'].value = c8_dose x = odesolve(model, t, rtol=rtol) frac_Smac_release = x['cSmac'] / model.parameters['Smac_0'].value outputs[:, i] = frac_Smac_release return [t, outputs]
def run_figure_sim(model): """Run the C8 dose-response series shown in Fig. 11 of [Albeck2008]_. Returns ------- [t, outputs] : list containing two numpy.array objects t: The time coordinates of each timepoint, in seconds, from 0 to 60,000 seconds (15 hours), at 60-second intervals. outputs: A 901 x 7 array. Each row corresponds to the fraction of Smac released into the cytosol at each timepoint. Each column correspond to a distinct caspase 8 dose, from lowest to highest: [1, 5, 10, 50, 100, 500, 1000], in molecules per cell. """ # Set timepoints and c8 doses tf = 15 * 3600 # 15 hours t = np.linspace(0, tf, (tf / 60) + 1) c8_doses = [0.01e2, 0.05e2, 0.1e2, 0.5e2, 1e2, 5e2, 10e2] outputs = np.empty((len(t), len(c8_doses))) for i, c8_dose in enumerate(c8_doses): model.parameters['C8_0'].value = c8_dose x = odesolve(model, t, rtol=rtol) frac_Smac_release = x['cSmac'] / model.parameters['Smac_0'].value outputs[:,i] = frac_Smac_release return [t, outputs]
def test_integrate_with_expression(): """Ensure a model with Expressions simulates.""" Monomer('s1') Monomer('s9') Monomer('s16') Monomer('s20') # Parameters should be able to contain s(\d+) without error Parameter('ks0',2e-5) Parameter('ka20', 1e5) Initial(s9(), Parameter('s9_0', 10000)) Observable('s1_obs', s1()) Observable('s9_obs', s9()) Observable('s16_obs', s16()) Observable('s20_obs', s20()) Expression('keff', (ks0*ka20)/(ka20+s9_obs)) Rule('R1', None >> s16(), ks0) Rule('R2', None >> s20(), ks0) Rule('R3', s16() + s20() >> s16() + s1(), keff) time = np.linspace(0, 40) x = odesolve(model, time)
def plot_model_data(): """Plots a simulation of the model along with the data.""" plt.ion() x = odesolve(model, tspan) plt.plot(tspan, x['A_']) plt.plot(tspan, synthetic_data['A_']) plt.show()
def run_model(tmax=12000, fittype='explin'): t = linspace(0, tmax, 1000) x = odesolve(model, t) figure() plot(t, (x['ctBid'])/tBid_0.value, label='ctBid') plot(t, (x['mtBid'])/tBid_0.value, label='mtBid') plot(t, (x['cBax'])/Bax_0.value, label='cBax') plot(t, (x['mBax'])/Bax_0.value, label='mBax') #plot(t, x['metBid']/tBid_0.value, label='metBid') #plot(t, x['mtBid']/tBid_0.value, label='mtBid') #plot(t, x['mftBid']/tBid_0.value, label='mftBid') #plot(t, x['mfBax']/Bax_0.value, label='mfBax') #plot(t, x['meBax']/Bax_0.value, label='meBax') #plot(t, x['tBidBax']/Bax_0.value, label='tBidBax') #plot(t, x['tBidiBax']/Bax_0.value, label='tBidiBax') #plot(t, (x['iBax']+x['pBax'])/Bax_0.value, label='ipBax') #plot(t, (x['iBax'])/Bax_0.value, label='iBax') #plot(t, (x['eiBax'])/Bax_0.value, label='eiBax') #plot(t, (2*x['ePore'])/Bax_0.value, label='ePore') #plot(t, (2*x['fPore'])/Bax_0.value, label='fPore') #plot(t, (x['pBax'])/Bax_0.value, label='pBax') #plot(t, (2*(x['Bax2']+(2*x['Bax4'])))/Bax_0.value, label='Bax2') #plot(t, (2*x['Bax2'])/Bax_0.value, label='Bax2') #plot(t, (4*x['Bax4'])/Bax_0.value, label='Bax4') #plot(t, x['pBax']/Bax_0.value, label='pBax') #plot(t, x['eVes']/Vesicles_0.value, label='eVes') legend() xlabel("Time (seconds)") ylabel("Normalized Concentration")
def main(self): output = [] ligand_array = [] observables = self.make_model() write_columns(observables) write_model_attributes(self.model.rules, "rules") write_model_attributes(self.model.parameters, "parameters") write_model_attributes(self.model.observables, "observables") np.savetxt("time", self.tspan, fmt='%f') for ligand in self.p_ligand: self.model.parameters['Ls_0'].value = ligand ligand_array.append(ligand) y = odesolve(self.model, self.tspan, compiler="python") if len(observables) > 1: output_array = y[observables[0]] + y[observables[1]] if self.num_samples == 1: np.savetxt("{0}_output".format(observables[0]), y[observables[0]], fmt='%f') np.savetxt("{0}_output".format(observables[1]), y[observables[1]], fmt='%f') np.savetxt("output_array", output_array, fmt='%f') output.append(output_array[-1]) else: output_array = y[observables[0]] output.append(output_array[-1]) np.savetxt("Ligand_concentrations", ligand_array, fmt='%f') np.savetxt("output", output, fmt='%f')
def test_integrate_with_expression(): """Ensure a model with Expressions simulates.""" Monomer('s1') Monomer('s9') Monomer('s16') Monomer('s20') # Parameters should be able to contain s(\d+) without error Parameter('ks0', 2e-5) Parameter('ka20', 1e5) Initial(s9(), Parameter('s9_0', 10000)) Observable('s1_obs', s1()) Observable('s9_obs', s9()) Observable('s16_obs', s16()) Observable('s20_obs', s20()) Expression('keff', (ks0 * ka20) / (ka20 + s9_obs)) Rule('R1', None >> s16(), ks0) Rule('R2', None >> s20(), ks0) Rule('R3', s16() + s20() >> s16() + s1(), keff) time = np.linspace(0, 40) x = odesolve(model, time)
def fig_4b(): print("Simulating model for figure 4B...") t = linspace(0, 6 * 3600, 6 * 60 + 1) # 6 hours x = odesolve(model, t) x_norm = c_[x['Bid_unbound'], x['PARP_unbound'], x['mSmac_unbound']] x_norm = 1 - x_norm / x_norm[ 0, :] # gets away without max() since first values are largest # this is what I originally thought 4B was plotting. it's actually very close. -JLM #x_norm = array([x['tBid_total'], x['CPARP_total'], x['cSmac_total']]).T #x_norm /= x_norm.max(0) tp = t / 3600 # x axis as hours figure("Figure 4B") plot(tp, x_norm[:, 0], 'b', label='IC substrate (tBid)') plot(tp, x_norm[:, 1], 'y', label='EC substrate (cPARP)') plot(tp, x_norm[:, 2], 'r', label='MOMP (cytosolic Smac)') legend(loc='upper left', bbox_to_anchor=(0, 1)).draw_frame(False) xlabel('Time (hr)') ylabel('fraction') a = gca() a.set_ylim((-.05, 1.05))
def synthetic_data(model, tspan, obs_list=None, sigma=0.1, seed=None): from pysb.integrate import odesolve random = numpy.random.RandomState(seed) ysim = odesolve(model, tspan) ysim_array = ysim.view().reshape(len(tspan), len(ysim.dtype)) ysim_array *= random.randn(*ysim_array.shape) * sigma + 1 return ysim
def main(): t = linspace(0, 60) y = pint.odesolve(model, t) print y['A_total'][-1], y['B_total'][-1] plot(t, y['A_total']) plot(t, y['B_total']) legend([o.name for o in model.observables]) show()
def main(): t = linspace(0, 60) y = pint.odesolve(model, t) print y.A_total[-1], y.B_total[-1] plot(t, y.A_total) plot(t, y.B_total) legend([o.name for o in model.observables]) show()
def visualize(self, fig_path='', tspan=None, parameters=None, verbose=False): if verbose: print("Solving Simulation") if tspan is not None: self.tspan = tspan elif self.tspan is None: raise Exception("'tspan' must be defined.") if parameters is not None: # accept vector of parameter values as an argument if len(parameters) != len(self.model.parameters): raise Exception("parameters must be the same length as model.parameters") if not isinstance(parameters, numpy.ndarray): parameters = numpy.array(parameters) else: # create parameter vector from the values in the model parameters = numpy.array([p.value for p in self.model.parameters]) new_pars = dict((p.name, parameters[i]) for i, p in enumerate(self.model.parameters)) self.parameters = new_pars self.y = odesolve(self.model, self.tspan, self.parameters) if verbose: print("Creating graph") self.species_graph() self.sp_graph.layout(prog='dot', args="-Gstart=50 -Gesep=1.5 -Gnodesep=0.8 -Gsep=0.5 -Gsplines=true -Gsize=30.75,10.75\! " "-Gratio=fill -Grankdir=LR -Gdpi=200! -Gordering=in") self.sp_graph.add_node('t', label='time', shape='oval', fillcolor='white', style="filled", color="transparent", fontsize="50", margin="0,0", pos="20,20!") self.edges_colors(self.y) self.nodes_colors(self.y) if os.path.exists(fig_path): directory = fig_path else: directory = os.getcwd() + '/visualizations' os.makedirs(directory) if verbose: "Generating images" for kx, time in enumerate(self.tspan): self.sp_graph.get_node('t').attr['label'] = 'time:' + ' ' + '%d' % time + ' ' + 'sec' map(functools.partial(change_edge_colors, graph=self.sp_graph), list(self.colors_time_edges.index), list(self.colors_time_edges.iloc[:, kx])) map(functools.partial(change_node_colors, graph=self.sp_graph), list(self.colors_time_nodes.index), list(self.colors_time_nodes.iloc[:, kx])) self.sp_graph.draw(directory + '/file' + '%03d' % kx + '.png')
def plot_pores_and_efflux(model): t = np.linspace(0, 5000, 500) x = odesolve(model, t) plt.figure() avg_pores = x['pores']/model.parameters['Vesicles_0'].value plt.plot(t, avg_pores, 'r', label="Pores/Ves") plt.plot(t, 1 - np.exp(-avg_pores), 'b', label="Dye release") plt.legend(loc='lower right') plt.xlabel('Time (sec)') plt.show()
def add_subplot(traj, title, params): plt.title(title) plt.plot(tspan, traj, '0.5', lw=2, alpha=0.25) plt.plot(tspan, traj.mean(1), 'k-*', lw=3, label="Mean") plt.plot(tspan, traj.min(1), 'b--', lw=3, label="Minimum") plt.plot(tspan, traj.max(1), 'r--', lw=3, label="Maximum") y = odesolve(model, tspan, params) plt.plot(tspan, y[name], 'g--', lw=3, label="ODE") plt.ylim(0, 800) plt.xlabel('Time') plt.ylabel('X molecules')
def tropicalize(self, tspan=None, param_values=None, ignore=1, epsilon=1, plot_imposed_trace=False, verbose=False): """ tropicalization of driver species :param plot_imposed_trace: Option to plot imposed trace :param tspan: Time span :param param_values: PySB model parameter values :param ignore: Initial time points to ignore :param epsilon: Order of magnitude difference between solution of ODE and imposed trace to consider species as passenger :param verbose: Verbose :return: """ if verbose: print("Solving Simulation") if tspan is not None: self.tspan = tspan else: raise SimulatorException("'tspan' must be defined.") if param_values is not None: # accept vector of parameter values as an argument if len(param_values) != len(self.model.parameters): raise Exception("param_values must be the same length as model.parameters") if not isinstance(param_values, numpy.ndarray): param_values = numpy.array(param_values) else: # create parameter vector from the values in the model param_values = numpy.array([p.value for p in self.model.parameters]) # convert model parameters into dictionary self.param_values = dict((p.name, param_values[i]) for i, p in enumerate(self.model.parameters)) self.y = odesolve(self.model, self.tspan, self.param_values) if verbose: print("Getting Passenger species") if plot_imposed_trace: self.find_passengers(self.y[ignore:], epsilon, plot=plot_imposed_trace) else: self.find_passengers(self.y[ignore:], epsilon) if verbose: print("equation to tropicalize") self.equations_to_tropicalize() if verbose: print("Getting tropicalized equations") self.final_tropicalization() self.data_drivers(self.y[ignore:]) return
def simulate(f2=0.5, tmax=3000): t = linspace(0, tmax, 100) ion() figure() model.parameters['Bid_0'].value = f2 * 1e-1 x = odesolve(model, t) plot(t, x['aBax_']/model.parameters['Bax_0'].value, label='aBax') plot(t, x['Bid_']/model.parameters['Bid_0'].value, label='Bid free') plot(t, x['Bcl2_']/model.parameters['Bcl2_0'].value, label='Bcl2 free') plot(t, x['Bcl2_Bid_']/model.parameters['Bid_0'].value, label='Bcl2-Bid') plot(t, x['Bcl2_Bax_']/model.parameters['Bax_0'].value, label='Bcl2-Bax') legend() return x
def run_model_ode(tmax=12000): from pysb.integrate import odesolve t = np.linspace(0, tmax, 1000) x = odesolve(model, t) ci = color_iter() plt.figure(1) # Translocation plt.plot(t, (x['ctBid'])/tBid_0.value, label='ctBid', color=ci.next()) plt.plot(t, (x['mtBid'])/tBid_0.value, label='mtBid', color=ci.next()) plt.plot(t, (x['cBax'])/Bax_0.value, label='cBax', color=ci.next()) plt.plot(t, (x['mBax'])/Bax_0.value, label='mBax', color=ci.next()) plt.legend()
def simulate(f2=0.5, tmax=3000): t = linspace(0, tmax, 100) ion() figure() model.parameters['Bid_0'].value = f2 * 1e-1 x = odesolve(model, t) plot(t, x['aBax_'] / model.parameters['Bax_0'].value, label='aBax') plot(t, x['Bid_'] / model.parameters['Bid_0'].value, label='Bid free') plot(t, x['Bcl2_'] / model.parameters['Bcl2_0'].value, label='Bcl2 free') plot(t, x['Bcl2_Bid_'] / model.parameters['Bid_0'].value, label='Bcl2-Bid') plot(t, x['Bcl2_Bax_'] / model.parameters['Bax_0'].value, label='Bcl2-Bax') legend() return x
def run_model(): t = linspace(0,200,100) Pep_0 = 1e-6 L_0 = 10e-6 figure() x = odesolve(model,t) plot(t, x['eVes']/L_0 , label='eVes') plot(t, x['wPep']/Pep_0, label='wPep') plot(t, x['lfPep']/Pep_0, label='lfPep') plot(t, x['lePep']/Pep_0, label='lePep') xlabel('Time (s)') ylabel('Fraction of peptide species') #ylabel('Percentage Dye Release') legend()
def fig_4a(): print("Simulating model for figure 4A...") t = linspace(0, 20 * 3600, 20 * 60 + 1) # 20 hours, in seconds, 1 min sampling dt = t[1] - t[0] Ls_exp = Lsat / array([1, 4, 20, 100, 500]) Td_exp = [144.2, 178.7, 236, 362.5, 656.5] Td_std = [32.5, 32.2, 36.4, 78.6, 171.6] Ts_exp = [21.6, 23.8, 27.2, 22.0, 19.0] Ts_std = [9.5, 9.5, 12.9, 7.7, 10.5] CVenv = 0.2 # num steps was originally 40, but 15 is plenty smooth enough for screen display Ls = floor(logspace(1, 5, 15)) fs = empty_like(Ls) Ts = empty_like(Ls) Td = empty_like(Ls) print("Scanning over %d values of L_0" % len(Ls)) for i in range(len(Ls)): model.parameters['L_0'].value = Ls[i] print(" L_0 = %g" % Ls[i]) x = odesolve(model, t) fs[i] = (x['PARP_unbound'][0] - x['PARP_unbound'][-1]) / x['PARP_unbound'][0] dP = 60 * (x['PARP_unbound'][:-1] - x['PARP_unbound'][1:]) / ( dt * x['PARP_unbound'][0]) # in minutes ttn = argmax(dP) dPmax = dP[ttn] Ts[i] = 1 / dPmax # minutes Td[i] = t[ttn] / 60 # minutes figure("Figure 4A") plot(Ls / Lfactor, Td, 'g-', Ls / Lfactor, (1 - CVenv) * Td, 'g--', Ls / Lfactor, (1 + CVenv) * Td, 'g--') errorbar(Ls_exp / Lfactor, Td_exp, Td_std, None, 'go', capsize=0), ylabel('Td (min)'), xlabel('TRAIL (ng/ml)'), a = gca() a.set_xscale('log') a.set_xlim((min(Ls) / Lfactor, max(Ls) / Lfactor)) a.set_ylim((0, 1000)) model.parameters['L_0'].value = L_0_baseline
def plot_from_params(params_dict): """Plot the model output using the given parameter value.""" # The specific model may need to be changed here m1c = tBid_Bax_1c(params_dict=params_dict) m1c.build_model2() model = m1c.model plt.ion() plt.plot(tspan, ydata_norm) output = odesolve(model, tspan) #output_array = output.view().reshape(len(tspan), len(output.dtype)) iBax = 2*output['Bax2'] + 4*output['Bax4'] iBax_norm = iBax / max(iBax) plt.plot(tspan, iBax_norm[:]) plt.show()
def figure_2a(): """Reproduce the dose-response in Figure 2a of [Chen2007febs]_. Despite the fact that the PySB versions of the two models exactly reproduce the ODEs given in the supplement of the Chen et al. paper, this function does not quantitatively reproduce the plots in Figure 2. The steady-state output of both models is slightly higher than shown in the figure: for example, the steady-state fraction of oligomerized Bax produced by the PySB direct model for 0 input stimulus is 0.85, whereas the intercept shown in the plot is clearly lower than this. The same is true for the indirect model. The reasons for this are not clear, as the parameter values and ODE structure have been verified to be identical. There appears to be a discrepancy in the way that the dose-response curves are calculated, possibly in the timepoint used for sampling the steady-state value. """ f_range = linspace(0, 20, 50) t = linspace(0, 50000, 1000) ion() figure() for model in [direct, indirect]: ss_Bax4_vals = [] for f in f_range: if model is direct: model.parameters['Bid_0'].value = 1 + (f * 1) model.parameters['Bad_0'].value = 2 + (f * 2) else: model.parameters['Bid_0'].value = 3 + (f * 3) # Calculate the fraction of oligomerized Bax x = odesolve(model, t) Bax_frac = (4*x['Bax4_'])/model.parameters['Bax_0'].value ss_Bax4_val = Bax_frac[-1] ss_Bax4_vals.append(ss_Bax4_val) plot(f_range, ss_Bax4_vals, label='DM' if model is direct else 'IM') ylim([0.75, 1]) legend(loc='lower right')
def figure_2a(): """Reproduce the dose-response in Figure 2a of [Chen2007febs]_. Despite the fact that the PySB versions of the two models exactly reproduce the ODEs given in the supplement of the Chen et al. paper, this function does not quantitatively reproduce the plots in Figure 2. The steady-state output of both models is slightly higher than shown in the figure: for example, the steady-state fraction of oligomerized Bax produced by the PySB direct model for 0 input stimulus is 0.85, whereas the intercept shown in the plot is clearly lower than this. The same is true for the indirect model. The reasons for this are not clear, as the parameter values and ODE structure have been verified to be identical. There appears to be a discrepancy in the way that the dose-response curves are calculated, possibly in the timepoint used for sampling the steady-state value. """ f_range = linspace(0, 20, 50) t = linspace(0, 50000, 1000) ion() figure() for model in [direct, indirect]: ss_Bax4_vals = [] for f in f_range: if model is direct: model.parameters['Bid_0'].value = 1 + (f * 1) model.parameters['Bad_0'].value = 2 + (f * 2) else: model.parameters['Bid_0'].value = 3 + (f * 3) # Calculate the fraction of oligomerized Bax x = odesolve(model, t) Bax_frac = (4 * x['Bax4_']) / model.parameters['Bax_0'].value ss_Bax4_val = Bax_frac[-1] ss_Bax4_vals.append(ss_Bax4_val) plot(f_range, ss_Bax4_vals, label='DM' if model is direct else 'IM') ylim([0.75, 1]) legend(loc='lower right')
def fig_4a(): print("Simulating model for figure 4A...") t = linspace(0, 20*3600, 20*60+1) # 20 hours, in seconds, 1 min sampling dt = t[1] - t[0] Ls_exp = Lsat / array([1, 4, 20, 100, 500]) Td_exp = [144.2, 178.7, 236, 362.5, 656.5] Td_std = [32.5, 32.2, 36.4, 78.6, 171.6] Ts_exp = [21.6, 23.8, 27.2, 22.0, 19.0] Ts_std = [9.5, 9.5, 12.9, 7.7, 10.5] CVenv = 0.2 # num steps was originally 40, but 15 is plenty smooth enough for screen display Ls = floor(logspace(1,5,15)) fs = empty_like(Ls) Ts = empty_like(Ls) Td = empty_like(Ls) print("Scanning over %d values of L_0" % len(Ls)) for i in range(len(Ls)): model.parameters['L_0'].value = Ls[i] print(" L_0 = %g" % Ls[i]) x = odesolve(model, t) fs[i] = (x['PARP_unbound'][0] - x['PARP_unbound'][-1]) / x['PARP_unbound'][0] dP = 60 * (x['PARP_unbound'][:-1] - x['PARP_unbound'][1:]) / (dt * x['PARP_unbound'][0]) # in minutes ttn = argmax(dP) dPmax = dP[ttn] Ts[i] = 1 / dPmax # minutes Td[i] = t[ttn] / 60 # minutes figure("Figure 4A") plot(Ls/Lfactor, Td, 'g-', Ls/Lfactor, (1-CVenv)*Td, 'g--', Ls/Lfactor, (1+CVenv)*Td, 'g--') errorbar(Ls_exp/Lfactor, Td_exp, Td_std, None, 'go', capsize=0), ylabel('Td (min)'), xlabel('TRAIL (ng/ml)'), a = gca() a.set_xscale('log') a.set_xlim((min(Ls) / Lfactor, max(Ls) / Lfactor)) a.set_ylim((0, 1000)) model.parameters['L_0'].value = L_0_baseline
def fig_4b(): t = linspace(0, 6*3600, 6*60+1) # 6 hours x = odesolve(model, t) x_norm = c_[x['Bid_unbound'], x['PARP_unbound'], x['mSmac_unbound']] x_norm = 1 - x_norm / x_norm[0, :] # gets away without max() since first values are largest # this is what I originally thought 4B was plotting. oddly it's very close. #x_norm = array([x['tBid_total'], x['CPARP_total'], x['cSmac_total']]).T #x_norm /= x_norm.max(0) tp = t / 3600 # x axis as hours figure() plot(tp, x_norm[:,0], 'b', label='IC substrate (tBid)') plot(tp, x_norm[:,1], 'y', label='EC substrate (cPARP)') plot(tp, x_norm[:,2], 'r', label='MOMP (cytosolic Smac)') legend(loc='upper left', bbox_to_anchor=(0,1)).draw_frame(False) xlabel('Time (hr)') ylabel('fraction') a = gca() a.set_ylim((-.05, 1.05))
def sensitivity(self, tspan=None, parameters_ref=None, sp_SA=None, sampling_method='saltelli', analyze_method='sobol', N=1, verbose=True): ana_meth = importlib.import_module('SALib.analyze.%s' % analyze_method) if tspan is not None: self.tspan = tspan elif self.tspan is None: raise Exception("'time t' must be defined.") if sp_SA is None: raise Exception( "A species to do the sensitivity analysis on must be defined") if sp_SA not in [ str(sp) for sp in self.model.species ] and sp_SA not in [str(obs.name) for obs in self.model.observables]: raise Exception("Species is not in model species") ref = odesolve(self.model, self.tspan, param_values=parameters_ref) if verbose: print "Getting parameters information" self.pars_info(parameters_ref, sampling_method=sampling_method, N=N) if verbose: print "Simulating with parameters from sampling" p = multiprocessing.Pool(2) func = partial(self.sim_model, sp_SA=sp_SA) self.sim = p.map(func, self.param_sets) self.output = [sum((r - ref[sp_SA])**2) for r in self.sim] if verbose: print "Sensitivity analysis" self.sa_result = ana_meth.analyze(self.problem, numpy.array(self.output), print_to_console=True)
def main(self): sos_array = [] output = [] observables = self.make_model() write_columns(observables) write_model_attributes(model.rules, "rules") write_model_attributes(model.parameters, "parameters") write_model_attributes(model.observables, "observables") np.savetxt("time", self.tspan, fmt='%f') for sos in self.sos: model.parameters['Sos_0'].value = sos y = odesolve(model, self.tspan, compiler="python") sos_array.append(sos) # print(y[observables[0]][-1]) output.append(y[observables[0]][-1]) df = pd.DataFrame({'Sos': sos_array, 'RasGTP': output}) df.to_csv("./sos_rasgtp", sep='\t')
def main(self): output_array = [] ligand_array = [] ls_ss_array = [] r_ss_array = [] lf_ss_array = [] self.make_model() write_model_attributes(self.model.rules, "rules") write_model_attributes(self.model.parameters, "parameters") write_model_attributes(self.model.observables, "observables") np.savetxt("time", self.tspan, fmt='%f') for ligand in self.p_ligand: self.model.parameters['Ls_0'].value = ligand ligand_array.append(ligand) y = odesolve(self.model, self.tspan, compiler="python") output = y['O_SP'] ls_ss = y['O_Ls'] r_ss = y['O_R'] if self.self_foreign: lf_ss = y['O_Lf'] lf_ss_array.append(lf_ss[-1]) output_array.append(output[-1]) ls_ss_array.append(ls_ss[-1]) r_ss_array.append(r_ss[-1]) np.savetxt("Ligand_concentrations", ligand_array, fmt='%f') np.savetxt("output", output_array, fmt='%f') np.savetxt("ls_ss", ls_ss_array, fmt='%f') np.savetxt("lf_ss", lf_ss_array, fmt='%f') np.savetxt("r_ss", r_ss_array, fmt='%f')
def visualize(self, fig_path='', tspan=None, parameters=None, verbose=False): if verbose: print("Solving Simulation") if tspan is not None: self.tspan = tspan elif self.tspan is None: raise Exception("'tspan' must be defined.") if parameters is not None: # accept vector of parameter values as an argument if len(parameters) != len(self.model.parameters): raise Exception("parameters must be the same length as model.parameters") if not isinstance(parameters, numpy.ndarray): parameters = numpy.array(parameters) else: # create parameter vector from the values in the model parameters = numpy.array([p.value for p in self.model.parameters]) new_pars = dict((p.name, parameters[i]) for i, p in enumerate(self.model.parameters)) self.parameters = new_pars self.y = odesolve(self.model, self.tspan, self.parameters) if verbose: print("Creating graph") self.species_graph() self.sp_graph.add_node('t', label='time', shape='oval', fillcolor='white', style="filled", color="transparent", fontsize="50", margin="0,0", pos="20,20!") nx.write_gexf(self.sp_graph, '/home/oscar/Desktop/gexf_try1.gexf', version="1.2draft")
def howells_figure2ab(model): """Reproduce Figure 2a/b from Howells (2011).""" model.parameters['Bcl2_0'].value = 0.1 # Total Bcl2 model.parameters['Bax_0'].value = 0.2 # Total Bax model.parameters['Bid_0'].value = 0.018 # Total tBid model.parameters['Bad_0'].value = 0.025 # Total Bad Bcl2_free_0 = Parameter('Bcl2_free_0', model.parameters['Bcl2_0'].value - model.parameters['Bid_0'].value, _export=False) # free Bcl2 model.add_component(Bcl2_free_0) # Reset initial conditions model.initial_conditions = [] c = model.all_components() # pBad1433_0 = total Bad model.initial(c['Bad'](bf=None, state='C', serine='B'), c['Bad_0']) # Bax_inac_0 = total Bax model.initial(c['Bax'](bf=None, s1=None, s2=None, state='C'), c['Bax_0']) # tBid:Bcl2_0 = total tBid model.initial(c['Bid'](state='T', bf=1) % c['Bcl2'](bf=1), c['Bid_0']) # Bcl2_free = Bcl2_0 - tBid_0 model.initial(c['Bcl2'](bf=None), Bcl2_free_0) t = np.linspace(0, 300*60, 101) x = odesolve(model, t) plt.figure() plt.ion() t = t / 60 plt.plot(t, x['Bax4_'], label='Bak_poly') plt.plot(t, x['Bcl2_'], label='Bcl2') plt.plot(t, x['pBad1433_'], label='pBad:14-3-3') plt.plot(t, x['Bad_Bcl2_'], label='Bad:Bcl2') plt.plot(t, x['Bax_Bcl2_'], label='Bax:Bcl2') plt.legend(loc='upper right')
def plot_tbid_titration(model): plt.ion() bid_concs = np.logspace(0, 4, 40) t = np.linspace(0, 10000, 1000) initial_rates = [] plt.figure() for bid_conc in bid_concs: model.parameters['tBid_0'].value = bid_conc x = odesolve(model, t) avg_pores = x['pores']/model.parameters['Vesicles_0'].value plt.plot(t, avg_pores) initial_rate = avg_pores[10] / t[10] initial_rates.append(initial_rate) initial_rates = np.array(initial_rates) plt.title('Avg. pores with Bid titration') plt.xlabel('Time') plt.ylabel('Avg. pores per liposome') plt.show() # Run a regression against the points and calculate the initial_rate log_concs = np.log(bid_concs) log_initial_rates = np.log(initial_rates) (slope, intercept) = np.polyfit(log_concs, log_initial_rates, 1) fitted_initial_rates = (slope * log_concs) + intercept # Figure with slope and intercept info plt.figure() plt.figtext(0.2, 0.8, 'Slope: %.4f' % slope) plt.figtext(0.2, 0.75, 'Intercept: %.4f' % intercept) plt.plot(log_concs, log_initial_rates, 'b') plt.plot(log_concs, fitted_initial_rates, 'r') plt.xlabel('Log([Bid])') plt.ylabel('Log(V_i)') plt.title("Log-Log plot of initial rate vs. Bid conc") plt.show()
from .erbb_exec import model import numpy as np from pysb.integrate import odesolve t = np.linspace(0, 2000, num=2000) yout = odesolve(model, t)
from simple_reaction_pyurdme import model from pysb_pyurdme import run_pyurdme import numpy as np import matplotlib.pyplot as plt import pyurdme from pysb.integrate import odesolve model.diffusivities = [('E(b=None)', 0.001), ('P(b=None)', 0.2)] initial_dist = { 'E(b=None)': ['set_initial_condition_place_near', [0.5, 0.5]], 'S(b=None)': ['set_initial_condition_place_near', [1, 0.5]] } mesh = pyurdme.URDMEMesh.generate_unit_square_mesh(40, 40) tspan = np.linspace(0, 5, 500) y = odesolve(model, tspan) # plt.plot(tspan,y['__s2']) # plt.show() result = run_pyurdme(model, tspan, mesh, initial_dist)
y['OBS_p16'] /= max(y['OBS_p16']) if max(y['OBS_p16']) > 0.0 else 1 y['OBS_Rb'] /= max(y['OBS_Rb']) if max(y['OBS_Rb']) > 0.0 else 1 y['OBS_CycD_CDK46'] /= max( y['OBS_CycD_CDK46']) if max(y['OBS_CycD_CDK46']) > 0.0 else 1 t = linspace(0, 3000, 300) vol = 1e-19 # ** Set No Damage ** # set_volume(vol) Na_V = constants.N_A * vol set_dna_damage(0.0) # For volume, * Na_V y = odesolve(model, t, verbose=True, rtol=1e-15, atol=1e-15) # set_dna_damage(0.0 * Na_V) # For volume, * Na_V # y = run_ssa(model,t,verbose=True, rtol = 1e-15, atol = 1e-15) normalize_output(y) pl.figure() for obs in ["OBS_p27", "OBS_E2F", "OBS_CycE", "OBS_CycA"]: pl.plot(t, y[obs], label=re.match(r"OBS_(\w+)", obs).group(1), linewidth=3) pl.legend(loc=0, prop={'size': 16}) pl.ylim(ymax=1.2) pl.xlabel("Time (arbitrary units)", fontsize=22) pl.ylabel("Protein Level", fontsize=22) pl.xticks(fontsize=18) pl.yticks(fontsize=18) pl.title("Protein Dynamics (No DNA Damage)", fontsize=22) pl.savefig("G1_S Cell Cycle No DNA Damage1.png", format="png")
#!/usr/bin/env python """Simulate the bax_pore model and plot the results.""" from __future__ import print_function from pylab import * from pysb.integrate import odesolve from bax_pore import model t = linspace(0, 100) print("Simulating...") x = odesolve(model, t) p = plot(t, c_[x['BAX4'], x['BAX4_inh']]) figlegend(p, ['BAX4', 'BAX4_inh'], 'upper left') show()
Parameter('k_CD44_div', 0.3) Parameter('k_CD44_die', 0.2) Rule('CD44_div', CD44() >> CD44() + CD44(), k_CD44_div) Rule('CD44_die', CD44() >> None, k_CD44_die) Parameter('k_TPC_diff_Hes1', 0.5) Parameter('k_TPC_diff_CD44', 0.1) Rule('TPC_diff_Hes1', TPC() >> Hes1(), k_TPC_diff_Hes1) Rule('TPC_diff_CD44', TPC() >> CD44(), k_TPC_diff_CD44) ########################################################################### # In vivo tumors have on average 50% TPCs, 20% Hes1 cells, 5% CD44+ cells, and 25% unknown cell types. tspan = np.linspace(0, 10, 101) x = odesolve(model, tspan, verbose=True) # x = run_ssa(model, tspan[-1], len(tspan)-1, verbose=True) cell_tot = x['TPC_tot'] + x['Hes1_tot'] + x['CD44_tot'] print('TPC frac: %g (%g)' % (x['TPC_tot'][-1] / cell_tot[-1], 50 / 80)) print('Hes1+ frac: %g (%g)' % (x['Hes1_tot'][-1] / cell_tot[-1], 25 / 80)) print('CD44+ frac: %g (%g)' % (x['CD44_tot'][-1] / cell_tot[-1], 5 / 80)) plt.figure() plt.plot(tspan, x['TPC_tot'], lw=3, color='b', label='TPC') plt.plot(tspan, x['Hes1_tot'], lw=3, color='g', label='Hes1+') plt.plot(tspan, x['CD44_tot'], lw=3, color='r', label='CD44+') # plt.annotate("A" , (0.2, 0.8), xycoords='axes fraction', fontsize=24) plt.xlabel('time (d)', fontsize=16) plt.ylabel('cell count', fontsize=16)
Monomer('L', ['s']) Monomer('R', ['s']) # Declare the parameters Parameter('L_0', 100) Parameter('R_0', 200) Parameter('kf', 1e-3) Parameter('kr', 1e-3) # Declare the initial conditions Initial(L(s=None), L_0) Initial(R(s=None), R_0) # Declare the binding rule Rule('L_binds_R', L(s=None) + R(s=None) <> L(s=1) % R(s=1), kf, kr) # Observe the complex Observable('LR', L(s=1) % R(s=1)) if __name__ == '__main__': print __doc__ # Simulate the model through 40 seconds time = linspace(0, 40, 100) print "Simulating..." x = odesolve(model, time) # Plot the trajectory of LR plot(time, x['LR']) xlabel('Time (seconds)') ylabel('Amount of LR') show()
# Integrates Robertson's example, as defined in robertson.py, and # plots the trajectories. from pylab import * from pysb.integrate import odesolve from robertson import model # solve from t=0 to t=40 t = linspace(0, 40) yrec = odesolve(model, t, rtol=1e-4, atol=[1e-8, 1e-14, 1e-6]) # build a normal array with the values from the recarray y = yrec.view().reshape(len(yrec), len(yrec[0])) # plot trajectories, each normalized to the range 0-1 p = plot(t, y / y.max(0)) figlegend(p, ['y1', 'y2', 'y3'], 'upper right') show()
#!/usr/bin/env python from pysb.integrate import odesolve from pylab import linspace, plot, legend, show from kinase_cascade import model tspan = linspace(0, 1200) print "Simulating..." yfull = odesolve(model, tspan) plot(tspan, yfull['ppMEK'], label='ppMEK') plot(tspan, yfull['ppERK'], label='ppERK') legend(loc='upper left') show()
from pysb.examples.robertson import model from pysb.integrate import odesolve import numpy import matplotlib.pyplot as plt import sys scenario = 2 if len(sys.argv) > 1: scenario = int(sys.argv[1]) seed = 2 random = numpy.random.RandomState(seed) sigma = 0.1 ntimes = 20 tspan = numpy.linspace(0, 40, ntimes) ysim = odesolve(model, tspan) ysim_array = ysim.view(float).reshape(len(ysim), -1) yspecies = ysim_array[:, :len(model.species)] ydata = yspecies * (random.randn(*yspecies.shape) * sigma + 1) ysim_max = yspecies.max(0) ydata_norm = ydata / ysim_max def likelihood(mcmc, position): yout = mcmc.simulate(position) yout_norm = yout / ysim_max if scenario == 3: # fit to "perfect" data ret = numpy.sum((yspecies / ysim_max - yout_norm)**2 / (2 * sigma**2)) else: # fit to noisy data
import G1_S_v1 as m import pylab as pl from pysb.integrate import odesolve from sympy import sympify # Set to False to plot I, Mdm2, p21, p53 cyclins = True ################################# ## Force PySB to generate ODEs ## ################################# t = pl.linspace(0,3000, num = 300) y = odesolve(m.model,t) ############### ## Overrides ## ############### _source = "s30" #m.model.odes[24] = sympify("k60*s32 + k61*s28 - k62*s24 - k73*s24*s25*s28 + k73*s24*s25*s31 - k74*s24*s25") m.model.odes[25] = sympify("k63*" + _source + " + k66*s27**9/(k65**9 + s27**9) - k64*s25") #!!! m.model.odes[27] = sympify("(k70*s24*s28)/(1 + k71*s24*s25) - k67*s27") #!!! m.model.odes[28] = sympify("-k72*s28") #!!! #m.model.odes[18] = sympify("k40*s32 + k41/(1 + k42*s23) - k43*s18 - k44*s18*s5") #m.model.odes[23] = sympify("-k45*s21*s23 + k55*s22 + k56*s32 - k57*s23 + k58/(1 + k59*s18)") ########### ## Solve ## ########### t = pl.linspace(0,3000, num = 300) y = odesolve(m.model,t)
if m == 'tyson': from pysb.examples.tyson_oscillator import model tspan = np.linspace(0, 100, 100) elif m == 'ras': from ras_amp_pka import model tspan = np.linspace(0, 1500, 100) elif m == 'earm': from earm.lopez_embedded import model tspan = np.linspace(0, 20000, 100) colors = cm.rainbow(np.linspace(0, 1, len(model.observables))) x = odesolve(model, tspan, atol=1e-6, rtol=1e-6, nsteps=20000, verbose=True) for i, obs in enumerate(model.observables): ax.plot(tspan, x[obs.name] / np.nanmax(x[obs.name]), lw=3, label=obs.name.lstrip('obs_'), c=colors[i]) if m == 'ras': ax.legend(loc='center left', bbox_to_anchor=(1.05, 0.5), fontsize=8) else: ax.legend(loc='center left', bbox_to_anchor=(1.05, 0.5))
import pickle from anrm import merge from pysb.integrate import odesolve from anrm.irvin_anrm_experiment_10 import model #Edit parameters new_params = pickle.load(open('TNFa_H2_Calibrated_Params_exp10.pkl')) param_edits = merge.Edit_Parameters(model.parameters, new_params) merged_parameters = param_edits.merged_parameters pysb.core.Model('m') m.monomers = model.monomers m.compartments = model.compartments m.parameters = merged_parameters m.rules = model.rules m.observables = model.observables m.initial_conditions = model.initial_conditions t = np.linspace(0, 20000, 100) yout = odesolve(m, t) p.ion() p.plot(t, yout['Obs_cPARP'], label='Cleaved Parp') p.plot(t, yout['Obs_MLKL'], label='MLKL') p.xlabel('time [sec]') p.ylabel('PARP concentration [molecules per cell]') p.legend()
Rule('A_D', A(d=None) + D(s=None) <> A(d=1) % D(s=1), k_A_D, l_A_D) Rule('B_D', B(d=None) + D(s=None) <> B(d=1) % D(s=1), k_B_D, l_B_D) Initial(A(d=None), Parameter('A_0', 1)) Initial(B(d=None), Parameter('B_0', 1.1)) Initial(D(s=None), Parameter('D_0', 1)) Observable('tA', A(d=None)) Observable('tB', B(d=None)) Observable('tD', D(s=None)) Observable('tAD', A(d=1) % D(s=1)) Observable('tBD', B(d=1) % D(s=1)) t = np.linspace(0, 3, 10000) z1 = odesolve( model, t) #, integrator='vode', with_jacobian=True, rtol=1e-20, atol=1e-20) pl.figure() pl.xlim(0, 3) pl.ylim(0, 1) pl.title('A_0=1,B_0=1.1,D_0=1 with k_ad, 0.4,>k_bd, 0.3') pl.plot(t, z1['tA'], label="A") pl.plot(t, z1['tB'], label="B") pl.plot(t, z1['tD'], label="D") pl.plot(t, z1['tAD'], label="AD") pl.plot(t, z1['tBD'], label="BD") pl.legend() pl.xlabel("Time") pl.ylabel("Concentrations") pl.show()
from pysb import * from pysb.integrate import odesolve from nbd_model import model params_dict = { } #tspan = nbd.time_c62 nbd_avgs, nbd_stds = nbd.calc_norm_avg_std() #ydata_norm = nbd_avgs[1] # NBD_62c # Plot data curves plt.ion() plt.plot(nbd.time_other, nbd_avgs[0], 'r,', label='c3 data', alpha=0.2) plt.plot(nbd.time_c62, nbd_avgs[1], 'g,', label='c62 data', alpha=0.2) plt.plot(nbd.time_other, nbd_avgs[2], 'b,', label='c120 data', alpha=0.2) plt.plot(nbd.time_other, nbd_avgs[3], 'm,', label='c122 data', alpha=0.2) plt.plot(nbd.time_other, nbd_avgs[4], 'k,', label='c126 data', alpha=0.2) # Plot model curves tspan = nbd.time_other x = odesolve(model, tspan) plt.plot(tspan, x['Baxc3'] * model.parameters['c3_scaling'].value, 'r', label='c3 model') plt.plot(tspan, x['Baxc62'], 'g', label='c62 model') plt.plot(tspan, x['Baxc120'], 'b', label='c120 model') plt.plot(tspan, x['Baxc122'], 'm', label='c122 model') plt.plot(tspan, x['Baxc126'], 'k', label='c126 model') plt.show() plt.legend(loc='lower right')
def sim_model(self, par, sp_SA=None): y = odesolve(self.model, self.tspan, par) return y[sp_SA]