# "num_local_threads": 1,
# "resolution": 5.*minute,
# "interactions": True}
# ~ kernel={
# ~ "seeds":[23, 68],
# ~ "num_local_threads": 2,
# ~ "resolution": 30.*minute
# ~ }
kernel["environment_required"] = False
ds.set_kernel_status(kernel, simulation_id="ID")
gids, culture = None, None
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,
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)]
}
if gc_model == "run_tumble":
params["persistence_length"] = 50.
if __name__ == '__main__':
kernel= {
"seeds": [i for i in range(num_omp)],
"num_local_threads": num_omp,
"resolution": 10.*minute,
#~ "adaptive_timestep": -1.
}
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)
# ~ "num_local_threads": 1,
# ~ "resolution": 30.}
#~ kernel={"seeds":[23, 68],
#~ "num_local_threads": 2,
#~ "resolution": 30.}
kernel["environment_required"] = True
culture_file = current_dir + "/2chamber_culture_sharpen.svg"
ds.set_kernel_status(kernel, simulation_id="ID")
gids, culture = None, None
num_neurons = 10
if kernel["environment_required"]:
culture = ds.set_environment(culture_file,
min_x=-culture_size,
max_x=culture_size)
# generate the neurons inside the left chamber
pos_left = culture.seed_neurons(neurons=num_neurons,
xmax=-220 * um,
soma_radius=soma_radius)
pos_right = culture.seed_neurons(neurons=num_neurons,
xmin=680 * um,
soma_radius=soma_radius)
neuron_params['position'] = np.concatenate((pos_right, pos_left)) * um
else:
neuron_params['position'] = np.random.uniform(
-1000, 1000, (int(2 * num_neurons), 2))
print("Creating neurons")
gids = ds.create_neurons(n=int(2 * num_neurons),
max_x = 800 # and height of 84.94 cm
min_y = -580
max_y = 580 # set here same aspect ratio X , Y as size of environment
# in the svg file
culture_file = current_dir + "angles5.svg"
#culture_file = current_dir + "Arches20reduced_thick-Tanguy.svg"
ds.set_kernel_status(kernel, simulation_id="ID")
#ds.set_kernel_status({"interactions": False})
gids, culture = None, None
print(ds.get_kernel_status("num_local_threads"))
if kernel["environment_required"]:
culture = ds.set_environment(culture_file, min_x=min_x, max_x=max_x)
Region = "BOTTOM"
if Region == "BOTTOM":
# generate the neurons inside the left chamber
pos = culture.seed_neurons(
# upper region ymin=500.
neurons=num_neurons, soma_radius=soma_radius, ymax=-200)
elif Region == "TOP":
# generate the neurons inside the right chamber
pos = culture.seed_neurons(
# upper region ymin=500.
neurons=num_neurons, soma_radius=soma_radius, xmin=590)
neuron_params['position'] = pos
else:
neuron_params['position'] = np.random.uniform(-1000, 1000, (200, 2)) * um
Simulation
'''
if __name__ == '__main__':
np.random.seed(1)
kernel = {
"seeds": np.random.randint(0, 1000, num_omp),
"num_local_threads": num_omp,
"resolution": 10. * minute,
}
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),
simu_params = {
"resolution": 10. * minute,
"num_local_threads": num_omp,
"seeds": [i for i in range(num_omp)],
"environment_required": True,
"interactions": False,
}
# configure DeNSE
ds.set_kernel_status(simu_params)
''' Create and set the environment '''
env = ds.environment.Shape.rectangle(500 * um, 500 * um)
ds.set_environment(env)
# choose neuron positions randomly inside
soma_radius = 4. * um
pos = env.seed_neurons(num_neurons,
soma_radius=soma_radius,
unit="um",
return_quantity=False)
neuron_params = {
"growth_cone_model": "simple-random-walk",
"position": [tuple(p) for p in pos] * um,
"persistence_length": 200. * um,
"speed_growth_cone": 0.03 * um / minute,
"soma_radius": soma_radius,
"use_uniform_branching": True,
'''
if __name__ == '__main__':
np.random.seed(1)
kernel = {
"seeds": np.random.randint(0, 100, num_omp),
"num_local_threads": num_omp,
"resolution": 5. * minute,
"environment_required": True
}
ds.set_kernel_status(kernel)
culture = ds.set_environment(cwd + "/test_15-75_small.dxf",
internal_shapes_as="areas",
default_properties={"substrate_affinity": 0.},
other_properties={"substrate_affinity": 100.})
# ~ ds.environment.plot_shape(culture, show=True)
gids = ds.create_neurons(
n=num_neurons,
culture=culture,
on_area=culture.non_default_areas.keys(),
neurites_on_area=True,
params=neuron_params,
neurite_params=neurite_params,
neurite_names=["axon", "dendrite_1", "dendrite_2"],
num_neurites=3)
ds.plot.plot_neurons(show=False)
# ~ xlim = -10200., -9500.
