bmtool 0.7.0.6.2__py3-none-any.whl → 0.7.1__py3-none-any.whl

bmtool/bmplot/entrainment.py

@@ -1,11 +1,11 @@
-
 import matplotlib.pyplot as plt
 import seaborn as sns
 
+
 def plot_spike_power_correlation(correlation_results, frequencies, pop_names):
     """
     Plot the correlation between population spike rates and LFP power.
-    
+
     Parameters:
     -----------
     correlation_results : dict
@@ -17,35 +17,34 @@ def plot_spike_power_correlation(correlation_results, frequencies, pop_names):
     """
     sns.set_style("whitegrid")
     plt.figure(figsize=(10, 6))
-    
+
     for pop in pop_names:
         # Extract correlation values for each frequency
         corr_values = []
         valid_freqs = []
-        
+
         for freq in frequencies:
             if freq in correlation_results[pop]:
-                corr_values.append(correlation_results[pop][freq]['correlation'])
+                corr_values.append(correlation_results[pop][freq]["correlation"])
                 valid_freqs.append(freq)
-        
+
         # Plot correlation line
-        plt.plot(valid_freqs, corr_values, marker='o', label=pop, 
-                linewidth=2, markersize=6)
-    
-    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.plot(valid_freqs, corr_values, marker="o", label=pop, linewidth=2, markersize=6)
+
+    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
-    plt.axhline(y=0, color='gray', linestyle='-', alpha=0.5)
-    
+    plt.axhline(y=0, color="gray", linestyle="-", alpha=0.5)
+
     # Set y-axis limits to make zero visible
     y_min, y_max = plt.ylim()
     plt.ylim(min(y_min, -0.1), max(y_max, 0.1))
-    
+
     plt.tight_layout()
-    
-    plt.show()
+
+    plt.show()

bmtool/bmplot/lfp.py

@@ -1,35 +1,43 @@
+import matplotlib.pyplot as plt
 import numpy as np
+
 from bmtool.analysis.lfp import gen_aperiodic
-import matplotlib.pyplot as plt
 
 
-def plot_spectrogram(sxx_xarray, remove_aperiodic=None, log_power=False,
-                     plt_range=None, clr_freq_range=None, pad=0.03, ax=None):
+def plot_spectrogram(
+    sxx_xarray,
+    remove_aperiodic=None,
+    log_power=False,
+    plt_range=None,
+    clr_freq_range=None,
+    pad=0.03,
+    ax=None,
+):
     """Plot spectrogram. Determine color limits using value in frequency band clr_freq_range"""
     sxx = sxx_xarray.PSD.values.copy()
     t = sxx_xarray.time.values.copy()
     f = sxx_xarray.frequency.values.copy()
 
-    cbar_label = 'PSD' if remove_aperiodic is None else 'PSD Residual'
+    cbar_label = "PSD" if remove_aperiodic is None else "PSD Residual"
     if log_power:
-        with np.errstate(divide='ignore'):
+        with np.errstate(divide="ignore"):
             sxx = np.log10(sxx)
-        cbar_label += ' dB' if log_power == 'dB' else ' log(power)'
+        cbar_label += " dB" if log_power == "dB" else " log(power)"
 
     if remove_aperiodic is not None:
         f1_idx = 0 if f[0] else 1
         ap_fit = gen_aperiodic(f[f1_idx:], remove_aperiodic.aperiodic_params)
-        sxx[f1_idx:, :] -= (ap_fit if log_power else 10 ** ap_fit)[:, None]
-        sxx[:f1_idx, :] = 0.
+        sxx[f1_idx:, :] -= (ap_fit if log_power else 10**ap_fit)[:, None]
+        sxx[:f1_idx, :] = 0.0
 
-    if log_power == 'dB':
+    if log_power == "dB":
         sxx *= 10
 
     if ax is None:
         _, ax = plt.subplots(1, 1)
     plt_range = np.array(f[-1]) if plt_range is None else np.array(plt_range)
     if plt_range.size == 1:
-        plt_range = [f[0 if f[0] else 1] if log_power else 0., plt_range.item()]
+        plt_range = [f[0 if f[0] else 1] if log_power else 0.0, plt_range.item()]
     f_idx = (f >= plt_range[0]) & (f <= plt_range[1])
     if clr_freq_range is None:
         vmin, vmax = None, None
@@ -38,16 +46,15 @@ def plot_spectrogram(sxx_xarray, remove_aperiodic=None, log_power=False,
         vmin, vmax = sxx[c_idx, :].min(), sxx[c_idx, :].max()
 
     f = f[f_idx]
-    pcm = ax.pcolormesh(t, f, sxx[f_idx, :], shading='gouraud', vmin=vmin, vmax=vmax)
-    if 'cone_of_influence_frequency' in sxx_xarray:
+    pcm = ax.pcolormesh(t, f, sxx[f_idx, :], shading="gouraud", vmin=vmin, vmax=vmax)
+    if "cone_of_influence_frequency" in sxx_xarray:
         coif = sxx_xarray.cone_of_influence_frequency
         ax.plot(t, coif)
-        ax.fill_between(t, coif, step='mid', alpha=0.2)
+        ax.fill_between(t, coif, step="mid", alpha=0.2)
     ax.set_xlim(t[0], t[-1])
-    #ax.set_xlim(t[0],0.2)
+    # ax.set_xlim(t[0],0.2)
     ax.set_ylim(f[0], f[-1])
     plt.colorbar(mappable=pcm, ax=ax, label=cbar_label, pad=pad)
-    ax.set_xlabel('Time (sec)')
-    ax.set_ylabel('Frequency (Hz)')
+    ax.set_xlabel("Time (sec)")
+    ax.set_ylabel("Frequency (Hz)")
     return sxx
-

bmtool/bmplot/netcon_reports.py

@@ -1,4 +0,0 @@
-
-
-
-

bmtool/bmplot/spikes.py

@@ -1,19 +1,27 @@
-from ..util.util import load_nodes_from_config
-from typing import Optional, Dict, List, Union
-import pandas as pd
-from matplotlib.axes import Axes
+from typing import Dict, List, Optional, Union
+
 import matplotlib.pyplot as plt
-import seaborn as sns
 import numpy as np
+import pandas as pd
+import seaborn as sns
+from matplotlib.axes import Axes
 
+from ..util.util import load_nodes_from_config
 
 
-def raster(spikes_df: Optional[pd.DataFrame] = None, config: Optional[str] = None, network_name: Optional[str] = None, groupby:Optional[str] = 'pop_name',
-           ax: Optional[Axes] = None,tstart: Optional[float] = None,tstop: Optional[float] = None,
-           color_map: Optional[Dict[str, str]] = None) -> Axes:
+def raster(
+    spikes_df: Optional[pd.DataFrame] = None,
+    config: Optional[str] = None,
+    network_name: Optional[str] = None,
+    groupby: Optional[str] = "pop_name",
+    ax: Optional[Axes] = None,
+    tstart: Optional[float] = None,
+    tstop: Optional[float] = None,
+    color_map: Optional[Dict[str, str]] = None,
+) -> Axes:
     """
     Plots a raster plot of neural spikes, with different colors for each population.
-    
+
     Parameters:
     ----------
     spikes_df : pd.DataFrame, optional
@@ -30,12 +38,12 @@ def raster(spikes_df: Optional[pd.DataFrame] = None, config: Optional[str] = Non
         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.
-    
+
     Returns:
     -------
     matplotlib.axes.Axes
         Axes with the raster plot.
-    
+
     Notes:
     -----
     - If `config` is provided, the function merges population names from the node data with `spikes_df`.
@@ -48,9 +56,9 @@ def raster(spikes_df: Optional[pd.DataFrame] = None, config: Optional[str] = Non
 
     # Filter spikes by time range if specified
     if tstart is not None:
-        spikes_df = spikes_df[spikes_df['timestamps'] > tstart]
+        spikes_df = spikes_df[spikes_df["timestamps"] > tstart]
     if tstop is not None:
-        spikes_df = spikes_df[spikes_df['timestamps'] < tstop]
+        spikes_df = spikes_df[spikes_df["timestamps"] < tstop]
 
     # Load and merge node population data if config is provided
     if config:
@@ -59,45 +67,59 @@ def raster(spikes_df: Optional[pd.DataFrame] = None, config: Optional[str] = Non
             nodes = nodes.get(network_name, {})
         else:
             nodes = list(nodes.values())[0] if nodes else {}
-            print("Grabbing first network; specify a network name to ensure correct node population is selected.")
-        
+            print(
+                "Grabbing first network; specify a network name to ensure correct node population is selected."
+            )
+
         # Find common columns, but exclude the join key from the list
         common_columns = spikes_df.columns.intersection(nodes.columns).tolist()
-        common_columns = [col for col in common_columns if col != 'node_ids']  # Remove our join key from the common list
+        common_columns = [
+            col for col in common_columns if col != "node_ids"
+        ]  # Remove our join key from the common list
 
         # Drop all intersecting columns except the join key column from df2
         spikes_df = spikes_df.drop(columns=common_columns)
         # merge nodes and spikes df
-        spikes_df = spikes_df.merge(nodes[groupby], left_on='node_ids', right_index=True, how='left')
-
+        spikes_df = spikes_df.merge(
+            nodes[groupby], left_on="node_ids", right_index=True, how="left"
+        )
 
     # Get unique population names
     unique_pop_names = spikes_df[groupby].unique()
-    
+
     # Generate colors if no color_map is provided
     if color_map is None:
-        cmap = plt.get_cmap('tab10')  # Default colormap
-        color_map = {pop_name: cmap(i / len(unique_pop_names)) for i, pop_name in enumerate(unique_pop_names)}
+        cmap = plt.get_cmap("tab10")  # Default colormap
+        color_map = {
+            pop_name: cmap(i / len(unique_pop_names)) for i, pop_name in enumerate(unique_pop_names)
+        }
     else:
         # Ensure color_map contains all population names
         missing_colors = [pop for pop in unique_pop_names if pop not in color_map]
         if missing_colors:
             raise ValueError(f"color_map is missing colors for populations: {missing_colors}")
-    
+
     # Plot each population with its specified or generated color
     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"], label=pop_name, color=color_map[pop_name], s=0.5
+        )
 
     # 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(title="Population", loc="upper right", framealpha=0.9, markerfirst=False)
+
     return ax
-    
+
+
 # uses df from bmtool.analysis.spikes compute_firing_rate_stats
-def plot_firing_rate_pop_stats(firing_stats: pd.DataFrame, groupby: Union[str, List[str]], ax: Optional[Axes] = None, 
-                               color_map: Optional[Dict[str, str]] = None) -> Axes:
+def plot_firing_rate_pop_stats(
+    firing_stats: pd.DataFrame,
+    groupby: Union[str, List[str]],
+    ax: Optional[Axes] = None,
+    color_map: Optional[Dict[str, str]] = None,
+) -> Axes:
     """
     Plots a bar graph of mean firing rates with error bars (standard deviation).
 
@@ -129,7 +151,7 @@ def plot_firing_rate_pop_stats(firing_stats: pd.DataFrame, groupby: Union[str, L
 
     # Generate colors if no color_map is provided
     if color_map is None:
-        cmap = plt.get_cmap('viridis')
+        cmap = plt.get_cmap("viridis")
         color_map = {group: cmap(i / len(unique_groups)) for i, group in enumerate(unique_groups)}
     else:
         # Ensure color_map contains all groups
@@ -157,13 +179,13 @@ def plot_firing_rate_pop_stats(firing_stats: pd.DataFrame, groupby: Union[str, L
 
     # Add error bars manually with caps
     _, caps, _ = ax.errorbar(
-        x=np.arange(len(x_labels)), 
-        y=means, 
-        yerr=std_devs, 
-        fmt='none', 
-        capsize=5, 
-        capthick=2, 
-        color="black"
+        x=np.arange(len(x_labels)),
+        y=means,
+        yerr=std_devs,
+        fmt="none",
+        capsize=5,
+        capthick=2,
+        color="black",
     )
 
     # Formatting
@@ -172,14 +194,20 @@ def plot_firing_rate_pop_stats(firing_stats: pd.DataFrame, groupby: Union[str, L
     ax.set_xlabel("Population Group")
     ax.set_ylabel("Mean Firing Rate (spikes/s)")
     ax.set_title("Firing Rate Statistics by Population")
-    ax.grid(axis='y', linestyle='--', alpha=0.7)
+    ax.grid(axis="y", linestyle="--", alpha=0.7)
 
     return ax
 
+
 # uses df from bmtool.analysis.spikes compute_firing_rate_stats
-def plot_firing_rate_distribution(individual_stats: pd.DataFrame, groupby: Union[str, list], ax: Optional[Axes] = None, 
-                                  color_map: Optional[Dict[str, str]] = None, 
-                                  plot_type: Union[str, list] = "box", swarm_alpha: float = 0.6) -> Axes:
+def plot_firing_rate_distribution(
+    individual_stats: pd.DataFrame,
+    groupby: Union[str, list],
+    ax: Optional[Axes] = None,
+    color_map: Optional[Dict[str, str]] = None,
+    plot_type: Union[str, list] = "box",
+    swarm_alpha: float = 0.6,
+) -> Axes:
     """
     Plots a distribution of individual firing rates using one or more plot types
     (box plot, violin plot, or swarm plot), overlaying them on top of each other.
@@ -214,7 +242,7 @@ def plot_firing_rate_distribution(individual_stats: pd.DataFrame, groupby: Union
     # Validate plot_type (it can be a list or a single type)
     if isinstance(plot_type, str):
         plot_type = [plot_type]
-    
+
     for pt in plot_type:
         if pt not in ["box", "violin", "swarm"]:
             raise ValueError("plot_type must be one of: 'box', 'violin', 'swarm'.")
@@ -224,9 +252,9 @@ def plot_firing_rate_distribution(individual_stats: pd.DataFrame, groupby: Union
 
     # Generate colors if no color_map is provided
     if color_map is None:
-        cmap = plt.get_cmap('viridis')
+        cmap = plt.get_cmap("viridis")
         color_map = {group: cmap(i / len(unique_groups)) for i, group in enumerate(unique_groups)}
-    
+
     # Ensure color_map contains all groups
     missing_colors = [group for group in unique_groups if group not in color_map]
     if missing_colors:
@@ -242,18 +270,39 @@ def plot_firing_rate_distribution(individual_stats: pd.DataFrame, groupby: Union
     # Loop over each plot type and overlay them
     for pt in plot_type:
         if pt == "box":
-            sns.boxplot(data=individual_stats, x="group", y="firing_rate", ax=ax, palette=color_map, width=0.5)
+            sns.boxplot(
+                data=individual_stats,
+                x="group",
+                y="firing_rate",
+                ax=ax,
+                palette=color_map,
+                width=0.5,
+            )
         elif pt == "violin":
-            sns.violinplot(data=individual_stats, x="group", y="firing_rate", ax=ax, palette=color_map, inner="quartile", alpha=0.4)
+            sns.violinplot(
+                data=individual_stats,
+                x="group",
+                y="firing_rate",
+                ax=ax,
+                palette=color_map,
+                inner="quartile",
+                alpha=0.4,
+            )
         elif pt == "swarm":
-            sns.swarmplot(data=individual_stats, x="group", y="firing_rate", ax=ax, palette=color_map, alpha=swarm_alpha)
+            sns.swarmplot(
+                data=individual_stats,
+                x="group",
+                y="firing_rate",
+                ax=ax,
+                palette=color_map,
+                alpha=swarm_alpha,
+            )
 
     # Formatting
     ax.set_xticklabels(ax.get_xticklabels(), rotation=45, ha="right")
     ax.set_xlabel("Population Group")
     ax.set_ylabel("Firing Rate (spikes/s)")
     ax.set_title("Firing Rate Distribution for individual cells")
-    ax.grid(axis='y', linestyle='--', alpha=0.7)
+    ax.grid(axis="y", linestyle="--", alpha=0.7)
 
     return ax
-