def lateral_branching(neuron_params): ds.reset_kernel() np.random.seed(kernel['seeds']) ds.set_kernel_status(kernel, simulation_id="uniform_branching") neuron_params['growth_cone_model'] = 'run_tumble' neuron_params[use_type] = False neuron_params["position"] = np.random.uniform(-500, 500, (num_neurons, 2)) * um gid = ds.create_neurons(n=num_neurons, params=neuron_params, num_neurites=2) step(1 * hour, 1, False, False) neuron_params[use_type] = True ds.set_object_properties(gid, params=neuron_params) # ~ axon_params=neuron_params) step(2 * day, 1, False, False) # neuron_params['use_lateral_branching'] = True ds.SaveSwc(swc_resolution=5) ds.save_json_info() swc_file = ds.get_simulation_id() # print(swc_file) return swc_file
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_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_3_space_embedded_neurons(monkeypatch): ''' Run second example. ''' monkeypatch.setattr(plt, "show", mock_show) ds.reset_kernel() exec(open(tuto + "/3_space-embedding.py").read())
def test_create_neurites_many_neurons(): ''' Detailed neurite creation for many neurons ''' ds.reset_kernel() # with two neurons, create neurites, all named neurons = ds.create_neurons(2) neurite_params = { "axon": { "speed_growth_cone": [0.1, 0.095] * um / minute }, "d1": { "speed_growth_cone": [0.02, 0.021] * um / minute }, "d2": { "speed_growth_cone": [0.03, 0.029] * um / minute } } ds.create_neurites(neurons, num_neurites=3, params=neurite_params) for neuron in neurons: assert set(neuron.neurites.keys()) == {"axon", "d1", "d2"} assert neurons[0].axon.speed_growth_cone == 0.1 * um / minute assert neurons[1].axon.speed_growth_cone == 0.095 * um / minute assert neurons[0].d1.speed_growth_cone == 0.02 * um / minute assert neurons[1].d1.speed_growth_cone == 0.021 * um / minute assert neurons[0].d2.speed_growth_cone == 0.03 * um / minute assert neurons[1].d2.speed_growth_cone == 0.029 * um / minute
def test_1_first_steps(monkeypatch): ''' Run first example. ''' monkeypatch.setattr(plt, "show", mock_show) ds.reset_kernel() exec(open(tuto + "/1_first-steps.py").read())
def test_2_interacting_neurons(monkeypatch): ''' Run second example. ''' monkeypatch.setattr(plt, "show", mock_show) ds.reset_kernel() exec(open(tuto + "/2_interacting-neurons.py").read())
def resource_branching(neuron_params): ds.reset_kernel() np.random.seed(kernel['seeds']) ds.set_kernel_status(kernel, simulation_id="van_pelt_branching") neuron_params['growth_cone_model'] = 'run_tumble_critical' neuron_params['res_branching_threshold'] = np.inf neuron_params["position"] = np.random.uniform(-500, 500, (num_neurons, 2)) gid = ds.create_neurons(n=num_neurons, params=neuron_params, axon_params=neuron_params, num_neurites=1, position=[]) step(10, 1, False, False) neuron_params['res_branching_threshold'] = b_th ds.set_object_properties(gid, params=neuron_params, axon_params=neuron_params) step(5000, 1, False, False) # neuron_params['use_lateral_branching'] = True ds.SaveSwc(swc_resolution=5) ds.save_json_info() swc_file = ds.get_simulation_id() # print(swc_file) return swc_file
def test_elements(): ''' Test members and methods of neuronal elements ''' ds.reset_kernel() neuron = ds.create_neurons(num_neurites=2) # test neuron neuron.get_properties() neuron.get_state() for obs in neuron.get_properties("observables"): neuron.get_state(obs) neuron.create_neurites() neuron.delete_neurites("dendrite_1") # test neurite neuron.axon.get_properties() neuron.axon.set_properties({"taper_rate": 0.1}) neuron.axon.get_state() neuron.axon.get_state("angle") neuron.dendrites["dendrite_2"].get_state() assert neuron.axon.name == "axon" assert str(neuron.axon) == "axon" assert neuron.dendrites["dendrite_2"].name == "dendrite_2" assert neuron == neuron.axon.neuron
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_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_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_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 test_delete_neurites(): ''' Neurons deletion ''' ds.reset_kernel() initial_state = np.random.get_state() num_neurons = 50 simtime = 2. * minute ds.set_kernel_status("environment_required", False) # create and delete pos = np.random.uniform(-1000, 1000, (num_neurons, 2)) * um neurons = ds.create_neurons(num_neurons, params={"position": pos}, num_neurites=2) ds.delete_neurites("axon") for n in neurons: assert not n.has_axon, \ "Failed with state " + str(initial_state) assert "axon" not in n.neurites, \ "Failed with state " + str(initial_state) assert len(n.neurites) == 1, \ "Failed with state " + str(initial_state) ds.create_neurites(neurons[0], neurite_types="axon") assert neurons[0].has_axon, \ "Failed with state " + str(initial_state) assert len(neurons[0].neurites) == 2, \ "Failed with state " + str(initial_state) ds.delete_neurites("dendrite_1", neurons[1]) for n in neurons: if n == neurons[1]: assert "dendrite_1" not in n.neurites, \ "Failed with state " + str(initial_state) assert not n.neurites, \ "Failed with state " + str(initial_state) elif n == neurons[0]: assert len(n.neurites) == 2, \ "Failed with state " + str(initial_state) else: assert len(n.neurites) == 1, \ "Failed with state " + str(initial_state) ds.delete_neurites() for n in neurons: assert not n.neurites, \ "Failed with state " + str(initial_state)
def test_initial_diam(): ''' Create neuron with one neurite and check initial diameter ''' ds.reset_kernel() diam = 2. * um # create one neuron neuron = ds.create_neurons(num_neurites=1, params={"axon_diameter": diam}) assert neuron.axon.branches[0].diameter == diam
def random_walk_axon(neuron_params): np.random.seed(kernel['seeds']) ds.set_kernel_status(kernel, simulation_id="random_walk_axons") neuron_params['growth_cone_model'] = 'random_walk' neuron_params["position"] = np.random.uniform(-500, 500, (num_neurons, 2)) ds.create_neurons(n=num_neurons, params=neuron_params, num_neurites=1, position=[]) name = str(neuron_params["persistence_length"]) step(1000, 1, os.path.join(os.getcwd(), "random_walk_axon_" + name)) ds.reset_kernel()
def run_dense(neuron_params, axes, letter, single=False): # neuron_params["rw_memory_tau"]: 4., # neuron_params["rw_delta_corr"]: 1.8, ds.set_kernel_status(kernel, simulation_id="random_walk_axons") neuron_params["position"] = np.zeros((num_neurons, 2)) * um simulated_neurons = num_neurons if single: simulated_neurons = 1. neuron_params["position"] = np.array([0, 0]) * um gids = ds.create_neurons(n=simulated_neurons, params=neuron_params, num_neurites=1, position=[]) step(1000 * second, 1, os.path.join(os.getcwd(), "primo"), plot=False) neurons = ds.get_neurons() structure = ds.morphology.NeuronStructure(neurons) population = ds.Population.from_structure(structure) axons = population.axon_all_points() from matplotlib.colors import LogNorm import matplotlib import copy axes.text(0.03, 1.2, letter, horizontalalignment='center', verticalalignment='center', weight='bold', fontsize=12, transform=axes.transAxes) if not single: my_cmap = copy.copy( matplotlib.cm.get_cmap('viridis')) # copy the default cmap my_cmap.set_bad((0, 0, 0)) axes.hist2d(axons[:, 0], axons[:, 1], bins=100, range=[[0, 400], [-200, 200]], norm=LogNorm(), cmap=my_cmap) axes.set_xlabel("X") axes.set_ylabel("Y") axes.set_title("path density for\n {}".format( neuron_params["growth_cone_model"])) else: axes.plot(axons[:, 0], axons[:, 1], c='r') ds.reset_kernel()
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 test_create(): ''' Create neurons and neurites ''' ds.reset_kernel() # create one neuron neuron = ds.create_neurons(num_neurites=1) # create a new neurite neuron.create_neurites(names="new_dendrite") assert len(neuron.neurites) == 2 assert "new_dendrite" in neuron.neurites neuron = ds.create_neurons() assert not neuron.neurites
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()
def run_dense(neuron_params,letter,length_simulation,single=False): # neuron_params["rw_memory_tau"]: 4., # neuron_params["rw_delta_corr"]: 1.8, ds.set_kernel_status(kernel, simulation_id="random_walk_axons") neuron_params["position"]=np.zeros((num_neurons,2)) simulated_neurons = num_neurons gids = ds.create_neurons(n=simulated_neurons, params=neuron_params, num_neurites=1, position=[] ) step(length_simulation, 1, False ,plot=False) neurons = ds.get_neurons() structure = ds.morphology.NeuronStructure(neurons) population = ds.Population.from_structure(structure) ens = ds.EnsembleRW(population) ens.characterizeRW("axon") ens.name = neuron_params["growth_cone_model"] fits = ens.fit() # import pdb; pdb.set_trace() # XXX BREAKPOINT ds.reset_kernel() return ens
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)
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
def test_named_neurites(): ''' Run second example. ''' ds.reset_kernel() exec(open(tuto + "/named_neurites.py").read())
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)
data_times = {} statuses = {} observable = "num_tumbles" fig, ax = plt.subplots() fig2, ax2 = plt.subplots() #~ observable = "angle" #~ observable = "status" xbins = np.linspace(-5000, 5000, int(num_neurons / 200.)) abins = np.linspace(-np.pi, np.pi, 50) tbins = np.linspace(50, 150, 50) sequence = [] for k, resol in enumerate(resolutions[::-1]): np.random.seed(1) ds.reset_kernel() ds.get_kernel_status({ "resolution": resol, "num_local_threads": num_omp, "seeds": [2 * i for i in range(num_omp)], "environment_required": with_env, }) if with_env: ds.set_environment(shape) params = { "growth_cone_model": gc_model, "use_critical_resource": False, "sensing_angle": sensing_angle, "filopodia_wall_affinity": 2.5,
def test_create_neurites_one_neuron(): ''' Detailed neurite creation for a single neuron ''' ds.reset_kernel() # with one neuron, create neurites, all named neuron = ds.create_neurons() neurite_params = { "axon": { "speed_growth_cone": 0.1 * um / minute, "initial_diameter": 1. * um }, "dendrite1": { "speed_growth_cone": 0.02 * um / minute }, "dendrite2": { "speed_growth_cone": 0.03 * um / minute } } neuron.create_neurites(num_neurites=3, params=neurite_params) assert len(neuron.neurites) == 3 assert set(neuron.dendrites.keys()) == {"dendrite1", "dendrite2"} assert neuron.axon.speed_growth_cone == 0.1 * um / minute assert neuron.axon.initial_diameter == 1. * um assert neuron.dendrite1.speed_growth_cone == 0.02 * um / minute assert neuron.dendrite2.speed_growth_cone == 0.03 * um / minute # with one neuron, create neurites using "dendrites" and names neuron = ds.create_neurons() neurite_params = { "axon": { "speed_growth_cone": 0.1 * um / minute }, "dendrites": { "speed_growth_cone": 0.0256 * um / minute } } neuron.create_neurites(num_neurites=3, params=neurite_params, names=["axon", "d1", "d2"]) assert set(neuron.neurites.keys()) == {"axon", "d1", "d2"} assert neuron.axon.speed_growth_cone == 0.1 * um / minute for dendrite in neuron.dendrites.values(): assert dendrite.speed_growth_cone == 0.0256 * um / minute # with one neuron, create neurites with all same parameters and names neuron = ds.create_neurons() neurite_params = {"speed_growth_cone": 0.0236 * um / minute} neuron.create_neurites(num_neurites=3, params=neurite_params, names=["axon", "dend1", "dend2"]) assert set(neuron.neurites.keys()) == {"axon", "dend1", "dend2"} for neurite in neuron.neurites.values(): assert neurite.speed_growth_cone == 0.0236 * um / minute