bmtool 0.7.1.7__py3-none-any.whl → 0.7.2__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

@@ -1088,7 +1088,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 +1095,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
+
+    # 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))
 
-    # Set ticks and labels for source and target
+    # 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 +1512,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,

bmtool/bmplot/entrainment.py

@@ -1,56 +1,299 @@
+from typing import List, Tuple, Union
+
 import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
 import seaborn as sns
+import xarray as xr
 from matplotlib.gridspec import GridSpec
 from scipy import stats
 
-
-def plot_spike_power_correlation(correlation_results, frequencies, pop_names):
+from bmtool.analysis import entrainment as bmentr
+from bmtool.analysis import spikes as bmspikes
+from bmtool.analysis.lfp import get_lfp_power
+
+
+def plot_spike_power_correlation(
+    spike_df: pd.DataFrame,
+    lfp_data: xr.DataArray,
+    firing_quantile: float,
+    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",
+    time_windows: list = None,
+    error_type: str = "ci",  # New parameter: "ci" for confidence interval, "sem" for standard error, "std" for standard deviation
+):
     """
-    Plot the correlation between population spike rates and LFP power.
-
-    Parameters:
-    -----------
-    correlation_results : dict
-        Dictionary with correlation results for calculate_spike_rate_power_correlation
-    frequencies : array
-        Array of frequencies analyzed
+    Calculate and plot correlation between population spike rates and LFP power across frequencies.
+    Supports both single-signal and trial-based analysis with error bars.
+
+    Parameters
+    ----------
+    spike_rate : xr.DataArray
+        Population spike rates with dimensions (time, population[, type])
+    lfp_data : xr.DataArray
+        LFP data
+    fs : float
+        Sampling frequency
     pop_names : list
-        List of population names
+        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')
+    time_windows : list, optional
+        List of (start, end) time tuples for trial-based analysis. If None, analyze entire signal
+    error_type : str, optional
+        Type of error bars to plot: "ci" for 95% confidence interval, "sem" for standard error, "std" for standard deviation
     """
-    sns.set_style("whitegrid")
-    plt.figure(figsize=(10, 6))
 
+    if not (0 <= firing_quantile < 1):
+        raise ValueError("firing_quantile must be between 0 and 1")
+
+    if error_type not in ["ci", "sem", "std"]:
+        raise ValueError(
+            "error_type must be 'ci' for confidence interval, 'sem' for standard error, or 'std' for standard deviation"
+        )
+
+    # Setup
+    is_trial_based = time_windows is not None
+
+    # Convert spike_df to spike rate with trial-based filtering of high firing cells
+    if is_trial_based:
+        # Initialize storage for trial-based spike rates
+        trial_rates = []
+
+        for start_time, end_time in time_windows:
+            # Get spikes for this trial
+            trial_spikes = spike_df[
+                (spike_df["timestamps"] >= start_time) & (spike_df["timestamps"] <= end_time)
+            ].copy()
+
+            # Filter for high firing cells within this trial
+            trial_spikes = bmspikes.find_highest_firing_cells(
+                trial_spikes, upper_quantile=firing_quantile
+            )
+            # Calculate rate for this trial's filtered spikes
+            trial_rate = bmspikes.get_population_spike_rate(
+                trial_spikes, fs=fs, t_start=start_time, t_stop=end_time
+            )
+            trial_rates.append(trial_rate)
+
+        # Combine all trial rates
+        spike_rate = xr.concat(trial_rates, dim="trial")
+    else:
+        # For non-trial analysis, proceed as before
+        spike_df = bmspikes.find_highest_firing_cells(spike_df, upper_quantile=firing_quantile)
+        spike_rate = bmspikes.get_population_spike_rate(spike_df)
+
+    # Setup frequencies for analysis
+    frequencies = np.arange(freq_range[0], freq_range[1] + 1, freq_step)
+
+    # Pre-calculate LFP power for all frequencies
+    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
+        )
+
+    # Calculate correlations
+    results = {}
     for pop in pop_names:
-        # Extract correlation values for each frequency
-        corr_values = []
-        valid_freqs = []
+        pop_spike_rate = spike_rate.sel(population=pop, type=type_name)
+        results[pop] = {}
 
         for freq in frequencies:
-            if freq in correlation_results[pop]:
-                corr_values.append(correlation_results[pop][freq]["correlation"])
-                valid_freqs.append(freq)
+            lfp_power = power_by_freq[freq]
 
-        # Plot correlation line
-        plt.plot(valid_freqs, corr_values, marker="o", label=pop, linewidth=2, markersize=6)
+            if not is_trial_based:
+                # Single signal analysis
+                if len(pop_spike_rate) != len(lfp_power):
+                    print(f"Warning: Length mismatch for {pop} at {freq} Hz")
+                    continue
+
+                corr, p_val = stats.spearmanr(pop_spike_rate, lfp_power)
+                results[pop][freq] = {
+                    "correlation": corr,
+                    "p_value": p_val,
+                }
+            else:
+                # Trial-based analysis using pre-filtered trial rates
+                trial_correlations = []
+
+                for trial_idx in range(len(time_windows)):
+                    # Get time window first
+                    start_time, end_time = time_windows[trial_idx]
+
+                    # Get the pre-filtered spike rate for this trial
+                    trial_spike_rate = pop_spike_rate.sel(trial=trial_idx)
+
+                    # Get corresponding LFP power for this trial window
+                    trial_lfp_power = lfp_power.sel(time=slice(start_time, end_time))
+
+                    # Ensure both signals have same time points
+                    common_times = np.intersect1d(trial_spike_rate.time, trial_lfp_power.time)
+
+                    if len(common_times) > 0:
+                        trial_sr = trial_spike_rate.sel(time=common_times).values
+                        trial_lfp = trial_lfp_power.sel(time=common_times).values
+
+                        if (
+                            len(trial_sr) > 1 and len(trial_lfp) > 1
+                        ):  # Need at least 2 points for correlation
+                            corr, _ = stats.spearmanr(trial_sr, trial_lfp)
+                            if not np.isnan(corr):
+                                trial_correlations.append(corr)
+
+                # Calculate trial statistics
+                if len(trial_correlations) > 0:
+                    trial_correlations = np.array(trial_correlations)
+                    mean_corr = np.mean(trial_correlations)
+
+                    if len(trial_correlations) > 1:
+                        if error_type == "ci":
+                            # Calculate 95% confidence interval using t-distribution
+                            df = len(trial_correlations) - 1
+                            sem = stats.sem(trial_correlations)
+                            t_critical = stats.t.ppf(0.975, df)  # 95% CI, two-tailed
+                            error_val = t_critical * sem
+                            error_lower = mean_corr - error_val
+                            error_upper = mean_corr + error_val
+                        elif error_type == "sem":
+                            # Calculate standard error of the mean
+                            sem = stats.sem(trial_correlations)
+                            error_lower = mean_corr - sem
+                            error_upper = mean_corr + sem
+                        elif error_type == "std":
+                            # Calculate standard deviation
+                            std = np.std(trial_correlations, ddof=1)
+                            error_lower = mean_corr - std
+                            error_upper = mean_corr + std
+                    else:
+                        error_lower = error_upper = mean_corr
+
+                    results[pop][freq] = {
+                        "correlation": mean_corr,
+                        "error_lower": error_lower,
+                        "error_upper": error_upper,
+                        "n_trials": len(trial_correlations),
+                        "trial_correlations": trial_correlations,
+                    }
+                else:
+                    # No valid trials
+                    results[pop][freq] = {
+                        "correlation": np.nan,
+                        "error_lower": np.nan,
+                        "error_upper": np.nan,
+                        "n_trials": 0,
+                        "trial_correlations": np.array([]),
+                    }
+
+    # Plotting
+    sns.set_style("whitegrid")
+    plt.figure(figsize=(12, 8))
 
+    for i, pop in enumerate(pop_names):
+        # Extract data for plotting
+        plot_freqs = []
+        plot_corrs = []
+        plot_ci_lower = []
+        plot_ci_upper = []
+
+        for freq in frequencies:
+            if freq in results[pop] and not np.isnan(results[pop][freq]["correlation"]):
+                plot_freqs.append(freq)
+                plot_corrs.append(results[pop][freq]["correlation"])
+
+                if is_trial_based:
+                    plot_ci_lower.append(results[pop][freq]["error_lower"])
+                    plot_ci_upper.append(results[pop][freq]["error_upper"])
+
+        if len(plot_freqs) == 0:
+            continue
+
+        # Convert to arrays
+        plot_freqs = np.array(plot_freqs)
+        plot_corrs = np.array(plot_corrs)
+
+        # Get color for this population
+        colors = plt.get_cmap("tab10")
+        color = colors(i)
+
+        # Plot main line
+        plt.plot(
+            plot_freqs, plot_corrs, marker="o", label=pop, linewidth=2, markersize=6, color=color
+        )
+
+        # Plot error bands for trial-based analysis
+        if is_trial_based and len(plot_ci_lower) > 0:
+            plot_ci_lower = np.array(plot_ci_lower)
+            plot_ci_upper = np.array(plot_ci_upper)
+            plt.fill_between(plot_freqs, plot_ci_lower, plot_ci_upper, alpha=0.2, color=color)
+
+    # Formatting
     plt.xlabel("Frequency (Hz)", fontsize=12)
     plt.ylabel("Spike Rate-Power Correlation", fontsize=12)
-    plt.title("Spike rate LFP power correlation during stimulus", fontsize=14)
-    plt.grid(True, alpha=0.3)
-    plt.legend(fontsize=12)
-    plt.xticks(frequencies[::2])  # Display every other frequency on x-axis
 
-    # Add horizontal line at zero for reference
+    # Calculate percentage for title
+    firing_percentage = round(float((1 - firing_quantile) * 100), 1)
+    if is_trial_based:
+        title = f"Trial-averaged Spike Rate-LFP Power Correlation\nTop {firing_percentage}% Firing Cells (95% CI)"
+    else:
+        title = f"Spike Rate-LFP Power Correlation\nTop {firing_percentage}% Firing Cells"
+
+    plt.title(title, fontsize=14)
+    plt.grid(True, alpha=0.3)
     plt.axhline(y=0, color="gray", linestyle="-", alpha=0.5)
 
-    # Set y-axis limits to make zero visible
+    # Legend
+    # Create legend elements for each population
+    from matplotlib.lines import Line2D
+
+    colors = plt.get_cmap("tab10")
+    legend_elements = [
+        Line2D([0], [0], color=colors(i), marker="o", linestyle="-", label=pop)
+        for i, pop in enumerate(pop_names)
+    ]
+
+    # Add error band legend element for trial-based analysis
+    if is_trial_based:
+        # Map error type to legend label
+        error_labels = {"ci": "95% CI", "sem": "±SEM", "std": "±1 SD"}
+        error_label = error_labels[error_type]
+
+        legend_elements.append(
+            Line2D([0], [0], color="gray", alpha=0.3, linewidth=10, label=error_label)
+        )
+
+    plt.legend(handles=legend_elements, fontsize=10, loc="best")
+
+    # Axis formatting
+    if len(frequencies) > 10:
+        plt.xticks(frequencies[::2])
+    else:
+        plt.xticks(frequencies)
+    plt.xlim(frequencies[0], frequencies[-1])
+
     y_min, y_max = plt.ylim()
     plt.ylim(min(y_min, -0.1), max(y_max, 0.1))
 
     plt.tight_layout()
-
     plt.show()
 
 
@@ -366,3 +609,257 @@ def plot_entrainment_swarm_plot(ppc_dict, pop_names, freq, save_path=None, title
         plt.savefig(f"{save_path}/ppc_change_swarm_plot_{freq}Hz.png", dpi=300, bbox_inches="tight")
 
     plt.show()
+
+
+def plot_trial_avg_entrainment(
+    spike_df: pd.DataFrame,
+    lfp: np.ndarray,
+    time_windows: List[Tuple[float, float]],
+    entrainment_method: str,
+    pop_names: List[str],
+    freqs: Union[List[float], np.ndarray],
+    firing_quantile: float,
+    spike_fs: float = 1000,
+    error_type: str = "ci",  # New parameter: "ci" for confidence interval, "sem" for standard error, "std" for standard deviation
+) -> None:
+    """
+    Plot trial-averaged entrainment for specified population names. Only supports wavelet filter current, could easily add other support
+
+    Parameters:
+    -----------
+    spike_df : pd.DataFrame
+        Spike data containing timestamps, node_ids, and pop_name columns
+    spike_fs : float
+        fs for spike data. Default is 1000
+    lfp : xarray
+        Xarray for a channel of the lfp data
+    time_windows : List[Tuple[float, float]]
+        List of windows to analysis with start and stp time [(start_time, end_time), ...] for each trial
+    entrainment_method : str
+        Method for entrainment calculation ('ppc', 'ppc2' or 'plv')
+    pop_names : List[str]
+        List of population names to process (e.g., ['FSI', 'LTS'])
+    freqs : Union[List[float], np.ndarray]
+        Array of frequencies to analyze (Hz)
+    firing_quantile : float
+        Upper quantile threshold for selecting high-firing cells (e.g., 0.8 for top 20%)
+    error_type : str
+        Type of error bars to plot: "ci" for 95% confidence interval, "sem" for standard error, "std" for standard deviation
+
+    Raises:
+    -------
+    ValueError
+        If entrainment_method is not 'ppc', 'ppc2' or 'plv'
+        If error_type is not 'ci', 'sem', or 'std'
+        If no spikes found for a population in a trial
+
+    Returns:
+    --------
+    None
+        Displays plot and prints summary statistics
+    """
+    sns.set_style("whitegrid")
+    # Validate inputs
+    if entrainment_method not in ["ppc", "plv", "ppc2"]:
+        raise ValueError("entrainment_method must be 'ppc', ppc2 or 'plv'")
+
+    if error_type not in ["ci", "sem", "std"]:
+        raise ValueError(
+            "error_type must be 'ci' for confidence interval, 'sem' for standard error, or 'std' for standard deviation"
+        )
+
+    if not (0 <= firing_quantile < 1):
+        raise ValueError("firing_quantile must be between 0 and 1")
+
+    # Convert freqs to numpy array for easier indexing
+    freqs = np.array(freqs)
+
+    # Collect all PPC/PLV values across trials for each population
+    all_plv_data = {}  # Dictionary to store results for each population
+
+    # Initialize storage for each population
+    for pop_name in pop_names:
+        all_plv_data[pop_name] = []  # Will be shape (n_trials, n_freqs)
+
+    # Loop through all pulse groups to collect data
+    for trial_idx in range(len(time_windows)):
+        plv_lists = {}  # Store PLV lists for this trial
+
+        # Initialize PLV lists for each population
+        for pop_name in pop_names:
+            plv_lists[pop_name] = []
+
+        # Filter spikes for this trial
+        network_spikes = spike_df[
+            (spike_df["timestamps"] >= time_windows[trial_idx][0])
+            & (spike_df["timestamps"] <= time_windows[trial_idx][1])
+        ].copy()
+
+        # Process each population
+        pop_spike_data = {}
+        for pop_name in pop_names:
+            # Get spikes for this population
+            pop_spikes = network_spikes[network_spikes["pop_name"] == pop_name]
+
+            if len(pop_spikes) == 0:
+                print(f"Warning: No spikes found for population {pop_name} in trial {trial_idx}")
+                # Add NaN values for this trial/population
+                plv_lists[pop_name] = [np.nan] * len(freqs)
+                continue
+
+            # Filter to get the top firing cells
+            # firing_quantile of 0.8 gets the top 20% of firing cells to use
+            pop_spikes = bmspikes.find_highest_firing_cells(
+                pop_spikes, upper_quantile=firing_quantile
+            )
+
+            if len(pop_spikes) == 0:
+                print(
+                    f"Warning: No high-firing spikes found for population {pop_name} in trial {trial_idx}"
+                )
+                plv_lists[pop_name] = [np.nan] * len(freqs)
+                continue
+
+            pop_spike_data[pop_name] = pop_spikes
+
+        # Calculate PPC/PLV for each frequency and each population
+        for freq_idx, freq in enumerate(freqs):
+            for pop_name in pop_names:
+                if pop_name not in pop_spike_data:
+                    continue  # Skip if no data for this population
+
+                pop_spikes = pop_spike_data[pop_name]
+
+                try:
+                    if entrainment_method == "ppc":
+                        result = bmentr.calculate_ppc(
+                            pop_spikes["timestamps"].values,
+                            lfp,
+                            spike_fs=spike_fs,
+                            lfp_fs=lfp.fs,
+                            freq_of_interest=freq,
+                            filter_method="wavelet",
+                            ppc_method="gpu",
+                        )
+                    elif entrainment_method == "plv":
+                        result = bmentr.calculate_spike_lfp_plv(
+                            pop_spikes["timestamps"].values,
+                            lfp,
+                            spike_fs=spike_fs,
+                            lfp_fs=lfp.fs,
+                            freq_of_interest=freq,
+                            filter_method="wavelet",
+                        )
+                    elif entrainment_method == "ppc2":
+                        result = bmentr.calculate_ppc2(
+                            pop_spikes["timestamps"].values,
+                            lfp,
+                            spike_fs=spike_fs,
+                            lfp_fs=lfp.fs,
+                            freq_of_interest=freq,
+                            filter_method="wavelet",
+                        )
+
+                    plv_lists[pop_name].append(result)
+
+                except Exception as e:
+                    print(
+                        f"Warning: Error calculating {entrainment_method} for {pop_name} at {freq}Hz in trial {trial_idx}: {e}"
+                    )
+                    plv_lists[pop_name].append(np.nan)
+
+        # Store this trial's results for each population
+        for pop_name in pop_names:
+            if pop_name in plv_lists and len(plv_lists[pop_name]) == len(freqs):
+                all_plv_data[pop_name].append(plv_lists[pop_name])
+            else:
+                # Fill with NaNs if data is missing
+                all_plv_data[pop_name].append([np.nan] * len(freqs))
+
+    # Convert to numpy arrays and calculate statistics
+    mean_plv = {}
+    error_plv = {}
+
+    for pop_name in pop_names:
+        all_plv_data[pop_name] = np.array(all_plv_data[pop_name])  # Shape: (n_trials, n_freqs)
+
+        # Calculate statistics across trials, ignoring NaN values
+        with np.errstate(invalid="ignore"):  # Suppress warnings for all-NaN slices
+            mean_plv[pop_name] = np.nanmean(all_plv_data[pop_name], axis=0)
+
+            if error_type == "ci":
+                # Calculate 95% confidence intervals using SEM
+                valid_counts = np.sum(~np.isnan(all_plv_data[pop_name]), axis=0)
+                sem_plv = np.nanstd(all_plv_data[pop_name], axis=0, ddof=1) / np.sqrt(valid_counts)
+
+                # For 95% CI, multiply SEM by appropriate t-value
+                # Use minimum valid count across frequencies for conservative t-value
+                min_valid_trials = np.min(valid_counts[valid_counts > 1])  # Avoid division by zero
+                if min_valid_trials > 1:
+                    t_value = stats.t.ppf(0.975, min_valid_trials - 1)  # 95% CI, two-tailed
+                    error_plv[pop_name] = t_value * sem_plv
+                else:
+                    error_plv[pop_name] = np.full_like(sem_plv, np.nan)
+
+            elif error_type == "sem":
+                # Calculate standard error of the mean
+                valid_counts = np.sum(~np.isnan(all_plv_data[pop_name]), axis=0)
+                error_plv[pop_name] = np.nanstd(all_plv_data[pop_name], axis=0, ddof=1) / np.sqrt(
+                    valid_counts
+                )
+
+            elif error_type == "std":
+                # Calculate standard deviation
+                error_plv[pop_name] = np.nanstd(all_plv_data[pop_name], axis=0, ddof=1)
+
+    # Create the combined plot
+    plt.figure(figsize=(12, 8))
+
+    # Define markers and colors for different populations
+    markers = ["o-", "s-", "^-", "D-", "v-", "<-", ">-", "p-"]
+    colors = sns.color_palette(n_colors=len(pop_names))
+
+    # Plot each population
+    for i, pop_name in enumerate(pop_names):
+        marker = markers[i % len(markers)]  # Cycle through markers if more populations than markers
+        color = colors[i]
+
+        # Only plot if we have valid data
+        valid_mask = ~np.isnan(mean_plv[pop_name])
+        if np.any(valid_mask):
+            plt.plot(
+                freqs[valid_mask],
+                mean_plv[pop_name][valid_mask],
+                marker,
+                linewidth=2,
+                label=pop_name,
+                color=color,
+                markersize=6,
+            )
+
+            # Add error bars/shading if available
+            if not np.all(np.isnan(error_plv[pop_name])):
+                plt.fill_between(
+                    freqs[valid_mask],
+                    (mean_plv[pop_name] - error_plv[pop_name])[valid_mask],
+                    (mean_plv[pop_name] + error_plv[pop_name])[valid_mask],
+                    alpha=0.3,
+                    color=color,
+                )
+
+    plt.xlabel("Frequency (Hz)", fontsize=12)
+    plt.ylabel(f"{entrainment_method.upper()}", fontsize=12)
+
+    # Calculate percentage for title and update title based on error type
+    firing_percentage = round(float((1 - firing_quantile) * 100), 1)
+    error_labels = {"ci": "95% CI", "sem": "±SEM", "std": "±1 SD"}
+    error_label = error_labels[error_type]
+    plt.title(
+        f"{entrainment_method.upper()} Across Trials for Top {firing_percentage}% Firing Cells ({error_label})",
+        fontsize=14,
+    )
+
+    plt.legend(fontsize=10)
+    plt.grid(True, alpha=0.3)
+    plt.tight_layout()
+    plt.show()

bmtool/bmplot/spikes.py

@@ -20,6 +20,7 @@ def raster(
     tstart: Optional[float] = None,
     tstop: Optional[float] = None,
     color_map: Optional[Dict[str, str]] = None,
+    dot_size: Optional[float] = 0.3,
 ) -> Axes:
     """
     Plots a raster plot of neural spikes, with different colors for each population.
@@ -40,6 +41,8 @@ def raster(
         Stop time for filtering spikes; only spikes with timestamps less than `tstop` will be plotted.
     color_map : dict, optional
         Dictionary specifying colors for each population. Keys should be population names, and values should be color values.
+    dot_size: float, optional
+        Size of the dot to display on the scatterplot
 
     Returns:
     -------
@@ -53,6 +56,7 @@ def raster(
     - If `color_map` is provided, it should contain colors for all unique `pop_name` values in `spikes_df`.
     """
     # Initialize axes if none provided
+    sns.set_style("whitegrid")
     if ax is None:
         _, ax = plt.subplots(1, 1)
 
@@ -102,15 +106,17 @@ def raster(
             raise ValueError(f"color_map is missing colors for populations: {missing_colors}")
 
     # Plot each population with its specified or generated color
+    legend_handles = []
     for pop_name, group in spikes_df.groupby(groupby):
-        ax.scatter(
-            group["timestamps"], group["node_ids"], label=pop_name, color=color_map[pop_name], s=0.5
-        )
+        ax.scatter(group["timestamps"], group["node_ids"], color=color_map[pop_name], s=dot_size)
+        # Dummy scatter for consistent legend appearance
+        handle = ax.scatter([], [], color=color_map[pop_name], label=pop_name, s=20)
+        legend_handles.append(handle)
 
     # Label axes
     ax.set_xlabel("Time")
     ax.set_ylabel("Node ID")
-    ax.legend(title="Population", loc="upper right", framealpha=0.9, markerfirst=False)
+    ax.legend(handles=legend_handles, title="Population", loc="upper right", framealpha=0.9)
 
     return ax
 
@@ -142,6 +148,7 @@ def plot_firing_rate_pop_stats(
         Axes with the bar plot.
     """
     # Ensure groupby is a list for consistent handling
+    sns.set_style("whitegrid")
     if isinstance(groupby, str):
         groupby = [groupby]
 
@@ -234,6 +241,7 @@ def plot_firing_rate_distribution(
     matplotlib.axes.Axes
         Axes with the selected plot type(s) overlayed.
     """
+    sns.set_style("whitegrid")
     # Ensure groupby is a list for consistent handling
     if isinstance(groupby, str):
         groupby = [groupby]
@@ -287,8 +295,9 @@ def plot_firing_rate_distribution(
                 y="firing_rate",
                 ax=ax,
                 palette=color_map,
-                inner="quartile",
+                inner="box",
                 alpha=0.4,
+                cut=0,  # This prevents the KDE from extending beyond the data range
             )
         elif pt == "swarm":
             sns.swarmplot(
@@ -308,3 +317,107 @@ def plot_firing_rate_distribution(
     ax.grid(axis="y", linestyle="--", alpha=0.7)
 
     return ax
+
+
+def plot_firing_rate_vs_node_attribute(
+    individual_stats: Optional[pd.DataFrame] = None,
+    config: Optional[str] = None,
+    nodes: Optional[pd.DataFrame] = None,
+    groupby: Optional[str] = None,
+    network_name: Optional[str] = None,
+    attribute: Optional[str] = None,
+    figsize=(12, 8),
+    dot_size: float = 3,
+) -> plt.Figure:
+    """
+    Plot firing rate vs node attribute for each group in separate subplots.
+
+    Parameters
+    ----------
+    individual_stats : pd.DataFrame, optional
+        DataFrame containing individual cell firing rates from compute_firing_rate_stats
+    config : str, optional
+        Path to configuration file for loading node data
+    nodes : pd.DataFrame, optional
+        Pre-loaded node data as alternative to loading from config
+    groupby : str, optional
+        Column name in individual_stats to group plots by
+    network_name : str, optional
+        Name of network to load from config file
+    attribute : str, optional
+        Node attribute column name to plot against firing rate
+    figsize : tuple[int, int], optional
+        Figure dimensions (width, height) in inches
+    dot_size : float, optional
+        Size of scatter plot points
+
+    Returns
+    -------
+    matplotlib.figure.Figure
+        Figure containing the subplots
+
+    Raises
+    ------
+    ValueError
+        If neither config nor nodes is provided
+        If network_name is missing when using config
+        If attribute is not found in nodes DataFrame
+        If node_ids column is missing
+        If nodes index is not unique
+    """
+    # Input validation
+    if config is None and nodes is None:
+        raise ValueError("Must provide either config or nodes")
+    if config is not None and nodes is None:
+        if network_name is None:
+            raise ValueError("network_name required when using config")
+        nodes = load_nodes_from_config(config)
+    if attribute not in nodes.columns:
+        raise ValueError(f"Attribute '{attribute}' not found in nodes DataFrame")
+
+    # Extract node attribute data
+    node_attribute = nodes[attribute]
+
+    # Validate data structure
+    if "node_ids" not in individual_stats.columns:
+        raise ValueError("individual_stats missing required 'node_ids' column")
+    if not nodes.index.is_unique:
+        raise ValueError("nodes DataFrame must have unique index for merging")
+
+    # Merge firing rate data with node attributes
+    merged_df = individual_stats.merge(
+        node_attribute, left_on="node_ids", right_index=True, how="left"
+    )
+
+    # Setup subplot layout
+    max_groups = 15  # Maximum number of subplots to avoid overcrowding
+    unique_groups = merged_df[groupby].unique()
+    n_groups = min(len(unique_groups), max_groups)
+
+    if len(unique_groups) > max_groups:
+        print(f"Warning: Limiting display to {max_groups} groups out of {len(unique_groups)}")
+        unique_groups = unique_groups[:max_groups]
+
+    n_cols = min(3, n_groups)
+    n_rows = (n_groups + n_cols - 1) // n_cols
+
+    # Create subplots
+    fig, axes = plt.subplots(n_rows, n_cols, figsize=figsize)
+    if n_groups == 1:
+        axes = np.array([axes])
+    axes = axes.flatten()
+
+    # Plot each group
+    for i, group in enumerate(unique_groups):
+        group_df = merged_df[merged_df[groupby] == group]
+        axes[i].scatter(group_df["firing_rate"], group_df[attribute], s=dot_size)
+        axes[i].set_xlabel("Firing Rate (Hz)")
+        axes[i].set_ylabel(attribute)
+        axes[i].set_title(f"{groupby}: {group}")
+
+    # Hide unused subplots
+    for j in range(i + 1, len(axes)):
+        axes[j].set_visible(False)
+
+    plt.tight_layout()
+    plt.show()

bmtool/synapses.py

@@ -18,7 +18,7 @@ from scipy.optimize import curve_fit, minimize, minimize_scalar
 from scipy.signal import find_peaks
 from tqdm.notebook import tqdm
 
-from bmtool.util.util import load_mechanisms_from_config, load_templates_from_config
+from bmtool.util.util import load_templates_from_config
 
 
 class SynapseTuner:
@@ -69,7 +69,7 @@ class SynapseTuner:
             neuron.load_mechanisms(mechanisms_dir)
             h.load_file(templates_dir)
         else:
-            load_mechanisms_from_config(config)
+            # loads both mech and templates
             load_templates_from_config(config)
 
         self.conn_type_settings = conn_type_settings
@@ -983,7 +983,7 @@ class GapJunctionTuner:
             neuron.load_mechanisms(mechanisms_dir)
             h.load_file(templates_dir)
         else:
-            load_mechanisms_from_config(config)
+            # this will load both mechs and templates
             load_templates_from_config(config)
 
         self.general_settings = general_settings

bmtool/util/util.py

@@ -447,6 +447,9 @@ def load_mechanisms_from_config(config=None):
 
 
 def load_templates_from_config(config=None):
+    """
+    loads the neuron mechanisms and templates provided from BMTK config
+    """
     if config is None:
         config = "simulation_config.json"
     config = load_config(config)

{bmtool-0.7.1.7.dist-info → bmtool-0.7.2.dist-info}/METADATA

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

{bmtool-0.7.1.7.dist-info → bmtool-0.7.2.dist-info}/RECORD

@@ -6,29 +6,29 @@ bmtool/graphs.py,sha256=gBTzI6c2BBK49dWGcfWh9c56TAooyn-KaiEy0Im1HcI,6717
 bmtool/manage.py,sha256=lsgRejp02P-x6QpA7SXcyXdalPhRmypoviIA2uAitQs,608
 bmtool/plot_commands.py,sha256=Dxm_RaT4CtHnfsltTtUopJ4KVbfhxtktEB_b7bFEXII,12716
 bmtool/singlecell.py,sha256=I2yolbAnNC8qpnRkNdnDCLidNW7CktmBuRrcowMZJ3A,45041
-bmtool/synapses.py,sha256=hRuxRCXVpu0_0egi183qyp343tT-_gZNSxjk9rT5J8Q,66175
+bmtool/synapses.py,sha256=y8UJAqO1jpZY-mY9gVVMN8Dj1r9jD2fI1nAaNQeQfz4,66148
 bmtool/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bmtool/analysis/entrainment.py,sha256=TUeV-WfCfVPqilVTjg6Cv1WKOz_zSX7LeE7k2Wuceug,28449
+bmtool/analysis/entrainment.py,sha256=NQloQtVpEWjDzmkZwMWVcm3hSjErHBZfQl1mrBVoIE8,25321
 bmtool/analysis/lfp.py,sha256=S2JvxkjcK3-EH93wCrhqNSFY6cX7fOq74pz64ibHKrc,26556
 bmtool/analysis/netcon_reports.py,sha256=VnPZNKPaQA7oh1q9cIatsqQudm4cOtzNtbGPXoiDCD0,2909
-bmtool/analysis/spikes.py,sha256=u7Qu0NVGPDAH5jlgNLv32H1hDAkOlG6P4nKEFeAOkdE,22833
+bmtool/analysis/spikes.py,sha256=3n-xmyEZ7w6CKEND7-aKOAvdDg0lwDuPI5sMdOuPwa0,24637
 bmtool/bmplot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bmtool/bmplot/connections.py,sha256=P1JBG4xCbLVq4sfQuUE6c3dO949qajrjdQcrazdmDS4,53861
-bmtool/bmplot/entrainment.py,sha256=YBHTJ-nK0OgM8CNssM8IyqPNYez9ss9bQi-C5HW4kGw,12593
+bmtool/bmplot/connections.py,sha256=KSORZ43v1B5xfiBN6AnAD7tJySVTkLIY3j_zb2r-YPA,55696
+bmtool/bmplot/entrainment.py,sha256=BrBMerqyiG2YWAO_OEFv7OJf3yeFz3l9jUt4NamluLc,32837
 bmtool/bmplot/lfp.py,sha256=SNpbWGOUnYEgnkeBw5S--aPN5mIGD22Gw2Pwus0_lvY,2034
 bmtool/bmplot/netcon_reports.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bmtool/bmplot/spikes.py,sha256=RJOOtmgWhTvyVi1CghoKTtxvt7MF9cJCrJVm5hV5wA4,11210
+bmtool/bmplot/spikes.py,sha256=odzCSMbFRHp9qthSGQ0WzMWUwNQ7R1Z6gLT6VPF_o5Q,15326
 bmtool/debug/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/debug/commands.py,sha256=VV00f6q5gzZI503vUPeG40ABLLen0bw_k4-EX-H5WZE,580
 bmtool/debug/debug.py,sha256=9yUFvA4_Bl-x9s29quIEG3pY-S8hNJF3RKBfRBHCl28,208
 bmtool/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/util/commands.py,sha256=Nn-R-4e9g8ZhSPZvTkr38xeKRPfEMANB9Lugppj82UI,68564
-bmtool/util/util.py,sha256=owce5BEusZO_8T5x05N2_B583G26vWAy7QX29V0Pj0Y,62818
+bmtool/util/util.py,sha256=S8sAXwDiISGAqnSXRIgFqxqCRzL5YcxAqP1UGxGA5Z4,62906
 bmtool/util/neuron/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/util/neuron/celltuner.py,sha256=lokRLUM1rsdSYBYrNbLBBo39j14mm8TBNVNRnSlhHCk,94868
-bmtool-0.7.1.7.dist-info/licenses/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
-bmtool-0.7.1.7.dist-info/METADATA,sha256=-2fuMCtlaM_YoVuYHcuhNAGe-Cw-5Yfb3kqejIV7S6c,3577
-bmtool-0.7.1.7.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-bmtool-0.7.1.7.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
-bmtool-0.7.1.7.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
-bmtool-0.7.1.7.dist-info/RECORD,,
+bmtool-0.7.2.dist-info/licenses/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
+bmtool-0.7.2.dist-info/METADATA,sha256=JacxbP2RvvbSuuveedTUJjl8KeqOCKf4FlW-UrRmfCk,3575
+bmtool-0.7.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bmtool-0.7.2.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
+bmtool-0.7.2.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
+bmtool-0.7.2.dist-info/RECORD,,

{bmtool-0.7.1.7.dist-info → bmtool-0.7.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any