bmtool 0.6.9.23__tar.gz → 0.6.9.24__tar.gz

{bmtool-0.6.9.23 → bmtool-0.6.9.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bmtool
-Version: 0.6.9.23
+Version: 0.6.9.24
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 

{bmtool-0.6.9.23 → bmtool-0.6.9.24}/bmtool/analysis/spikes.py

@@ -7,6 +7,7 @@ import pandas as pd
 from bmtool.util.util import load_nodes_from_config
 from typing import Dict, Optional,Tuple, Union, List
 import numpy as np
+from scipy.stats import mannwhitneyu
 import os
 
 
@@ -252,3 +253,55 @@ def get_population_spike_rate(spikes: pd.DataFrame, fs: float = 400.0, t_start:
 
     return spike_rate
 
+
+def compare_firing_over_times(spike_df,group_by, time_window_1, time_window_2):
+    """
+    Compares the firing rates of a population during two different time windows
+    time_window_1 and time_window_2 should be a list of [start, stop] in milliseconds
+    Returns firing rates and results of a Mann-Whitney U test (non-parametric)
+    """
+    # Filter spikes for the population of interest
+    for pop_name in spike_df[group_by].unique():
+        print(f"Population: {pop_name}")
+        pop_spikes = spike_df[spike_df[group_by] == pop_name]
+        
+        # Filter by time windows
+        pop_spikes_1 = pop_spikes[(pop_spikes['timestamps'] >= time_window_1[0]) & (pop_spikes['timestamps'] <= time_window_1[1])]
+        pop_spikes_2 = pop_spikes[(pop_spikes['timestamps'] >= time_window_2[0]) & (pop_spikes['timestamps'] <= time_window_2[1])]
+        
+        # Get unique neuron IDs
+        unique_neurons = pop_spikes['node_ids'].unique()
+        
+        # Calculate firing rates per neuron for each time window in Hz
+        neuron_rates_1 = []
+        neuron_rates_2 = []
+        
+        for neuron in unique_neurons:
+            # Count spikes for this neuron in each window
+            n_spikes_1 = len(pop_spikes_1[pop_spikes_1['node_ids'] == neuron])
+            n_spikes_2 = len(pop_spikes_2[pop_spikes_2['node_ids'] == neuron])
+            
+            # Calculate firing rate in Hz (convert ms to seconds by dividing by 1000)
+            rate_1 = n_spikes_1 / ((time_window_1[1] - time_window_1[0]) / 1000)
+            rate_2 = n_spikes_2 / ((time_window_2[1] - time_window_2[0]) / 1000)
+            
+            neuron_rates_1.append(rate_1)
+            neuron_rates_2.append(rate_2)
+        
+        # Calculate average firing rates
+        avg_firing_rate_1 = np.mean(neuron_rates_1) if neuron_rates_1 else 0
+        avg_firing_rate_2 = np.mean(neuron_rates_2) if neuron_rates_2 else 0
+        
+        # Perform Mann-Whitney U test
+        # Handle the case when one or both arrays are empty
+        if len(neuron_rates_1) > 0 and len(neuron_rates_2) > 0:
+            u_stat, p_val = mannwhitneyu(neuron_rates_1, neuron_rates_2, alternative='two-sided')
+        else:
+            u_stat, p_val = np.nan, np.nan
+
+        print(f"    Average firing rate in window 1: {avg_firing_rate_1:.2f} Hz")
+        print(f"    Average firing rate in window 2: {avg_firing_rate_2:.2f} Hz")
+        print(f"    U-statistic: {u_stat:.2f}")
+        print(f"    p-value: {p_val}")
+        print(f"    Significant difference (p<0.05): {'Yes' if p_val < 0.05 else 'No'}")
+    return

{bmtool-0.6.9.23 → bmtool-0.6.9.24}/bmtool/bmplot.py

@@ -23,8 +23,9 @@ import sys
 import re
 from typing import Optional, Dict, Union, List
 
-from .util.util import CellVarsFile,load_nodes_from_config #, missing_units
+from .util.util import CellVarsFile,load_nodes_from_config,load_templates_from_config #, missing_units
 from bmtk.analyzer.utils import listify
+from neuron import h
 
 use_description = """
 
@@ -682,6 +683,99 @@ def edge_histogram_matrix(config=None,sources = None,targets=None,sids=None,tids
     fig.text(0.04, 0.5, 'Source', va='center', rotation='vertical')
     plt.draw()
 
+def plot_synapse_location_histograms(config, target_model, source=None, target=None):
+    """
+    generates a histogram of the positions of the synapses on a cell broken down by section
+    config: a BMTK config
+    target_model: the name of the model_template used when building the BMTK node
+    source: The source BMTK network 
+    target: The target BMTK network
+    """
+    # Load mechanisms and template
+
+    util.load_templates_from_config(config)
+
+    # Load node and edge data
+    nodes, edges = util.load_nodes_edges_from_config(config)
+    nodes = nodes[source]
+    edges = edges[f'{source}_to_{target}']
+
+    # Map target_node_id to model_template
+    edges['target_model_template'] = edges['target_node_id'].map(nodes['model_template'])
+
+    # Map source_node_id to pop_name
+    edges['source_pop_name'] = edges['source_node_id'].map(nodes['pop_name'])
+
+    edges = edges[edges['target_model_template'] == target_model]
+
+    # Create the cell model from target model
+    cell = getattr(h, target_model.split(':')[1])()
+ 
+    # Create a mapping from section index to section name
+    section_id_to_name = {}
+    for idx, sec in enumerate(cell.all):
+        section_id_to_name[idx] = sec.name()
+
+    # Add a new column with section names based on afferent_section_id
+    edges['afferent_section_name'] = edges['afferent_section_id'].map(section_id_to_name)
+
+    # Get unique sections and source populations
+    unique_pops = edges['source_pop_name'].unique()
+
+    # Filter to only include sections with data
+    section_counts = edges['afferent_section_name'].value_counts()
+    sections_with_data = section_counts[section_counts > 0].index.tolist()
+
+
+    # Create a figure with subplots for each section
+    plt.figure(figsize=(8,12))
+
+    # Color map for source populations
+    color_map = plt.cm.tab10(np.linspace(0, 1, len(unique_pops)))
+    pop_colors = {pop: color for pop, color in zip(unique_pops, color_map)}
+
+    # Create a histogram for each section
+    for i, section in enumerate(sections_with_data):
+        ax = plt.subplot(len(sections_with_data), 1, i+1)
+        
+        # Get data for this section
+        section_data = edges[edges['afferent_section_name'] == section]
+        
+        # Group by source population
+        for pop_name, pop_group in section_data.groupby('source_pop_name'):
+            if len(pop_group) > 0:
+                ax.hist(pop_group['afferent_section_pos'], bins=15, alpha=0.7, 
+                    label=pop_name, color=pop_colors[pop_name])
+        
+        # Set title and labels
+        ax.set_title(f"{section}", fontsize=10)
+        ax.set_xlabel('Section Position', fontsize=8)
+        ax.set_ylabel('Frequency', fontsize=8)
+        ax.tick_params(labelsize=7)
+        ax.grid(True, alpha=0.3)
+        
+        # Only add legend to the first plot
+        if i == 0:
+            ax.legend(fontsize=8)
+
+    plt.tight_layout()
+    plt.suptitle('Connection Distribution by Cell Section and Source Population', fontsize=16, y=1.02)
+    if is_notebook:
+        plt.show()
+    else:
+        pass
+
+    # Create a summary table
+    print("Summary of connections by section and source population:")
+    pivot_table = edges.pivot_table(
+        values='afferent_section_id', 
+        index='afferent_section_name',
+        columns='source_pop_name',
+        aggfunc='count',
+        fill_value=0
+    )
+    print(pivot_table)
+
 def plot_connection_info(text, num, source_labels, target_labels, title, syn_info='0', save_file=None, return_dict=None):
     """
     Function to plot connection information as a heatmap, including handling missing source and target values.

{bmtool-0.6.9.23 → bmtool-0.6.9.24}/bmtool/util/util.py

@@ -6,6 +6,8 @@ import numpy as np
 from numpy import genfromtxt
 import h5py
 import pandas as pd
+import neuron
+from neuron import h
 
 #from bmtk.utils.io.cell_vars import CellVarsFile
 #from bmtk.analyzer.cell_vars import _get_cell_report
@@ -392,6 +394,32 @@ def load_edges_from_paths(edge_paths):#network_dir='network'):
     
     return edges_dict
 
+def load_mechanisms_from_config(config=None):
+    """
+    loads neuron mechanisms from BMTK config
+    """
+    if config is None:
+        config = 'simulation_config.json'
+    config = load_config(config)
+    return neuron.load_mechanisms(config['components']['mechanisms_dir'])
+
+def load_templates_from_config(config=None):
+    if config is None:
+        config = 'simulation_config.json'
+    config = load_config(config)
+    load_mechanisms_from_config(config)
+    return load_templates_from_paths(config['components']['templates_dir'])
+
+def load_templates_from_paths(template_paths):
+    # load all the files in the templates dir
+    for item in os.listdir(template_paths):
+        item_path = os.path.join(template_paths, item)
+        if os.path.isfile(item_path):
+            print(f"loading {item_path}")
+            h.load_file(item_path)
+
+    
+
 def cell_positions_by_id(config=None, nodes=None, populations=[], popids=[], prepend_pop=True):
     """
     Returns a dictionary of arrays of arrays {"population_popid":[[1,2,3],[1,2,4]],...

{bmtool-0.6.9.23 → bmtool-0.6.9.24}/bmtool.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bmtool
-Version: 0.6.9.23
+Version: 0.6.9.24
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 

{bmtool-0.6.9.23 → bmtool-0.6.9.24}/setup.py

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