bmtool 0.7.1.6__tar.gz → 0.7.1.7__tar.gz

{bmtool-0.7.1.6 → bmtool-0.7.1.7}/PKG-INFO

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

{bmtool-0.7.1.6 → bmtool-0.7.1.7}/bmtool/analysis/entrainment.py

@@ -636,26 +636,26 @@ def calculate_entrainment_per_cell(
 
 
 def calculate_spike_rate_power_correlation(
-    spike_rate,
-    lfp_data,
-    fs,
-    pop_names,
-    filter_method="wavelet",
-    bandwidth=2.0,
-    lowcut=None,
-    highcut=None,
-    freq_range=(10, 100),
-    freq_step=5,
+    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 and LFP power across frequencies
-    using wavelet filtering. This function assumes the fs of the spike_rate and lfp are the same.
+    Calculate correlation between population spike rates (xarray) and LFP power across frequencies.
 
-    Parameters:
-    -----------
-    spike_rate : DataFrame
-        Pre-calculated population spike rates at the same fs as lfp
-    lfp_data : np.array
+    Parameters
+    ----------
+    spike_rate : xr.DataArray
+        Population spike rates with dimensions (time, population[, type])
+    lfp_data : np.ndarray
         LFP data
     fs : float
         Sampling frequency
@@ -673,19 +673,17 @@ def calculate_spike_rate_power_correlation(
         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:
-    --------
+    Returns
+    -------
     correlation_results : dict
         Dictionary with correlation results for each population and frequency
     frequencies : array
         Array of frequencies analyzed
     """
-
-    # Define frequency bands to analyze
     frequencies = np.arange(freq_range[0], freq_range[1] + 1, freq_step)
-
-    # Dictionary to store results
     correlation_results = {pop: {} for pop in pop_names}
 
     # Calculate power at each frequency band using specified filter
@@ -695,20 +693,22 @@ def calculate_spike_rate_power_correlation(
             lfp_data, freq, fs, filter_method, lowcut=lowcut, highcut=highcut, bandwidth=bandwidth
         )
 
-    # Calculate correlation for each population
+    # For each population, extract the correct spike rate
     for pop in pop_names:
-        # Extract spike rate for this population
-        pop_rate = spike_rate[pop]
+        # 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:
-            # Make sure the lengths match
-            if len(pop_rate) != len(power_by_freq[freq]):
-                raise ValueError(
-                    f"Mismatched lengths for {pop} at {freq} Hz len(pop_rate): {len(pop_rate)}, len(power_by_freq): {len(power_by_freq[freq])}"
-                )
-            # use spearman for non-parametric correlation
-            corr, p_val = stats.spearmanr(pop_rate, power_by_freq[freq])
+            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

{bmtool-0.7.1.6 → bmtool-0.7.1.7}/bmtool/analysis/spikes.py

@@ -282,9 +282,11 @@ def get_population_spike_rate(
 
     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, and not all cells fired, this count might be incorrect."
+            "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."
         )
-        print("You can provide a config to calculate the correct amount of nodes!")
 
     if config:
         if not network_name:

{bmtool-0.7.1.6 → bmtool-0.7.1.7}/bmtool/bmplot/entrainment.py

@@ -1,5 +1,6 @@
 import matplotlib.pyplot as plt
 import numpy as np
+import pandas as pd
 import seaborn as sns
 from matplotlib.gridspec import GridSpec
 from scipy import stats
@@ -55,7 +56,7 @@ def plot_spike_power_correlation(correlation_results, frequencies, pop_names):
 
 def plot_cycle_with_spike_histograms(phase_data, bins=36, pop_name=None):
     """
-    Plot an idealized gamma cycle with spike histograms for different neuron populations.
+    Plot an idealized cycle with spike histograms for different neuron populations.
 
     Parameters:
     -----------
@@ -120,7 +121,7 @@ def plot_cycle_with_spike_histograms(phase_data, bins=36, pop_name=None):
     plt.show()
 
 
-def plot_ppc_by_population(ppc_dict, pop_names, freqs, figsize=(15, 8), title=None):
+def plot_entrainment_by_population(ppc_dict, pop_names, freqs, figsize=(15, 8), title=None):
     """
     Plot PPC for all node populations on one graph with mean and standard error.
 
@@ -200,3 +201,168 @@ def plot_ppc_by_population(ppc_dict, pop_names, freqs, figsize=(15, 8), title=No
     # Adjust layout and save
     plt.tight_layout()
     plt.show()
+
+
+def plot_entrainment_swarm_plot(ppc_dict, pop_names, freq, save_path=None, title=None):
+    """
+    Plot a swarm plot of the entrainment for different populations at a single frequency.
+
+    Parameters:
+    -----------
+    ppc_dict : dict
+        Dictionary containing PPC values organized by population, node, and frequency
+    pop_names : list
+        List of population names to include in the plot
+    freq : float or int
+        The specific frequency to plot
+    save_path : str, optional
+        Path to save the figure. If None, figure is just displayed.
+
+    Returns:
+    --------
+    matplotlib.figure.Figure
+        The figure object for further customization if needed
+    """
+    # Set the style
+    sns.set_style("whitegrid")
+
+    # Prepare data for the swarm plot
+    data_list = []
+
+    for pop in pop_names:
+        values = []
+        node_ids = []
+
+        for node in ppc_dict[pop]:
+            if freq in ppc_dict[pop][node] and ppc_dict[pop][node][freq] is not None:
+                data_list.append(
+                    {"Population": pop, "Node": node, "PPC Difference": ppc_dict[pop][node][freq]}
+                )
+
+    # Create DataFrame in long format
+    df = pd.DataFrame(data_list)
+
+    if df.empty:
+        print(f"No data available for frequency {freq}.")
+        return None
+
+    # Print mean PPC change for each population)
+    for pop in pop_names:
+        subset = df[df["Population"] == pop]
+        if not subset.empty:
+            mean_val = subset["PPC Difference"].mean()
+            std_val = subset["PPC Difference"].std()
+            n = len(subset)
+            sem_val = std_val / np.sqrt(n)  # Standard error of the mean
+            print(f"{pop}: {mean_val:.4f} ± {sem_val:.4f} (n={n})")
+
+    # Create figure
+    plt.figure(figsize=(max(8, len(pop_names) * 1.5), 8))
+
+    # Create swarm plot
+    ax = sns.swarmplot(
+        x="Population",
+        y="PPC Difference",
+        data=df,
+        size=3,
+        # palette='Set2'
+    )
+
+    # Add sample size annotations
+    for i, pop in enumerate(pop_names):
+        subset = df[df["Population"] == pop]
+        if not subset.empty:
+            n = len(subset)
+            y_min = subset["PPC Difference"].min()
+            y_max = subset["PPC Difference"].max()
+
+            # Position annotation below the lowest point
+            plt.annotate(
+                f"n={n}", (i, y_min - 0.05 * (y_max - y_min) - 0.05), ha="center", fontsize=10
+            )
+
+    # Add reference line at y=0
+    plt.axhline(y=0, color="black", linestyle="-", linewidth=0.5, alpha=0.7)
+
+    # Add horizontal lines for mean values
+    for i, pop in enumerate(pop_names):
+        subset = df[df["Population"] == pop]
+        if not subset.empty:
+            mean_val = subset["PPC Difference"].mean()
+            plt.plot([i - 0.25, i + 0.25], [mean_val, mean_val], "r-", linewidth=2)
+
+    # Calculate and display statistics
+    if len(pop_names) > 1:
+        # Print statistical test results
+        print(f"\nMann-Whitney U Test Results at {freq} Hz:")
+        print("-" * 60)
+
+        # Add p-values for pairwise comparisons
+        y_max = df["PPC Difference"].max()
+        y_min = df["PPC Difference"].min()
+        y_range = y_max - y_min
+
+        # Perform t-tests between populations if there are at least 2
+        for i in range(len(pop_names)):
+            for j in range(i + 1, len(pop_names)):
+                pop1 = pop_names[i]
+                pop2 = pop_names[j]
+
+                vals1 = df[df["Population"] == pop1]["PPC Difference"].values
+                vals2 = df[df["Population"] == pop2]["PPC Difference"].values
+
+                if len(vals1) > 1 and len(vals2) > 1:
+                    # Perform Mann-Whitney U test (non-parametric)
+                    u_stat, p_val = stats.mannwhitneyu(vals1, vals2, alternative="two-sided")
+
+                    # Add significance markers
+                    sig_str = "ns"
+                    if p_val < 0.05:
+                        sig_str = "*"
+                    if p_val < 0.01:
+                        sig_str = "**"
+                    if p_val < 0.001:
+                        sig_str = "***"
+
+                    # Position the significance bar
+                    bar_height = y_max + 0.1 * y_range * (1 + (j - i - 1) * 0.5)
+
+                    # Draw the bar
+                    plt.plot([i, j], [bar_height, bar_height], "k-")
+                    plt.plot([i, i], [bar_height - 0.02 * y_range, bar_height], "k-")
+                    plt.plot([j, j], [bar_height - 0.02 * y_range, bar_height], "k-")
+
+                    # Add significance marker
+                    plt.text(
+                        (i + j) / 2,
+                        bar_height + 0.01 * y_range,
+                        sig_str,
+                        ha="center",
+                        va="bottom",
+                        fontsize=12,
+                    )
+
+                    # Print the statistical comparison
+                    print(f"{pop1} vs {pop2}: U={u_stat:.1f}, p={p_val:.4f} {sig_str}")
+
+    # Add labels and title
+    plt.xlabel("Population", fontsize=14)
+    plt.ylabel("PPC", fontsize=14)
+    if title:
+        plt.title(title, fontsize=16)
+
+    # Adjust y-axis limits to make room for annotations
+    y_min, y_max = plt.ylim()
+    plt.ylim(y_min - 0.15 * (y_max - y_min), y_max + 0.25 * (y_max - y_min))
+
+    # Add gridlines
+    plt.grid(True, linestyle="--", alpha=0.7, axis="y")
+
+    # Adjust layout
+    plt.tight_layout()
+
+    # Save figure if path is provided
+    if save_path:
+        plt.savefig(f"{save_path}/ppc_change_swarm_plot_{freq}Hz.png", dpi=300, bbox_inches="tight")
+
+    plt.show()

{bmtool-0.7.1.6 → bmtool-0.7.1.7}/bmtool/synapses.py

@@ -18,15 +18,18 @@ 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
+
 
 class SynapseTuner:
     def __init__(
         self,
-        mechanisms_dir: str,
-        templates_dir: str,
-        conn_type_settings: dict,
-        connection: str,
-        general_settings: dict,
+        mechanisms_dir: str = None,
+        templates_dir: str = None,
+        config: str = None,
+        conn_type_settings: dict = None,
+        connection: str = None,
+        general_settings: dict = None,
         json_folder_path: str = None,
         current_name: str = "i",
         other_vars_to_record: list = None,
@@ -57,8 +60,18 @@ class SynapseTuner:
             List of synaptic variables you would like sliders set up for the STP sliders method by default will use all parameters in spec_syn_param.
 
         """
-        neuron.load_mechanisms(mechanisms_dir)
-        h.load_file(templates_dir)
+        if config is None and (mechanisms_dir is None or templates_dir is None):
+            raise ValueError(
+                "Either a config file or both mechanisms_dir and templates_dir must be provided."
+            )
+
+        if config is None:
+            neuron.load_mechanisms(mechanisms_dir)
+            h.load_file(templates_dir)
+        else:
+            load_mechanisms_from_config(config)
+            load_templates_from_config(config)
+
         self.conn_type_settings = conn_type_settings
         if json_folder_path:
             print(f"updating settings from json path {json_folder_path}")
@@ -939,10 +952,11 @@ class SynapseTuner:
 class GapJunctionTuner:
     def __init__(
         self,
-        mechanisms_dir: str,
-        templates_dir: str,
-        general_settings: dict,
-        conn_type_settings: dict,
+        mechanisms_dir: str = None,
+        templates_dir: str = None,
+        config: str = None,
+        general_settings: dict = None,
+        conn_type_settings: dict = None,
     ):
         """
         Initialize the GapJunctionTuner class.
@@ -953,13 +967,24 @@ class GapJunctionTuner:
             Directory path containing the compiled mod files needed for NEURON mechanisms.
         templates_dir : str
             Directory path containing cell template files (.hoc or .py) loaded into NEURON.
+        config : str
+            Path to a BMTK config.json file. Can be used to load mechanisms, templates, and other settings.
         general_settings : dict
             General settings dictionary including parameters like simulation time step, duration, and temperature.
         conn_type_settings : dict
             A dictionary containing connection-specific settings for gap junctions.
         """
-        neuron.load_mechanisms(mechanisms_dir)
-        h.load_file(templates_dir)
+        if config is None and (mechanisms_dir is None or templates_dir is None):
+            raise ValueError(
+                "Either a config file or both mechanisms_dir and templates_dir must be provided."
+            )
+
+        if config is None:
+            neuron.load_mechanisms(mechanisms_dir)
+            h.load_file(templates_dir)
+        else:
+            load_mechanisms_from_config(config)
+            load_templates_from_config(config)
 
         self.general_settings = general_settings
         self.conn_type_settings = conn_type_settings
@@ -1049,7 +1074,6 @@ class GapJunctionTuner:
         plt.xlabel("Time (ms)")
         plt.ylabel("Membrane Voltage (mV)")
         plt.legend()
-        plt.show()
 
     def coupling_coefficient(self, t, v1, v2, t_start, t_end, dt=h.dt):
         """
@@ -1085,28 +1109,55 @@ class GapJunctionTuner:
 
     def InteractiveTuner(self):
         w_run = widgets.Button(description="Run", icon="history", button_style="primary")
-        values = [i * 10**-4 for i in range(1, 101)]  # From 1e-4 to 1e-2
+        values = [i * 10**-4 for i in range(1, 1001)]  # From 1e-4 to 1e-1
 
         # Create the SelectionSlider widget with appropriate formatting
-        resistance = widgets.SelectionSlider(
-            options=[("%g" % i, i) for i in values],  # Use scientific notation for display
-            value=10**-3,  # Default value
+        resistance = widgets.FloatLogSlider(
+            value=0.001,
+            base=10,
+            min=-4,  # max exponent of base
+            max=-1,  # min exponent of base
+            step=0.1,  # exponent step
             description="Resistance: ",
             continuous_update=True,
         )
 
         ui = VBox([w_run, resistance])
+
+        # Create an output widget to control what gets cleared
+        output = widgets.Output()
+
         display(ui)
+        display(output)
 
         def on_button(*args):
-            clear_output()
-            display(ui)
-            resistance_for_gap = resistance.value
-            self.model(resistance_for_gap)
-            self.plot_model()
-            cc = self.coupling_coefficient(self.t_vec, self.soma_v_1, self.soma_v_2, 500, 1000)
-            print(f"coupling_coefficient is {cc:0.4f}")
+            with output:
+                # Clear only the output widget, not the entire cell
+                output.clear_output(wait=True)
+
+                resistance_for_gap = resistance.value
+                print(f"Running simulation with resistance: {resistance_for_gap}")
+
+                try:
+                    self.model(resistance_for_gap)
+                    self.plot_model()
+
+                    # Convert NEURON vectors to numpy arrays
+                    t_array = np.array(self.t_vec)
+                    v1_array = np.array(self.soma_v_1)
+                    v2_array = np.array(self.soma_v_2)
+
+                    cc = self.coupling_coefficient(t_array, v1_array, v2_array, 500, 1000)
+                    print(f"coupling_coefficient is {cc:0.4f}")
+                    plt.show()
+
+                except Exception as e:
+                    print(f"Error during simulation or analysis: {e}")
+                    import traceback
+
+                    traceback.print_exc()
 
+        # Run once initially
         on_button()
         w_run.on_click(on_button)
 

{bmtool-0.7.1.6 → bmtool-0.7.1.7}/bmtool.egg-info/PKG-INFO

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

{bmtool-0.7.1.6 → bmtool-0.7.1.7}/setup.py

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