bmtool 0.5.1__py3-none-any.whl → 0.5.3__py3-none-any.whl

bmtool/graphs.py

@@ -0,0 +1,170 @@
+import networkx as nx
+import plotly.graph_objects as go
+import pandas as pd
+import bmtool.util.util as u
+import pandas as pd
+
+
+def generate_graph(config,source,target):
+    """
+    returns a graph object
+    config: A BMTK simulation config 
+    source: network name 
+    target: network name
+    """
+    nodes,edges = u.load_nodes_edges_from_config(config)
+    nodes_source = nodes[source]
+    nodes_target = nodes[target]
+    if source != target:
+        # Concatenate the DataFrames if source and target are different nodes
+        nodes = pd.concat([nodes_source, nodes_target])
+    else:
+        nodes = nodes[source]
+    edge_to_grap = source+"_to_"+target
+    edges = edges[edge_to_grap]
+
+    # Create an empty graph
+    G = nx.Graph()
+
+    # Add nodes to the graph with their positions and labels
+    for index, node_data in nodes.iterrows():
+        G.add_node(index, pos=(node_data['pos_x'], node_data['pos_y'], node_data['pos_z']), label=node_data['pop_name'])
+
+    # Add edges to the graph
+    for _, row in edges.iterrows():
+        G.add_edge(row['source_node_id'], row['target_node_id'])
+
+    return G
+
+
+def plot_graph(Graph=None,show_edges = False,title = None):
+    """
+    Generate an interactive plot of the network
+    Graph: A Graph object
+    show_edges: Boolean to show edges in graph plot
+    title: A string for the title of the graph
+    
+    """
+
+    # Extract node positions
+    node_positions = nx.get_node_attributes(Graph, 'pos')
+    node_x = [data[0] for data in node_positions.values()]
+    node_y = [data[1] for data in node_positions.values()]
+    node_z = [data[2] for data in node_positions.values()]
+
+    # Create edge traces
+    edge_x = []
+    edge_y = []
+    edge_z = []
+    for edge in Graph.edges():
+        x0, y0, z0 = node_positions[edge[0]]
+        x1, y1, z1 = node_positions[edge[1]]
+        edge_x.extend([x0, x1, None])
+        edge_y.extend([y0, y1, None])
+        edge_z.extend([z0, z1, None])
+
+    # Create edge trace
+    edge_trace = go.Scatter3d(
+        x=edge_x,
+        y=edge_y,
+        z=edge_z,
+        line=dict(width=1, color='#888'),
+        hoverinfo='none',
+        mode='lines',
+        opacity=0.2)
+
+    # Create node trace
+    node_trace = go.Scatter3d(
+        x=node_x,
+        y=node_y,
+        z=node_z,
+        mode='markers',
+        hoverinfo='text',
+        marker=dict(
+            showscale=True,
+            colorscale='YlGnBu',  # Adjust color scale here
+            reversescale=True,
+            color=[len(list(Graph.neighbors(node))) for node in Graph.nodes()],  # Assign color data here
+            size=5,  # Adjust the size of the nodes here
+            colorbar=dict(
+                thickness=15,
+                title='Node Connections',
+                xanchor='left',
+                titleside='right'
+            ),
+            line_width=2,
+            cmin=0,  # Adjust color scale range here
+            cmax=max([len(list(Graph.neighbors(node))) for node in Graph.nodes()])   # Adjust color scale range here
+        ))
+
+    # Define hover text for nodes
+    node_hover_text = [f'Node ID: {node_id}<br>Population Name: {node_data["label"]}<br># of Connections: {len(list(Graph.neighbors(node_id)))}' for node_id, node_data in Graph.nodes(data=True)]
+    node_trace.hovertext = node_hover_text
+
+    # Create figure
+    if show_edges:
+        graph_prop = [edge_trace,node_trace]
+    else:
+        graph_prop = [node_trace]
+
+    if title == None:
+        title = '3D plot'
+    
+    fig = go.Figure(data=graph_prop,
+                    layout=go.Layout(
+                        title=title,
+                        titlefont_size=16,
+                        showlegend=False,
+                        hovermode='closest',
+                        margin=dict(b=20, l=5, r=5, t=40),
+                        scene=dict(
+                            xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                            yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                            zaxis=dict(showgrid=False, zeroline=False, showticklabels=False)
+                        ),
+                        width=800,
+                        height=800
+                    ))
+
+    # Show figure
+    fig.show()
+
+
+def export_node_connections_to_csv(Graph, filename):
+    """
+    Generates a csv file with node type and all connections that node receives 
+    Graph: a Graph object
+    filename: A string for the name of output must end in .csv
+    """
+    # Create an empty dictionary to store the connections for each node
+    node_connections = {}
+
+    # Iterate over each node in the graph
+    for node in Graph.nodes():
+        # Initialize a dictionary to store the connections for the current node
+        connections = {}
+        node_label = Graph.nodes[node]['label']
+
+        # Iterate over each neighbor of the current node
+        for neighbor in Graph.neighbors(node):
+            # Get the label of the neighbor node
+            neighbor_label = Graph.nodes[neighbor]['label']
+
+            # Increment the connection count for the current node and neighbor label
+            connections[f'{neighbor_label} Connections'] = connections.get(f'{neighbor_label} Connections', 0) + 1
+
+        # Add the connections information for the current node to the dictionary
+        connections['Node Label'] = node_label
+        node_connections[node] = connections
+
+    # Convert the dictionary to a DataFrame
+    df = pd.DataFrame(node_connections).fillna(0).T
+
+    # Reorder columns so that 'Node Label' is the leftmost column
+    cols = df.columns.tolist()
+    cols = ['Node Label'] + [col for col in cols if col != 'Node Label']
+    df = df[cols]
+
+    # Write the DataFrame to a CSV file
+    df.to_csv(filename)
+

bmtool/singlecell.py

@@ -217,8 +217,8 @@ class Passive(CurrentClamp):
         self.v_final_time = self.t_vec[self.index_v_final]
 
         t_idx = slice(self.index_v_rest, self.index_v_final + 1)
-        self.v_vec_inj = self.v_vec.as_numpy()[t_idx].copy()
-        self.t_vec_inj = self.t_vec.as_numpy()[t_idx].copy() - self.v_rest_time
+        self.v_vec_inj = np.array(self.v_vec)[t_idx]
+        self.t_vec_inj = np.array(self.t_vec)[t_idx] - self.v_rest_time
 
         self.v_diff = self.cell_v_final - self.v_rest
         self.r_in = self.v_diff / self.inj_amp # MegaOhms
@@ -388,8 +388,8 @@ class ZAP(CurrentClamp):
         self.v_rest_time = self.t_vec[self.index_v_rest]
 
         t_idx = slice(self.index_v_rest, self.index_v_final + 1)
-        self.v_vec_inj = self.v_vec.as_numpy()[t_idx].copy() - self.v_rest
-        self.t_vec_inj = self.t_vec.as_numpy()[t_idx].copy() - self.v_rest_time
+        self.v_vec_inj = np.array(self.v_vec)[t_idx] - self.v_rest
+        self.t_vec_inj = np.array(self.t_vec)[t_idx] - self.v_rest_time
 
         self.cell_v_amp_max = np.abs(self.v_vec_inj).max()
         self.Z = np.fft.rfft(self.v_vec_inj) / np.fft.rfft(self.zap_vec_inj) # MOhms

bmtool/util/util.py

@@ -258,18 +258,20 @@ def load_nodes_from_paths(node_paths):
             for group_id in range(n_group):
                 group = nodes_grp[str(group_id)]
                 idx = node_group_id == group_id
+                group_node = node_id[idx]
+                group_index = node_group_index[idx]
                 for prop in group:
                     if prop == 'positions':
-                        positions = group[prop][node_group_index[idx]]
+                        positions = group[prop][group_index]
                         for i in range(positions.shape[1]):
                             if pos_labels[i] not in nodes_df:
                                 nodes_df[pos_labels[i]] = np.nan
-                            nodes_df.loc[node_id, pos_labels[i]] = positions[:, i]
+                            nodes_df.loc[group_node, pos_labels[i]] = positions[:, i]
                     else:
                         # create new column with NaN if property does not exist
                         if prop not in nodes_df: 
                             nodes_df[prop] = np.nan
-                        nodes_df.loc[idx, prop] = tuple(group[prop][node_group_index[idx]])
+                        nodes_df.loc[group_node, prop] = group[prop][group_index]
                         prop_dtype[prop] = group[prop].dtype
             # convert to original data type if possible
             for prop, dtype in prop_dtype.items():
@@ -566,7 +568,10 @@ def relation_matrix(config=None, nodes=None,edges=None,sources=[],targets=[],sid
                 
                         total = relation_func(source_nodes=source_nodes, target_nodes=target_nodes, edges=c_edges, source=source,sid="source_"+sids[s], target=target,tid="target_"+tids[t],source_id=s_type,target_id=t_type)
                         if synaptic_info=='0':
-                            syn_info[source_index,target_index] = total
+                            if isinstance(total, tuple):
+                                syn_info[source_index, target_index] = str(round(total[0], 1)) + '\n' + str(round(total[1], 1))
+                            else:
+                                syn_info[source_index,target_index] = total
                         elif synaptic_info=='1':
                             mean = conn_mean_func(source_nodes=source_nodes, target_nodes=target_nodes, edges=c_edges, source=source,sid="source_"+sids[s], target=target,tid="target_"+tids[t],source_id=s_type,target_id=t_type)
                             stdev = conn_stdev_func(source_nodes=source_nodes, target_nodes=target_nodes, edges=c_edges, source=source,sid="source_"+sids[s], target=target,tid="target_"+tids[t],source_id=s_type,target_id=t_type)
@@ -587,8 +592,11 @@ def relation_matrix(config=None, nodes=None,edges=None,sources=[],targets=[],sid
                                 syn_info[source_index,target_index] = ""
                             else:
                                 syn_info[source_index,target_index] = syn_list
+                        if isinstance(total, tuple):
+                            e_matrix[source_index,target_index]=total[0]
+                        else:
+                            e_matrix[source_index,target_index]=total
 
-                        e_matrix[source_index,target_index]=total
                                                 
     return syn_info, e_matrix, source_pop_names, target_pop_names
 
@@ -609,7 +617,9 @@ def connection_totals(config=None,nodes=None,edges=None,sources=[],targets=[],si
         return total
     return relation_matrix(config,nodes,edges,sources,targets,sids,tids,prepend_pop,relation_func=total_connection_relationship,synaptic_info=synaptic_info)
 
-def percent_connections(config=None,nodes=None,edges=None,sources=[],targets=[],sids=[],tids=[],prepend_pop=True,method=None,include_gap=True):
+
+def percent_connections(config=None,nodes=None,edges=None,sources=[],targets=[],sids=[],tids=[],prepend_pop=True,type='convergence',method=None,include_gap=True):
+
 
     def precent_func(**kwargs): 
         edges = kwargs["edges"]
@@ -638,8 +648,12 @@ def percent_connections(config=None,nodes=None,edges=None,sources=[],targets=[],
         num_bi = (cons_recip.count().source_node_id - cons_recip_dedup.count().source_node_id)
         num_uni = total_cons - num_bi    
 
-        num_sources = s_list.apply(pd.Series.value_counts)[source_id_type].dropna().sort_index().loc[source_id]
-        num_targets = t_list.apply(pd.Series.value_counts)[target_id_type].dropna().sort_index().loc[target_id]
+        #num_sources = s_list.apply(pd.Series.value_counts)[source_id_type].dropna().sort_index().loc[source_id]
+        #num_targets = t_list.apply(pd.Series.value_counts)[target_id_type].dropna().sort_index().loc[target_id]
+
+        num_sources = s_list[source_id_type].value_counts().sort_index().loc[source_id]
+        num_targets = t_list[target_id_type].value_counts().sort_index().loc[target_id]
+
 
         total = round(total_cons / (num_sources*num_targets) * 100,2)
         uni = round(num_uni / (num_sources*num_targets) * 100,2)
@@ -654,7 +668,8 @@ def percent_connections(config=None,nodes=None,edges=None,sources=[],targets=[],
 
     return relation_matrix(config,nodes,edges,sources,targets,sids,tids,prepend_pop,relation_func=precent_func)
 
-def connection_divergence(config=None,nodes=None,edges=None,sources=[],targets=[],sids=[],tids=[],prepend_pop=True,convergence=False,method='mean',include_gap=True):
+
+def connection_divergence(config=None,nodes=None,edges=None,sources=[],targets=[],sids=[],tids=[],prepend_pop=True,convergence=False,method='mean+std',include_gap=True):
 
     import pandas as pd
 
@@ -674,47 +689,97 @@ def connection_divergence(config=None,nodes=None,edges=None,sources=[],targets=[
 
         if convergence:
             if method == 'min':
-                count = cons.apply(pd.Series.value_counts).target_node_id.dropna().min()
-                return count
+                count = cons['target_node_id'].value_counts().min()
+                return round(count,2)
             elif method == 'max':
-                count = cons.apply(pd.Series.value_counts).target_node_id.dropna().max()
-                return count
+                count = cons['target_node_id'].value_counts().max()
+                return round(count,2)
             elif method == 'std':
-                std = cons.apply(pd.Series.value_counts).target_node_id.dropna().std()
+                std = cons['target_node_id'].value_counts().std()
                 return round(std,2)
-            else: #mean
-                vc = t_list.apply(pd.Series.value_counts)
-                vc = vc[target_id_type].dropna().sort_index()
-                count = vc.loc[target_id]#t_list[t_list[target_id_type]==target_id]
+            elif method == 'mean': 
+                mean = cons['target_node_id'].value_counts().mean()
+                return round(mean,2)
+            elif method == 'mean+std': #default is mean + std
+                mean = cons['target_node_id'].value_counts().mean()
+                std = cons['target_node_id'].value_counts().std()
+                #std = cons.apply(pd.Series.value_counts).target_node_id.dropna().std() no longer a valid way
+                return (round(mean,2)), (round(std,2))
         else: #divergence
             if method == 'min':
-                count = cons.apply(pd.Series.value_counts).source_node_id.dropna().min()
-                return count
+                count = cons['source_node_id'].value_counts().min()
+                return round(count,2)
             elif method == 'max':
-                count = cons.apply(pd.Series.value_counts).source_node_id.dropna().max()
-                return count
+                count = cons['source_node_id'].value_counts().max()
+                return round(count,2)
             elif method == 'std':
-                std = cons.apply(pd.Series.value_counts).source_node_id.dropna().std()
+                std = cons['source_node_id'].value_counts().std()
                 return round(std,2)
-            else: #mean
-                #vc = s_list.apply(pd.Series.value_counts)[source_id_type].dropna().sort_index().loc[source_id]
-                vc = s_list.apply(pd.Series.value_counts)
-                vc = vc[source_id_type].dropna().sort_index()
-                count = vc.loc[source_id]#count = s_list[s_list[source_id_type]==source_id]
-
-        # Only executed when mean
-        total = edges[(edges[source_id_type] == source_id) & (edges[target_id_type]==target_id)]
-        if include_gap == False:
-            total = total[total['is_gap_junction'] != True]
-        total = total.count()
-        total = total.source_node_id # may not be the best way to pick
-        ret = round(total/count,1)
-        if ret == 0:
-            ret = None
-        return ret
+            elif method == 'mean': 
+                mean = cons['source_node_id'].value_counts().mean()
+                return round(mean,2)
+            elif method == 'mean+std': #default is mean + std
+                mean = cons['source_node_id'].value_counts().mean()
+                std = cons['source_node_id'].value_counts().std()
+                return (round(mean,2)), (round(std,2))
 
     return relation_matrix(config,nodes,edges,sources,targets,sids,tids,prepend_pop,relation_func=total_connection_relationship)
 
+def gap_junction_connections(config=None,nodes=None,edges=None,sources=[],targets=[],sids=[],tids=[],prepend_pop=True,type='convergence'):
+    import pandas as pd
+
+    
+    def total_connection_relationship(**kwargs): #reduced version of original function; only gets mean+std
+        edges = kwargs["edges"]
+        source_id_type = kwargs["sid"]
+        target_id_type = kwargs["tid"]
+        source_id = kwargs["source_id"]
+        target_id = kwargs["target_id"]
+
+        cons = edges[(edges[source_id_type] == source_id) & (edges[target_id_type]==target_id)] 
+        #print(cons)
+        
+        cons = cons[cons['is_gap_junction'] == True] #only gap_junctions
+        mean = cons['target_node_id'].value_counts().mean()
+        std = cons['target_node_id'].value_counts().std()
+        return (round(mean,2)), (round(std,2))
+    
+    def precent_func(**kwargs): #barely different than original function; only gets gap_junctions.
+        edges = kwargs["edges"]
+        source_id_type = kwargs["sid"]
+        target_id_type = kwargs["tid"]
+        source_id = kwargs["source_id"]
+        target_id = kwargs["target_id"]
+        t_list = kwargs["target_nodes"]
+        s_list = kwargs["source_nodes"]
+
+        cons = edges[(edges[source_id_type] == source_id) & (edges[target_id_type]==target_id)]
+        #add functionality that shows only the one's with gap_junctions
+        cons = cons[cons['is_gap_junction'] == True]
+        total_cons = cons.count().source_node_id
+
+        num_sources = s_list[source_id_type].value_counts().sort_index().loc[source_id]
+        num_targets = t_list[target_id_type].value_counts().sort_index().loc[target_id]
+
+
+        total = round(total_cons / (num_sources*num_targets) * 100,2)
+        return total
+    
+    if type == 'convergence':
+        return relation_matrix(config,nodes,edges,sources,targets,sids,tids,prepend_pop,relation_func=total_connection_relationship)
+    elif type == 'percent':
+        return relation_matrix(config,nodes,edges,sources,targets,sids,tids,prepend_pop,relation_func=precent_func)
+        
+
+def gap_junction_percent_connections(config=None,nodes=None,edges=None,sources=[],targets=[],sids=[],tids=[],prepend_pop=True,method=None):
+    import pandas as pd
+    
+        
+        
+    
+    
+        
+    
 def connection_probabilities(config=None,nodes=None,edges=None,sources=[],
     targets=[],sids=[],tids=[],prepend_pop=True,dist_X=True,dist_Y=True,dist_Z=True,num_bins=10,include_gap=True):
     
@@ -753,11 +818,11 @@ def connection_probabilities(config=None,nodes=None,edges=None,sources=[],
         def eudist(df,use_x=True,use_y=True,use_z=True):
             def _dist(x):
                 if len(x) == 6:
-                    return distance.euclidean((x[0],x[1],x[2]),(x[3],x[4],x[5]))
+                    return distance.euclidean((x.iloc[0], x.iloc[1], x.iloc[2]), (x.iloc[3], x.iloc[4], x.iloc[5]))
                 elif len(x) == 4:
-                    return distance.euclidean((x[0],x[1]),(x[2],x[3]))
+                    return distance.euclidean((x.iloc[0],x.iloc[1]),(x.iloc[2],x.iloc[3]))
                 elif len(x) == 2:
-                    return distance.euclidean((x[0]),(x[1]))
+                    return distance.euclidean((x.iloc[0]),(x.iloc[1]))
                 else:
                     return -1
 
@@ -835,6 +900,7 @@ def connection_graph_edge_types(config=None,nodes=None,edges=None,sources=[],tar
 
     return relation_matrix(config,nodes,edges,sources,targets,sids,tids,prepend_pop,relation_func=synapse_type_relationship,return_type=object)
 
+
 def edge_property_matrix(edge_property, config=None, nodes=None, edges=None, sources=[],targets=[],sids=[],tids=[],prepend_pop=True,report=None,time=-1,time_compare=None):
     
     var_report = None
@@ -906,10 +972,11 @@ def percent_connectivity(config=None,nodes=None,edges=None,sources=[],targets=[]
 
     return ret, source_labels, target_labels
     
-    
+
 def connection_average_synapses():
     return
 
+
 def connection_divergence_average_old(config=None, nodes=None, edges=None,populations=[],convergence=False):
     """
     For each cell in source count # of connections in target and average