def test_models(): ''' Simulate one neurons with each defaults model ''' models = ds.get_models() observables = ds.get_default_properties('neuron', 'observables', settables_only=False) for m in models: print(m) ds.reset_kernel() kernel = {"environment_required": False} params = { "growth_cone_model": m, "position" : [0.,0.]*um } ds.set_kernel_status(kernel) gids = ds.create_neurons(n=1, num_neurites=3, params=params) rec = [ds.create_recorders(gids, obs, levels="neuron") for obs in observables] ds.simulate(10*hour) for r in rec: ds.get_recording(r)
def test_persistence(): persistences = [] for k, resol in enumerate(resolutions): np.random.seed(1) ds.reset_kernel() ds.set_kernel_status({ "resolution": resol * minute, "num_local_threads": num_omp, "seeds": [2 * i for i in range(num_omp)], "environment_required": False, "adaptive_timestep": -1., "interactions": False, }) params = { "growth_cone_model": gc_model, "speed_growth_cone": speed * um / minute, "filopodia_wall_affinity": 2.5, "filopodia_min_number": 100, "proba_down_move": 0.05, "scale_up_move": 5. * um, "persistence_length": l_p * um, "sensing_angle": sensing_angle, "position": [(0., 0.) for _ in range(num_neurons)] * um, "taper_rate": 0., } gids = ds.create_neurons(n=num_neurons, num_neurites=1, params=params) rec = ds.create_recorders(gids, "length") ds.simulate(simtime * minute) ''' Analyze the resulting neurons ''' population = ds.elements.Population.from_gids(gids) axons = [neuron.axon.xy.m.transpose() for neuron in population] sequence = [] for i, points in enumerate(axons): sequence.append(correlation(points, distances)) avg_corr = np.average(sequence, axis=0) lp, _ = curve_fit(exp_decay, distances, avg_corr, p0=l_p) persistences.append(lp) if do_plot: ax2.scatter(resol, lp[0]) ax.plot(distances, avg_corr, color=cmap(colors[k]), alpha=1, label="resol: {}".format(resol)) ax.plot(distances, exp_decay(distances, lp[0])) if show_neurons: ds.plot.plot_neurons(show=False, title=str(resol)) if do_plot: ax.plot(distances, np.exp(-distances / l_p), ls="--", c="k") ax.legend(loc=1, fancybox=True, frameon=True) ax.set_ylabel("Correlation") ax.set_ylabel(r"Distance ($\mu$m)") ax2.set_ylabel(r"Persistence length ($\mu$m)") ax2.set_xlabel("Resolution (minutes)") ax2.axhline(l_p) fig.patch.set_alpha(0.) fig2.patch.set_alpha(0.) plt.show() # just check that no ridiculous number is encountered for lp in persistences: assert lp > 0. and np.abs((lp - l_p) / l_p) < 0.5
# neurons=100, xmax=540, soma_radius=soma_radius) neuron_params['position'] = culture.seed_neurons( neurons=num_neurons, soma_radius=soma_radius) else: neuron_params['position'] = \ np.random.uniform(-1000, 1000, (num_neurons, 2))*um print("\nCreating neurons\n") gids = ds.create_neurons(n=num_neurons, culture=culture, params=neuron_params, dendrites_params=dendrite_params, axon_params=axon_params, num_neurites=3) rec = ds.create_recorders(gids, "num_growth_cones") start = time.time() for i in range(1): step(1 * day, 0, True) dendrite_params.update({ "speed_growth_cone": 0.04 * um / minute, "use_van_pelt": False }) axon_params.update({ "speed_growth_cone": 0.1 * um / minute, "use_van_pelt": False, "use_uniform_branching": True, "uniform_branching_rate": 0.1 * cph,
"use_critical_resource": False, "sensing_angle": sensing_angle, "filopodia_wall_affinity": 2.5, "filopodia_min_number": 25, "proba_down_move": 0.05, "scale_up_move": 5., "position": [(0., 0.) for _ in range(num_neurons)] } if gc_model == "run_tumble": params["persistence_length"] = 50. gids = ds.create_neurons(n=num_neurons, num_neurites=1, params=params) if recording: rec = ds.create_recorders(gids, observable, levels="growth_cone") ds.simulate(simtime) ''' Analyze the resulting neurons ''' # neurons = ds.structure.NeuronStructure(gids) structure = ds.morphology.NeuronStructure(gids) population = ds.Population.from_structure(structure) ens = ds.EnsembleRW(population) sequence.append(ens) num_trials = 10 step_size = np.linspace(0.01, 1., num_trials) tort_evol = np.zeros((num_neurons, num_trials)) ahist = np.zeros(len(abins) - 1) axons = [neuron.axon.xy.transpose() for neuron in population]
"seeds": [10], "environment_required": False, "num_local_threads": num_omp, } ds.set_kernel_status(kernel) # create neurons n = ds.create_neurons(n=num_neurons, params=neuron_params, axon_params=axon_params, dendrites_params=dend_params, num_neurites=4) rec = ds.create_recorders(n, ["angle", "length"], levels="growth_cone") rec2 = ds.create_recorders(n, "num_growth_cones", levels="neurite") # Turn branching on #~ vp_branching = {'use_van_pelt': True} # resource_branching = {'res_branching_threshold': 80., 'res_branching_proba': 0.0005} # d_rsrc_branching = {'res_branching_threshold': 60., 'res_branching_proba': 0.0003} #~ ds.set_object_properties(n, params=vp_branching) #~ ds.set_object_properties(n, params=resource_branching) # ds.set_object_properties(n, axon_params=resource_branching, dendrites_params=d_rsrc_branching) ds.simulate(5 * day) ds.plot.plot_recording(rec, show=False) ds.plot.plot_neurons(show=True)
ds.set_kernel_status(kernel) ''' Create neurons ''' neuron_params['position'] = (0, 0) * um gids = ds.create_neurons(n=1, params=neuron_params, neurite_params=neurite_params, num_neurites=3) ''' Create recorders ''' gids_rec = ds.create_recorders(gids, "length", levels="growth_cone") ''' simulate first non-branching period ''' ds.simulate(7 * day) print("Simulation time : {}".format(dense.get_kernel_status('time'))) ds.plot.plot_neurons(mode="mixed", show=True) ''' Change the parameters to include growth cone splitting ''' print("\nVan Pelt branching ON\n") # additional new parameters, with branching
neuron_params['growth_cone_model'] = 'default' neuron_params['position'] = np.random.uniform(-10000, 10000, (num_neurons, 2)) gids = ds.create_neurons(n=num_neurons, growth_cone_model='random_walk', params=neuron_params, dendrites_params=dendrite_params, num_neurites=2) ''' Create recorders ''' gids_rec = ds.create_recorders(gids, "length", levels="growth_cone") rec_ngc = ds.create_recorders(gids, "num_growth_cones", levels="neuron") #~ step(6000, 0, True) #~ for i in range(10): #~ print("\nNew step block") #~ step(2000, 0, True) for i in range(10): print("\nNew step block") step(2000, 0, False) ds.plot_neurons(show_nodes=True, show=True) #~ pprint(ds.get_object_properties(gids_rec)) ds.plot_recording(rec_ngc, time_units="minutes")
if __name__ == '__main__': kernel = { "seeds": [0], "num_local_threads": 1, "environment_required": False, "resolution": 5.*minute, } ds.set_kernel_status(kernel) neuron = ds.create_neurons(n=num_neurons, params=neuron_params, axon_params=axon_params, dendrites_params=dendrite_params, num_neurites=2) rec = ds.create_recorders(neuron, "num_growth_cones", levels="neuron") ds.simulate(2*hour) ds.plot.plot_neurons(scale=None) neuron.dendrites["dendrite_1"].set_properties({ "B": 6.*cpm, "T": 5.*hour, # "somatropic_scale": 200.*um, "somatropic_factor": 1. }) ds.simulate(15*hour) ds.plot.plot_neurons(scale=False) neuron.set_properties(dendrites_params={ "use_van_pelt": False, "use_uniform_branching": True, "uniform_branching_rate": 1.*cph, "speed_growth_cone": 0.1*um/minute,
def run_dense(neuron_params): """ """ kernel["resolution"] = resolution * minute ds.set_kernel_status(kernel, simulation_id="case_neuron") neuron_params['growth_cone_model'] = gc_model print(neuron_params['growth_cone_model']) neuron_params["position"] = np.random.uniform(-1000, 1000, (num_neurons, 2)) * um print(neuron_params['growth_cone_model']) gid = ds.create_neurons(n=num_neurons, params=neuron_params, axon_params=axon_params, dendrites_params=dendrite_params, num_neurites=1) print(neuron_params['growth_cone_model']) # ~ rec = ds.create_recorders(gid, ["speed", "resource"], levels="growth_cone") rec = ds.create_recorders(gid, ["resource"], levels="growth_cone") print(neuron_params['growth_cone_model']) # ds.set_object_properties(gid, params=neuron_params, # axon_params=neuron_params) step(3. / resolution * minute, 1, False, False) step(500. / resolution * minute, 1, False, False) print(neuron_params['growth_cone_model']) neuron_params['use_van_pelt'] = True dendrite_params['use_van_pelt'] = True axon_params['use_flpl_branching'] = True axon_params['flpl_branching_rate'] = 0.001 * cpm neuron_params.pop('growth_cone_model') print(dendrite_params) ds.set_object_properties(gid, params=neuron_params, dendrites_params=dendrite_params, axon_params=axon_params) step(2000. / resolution * minute, 1, False, True) axon_migated = { # 'use_flpl_branching' : True, # "flpl_branching_rate" : 0.004 * cpm, "res_retraction_threshold": 0.4 * uM, "res_elongation_threshold": 0.15 * uM, "res_elongation_factor": 0.4 * um / minute, # 'use_van_pelt' : True, "res_neurite_generated": 4500. * uM, "res_neurite_delivery_tau": 50. * minute, "res_correlation": 0.15, "res_variance": 0.02 * uM / minute**0.5, "res_use_ratio": 0.3, } axon_params.update(axon_migated) ds.set_object_properties(gid, params=neuron_params, dendrites_params=dendrite_params, axon_params=axon_params) step(3000. / resolution * minute, 1, False, True) # neuron_params['use_flpl_branching'] = True # neuron_params["flpl_branching_rate"] = 0.001 * cpm # ds.set_object_properties(gid,params = neuron_params, # axon_params= neuron_params) # step(1000./resolution, 1, False, True) # step(1000./resolution, 1, False, True) # step(1000./resolution, 1, False, True) # step(1000./resolution, 1, False, True) # step(180, 1, False, True) # step(1080, 1, False, True) # step(1080, 1, False, True) # step(1080, 1, False, True) # step(1080, 1, False, True) # step(1080, 1, False, True) # step(1080, 1, False, True) # step(4080, 1, False, True) # neuron_params['use_van_pelt'] = True # ds.set_object_properties(gid,params = neuron_params, # axon_params=neuron_params) # step(10, 1, False, True) # step(10, 1, False, False) # neuron_params['use_lateral_branching'] = True #~ ds.SaveSwc(swc_resolution=5) #~ ds.save_json_info() ds.plot.plot_recording(rec, show=False) swc_file = ds.get_simulation_id() # print(swc_file) # ds.reset_kernel() return swc_file
# mpl.use("Qt5Agg") ds.set_kernel_status("resolution", 10. * minute) params = { # "growth_cone_model": "run-and-tumble", "growth_cone_model": "self-referential-forces", "somatropic_factor": 0.03, "somatropic_scale": 50. * um, "noise_amplitude": 1. * deg, "position": (0., 0.) * um, } neuron = ds.create_neurons(params=params, num_neurites=1) rec = ds.create_recorders(neuron, ["length", "stepping_probability"], levels="growth_cone") ds.simulate(1 * day) # ds.plot.plot_recording(rec, show=True) neuron.set_properties({ "use_uniform_branching": True, "uniform_branching_rate": 0.3 * cph, }) ds.simulate(0.51 * day) # ds.plot.plot_recording(rec, show=False) # ds.plot.plot_neurons(mode="mixed") neuron.set_properties({"use_uniform_branching": False})
"num_local_threads": 1, "environment_required": False, "resolution": resolution * minute, } ds.set_kernel_status(kernel, simulation_id="case_neuron") neuron_params['growth_cone_model'] = gc_model neuron_params["position"] = np.random.uniform(-1000, 1000, (num_neurons, 2)) * um gid = ds.create_neurons(n=num_neurons, params=neuron_params, axon_params=axon_params, num_neurites=1) rec = ds.create_recorders(gid, ["length", "resource"], levels="growth_cone") ds.simulate(3 * day) ''' Get recording ''' data = ds.get_recording(rec, "compact") key = (0, "axon", 1) times = data["resource"]["times"][key] resc = data["resource"]["data"][key] leng = data["length"]["data"][key] # plot resource probability distribution fig, ax = plt.subplots() sns.distplot(resc, hist=False, kde=True, rug=True)
''' Create neurons ''' neuron_params['growth_cone_model'] = 'default' neuron_params['position'] = np.random.uniform(-1000, 1000, (5, 2)) num_neurons = 5 gids = ds.create_neurons(n=num_neurons, growth_cone_model='random_walk', params=neuron_params, dendrites_params=dendrite_params, num_neurites=2) pprint("neuron status") pprint(ds.get_object_properties(gids[0])) ''' Create recorders ''' gids_rec = ds.create_recorders(gids, "length", levels="neurite") print(gids_rec, ds.get_object_properties(gids_rec)) print("start simu") step(100, 0, False) ds.plot_recording(gids_rec, show=True)
def test_branching(): do_plot = int(os.environ.get("DO_PLOT", True)) num_omp = 4 res = 10. # seed initial_state = np.random.get_state() seeds = np.random.choice(np.arange(0, 1000), size=num_omp, replace=False) num_neurons = 10 gc_model = 'gf_po_nm' btype = 'flpl' branching_rate = btype + '_branching_rate' branching_type = 'use_' + btype + '_branching' neuron_params = { "position" : np.random.uniform( -1000, 1000, (num_neurons, 2)) * um, "growth_cone_model": gc_model, "sensing_angle": 45.*deg, "speed_growth_cone": .1 * um / minute, "persistence_length": 100. * um, "filopodia_finger_length": 10. * um, "filopodia_min_number": 30, "lateral_branching_angle_mean": 25.*deg, "lateral_branching_angle_std": 0.*deg, "min_branching_distance": 5.*um, "taper_rate": 0., "diameter_fraction_lb": 1., branching_type: True, "use_van_pelt": False, } expected_branching = 500. test_nb = 6 rates = np.linspace(0.001, 0.005, test_nb) mean = [] er = [] Nb = [] scipy_exp = [] for rate in rates: ds.reset_kernel() kernel = { "resolution": res*minute, "seeds": seeds, "environment_required": False, "interactions": False, "num_local_threads": num_omp, } ds.set_kernel_status(kernel) sim_time = expected_branching/rate * minute sim_time.ito(day) neuron_params[branching_rate] = rate * cpm pop = ds.create_neurons(n=num_neurons, params=neuron_params, num_neurites=1) rec = ds.create_recorders(pop, 'num_growth_cones', levels='neuron') ds.simulate(sim_time) branch_times = ds.get_recording(rec)['num_growth_cones']['times'] Dt = [] for bn in branch_times.values(): if len(bn) > 1: Dt.extend(np.diff(bn)) mean.append(np.mean(Dt)) # 99% confidence interval for a Poisson distribution gives 2.576 er.append(2.576/rate/np.sqrt(len(Dt))) Nb.append(len(Dt)) mean_merr = np.subtract(mean, er) mean_perr = np.add(mean, er) test1 = (1/rates > mean_merr) test2 = (1/rates < mean_perr) if do_plot: import matplotlib.pyplot as plt plt.plot(rates, mean) plt.plot(rates, 1/rates, ls=":") plt.fill_between(rates, mean_merr, mean_perr, alpha=0.5) plt.show() assert test1.all() and test2.all(), \ "Failed test with state " + str(initial_state)