Пример #1
0
def build_hippocampus():

    net = NetworkBuilder('CA3')
    net.add_nodes(N=1,
                  pop_name='CA3e',
                  model_type='biophysical',
                  model_template='hoc:Spikingcell',
                  morphology='blank.swc')

    inputnet = NetworkBuilder('input')
    inputnet.add_nodes(N=1, model_type='virtual', pat='pat1', pop_name='virt')
    conn = inputnet.add_edges(
        target=net.nodes(pop_name='CA3e'),
        source={'pat': 'pat1'},
        connection_rule=1,
        dynamics_params='stsp.json',
        model_template='Exp2Syn1_STSP',
        delay=0,
        syn_weight=.5,
        target_sections=['soma'],  # target soma
        distance_range=[0.0, 300])
    conn.add_properties(['sec_id', 'sec_x'],
                        rule=(0, 0.9),
                        dtypes=[np.int32, np.float])

    net.build()
    net.save_nodes(output_dir='network')
    net.save_edges(output_dir='network')

    inputnet.build()
    inputnet.save(output_dir='network')
Пример #2
0
def build_input_network(net, output_dir='network/source_input'):
    def select_source_cells(sources, target, N_syn=10):
        """ Note here that "sources" are given (not "source"). So the iterations occur through every target 
         with all sources as potential inputs. Faster than before and better if will have common rules.
        """

        target_id = target.node_id
        source_ids = [s.node_id for s in sources]

        nsyns_ret = [N_syn] * len(source_ids)
        return nsyns_ret

    filter_models = {
        'inputFilter': {
            'N': 25,
            'ei': 'e',
            'pop_name': 'input_filter',
            'model_type': 'virtual'
        }
    }

    inputNetwork = NetworkBuilder("inputNetwork")
    inputNetwork.add_nodes(**filter_models['inputFilter'])

    inputNetwork.add_edges(target=net.nodes(pop_name='Scnn1a'),
                           iterator='all_to_one',
                           connection_rule=select_source_cells,
                           syn_weight=0.0007,
                           distance_range=[0.0, 150.0],
                           target_sections=['basal', 'apical'],
                           delay=2.0,
                           dynamics_params='AMPA_ExcToExc.json',
                           model_template='exp2syn')

    inputNetwork.add_edges(target=net.nodes(pop_name='LIF_exc'),
                           iterator='all_to_one',
                           connection_rule=select_source_cells,
                           syn_weight=0.07,
                           delay=2.0,
                           dynamics_params='instanteneousExc.json')

    inputNetwork.add_edges(target=net.nodes(pop_name='PV1'),
                           iterator='all_to_one',
                           connection_rule=select_source_cells,
                           syn_weight=0.002,
                           distance_range=[0.0, 1.0e+20],
                           target_sections=['basal', 'somatic'],
                           delay=2.0,
                           dynamics_params='AMPA_ExcToInh.json',
                           model_template='exp2syn')

    inputNetwork.add_edges(target=net.nodes(pop_name='LIF_inh'),
                           iterator='all_to_one',
                           connection_rule=select_source_cells,
                           syn_weight=0.01,
                           delay=2.0,
                           dynamics_params='instanteneousExc.json')

    inputNetwork.build()
    inputNetwork.save(output_dir=output_dir)
Пример #3
0
def build_net():
    net = NetworkBuilder("slice")
    net.add_nodes(
        N=5,
        pop_name='Scnn1a',
        synapse_model='a',
        firing_rate=firing_rate,
        model_type='biophysical',
        model_template='ctdb:Biophys1.hoc',
        dynamics_params='472363762_fit.json',
        morphology='Scnn1a-Tg3-Cre_Ai14_IVSCC_-177300.01.02.01_473845048_m.swc',
        rotation_angle_zaxis=-3.646878266,
        model_processing='aibs_perisomatic,extracellular')

    net.add_nodes(
        N=5,
        pop_name='Scnn1a',
        synapse_model='b',
        firing_rate=firing_rate,
        model_type='biophysical',
        model_template='ctdb:Biophys1.hoc',
        model_processing='aibs_perisomatic,extracellular',
        dynamics_params='472363762_fit.json',
        morphology='Scnn1a-Tg3-Cre_Ai14_IVSCC_-177300.01.02.01_473845048_m.swc',
        rotation_angle_zaxis=-3.646878266)

    net.build()
    net.save_nodes(nodes_file_name='network/slice_nodes.h5',
                   node_types_file_name='network/slice_node_types.csv')

    return net
Пример #4
0
def build_sim():
    from bmtk.builder.networks import NetworkBuilder

    # My all active-model (does not work):
    #Model ID 496497595
    #Cell ID 487667205

    # Other perisomatic model (available on Allen Brain Institute - CellTypes):
    #Model ID 491623973
    #Cell  ID 490387590

    print('BMTK import success')
    net = NetworkBuilder('mcortex')
    print('Network builder initiated')
    # Testing other models: # Surprise, surprise, this does not work...
    net.add_nodes(cell_name='Pvalb_490387590_m',
                  model_type='biophysical',
                  model_template='ctdb:Biophys1.hoc',
                  model_processing='aibs_perisomatic',
                  dynamics_params='491623973_fit.json',
                  morphology='Pvalb_490387590_m.swc')
    ''' # Standard
    net.add_nodes(cell_name='Scnn1a_473845048',
                  potental='exc',
                  model_type='biophysical',
                  model_template='ctdb:Biophys1.hoc',
                  model_processing='aibs_perisomatic',
                  dynamics_params='472363762_fit.json',
                  morphology='Scnn1a_473845048_m.swc')
    '''
    print('Node added')

    net.build()
    net.save_nodes(output_dir='network')
    for node in net.nodes():
        print(node)
    print('Node printed')

    from bmtk.utils.sim_setup import build_env_bionet
    print('Setting environment')

    build_env_bionet(
        base_dir='sim_ch01',  # Where to save the scripts and config files
        network_dir='network',  # Location of directory containing network files
        tstop=1200.0,
        dt=0.1,  # Run a simulation for 2000 ms at 0.1 ms intervals
        report_vars=[
            'v'
        ],  # Tells simulator we want to record membrane potential and calcium traces
        current_clamp={  # Creates a step current from 500.ms to 1500.0 ms
            'amp': 0.61,  # 0.12#0.610
            'delay': 100.0,  # 100, #500
            'duration': 1000.0
        },
        include_examples=True,  # Copies components files
        compile_mechanisms=True  # Will try to compile NEURON mechanisms
    )
    print('Build done')
Пример #5
0
def build_tw():
    if not os.path.exists('output'):
        os.makedirs('output')

    TW = NetworkBuilder("TW")
    TW.add_nodes(N=3000, pop_name='TW', ei='e', location='TW', level_of_detail='filter')

    # Save cells.csv and cell_types.csv
    TW.save_nodes(nodes_file_name='output/tw_nodes.h5', node_types_file_name='output/tw_node_types.csv')

    VL4 = NetworkBuilder('V1/L4')
    VL4.import_nodes(nodes_file_name='output/v1_nodes.h5', node_types_file_name='output/v1_node_types.csv')
    VL4.add_edges(source=TW.nodes(), target={'pop_name': 'Rorb'},
                  connection_rule=lambda trg, src: 5,
                  **({'weight_max': 0.00015, 'weight_function': 'wmax', 'distance_range': [30.0, 150.0],
                      'target_sections': ['basal', 'apical'], 'delay': 2.0, 'params_file': 'AMPA_ExcToExc.json',
                      'set_params_function': 'exp2syn'}))

    VL4.add_edges(source=TW.nodes(), target={'pop_name': 'Scnn1a'},
                  connection_rule=lambda trg, src: 5,
                  **({'weight_max': 0.00019, 'weight_function': 'wmax', 'distance_range': [30.0, 150.0],
                      'target_sections': ['basal', 'apical'], 'delay': 2.0, 'params_file': 'AMPA_ExcToExc.json',
                      'set_params_function': 'exp2syn'}))

    VL4.add_edges(source=TW.nodes(), target={'pop_name': 'Nr5a1'},
                  connection_rule=lambda trg, src: 5,
                  **({'weight_max': 0.00019, 'weight_function': 'wmax', 'distance_range': [30.0, 150.0],
                      'target_sections': ['basal', 'apical'], 'delay': 2.0, 'params_file': 'AMPA_ExcToExc.json',
                      'set_params_function': 'exp2syn'}))

    VL4.add_edges(source=TW.nodes(), target={'pop_name': 'PV1'},
                  connection_rule=lambda trg, src: 5,
                  **({'weight_max': 0.0022, 'weight_function': 'wmax', 'distance_range': [0.0, 1.0e+20],
                      'target_sections': ['somatic', 'basal'], 'delay': 2.0, 'params_file': 'AMPA_ExcToInh.json',
                      'set_params_function': 'exp2syn'}))

    VL4.add_edges(source=TW.nodes(), target={'pop_name': 'PV2'},
                  connection_rule=lambda trg, src: 5,
                  **({'weight_max': 0.0013, 'weight_function': 'wmax', 'distance_range': [0.0, 1.0e+20],
                      'target_sections': ['somatic', 'basal'], 'delay': 2.0, 'params_file': 'AMPA_ExcToInh.json',
                      'set_params_function': 'exp2syn'}))

    VL4.add_edges(source=TW.nodes(), target={'pop_name': 'LIF_exc'},
                  connection_rule=lambda trg, src: 5,
                  **({'weight_max': 0.015, 'weight_function': 'wmax', 'delay': 2.0,
                      'params_file': 'instanteneousExc.json', 'set_params_function': 'exp2syn'}))

    VL4.add_edges(source=TW.nodes(), target={'pop_name': 'LIF_inh'},
                  connection_rule=lambda trg, src: 5,
                  **({'weight_max': 0.05, 'weight_function': 'wmax', 'delay': 2.0,
                      'params_file': 'instanteneousExc.json', 'set_params_function': 'exp2syn'}))

    VL4.build()
    VL4.save_edges(edges_file_name='output/tw_v1_edges.h5', edge_types_file_name='output/tw_v1_edge_types.csv')
Пример #6
0
def build_l4():
    net = NetworkBuilder("V1/L4")
    net.add_nodes(N=1, pop_name='DG_GC', node_type_id=478230220,
                  positions=[(28.753, -364.868, -161.705)],
                  #tuning_angle=[0.0, 25.0],
                  rotation_angle_yaxis=[3.55501],
                  #location='VisL4',
                  ei='e',
                  level_of_detail='biophysical',
                  params_file='478230220.json',
                  morphology_file='478230220.swc',
                  rotation_angle_zaxis=-3.646878266,
                  set_params_function='Biophys1')

    net.build()
    net.save_nodes(nodes_file_name='output/v1_nodes.h5', node_types_file_name='output/v1_node_types.csv')
  #  net.save_edges(edges_file_name='output/v1_v1_edges.h5', edge_types_file_name='output/v1_v1_edge_types.csv')

    return net
Пример #7
0
              connection_params={
                  'nedges': 140,
                  'nsyns_min': 2,
                  'nsyns_max': 5,
                  'divergence': 100
              },
              iterator='one_to_all',
              syn_weight=0.0016,
              weight_function='wmax',
              distance_range=[0.0, 50.0],
              target_sections=['somatic'],
              delay=0.85,
              model_template='exp2syn',
              dynamics_params='GABA_InhToExc_BC_GC.json')

net.build()
net.save(output_dir='network')

# BASELINE EXTERNAL DRIVE TO THE GC population
GC_external_input = NetworkBuilder("GC_external_input")
GC_external_input.add_nodes(N=9000,
                            pop_name='perforant_path',
                            ei='e',
                            positions=generate_positions(9000),
                            model_type='virtual')
# drive to the GC population
GC_external_input.add_edges(
    source=GC_external_input.nodes(),
    target=net.nodes(ei='e'),
    connection_rule=select_random_srcs,
    connection_params={
Пример #8
0
def build_l4():
    if not os.path.exists('output/network/VisL4'):
        os.makedirs('output/network/VisL4')

    net = NetworkBuilder("V1/L4")
    net.add_nodes(N=2,
                  pop_name='Scnn1a',
                  node_type_id='395830185',
                  position='points',
                  position_params={
                      'location': [(28.753, -364.868, -161.705),
                                   (48.753, -344.868, -141.705)]
                  },
                  array_params={"tuning_angle": [0.0, 25.0]},
                  location='VisL4',
                  ei='e',
                  gaba_synapse='y',
                  params_file='472363762_point.json',
                  model_type='iaf_psc_alpha')

    net.add_nodes(N=2,
                  pop_name='Rorb',
                  node_type_id='314804042',
                  position='points',
                  position_params={
                      'location': [(241.092, -349.263, 146.916),
                                   (201.092, -399.263, 126.916)]
                  },
                  array_params={"tuning_angle": [50.0, 75.0]},
                  location='VisL4',
                  ei='e',
                  gaba_synapse='y',
                  params_file='473863510_point.json',
                  model_type='iaf_psc_alpha')

    net.add_nodes(N=2,
                  pop_name='Nr5a1',
                  node_type_id='318808427',
                  position='points',
                  position_params={
                      'location': [(320.498, -351.259, 20.273),
                                   (310.498, -371.259, 10.273)]
                  },
                  array_params={"tuning_angle": [100.0, 125.0]},
                  location='VisL4',
                  ei='e',
                  gaba_synapse='y',
                  params_file='473863035_point.json',
                  model_type='iaf_psc_alpha')

    net.add_nodes(N=2,
                  pop_name='PV1',
                  node_type_id='330080937',
                  position='points',
                  position_params={
                      'location': [(122.373, -352.417, -216.748),
                                   (102.373, -342.417, -206.748)]
                  },
                  array_params={'tuning_angle': ['NA', 'NA']},
                  location='VisL4',
                  ei='i',
                  gaba_synapse='y',
                  params_file='472912177_fit.json',
                  model_type='iaf_psc_alpha')

    net.add_nodes(N=2,
                  pop_name='PV2',
                  node_type_id='318331342',
                  position='points',
                  position_params={
                      'location': [(350.321, -372.535, -18.282),
                                   (360.321, -371.535, -12.282)]
                  },
                  array_params={'tuning_angle': ['NA', 'NA']},
                  location='VisL4',
                  ei='i',
                  gaba_synapse='y',
                  params_file='473862421_point.json',
                  model_type='iaf_psc_alpha')

    net.add_nodes(N=2,
                  pop_name='LIF_exc',
                  node_type_id='100000101',
                  position='points',
                  position_params={
                      'location': [(-243.04, -342.352, -665.666),
                                   (-233.04, -332.352, -675.666)]
                  },
                  array_params={'tuning_angle': ['NA', 'NA']},
                  location='VisL4',
                  ei='e',
                  gaba_synapse='n',
                  params_file='IntFire1_exc_1.json',
                  model_type='iaf_psc_alpha')

    net.add_nodes(N=2,
                  pop_name='LIF_inh',
                  node_type_id='100000102',
                  position='points',
                  position_params={
                      'location': [(211.04, -321.333, -631.593),
                                   (218.04, -327.333, -635.593)]
                  },
                  array_params={'tuning_angle': [150.0, 175.0]},
                  location='VisL4',
                  ei='i',
                  gaba_synapse='n',
                  params_file='IntFire1_inh_1.json',
                  model_type='iaf_psc_alpha')

    print("Setting connections...")
    net.connect(source={'ei': 'i'},
                target={
                    'ei': 'i',
                    'gaba_synapse': 'y'
                },
                connector=lambda trg, src: 5,
                edge_params={
                    'weight_max': -1.8,
                    'weight_function': 'wmax',
                    'delay': 2.0,
                    'params_file': 'InhToInh.json',
                    'synapse_model': 'static_synapse'
                })

    net.connect(source={'ei': 'i'},
                target={
                    'ei': 'e',
                    'gaba_synapse': 'y'
                },
                connector=lambda trg, src: 5,
                edge_params={
                    'weight_max': -12.6,
                    'weight_function': 'wmax',
                    'delay': 2.0,
                    'params_file': 'InhToExc.json',
                    'synapse_model': 'static_synapse'
                })

    net.connect(source={'ei': 'i'},
                target={'pop_name': 'LIF_inh'},
                connector=lambda trg, src: 5,
                edge_params={
                    'weight_max': -1.125,
                    'weight_function': 'wmax',
                    'delay': 2.0,
                    'params_file': 'InhToInh.json',
                    'synapse_model': 'static_synapse'
                })

    net.connect(source={'ei': 'i'},
                target={'pop_name': 'LIF_exc'},
                connector=lambda trg, src: 5,
                edge_params={
                    'weight_max': -6.3,
                    'weight_function': 'wmax',
                    'delay': 2.0,
                    'params_file': 'ExcToInh.json',
                    'synapse_model': 'static_synapse'
                })

    net.connect(source={'ei': 'e'},
                target={'pop_name': 'PV1'},
                connector=lambda trg, src: 5,
                edge_params={
                    'weight_max': 7.7,
                    'weight_function': 'wmax',
                    'delay': 2.0,
                    'params_file': 'ExcToInh.json',
                    'synapse_model': 'static_synapse'
                })

    net.connect(source={'ei': 'e'},
                target={'pop_name': 'PV2'},
                connector=lambda trg, src: 5,
                edge_params={
                    'weight_max': 5.4,
                    'weight_function': 'wmax',
                    'delay': 2.0,
                    'params_file': 'ExcToInh.json',
                    'synapse_model': 'static_synapse'
                })

    net.connect(source={'ei': 'e'},
                target={'pop_name': 'LIF_inh'},
                connector=lambda trg, src: 5,
                edge_params={
                    'weight_max': 3.44,
                    'weight_function': 'wmax',
                    'delay': 2.0,
                    'params_file': 'ExcToInh.json',
                    'synapse_model': 'static_synapse'
                })

    print("Generating E-to-E connections.")
    net.connect(source={'ei': 'e'},
                target={'pop_name': 'Scnn1a'},
                connector=lambda trg, src: 5,
                edge_params={
                    'weight_max': 8.448,
                    'weight_function': 'gaussianLL',
                    'weight_sigma': 50.0,
                    'delay': 2.0,
                    'params_file': 'ExcToExc.json',
                    'synapse_model': 'static_synapse'
                })

    net.connect(source={'ei': 'e'},
                target={'pop_name': 'Rorb'},
                connector=lambda trg, src: 5,
                edge_params={
                    'weight_max': 4.292,
                    'weight_function': 'gaussianLL',
                    'weight_sigma': 50.0,
                    'delay': 2.0,
                    'params_file': 'ExcToExc.json',
                    'synapse_model': 'static_synapse'
                })

    net.connect(source={'ei': 'e'},
                target={'pop_name': 'Nr5a1'},
                connector=lambda trg, src: 5,
                edge_params={
                    'weight_max': 5.184,
                    'weight_function': 'gaussianLL',
                    'weight_sigma': 50.0,
                    'delay': 2.0,
                    'params_file': 'ExcToExc.json',
                    'synapse_model': 'static_synapse'
                })

    net.connect(source={'ei': 'e'},
                target={'pop_name': 'LIF_exc'},
                connector=lambda trg, src: 5,
                edge_params={
                    'weight_max': 1.995,
                    'weight_function': 'gaussianLL',
                    'weight_sigma': 50.0,
                    'delay': 2.0,
                    'params_file': 'ExcToExc.json',
                    'synapse_model': 'static_synapse'
                })

    net.build()
    net.save_cells(
        filename='output/network/VisL4/nodes.csv',
        columns=['node_id', 'node_type_id', 'position', 'tuning_angle'],
        position_labels=['x', 'y', 'z'])

    net.save_types(filename='output/network/VisL4/node_types.csv',
                   columns=[
                       'node_type_id', 'pop_name', 'ei', 'gaba_synapse',
                       'location', 'model_type', 'params_file'
                   ])

    net.save_edge_types('output/network/VisL4/edge_types.csv',
                        opt_columns=[
                            'weight_max', 'weight_function', 'weight_sigma',
                            'delay', 'params_file', 'synapse_model'
                        ])
    net.save_edges(filename='output/network/VisL4/edges.h5')
    return net
Пример #9
0
def build_cortical_network(output_dir='network/recurrent_network'):
    def distance_connection_handler(source, target, d_max, nsyn_min, nsyn_max):
        """ Connect cells that are less than d_max apart with a random number of synapses in the 
          interval [nsyn_min, nsyn_max)
        """
        sid = source['node_id']  # Get source id
        tid = target['node_id']  # Get target id

        # Avoid self-connections.
        if (sid == tid):
            return None

        # first calculate euclidean distance between cells
        src_positions = np.array([source['x'], source['y'], source['z']])
        trg_positions = np.array([target['x'], target['y'], target['z']])
        separation = np.sqrt(np.sum(src_positions - trg_positions)**2)

        # drop the connection if nodes too far apart
        if separation >= d_max:
            return None

        # Add the number of synapses for every connection.
        tmp_nsyn = random.randint(nsyn_min, nsyn_max)
        return tmp_nsyn

    #### Step 1: Figure out what types, and number of, different cells to use in our network ####
    # Number of cell models desired
    N_Scnn1a = 2
    N_PV1 = 2
    N_LIF_exc = 2
    N_LIF_inh = 2

    # Define all the cell models in a dictionary (note dictionaries within a dictionary)
    biophysical_models = {
        'Scnn1a': {
            'N': N_Scnn1a,
            'ei': 'e',
            'pop_name': 'Scnn1a',
            'model_type': 'biophysical',
            'model_template': 'ctdb:Biophys1.hoc',
            'model_processing': 'aibs_perisomatic',
            'morphology_file':
            'Scnn1a-Tg3-Cre_Ai14_IVSCC_-177300.01.02.01_473845048_m.swc',
            'dynamics_params': '472363762_fit.json',
            'rotation_angle_zaxis': -3.646878266
        },
        'PV1': {
            'N': N_PV1,
            'ei': 'i',
            'pop_name': 'PV1',
            'model_type': 'biophysical',
            'model_template': 'ctdb:Biophys1.hoc',
            'model_processing': 'aibs_perisomatic',
            'dynamics_params': '472912177_fit.json',
            'morphology_file':
            'Pvalb-IRES-Cre_Ai14_IVSCC_-176847.04.02.01_470522102_m.swc',
            'rotation_angle_zaxis': -2.539551891
        }
    }

    # Define all the cell models in a dictionary.
    LIF_models = {
        'LIF_exc': {
            'N': N_LIF_exc,
            'ei': 'e',
            'pop_name': 'LIF_exc',
            'model_type': 'point_process',
            'model_template': 'nrn:IntFire1',
            'dynamics_params': 'IntFire1_exc_1.json'
        },
        'LIF_inh': {
            'N': N_LIF_inh,
            'ei': 'i',
            'pop_name': 'LIF_inh',
            'model_type': 'point_process',
            'model_template': 'nrn:IntFire1',
            'dynamics_params': 'IntFire1_inh_1.json'
        }
    }

    #### Step 2: Create NetworkBuidler object to build nodes and edges ####
    net = NetworkBuilder('Cortical')

    #### Step 3: Used add_nodes() method to add all our cells/cell-types
    for model in biophysical_models:
        # Build our biophysical cells
        params = biophysical_models[model]
        n_cells = params.pop('N')

        # We'll randomly assign positions
        positions = generate_random_positions(n_cells)

        # Use add_nodes to create a set of N cells for each cell-type
        net.add_nodes(
            N=n_cells,  # Specify the numer of cells belonging to this set of nodes 
            x=positions[:, 0],
            y=positions[:, 1],
            z=positions[:, 2],
            rotation_angle_yaxis=np.random.uniform(0.0, 2 * np.pi, n_cells),

            # The other parameters are shared by all cells of this set in the dictionary
            **params)  # python shortcut for unrolling a dictionary

    for model in LIF_models:
        # Same thing as above but for our LIF type cells
        params = LIF_models[model].copy()

        # Number of cells for this model type
        n_cells = params.pop('N')

        # Precacluate positions, rotation angles for each N neurons in the population
        positions = generate_random_positions(n_cells)

        # Adds node populations
        net.add_nodes(N=n_cells,
                      x=positions[:, 0],
                      y=positions[:, 1],
                      z=positions[:, 2],
                      rotation_angle_yaxis=np.random.uniform(
                          0.0, 2 * np.pi, n_cells),
                      **params)

    #### Step 4: Used add_edges() to set our connections between cells ####
    cparameters = {
        'd_max':
        160.0,  # Maximum separation between nodes where connection allowed 
        'nsyn_min': 3,  # If connection exist, minimum number of synapses
        'nsyn_max': 7
    }  # If connection exist, maximum number of synapses

    net.add_edges(
        source={
            'ei': 'i'
        },  # Select all inhibitory cells to apply this connection rule too
        target={
            'ei': 'i',
            'model_type': 'biophysical'
        },  # for the target cells we will use inhibitory biophysical cells
        connection_rule=distance_connection_handler,
        connection_params={
            'd_max': 160.0,
            'nsyn_min': 3,
            'nsyn_max': 7
        },
        syn_weight=0.03,
        distance_range=[0.0, 1e+20],
        target_sections=['somatic', 'basal'],
        delay=2.0,
        dynamics_params='GABA_InhToInh.json',
        model_template='exp2syn')

    # inhibitory --> point-inhibitory
    net.add_edges(source={'ei': 'i'},
                  target={
                      'ei': 'i',
                      'model_type': 'point_process'
                  },
                  connection_rule=distance_connection_handler,
                  connection_params={
                      'd_max': 160.0,
                      'nsyn_min': 3,
                      'nsyn_max': 7
                  },
                  syn_weight=0.3,
                  delay=2.0,
                  dynamics_params='instanteneousInh.json')

    # inhibiotry --> biophysical-excitatory
    net.add_edges(source={'ei': 'i'},
                  target={
                      'ei': 'e',
                      'model_type': 'biophysical'
                  },
                  connection_rule=distance_connection_handler,
                  connection_params={
                      'd_max': 160.0,
                      'nsyn_min': 3,
                      'nsyn_max': 7
                  },
                  syn_weight=0.3,
                  distance_range=[0.0, 50.0],
                  target_sections=['somatic', 'basal', 'apical'],
                  delay=2.0,
                  dynamics_params='GABA_InhToExc.json',
                  model_template='exp2syn')

    # inhibitory --> point-excitatory
    net.add_edges(source={'ei': 'i'},
                  target={
                      'ei': 'e',
                      'model_type': 'point_process'
                  },
                  connection_rule=distance_connection_handler,
                  connection_params={
                      'd_max': 160.0,
                      'nsyn_min': 3,
                      'nsyn_max': 7
                  },
                  syn_weight=0.4,
                  delay=2.0,
                  dynamics_params='instanteneousInh.json')

    # excitatory --> PV1 cells
    net.add_edges(source={'ei': 'e'},
                  target={'pop_name': 'PV1'},
                  connection_rule=distance_connection_handler,
                  connection_params={
                      'd_max': 160.0,
                      'nsyn_min': 3,
                      'nsyn_max': 7
                  },
                  syn_weight=0.05,
                  distance_range=[0.0, 1e+20],
                  target_sections=['somatic', 'basal'],
                  delay=2.0,
                  dynamics_params='AMPA_ExcToInh.json',
                  model_template='exp2syn')

    # excitatory --> LIF_inh
    net.add_edges(source={'ei': 'e'},
                  target={'pop_name': 'LIF_inh'},
                  connection_rule=distance_connection_handler,
                  connection_params=cparameters,
                  syn_weight=0.2,
                  delay=2.0,
                  dynamics_params='instanteneousExc.json')

    # excitatory --> Scnn1a
    net.add_edges(source={'ei': 'e'},
                  target={'pop_name': 'Scnn1a'},
                  connection_rule=distance_connection_handler,
                  connection_params={
                      'd_max': 160.0,
                      'nsyn_min': 3,
                      'nsyn_max': 7
                  },
                  syn_weight=0.05,
                  distance_range=[30.0, 150.0],
                  target_sections=['basal', 'apical'],
                  delay=2.0,
                  dynamics_params='AMPA_ExcToExc.json',
                  model_template='exp2syn')

    # excitatory --> LIF_exc
    net.add_edges(source={'ei': 'e'},
                  target={'pop_name': 'LIF_exc'},
                  connection_rule=distance_connection_handler,
                  connection_params={
                      'd_max': 160.0,
                      'nsyn_min': 3,
                      'nsyn_max': 7
                  },
                  syn_weight=0.05,
                  delay=2.0,
                  dynamics_params='instanteneousExc.json')

    #### Step 5: Build and save the network ####
    net.build()
    net.save(output_dir=output_dir)
    return net
Пример #10
0
def build_lgn():
    def generate_positions(N, x0=0.0, x1=300.0, y0=0.0, y1=100.0):
        X = np.random.uniform(x0, x1, N)
        Y = np.random.uniform(y0, y1, N)
        return np.column_stack((X, Y))

    def select_source_cells(src_cells, trg_cell, n_syns):
        if trg_cell['tuning_angle'] is not None:
            synapses = [n_syns if src['pop_name'] == 'tON' or src['pop_name'] == 'tOFF' else 0 for src in src_cells]
        else:
            synapses = [n_syns if src['pop_name'] == 'tONOFF' else 0 for src in src_cells]

        return synapses

    if not os.path.exists('output'):
        os.makedirs('output')

    LGN = NetworkBuilder("LGN")
    LGN.add_nodes(N=3000,
                  positions=generate_positions(3000),
                  location='LGN',
                  level_of_detail='filter',
                  pop_name='tON',
                  ei='e')

    LGN.add_nodes(N=3000,
                  positions=generate_positions(3000),
                  location='LGN',
                  level_of_detail='filter',
                  pop_name='tOFF',
                  ei='e')

    LGN.add_nodes(N=3000,
                  positions=generate_positions(3000),
                  location='LGN',
                  level_of_detail='filter',
                  pop_name='tONOFF',
                  ei='e')

    VL4 = NetworkBuilder('V1/L4')
    VL4.import_nodes(nodes_file_name='output/v1_nodes.h5', node_types_file_name='output/v1_node_types.csv')
    VL4.add_edges(source=LGN.nodes(), target={'pop_name': 'Rorb'},
                  iterator='all_to_one',
                  connection_rule=select_source_cells,
                  connection_params={'n_syns': 10},
                  weight_max=5e-05,
                  weight_function='wmax',
                  distance_range=[0.0, 150.0],
                  target_sections=['basal', 'apical'],
                  delay=2.0,
                  params_file='AMPA_ExcToExc.json',
                  set_params_function='exp2syn')

    VL4.add_edges(source=LGN.nodes(), target={'pop_name': 'Nr5a1'},
                  iterator='all_to_one',
                  connection_rule=select_source_cells,
                  connection_params={'n_syns': 10},
                  weight_max=5e-05,
                  weight_function='wmax',
                  distance_range=[0.0, 150.0],
                  target_sections=['basal', 'apical'],
                  delay=2.0,
                  params_file='AMPA_ExcToExc.json',
                  set_params_function='exp2syn')

    VL4.add_edges(source=LGN.nodes(), target={'pop_name': 'Scnn1a'},
                  iterator='all_to_one',
                  connection_rule=select_source_cells,
                  connection_params={'n_syns': 10},
                  weight_max=4e-05,
                  weight_function='wmax',
                  distance_range=[0.0, 150.0],
                  target_sections=['basal', 'apical'],
                  delay=2.0,
                  params_file='AMPA_ExcToExc.json',
                  set_params_function='exp2syn')

    VL4.add_edges(source=LGN.nodes(), target={'pop_name': 'PV1'},
                  iterator='all_to_one',
                  connection_rule=select_source_cells,
                  connection_params={'n_syns': 10},
                  weight_max=0.0001,
                  weight_function='wmax',
                  distance_range=[0.0, 1.0e+20],
                  target_sections=['somatic', 'basal'],
                  delay=2.0,
                  params_file='AMPA_ExcToInh.json',
                  set_params_function='exp2syn')

    VL4.add_edges(source=LGN.nodes(), target={'pop_name': 'PV2'},
                  iterator='all_to_one',
                  connection_rule=select_source_cells,
                  connection_params={'n_syns': 10},
                  weight_max=9e-05,
                  weight_function='wmax',
                  distance_range=[0.0, 1.0e+20],
                  target_sections=['somatic', 'basal'],
                  delay=2.0,
                  params_file='AMPA_ExcToInh.json',
                  set_params_function='exp2syn')

    VL4.add_edges(source=LGN.nodes(), target={'pop_name': 'LIF_exc'},
                  iterator='all_to_one',
                  connection_rule=select_source_cells,
                  connection_params={'n_syns': 10},
                  weight_max=0.0045,
                  weight_function='wmax',
                  delay=2.0,
                  params_file='instanteneousExc.json',
                  set_params_function='exp2syn')

    VL4.add_edges(source=LGN.nodes(), target={'pop_name': 'LIF_inh'},
                  iterator='all_to_one',
                  connection_rule=select_source_cells,
                  connection_params={'n_syns': 10},
                  weight_max=0.002,
                  weight_function='wmax',
                  delay=2.0,
                  params_file='instanteneousExc.json',
                  set_params_function='exp2syn')

    VL4.build()
    LGN.save_nodes(nodes_file_name='output/lgn_nodes.h5', node_types_file_name='output/lgn_node_types.csv')
    VL4.save_edges(edges_file_name='output/lgn_v1_edges.h5', edge_types_file_name='output/lgn_v1_edge_types.csv')

    assert(os.path.exists('output/lgn_node_types.csv'))
    node_types_csv = pd.read_csv('output/lgn_node_types.csv', sep=' ')
    assert(len(node_types_csv) == 3)
    assert(set(node_types_csv.columns) == {'node_type_id', 'location', 'ei', 'level_of_detail', 'pop_name'})


    assert(os.path.exists('output/lgn_nodes.h5'))
    nodes_h5 = h5py.File('output/lgn_nodes.h5')
    assert(len(nodes_h5['/nodes/node_gid']) == 9000)
    assert(len(nodes_h5['/nodes/node_type_id']) == 9000)
    assert(len(nodes_h5['/nodes/node_group']) == 9000)
    assert(len(nodes_h5['/nodes/node_group_index']) == 9000)
    assert(set(nodes_h5['/nodes/0'].keys()) == {'positions'})
    assert(len(nodes_h5['/nodes/0/positions']) == 9000)

    assert(os.path.exists('output/lgn_v1_edge_types.csv'))
    edge_types_csv = pd.read_csv('output/lgn_v1_edge_types.csv', sep=' ')
    assert(len(edge_types_csv) == 7)
    assert(set(edge_types_csv.columns) == {'weight_max', 'edge_type_id', 'target_query', 'params_file',
                                           'set_params_function', 'delay', 'target_sections', 'weight_function',
                                           'source_query', 'distance_range'})

    assert(os.path.exists('output/lgn_v1_edges.h5'))
    edges_h5 = h5py.File('output/lgn_v1_edges.h5')
    assert(len(edges_h5['/edges/index_pointer']) == 14+1)
    assert(len(edges_h5['/edges/target_gid']) == 6000*14)
    assert(len(edges_h5['/edges/source_gid']) == 6000*14)
    assert(len(edges_h5['/edges/0/nsyns']) == 6000*14)
Пример #11
0
for model_name, model_params in cell_models.items():
    positions = positions_table[model_name]
    xcoords += [p[0] for p in positions]
    ycoords += [p[1] for p in positions]
    tuning_angles = [calc_tuning_angle(o) for o in offset_table[model_name]]

    lgn_net.add_nodes(model_params['N'],
                      position=positions,
                      tuning_angle=tuning_angles,
                      ei=model_params['ei'],
                      location=model_params['location'],
                      level_of_detail=model_params['level_of_detail'],
                      pop_name=model_params['pop_name'],
                      pop_id=model_params['pop_id'])

lgn_net.build()
lgn_net.save_nodes('lgn_nodes.h5', 'lgn_node_types.csv')
exit()

v1_net = NetworkBuilder('V1')
v1_net.import_nodes('v1_nodes.h5', 'v1_node_types.csv')

lgn_mean = (np.mean(xcoords), np.mean(ycoords))
lgn_dim = (140.0, 70.0)
print "> LGN mean center:"

# Determine the mean center of the CC cells
xcoords = [n['position'][0] for n in v1_net.nodes()]
ycoords = [n['position'][1] for n in v1_net.nodes()]
zcoords = [n['position'][2] for n in v1_net.nodes()]
l4_mean = (np.mean(xcoords), np.mean(ycoords), np.mean(zcoords))
Пример #12
0
            

                        
net1.add_edges(source={'cell_name': 'HCOCell1'}, target={'cell_name':'HCOCell2'},
              connection_rule=1,
              syn_weight=40.0e-02,
              dynamics_params='GABA_InhToInh.json',
              model_template='Exp2Syn',
              delay=0.0,
              target_sections=["soma"],
              distance_range=[0,999])
              
net1.add_edges(source={'cell_name': 'HCOCell2'}, target={'cell_name':'HCOCell1'},
              connection_rule=1,
              syn_weight=40.0e-02,
              dynamics_params='GABA_InhToInh.json',
              model_template='Exp2Syn',
              delay=0.0,
              target_sections=["soma"],
              distance_range=[0,999])

net1.build()
net1.save_nodes(output_dir='network')             
              
net1.build()
net1.save_edges(output_dir='network')


#from bmtk.analyzer import node_types_table
#node_types_table(node_types_file='network/mcortex_node_types.csv', population='mcortex')
Пример #13
0
                   target_sections=['somatic'],
                   distance_range=[0.0, 300.0],
                   dynamics_params='AMPA_ExcToExc.json',
                   model_template='Exp2Syn')

conn = net.add_edges(source=net.nodes(pop_name='PMC'), target=net.nodes(pop_name='IND'),
                   connection_rule=one_to_one,
                   delay=0.5,
                   syn_weight = 0.033,
                   target_sections=['somatic'],
                   distance_range=[0.0, 300.0],
                   dynamics_params='AMPA_ExcToExc.json',
                   model_template='Exp2Syn')


net.build()
net.save_nodes(output_dir=output_dir)
net.save_edges(output_dir=output_dir)

#inp = NetworkBuilder('INPUT') # Virtual cells delivering input to PUD
#inp.add_nodes(N=1, pop_name = 'Pel_aff_virt', model_type='virtual', potential='exc')
#inp.add_edges(source=inp.nodes(pop_name='Pel_aff_virt'), target=net.nodes(pop_name='SPN'),
#                   connection_rule=1,
#                   syn_weight=0.06,
#                   target_sections=['somatic'],
#				   delay=0.5,
#                   distance_range=[0.0, 300.0],
#                   dynamics_params='AMPA_ExcToExc.json',
#                   model_template='Exp2Syn')
#
#inp.build()
Пример #14
0
def connect_random(source, target, nsyn_min=0, nsyn_max=10, distribution=None):
    return np.random.randint(nsyn_min, nsyn_max)
"""

thalamus = NetworkBuilder('mthalamus')
thalamus.add_nodes(N=100,
                   pop_name='tON',
                   potential='exc',
                   level_of_detail='filter')

cortex = NetworkBuilder('mcortex')
cortex.import_nodes(nodes_file_name='network/mcortex_nodes.h5',
                    node_types_file_name='network/mcortex_node_types.csv')
thalamus.add_edges(source=thalamus.nodes(),
                   target=cortex.nodes(),
                   connection_rule=connect_random,
                   connection_params={
                       'nsyn_min': 0,
                       'nsyn_max': 12
                   },
                   syn_weight=1.0e-04,
                   distance_range=[0.0, 150.0],
                   target_sections=['basal', 'apical'],
                   delay=2.0,
                   dynamics_params='AMPA_ExcToExc.json',
                   model_template='exp2syn')

thalamus.build()
thalamus.save_nodes(output_dir='network')
thalamus.save_edges(output_dir='network')
Пример #15
0
lgn.add_edges(source=lgn.nodes(),
              target=net.nodes(pop_name='LIF_exc'),
              connection_rule=select_source_cells,
              connection_params={
                  'nsources_min': 10,
                  'nsources_max': 25
              },
              iterator='all_to_one',
              syn_weight=0.045,
              weight_function='wmax',
              delay=2.0,
              dynamics_params='instanteneousExc.json',
              model_template='exp2syn')

lgn.add_edges(source=lgn.nodes(),
              target=net.nodes(pop_name='LIF_inh'),
              connection_rule=select_source_cells,
              connection_params={
                  'nsources_min': 15,
                  'nsources_max': 30
              },
              iterator='all_to_one',
              syn_weight=0.02,
              weight_function='wmax',
              delay=2.0,
              dynamics_params='instanteneousExc.json',
              model_template='exp2syn')

lgn.build()
lgn.save_nodes(output_dir='network')
lgn.save_edges(output_dir='network')
Пример #16
0
'''
tw = NetworkBuilder("tw")
tw.add_nodes(N=30, pop_name='TW', ei='e', location='TW', model_type='virtual')

tw.add_edges(source=tw.nodes(), target=net.nodes(pop_name='LIF_exc'),
             iterator='all_to_one',
             connection_rule=recurrent_connections_low,
             connection_params={'n_syns': 1},
             syn_weight=0.5,
             weight_function='wmax',
             delay=0.0,
             dynamics_params='instanteneousExc.json')


tw.add_edges(source=tw.nodes(), target=net.nodes(pop_name='LIF_inh'),
             connection_rule=1,
             syn_weight=0.2,
             weight_function='wmax',
             delay=0.0,
             dynamics_params='instanteneousExc.json')

tw.build()
tw.save(output_dir='../input/network')'''

net_pre.build()
net_pre.save(output_dir='../input/network')

net_post.build()
net_post.save(output_dir='../input/network')

print 'done'
Пример #17
0
def build_lgn():
    def generate_positions(N, x0=0.0, x1=300.0, y0=0.0, y1=100.0):
        X = np.random.uniform(x0, x1, N)
        Y = np.random.uniform(y0, y1, N)
        return np.column_stack((X, Y))

    def select_source_cells(src_cell, trg_cell, n_syns_exc, n_syns_inh):
        #if trg_cell['tuning_angle'] is not None:
        #    synapses = [n_syns if src['pop_name'] == 'tON' or src['pop_name'] == 'tOFF' else 0 for src in src_cells]
        #else:
        #    synapses = [n_syns if src['pop_name'] == 'tONOFF' else 0 for src in src_cells]

        # will always give synapse number depending on type
        if n_syns_exc > 0:
            n_synapses = n_syns_exc
        if n_syns_inh > 0:
            n_synapses = n_syns_inh

        return n_synapses

        # varible number of synapses
        #return np.random.randint(n_syns_min, n_syns_max)
        #return synapses

    if not os.path.exists('output'):
        os.makedirs('output')

    LGN = NetworkBuilder("LGN")
    LGN.add_nodes(N=1000,
                  positions=generate_positions(1000),
                  location='LGN',
                  level_of_detail='filter',
                  pop_name='ExcIN',
                  ei='e')

    LGN.add_nodes(N=1,
                  positions=generate_positions(1),
                  location='LGN',
                  level_of_detail='filter',
                  pop_name='InhIN',
                  ei='i')
  


    VL4 = NetworkBuilder('V1/L4')
    VL4.import_nodes(nodes_file_name='output/v1_nodes.h5', node_types_file_name='output/v1_node_types.csv')
    cm = VL4.add_edges(source=LGN.nodes(ei='e'), #target={'pop_name': 'DG_GC'},
                  connection_rule=select_source_cells,
                  connection_params={'n_syns_exc': 1, 'n_syns_inh': 0},
                  weight_max=10e-03,
                  weight_function='wmax',
                  distance_range=[1, 1e+20],
                  target_sections=['apical'],
                  delay=2.0,
                  params_file='AMPA_ExcToExc.json',
                  set_params_function='exp2syn')



    VL4.build()
    LGN.save_nodes(nodes_file_name='output/lgn_nodes.h5', node_types_file_name='output/lgn_node_types.csv')
    VL4.save_edges(edges_file_name='output/lgn_v1_edges.h5', edge_types_file_name='output/lgn_v1_edge_types.csv')
Пример #18
0
              connection_params={'d_weight_min': 0.0, 'd_weight_max': 0.26, 'd_max': 300.0, 'nsyn_min': 3, 'nsyn_max': 7},
              syn_weight=15.0,
              delay=2.0,
              dynamics_params='ExcToInh.json',
              model_template='static_synapse')


net.add_edges(source={'ei': 'e'}, target={'pop_name': 'LIF_inh'},
              connection_rule=distance_connector,
              connection_params={'d_weight_min': 0.0, 'd_weight_max': 0.26, 'd_max': 300.0, 'nsyn_min': 3, 'nsyn_max': 7},
              syn_weight=5.0,
              delay=2.0,
              dynamics_params='instanteneousExc.json',
              model_template='static_synapse')

net.build()
net.save_nodes(output_dir='network')
net.save_edges(output_dir='network')



lgn = NetworkBuilder('LGN')
lgn.add_nodes(N=500,
              pop_name='tON',
              potential='exc',
              model_type='virtual')


def select_source_cells(sources, target, nsources_min=10, nsources_max=30, nsyns_min=3, nsyns_max=12):
    total_sources = len(sources)
    nsources = np.random.randint(nsources_min, nsources_max)
Пример #19
0
def build_l4():
    net = NetworkBuilder("V1/L4")
    net.add_nodes(N=2, pop_name='Scnn1a',
                  positions=[(28.753, -364.868, -161.705), (48.753, -344.868, -141.705)],
                  tuning_angle=[0.0, 25.0],
                  rotation_angle_yaxis=[3.55501, 3.55501],
                  location='VisL4',
                  ei='e',
                  level_of_detail='biophysical',
                  params_file='472363762_fit.json',
                  morphology_file='Scnn1a-Tg3-Cre_Ai14_IVSCC_-177300.01.02.01_473845048_m.swc',
                  rotation_angle_zaxis=-3.646878266,
                  set_params_function='Biophys1')

    net.add_nodes(N=2, pop_name='Rorb',
                  positions=[(241.092, -349.263, 146.916), (201.092, -399.263, 126.916)],
                  tuning_angle=[50.0, 75.0],
                  rotation_angle_yaxis=[3.50934, 3.50934],
                  location='VisL4',
                  ei='e',
                  level_of_detail='biophysical',
                  params_file='473863510_fit.json',
                  morphology_file='Rorb-IRES2-Cre-D_Ai14_IVSCC_-168053.05.01.01_325404214_m.swc',
                  rotation_angle_zaxis=-4.159763785,
                  set_params_function='Biophys1')

    net.add_nodes(N=2, pop_name='Nr5a1',
                  positions=[(320.498, -351.259, 20.273), (310.498, -371.259, 10.273)],
                  tuning_angle=[100.0, 125.0],
                  rotation_angle_yaxis=[0.72202, 0.72202],
                  location='VisL4',
                  ei='e',
                  level_of_detail='biophysical',
                  params_file='473863035_fit.json',
                  morphology_file='Nr5a1-Cre_Ai14_IVSCC_-169250.03.02.01_471087815_m.swc',
                  rotation_angle_zaxis=-2.639275277,
                  set_params_function='Biophys1')

    net.add_nodes(N=2, pop_name='PV1',
                  positions=[(122.373, -352.417, -216.748), (102.373, -342.417, -206.748)],
                  tuning_angle=['NA', 'NA'],
                  rotation_angle_yaxis=[2.92043, 2.92043],
                  location='VisL4',
                  ei='i',
                  level_of_detail='biophysical',
                  params_file='472912177_fit.json',
                  morphology_file='Pvalb-IRES-Cre_Ai14_IVSCC_-176847.04.02.01_470522102_m.swc',
                  rotation_angle_zaxis=-2.539551891,
                  set_params_function='Biophys1')

    net.add_nodes(N=2, pop_name='PV2',
                  positions=[(350.321, -372.535, -18.282), (360.321, -371.535, -12.282)],
                  tuning_angle=['NA', 'NA'],
                  rotation_angle_yaxis=[5.043336, 5.043336],
                  location='VisL4',
                  ei='i',
                  level_of_detail='biophysical',
                  params_file='473862421_fit.json',
                  morphology_file='Pvalb-IRES-Cre_Ai14_IVSCC_-169125.03.01.01_469628681_m.swc',
                  rotation_angle_zaxis=-3.684439949,
                  set_params_function='Biophys1')

    net.add_nodes(N=2, pop_name='LIF_exc',
                  positions=[(-243.04, -342.352, -665.666), (-233.04, -332.352, -675.666)],
                  tuning_angle=['NA', 'NA'],
                  #rotation_angle_yaxis=[5.11801, 5.11801],
                  location='VisL4',
                  ei='e',
                  level_of_detail='intfire',
                  params_file='IntFire1_exc_1.json',
                  set_params_function='IntFire1')

    net.add_nodes(N=2, pop_name='LIF_inh',
                  positions=[(211.04, -321.333, -631.593), (218.04, -327.333, -635.593)],
                  tuning_angle=[150.0, 175.0],
                  #rotation_angle_yaxis=[4.566091, 4.566091],
                  location='VisL4',
                  ei='i',
                  level_of_detail='intfire',
                  params_file='IntFire1_inh_1.json',
                  set_params_function='IntFire1')

    print("Setting connections...")
    print("Generating I-to-I connections.")
    net.add_edges(source={'ei': 'i'}, target={'ei': 'i', 'level_of_detail': 'biophysical'},
                  connection_rule=5,
                  weight_max=0.0002,
                  weight_function='wmax',
                  distance_range=[0.0, 1e+20],
                  target_sections=['somatic', 'basal'],
                  delay=2.0,
                  params_file='GABA_InhToInh.json',
                  set_params_function='exp2syn')

    net.add_edges(source={'ei': 'i'}, target={'ei': 'i', 'level_of_detail': 'intfire'},
                  connection_rule=5,
                  weight_max=0.00225,
                  weight_function='wmax',
                  delay=2.0,
                  params_file='instanteneousInh.json',
                  set_params_function='exp2syn')

    print("Generating I-to-E connections.")
    net.add_edges(source={'ei': 'i'}, target={'ei': 'e', 'level_of_detail': 'biophysical'},
                  connection_rule=lambda trg, src: 5,
                  weight_max=0.00018,
                  weight_function='wmax',
                  distance_range=[0.0, 50.0],
                  target_sections=['somatic', 'basal', 'apical'],
                  delay=2.0,
                  params_file='GABA_InhToExc.json',
                  set_params_function='exp2syn')

    net.add_edges(source={'ei': 'i'}, target={'ei': 'e', 'level_of_detail': 'intfire'},
                  connection_rule=5,
                  weight_max=0.009,
                  weight_function='wmax',
                  delay=2.0,
                  params_file='instanteneousInh.json',
                  set_params_function='exp2syn')

    print("Generating E-to-I connections.")
    net.add_edges(source={'ei': 'e'}, target={'pop_name': 'PV1'},
                  connection_rule=5,
                  weight_max=0.00035,
                  weight_function='wmax',
                  distance_range=[0.0, 1e+20],
                  target_sections=['somatic', 'basal'],
                  delay=2.0,
                  params_file='AMPA_ExcToInh.json',
                  set_params_function='exp2syn')

    net.add_edges(source={'ei': 'e'}, target={'pop_name': 'PV2'},
                  connection_rule=5,
                  weight_max=0.00027,
                  weight_function='wmax',
                  distance_range=[0.0, 1e+20],
                  target_sections=['somatic', 'basal'],
                  delay=2.0,
                  params_file='AMPA_ExcToInh.json',
                  set_params_function='exp2syn')

    net.add_edges(source={'ei': 'e'}, target={'pop_name': 'LIF_inh'},
                  connection_rule=5,
                  weight_max=0.0043,
                  weight_function='wmax',
                  delay=2.0,
                  params_file='instanteneousExc.json',
                  set_params_function='exp2syn')

    print("Generating E-to-E connections.")
    net.add_edges(source={'ei': 'e'}, target={'pop_name': 'Scnn1a'},
                  connection_rule=5,
                  weight_max=6.4e-05,
                  weight_function='gaussianLL',
                  weight_sigma=50.0,
                  distance_range=[30.0, 150.0],
                  target_sections=['basal', 'apical'],
                  delay=2.0,
                  params_file='AMPA_ExcToExc.json',
                  set_params_function='exp2syn')

    net.add_edges(source={'ei': 'e'}, target={'pop_name': 'Rorb'},
                  connection_rule=5,
                  weight_max=5.5e-05,
                  weight_function='gaussianLL',
                  weight_sigma=50.0,
                  distance_range=[30.0, 150.0],
                  target_sections=['basal', 'apical'],
                  delay=2.0,
                  params_file='AMPA_ExcToExc.json',
                  set_params_function='exp2syn')

    net.add_edges(source={'ei': 'e'}, target={'pop_name': 'Nr5a1'},
                  connection_rule=5,
                  weight_max=7.2e-05,
                  weight_function='gaussianLL',
                  weight_sigma=50.0,
                  distance_range=[30.0, 150.0],
                  target_sections=['basal', 'apical'],
                  delay=2.0,
                  params_file='AMPA_ExcToExc.json',
                  set_params_function='exp2syn')

    net.add_edges(source={'ei': 'e'}, target={'pop_name': 'LIF_exc'},
                  connection_rule=5,
                  weight_max=0.0019,
                  weight_function='gaussianLL',
                  weight_sigma=50.0,
                  delay=2.0,
                  params_file='instanteneousExc.json',
                  set_params_function='exp2syn')


    net.build()
    net.save_nodes(nodes_file_name='output/v1_nodes.h5', node_types_file_name='output/v1_node_types.csv')
    net.save_edges(edges_file_name='output/v1_v1_edges.h5', edge_types_file_name='output/v1_v1_edge_types.csv')

    assert(os.path.exists('output/v1_node_types.csv'))
    node_types_csv = pd.read_csv('output/v1_node_types.csv', sep=' ')
    assert(len(node_types_csv) == 7)
    assert(set(node_types_csv.columns) == {'node_type_id', 'location', 'ei', 'level_of_detail', 'params_file',
                                           'pop_name', 'set_params_function', 'rotation_angle_zaxis',
                                           'morphology_file'})

    assert(os.path.exists('output/v1_nodes.h5'))
    nodes_h5 = h5py.File('output/v1_nodes.h5')
    assert(len(nodes_h5['/nodes/node_gid']) == 14)
    assert(len(nodes_h5['/nodes/node_type_id']) == 14)
    assert(len(nodes_h5['/nodes/node_group']) == 14)
    assert(len(nodes_h5['/nodes/node_group_index']) == 14)
    assert(set(nodes_h5['/nodes/0'].keys()) == {'positions', 'rotation_angle_yaxis', 'tuning_angle'})
    assert(len(nodes_h5['/nodes/0/positions']) == 10)
    assert(len(nodes_h5['/nodes/1/positions']) == 4)

    assert(os.path.exists('output/v1_v1_edge_types.csv'))
    edge_types_csv = pd.read_csv('output/v1_v1_edge_types.csv', sep=' ')
    assert(len(edge_types_csv) == 11)
    assert(set(edge_types_csv.columns) == {'weight_max', 'edge_type_id', 'target_query', 'params_file',
                                           'set_params_function', 'delay', 'target_sections', 'weight_function',
                                           'weight_sigma', 'source_query', 'distance_range'})

    assert(os.path.exists('output/v1_v1_edges.h5'))
    edges_h5 = h5py.File('output/v1_v1_edges.h5')
    assert(len(edges_h5['/edges/index_pointer']) == 14+1)
    assert(len(edges_h5['/edges/target_gid']) == 14*14)
    assert(len(edges_h5['/edges/source_gid']) == 14*14)
    assert(len(edges_h5['/edges/0/nsyns']) == 14*14)

    return net
Пример #20
0
from bmtk.builder.networks import NetworkBuilder

cortex = NetworkBuilder('mcortex')
cortex.add_nodes(cell_name='Scnn1a',
                 potental='exc',
                 level_of_detail='biophysical',
                 params_file='472363762_fit.json',
                 morphology_file='Scnn1a.swc',
                 set_params_function='Biophys1')

cortex.build()
cortex.save_nodes(output_dir='network')

thalamus = NetworkBuilder('mthalamus')
thalamus.add_nodes(N=10,
                   pop_name='tON',
                   potential='exc',
                   level_of_detail='filter')

thalamus.add_edges(source={'pop_name': 'tON'},
                   target=cortex.nodes(),
                   connection_rule=5,
                   weight_max=5e-05,
                   weight_function='wmax',
                   distance_range=[0.0, 150.0],
                   target_sections=['basal', 'apical'],
                   delay=2.0,
                   params_file='AMPA_ExcToExc.json',
                   set_params_function='exp2syn')

thalamus.build()
Пример #21
0
    N = model_params['N']
    cell_props = {'position': np.random.rand(N, 3)*[100.0, -300.0, 100.0],
                  'rotation_angle': np.random.uniform(0.0, 2*np.pi, (N,))}
    if model_params['props']['ei'] == 'e':
        cell_props['tuning_angle'] = np.linspace(0, 360.0, N, endpoint=False)
    else:
        cell_props['tuning_angle'] = ['NA']*N

    cell_props.update(model_params['props'])

    net.add_nodes(N=N,
                  pop_name=name,
                  location='VisL4',
                  **cell_props)

'''
net.build()
net.save_nodes('tmp_nodes.h5', 'tmp_node_types.csv')
exit()
'''

cparameters = {'d_weight_min': 0.0, 'd_weight_max': 1.0, 'd_max': 160.0, 'nsyn_min': 3, 'nsyn_max': 7}
net.add_edges(sources={'ei': 'i'}, targets={'ei': 'i', 'level_of_detail': 'biophysical'},
              func=distance_connection_handler, func_params=cparameters,
              weight_max=0.0002,
              weight_function='wmax',
              distance_range=[0.0, 1e+20],
              target_sections=['somatic', 'basal'],
              delay=2.0,
              params_file='GABA_InhToInh.json',
              set_params_function='exp2syn')
Пример #22
0
PAG_aff_virt.add_edges(source=PAG_aff_virt.nodes(), target=net.nodes(pop_name='PAGaff'),
                   connection_rule=percent_connector,
                   connection_params={'percent':100.0},
                   syn_weight=20.0e-03,
                   target_sections=['somatic'],
                   delay=2.0,
                   distance_range=[0.0, 300.0],
                   dynamics_params='AMPA_ExcToExc.json',
                   model_template='Exp2Syn')

####################################################################################
########################## Build and save network ##################################
####################################################################################

print("\nBuilding network and saving to directory \"" + output_dir + "\"")
net.build()
Blad_aff_virt.build()
EUS_aff_virt.build()
PAG_aff_virt.build()

net.save_nodes(output_dir=output_dir)
net.save_edges(output_dir=output_dir)

Blad_aff_virt.save_nodes(output_dir=output_dir)
Blad_aff_virt.save_edges(output_dir=output_dir)

EUS_aff_virt.save_nodes(output_dir=output_dir)
EUS_aff_virt.save_edges(output_dir=output_dir)

PAG_aff_virt.save_nodes(output_dir=output_dir)
PAG_aff_virt.save_edges(output_dir=output_dir)
Пример #23
0
    dynamics_params='473863035_fit.json',
    morphology='Nr5a1-Cre_Ai14_IVSCC_-169250.03.02.01_471087815_m.swc')

# Create synapse from the high-level cell to the low-level cell (0 --> 1)
net.add_edges(source={'level': 'high'},
              target={'level': 'low'},
              connection_rule=5,
              syn_weight=12.0e-03,
              target_sections=['somatic'],
              distance_range=[0.0, 300.0],
              delay=1.0,
              dynamics_params='AMPA_ExcToExc.json',
              model_template='exp2syn')

# build and save the network.
net.build()
net.save(output_dir='network')

# An external network with 1 (excitatory virtual) cell that will connect to the internal excitatory cell to drive
# it with the spikes inputs
inputs = NetworkBuilder("external")
inputs.add_nodes(N=1, model_type='virtual')
inputs.add_edges(
    source=inputs.nodes(),
    target=net.nodes(level='low'),
    connection_rule=1,
    syn_weight=12.0E-03,
    # weight_function='wmax',
    distance_range=[0.0, 300.0],
    target_sections=['somatic'],
    delay=1.0,
Пример #24
0
import numpy as np
import random


cortex = NetworkBuilder('mcortex')
cortex.add_nodes(N=100,
                 pop_name='Scnn1a',
                 positions=positions_columinar(N=100, center=[0, 50.0, 0], max_radius=30.0, height=100.0),
                 rotation_angle_yaxis=xiter_random(N=100, min_x=0.0, max_x=2*np.pi),
                 rotation_angle_zaxis=3.646878266,
                 potental='exc',
                 model_type='biophysical',
                 model_template='ctdb:Biophys1.hoc',
                 model_processing='aibs_perisomatic',
                 dynamics_params='472363762_fit.json',
                 morphology='Scnn1a_473845048_m.swc')

cortex.add_edges(source={'pop_name': 'Scnn1a'}, target={'pop_name': 'Scnn1a'},
                 connection_rule=distance_connector,
                 connection_params={'d_weight_min': 0.0, 'd_weight_max': 0.34, 'd_max': 50.0, 'nsyn_min': 0, 'nsyn_max': 10},
                 syn_weight=2.0e-04,
                 distance_range=[30.0, 150.0],
                 target_sections=['basal', 'apical', 'soma'],
                 delay=2.0,
                 dynamics_params='AMPA_ExcToExc.json',
                 model_template='exp2syn')

cortex.build()
cortex.save_nodes(output_dir='network')
cortex.save_edges(output_dir='network')
Пример #25
0
def build_ext5_nodes():
    if not os.path.exists('network'):
        os.makedirs('network')

    EXT = NetworkBuilder("EXT")
    # need 5 cells to stimulate at 5 different frequencies
    EXT.add_nodes(N=5,
                  pop_name='EXT',
                  model_type='virtual',
                  firing_rate=firing_rate)

    # Save cells.csv and cell_types.csv
    EXT.save_nodes(nodes_file_name='network/ext_nodes.h5',
                   node_types_file_name='network/ext_node_types.csv')

    net = NetworkBuilder('slice')
    net.import_nodes(nodes_file_name='network/slice_nodes.h5',
                     node_types_file_name='network/slice_node_types.csv')

    net.add_edges(source=EXT.nodes(firing_rate=10),
                  target=net.nodes(firing_rate=10, synapse_model='a'),
                  connection_rule=5,
                  **({
                      'syn_weight': 0.002,
                      'weight_function': 'wmax',
                      'distance_range': [0.0, 50.0],
                      'target_sections': ['somatic', 'basal', 'apical'],
                      'delay': 2.0,
                      'dynamics_params': 'AMPA_ExcToExc.json',
                      'model_template': 'expsyn'
                  }))

    net.add_edges(source=EXT.nodes(firing_rate=20),
                  target=net.nodes(firing_rate=20, synapse_model='a'),
                  connection_rule=5,
                  **({
                      'syn_weight': 0.002,
                      'weight_function': 'wmax',
                      'distance_range': [0.0, 50.0],
                      'target_sections': ['somatic', 'basal', 'apical'],
                      'delay': 2.0,
                      'dynamics_params': 'AMPA_ExcToExc.json',
                      'model_template': 'expsyn'
                  }))

    net.add_edges(source=EXT.nodes(firing_rate=50),
                  target=net.nodes(firing_rate=50, synapse_model='a'),
                  connection_rule=5,
                  **({
                      'syn_weight': 0.002,
                      'weight_function': 'wmax',
                      'distance_range': [0.0, 50.0],
                      'target_sections': ['somatic', 'basal', 'apical'],
                      'delay': 2.0,
                      'dynamics_params': 'AMPA_ExcToExc.json',
                      'model_template': 'expsyn'
                  }))

    net.add_edges(source=EXT.nodes(firing_rate=100),
                  target=net.nodes(firing_rate=100, synapse_model='a'),
                  connection_rule=5,
                  **({
                      'syn_weight': 0.002,
                      'weight_function': 'wmax',
                      'distance_range': [0.0, 50.0],
                      'target_sections': ['somatic', 'basal', 'apical'],
                      'delay': 2.0,
                      'dynamics_params': 'AMPA_ExcToExc.json',
                      'model_template': 'expsyn'
                  }))

    net.add_edges(source=EXT.nodes(firing_rate=200),
                  target=net.nodes(firing_rate=200, synapse_model='a'),
                  connection_rule=5,
                  **({
                      'syn_weight': 0.002,
                      'weight_function': 'wmax',
                      'distance_range': [0.0, 50.0],
                      'target_sections': ['somatic', 'basal', 'apical'],
                      'delay': 2.0,
                      'dynamics_params': 'AMPA_ExcToExc.json',
                      'model_template': 'expsyn'
                  }))

    net.add_edges(source=EXT.nodes(firing_rate=10),
                  target=net.nodes(firing_rate=10, synapse_model='b'),
                  connection_rule=5,
                  **({
                      'syn_weight': 0.002,
                      'weight_function': 'wmax',
                      'distance_range': [0.0, 50.0],
                      'target_sections': ['somatic', 'basal', 'apical'],
                      'delay': 2.0,
                      'dynamics_params': 'pvalb_pvalb.json',
                      'model_template': 'stp2syn'
                  }))

    net.add_edges(source=EXT.nodes(firing_rate=20),
                  target=net.nodes(firing_rate=20, synapse_model='b'),
                  connection_rule=5,
                  **({
                      'syn_weight': 0.002,
                      'weight_function': 'wmax',
                      'distance_range': [0.0, 50.0],
                      'target_sections': ['somatic', 'basal', 'apical'],
                      'delay': 2.0,
                      'dynamics_params': 'pvalb_pvalb.json',
                      'model_template': 'stp2syn'
                  }))

    net.add_edges(source=EXT.nodes(firing_rate=50),
                  target=net.nodes(firing_rate=50, synapse_model='b'),
                  connection_rule=5,
                  **({
                      'syn_weight': 0.002,
                      'weight_function': 'wmax',
                      'distance_range': [0.0, 50.0],
                      'target_sections': ['somatic', 'basal', 'apical'],
                      'delay': 2.0,
                      'dynamics_params': 'pvalb_pvalb.json',
                      'model_template': 'stp2syn'
                  }))

    net.add_edges(source=EXT.nodes(firing_rate=100),
                  target=net.nodes(firing_rate=100, synapse_model='b'),
                  connection_rule=5,
                  **({
                      'syn_weight': 0.002,
                      'weight_function': 'wmax',
                      'distance_range': [0.0, 50.0],
                      'target_sections': ['somatic', 'basal', 'apical'],
                      'delay': 2.0,
                      'dynamics_params': 'pvalb_pvalb.json',
                      'model_template': 'stp2syn'
                  }))

    net.add_edges(source=EXT.nodes(firing_rate=200),
                  target=net.nodes(firing_rate=200, synapse_model='b'),
                  connection_rule=5,
                  **({
                      'syn_weight': 0.002,
                      'weight_function': 'wmax',
                      'distance_range': [0.0, 50.0],
                      'target_sections': ['somatic', 'basal', 'apical'],
                      'delay': 2.0,
                      'dynamics_params': 'pvalb_pvalb.json',
                      'model_template': 'stp2syn'
                  }))

    net.build()
    net.save_edges(edges_file_name='network/ext_to_slice_edges.h5',
                   edge_types_file_name='network/ext_to_slice_edge_types.csv')