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_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
# neurons=100, xmax=540, soma_radius=soma_radius)
neuron_params['position'] = culture.seed_neurons(
neurons=num_neurons, soma_radius=soma_radius)
else:
neuron_params['position'] = \
np.random.uniform(-1000, 1000, (num_neurons, 2))*um
print("\nCreating neurons\n")
gids = ds.create_neurons(n=num_neurons,
culture=culture,
params=neuron_params,
dendrites_params=dendrite_params,
axon_params=axon_params,
num_neurites=3)
rec = ds.create_recorders(gids, "num_growth_cones")
start = time.time()
for i in range(1):
step(1 * day, 0, True)
dendrite_params.update({
"speed_growth_cone": 0.04 * um / minute,
"use_van_pelt": False
})
axon_params.update({
"speed_growth_cone": 0.1 * um / minute,
"use_van_pelt": False,
"use_uniform_branching": True,
"uniform_branching_rate": 0.1 * cph,
"use_critical_resource": False,
"sensing_angle": sensing_angle,
"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]
"seeds": [10],
"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,
axon_params=axon_params,
dendrites_params=dend_params,
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)
ds.set_kernel_status(kernel)
'''
Create neurons
'''
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
neuron_params['growth_cone_model'] = 'default'
neuron_params['position'] = np.random.uniform(-10000, 10000,
(num_neurons, 2))
gids = ds.create_neurons(n=num_neurons,
growth_cone_model='random_walk',
params=neuron_params,
dendrites_params=dendrite_params,
num_neurites=2)
'''
Create recorders
'''
gids_rec = ds.create_recorders(gids, "length", levels="growth_cone")
rec_ngc = ds.create_recorders(gids, "num_growth_cones", levels="neuron")
#~ step(6000, 0, True)
#~ for i in range(10):
#~ print("\nNew step block")
#~ step(2000, 0, True)
for i in range(10):
print("\nNew step block")
step(2000, 0, False)
ds.plot_neurons(show_nodes=True, show=True)
#~ pprint(ds.get_object_properties(gids_rec))
ds.plot_recording(rec_ngc, time_units="minutes")
if __name__ == '__main__':
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,
def run_dense(neuron_params):
"""
"""
kernel["resolution"] = resolution * minute
ds.set_kernel_status(kernel, simulation_id="case_neuron")
neuron_params['growth_cone_model'] = gc_model
print(neuron_params['growth_cone_model'])
neuron_params["position"] = np.random.uniform(-1000, 1000,
(num_neurons, 2)) * um
print(neuron_params['growth_cone_model'])
gid = ds.create_neurons(n=num_neurons,
params=neuron_params,
axon_params=axon_params,
dendrites_params=dendrite_params,
num_neurites=1)
print(neuron_params['growth_cone_model'])
# ~ rec = ds.create_recorders(gid, ["speed", "resource"], levels="growth_cone")
rec = ds.create_recorders(gid, ["resource"], levels="growth_cone")
print(neuron_params['growth_cone_model'])
# ds.set_object_properties(gid, params=neuron_params,
# axon_params=neuron_params)
step(3. / resolution * minute, 1, False, False)
step(500. / resolution * minute, 1, False, False)
print(neuron_params['growth_cone_model'])
neuron_params['use_van_pelt'] = True
dendrite_params['use_van_pelt'] = True
axon_params['use_flpl_branching'] = True
axon_params['flpl_branching_rate'] = 0.001 * cpm
neuron_params.pop('growth_cone_model')
print(dendrite_params)
ds.set_object_properties(gid,
params=neuron_params,
dendrites_params=dendrite_params,
axon_params=axon_params)
step(2000. / resolution * minute, 1, False, True)
axon_migated = {
# 'use_flpl_branching' : True,
# "flpl_branching_rate" : 0.004 * cpm,
"res_retraction_threshold": 0.4 * uM,
"res_elongation_threshold": 0.15 * uM,
"res_elongation_factor": 0.4 * um / minute,
# 'use_van_pelt' : True,
"res_neurite_generated": 4500. * uM,
"res_neurite_delivery_tau": 50. * minute,
"res_correlation": 0.15,
"res_variance": 0.02 * uM / minute**0.5,
"res_use_ratio": 0.3,
}
axon_params.update(axon_migated)
ds.set_object_properties(gid,
params=neuron_params,
dendrites_params=dendrite_params,
axon_params=axon_params)
step(3000. / resolution * minute, 1, False, True)
# neuron_params['use_flpl_branching'] = True
# neuron_params["flpl_branching_rate"] = 0.001 * cpm
# ds.set_object_properties(gid,params = neuron_params,
# axon_params= neuron_params)
# step(1000./resolution, 1, False, True)
# step(1000./resolution, 1, False, True)
# step(1000./resolution, 1, False, True)
# step(1000./resolution, 1, False, True)
# step(180, 1, False, True)
# step(1080, 1, False, True)
# step(1080, 1, False, True)
# step(1080, 1, False, True)
# step(1080, 1, False, True)
# step(1080, 1, False, True)
# step(1080, 1, False, True)
# step(4080, 1, False, True)
# neuron_params['use_van_pelt'] = True
# ds.set_object_properties(gid,params = neuron_params,
# axon_params=neuron_params)
# step(10, 1, False, True)
# step(10, 1, False, False)
# neuron_params['use_lateral_branching'] = True
#~ ds.SaveSwc(swc_resolution=5)
#~ ds.save_json_info()
ds.plot.plot_recording(rec, show=False)
swc_file = ds.get_simulation_id()
# print(swc_file)
# ds.reset_kernel()
return swc_file
# mpl.use("Qt5Agg")
ds.set_kernel_status("resolution", 10. * minute)
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})
"num_local_threads": 1,
"environment_required": False,
"resolution": resolution * minute,
}
ds.set_kernel_status(kernel, simulation_id="case_neuron")
neuron_params['growth_cone_model'] = gc_model
neuron_params["position"] = np.random.uniform(-1000, 1000,
(num_neurons, 2)) * um
gid = ds.create_neurons(n=num_neurons,
params=neuron_params,
axon_params=axon_params,
num_neurites=1)
rec = ds.create_recorders(gid, ["length", "resource"],
levels="growth_cone")
ds.simulate(3 * day)
'''
Get recording
'''
data = ds.get_recording(rec, "compact")
key = (0, "axon", 1)
times = data["resource"]["times"][key]
resc = data["resource"]["data"][key]
leng = data["length"]["data"][key]
# plot resource probability distribution
fig, ax = plt.subplots()
sns.distplot(resc, hist=False, kde=True, rug=True)
'''
Create neurons
'''
neuron_params['growth_cone_model'] = 'default'
neuron_params['position'] = np.random.uniform(-1000, 1000, (5, 2))
num_neurons = 5
gids = ds.create_neurons(n=num_neurons,
growth_cone_model='random_walk',
params=neuron_params,
dendrites_params=dendrite_params,
num_neurites=2)
pprint("neuron status")
pprint(ds.get_object_properties(gids[0]))
'''
Create recorders
'''
gids_rec = ds.create_recorders(gids, "length", levels="neurite")
print(gids_rec, ds.get_object_properties(gids_rec))
print("start simu")
step(100, 0, False)
ds.plot_recording(gids_rec, show=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)