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
