def test_functions(): ''' Run each of the main functions. ''' ds.reset_kernel() ds.set_kernel_status('environment_required', False) m = ds.generate_model('constant', 'memory-based', 'run-and-tumble') dp = ds.get_default_properties(m) e = ds.get_environment() ks = ds.get_kernel_status() ms = ds.get_models() pp = {"growth_cone_model": m, "position": (0., 0.) * um} gn = ds.create_neurons(params=pp, num_neurites=2) n = ds.get_neurons() ns = ds.get_object_properties(n) ns = ds.get_object_properties(n, level="neurite") ns = ds.get_object_properties(n, level="growth_cone") ns = ds.get_object_state(n) assert ds.get_object_state(n, "num_growth_cones") == 2 ns = ds.get_object_state(n, level="dendrite_1") si = ds.get_simulation_id() ds.simulate(20 * hour) ni = ds.get_neurons()
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 step(n, loop_n, save_path, plot=True): ds.simulate(n) if plot: if save_path is False: ds.plot_neurons(show_nodes=True) else: ds.plot_neurons(show_nodes=False, save_path=save_path)
def run_axon_only(B, E, S, T, seed): neuron_params = { "position": np.random.uniform(-1000, 1000, (1, 2)) * um, "retraction_probability": 1., "somatropic_factor": 0.02, "self_avoidance_factor": 1., "growth_cone_model": "self-referential-forces", "filopodia_finger_length": 20. * um } ds.reset_kernel() axon_params = { "use_van_pelt": True, "B": B, "E": E, "S": S, "T": T * minute, "gc_split_angle_mean": 35. * deg, } kernel = { "resolution": 30. * minute, "seeds": [seed], "environment_required": False, "num_local_threads": 1, } ds.set_kernel_status(kernel) neurite_params = {"axon": axon_params} n = ds.create_neurons(n=1, params=neuron_params, neurite_params=neurite_params, num_neurites=1) ds.simulate(21 * day) return n
def test_network(plot=False): ''' Bigger network ''' ds.reset_kernel() ds.set_kernel_status({ "resolution": 10. * minute, "num_local_threads": 6, }) initial_state = np.random.get_state() num_neurons = 100 positions = np.random.uniform(-200, 200, (num_neurons, 2)) * um params = { "position": positions, "growth_cone_model": "run-and-tumble", } neurons = ds.create_neurons(num_neurons, params, num_neurites=3) ds.simulate(0.45 * day) net = ds.morphology.generate_network(method="spines", max_spine_length=4. * um) if plot: ds.plot.plot_neurons(neurons, show_neuron_id=True) assert net.node_nb() == num_neurons, \ "Incorrect node number in the network; failed with state " + \ str(initial_state)
def test_final_diam(): ds.reset_kernel() diam_axon = 2. * um diam_dend = 3. * um taper = 0.005 # create one neuron neuron = ds.create_neurons(num_neurites=2, params={ "axon_diameter": diam_axon, "dendrite_diameter": diam_dend, "taper_rate": taper }) ds.simulate(100. * minute) len_axon = neuron.axon.total_length len_dend = neuron.dendrites["dendrite_1"].total_length daxon_th = diam_axon - len_axon * taper ddend_th = diam_dend - len_dend * taper assert np.isclose(neuron.axon.branches[0].diameter.m, daxon_th.m) assert np.isclose(neuron.dendrites["dendrite_1"].branches[0].diameter.m, ddend_th.m)
def test_2neuron_network(plot=True): ''' Most simple network of 2 neurons ''' ds.reset_kernel() ds.set_kernel_status("resolution", 10. * minute) num_neurons = 2 positions = [(0, 0), (20, -20)] * um params = { "position": positions, "growth_cone_model": "run-and-tumble", "neurite_angles": [ { "axon": 90. * deg, "dendrite_1": 270. * deg }, { "axon": 180. * deg, "dendrite_1": 60. * deg }, ], } neurons = ds.create_neurons(num_neurons, params, num_neurites=2) ds.simulate(0.45 * day) net = ds.morphology.generate_network(method="spines", spine_density=1. / um**2, max_spine_length=4. * um) if plot: ds.plot.plot_neurons(neurons, show_neuron_id=True) assert net.node_nb() == num_neurons, \ "Incorrect node number in the network" assert net.edge_nb() == 1, \ "Incorrect number of edges in the network" assert net.get_edge_attributes(name="weight")[0] > 1, \ "Incorrect weight" net = ds.morphology.generate_network(method="intersections", connection_probability=1., default_synaptic_strength=2.) assert net.node_nb() == num_neurons, \ "Incorrect node number in the network" assert net.edge_nb() == 1, \ "Incorrect number of edges in the network" assert net.get_edge_attributes(name="weight")[0] == 2, \ "Incorrect weight"
def step(n, loop_n, plot=True): print("simulating", n) ds.simulate(n) print("done") if plot: _, ax = plt.subplots() ds.plot.plot_neurons(mode='mixed', subsample=1, axis=ax, show_nodes=True, show_neuron_id=True, show=True)
def test_dendrogram(): ''' Run each of the main functions. ''' ds.reset_kernel() ds.set_kernel_status('environment_required', False) m = ds.generate_model('constant', 'pull-only', 'noisy-weighted-average') pp = {"growth_cone_model": m, "position": (0., 0.) * um} np = {"use_uniform_branching": True, "uniform_branching_rate": 3. * cpd} gn = ds.create_neurons(params=pp, neurite_params=np, num_neurites=2) ds.simulate(2 * day) ds.plot.plot_dendrogram(gn.axon, show=False) gn.dendrites["dendrite_1"].plot_dendrogram(show=False)
def RunNetGrowth(n_samples, sim_length, n_procs, neuron_params, save_path="tmp_measure", plot=False): """ Run NetGrowth simulation """ kernel = { "seeds": [33, 57, 19, 37, 79, 87, 11][:n_procs], "num_local_threads": n_procs, "resolution": 1. } experiment_params = {} experiment_params["num_neurons"] = n_samples np.random.seed(kernel['seeds']) ds.get_kernel_status(kernel, ds.generate_simulation_id()) culture = ds.CreateEnvironment(culture_file, min_x=0, max_x=cavity_x_max) pos_left = culture.seed_neurons(neurons=experiment_params["num_neurons"], xmax=neuron_x_max, soma_radius=1.) neuron_params['growth_cone_model'] = 'random_walk' neuron_params['position'] = pos_left gids = None gids = ds.create_neurons(experiment_params["num_neurons"], "random_walk", culture=culture, params=neuron_params, num_neurites=1) ds.simulate(sim_length) # fig, ax = plt.subplots() # ds.plot.plot_neurons(gid=range(experiment_params["num_neurons"]), # culture = culture, soma_color="k", # axon_color='g', axis=ax, show=True) ds.save_json_info(filepath=save_path) ds.SaveSwc(filepath=save_path, swc_resolution=1) # ds.save_json_info(filepath=tmp_dir) # ds.plot_neurons(show_nodes=True) ds.reset_kernel()
"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] if do_tort: for i, s in enumerate(step_size):
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) lb = { # 'res_branching_threshold': np.inf, "use_flpl_branching": True, "flpl_branching_rate": 0.003 * cph, "lateral_branching_angle_mean": 50. * deg } lb_axon = lb.copy() lb_axon["flpl_branching_rate"] = 0.012 * cph ds.set_object_properties(n, axon_params=lb_axon, dendrites_params=lb)
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 vp_axon = { # branching choice and parameters "use_van_pelt": True, "gc_split_angle_mean": 30. * deg, "gc_split_angle_std": 5. * deg,
} # configure DeNSE ds.set_kernel_status(simu_params) # create neurons n = ds.create_neurons(n=num_neurons, params=neuron_params, neurite_params=neurite_params, num_neurites=2) ''' Plot the initial state ''' ds.plot.plot_neurons() ''' Simulate a few days then plot the result ''' ds.simulate(7 * day) ds.plot.plot_neurons() ''' Change parameters and simulate again ''' # new dendritic and axonal parameters axon_params = { "speed_growth_cone": 0.02 * um / minute, } dend_params = { "use_uniform_branching": False, "speed_growth_cone": 0.01 * um / minute, } neurite_params = {"axon": axon_params, "dendrites": dend_params}
def step(n, loop_n, save_path, plot=True): ds.simulate(n) if plot: ds.plot_neurons( show_nodes=True, save_path=save_path)
def step(n, loop_n, plot=True): ds.simulate(n*minute) if plot: ds.plot_neurons(show_nodes=True, show=True)
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
2.5, "proba_down_move": 0.1, "scale_up_move": 0., "axon_angle": -179. * deg, "position": [(x, y) * um for x, y in zip(np.random.uniform(490, 510, num_neurons), np.random.uniform(-250, 250, num_neurons))], } gids = ds.create_neurons(n=num_neurons, num_neurites=1, params=params) ds.simulate(800) neurons = ds.structure.NeuronStructure(gids) tips = np.concatenate( [neurons["growth_cones"][i] for i in range(num_neurons)]) contained = shape.areas["default_area"].contains_neurons(tips) fractions.append(np.sum(contained) / float(num_neurons)) lengths.append(neurite_length(gids)) ds.plot_neurons(show=False, title="resol {}".format(resol)) ''' Plot the results '''
"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, neurite_params=neurite_params, num_neurites=2) # first, elongation ds.simulate(7 * day) # then branching lb_axon = { "speed_growth_cone": 0.02 * um / minute, "use_van_pelt": False, "use_flpl_branching": True, "flpl_branching_rate": 0.00025 * cpm, "lateral_branching_angle_mean": 60. * deg, } dend_params = { "use_van_pelt": False, "use_uniform_branching": True, "uniform_branching_rate": 0.0002 * cpm,
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, "somatropic_scale": 300.*um, "somatropic_factor": 0.95, "self_avoidance_scale": 5.*um,
"seeds": [1], "environment_required": False, "num_local_threads": num_omp, "adaptive_timestep": -1., } ds.set_kernel_status(kernel) pyr_neuron = ds.create_neurons(1, params=pyr_nrn, axon_params=pyr_axon_i, dendrites_params=pyr_dend_i, num_neurites=3) # initial extension (5 days) ds.simulate(sim_time) ds.plot.plot_neurons(mode="mixed") print(ds.get_object_properties(pyr_neuron)) # Extension and branching period (5 days) ds.set_object_properties(pyr_neuron, axon_params=pyr_axon_lb, dendrites_params=pyr_dend_lb) ds.simulate(sim_time) ds.plot.plot_neurons(mode="mixed") # Extension and branching period (5 more days) ds.simulate(sim_time) ds.plot.plot_neurons(mode="mixed") # Termination period (10 days) ds.set_object_properties(pyr_neuron,
"environment_required": False, "num_local_threads": num_omp, "adaptive_timestep": -1., } ds.get_kernel_status(kernel) bip_neuron = ds.create_neurons(1, params=bip_nrn, axon_params=bip_axon_i, dendrites_params=bip_dend_i, num_neurites=2) # initial extension (5 days) ds.simulate(7200) show_nrn(bip_neuron) # Extension and branching period (5 days) ds.set_object_properties(bip_neuron, axon_params=bip_axon_lb, dendrites_params=bip_dend_lb) ds.simulate(7200) show_nrn(bip_neuron) # Extension and branching period (5 more days) ds.simulate(7200) show_nrn(bip_neuron)
def test_delete_neurons(): ''' Neurons deletion ''' ds.reset_kernel() num_neurons = 50 simtime = 2.*minute initial_state = np.random.get_state() ds.set_kernel_status("environment_required", False) # create and delete nparams = { "position": np.random.uniform(-1000, 1000, (num_neurons, 2))*um, "growth_cone_model": "res_po_rt" } neurons = ds.create_neurons(num_neurons, params=nparams, num_neurites=2) ds.delete_neurons(3) ds.delete_neurons(neurons[8]) # check neurons have been deleted neurons_got = ds.get_neurons() n_to_ints = [int(n) for n in neurons_got] n_to_ints += ds.get_neurons(True) assert len(n_to_ints) == 2*(num_neurons - 2), \ "Failed with state " + str(initial_state) assert 3 not in n_to_ints, \ "Failed with state " + str(initial_state) assert 8 not in n_to_ints, \ "Failed with state " + str(initial_state) # simulate then delete ds.simulate(simtime) ds.delete_neurons([5, 7]) ds.delete_neurons(neurons[40:45]) # recreate neurons and resimulate nparams = { "position": np.random.uniform(-1000, 1000, (num_neurons, 2))*um, "growth_cone_model": "res_po_rt" } _ = ds.create_neurons(num_neurons, params=nparams, num_neurites=2) ds.simulate(simtime) neurons_got = ds.get_neurons() n_to_ints = [int(n) for n in neurons_got] n_to_ints += ds.get_neurons(True) assert len(n_to_ints) == 2*(2*num_neurons - 4 - len(neurons[40:45])), \ "Failed with state " + str(initial_state) assert 5 not in n_to_ints, \ "Failed with state " + str(initial_state) assert 7 not in n_to_ints, \ "Failed with state " + str(initial_state) for n in neurons[40:45]: assert int(n) not in n_to_ints, \ "Failed with state " + str(initial_state) # delete all neurons ds.delete_neurons() # check no neurons are left assert not ds.get_neurons(), \ "Failed with state " + str(initial_state)
} ds.set_kernel_status(kernel) culture = ds.set_environment(cwd + "/simple_pattern.svg", min_x=0 * um, max_x=500 * um) interior = Shape(culture.intersection(Shape.disk(180 * um, (250, 0) * um))) exterior = Shape(culture.difference(Shape.disk(210 * um, (250, 0) * um))) gids = ds.create_neurons( n=int(0.8 * num_neurons), culture=interior, params=neuron_params, neurite_params=neurite_params, neurite_names=["axon", "dendrite_1", "dendrite_2"], num_neurites=3) gids = ds.create_neurons( n=int(0.2 * num_neurons), culture=exterior, params=neuron_params, neurite_params=neurite_params, neurite_names=["axon", "dendrite_1", "dendrite_2"], num_neurites=3) for i in range(2): ds.simulate(350. * minute) ds.plot.plot_neurons(show_neuron_id=False, scale_text=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=2) # first, elongation ds.simulate(10000 * minute) ds.plot.plot_neurons() # then branching lb_axon = { "speed_growth_cone": 0.02 * um / minute, "use_van_pelt": False, "use_flpl_branching": True, "flpl_branching_rate": 0.00025 * cpm, "lateral_branching_angle_mean": 45. * deg, } dend_params = { "use_van_pelt": False, "use_uniform_branching": True,
def step(n, loop_n, plot=True): ds.simulate(n) if plot: ds.plot_neurons(show_nodes=True, show=False)
def step(time, loop_n, plot=True): ds.simulate(time) if plot: ds.plot_neurons(show_nodes=True, show=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(20000) ds.plot.plot_neurons(show=True) lb = { "use_van_pelt": False, 'res_branching_threshold': np.inf, "use_flpl_branching": True, "flpl_branching_rate": 0.001, "lateral_branching_angle_mean": 45. } no_b = {"use_van_pelt": False} ds.set_object_properties(n, axon_params=lb, dendrites_params=no_b)
"seeds": [5], "environment_required": False, "num_local_threads": num_omp, # "interactions": False, } ds.set_kernel_status(kernel) # create neurons n = ds.create_neurons(n=num_neurons, params=neuron_params, dendrites_params=dend_params, num_neurites=8) ds.simulate(1. * day) ds.plot.plot_neurons() dend_params = { # "use_uniform_branching": True, # "uniform_branching_rate": 0.02*cph, # "lateral_branching_angle_mean": 70.*deg, } ds.set_object_properties(n, dendrites_params=dend_params) ds.simulate(1. * day) ds.plot.plot_neurons()
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}) ds.simulate(1 * day)