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 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_dense(kernel, neuron_params, ID, plot):
"""
"""
resolution = 1.
np.random.seed(kernel['seeds'])
kernel["resolution"] = resolution
kernel["angles_in_radians"] = True
ds.set_kernel_status(kernel, simulation_id=ID)
neuron_params['growth_cone_model'] = gc_model
neuron_params["position"] = np.random.uniform(-1000, 1000,
(num_neurons, 2))
gid = ds.create_neurons(n=num_neurons,
params=neuron_params,
axon_params=axon_params,
dendrites_params=dendrite_params,
num_neurites=6,
position=[])
# ds.set_object_properties(gid, params=neuron_params,
# axon_params=neuron_params)
step(3. / resolution, 1, False, plot)
step(300. / resolution, 1, False, plot)
neuron_params['use_van_pelt'] = True
dendrite_params['use_van_pelt'] = True
axon_params['use_flpl_branching'] = False
axon_params['flpl_branching_rate'] = 0.001
ds.set_object_properties(gid,
params=neuron_params,
dendrites_params=dendrite_params,
axon_params=axon_params)
step(6000. / resolution, 1, False, plot)
axon_migated = {
'use_van_pelt': True,
# "flpl_branching_rate" : 0.004,
"res_retraction_threshold": 0.4,
"res_elongation_threshold": 0.15,
"res_elongation_factor": 0.6,
# 'use_van_pelt' : True,
"res_neurite_generated": 4500.,
"res_neurite_delivery_tau": 50.,
"res_correlation": 0.15,
"res_variance": 0.02,
"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, 1, False, plot)
ds.SaveSwc(swc_resolution=25)
ds.save_json_info()
swc_file = ds.get_simulation_id()
# print(swc_file)
# ds.reset_kernel()
return swc_file
def run_dense(neuron_params):
"""
"""
resolution = 1.
# np.random.seed(kernel['seeds'])
np.random.seed(13)
kernel["resolution"] = resolution * minute
# kernel["angles_in_radians"] = False
ds.set_kernel_status(kernel, simulation_id="van_pelt_branching")
neuron_params['growth_cone_model'] = gc_model
neuron_params["position"] = np.random.uniform(-2500, 2500,
(num_neurons, 2)) * um
gid = ds.create_neurons(n=num_neurons,
params=neuron_params,
num_neurites=3,
position=[])
step(6000. / resolution * hour, 1, False, True)
ds.SaveSwc(swc_resolution=5)
ds.save_json_info()
swc_file = ds.get_simulation_id()
print(swc_file)
# ds.reset_kernel()
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_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_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_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 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_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 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 run_dense(neuron_params):
"""
"""
resolution = 1.
np.random.seed(kernel['seeds'])
kernel["resolution"] = resolution * minute
ds.set_kernel_status(kernel, simulation_id="van_pelt_branching")
neuron_params['growth_cone_model'] = gc_model
neuron_params["position"] = np.random.uniform(
-500, 500, (num_neurons, 2)) * um
gid = ds.create_neurons(n=num_neurons,
params=neuron_params,
axon_params=axon_params,
num_neurites=3,
position=[]
)
neuron_params['use_van_pelt'] = False
neuron_params['use_flpl_branching'] = False
ds.set_object_properties(gid, params=neuron_params,
axon_params=axon_params)
step(200./resolution * minute, 1, False, True)
neuron_params['use_van_pelt'] = True
# neuron_params['use_flpl_branching'] = True
# neuron_params["flpl_branching_rate"] = 0.001
ds.set_object_properties(gid, params=neuron_params,
axon_params=neuron_params)
step(1000./resolution * minute, 1, False, True)
step(1000./resolution * minute, 1, False, True)
step(1000./resolution * minute, 1, False, True)
step(1000./resolution * minute, 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()
swc_file = ds.get_simulation_id()
# print(swc_file)
# ds.reset_kernel()
return swc_file
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 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 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_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
if kernel["environment_required"]:
shape = ds.environment.Shape.disk(300.)
culture = ds.set_environment(shape)
# generate the neurons inside the left chamber
# pos_left = culture.seed_neurons(
# 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({
culture_file = main_dir + "/angle40.svg"
ds.set_kernel_status(kernel, simulation_id="ID")
neuron_params['growth_cone_model'] = 'run-and-tumble'
gids = None
culture = ds.set_environment(culture_file, min_x=0, max_x=500)
ds.environment.plot.plot_shape(culture, show=True)
# generate the neurons inside the left chamber
pos_left = culture.seed_neurons(neurons=100, xmin=0, xmax=100, soma_radius=soma_radius)
neuron_params['position'] = pos_left
gids = ds.create_neurons(n=100, culture=culture, params=neuron_params,
num_neurites=1)
#~ ds.plot.plot_neurons(show=True)
#~ step(200, 0, False)
for loop_n in range(5):
step(1000, loop_n, True)
# prepare the plot
fig, ax = plt.subplots()
#~ ds.plot.plot_neurons(gid=range(100), culture=culture, soma_color="k",
#~ axon_color='#00ff00a0', axis=ax, show=False)
#~ ds.plot.plot_neurons(gid=range(100, 200), show_culture=False, axis=ax,
#~ soma_color='k', axon_color='#ffa000a0',
#~ show=True)
ax, ax2 = ds.plot.plot_neurons(gid=range(40), culture=culture, soma_color="k",
def run_dense(kernel, neuron_params, ID, plot=True):
"""
"""
np.random.seed(kernel['seeds'])
resolution = kernel["resolution"]
kernel["angles_in_radians"] = True
ds.set_kernel_status(kernel, simulation_id=ID)
neuron_params['growth_cone_model'] = gc_model
neuron_params["position"] = np.random.uniform(-1000, 1000,
(num_neurons, 2))
gid = ds.create_neurons(n=num_neurons,
params=neuron_params,
axon_params=axon_params,
dendrites_params=dendrite_params,
num_neurites=4,
position=[])
step(100. / resolution, 1, False, plot)
arborization = {
"use_van_pelt": True,
"gc_split_angle_mean": 0.50,
"B": 11.,
"T": 200.
}
arborization_axon = {
"use_van_pelt": True,
"gc_split_angle_mean": 1.0,
"B": 19.,
"T": 2000.
}
dendrite_params.update(arborization)
axon_params.update(arborization_axon)
ds.set_object_properties(gid,
params=neuron_params,
dendrites_params=dendrite_params,
axon_params=axon_params)
step(1000. / resolution, 1, False, plot)
elongation = {
"use_van_pelt": False,
"persistence_length": 30.,
}
dendrite_params.update(elongation)
ds.set_object_properties(gid,
params=neuron_params,
dendrites_params=dendrite_params,
axon_params=axon_params)
step(2002. / resolution, 1, False, plot)
stortignation = {
"use_van_pelt": False,
"persistence_length": 10.,
}
stortignation_axon = {
"use_van_pelt": False,
# "sensing_angle": 0.20,
"use_flpl_branching": True,
"persistence_length": 91.,
"flpl_branching_rate": 0.0066,
}
# dendrite_params.update(stortignation)
# axon_params.update(stortignation_axon)
# ds.set_object_properties(gid,
# params=neuron_params,
# dendrites_params=dendrite_params,
# axon_params=axon_params)
step(2000. / resolution, 1, False, plot)
# stortignation = {"use_van_pelt": False,
# "persistence_length":10.,
# }
# stortignation_axon={
# "use_van_pelt": False,
# "use_flpl_branching": True,
# "flpl_branching_rate" : 0.003,
# "sensing_angle": 0.63,
# "persistence_length": 40.,
# }
# dendrite_params.update(stortignation)
# axon_params.update(stortignation_axon)
# ds.set_object_properties(gid,
# params=neuron_params,
# dendrites_params=dendrite_params,
# axon_params=axon_params)
# step(2000./resolution, 1, False, True)
# step(2000./resolution, 1, False, True)
ds.SaveSwc(swc_resolution=5)
ds.save_json_info()
swc_file = ds.get_simulation_id()
# print(swc_file)
# ds.reset_kernel()
return swc_file
}
kernel = {
"resolution": 30. * minute,
"seeds": [8],
"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=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,
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)]
}
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)
kernel = {
"seeds": [33],
"num_local_threads": 1,
"resolution": 30. * minute,
"environment_required": False
}
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)
'''
neurite_params = {
"axon": {
"initial_diameter": 4. * um
},
"dendrites": {
"taper_rate": 1. / 200.,
"initial_diameter": 3. * um
}
}
# 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,
}
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,
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")
