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 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()
"use_uniform_branching": True,
"uniform_branching_rate": 0.1 * cph,
})
ds.set_object_properties(gids,
params=neuron_params,
dendrites_params=dendrite_params,
axon_params=axon_params)
# ~ for i in range(2):
# ~ step(4.*day, 0, True)
# ~ step(16.25*hour, 0, True)
step(simtime, 0, True)
# ~ step(5.*hour, 0, True)
duration = time.time() - start
print(ds.get_kernel_status("time"))
# prepare the plot
plt.show(block=True)
print("SIMULATION ENDED")
# save
# ~ save_path = CleanFolder(os.path.join(os.getcwd(),"2culture_swc"))
# ~ ds.save_json_info(filepath=save_path)
# ~ ds.SaveSwc(filepath=save_path,swc_resolution = 10)
# ~ graph = ds.generate_network(connection_proba=1)
# ~ graph.to_file("circular.el")
# ~ nngt.plot.draw_network(graph, show=True)
#~ "T": 40000.,
#~ "gc_split_angle_mean": 30.,
}
dend_params = {
"use_van_pelt": True,
"use_uniform_branching": False,
"B": 5. * cpm,
"T": 50000. * minute,
"gc_split_angle_mean": 30. * deg,
}
ds.set_object_properties(n, dendrites_params=dend_params, axon_params=vp_axon)
ds.simulate(70000 * minute)
print(ds.get_kernel_status()["time"])
ds.plot.plot_neurons(show=True)
n.to_swc("pyramidal-cell.swc")
n.to_neuroml("bipolar_cell.nml")
import neurom as nm
from neurom import viewer
nrn = nm.load_neuron("pyramidal-cell.swc")
fig, _ = viewer.draw(nrn)
for ax in fig.axes:
ax.set_title("")
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,
"filopodia_min_number": 25,
"proba_down_move": 0.05,
"scale_up_move": 5.,
"position": [(0., 0.) for _ in range(num_neurons)]
def step(n, loop_n, plot=True):
ds.simulate(n)
if plot:
ds.plot_neurons(show_nodes=True, show=False)
if __name__ == '__main__':
# ~ kernel={"seeds":[33, 64, 84, 65, 68, 23],
# ~ "num_local_threads": 6,
# ~ "resolution": 10.}
kernel = {"seeds": [31], "num_local_threads": 1, "resolution": 10.}
kernel["environment_required"] = False
ds.get_kernel_status(kernel)
'''
Create neurons
'''
num_neurons = 1
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,
"resolution": 10. * minute,
"adaptive_timestep": -1.,
"environment_required": True
}
np.random.seed(12892) # seeds for the neuron positions
# ok pour 35 pas pour 40
#np.random.seed(21829) # seeds for the neuron positions
# ok pour 40
#np.random.seed(118239) # seeds for the neuron positions
culture_file = current_dir + "arches_3b.svg"
ds.set_kernel_status(kernel, simulation_id="ID")
gids, culture = None, None
print(ds.get_kernel_status("num_local_threads"))
if kernel["environment_required"]:
culture = ds.set_environment(culture_file, min_x=0, max_x=800)
# generate the neurons inside the left chamber
pos = culture.seed_neurons(
# upper region ymin=500.
neurons=num_neurons,
soma_radius=soma_radius,
ymin=790)
neuron_params['position'] = pos
else:
neuron_params['position'] = np.random.uniform(-1000, 1000,
(200, 2)) * um
print("Creating neurons")
fig, ax = plt.subplots()
fig.patch.set_alpha(0.)
fig0, ax0 = plt.subplots()
fig0.patch.set_alpha(0.)
for k, resol in enumerate(resolutions):
print("\nSimulating with resol {}\n".format(resol))
np.random.seed(1)
ds.reset_kernel()
ds.get_kernel_status({
"resolution": resol,
"num_local_threads": num_omp,
"seeds": [2 * i + 1 for i in range(num_omp)],
})
# ~ width = resol*np.sin(sensing_angle*np.sqrt(resol))
width = 50.
ds.set_environment(shape)
base_affinity = 10.
params = {
"sensing_angle": sensing_angle,
# ~ "filopodia_wall_affinity": base_affinity/resol,
# ~ "filopodia_wall_affinity": base_affinity/np.sqrt(resol),
# ~ "filopodia_wall_affinity": base_affinity*np.sqrt(resol),
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=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
