def test_add_edges(): net = NetworkBuilder('V1') net.add_nodes(N=10, cell_type='Scnna1', ei='e') net.add_nodes(N=10, cell_type='PV1', ei='i') net.add_nodes(N=10, cell_type='PV2', ei='i') net.add_edges( source={'ei': 'i'}, target={'ei': 'e'}, connection_rule=lambda s, t: 1, edge_arg='i2e' ) net.add_edges( source=net.nodes(cell_type='Scnna1'), target=net.nodes(cell_type='PV1'), connection_rule=2, edge_arg='e2i' ) net.build() assert(net.nedges == 200 + 200) assert(net.edges_built is True) for e in net.edges(target_nodes=net.nodes(cell_type='Scnna1')): assert(e['edge_arg'] == 'i2e') assert(e['nsyns'] == 1) for e in net.edges(target_nodes=net.nodes(cell_type='PV1')): assert(e['edge_arg'] == 'e2i') assert(e['nsyns'] == 2)
def test_save_multinetwork_1(): net1 = NetworkBuilder('NET1') net1.add_nodes(N=100, position=[(0.0, 1.0, -1.0)] * 100, cell_type='Scnna1', ei='e') net1.add_edges(source={'ei': 'e'}, target={'ei': 'e'}, connection_rule=5, ctype_1='n1_rec') net1.build() net2 = NetworkBuilder('NET2') net2.add_nodes(N=10, position=[(0.0, 1.0, -1.0)] * 10, cell_type='PV1', ei='i') net2.add_edges(connection_rule=10, ctype_1='n2_rec') net2.add_edges(source=net1.nodes(), target={'ei': 'i'}, connection_rule=1, ctype_2='n1_n2') net2.add_edges(target=net1.nodes(cell_type='Scnna1'), source={'cell_type': 'PV1'}, connection_rule=2, ctype_2='n2_n1') net2.build() net_dir = tempfile.mkdtemp() net2.save_edges(edges_file_name='NET2_NET1_edges.h5', edge_types_file_name='NET2_NET1_edge_types.csv', output_dir=net_dir, src_network='NET2') n1_n2_fname = '{}/{}_{}'.format(net_dir, 'NET2', 'NET1') edges_h5 = h5py.File(n1_n2_fname + '_edges.h5', 'r') assert(len(edges_h5['/edges/NET2_to_NET1/target_node_id']) == 100*10) assert(len(edges_h5['/edges/NET2_to_NET1/0/nsyns']) == 100*10) assert(edges_h5['/edges/NET2_to_NET1/0/nsyns'][0] == 2) edge_types_csv = pd.read_csv(n1_n2_fname + '_edge_types.csv', sep=' ') assert(len(edge_types_csv) == 1) assert('ctype_1' not in edge_types_csv.columns.values) assert(edge_types_csv['ctype_2'].iloc[0] == 'n2_n1')
def test_duplicate_node_ids(): # Check if the same node_id is being used twice net = NetworkBuilder('V1') net.add_nodes(N=1, node_id=[100]) with pytest.raises(ValueError): net.add_nodes(N=1, node_id=[100])
def test_node_sets(): net = NetworkBuilder('NET1') net.add_nodes(N=100, prop_n='prop1', pool1='p1', sp='sp', param1=range(100)) net.add_nodes(N=100, prop_n='prop2', pool2='p2', sp='sp', param1=range(100)) net.add_nodes(N=100, prop_n='prop3', pool3='p3', sp='sp', param1=range(100)) node_pool_1 = net.nodes(prop_n='prop1') assert(len(node_pool_1) == 100) assert(node_pool_1.filter_str == "prop_n=='prop1'") for n in node_pool_1: assert('pool1' in n and n['prop_n'] == 'prop1') node_pool_2 = net.nodes(sp='sp') assert(node_pool_2.filter_str == "sp=='sp'") assert(len(node_pool_2) == 300) for n in node_pool_2: assert(n['sp'] == 'sp') node_pool_3 = net.nodes(param1=10) assert(len(node_pool_3) == 3) assert(node_pool_3.filter_str == "param1=='10'") nodes = list(node_pool_3) assert(nodes[0]['node_id'] == 10) assert(nodes[1]['node_id'] == 110) assert(nodes[2]['node_id'] == 210) assert(nodes[0]['node_type_id'] != nodes[1]['node_type_id'] != nodes[2]['node_type_id'])
def build_injective_inputs(target_net): print('Building External Network') input_network_model = { 'external': { 'N': len(target_net.nodes() ), # Need one virtual node for every LIF_network node 'ei': 'e', 'pop_name': 'input_network', 'model_type': 'virtual' } } inputNetwork = NetworkBuilder("external") inputNetwork.add_nodes(**input_network_model['external']) inputNetwork.add_edges( target=target_net.nodes(pop_name='LIF_exc'), connection_rule=injective_connections, iterator='all_to_one', # will make building a little faster syn_weight=200, delay=D, dynamics_params='ExcToExc.json', model_template='static_synapse') inputNetwork.add_edges(target=target_net.nodes(pop_name='LIF_inh'), connection_rule=injective_connections, iterator='all_to_one', syn_weight=100, delay=D, dynamics_params='ExcToExc.json', model_template='static_synapse') inputNetwork.build() inputNetwork.save(output_dir='network')
def test_cross_population_edges(): tmp_dir = make_tmp_dir() edges_file = make_tmp_file(suffix='.h5') edge_types_file = make_tmp_file(suffix='.csv') net_a1 = NetworkBuilder('A1') net_a1.add_nodes(N=100, model='A') net_a1.build() net_a2 = NetworkBuilder('A2') net_a2.add_nodes(N=100, model='B') net_a2.add_edges( source=net_a1.nodes(), target=net_a2.nodes(), connection_rule=lambda s, t: 1 if s.node_id == t.node_id else 0 ) net_a2.build() net_a2.save_edges( edges_file_name=edges_file, edge_types_file_name=edge_types_file, output_dir=tmp_dir, name='A1_A2' ) edges_h5_path = os.path.join(tmp_dir, edges_file) assert(os.path.exists(edges_h5_path)) with h5py.File(edges_h5_path, 'r') as h5: assert('/edges/A1_A2' in h5) assert(len(h5['/edges/A1_A2/source_node_id']) == 100) assert(h5['/edges/A1_A2/source_node_id'].attrs['node_population'] == 'A1') assert(len(h5['/edges/A1_A2/target_node_id']) == 100) assert(h5['/edges/A1_A2/target_node_id'].attrs['node_population'] == 'A2') barrier()
def test_add_edges_custom_params(): # Uses connection map functionality to create edges with unique parameters net = NetworkBuilder('V1') net.add_nodes(N=10, arg_list=range(10), arg_ctype='e') net.add_nodes(N=5, arg_list=range(10, 15), arg_ctype='i') cm = net.add_edges( source={'arg_ctype': 'e'}, target={'arg_ctype': 'i'}, connection_rule=2 ) cm.add_properties('syn_weight', rule=0.5, dtypes=float) cm.add_properties( ['src_num', 'trg_num'], rule=lambda s, t: [s['node_id'], t['node_id']], dtypes=[int, int] ) net.build() assert(net.nedges == 2*50) assert(net.edges_built is True) for e in net.edges(): assert(e['syn_weight'] == 0.5) assert(e['src_num'] == e.source_node_id) assert(e['trg_num'] == e.target_node_id)
def test_single_node(): net = NetworkBuilder('NET1') net.add_nodes(prop1='prop1', prop2='prop2', param1=['param1']) nodes = list(net.nodes()) assert (len(nodes) == 1) assert (nodes[0]['param1'] == 'param1') assert (nodes[0]['prop1'] == 'prop1') assert (nodes[0]['prop2'] == 'prop2')
def test_failed_search(): net = NetworkBuilder('NET1') net.add_nodes(N=100, p1='p1', q1=range(100)) node_pool = net.nodes(p1='p2') assert (len(node_pool) == 0) node_pool = net.nodes(q2=10) assert (len(node_pool) == 0)
def test_multi_search(): net = NetworkBuilder('NET1') net.add_nodes(N=10, prop_n='prop1', sp='sp1', param1=range(0, 10)) net.add_nodes(N=10, prop_n='prop1', sp='sp2', param1=range(5, 15)) net.add_nodes(N=20, prop_n='prop2', sp='sp2', param1=range(20)) node_pool = net.nodes(prop_n='prop1', param1=5) assert (len(node_pool) == 2) nodes = list(node_pool) assert (nodes[0]['node_id'] == 5) assert (nodes[1]['node_id'] == 10)
def test_connection_map(): tmp_dir = tempfile.mkdtemp() edges_file = make_tmp_file(suffix='.h5') edge_types_file = make_tmp_file(suffix='.csv') net = NetworkBuilder('test') net.add_nodes(N=10, x=range(10), model='A') net.add_nodes(N=20, x=range(10, 30), model='B') net.add_edges(source={'model': 'A'}, target={'model': 'B'}, connection_rule=1, edge_model='A') cm = net.add_edges(source={'model': 'B'}, target={'model': 'B'}, connection_rule=2, edge_model='B') cm.add_properties(names='a', rule=5, dtypes=int) cm = net.add_edges(source={'model': 'B'}, target={'x': 0}, connection_rule=3, edge_model='C') cm.add_properties(names='b', rule=0.5, dtypes=float) cm.add_properties(names='c', rule=lambda *_: 2, dtypes=int) net.build() net.save_edges( edges_file_name=edges_file, edge_types_file_name=edge_types_file, output_dir=tmp_dir, name='test_test' ) edges_h5_path = os.path.join(tmp_dir, edges_file) assert(os.path.exists(edges_h5_path)) with h5py.File(edges_h5_path, 'r') as h5: n_edges = 10*20*1 + 20*20*2 + 20*1*3 assert('/edges/test_test' in h5) assert(len(h5['/edges/test_test/target_node_id']) == n_edges) assert(h5['/edges/test_test/target_node_id'].attrs['node_population'] == 'test') assert(len(h5['/edges/test_test/source_node_id']) == n_edges) assert(h5['/edges/test_test/source_node_id'].attrs['node_population'] == 'test') assert(len(h5['/edges/test_test/edge_type_id']) == n_edges) assert(len(h5['/edges/test_test/edge_group_id']) == n_edges) assert(len(h5['/edges/test_test/edge_group_index']) == n_edges) assert(len(np.unique(h5['/edges/test_test/edge_type_id'])) == 3) assert(len(np.unique(h5['/edges/test_test/edge_group_id'])) == 3) for grp_id, grp in h5['/edges/test_test'].items(): if not isinstance(grp, h5py.Group) or grp_id in ['indicies', 'indices']: continue assert(int('nsyns' in grp) + int('a' in grp) + int('c' in grp and 'c' in grp) == 1) edge_type_csv_path = os.path.join(tmp_dir, edge_types_file) assert(os.path.exists(edge_type_csv_path)) edge_types_df = pd.read_csv(edge_type_csv_path, sep=' ') assert(len(edge_types_df) == 3) assert('edge_type_id' in edge_types_df.columns) assert('edge_model' in edge_types_df.columns) barrier()
def test_nsyn_edges(): net = NetworkBuilder('NET1') net.add_nodes(N=100, cell_type='Scnna1', ei='e') net.add_nodes(N=100, cell_type='PV1', ei='i') net.add_nodes(N=100, cell_type='PV2', ei='i') net.add_edges(source={'ei': 'i'}, target={'ei': 'e'}, connection_rule=lambda s, t: 1) # 200*100 = 20000 edges net.add_edges(source=net.nodes(cell_type='Scnna1'), target=net.nodes(cell_type='PV1'), connection_rule=lambda s, t: 2) # 100*100*2 = 20000 net.build() assert(net.nedges == 20000 + 20000) assert(net.edges_built is True)
def test_build_nodes1(): net = NetworkBuilder('NET1') net.add_nodes(N=3, node_id=[100, 200, 300], node_type_id=101, name=['one', 'two', 'three']) node_one = list(net.nodes(name='one'))[0] assert(node_one['name'] == 'one') assert(node_one['node_id'] == 100) assert(node_one['node_type_id'] == 101) node_three = list(net.nodes(name='three'))[0] assert(node_three['name'] == 'three') assert(node_three['node_id'] == 300) assert(node_three['node_type_id'] == 101)
def test_add_nodes_ids(): # Special case if parameters node_id and node_type_id are explicitly defined by the user net = NetworkBuilder('V1') net.add_nodes(N=3, node_id=[100, 200, 300], node_type_id=101, name=['one', 'two', 'three']) node_one = list(net.nodes(name='one'))[0] assert(node_one['name'] == 'one') assert(node_one['node_id'] == 100) assert(node_one['node_type_id'] == 101) node_three = list(net.nodes(name='three'))[0] assert(node_three['name'] == 'three') assert(node_three['node_id'] == 300) assert(node_three['node_type_id'] == 101)
def test_node_set(): net = NetworkBuilder('NET1') net.add_nodes(N=100, prop1='prop1', param1=range(100)) node_pool = net.nodes() assert (node_pool.filter_str == '*') nodes = list(node_pool) assert (len(nodes) == 100) assert (nodes[0]['prop1'] == 'prop1') assert (nodes[0]['param1'] == 0) assert (nodes[99]['prop1'] == 'prop1') assert (nodes[99]['param1'] == 99) assert (nodes[0]['node_type_id'] == nodes[99]['node_type_id']) assert (nodes[0]['node_id'] != nodes[99]['node_id'])
def test_cross_pop_edges(): # Uses connection map functionality to create edges with unique parameters net1 = NetworkBuilder('V1') net1.add_nodes(N=10, arg_list=range(10), arg_ctype='e') net1.build() net2 = NetworkBuilder('V2') net2.add_nodes(N=5, arg_list=range(10, 15), arg_ctype='i') net2.add_edges(source={'arg_ctype': 'i'}, target=net1.nodes(arg_ctype='e'), connection_rule=lambda s, t: 1, edge_arg='i2e') net2.build() assert(net2.nedges == 50)
def test_add_nodes_tuples(): # Should be able to store tuples of values in single parameters for a given node net = NetworkBuilder('V1') net.add_nodes(N=10, arg_list=range(10), arg_tuples=[(r, r+1) for r in range(10)], arg_const=('a', 'b')) net.build() assert(net.nodes_built is True) assert(net.nnodes == 10) for node in net.nodes(): assert(len(node['arg_tuples']) == 2) assert(node['arg_tuples'][0] == node['arg_list'] and node['arg_tuples'][1] == node['arg_list']+1) assert(len(node['arg_const']) == 2) assert(node['arg_const'][0] == 'a' and node['arg_const'][1] == 'b')
def test_edge_models(): tmp_dir = tempfile.mkdtemp() edges_file = make_tmp_file(suffix='.h5') edge_types_file = make_tmp_file(suffix='.csv') net = NetworkBuilder('test') net.add_nodes(N=100, x=range(100), model='A') net.add_nodes(N=100, x=range(100, 200), model='B') net.add_edges(source={'model': 'A'}, target={'model': 'B'}, connection_rule=1, model='A') net.add_edges(source={'model': 'A'}, target={'x': 0}, connection_rule=2, model='B') net.add_edges(source={'model': 'A'}, target={'x': [1, 2, 3]}, connection_rule=3, model='C') net.add_edges(source={'model': 'A', 'x': 0}, target={'model': 'B', 'x': 100}, connection_rule=4, model='D') net.build() net.save_edges( edges_file_name=edges_file, edge_types_file_name=edge_types_file, output_dir=tmp_dir, name='test_test' ) edges_h5_path = os.path.join(tmp_dir, edges_file) assert(os.path.exists(edges_h5_path)) with h5py.File(edges_h5_path, 'r') as h5: n_edges = 100*100 + 100*1 + 100*3 + 1 assert('/edges/test_test' in h5) assert(len(h5['/edges/test_test/target_node_id']) == n_edges) assert(h5['/edges/test_test/target_node_id'].attrs['node_population'] == 'test') assert(len(h5['/edges/test_test/source_node_id']) == n_edges) assert(h5['/edges/test_test/source_node_id'].attrs['node_population'] == 'test') assert(len(h5['/edges/test_test/edge_type_id']) == n_edges) assert(len(h5['/edges/test_test/edge_group_id']) == n_edges) assert(len(h5['/edges/test_test/edge_group_index']) == n_edges) assert(len(np.unique(h5['/edges/test_test/edge_type_id'])) == 4) assert(len(np.unique(h5['/edges/test_test/edge_group_id'])) == 1) grp_id = str(h5['/edges/test_test/edge_group_id'][0]) assert(len(h5['/edges/test_test'][grp_id]['nsyns']) == n_edges) edge_type_csv_path = os.path.join(tmp_dir, edge_types_file) assert(os.path.exists(edge_type_csv_path)) edge_types_df = pd.read_csv(edge_type_csv_path, sep=' ') assert(len(edge_types_df) == 4) assert('edge_type_id' in edge_types_df.columns) assert('model' in edge_types_df.columns) barrier()
def test_mulitnet_iterator(): net1 = NetworkBuilder('NET1') net1.add_nodes(N=50, cell_type='Rorb', ei='e') net1.build() net2 = NetworkBuilder('NET2') net2.add_nodes(N=100, cell_type='Scnna1', ei='e') net2.add_nodes(N=100, cell_type='PV1', ei='i') net2.add_edges(source={'ei': 'e'}, target={'ei': 'i'}, connection_rule=5, syn_type='e2i', net_type='rec') net2.add_edges(source=net1.nodes(), target={'ei': 'e'}, connection_rule=1, syn_type='e2e', net_type='fwd') net2.build() assert (len(net2.edges()) == 50 * 100 + 100 * 100) assert (len(net2.edges(source_network='NET2', target_network='NET1')) == 0) assert (len(net2.edges(source_network='NET1', target_network='NET2')) == 50 * 100) assert (len(net2.edges(target_network='NET2', net_type='rec')) == 100 * 100) edges = net2.edges(source_network='NET1') assert (len(edges) == 50 * 100) for e in edges: assert (e['net_type'] == 'fwd')
def test_add_nodes(): # Tests that mutliple models of nodes can be added to network net = NetworkBuilder('V1') net.add_nodes(N=10, arg_list=range(10), arg_const='pop1', arg_shared='global') net.add_nodes(N=1, arg_list=[11], arg_const='pop2', arg_shared='global') net.add_nodes(N=5, arg_unique=range(12, 17), arg_const='pop3', arg_shared='global') # diff param signature net.build() assert(net.nodes_built is True) assert(net.nnodes == 16) assert(net.nedges == 0) assert(len(net.nodes()) == 16) assert(len(net.nodes(arg_const='pop1')) == 10) assert(len(net.nodes(arg_const='pop2')) == 1) assert(len(net.nodes(arg_shared='global')) == 16) assert(len(net.nodes(arg_shared='invalid')) == 0) node_set = net.nodes(arg_list=2) assert(len(node_set) == 1) node = list(node_set)[0] assert(node['arg_const'] == 'pop1') assert(node['arg_shared'] == 'global') node_set = net.nodes(arg_unique=12) assert(len(node_set) == 1) node = list(node_set)[0] assert(node['arg_const'] == 'pop3') assert(node['arg_shared'] == 'global') assert('arg_list' not in node)
def test_save_weights(): net = NetworkBuilder('NET1') net.add_nodes(N=100, position=[(0.0, 1.0, -1.0)]*100, cell_type='Scnna1', ei='e') net.add_nodes(N=100, position=[(0.0, 1.0, -1.0)]*100, cell_type='PV1', ei='i') net.add_nodes(N=100, position=[(0.0, 1.0, -1.0)]*100, tags=np.linspace(0, 100, 100), cell_type='PV2', ei='i') cm = net.add_edges(source={'ei': 'i'}, target={'ei': 'e'}, connection_rule=lambda s, t: 3, p1='e2i', p2='e2i') # 200*100 = 60000 edges cm.add_properties(names=['segment', 'distance'], rule=lambda s, t: [1, 0.5], dtypes=[np.int, np.float]) net.add_edges(source=net.nodes(cell_type='Scnna1'), target=net.nodes(cell_type='PV1'), connection_rule=lambda s, t: 2, p1='s2p') # 100*100 = 20000' net.build() net_dir = tempfile.mkdtemp() net.save_nodes('tmp_nodes.h5', 'tmp_node_types.csv', output_dir=net_dir) net.save_edges('tmp_edges.h5', 'tmp_edge_types.csv', output_dir=net_dir) edges_h5 = h5py.File('{}/tmp_edges.h5'.format(net_dir), 'r') assert(net.nedges == 80000) assert(len(edges_h5['/edges/NET1_to_NET1/0/distance']) == 60000) assert(len(edges_h5['/edges/NET1_to_NET1/0/segment']) == 60000) assert(len(edges_h5['/edges/NET1_to_NET1/1/nsyns']) == 10000) assert(edges_h5['/edges/NET1_to_NET1/0/distance'][0] == 0.5) assert(edges_h5['/edges/NET1_to_NET1/0/segment'][0] == 1) assert(edges_h5['/edges/NET1_to_NET1/1/nsyns'][0] == 2)
def test_itr_basic(): net = NetworkBuilder('NET1') net.add_nodes(N=100, position=[(0.0, 1.0, -1.0)] * 100, cell_type='Scnna1', ei='e') net.add_nodes(N=100, position=[(0.0, 1.0, -1.0)] * 100, cell_type='PV1', ei='i') net.add_edges(source={'ei': 'e'}, target={'ei': 'i'}, connection_rule=5, syn_type='e2i') net.add_edges(source={'cell_type': 'PV1'}, target={'cell_type': 'Scnna1'}, connection_rule=5, syn_type='i2e') net.build() edges = net.edges() assert (len(edges) == 100 * 100 * 2) assert (edges[0]['nsyns'] == 5)
def build_source_network(target_net): input_network_model = { 'external': { 'N': 1, 'ei': 'e', 'pop_name': 'input_network', 'model_type': 'virtual' } } inputNetwork = NetworkBuilder("external") inputNetwork.add_nodes(**input_network_model['external']) inputNetwork.add_edges(target=target_net.nodes(pop_name='LIF_exc'), connection_rule=random_connections, connection_params={'p': 0.1}, syn_weight=400, delay=D, dynamics_params='ExcToExc.json', model_template='static_synapse') inputNetwork.add_edges(target=target_net.nodes(pop_name='LIF_inh'), connection_rule=random_connections, connection_params={'p': 0.1}, syn_weight=400, delay=D, dynamics_params='ExcToExc.json', model_template='static_synapse') inputNetwork.build() net.save(output_dir='network') #inputNetwork.save_nodes(nodes_file_name='one_input_node.h5', node_types_file_name='one_input_node_type.csv', # output_dir='lif_network') #inputNetwork.save_edges(edges_file_name='one_input_edges.h5', edge_types_file_name='one_input_edge_type.csv', # output_dir='lif_network') return inputNetwork
def test_multi_node_models(): tmp_dir = make_tmp_dir() nodes_file = make_tmp_file(suffix='.h5') node_types_file = make_tmp_file(suffix='.csv') net = NetworkBuilder('test') net.add_nodes(N=10, x=np.arange(10), common=range(10), model='A', p='X') net.add_nodes(N=10, x=np.arange(10), common=range(10), model='B') net.add_nodes(N=20, y=np.arange(20), common=range(20), model='C', p='X') net.add_nodes(N=20, y=np.arange(20), common=range(20), model='D') net.add_nodes(N=30, z=np.arange(30), common=range(30), model='E') net.build() net.save_nodes( nodes_file_name=nodes_file, node_types_file_name=node_types_file, output_dir=tmp_dir ) nodes_h5_path = os.path.join(tmp_dir, nodes_file) assert(os.path.exists(nodes_h5_path)) with h5py.File(nodes_h5_path, 'r') as h5: assert('/nodes/test' in h5) assert(len(h5['/nodes/test/node_id']) == 90) assert(len(h5['/nodes/test/node_type_id']) == 90) assert(len(np.unique(h5['/nodes/test/node_type_id'])) == 5) assert(len(h5['/nodes/test/node_group_id']) == 90) assert(len(np.unique(h5['/nodes/test/node_group_id'])) == 3) assert(len(h5['/nodes/test/node_group_index']) == 90) for grp_id, grp in h5['/nodes/test'].items(): if not isinstance(grp, h5py.Group): continue assert('common' in grp) assert(int('x' in grp) + int('y' in grp) + int('z' in grp) == 1) node_types_csv_path = os.path.join(tmp_dir, node_types_file) assert (os.path.exists(node_types_csv_path)) node_types_df = pd.read_csv(node_types_csv_path, sep=' ') assert(len(node_types_df) == 5) assert('node_type_id' in node_types_df.columns) assert('model' in node_types_df.columns) assert('p' in node_types_df.columns) barrier()
def test_add_node_ids_mixed(): net = NetworkBuilder('V1') net.add_nodes(N=3, node_id=[0, 2, 4], vals=[0, 2, 4]) net.add_nodes(N=3, vals=[1, 1, 1]) net.add_nodes(nodes_ids=[6], vals=[6]) unique_ids = set() for n in net.nodes(): unique_ids.add(n.node_id) if n.node_id % 2 == 0: assert(n['vals'] == n.node_id) else: assert(n['vals'] == 1) assert(len(unique_ids) == 7)
def test_itr_advanced_search(): net = NetworkBuilder('NET1') net.add_nodes(N=1, cell_type='Scnna1', ei='e') net.add_nodes(N=50, cell_type='PV1', ei='i') net.add_nodes(N=100, cell_type='PV2', ei='i') net.add_edges(source={'ei': 'e'}, target={'ei': 'i'}, connection_rule=5, syn_type='e2i', nm='A') net.add_edges(source={'cell_type': 'PV1'}, target={'cell_type': 'PV2'}, connection_rule=5, syn_type='i2i', nm='B') net.add_edges(source={'cell_type': 'PV2'}, target={'ei': 'i'}, connection_rule=5, syn_type='i2i', nm='C') net.build() edges = net.edges(target_nodes=net.nodes(cell_type='Scnna1')) assert (len(edges) == 0) edges = net.edges(source_nodes={'ei': 'e'}, target_nodes={'ei': 'i'}) assert (len(edges) == 50 + 100) edges = net.edges(source_nodes=[n.node_id for n in net.nodes(ei='e')]) assert (len(edges) == 50 + 100) edges = net.edges(source_nodes={'ei': 'i'}) assert (len(edges) == 100 * 100 * 2) for e in edges: assert (e['syn_type'] == 'i2i') edges = net.edges(syn_type='i2i') print len(edges) == 100 * 100 * 2 for e in edges: assert (e['nm'] != 'A') edges = net.edges(syn_type='i2i', nm='C') assert (len(edges) == 100 * 150)
def test_build_nodes(): net = NetworkBuilder('NET1') net.add_nodes(N=100, position=[(100.0, -50.0, 50.0)] * 100, tunning_angle=np.linspace(0, 365.0, 100, endpoint=False), cell_type='Scnna1', model_type='Biophys1', location='V1', ei='e') net.add_nodes(N=25, position=np.random.rand(25, 3) * [100.0, 50.0, 100.0], model_type='intfire1', location='V1', ei='e') net.add_nodes(N=150, position=np.random.rand(150, 3) * [100.0, 50.0, 100.0], tunning_angle=np.linspace(0, 365.0, 150, endpoint=False), cell_type='SST', model_type='Biophys1', location='V1', ei='i') net.build() assert (net.nodes_built is True) assert (net.nnodes == 275) assert (net.nedges == 0) assert (len(net.nodes()) == 275) assert (len(net.nodes(ei='e')) == 125) assert (len(net.nodes(model_type='Biophys1')) == 250) assert (len(net.nodes(location='V1', model_type='Biophys1'))) intfire_nodes = list(net.nodes(model_type='intfire1')) assert (len(intfire_nodes) == 25) node1 = intfire_nodes[0] assert (node1['model_type'] == 'intfire1' and 'cell_type' not in node1)
from bmtk.builder import NetworkBuilder net = NetworkBuilder('brunel') net.add_nodes(pop_name='excitatory', ei='e', model_type='population', model_template='dipde:Internal', dynamics_params='exc_model.json') net.add_nodes(pop_name='inhibitory', ei='i', model_type='population', model_template='dipde:Internal', dynamics_params='inh_model.json') net.add_edges(source={'ei': 'e'}, target={'ei': 'i'}, syn_weight=0.005, nsyns=20, delay=0.002, dynamics_params='ExcToInh.json') net.add_edges(source={'ei': 'i'}, target={'ei': 'e'}, syn_weight=-0.002, nsyns=10, delay=0.002, dynamics_params='InhToExc.json') net.build() net.save_nodes(nodes_file_name='brunel_nodes.h5', node_types_file_name='brunel_node_types.csv', output_dir='network') net.save_edges(edges_file_name='brunel_edges.h5', edge_types_file_name='brunel_edge_types.csv', output_dir='network')
syn = synapses.syn_params_dicts() # Initialize our network net = NetworkBuilder("biophysical") num_inh = [1] num_exc = [1] ################################################################################## ###################################BIOPHY######################################### net.add_nodes(N=5, pop_name='PyrA', mem_potential='e', model_type='biophysical', model_template='hoc:feng_typeA', morphology=None) net.add_nodes(N=3, pop_name='PyrC', mem_potential='e', model_type='biophysical', model_template='hoc:feng_typeC', morphology=None) net.add_nodes(N=2, pop_name='OLM', mem_potential='e', model_type='biophysical', model_template='hoc:SOM_Cell', morphology=None)
# else: # raise Exception("no work" + str(sys.argv[-1])) N = 1#int(inp) np.random.seed(2129) #np.random.seed(42) # synapses.load() # syn = synapses.syn_params_dicts() net = NetworkBuilder("biophysical") net.add_nodes(N=N, pop_name='Pyrc', potental='exc', model_type='biophysical', model_template='hoc:L5PCtemplate', morphology = None) # exc_stim = NetworkBuilder('exc_stim') # exc_stim.add_nodes(N=1, # pop_name='exc_stim', # potential='exc', # model_type='virtual') # # Create connections between Exc --> Pyr cells # net.add_edges(source=exc_stim.nodes(), target=net.nodes(), # connection_rule=1, # syn_weight=1, # target_sections=['apic', 'dend'],