senec-initiative / dense Goto Github PK

# -*- coding: utf-8 -*-
import os
import shutil
import time

import numpy as np
import matplotlib.pyplot as plt

import nngt

import dense as ds
from dense.units import *

def CleanFolder(tmp_dir, make=True):
    if os.path.isdir(tmp_dir):
        shutil.rmtree(tmp_dir)
    if make:
        os.mkdir(tmp_dir)
    return tmp_dir


current_dir = os.path.abspath(os.path.dirname(__file__))
main_dir = current_dir[:current_dir.rfind("/")]

'''
Main parameters
'''
soma_radius = 8.
num_neurons = 10

#~ gc_model = 'persistent_random_walk'
gc_model = 'run-and-tumble'
use_uniform_branching = False
use_vp = True
use_run_tumble = False

neuron_params = {
    "axon_diameter": 4. * um,
    "dendrite_diameter": 2.*um,
    "soma_radius": soma_radius * um,
}

axon_params = {
    "growth_cone_model": gc_model,
    "use_uniform_branching": use_uniform_branching,
    "use_van_pelt": use_vp ,
    "sensing_angle": 45.*deg,
    "speed_growth_cone": 0.025 * um / minute, #0.15
    "filopodia_wall_affinity": 100.,
    "filopodia_finger_length": 7. * um,
    "filopodia_min_number": 30,
    "persistence_length": 300. * um,
    "taper_rate": 1./4000., 
    'B': 3. * cpm,
    'T': 1000. * minute,
    'E': 1.,
}

dendrite_params = {
    "use_van_pelt": use_vp,
    "growth_cone_model": gc_model,
    "speed_growth_cone": 0.01 * um / minute,
    "filopodia_wall_affinity": 10. ,
    "persistence_length" : 200. * um,
    "taper_rate": 3./250.,
    "B": 6. * cpm,
    "T": 1000. * minute,
    'E': 1.,
}

neurite_params = {"axon": axon_params, "dendrite": dendrite_params}

'''
Simulation
'''

def step(n, loop_n, plot=True):
    ds.simulate(n)
    if plot:
        ds.plot.plot_neurons(show_nodes=True, show=True)

if __name__ == '__main__':
    num_omp = 10
    kernel = {
        "seeds": range(10, 10+num_omp),
        "num_local_threads": num_omp,
        "resolution": 10. * minute,
        "adaptive_timestep": -1.,
        "environment_required": True,
        "interactions": True
    }

    ds.set_kernel_status(kernel, simulation_id="ID")
    gids, culture = None, None

    culture_file = current_dir + "/box.svg"

    min_x = 0  # Choice of the coordinates associated to
    max_x = 1800  # the x axis of the imported environment image
    #  the y coodirnated will be automatically determined
    # by scaling from the image
    # using Inkscape for the bix.svg the y coordinated will be
    min_y = -707
    max_y = +707

    y_margin = (max_y-min_y)/num_neurons  # choice of margin not to seed neurons closer to the border

    if kernel["environment_required"]:
        culture = ds.set_environment(culture_file, min_x=0, max_x=1800)

    # neuron_params['position'] = [(900., 0.),(900., 100.)] *um
    positions = []
    for y in np.linspace(min_y+y_margin,
                         max_y-y_margin, num_neurons):
        positions.append((900, y))
    neuron_params['position'] = positions *um
    print("Creating neurons")
    # gids = ds.create_neurons(n=num_neurons,
    #                          params=neuron_params,
    #                          num_neurites=0)

    gids = ds.create_neurons(n=num_neurons,
                             params=neuron_params,
                             num_neurites=2,
                             random_rotation_angles=False,
                             neurite_angles={"axon": 0.*deg,
                                             "dendrite_1": 180.*deg})

_pygrowth.pyx in dense._pygrowth._get_recorder_data()

OverflowError: cannot convert float infinity to integer

In [3]: neuron = ds.create_neurons(params={"position": (0., 0.)*um}, num_neurites=0)                                                                                        
In [4]: neuron.create_neurites(num_neurites=1,neurite_types="axon")                 
In [5]: neuron.create_neurites(num_neurites=1,neurite_types="dendrite")                                                                                                                                 
In [6]: neuron.neurites                                                                                                                                                                                                                   
In [7]: dd=neuron.dendrites                                                                                                                                                                                                               
In [8]: dd                                                                                                                                                                                                                                  
Out[8]: { 'dendrite_1': Neurite<dendrite_1 of neuron 0> }

In [9]: d1=dd["dendrite_1"]                                                                                                                                                                                                                
zero-dimensional arrays cannot be concatenated
dendrite.xy: dendrite_1 missing

In [10]: d1.get_properties()                                                                                                                                                                                                                
Out[10]:
{
  'critical_pull'                          : 4.0,
  'affinity_dendrite_soma_other_neuron'    : 0.0,
  'affinity_dendrite_soma_same_neuron'     : nan,
  'affinity_dendrite_axon_same_neuron'     : nan,
  'affinity_dendrite_dendrite_same_neuron' : nan,
  'duration_of_retraction'                 : 4.0 minute,
  'proba_down_move'                        : 0.008,
  'sensing_angle'                          : 69.99825383113267 degree,
  'taper_rate'                             : 0.002,
  'retraction_probability'                 : 0.001,
  'filopodia_min_number'                   : 24,
  'observables'                            : [
                                               'angle',
                                               'length',
                                               'num_growth_cones',
                                               'num_tumbles',
                                               'retraction_time',
                                               'speed',
                                               'status',
                                               'stepping_probability'
                                             ],
  'neurite_type'                           : 'dendrite',
  'filopodia_wall_affinity'                : 2.0,
  'diameter_fraction_lb'                   : 0.8,
  'persistence_length'                     : 500.0 micrometer,
  'diameter_ratio_avg'                     : 1.0,
  'use_van_pelt'                           : False,
  'gc_split_angle_mean'                    : 97.95031817647606 degree,
  'max_sensing_angle'                      : 89.95437383553924 degree,
  'max_gc_number'                          : 500,
  'diameter_ratio_std'                     : 0.02,
  'gc_split_angle_std'                     : 9.994930426171027 degree,
  'affinity_dendrite_axon_other_neuron'    : 5.0,
  'lateral_branching_angle_std'            : 0.9994930426171028 degree,
  'affinity_dendrite_self'                 : nan,
  'lateral_branching_angle_mean'           : 59.969582557026165 degree,
  'max_arbor_length'                       : 5000.0 micrometer,
  'active'                                 : True,
  'diameter_eta_exp'                       : 2.67,
  'speed_decay_factor'                     : 0.0,
  'min_branching_distance'                 : 20.0 micrometer,
  'use_uniform_branching'                  : False,
  'use_flpl_branching'                     : False,
  'speed_growth_cone'                      : 0.05 micrometer / minute,
  'use_uniform_split'                      : False,
  'scale_up_move'                          : 20.0 micrometer,
  'growth_cone_model'                      : 'constant_pull-only_run-and-tumble',
  'affinity_dendrite_dendrite_other_neuron': 2.0,
  'filopodia_finger_length'                : 12.0 micrometer
}

ValueError                                Traceback (most recent call last)
~/Documents/WORK/DENSE/examples/space_embedding/ordered_neurons/neurons_ordred_in_a_box.py in <module>
    151     #                          num_neurites=0)
    152 
--> 153     gids = ds.create_neurons(n=num_neurons,
    154                              params=neuron_params,
    155                              neurite_params=neurite_params,

_pygrowth.pyx in dense._pygrowth.create_neurons()
_pygrowth.pyx in dense._pygrowth._create_neurons()
ValueError: InvalidParameter @init_status in /home/ele/Documents/WORK/DENSE/src/elements/Neuron.cpp:200
`neurite_angles` contain invalid neurite names.

# -*- coding: utf-8 -*-
#
# polygons.py
#
# This file is part of DeNSE.
#
# Copyright (C) 2019 SeNEC Initiative
#
# DeNSE is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# DeNSE is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with DeNSE. If not, see <http://www.gnu.org/licenses/>.


import os
import shutil
import time

import numpy as np
import matplotlib.pyplot as plt

import nngt

import dense as ds
from dense.units import *


def CleanFolder(tmp_dir, make=True):
    if os.path.isdir(tmp_dir):
        shutil.rmtree(tmp_dir)
    if make:
        os.mkdir(tmp_dir)
    return tmp_dir


current_dir = os.path.abspath(os.path.dirname(__file__))
main_dir = current_dir[:current_dir.rfind("/")]

'''
Main parameters
'''
soma_radius = 8.
num_neurons = 10

#~ gc_model = 'persistent_random_walk'
gc_model = 'run-and-tumble'
use_uniform_branching = False
use_vp = True
use_run_tumble = False

neuron_params = {
    "axon_diameter": 4. * um,
    "dendrite_diameter": 2.*um,
    "soma_radius": soma_radius * um,
    "random_rotation_angles": False,
    "neurite_names": ["axon", "dendrite_1"],  # this I just added to see if explicit naming would help
    "neurite_angles": {"axon": 0.*deg, "dendrite_1": 180.*deg},
}

axon_params = {
    "growth_cone_model": gc_model,
    "use_uniform_branching": use_uniform_branching,
    "use_van_pelt": use_vp ,
    "sensing_angle": 45.*deg,
    "speed_growth_cone": 0.025 * um / minute, #0.15
    "filopodia_wall_affinity": 100.,
    "filopodia_finger_length": 7. * um,
    "filopodia_min_number": 30,
    "persistence_length": 300. * um,
    "taper_rate": 1./4000.,
    'B': 3. * cpm,
    'T': 1000. * minute,
    'E': 1.,
}

dendrite_params = {
    "use_van_pelt": use_vp,
    "growth_cone_model": gc_model,
    "speed_growth_cone": 0.01 * um / minute,
    "filopodia_wall_affinity": 10.,
    "persistence_length": 200. * um,
    "taper_rate": 3./250.,
    "B": 6. * cpm,
    "T": 1000. * minute,
    'E': 1.,
}

neurite_params = {"axon": axon_params, "dendrite": dendrite_params}

'''
Simulation
'''

def step(n, loop_n, plot=True):
    ds.simulate(n)
    if plot:
        ds.plot.plot_neurons(show_nodes=True, show=True)

if __name__ == '__main__':
    num_omp = 10
    kernel = {
        # For random simulations each time
        # "seeds": np.random.randint(0, 100, num_omp),
        "seeds": range(10, 10+num_omp),
        "num_local_threads": num_omp,
        "resolution": 10. * minute,
        "adaptive_timestep": -1.,
        "environment_required": True,
        "interactions": True
    }

    ds.set_kernel_status(kernel, simulation_id="ID")
    gids, culture = None, None

    culture_file = current_dir + "/box.svg"

    min_x = 0  # Choice of the coordinates associated to
    max_x = 1800  # the x axis of the imported environment image
    #  the y coodirnated will be automatically determined
    # by scaling from the image
    # using Inkscape for the bix.svg the y coordinated will be
    min_y = -707
    max_y = +707

    y_margin = (max_y-min_y)/num_neurons  # choice of margin not to seed neurons closer to the border

    if kernel["environment_required"]:
        culture = ds.set_environment(culture_file, min_x=0, max_x=1800)

    # neuron_params['position'] = [(900., 0.),(900., 100.)] *um 
    positions = []
    for y in np.linspace(min_y+y_margin,
                         max_y-y_margin, num_neurons):
        positions.append((900, y))
    neuron_params['position'] = positions *um
    print("Creating neurons")

    gids = ds.create_neurons(n=num_neurons,
                             params=neuron_params,
                             neurite_params=neurite_params,
                             num_neurites=2)

    start = time.time()
    for i in range(3):
        step(2 * day, 0, True)

    duration = time.time() - start

    plt.show(block=True)
    print("SIMULATION ENDED")

# Two successive simulation runs : ok
ds.simulate(1*day)
ds.simulate(1*day)
# Now update of parameters (error persist even if neurite_parameters unchanged)
  dense.set_object_properties(gids, neurite_params=neurite_params)
# Addition simulation run
ds.simulate(1*day)   # leads to segmentation fault

    for i in range(3):
        ds.simulate(1*day)

import os
import shutil
import time
import numpy as np
import matplotlib.pyplot as plt
import nngt
import dense as ds
from dense.units import *

current_dir = os.path.abspath(os.path.dirname(__file__))
main_dir = current_dir[:current_dir.rfind("/")]

def CleanFolder(tmp_dir, make=True):
    if os.path.isdir(tmp_dir):
        shutil.rmtree(tmp_dir)
    if make:
        os.mkdir(tmp_dir)
    return tmp_dir

def step(n, loop_n, plot=True):
    print("simulating", n)
    ds.simulate(n)
    print("done")
    if plot:
        _, ax = plt.subplots()
        ds.plot.plot_neurons(mode='mixed', subsample=1, axis=ax,
                             show_nodes=True, show_neuron_id=True, show=True)

'''
Main parameters
'''
np.random.seed(0)

soma_radius = 5.
num_neurons = 10

gc_model = 'cst_po_nwa'
use_vp = True

neuron_params = {
    "soma_radius": soma_radius * um,
}

dendrite_params = {
    "use_van_pelt": True,
    "growth_cone_model": gc_model,
    "speed_growth_cone": 0.06 * um / minute,
    "filopodia_wall_affinity": 0.01,
    "persistence_length": 200. * um,
    "B": 6. * cph,
    "T": 1000. * minute,
    "E": 1.,
}

axon_params = {
    "growth_cone_model": gc_model,
    "use_uniform_branching": False,
    "sensing_angle": 70.*deg,
    "speed_growth_cone": 0.1 * um / minute,
    "filopodia_wall_affinity": 10.,
    "filopodia_finger_length": 10. * um,
    "filopodia_min_number": 30,
    "affinity_axon_axon_other_neuron": 100.,

    "persistence_length": 500.*um,
    "taper_rate": 1./400.,
    "diameter_ratio_avg": 0.5,
    # branching
    "use_van_pelt": True,
    "use_uniform_branching": False,
    "filopodia_wall_affinity": 10.
}

neurite_params = {
    "axon": axon_params,
    "dendrites": dendrite_params
}

'''
Simulation
'''

if __name__ == '__main__':
    num_omp = 10
    kernel = {
              "seeds": range(num_omp),
              "num_local_threads": num_omp,
              "environment_required": True,
              "resolution": 5. * minute,
              "interactions": True}

    np.random.seed(118239)  # seeds for the neuron positions

    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,
                             neurite_params=neurite_params,
                             num_neurites=3)

    rec = ds.create_recorders(gids, "num_growth_cones")
    start = time.time()
    for i in range(3):
        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,})
    # NB dictionary neurite_params is updated
    print("update parameters")
    ds.set_object_properties(gids, neurite_params=neurite_params)
    print("parameters updated")
    print("extension run")
    step(1 * day, 0, True)
    print("extension run done")
    duration = time.time() - start
    print(ds.get_kernel_status("time"))
    plt.show(block=True)
    print("SIMULATION ENDED")

import dense as ds

pop = ds.create_neurons(10, num_neurites=1)
pop.get_properties()

# Here neurons created
gids = ds.create_neurons(n=num_neurons, params=neuron_params,  num_neurites=0)

# Now for each neuron, creation of neurites
for neuron in gids:
    neuron.create_neurites(num_neurites=2, params=neurite_params)

neuron_params = {
    "axon_diameter": 4. * um,
    "dendrite_diameter": 2.*um,
    "soma_radius": soma_radius * um,
}

axon_params = {
    "growth_cone_model": gc_model,
    "use_uniform_branching": use_uniform_branching,
    "use_van_pelt": use_vp ,
    "sensing_angle": 45.*deg,
    "speed_growth_cone": 0.025 * um / minute, #0.15
    "filopodia_wall_affinity": 100.,
    "filopodia_finger_length": 7. * um,
    "filopodia_min_number": 30,
    "persistence_length": 300. * um,
    "taper_rate": 1./4000., 
    'B': 3. * cpm,
    'T': 1000. * minute,
    'E': 1.,   
}

dendrite_params = {
    "use_van_pelt": use_vp,
    "growth_cone_model": gc_model,
    "speed_growth_cone": 0.01 * um / minute,
    "filopodia_wall_affinity": 10. ,
    "persistence_length" : 200. * um,
    "taper_rate": 3./250.,
    "B": 6. * cpm,
    "T": 1000. * minute,
    'E': 1.,
}

neurite_params = {"axon": axon_params, "dendrite": dendrite_params}