bmtool 0.5.8__tar.gz → 0.5.9.5__tar.gz

{bmtool-0.5.8 → bmtool-0.5.9.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bmtool
-Version: 0.5.8
+Version: 0.5.9.5
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 

{bmtool-0.5.8 → bmtool-0.5.9.5}/bmtool/bmplot.py

@@ -405,6 +405,76 @@ def connection_histogram(config=None,nodes=None,edges=None,sources=[],targets=[]
         tids = []
     util.relation_matrix(config,nodes,edges,sources,targets,sids,tids,prepend_pop,relation_func=connection_pair_histogram,synaptic_info=synaptic_info)
 
+def connection_distance(config: str,source: str,target: str,
+                        source_cell_id: int,target_id_type: str) -> None:
+    """
+    Plots the 3D spatial distribution of target nodes relative to a source node
+    and a histogram of distances from the source node to each target node.
+
+    Parameters:
+    ----------
+    config: (str) A BMTK simulation config 
+    sources: (str) network name(s) to plot
+    targets: (str) network name(s) to plot
+    source_cell_id : (int) ID of the source cell for calculating distances to target nodes.
+    target_id_type : (str) A string to filter target nodes based off the target_query.
+
+    """
+    if not config:
+        raise Exception("config not defined")
+    if not source or not target:
+        raise Exception("Sources or targets not defined")
+    #if source != target:
+        #raise Exception("Code is setup for source and target to be the same! Look at source code for function to add feature")
+    
+    # Load nodes and edges based on config file
+    nodes, edges = util.load_nodes_edges_from_config(config)
+    
+    edge_network = source + "_to_" + target
+    node_network = source
+
+    # Filter edges to obtain connections originating from the source node
+    edge = edges[edge_network]
+    edge = edge[edge['source_node_id'] == source_cell_id]
+    if target_id_type:
+        edge = edge[edge['target_query'].str.contains(target_id_type, na=False)]
+
+    target_node_ids = edge['target_node_id']
+
+    # Filter nodes to obtain only the target and source nodes
+    node = nodes[node_network]
+    target_nodes = node.loc[node.index.isin(target_node_ids)]
+    source_node = node.loc[node.index == source_cell_id]
+
+    # Calculate distances between source node and each target node
+    target_positions = target_nodes[['pos_x', 'pos_y', 'pos_z']].values
+    source_position = np.array([source_node['pos_x'], source_node['pos_y'], source_node['pos_z']]).ravel()  # Ensure 1D shape
+    distances = np.linalg.norm(target_positions - source_position, axis=1)
+
+    # Plot positions of source and target nodes in 3D space
+    fig = plt.figure(figsize=(8, 6)) 
+    ax = fig.add_subplot(111, projection='3d')
+
+    ax.scatter(target_nodes['pos_x'], target_nodes['pos_y'], target_nodes['pos_z'], c='blue', label="target cells")
+    ax.scatter(source_node['pos_x'], source_node['pos_y'], source_node['pos_z'], c='red', label="source cell")
+
+    # Optional: Add text annotations for distances
+    # for i, distance in enumerate(distances):
+    #     ax.text(target_nodes['pos_x'].iloc[i], target_nodes['pos_y'].iloc[i], target_nodes['pos_z'].iloc[i],
+    #             f'{distance:.2f}', color='black', fontsize=8, ha='center')
+
+    plt.legend()
+    plt.show()
+
+    # Plot distances in a separate 2D plot
+    plt.figure(figsize=(8, 6)) 
+    plt.hist(distances, bins=20, color='blue', edgecolor='black')
+    plt.xlabel("Distance")
+    plt.ylabel("Count")
+    plt.title("Distance from Source Node to Each Target Node")
+    plt.grid(True)
+    plt.show()
+
 def edge_histogram_matrix(config=None,sources = None,targets=None,sids=None,tids=None,no_prepend_pop=None,edge_property = None,time = None,time_compare = None,report=None,title=None,save_file=None):
     """
     write about function here
@@ -480,8 +550,14 @@ def plot_connection_info(text, num, source_labels,target_labels, title, syn_info
     # Loop over data dimensions and create text annotations.
     for i in range(num_source):
         for j in range(num_target):
-            edge_info = text[i,j]
-            graph_dict[str(source_labels[i])+'2'+str(target_labels[j])] = edge_info
+            edge_info = text[i, j]
+            
+            # Initialize the dictionary for the source node if not already done
+            if source_labels[i] not in graph_dict:
+                graph_dict[source_labels[i]] = {}
+            
+            # Add edge info for the target node
+            graph_dict[source_labels[i]][target_labels[j]] = edge_info
             if syn_info =='2' or syn_info =='3':
                 if num_source > 8 and num_source <20:
                     fig_text = ax1.text(j, i, edge_info,
@@ -726,71 +802,101 @@ def plot_spikes(nodes, spikes_file,save_file=None):
     
     return
     
-def plot_3d_positions(config=None,populations_list=None,group_by=None,title=None,save_file=None):
+def plot_3d_positions(config=None, populations_list=None, group_by=None, title=None, save_file=None, subset=None):
     """
-    plots a 3D graph of all cells with x,y,z location
-    config: A BMTK simulation config 
-    populations_list: Which network(s) to plot 
-    group_by: How to name cell groups
-    title: plot title
-    save_file: If plot should be saved
+    Plots a 3D graph of all cells with x, y, z location.
+    
+    Parameters:
+    - config: A BMTK simulation config 
+    - populations_list: Which network(s) to plot 
+    - group_by: How to name cell groups
+    - title: Plot title
+    - save_file: If plot should be saved
+    - subset: Take every Nth row. This will make plotting large network graphs easier to see.
     """
     
     if not config:
         raise Exception("config not defined")
-    if populations_list == None:
+    
+    if populations_list is None:
         populations_list = "all"
+    
+    # Set group keys (e.g., node types)
     group_keys = group_by
-    if title == None:
+    if title is None:
         title = "3D positions"
 
+    # Load nodes from the configuration
     nodes = util.load_nodes_from_config(config)
     
+    # Get the list of populations to plot
     if 'all' in populations_list:
         populations = list(nodes)
     else:
         populations = populations_list.split(",")
-
+    
+    # Split group_by into list 
     group_keys = group_keys.split(",")
-    group_keys += (len(populations)-len(group_keys)) * ["node_type_id"] #Extend the array to default values if not enough given
-    fig = plt.figure(figsize=(10,10))
+    group_keys += (len(populations) - len(group_keys)) * ["node_type_id"]  # Extend the array to default values if not enough given
+    if len(group_keys) > 1:
+        raise Exception("Only one group by is supported currently!")
+    
+    fig = plt.figure(figsize=(10, 10))
     ax = fig.add_subplot(projection='3d')
     handles = []
-    for nodes_key,group_key in zip(list(nodes),group_keys):
-        if 'all' not in populations and nodes_key not in populations:
-            continue
-            
-        nodes_df = nodes[nodes_key]
 
+    for pop in (list(nodes)):
+        
+        if 'all' not in populations and pop not in populations:
+            continue
+        
+        nodes_df = nodes[pop]
+        group_key = group_keys[0] 
+        
+        # If group_key is provided, ensure the column exists in the dataframe
         if group_key is not None:
             if group_key not in nodes_df:
-                raise Exception('Could not find column {}'.format(group_key))
+                raise Exception(f"Could not find column '{group_key}' in {pop}")
+            
             groupings = nodes_df.groupby(group_key)
-
             n_colors = nodes_df[group_key].nunique()
-            color_norm = colors.Normalize(vmin=0, vmax=(n_colors-1))
+            color_norm = colors.Normalize(vmin=0, vmax=(n_colors - 1))
             scalar_map = cmx.ScalarMappable(norm=color_norm, cmap='hsv')
-            color_map = [scalar_map.to_rgba(i) for i in range(0, n_colors)]
+            color_map = [scalar_map.to_rgba(i) for i in range(n_colors)]
         else:
             groupings = [(None, nodes_df)]
             color_map = ['blue']
 
+        # Loop over groupings and plot
         for color, (group_name, group_df) in zip(color_map, groupings):
-            if "pos_x" not in group_df: #could also check model type == virtual
-                continue #can't plot them if there isn't an xy coordinate (may be virtual)
-            h = ax.scatter(group_df["pos_x"],group_df["pos_y"],group_df["pos_z"],color=color,label=group_name)
+            if "pos_x" not in group_df or "pos_y" not in group_df or "pos_z" not in group_df:
+                print(f"Warning: Missing position columns in group '{group_name}' for {pop}. Skipping this group.")
+                continue  # Skip if position columns are missing
+
+            # Subset the dataframe by taking every Nth row if subset is provided
+            if subset is not None:
+                group_df = group_df.iloc[::subset]
+
+            h = ax.scatter(group_df["pos_x"], group_df["pos_y"], group_df["pos_z"], color=color, label=group_name)
             handles.append(h)
+    
     if not handles:
+        print("No data to plot.")
         return
+    
+    # Set plot title and legend
     plt.title(title)
     plt.legend(handles=handles)
     
+    # Draw the plot
     plt.draw()
 
+    # Save the plot if save_file is provided
     if save_file:
         plt.savefig(save_file)
-    notebook = is_notebook
-    if notebook == False:
+
+    # Show the plot if running outside of a notebook
+    if not is_notebook:
         plt.show()
 
     return

{bmtool-0.5.8 → bmtool-0.5.9.5}/bmtool/connectors.py

@@ -580,9 +580,11 @@ class ReciprocalConnector(AbstractConnector):
         self.source = source
         self.target = target
         if self.source is None or len(self.source) == 0:
-            raise ValueError("Source nodes do not exists")
+            src_str, trg_str = self.get_nodes_info()
+            raise ValueError(f"{src_str} nodes do not exists")
         if self.target is None or len(self.target) == 0:
-            raise ValueError("Target nodes do not exists")
+            src_str, trg_str = self.get_nodes_info()
+            raise ValueError(f"{trg_str} nodes do not exists")
 
         # Setup nodes
         self.recurrent = is_same_pop(self.source, self.target, quick=self.quick)
@@ -1130,9 +1132,11 @@ class UnidirectionConnector(AbstractConnector):
         self.source = source
         self.target = target
         if self.source is None or len(self.source) == 0:
-            raise ValueError("Source nodes do not exists")
+            src_str, trg_str = self.get_nodes_info()
+            raise ValueError(f"{src_str} nodes do not exists")
         if self.target is None or len(self.target) == 0:
-            raise ValueError("Target nodes do not exists")
+            src_str, trg_str = self.get_nodes_info()
+            raise ValueError(f"{trg_str} nodes do not exists")
         self.n_pair = len(self.source) * len(self.target)
 
     def edge_params(self):
@@ -1179,6 +1183,7 @@ class UnidirectionConnector(AbstractConnector):
                       + src_str + "\n  to " + trg_str,flush=True)
 
         # Make random connections
+
         p_arg = self.p_arg(source, target)
         p = self.p(p_arg)
         possible = p > 0
@@ -1274,8 +1279,9 @@ class GapJunction(UnidirectionConnector):
     def setup_nodes(self, source=None, target=None):
         super().setup_nodes(source=source, target=target)
         if len(self.source) != len(self.target):
-            raise ValueError("Source and target must be the same for "
-                             "gap junction.")
+            src_str, trg_str = self.get_nodes_info()
+            raise ValueError(f"Source and target must be the same for "
+                             f"gap junction. Nodes are {src_str} and {trg_str}")
         self.n_source = len(self.source)
 
     def make_connection(self, source, target, *args, **kwargs):
@@ -1500,8 +1506,9 @@ class OneToOneSequentialConnector(AbstractConnector):
             source, target = target, source
         if self.target_count == 0:
             if source is None or len(source) == 0:
-                raise ValueError(("Target" if self.partition_source else
-                                  "Source") + " nodes do not exists")
+                src_str, trg_str = self.get_nodes_info()
+                raise ValueError((f"{trg_str}" if self.partition_source else
+                                  f"{src_str}") + " nodes do not exists")
             self.source = source
             self.n_source = len(source)
         if target is None or len(target) == 0:

{bmtool-0.5.8 → bmtool-0.5.9.5}/bmtool.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bmtool
-Version: 0.5.8
+Version: 0.5.9.5
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 

{bmtool-0.5.8 → bmtool-0.5.9.5}/setup.py

@@ -6,7 +6,7 @@ with open("README.md", "r") as fh:
 
 setup(
     name="bmtool",
-    version='0.5.8',
+    version='0.5.9.5',
     author="Neural Engineering Laboratory at the University of Missouri",
     author_email="gregglickert@mail.missouri.edu",
     description="BMTool",