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

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/analysis/spikes.py

@@ -3,11 +3,12 @@ Module for processing BMTK spikes output.
 """
 
 import os
-from typing import Dict, List, Optional, Tuple, Union
+from typing import List, Optional, Tuple, Union
 
 import h5py
 import numpy as np
 import pandas as pd
+import xarray as xr
 from scipy.stats import mannwhitneyu
 
 from bmtool.util.util import load_nodes_from_config
@@ -213,9 +214,11 @@ def get_population_spike_rate(
     save: bool = False,
     save_path: Optional[str] = None,
     normalize: bool = False,
-) -> Dict[str, np.ndarray]:
+    smooth_window: int = 50,  # Window size for smoothing (in time bins)
+    smooth_method: str = "gaussian",  # Smoothing method: 'gaussian', 'boxcar', or 'exponential'
+) -> xr.DataArray:
     """
-    Calculate the population spike rate for each population in the given spike data, with an option to normalize.
+    Calculate the population spike rate for each population in the given spike data.
 
     Parameters
     ----------
@@ -239,31 +242,51 @@ def get_population_spike_rate(
         Directory path where the file should be saved if `save` is True (default: None)
     normalize : bool, optional
         Whether to normalize the spike rates for each population to a range of [0, 1] (default: False)
+    smooth_window : int, optional
+        Window size for smoothing in number of time bins (default: 50)
+    smooth_method : str, optional
+        Smoothing method to use: 'gaussian', 'boxcar', or 'exponential' (default: 'gaussian')
 
     Returns
     -------
-    Dict[str, np.ndarray]
-        A dictionary where keys are population names, and values are arrays representing the spike rate over time for each population.
-        If `normalize` is True, each population's spike rate is scaled to [0, 1].
+    xr.DataArray
+        An xarray DataArray containing the spike rates with dimensions of time, population, and type.
+        The 'type' dimension includes 'raw' and 'smoothed' values.
+        The DataArray includes sampling frequency (fs) as an attribute.
+        If normalize is True, each population's spike rate is scaled to [0, 1].
 
     Raises
     ------
     ValueError
         If `save` is True but `save_path` is not provided.
+        If an invalid smooth_method is specified.
 
     Notes
     -----
-    - If `config` is None, the function assumes all cells in each population have fired at least once; otherwise, the node count may be inaccurate.
-    - If normalization is enabled, each population's spike rate is scaled using Min-Max normalization based on its own minimum and maximum values.
+    - If `config` is None, the function assumes all cells in each population have fired at least once;
+      otherwise, the node count may be inaccurate.
+    - If normalization is enabled, each population's spike rate is scaled using Min-Max normalization.
+    - Smoothing is applied using scipy.ndimage's filters based on the specified method.
     """
+    import numpy as np
+    from scipy import ndimage
+
+    # Validate smoothing method
+    if smooth_method not in ["gaussian", "boxcar", "exponential"]:
+        raise ValueError(
+            f"Invalid smooth_method: {smooth_method}. Choose from 'gaussian', 'boxcar', or 'exponential'."
+        )
+
     pop_spikes = {}
     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, 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:
@@ -271,7 +294,13 @@ def get_population_spike_rate(
                 "Grabbing first network; specify a network name to ensure correct node population is selected."
             )
 
-    for pop_name in spike_data["pop_name"].unique():
+    # Get t_stop if not provided
+    if t_stop is None:
+        t_stop = spike_data["timestamps"].max()
+
+    # Get population names and prepare data
+    populations = spike_data["pop_name"].unique()
+    for pop_name in populations:
         ps = spike_data[spike_data["pop_name"] == pop_name]
 
         if config:
@@ -282,12 +311,10 @@ def get_population_spike_rate(
                 nodes = list(nodes.values())[0] if nodes else {}
             nodes = nodes[nodes["pop_name"] == pop_name]
             node_number[pop_name] = nodes.index.nunique()
+
         else:
             node_number[pop_name] = ps["node_ids"].nunique()
 
-        if t_stop is None:
-            t_stop = spike_data["timestamps"].max()
-
         filtered_spikes = spike_data[
             (spike_data["pop_name"] == pop_name)
             & (spike_data["timestamps"] > t_start)
@@ -295,29 +322,153 @@ def get_population_spike_rate(
         ]
         pop_spikes[pop_name] = filtered_spikes
 
-    time = np.array([t_start, t_stop, 1000 / fs])
-    pop_rspk = {p: _pop_spike_rate(spk["timestamps"], time) for p, spk in pop_spikes.items()}
-    spike_rate = {p: fs / node_number[p] * pop_rspk[p] for p in pop_rspk}
+    # Calculate time points
+    time = np.arange(t_start, t_stop, 1000 / fs)  # Convert sampling frequency to time steps
+
+    # Calculate spike rates for each population
+    spike_rates = []
+    for p in populations:
+        raw_rate = _pop_spike_rate(pop_spikes[p]["timestamps"], (t_start, t_stop, 1000 / fs))
+        rate = fs / node_number[p] * raw_rate
+        spike_rates.append(rate)
+
+    spike_rates_array = np.array(spike_rates).T  # Transpose to have time as first dimension
+
+    # Calculate smoothed version for each population
+    smoothed_rates = []
+
+    for i in range(spike_rates_array.shape[1]):
+        pop_rate = spike_rates_array[:, i]
+
+        if smooth_method == "gaussian":
+            # Gaussian smoothing (sigma is approximately window/6 for a Gaussian filter)
+            sigma = smooth_window / 6
+            smoothed_pop_rate = ndimage.gaussian_filter1d(pop_rate, sigma=sigma)
+        elif smooth_method == "boxcar":
+            # Boxcar/uniform smoothing
+            kernel = np.ones(smooth_window) / smooth_window
+            smoothed_pop_rate = ndimage.convolve1d(pop_rate, kernel, mode="nearest")
+        elif smooth_method == "exponential":
+            # Exponential smoothing
+            alpha = 2 / (smooth_window + 1)  # Equivalent to window size in exponential smoothing
+            smoothed_pop_rate = np.zeros_like(pop_rate)
+            smoothed_pop_rate[0] = pop_rate[0]
+            for t in range(1, len(pop_rate)):
+                smoothed_pop_rate[t] = alpha * pop_rate[t] + (1 - alpha) * smoothed_pop_rate[t - 1]
+
+        smoothed_rates.append(smoothed_pop_rate)
+
+    smoothed_rates_array = np.array(smoothed_rates).T  # Transpose to have time as first dimension
+
+    # Stack raw and smoothed data
+    combined_data = np.stack([spike_rates_array, smoothed_rates_array], axis=2)
+
+    # Create DataArray with the additional 'type' dimension
+    spike_rate_array = xr.DataArray(
+        combined_data,
+        coords={"time": time, "population": populations, "type": ["raw", "smoothed"]},
+        dims=["time", "population", "type"],
+        attrs={
+            "fs": fs,
+            "normalized": False,
+            "smooth_method": smooth_method,
+            "smooth_window": smooth_window,
+        },
+    )
 
-    # Normalize each spike rate series if normalize=True
+    # Normalize if requested
     if normalize:
-        spike_rate = {p: (sr - sr.min()) / (sr.max() - sr.min()) for p, sr in spike_rate.items()}
-
+        # Apply normalization for each population and each type (raw/smoothed)
+        for pop_idx in range(len(populations)):
+            for type_idx, type_name in enumerate(["raw", "smoothed"]):
+                pop_data = spike_rate_array.sel(population=populations[pop_idx], type=type_name)
+                min_val = pop_data.min(dim="time")
+                max_val = pop_data.max(dim="time")
+
+                # Handle case where min == max (constant signal)
+                if max_val != min_val:
+                    spike_rate_array.loc[:, populations[pop_idx], type_name] = (
+                        pop_data - min_val
+                    ) / (max_val - min_val)
+
+        spike_rate_array.attrs["normalized"] = True
+
+    # Save if requested
     if save:
         if save_path is None:
             raise ValueError("save_path must be provided if save is True.")
 
         os.makedirs(save_path, exist_ok=True)
-
         save_file = os.path.join(save_path, "spike_rate.h5")
-        with h5py.File(save_file, "w") as f:
-            f.create_dataset("time", data=time)
-            grp = f.create_group("populations")
-            for p, rspk in spike_rate.items():
-                pop_grp = grp.create_group(p)
-                pop_grp.create_dataset("data", data=rspk)
+        spike_rate_array.to_netcdf(save_file)
 
-    return spike_rate
+    return spike_rate_array
+
+
+def average_spike_rate_over_windows(
+    spike_rate: xr.DataArray, windows: List[Tuple[float, float]]
+) -> xr.DataArray:
+    """
+    Calculate the average spike rate over multiple time windows.
+
+    Parameters
+    ----------
+    spike_rate : xr.DataArray
+        The spike rate data array with dimensions (time, population, type)
+        where 'type' can be 'raw' or 'smoothed'
+    windows : List[Tuple[float, float]]
+        List of (start, end) times in milliseconds defining the windows to average over
+
+    Returns
+    -------
+    xr.DataArray
+        Averaged spike rate with time normalized to start at 0,
+        preserving all original dimensions (time, population, type)
+    """
+    # Check if the DataArray has a 'type' dimension (compatible with new format)
+    has_type_dim = "type" in spike_rate.dims
+
+    # Initialize list to store data from each window
+    window_data = []
+
+    # Get data for each window
+    for start, end in windows:
+        # Select data points within the window
+        window = spike_rate.sel(time=slice(start, end))
+
+        # Normalize time to start at 0 for this window
+        window = window.assign_coords(time=window.time - start)
+        window_data.append(window)
+
+    # Align and average windows
+    # First window determines the time coordinates
+    aligned_data = xr.concat(window_data, dim="window")
+    averaged_data = aligned_data.mean(dim="window")
+
+    # Create new DataArray with the averaged data
+    if has_type_dim:
+        # Create result with time, population, and type dimensions
+        result = xr.DataArray(
+            averaged_data.values,
+            coords={
+                "time": averaged_data.time.values,
+                "population": averaged_data.population,
+                "type": averaged_data.type,
+            },
+            dims=["time", "population", "type"],
+        )
+    else:
+        # Handle older format without 'type' dimension (for backward compatibility)
+        result = xr.DataArray(
+            averaged_data.values,
+            coords={"time": averaged_data.time.values, "population": averaged_data.population},
+            dims=["time", "population"],
+        )
+
+    # Preserve attributes
+    result.attrs = spike_rate.attrs
+
+    return result
 
 
 def compare_firing_over_times(

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/bmplot/spikes.py

@@ -1,3 +1,5 @@
+"""Plotting functions for neural spikes and firing rates."""
+
 from typing import Dict, List, Optional, Union
 
 import matplotlib.pyplot as plt

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.5.dist-info → bmtool-0.7.1.7.dist-info}/METADATA

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

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

@@ -6,18 +6,18 @@ 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=wlRY7IixefPzafqG6k2sPIK4s6PLG9Kct-oCaVR29wA,64269
+bmtool/synapses.py,sha256=hRuxRCXVpu0_0egi183qyp343tT-_gZNSxjk9rT5J8Q,66175
 bmtool/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bmtool/analysis/entrainment.py,sha256=PM4Do8Cl248Y2kIXLRFLPmUB_mH38Yhl8CUDDcunGq0,28241
+bmtool/analysis/entrainment.py,sha256=TUeV-WfCfVPqilVTjg6Cv1WKOz_zSX7LeE7k2Wuceug,28449
 bmtool/analysis/lfp.py,sha256=S2JvxkjcK3-EH93wCrhqNSFY6cX7fOq74pz64ibHKrc,26556
 bmtool/analysis/netcon_reports.py,sha256=VnPZNKPaQA7oh1q9cIatsqQudm4cOtzNtbGPXoiDCD0,2909
-bmtool/analysis/spikes.py,sha256=IHxV7_X8ojh4NDVBjzHCzfHF8muPPef2UtH3yqYre78,17091
+bmtool/analysis/spikes.py,sha256=u7Qu0NVGPDAH5jlgNLv32H1hDAkOlG6P4nKEFeAOkdE,22833
 bmtool/bmplot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/bmplot/connections.py,sha256=P1JBG4xCbLVq4sfQuUE6c3dO949qajrjdQcrazdmDS4,53861
-bmtool/bmplot/entrainment.py,sha256=VSlZvcSeXLr5OxGvmWcGU4s7JS7vOL38lq1XC69O_AE,6926
+bmtool/bmplot/entrainment.py,sha256=YBHTJ-nK0OgM8CNssM8IyqPNYez9ss9bQi-C5HW4kGw,12593
 bmtool/bmplot/lfp.py,sha256=SNpbWGOUnYEgnkeBw5S--aPN5mIGD22Gw2Pwus0_lvY,2034
 bmtool/bmplot/netcon_reports.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bmtool/bmplot/spikes.py,sha256=Lg8V3ynYCqk-QJvq-BOInjZMHYHrxHgXjtDOX67df-A,11148
+bmtool/bmplot/spikes.py,sha256=RJOOtmgWhTvyVi1CghoKTtxvt7MF9cJCrJVm5hV5wA4,11210
 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
@@ -26,9 +26,9 @@ bmtool/util/commands.py,sha256=Nn-R-4e9g8ZhSPZvTkr38xeKRPfEMANB9Lugppj82UI,68564
 bmtool/util/util.py,sha256=owce5BEusZO_8T5x05N2_B583G26vWAy7QX29V0Pj0Y,62818
 bmtool/util/neuron/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/util/neuron/celltuner.py,sha256=lokRLUM1rsdSYBYrNbLBBo39j14mm8TBNVNRnSlhHCk,94868
-bmtool-0.7.1.5.dist-info/licenses/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
-bmtool-0.7.1.5.dist-info/METADATA,sha256=pvpABD7P2ytzO08EYUC8HrbUTg_fk8pc67mBaEvi7-M,3577
-bmtool-0.7.1.5.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-bmtool-0.7.1.5.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
-bmtool-0.7.1.5.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
-bmtool-0.7.1.5.dist-info/RECORD,,
+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.1.5.dist-info → bmtool-0.7.1.7.dist-info}/WHEEL

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