bmtool 0.7.1.7__py3-none-any.whl → 0.7.2.1__py3-none-any.whl

bmtool/analysis/entrainment.py

@@ -7,13 +7,12 @@ from typing import Dict, List, Optional, Union
 import numba
 import numpy as np
 import pandas as pd
-import scipy.stats as stats
 import xarray as xr
 from numba import cuda
 from scipy import signal
 from tqdm.notebook import tqdm
 
-from .lfp import butter_bandpass_filter, get_lfp_phase, get_lfp_power, wavelet_filter
+from .lfp import butter_bandpass_filter, get_lfp_phase, wavelet_filter
 
 
 def align_spike_times_with_lfp(lfp: xr.DataArray, timestamps: np.ndarray) -> np.ndarray:
@@ -635,85 +634,6 @@ def calculate_entrainment_per_cell(
     return entrainment_dict
 
 
-def calculate_spike_rate_power_correlation(
-    spike_rate: xr.DataArray,
-    lfp_data: np.ndarray,
-    fs: float,
-    pop_names: list,
-    filter_method: str = "wavelet",
-    bandwidth: float = 2.0,
-    lowcut: float = None,
-    highcut: float = None,
-    freq_range: tuple = (10, 100),
-    freq_step: float = 5,
-    type_name: str = "raw",  # 'raw' or 'smoothed'
-):
-    """
-    Calculate correlation between population spike rates (xarray) and LFP power across frequencies.
-
-    Parameters
-    ----------
-    spike_rate : xr.DataArray
-        Population spike rates with dimensions (time, population[, type])
-    lfp_data : np.ndarray
-        LFP data
-    fs : float
-        Sampling frequency
-    pop_names : list
-        List of population names to analyze
-    filter_method : str, optional
-        Filtering method to use, either 'wavelet' or 'butter' (default: 'wavelet')
-    bandwidth : float, optional
-        Bandwidth parameter for wavelet filter when method='wavelet' (default: 2.0)
-    lowcut : float, optional
-        Lower frequency bound (Hz) for butterworth bandpass filter, required if filter_method='butter'
-    highcut : float, optional
-        Upper frequency bound (Hz) for butterworth bandpass filter, required if filter_method='butter'
-    freq_range : tuple, optional
-        Min and max frequency to analyze (default: (10, 100))
-    freq_step : float, optional
-        Step size for frequency analysis (default: 5)
-    type_name : str, optional
-        Which type of spike rate to use if 'type' dimension exists (default: 'raw')
-
-    Returns
-    -------
-    correlation_results : dict
-        Dictionary with correlation results for each population and frequency
-    frequencies : array
-        Array of frequencies analyzed
-    """
-    frequencies = np.arange(freq_range[0], freq_range[1] + 1, freq_step)
-    correlation_results = {pop: {} for pop in pop_names}
-
-    # Calculate power at each frequency band using specified filter
-    power_by_freq = {}
-    for freq in frequencies:
-        power_by_freq[freq] = get_lfp_power(
-            lfp_data, freq, fs, filter_method, lowcut=lowcut, highcut=highcut, bandwidth=bandwidth
-        )
-
-    # For each population, extract the correct spike rate
-    for pop in pop_names:
-        # If 'type' dimension exists, select the type
-        if "type" in spike_rate.dims:
-            pop_rate = spike_rate.sel(population=pop, type=type_name).values
-        else:
-            pop_rate = spike_rate.sel(population=pop).values
-
-        # Calculate correlation with power at each frequency
-        for freq in frequencies:
-            lfp_power = power_by_freq[freq]
-            # Ensure lengths match
-            min_len = min(len(pop_rate), len(lfp_power))
-            if len(pop_rate) != len(lfp_power):
-                print(f"Warning: Length mismatch for {pop} at {freq} Hz, truncating to {min_len}")
-            corr, p_val = stats.spearmanr(pop_rate[:min_len], lfp_power[:min_len])
-            correlation_results[pop][freq] = {"correlation": corr, "p_value": p_val}
-
-    return correlation_results, frequencies
-
-
 def get_spikes_in_cycle(
     spike_df,
     lfp_data,

bmtool/analysis/spikes.py

@@ -281,12 +281,13 @@ def get_population_spike_rate(
     node_number = {}
 
     if config is None:
-        print(
-            "Note: Node number is obtained by counting unique node spikes in the network.\nIf the network did not run for a sufficient duration, or not all cells fired,\nthen this count will not include all nodes so the firing rate will not be of the whole population!"
-        )
-        print(
-            "You can provide a config to calculate the correct amount of nodes! for a true population rate."
-        )
+        pass
+        # print(
+        #     "Note: Node number is obtained by counting unique node spikes in the network.\nIf the network did not run for a sufficient duration, or not all cells fired,\nthen this count will not include all nodes so the firing rate will not be of the whole population!"
+        # )
+        # print(
+        #     "You can provide a config to calculate the correct amount of nodes! for a true population rate."
+        # )
 
     if config:
         if not network_name:
@@ -602,3 +603,51 @@ def find_bursting_cells(
         )
 
     return burst_cells
+
+
+def find_highest_firing_cells(
+    df: pd.DataFrame, upper_quantile: float, groupby: str = "pop_name"
+) -> pd.DataFrame:
+    """
+    Identifies and returns spikes from cells with firing rates above a specified upper quantile,
+    grouped by a population label.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        DataFrame containing spike data with at least the following columns:
+        - 'timestamps': Time of each spike event
+        - 'node_ids': Identifier for each neuron
+        - groupby (e.g., 'pop_name'): Population labels or grouping identifiers for neurons
+
+    upper_quantile : float
+        The upper quantile threshold (between 0 and 1).
+        Cells with firing rates in the top (1 - upper_quantile) fraction are selected.
+        For example, upper_quantile=0.8 selects the top 20% of high-firing cells.
+
+    groupby : str, optional
+        The column name used to group neurons by population. Default is 'pop_name'.
+
+    Returns
+    -------
+    pd.DataFrame
+        A DataFrame containing only the spikes from the high-firing cells across all groupbys.
+    """
+    if upper_quantile == 0:
+        return df
+    df_list = []
+    for pop in df[groupby].unique():
+        pop_df = df[df[groupby] == pop]
+        _, pop_fr = compute_firing_rate_stats(pop_df, groupby=groupby)
+
+        # Identify high firing cells
+        threshold = pop_fr["firing_rate"].quantile(upper_quantile)
+        high_firing_cells = pop_fr[pop_fr["firing_rate"] >= threshold]["node_ids"]
+
+        # Filter spikes for high firing cells
+        pop_spikes = pop_df[pop_df["node_ids"].isin(high_firing_cells)]
+        df_list.append(pop_spikes)
+
+    # Combine all high firing spikes into one DataFrame
+    result_df = pd.concat(df_list, ignore_index=True)
+    return result_df

bmtool/bmplot/connections.py

@@ -12,7 +12,6 @@ import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
 from IPython import get_ipython
-from neuron import h
 
 from ..util import util
 
@@ -981,104 +980,158 @@ def distance_delay_plot(
     plt.show()
 
 
-def plot_synapse_location_histograms(config, target_model, source=None, target=None):
+def plot_synapse_location(config: str, source: str, target: str, sids: str, tids: str) -> tuple:
     """
-    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"])
+    Generates a connectivity matrix showing synaptic distribution across different cell sections.
 
-    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()
+    Parameters
+    ----------
+    config : str
+        Path to BMTK config file
+    source : str
+        The source BMTK network name
+    target : str
+        The target BMTK network name
+    sids : str
+        Column name in nodes file containing source population identifiers
+    tids : str
+        Column name in nodes file containing target population identifiers
+
+    Returns
+    -------
+    tuple
+        (matplotlib.figure.Figure, matplotlib.axes.Axes) containing the plot
+
+    Raises
+    ------
+    ValueError
+        If required parameters are missing or invalid
+    RuntimeError
+        If template loading or cell instantiation fails
+    """
+    import matplotlib.pyplot as plt
+    import numpy as np
+    from neuron import h
+
+    # Validate inputs
+    if not all([config, source, target, sids, tids]):
+        raise ValueError(
+            "Missing required parameters: config, source, target, sids, and tids must be provided"
+        )
 
-    # Create a figure with subplots for each section
-    plt.figure(figsize=(8, 12))
+    try:
+        # Load mechanisms and template
+        util.load_templates_from_config(config)
+    except Exception as e:
+        raise RuntimeError(f"Failed to load templates from config: {str(e)}")
 
-    # 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)}
+    try:
+        # Load node and edge data
+        nodes, edges = util.load_nodes_edges_from_config(config)
+        if source not in nodes or f"{source}_to_{target}" not in edges:
+            raise ValueError(f"Source '{source}' or target '{target}' networks not found in data")
 
-    # Create a histogram for each section
-    for i, section in enumerate(sections_with_data):
-        ax = plt.subplot(len(sections_with_data), 1, i + 1)
+        nodes = nodes[source]
+        edges = edges[f"{source}_to_{target}"]
+    except Exception as e:
+        raise RuntimeError(f"Failed to load nodes and edges: {str(e)}")
 
-        # Get data for this section
-        section_data = edges[edges["afferent_section_name"] == section]
+    # Map identifiers while checking for missing values
+    edges["target_model_template"] = edges["target_node_id"].map(nodes["model_template"])
+    edges["target_pop_name"] = edges["target_node_id"].map(nodes[tids])
+    edges["source_pop_name"] = edges["source_node_id"].map(nodes[sids])
+
+    if edges["target_model_template"].isnull().any():
+        print("Warning: Some target nodes missing model template")
+    if edges["target_pop_name"].isnull().any():
+        print("Warning: Some target nodes missing population name")
+    if edges["source_pop_name"].isnull().any():
+        print("Warning: Some source nodes missing population name")
+
+    # Get unique populations
+    source_pops = edges["source_pop_name"].unique()
+    target_pops = edges["target_pop_name"].unique()
+
+    # Initialize matrices
+    num_connections = np.zeros((len(source_pops), len(target_pops)))
+    text_data = np.empty((len(source_pops), len(target_pops)), dtype=object)
+
+    # Create mappings for indices
+    source_pop_to_idx = {pop: idx for idx, pop in enumerate(source_pops)}
+    target_pop_to_idx = {pop: idx for idx, pop in enumerate(target_pops)}
+
+    # Cache for section mappings to avoid recreating cells
+    section_mappings = {}
+
+    # Calculate connectivity statistics
+    for source_pop in source_pops:
+        for target_pop in target_pops:
+            # Filter edges for this source-target pair
+            filtered_edges = edges[
+                (edges["source_pop_name"] == source_pop) & (edges["target_pop_name"] == target_pop)
+            ]
 
-        # 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],
-                )
+            source_idx = source_pop_to_idx[source_pop]
+            target_idx = target_pop_to_idx[target_pop]
 
-        # 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)
+            if len(filtered_edges) == 0:
+                num_connections[source_idx, target_idx] = 0
+                text_data[source_idx, target_idx] = "No connections"
+                continue
 
-        # Only add legend to the first plot
-        if i == 0:
-            ax.legend(fontsize=8)
+            total_connections = len(filtered_edges)
+            target_model_template = filtered_edges["target_model_template"].iloc[0]
 
-    plt.tight_layout()
-    plt.suptitle(
-        "Connection Distribution by Cell Section and Source Population", fontsize=16, y=1.02
+            try:
+                # Get or create section mapping for this model
+                if target_model_template not in section_mappings:
+                    cell_class_name = (
+                        target_model_template.split(":")[1]
+                        if ":" in target_model_template
+                        else target_model_template
+                    )
+                    cell = getattr(h, cell_class_name)()
+
+                    # Create section mapping
+                    section_mapping = {}
+                    for idx, sec in enumerate(cell.all):
+                        section_mapping[idx] = sec.name().split(".")[-1]  # Clean name
+                    section_mappings[target_model_template] = section_mapping
+
+                section_mapping = section_mappings[target_model_template]
+
+                # Calculate section distribution
+                section_counts = filtered_edges["afferent_section_id"].value_counts()
+                section_percentages = (section_counts / total_connections * 100).round(1)
+
+                # Format section distribution text - show all sections
+                section_display = []
+                for section_id, percentage in section_percentages.items():
+                    section_name = section_mapping.get(section_id, f"sec_{section_id}")
+                    section_display.append(f"{section_name}:{percentage}%")
+
+                num_connections[source_idx, target_idx] = total_connections
+                text_data[source_idx, target_idx] = "\n".join(section_display)
+
+            except Exception as e:
+                print(f"Warning: Error processing {target_model_template}: {str(e)}")
+                num_connections[source_idx, target_idx] = total_connections
+                text_data[source_idx, target_idx] = "Section info N/A"
+
+    # Create the plot
+    title = f"Synaptic Distribution by Section: {source} to {target}"
+    fig, ax = plot_connection_info(
+        text=text_data,
+        num=num_connections,
+        source_labels=list(source_pops),
+        target_labels=list(target_pops),
+        title=title,
+        syn_info="1",
     )
-    if is_notebook:
+    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)
+        return fig, ax
 
 
 def plot_connection_info(
@@ -1088,7 +1141,6 @@ def plot_connection_info(
     Function to plot connection information as a heatmap, including handling missing source and target values.
     If there is no source or target, set the value to 0.
     """
-
     # Ensure text dimensions match num dimensions
     num_source = len(source_labels)
     num_target = len(target_labels)
@@ -1096,103 +1148,149 @@ def plot_connection_info(
     # Set color map
     matplotlib.rc("image", cmap="viridis")
 
-    # Create figure and axis for the plot
-    fig1, ax1 = plt.subplots(figsize=(num_source, num_target))
-    num = np.nan_to_num(num, nan=0)  # replace NaN with 0
-    im1 = ax1.imshow(num)
+    # Calculate square cell size to ensure proper aspect ratio
+    base_cell_size = 0.6  # Base size per cell
+
+    # Calculate figure dimensions with proper aspect ratio
+    # Make sure width and height are proportional to the matrix dimensions
+    fig_width = max(8, num_target * base_cell_size + 4)  # Width based on columns
+    fig_height = max(6, num_source * base_cell_size + 3)  # Height based on rows
 
-    # Set ticks and labels for source and target
+    # Ensure minimum readable size
+    min_fig_size = 8
+    if fig_width < min_fig_size or fig_height < min_fig_size:
+        scale_factor = min_fig_size / min(fig_width, fig_height)
+        fig_width *= scale_factor
+        fig_height *= scale_factor
+
+    # Create figure and axis
+    fig1, ax1 = plt.subplots(figsize=(fig_width, fig_height))
+
+    # Replace NaN with 0 and create heatmap
+    num_clean = np.nan_to_num(num, nan=0)
+    # if string is nan\nnan make it 0
+
+    # Use 'auto' aspect ratio to let matplotlib handle it properly
+    # This prevents the stretching issue
+    im1 = ax1.imshow(num_clean, aspect="auto", interpolation="nearest")
+
+    # Set ticks and labels
     ax1.set_xticks(list(np.arange(len(target_labels))))
     ax1.set_yticks(list(np.arange(len(source_labels))))
     ax1.set_xticklabels(target_labels)
-    ax1.set_yticklabels(source_labels, size=12, weight="semibold")
+    ax1.set_yticklabels(source_labels)
 
-    # Rotate the tick labels for better visibility
+    # Improved font sizing based on matrix size
+    label_font_size = max(8, min(14, 120 / max(num_source, num_target)))
+
+    # Style the tick labels
+    ax1.tick_params(axis="y", labelsize=label_font_size, pad=5)
     plt.setp(
         ax1.get_xticklabels(),
         rotation=45,
         ha="right",
         rotation_mode="anchor",
-        size=12,
-        weight="semibold",
+        fontsize=label_font_size,
     )
 
     # Dictionary to store connection information
     graph_dict = {}
 
+    # Improved text size calculation - more readable for larger matrices
+    text_size = max(6, min(12, 80 / max(num_source, num_target)))
+
     # Loop over data dimensions and create text annotations
     for i in range(num_source):
         for j in range(num_target):
-            # Get the edge info, or set it to '0' if it's missing
-            edge_info = text[i, j] if text[i, j] is not None else 0
+            edge_info = text[i, j] if text[i, j] is not None else "0\n0"
 
-            # 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
 
-            # Set text annotations based on syn_info type
-            if syn_info == "2" or syn_info == "3":
-                if num_source > 8 and num_source < 20:
-                    fig_text = ax1.text(
-                        j,
-                        i,
-                        edge_info,
-                        ha="center",
-                        va="center",
-                        color="w",
-                        rotation=37.5,
-                        size=8,
-                        weight="semibold",
-                    )
-                elif num_source > 20:
-                    fig_text = ax1.text(
-                        j,
-                        i,
-                        edge_info,
-                        ha="center",
-                        va="center",
-                        color="w",
-                        rotation=37.5,
-                        size=7,
-                        weight="semibold",
-                    )
+            # Skip displaying text for NaN values to reduce clutter
+            if edge_info == "nan\nnan":
+                edge_info = "0\n±0"
+
+            # Format the text display
+            if isinstance(edge_info, str) and "\n" in edge_info:
+                # For mean/std format (e.g. "15.5\n4.0")
+                parts = edge_info.split("\n")
+                if len(parts) == 2:
+                    try:
+                        mean_val = float(parts[0])
+                        std_val = float(parts[1])
+                        display_text = f"{mean_val:.1f}\n±{std_val:.1f}"
+                    except ValueError:
+                        display_text = edge_info
                 else:
-                    fig_text = ax1.text(
-                        j,
-                        i,
-                        edge_info,
-                        ha="center",
-                        va="center",
-                        color="w",
-                        rotation=37.5,
-                        size=11,
-                        weight="semibold",
-                    )
+                    display_text = edge_info
+            else:
+                display_text = str(edge_info)
+
+            # Add text to plot with better contrast
+            text_color = "white" if num_clean[i, j] < (np.nanmax(num_clean) * 0.9) else "black"
+
+            if syn_info == "2" or syn_info == "3":
+                ax1.text(
+                    j,
+                    i,
+                    display_text,
+                    ha="center",
+                    va="center",
+                    color=text_color,
+                    rotation=37.5,
+                    fontsize=text_size,
+                    weight="bold",
+                )
             else:
-                fig_text = ax1.text(
-                    j, i, edge_info, ha="center", va="center", color="w", size=11, weight="semibold"
+                ax1.text(
+                    j,
+                    i,
+                    display_text,
+                    ha="center",
+                    va="center",
+                    color=text_color,
+                    fontsize=text_size,
+                    weight="bold",
                 )
 
-    # Set labels and title for the plot
-    ax1.set_ylabel("Source", size=11, weight="semibold")
-    ax1.set_xlabel("Target", size=11, weight="semibold")
-    ax1.set_title(title, size=20, weight="semibold")
+    # Set labels and title
+    title_font_size = max(12, min(18, label_font_size + 4))
+    ax1.set_ylabel("Source", fontsize=title_font_size, weight="bold", labelpad=10)
+    ax1.set_xlabel("Target", fontsize=title_font_size, weight="bold", labelpad=10)
+    ax1.set_title(title, fontsize=title_font_size + 2, weight="bold", pad=20)
+
+    # Add colorbar
+    cbar = plt.colorbar(im1, shrink=0.8)
+    cbar.ax.tick_params(labelsize=label_font_size)
+
+    # Adjust layout to minimize whitespace and prevent stretching
+    plt.tight_layout(pad=1.5)
+
+    # Force square cells by setting equal axis limits if needed
+    ax1.set_xlim(-0.5, num_target - 0.5)
+    ax1.set_ylim(num_source - 0.5, -0.5)  # Inverted for proper matrix orientation
+
+    # Display or save the plot
+    try:
+        # Check if running in notebook
+        from IPython import get_ipython
+
+        notebook = get_ipython() is not None
+    except ImportError:
+        notebook = False
 
-    # Display the plot or save it based on the environment and arguments
-    notebook = is_notebook()  # Check if running in a Jupyter notebook
     if not notebook:
-        fig1.show()
+        plt.show()
 
     if save_file:
-        plt.savefig(save_file)
+        plt.savefig(save_file, dpi=300, bbox_inches="tight", pad_inches=0.1)
 
     if return_dict:
         return graph_dict
     else:
-        return
+        return fig1, ax1
 
 
 def connector_percent_matrix(
@@ -1467,19 +1565,23 @@ def plot_3d_positions(config=None, sources=None, sid=None, title=None, save_file
     plt.title(title)
     plt.legend(handles=handles)
 
+    # Add axis labels
+    ax.set_xlabel("X Position (μm)")
+    ax.set_ylabel("Y Position (μm)")
+    ax.set_zlabel("Z Position (μm)")
+
     # Draw the plot
     plt.draw()
+    plt.tight_layout()
 
     # Save the plot if save_file is provided
     if save_file:
         plt.savefig(save_file)
 
-    # Show the plot if running outside of a notebook
-    if not is_notebook:
+    # Show if running in notebook
+    if is_notebook:
         plt.show()
 
-    return ax
-
 
 def plot_3d_cell_rotation(
     config=None,