Example #1
0
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
Example #2
0
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
Example #3
0
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
Example #4
0
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
Example #5
0
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
Example #6
0
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()
Example #7
0
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
Example #8
0
                             dendrites_params=dendrite_params,
                             axon_params=axon_params)
    fig, ax = plt.subplots()
    # ds.plot.plot_neurons(gid=range(100), culture=culture, soma_alpha=0.8,
                       # axon_color='g', gc_color="r", axis=ax, show=False)
    # ds.plot.plot_neurons(gid=range(100, 200), show_culture=False, axis=ax,
                       # soma_alpha=0.8, axon_color='darkorange', gc_color="r",
                       # show=True)
    # step(4000, 0, False)
    # ~ for loop_n in range(5):
    # ~ step(500, loop_n, True)
    duration = time.time() - start

    # prepare the plot
    ds.plot.plot_neurons(gid=range(200), culture=culture, soma_alpha=0.8,
                       axon_color='g', gc_color="r", axis=ax, show=False)
    ds.plot.plot_neurons(gid=range(200, 400), show_culture=False, axis=ax, ymax=500,
                       soma_alpha=0.8, axon_color='darkorange', gc_color="r",
                       show=True)
    ds.plot.plot_neurons(gid=range(200, 400), show_culture=False, axis=ax,
                       soma_alpha=0.8, axon_color='yellow', gc_color="r",
                       show=True)
    plt.show(block=True)
    print("SIMULATION ENDED")

    # save
    graph =ds.generate_network()
    save_path = CleanFolder(os.path.join(os.getcwd(),"diode_double_swc"))
    ds.save_json_info(filepath=save_path)
    ds.SaveSwc(filepath=save_path,swc_resolution = 10)
Example #9
0
def run_dense(neuron_params):
    """
    """
    resolution = 1.
    np.random.seed(kernel['seeds'])
    kernel["resolution"] = resolution
    kernel["angles_in_radians"] = True
    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))
    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, True)
    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": 5000.
    }

    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, True)
    elongation = {
        "use_van_pelt": False,
        "persistence_length": 30.,
        "res_retraction_factor": 0.01,
        "res_elongation_factor": 0.1,
        # "res_leakage": 0.05,
        "res_retraction_threshold": 0.1,
        "res_elongation_threshold": 0.2,
        "res_leakage": 30.0,
        "res_neurite_generated": 4500.,
        "res_correlation": 0.05,
        "res_variance": 0.002,
        "res_use_ratio": 0.1,
    }
    elongation_axon = {"res_elongation_factor": 0.5}

    dendrite_params.update(elongation)
    axon_params.update(elongation_axon)

    print("elongation")

    ds.set_object_properties(gid,
                             params=neuron_params,
                             dendrites_params=dendrite_params,
                             axon_params=axon_params)
    step(2002. / resolution, 1, False, True)

    # stop the dendrites
    stortignation = {
        "use_van_pelt": False,
        "persistence_length": 10.,
        "res_retraction_factor": 0.0,
        "res_elongation_factor": 0.0,
        "res_retraction_threshold": 0.000,
        "res_elongation_threshold": 10.,
    }

    stortignation_axon = {
        "use_van_pelt": False,
        "sensing_angle": 0.20,
        "persistence_length": 91.,
        "flpl_branching_rate": 0.002,
        "use_flpl_branching": True,
        "res_retraction_factor": 0.02,
        "res_elongation_factor": 0.2910,
        # "res_leakage": 0.05,
        "res_retraction_threshold": 0.0001,
        "res_elongation_threshold": 0.10,
        "res_leakage": 10.0,
        "res_neurite_generated": 45000.,
        "res_correlation": 0.05,
        "res_weight_diameter": 0.,
        "res_variance": 0.001,
        "res_use_ratio": 0.1,
    }

    print("stortignation")

    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)

    ds.SaveSwc(swc_resolution=5)
    ds.save_json_info()

    swc_file = ds.get_simulation_id()
    # print(swc_file)

    # ds.reset_kernel()
    return swc_file
Example #10
0
def run_dense(neuron_params):
    """
    """
    resolution = 1.
    np.random.seed(kernel['seeds'])
    kernel["resolution"] = resolution
    kernel["angles_in_radians"] = True
    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))
    gid = ds.create_neurons(n=num_neurons,
                            params=neuron_params,
                            axon_params=axon_params,
                            dendrites_params=dendrite_params,
                            num_neurites=4,
                            position=[])

    step(2000. / resolution, 1, False, True)

    splitting_dendrites = {
        'use_van_pelt': True,
        "persistence_length": 60.0,
        "gc_split_angle_mean": 1.,
        'use_flpl_branching': True,
        "flpl_branching_rate": 0.0036,
        "B": 30.,
        "E": 0.9,
        "S": 1.0,
        "T": 10000.,
    }
    dendrite_params.update(splitting_dendrites)
    ds.set_object_properties(gid,
                             params=neuron_params,
                             dendrites_params=dendrite_params)
    step(2000. / resolution, 1, False, True)
    arborization = {
        'use_van_pelt': False,
        'use_flpl_branching': False,
        "persistence_length": 30.0,
        "res_weight_diameter": 0.1,
        "res_retraction_threshold": 0.01,
        "res_elongation_threshold": 0.12,
        "res_elongation_factor": 0.0612,
        "res_retraction_factor": 10.,
        # 'use_van_pelt' : True,
        "res_neurite_generated": 9500.,
        "res_neurite_delivery_tau": 50.,
        "res_correlation": 0.15,
        "res_variance": 0.02,
        "res_use_ratio": 0.3,
    }
    dendrite_params.update(arborization)
    ds.set_object_properties(gid,
                             params=neuron_params,
                             dendrites_params=dendrite_params,
                             axon_params=axon_params)
    step(2000. / resolution, 1, False, True)

    arborization = {
        'use_van_pelt': True,
        # 'use_flpl_branching' : True,
        "flpl_branching_rate": 0.00036,
        "persistence_length": 5.0,
        "res_retraction_threshold": 0.1,
        "res_weight_diameter": 0.001,
        "res_elongation_threshold": 0.14,
        "res_elongation_factor": 0.12,
        # 'use_van_pelt' : True,
        "res_neurite_generated": 9500.,
        "res_neurite_delivery_tau": 50.,
        "res_correlation": 0.5,
        "res_variance": 0.2,
        "res_use_ratio": 0.4,
    }
    dendrite_params.update(arborization)
    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)
    # 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, 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=15)
    ds.save_json_info()

    swc_file = ds.get_simulation_id()
    # print(swc_file)

    # ds.reset_kernel()
    return swc_file
Example #11
0
def run_dense(neuron_params):
    """
    """
    resolution = 30. * minute
    np.random.seed(kernel['seeds'])  #Seeds the random number generator
    kernel["resolution"] = resolution
    #    kernel["angles_in_radians"] = True
    ds.set_kernel_status(kernel, simulation_id="multipolar")

    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,
                            dendrites_params=dendrite_params,
                            num_neurites=4)

    # ds.set_object_properties(gid, params=neuron_params,
    # axon_params=neuron_params)
    step(3 * day, 1, False, True)

    axon_params['use_van_pelt'] = True
    axon_params["B"] = 90. * cpm
    axon_params["E"] = 0.2
    axon_params["S"] = 1.
    axon_params["T"] = 10000. * minute

    dendrite_params['use_van_pelt'] = True
    dendrite_params["B"] = 90. * cpm
    dendrite_params["E"] = 0.2
    dendrite_params["S"] = 1.
    dendrite_params["T"] = 10000. * minute

    axon_params['use_flpl_branching'] = False
    axon_params['flpl_branching_rate'] = 0.001 * cpm

    ds.set_object_properties(gid,
                             params=neuron_params,
                             dendrites_params=dendrite_params,
                             axon_params=axon_params)

    step(6 * day, 1, False, True)

    axon_migated = {
        'use_van_pelt': True,
        # "flpl_branching_rate" : 0.004,
        "res_retraction_threshold": 0.4 * uM,
        "res_elongation_threshold": 0.15 * uM,
        "res_elongation_factor": 0.6 * 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 * cpm,
    }
    axon_params.update(axon_migated)
    ds.set_object_properties(gid,
                             params=neuron_params,
                             dendrites_params=dendrite_params,
                             axon_params=axon_params)
    step(3 * day, 1, False, 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, 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.io.save_to_swc(resolution=25)
    ds.save_json_info()

    swc_file = ds.get_simulation_id()
    # print(swc_file)

    # ds.reset_kernel()
    return swc_file