bmtool 0.5.3__tar.gz → 0.5.4__tar.gz

{bmtool-0.5.3 → bmtool-0.5.4}/PKG-INFO

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

{bmtool-0.5.3 → bmtool-0.5.4}/bmtool/bmplot.py

@@ -367,10 +367,15 @@ def connection_histogram(config=None,nodes=None,edges=None,sources=[],targets=[]
             if include_gap == False:
                 temp = temp[temp['is_gap_junction'] != True]
             node_pairs = temp.groupby('target_node_id')['source_node_id'].count()
-            conn_mean = statistics.mean(node_pairs.values)
-            conn_std = statistics.stdev(node_pairs.values)
-            conn_median = statistics.median(node_pairs.values)
-            label = "mean {:.2f} std ({:.2f}) median {:.2f}".format(conn_mean,conn_std,conn_median)
+            try:
+                conn_mean = statistics.mean(node_pairs.values)
+                conn_std = statistics.stdev(node_pairs.values)
+                conn_median = statistics.median(node_pairs.values)
+                label = "mean {:.2f} std ({:.2f}) median {:.2f}".format(conn_mean,conn_std,conn_median)
+            except: # lazy fix for std not calculated with 1 node
+                conn_mean = statistics.mean(node_pairs.values)
+                conn_median = statistics.median(node_pairs.values)
+                label = "mean {:.2f} median {:.2f}".format(conn_mean,conn_median)
             plt.hist(node_pairs.values,density=True,bins='auto',stacked=True,label=label)
             plt.legend()
             plt.xlabel("# of conns from {} to {}".format(source_cell,target_cell))
@@ -495,6 +500,89 @@ def plot_connection_info(text, num, source_labels,target_labels, title, syn_info
         plt.savefig(save_file)
     return
 
+def connector_percent_matrix(csv_path = None):
+    """
+    useful because can display percent connectivity factoring in distance easily 
+    Generates a connection matrix from the output of bmtool.connector
+    csv: An output csv from the bmtool.connector classes see function save_connection_report() in that module
+    returns: connection matrix plot
+    """
+    # Read the CSV data
+    df = pd.read_csv(csv_path)
+
+    # Choose the column to display
+    selected_column = "Fraction of connected pairs in possible ones (%)"  # Change this to the desired column name
+
+    # Create an empty dictionary to store connection percentages
+    connection_data = {}
+
+    # Iterate over each row in the DataFrame
+    for index, row in df.iterrows():
+        source = row['Source']
+        target = row['Target']
+        selected_percentage = row[selected_column]
+        
+        # If the selected percentage is an array-like string, extract the first and second values
+        if isinstance(selected_percentage, str):
+            selected_percentage = selected_percentage.strip('[]').split()
+            selected_percentage = [float(p) for p in selected_percentage]  # Convert to float
+        
+        # Store the selected percentage(s) for the source-target pair
+        connection_data[(source, target)] = selected_percentage
+
+    # Prepare unique populations and create an empty matrix
+    populations = sorted(list(set(df['Source'].unique()) | set(df['Target'].unique())))
+    num_populations = len(populations)
+    connection_matrix = np.zeros((num_populations, num_populations), dtype=float)
+
+    # Populate the matrix with the selected connection percentages
+    for source, target in connection_data.keys():
+        source_idx = populations.index(source)
+        target_idx = populations.index(target)
+        connection_probabilities = connection_data[(source, target)]
+        
+        # Use the first value for one-way connection from source to target
+        connection_matrix[source_idx][target_idx] = connection_probabilities[0]
+
+        # Check if the source and target are the same population
+        if source == target:
+            # Use the first value (uni-directional) and ignore the second value (bi-directional)
+            continue
+
+        # Check if there is a bidirectional connection and use the second value
+        if len(connection_probabilities) > 1:
+            connection_matrix[target_idx][source_idx] = connection_probabilities[1]
+
+    # Replace NaN values with 0
+    connection_matrix[np.isnan(connection_matrix)] = 0
+
+    # Plot the matrix
+    fig, ax = plt.subplots(figsize=(10, 8))
+    im = ax.imshow(connection_matrix, cmap='viridis', interpolation='nearest')
+
+    # Add annotations
+    for i in range(num_populations):
+        for j in range(num_populations):
+            text = ax.text(j, i, f"{connection_matrix[i, j]:.2f}%",
+                        ha="center", va="center", color="w", size=10, weight='bold')
+
+    # Add colorbar
+    plt.colorbar(im, label=f'Percentage of connected pairs ({selected_column})')
+
+    # Set title and axis labels
+    ax.set_title('Neuronal Connection Matrix')
+    ax.set_xlabel('Target Population')
+    ax.set_ylabel('Source Population')
+
+    # Set ticks and labels
+    ax.set_xticks(np.arange(num_populations))
+    ax.set_yticks(np.arange(num_populations))
+    ax.set_xticklabels(populations, rotation=45, ha="right", size=12, weight='semibold')
+    ax.set_yticklabels(populations, size=12, weight='semibold')
+
+    plt.tight_layout()
+    plt.show()
+
 def raster_old(config=None,title=None,populations=['hippocampus']):
     """
     old function probs dep

{bmtool-0.5.3 → bmtool-0.5.4}/bmtool/connectors.py

@@ -5,6 +5,8 @@ from scipy.optimize import minimize_scalar
 from functools import partial
 import time
 import types
+import pandas as pd
+import re
 
 rng = np.random.default_rng()
 
@@ -532,7 +534,7 @@ class ReciprocalConnector(AbstractConnector):
                  pr=0., pr_arg=None, estimate_rho=True, rho=None,
                  dist_range_forward=None, dist_range_backward=None,
                  n_syn0=1, n_syn1=1, autapses=False,
-                 quick_pop_check=False, cache_data=True, verbose=True):
+                 quick_pop_check=False, cache_data=True, verbose=True,save_report=True):
         args = locals()
         var_set = ('p0', 'p0_arg', 'p1', 'p1_arg',
                    'pr', 'pr_arg', 'n_syn0', 'n_syn1')
@@ -550,6 +552,7 @@ class ReciprocalConnector(AbstractConnector):
         self.quick = quick_pop_check
         self.cache = self.ConnectorCache(cache_data and self.estimate_rho)
         self.verbose = verbose
+        self.save_report = save_report
 
         self.conn_prop = [{}, {}]
         self.stage = 0
@@ -947,6 +950,8 @@ class ReciprocalConnector(AbstractConnector):
             if self.wrong_pr:
                 print("Warning: Value of 'pr' outside the bounds occurred.\n")
             self.connection_number_info()
+        if self.save_report:
+            self.save_connection_report()
 
     def make_connection(self):
         """ Assign number of synapses per iteration.
@@ -1042,6 +1047,31 @@ class ReciprocalConnector(AbstractConnector):
         print("Fraction of connected pairs in all pairs: (%s)\n"
               % arr2str(100 * fraction[1], '%.2f%%'))
 
+    def save_connection_report(self):
+        """Save connections into a CSV file to be read from later"""
+        src_str, trg_str = self.get_nodes_info()
+        n_conn, n_poss, n_pair, fraction = self.connection_number()
+
+        # Extract the population name from source_str and target_str
+        data = {
+            "Source": [src_str],
+            "Target": [trg_str],
+            "Fraction of connected pairs in possible ones (%)": [fraction[0]*100],
+            "Fraction of connected pairs in all pairs (%)": [fraction[1]*100]
+        }
+        df = pd.DataFrame(data)
+        
+        # Append the data to the CSV file
+        try:
+            # Check if the file exists by trying to read it
+            existing_df = pd.read_csv('connection_report.csv')
+            # If no exception is raised, append without header
+            df.to_csv('connection_report.csv', mode='a', header=False, index=False)
+        except FileNotFoundError:
+            # If the file does not exist, write with header
+            df.to_csv('connection_report.csv', mode='w', header=True, index=False)
+            
+
 
 class UnidirectionConnector(AbstractConnector):
     """
@@ -1074,12 +1104,13 @@ class UnidirectionConnector(AbstractConnector):
             This is useful in similar manner as in ReciprocalConnector.
     """
 
-    def __init__(self, p=1., p_arg=None, n_syn=1, verbose=True):
+    def __init__(self, p=1., p_arg=None, n_syn=1, verbose=True,save_report=True):
         args = locals()
         var_set = ('p', 'p_arg', 'n_syn')
         self.vars = {key: args[key] for key in var_set}
 
         self.verbose = verbose
+        self.save_report = save_report
         self.conn_prop = {}
         self.iter_count = 0
 
@@ -1157,6 +1188,9 @@ class UnidirectionConnector(AbstractConnector):
             if self.verbose:
                 self.connection_number_info()
                 self.timer.report('Done! \nTime for building connections')
+            if self.save_report:
+                self.save_connection_report()
+
         return nsyns
 
     # *** Helper functions for verbose ***
@@ -1175,6 +1209,32 @@ class UnidirectionConnector(AbstractConnector):
         print("Number of total pairs: %d" % self.n_pair)
         print("Fraction of connected pairs in all pairs: %.2f%%\n"
               % (100. * self.n_conn / self.n_pair))
+    
+    def save_connection_report(self):
+        """Save connections into a CSV file to be read from later"""
+        src_str, trg_str = self.get_nodes_info()
+        n_pair = self.n_pair
+        fraction_0 = self.n_conn / self.n_poss if self.n_poss else 0.
+        fraction_1 = self.n_conn / self.n_pair
+
+        # Convert fraction to percentage and prepare data for the DataFrame
+        data = {
+            "Source": [src_str],
+            "Target": [trg_str],
+            "Fraction of connected pairs in possible ones (%)": [fraction_0*100],
+            "Fraction of connected pairs in all pairs (%)": [fraction_1*100]
+        }
+        df = pd.DataFrame(data)
+        
+        # Append the data to the CSV file
+        try:
+            # Check if the file exists by trying to read it
+            existing_df = pd.read_csv('connection_report.csv')
+            # If no exception is raised, append without header
+            df.to_csv('connection_report.csv', mode='a', header=False, index=False)
+        except FileNotFoundError:
+            # If the file does not exist, write with header
+            df.to_csv('connection_report.csv', mode='w', header=True, index=False)
 
 
 class GapJunction(UnidirectionConnector):
@@ -1198,8 +1258,8 @@ class GapJunction(UnidirectionConnector):
         Similar to `UnidirectionConnector`.
     """
 
-    def __init__(self, p=1., p_arg=None, verbose=True):
-        super().__init__(p=p, p_arg=p_arg, verbose=verbose)
+    def __init__(self, p=1., p_arg=None, verbose=True,save_report=True):
+        super().__init__(p=p, p_arg=p_arg, verbose=verbose,save_report=save_report)
 
     def setup_nodes(self, source=None, target=None):
         super().setup_nodes(source=source, target=target)
@@ -1239,6 +1299,8 @@ class GapJunction(UnidirectionConnector):
             if self.verbose:
                 self.connection_number_info()
                 self.timer.report('Done! \nTime for building connections')
+            if self.save_report:
+                self.save_connection_report()
         return nsyns
 
     def connection_number_info(self):
@@ -1247,6 +1309,32 @@ class GapJunction(UnidirectionConnector):
         super().connection_number_info()
         self.n_pair = n_pair
 
+    def save_connection_report(self):
+        """Save connections into a CSV file to be read from later"""
+        src_str, trg_str = self.get_nodes_info()
+        n_pair = self.n_pair
+        fraction_0 = self.n_conn / self.n_poss if self.n_poss else 0.
+        fraction_1 = self.n_conn / self.n_pair
+
+        # Convert fraction to percentage and prepare data for the DataFrame
+        data = {
+            "Source": [src_str+"Gap"],
+            "Target": [trg_str+"Gap"],
+            "Fraction of connected pairs in possible ones (%)": [fraction_0*100],
+            "Fraction of connected pairs in all pairs (%)": [fraction_1*100]
+        }
+        df = pd.DataFrame(data)
+        
+        # Append the data to the CSV file
+        try:
+            # Check if the file exists by trying to read it
+            existing_df = pd.read_csv('connection_report.csv')
+            # If no exception is raised, append without header
+            df.to_csv('connection_report.csv', mode='a', header=False, index=False)
+        except FileNotFoundError:
+            # If the file does not exist, write with header
+            df.to_csv('connection_report.csv', mode='w', header=True, index=False)
+
 
 class CorrelatedGapJunction(GapJunction):
     """
@@ -1276,8 +1364,8 @@ class CorrelatedGapJunction(GapJunction):
     """
 
     def __init__(self, p_non=1., p_uni=1., p_rec=1., p_arg=None,
-                 connector=None, verbose=True):
-        super().__init__(p=p_non, p_arg=p_arg, verbose=verbose)
+                 connector=None, verbose=True,save_report=True):
+        super().__init__(p=p_non, p_arg=p_arg, verbose=verbose,save_report=save_report)
         self.vars['p_non'] = self.vars.pop('p')
         self.vars['p_uni'] = p_uni
         self.vars['p_rec'] = p_rec
@@ -1340,6 +1428,8 @@ class CorrelatedGapJunction(GapJunction):
             if self.verbose:
                 self.connection_number_info()
                 self.timer.report('Done! \nTime for building connections')
+            if self.save_report:
+                self.save_connection_report()
         return nsyns
 
 

{bmtool-0.5.3 → bmtool-0.5.4}/bmtool/util/util.py

@@ -611,7 +611,11 @@ def connection_totals(config=None,nodes=None,edges=None,sources=[],targets=[],si
 
         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]
+            try: 
+                cons = cons[cons['is_gap_junction'] != True]
+            except:
+                raise Exception("no gap junctions found to drop from connections")
+            
         total = total.count()
         total = total.source_node_id # may not be the best way to pick
         return total
@@ -632,7 +636,11 @@ def percent_connections(config=None,nodes=None,edges=None,sources=[],targets=[],
 
         cons = edges[(edges[source_id_type] == source_id) & (edges[target_id_type]==target_id)]
         if include_gap == False:
-            cons = cons[cons['is_gap_junction'] != True]
+            try: 
+                cons = cons[cons['is_gap_junction'] != True]
+            except:
+                raise Exception("no gap junctions found to drop from connections")
+            
         total_cons = cons.count().source_node_id
         # to determine reciprocal connectivity
         # create a copy and flip source/dest
@@ -685,7 +693,10 @@ def connection_divergence(config=None,nodes=None,edges=None,sources=[],targets=[
 
         cons = edges[(edges[source_id_type] == source_id) & (edges[target_id_type]==target_id)]
         if include_gap == False:
-            cons = cons[cons['is_gap_junction'] != True]
+            try: 
+                cons = cons[cons['is_gap_junction'] != True]
+            except:
+                raise Exception("no gap junctions found to drop from connections")
 
         if convergence:
             if method == 'min':
@@ -739,7 +750,10 @@ def gap_junction_connections(config=None,nodes=None,edges=None,sources=[],target
         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
+        try: 
+            cons = cons[cons['is_gap_junction'] != True]
+        except:
+            raise Exception("no gap junctions found to drop from connections")
         mean = cons['target_node_id'].value_counts().mean()
         std = cons['target_node_id'].value_counts().std()
         return (round(mean,2)), (round(std,2))
@@ -755,7 +769,11 @@ def gap_junction_connections(config=None,nodes=None,edges=None,sources=[],target
 
         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]
+        try: 
+            cons = cons[cons['is_gap_junction'] != True]
+        except:
+            raise Exception("no gap junctions found to drop from connections")
+        
         total_cons = cons.count().source_node_id
 
         num_sources = s_list[source_id_type].value_counts().sort_index().loc[source_id]
@@ -775,10 +793,6 @@ def gap_junction_percent_connections(config=None,nodes=None,edges=None,sources=[
     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):
@@ -857,7 +871,10 @@ def connection_probabilities(config=None,nodes=None,edges=None,sources=[],
 
         relevant_edges = edges[(edges[source_id_type] == source_id) & (edges[target_id_type]==target_id)]
         if include_gap == False:
-            relevant_edges = relevant_edges[relevant_edges['is_gap_junction'] != True]
+            try: 
+                relevant_edges = relevant_edges[relevant_edges['is_gap_junction'] != True]
+            except:
+                raise Exception("no gap junctions found to drop from connections")
         connected_distances = eudist(relevant_edges,dist_X,dist_Y,dist_Z).values.tolist()
         if len(connected_distances)>0:
             if connected_distances[0]==0:

{bmtool-0.5.3 → bmtool-0.5.4}/bmtool.egg-info/PKG-INFO

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

{bmtool-0.5.3 → bmtool-0.5.4}/setup.py

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