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)
