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)
for i, s in enumerate(step_size):
for j, points in enumerate(axons):
tort_evol[j][i] = tortuosity(points, step_size=s)
up, median, low = np.percentile(tort_evol, [90, 50, 10], axis=0)
ax.plot(step_size,
median,
color=cmap(colors[k]),
alpha=1,
label="resol: {}".format(resol))
ax.plot(step_size, low, ls="--", color=cmap(colors[k]), alpha=0.5)
ax.plot(step_size, up, ls="--", color=cmap(colors[k]), alpha=0.5)
# get observable status
if recording:
data = ds.get_recording(rec, "compact")
data_times[resol] = next(iter(data[observable]["times"].values()))
statuses[resol] = []
if observable == "num_tumbles":
for v in data[observable]["data"].values():
statuses[resol].append(v[-1])
hist, _ = np.histogram(statuses[resol], tbins)
statuses[resol] = hist
else:
for v in data[observable]["data"].values():
statuses[resol].append(v)
if do_angles:
# create neurons
n = ds.create_neurons(n=num_neurons, params=neuron_params,
axon_params=axon_params, dendrites_params=dend_params,
num_neurites=3)
rec = ds.create_recorders(n, "num_growth_cones")
# first development phase : initial pure elongation (no branching) during 7 days
ds.simulate(10*day)
print(ds.get_kernel_status('time'))
recording = ds.get_recording(rec, record_format="compact")
print(recording)
ds.plot.plot_neurons(mode="mixed", show=True)
# second development phase : with lateral branching
# updated parameters
lb_axon = {
# extension parameters
"speed_growth_cone": 0.02*um/minute,
# branching choice and parameters
"use_van_pelt": False,
"use_flpl_branching": 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)