bmtool 0.6.7__tar.gz → 0.6.7.1__tar.gz

{bmtool-0.6.7 → bmtool-0.6.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: bmtool
-Version: 0.6.7
+Version: 0.6.7.1
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 

{bmtool-0.6.7 → bmtool-0.6.7.1}/bmtool/SLURM.py

@@ -353,17 +353,15 @@ class BlockRunner:
                 shutil.copytree(source_dir, destination_dir) # create new components folder
                 json_file_path = os.path.join(destination_dir,self.json_file_path)
                 
-                # need to keep the orignal around
-                syn_dict_temp = copy.deepcopy(self.syn_dict)
-                print(self.syn_dict['json_file_path'])
-                json_to_be_ratioed = syn_dict_temp['json_file_path']
-                corrected_ratio_path = os.path.join(destination_dir,json_to_be_ratioed)
-                syn_dict_temp['json_file_path'] = corrected_ratio_path
-                
                 if self.syn_dict == None:
                     json_editor = seedSweep(json_file_path , self.param_name)
                     json_editor.edit_json(new_value)
                 else:
+                    # need to keep the orignal around
+                    syn_dict_temp = copy.deepcopy(self.syn_dict)
+                    json_to_be_ratioed = syn_dict_temp['json_file_path']
+                    corrected_ratio_path = os.path.join(destination_dir,json_to_be_ratioed)
+                    syn_dict_temp['json_file_path'] = corrected_ratio_path
                     json_editor = multiSeedSweep(json_file_path ,self.param_name,
                                                 syn_dict=syn_dict_temp,base_ratio=1)
                     json_editor.edit_all_jsons(new_value) 
@@ -415,17 +413,15 @@ class BlockRunner:
                 shutil.copytree(source_dir, destination_dir) # create new components folder 
                 json_file_path = os.path.join(destination_dir,self.json_file_path)
                 
-                # need to keep the orignal around
-                syn_dict_temp = copy.deepcopy(self.syn_dict)
-                print(self.syn_dict['json_file_path'])
-                json_to_be_ratioed = syn_dict_temp['json_file_path']
-                corrected_ratio_path = os.path.join(destination_dir,json_to_be_ratioed)
-                syn_dict_temp['json_file_path'] = corrected_ratio_path
-                
                 if self.syn_dict == None:
                     json_editor = seedSweep(json_file_path , self.param_name)
                     json_editor.edit_json(new_value)
                 else:
+                    # need to keep the orignal around
+                    syn_dict_temp = copy.deepcopy(self.syn_dict)
+                    json_to_be_ratioed = syn_dict_temp['json_file_path']
+                    corrected_ratio_path = os.path.join(destination_dir,json_to_be_ratioed)
+                    syn_dict_temp['json_file_path'] = corrected_ratio_path
                     json_editor = multiSeedSweep(json_file_path ,self.param_name,
                                                 syn_dict_temp,base_ratio=1)
                     json_editor.edit_all_jsons(new_value) 

bmtool-0.6.7.1/bmtool/analysis/lfp.py

@@ -0,0 +1,408 @@
+"""
+Module for processing BMTK LFP output.
+"""
+
+import h5py
+import numpy as np
+import xarray as xr
+from fooof import FOOOF
+from fooof.sim.gen import gen_model
+import matplotlib.pyplot as plt
+from scipy import signal 
+import pywt
+from bmtool.bmplot import is_notebook
+
+
+def load_ecp_to_xarray(ecp_file: str, demean: bool = False) -> xr.DataArray:
+    """
+    Load ECP data from an HDF5 file (BMTK sim) into an xarray DataArray.
+
+    Parameters:
+    ----------
+    ecp_file : str
+        Path to the HDF5 file containing ECP data.
+    demean : bool, optional
+        If True, the mean of the data will be subtracted (default is False).
+
+    Returns:
+    -------
+    xr.DataArray
+        An xarray DataArray containing the ECP data, with time as one dimension
+        and channel_id as another.
+    """
+    with h5py.File(ecp_file, 'r') as f:
+        ecp = xr.DataArray(
+            f['ecp']['data'][()].T,
+            coords=dict(
+                channel_id=f['ecp']['channel_id'][()],
+                time=np.arange(*f['ecp']['time'])  # ms
+            ),
+            attrs=dict(
+                fs=1000 / f['ecp']['time'][2]  # Hz
+            )
+        )
+    if demean:
+        ecp -= ecp.mean(dim='time')
+    return ecp
+
+
+def ecp_to_lfp(ecp_data: xr.DataArray, cutoff: float = 250, fs: float = 10000,
+                    downsample_freq: float = 1000) -> xr.DataArray:
+    """
+    Apply a low-pass Butterworth filter to an xarray DataArray and optionally downsample. 
+    This filters out the high end frequencies turning the ECP into a LFP
+
+    Parameters:
+    ----------
+    ecp_data : xr.DataArray
+        The input data array containing LFP data with time as one dimension.
+    cutoff : float
+        The cutoff frequency for the low-pass filter in Hz (default is 250Hz).
+    fs : float, optional
+        The sampling frequency of the data (default is 10000 Hz).
+    downsample_freq : float, optional
+        The frequency to downsample to (default is 1000 Hz).
+
+    Returns:
+    -------
+    xr.DataArray
+        The filtered (and possibly downsampled) data as an xarray DataArray.
+    """
+    # Bandpass filter design
+    nyq = 0.5 * fs
+    cut = cutoff / nyq
+    b, a = signal.butter(8, cut, btype='low', analog=False)
+
+    # Initialize an array to hold filtered data
+    filtered_data = xr.DataArray(np.zeros_like(ecp_data), coords=ecp_data.coords, dims=ecp_data.dims)
+
+    # Apply the filter to each channel
+    for channel in ecp_data.channel_id:
+        filtered_data.loc[channel, :] = signal.filtfilt(b, a, ecp_data.sel(channel_id=channel).values)
+
+    # Downsample the filtered data if a downsample frequency is provided
+    if downsample_freq is not None:
+        downsample_factor = int(fs / downsample_freq)
+        filtered_data = filtered_data.isel(time=slice(None, None, downsample_factor))
+        # Update the sampling frequency attribute
+        filtered_data.attrs['fs'] = downsample_freq
+
+    return filtered_data
+
+
+def slice_time_series(data: xr.DataArray, time_ranges: tuple) -> xr.DataArray:
+    """
+    Slice the xarray DataArray based on provided time ranges.
+    Can be used to get LFP during certain stimulus times
+
+    Parameters:
+    ----------
+    data : xr.DataArray
+        The input xarray DataArray containing time-series data.
+    time_ranges : tuple or list of tuples
+        One or more tuples representing the (start, stop) time points for slicing. 
+        For example: (start, stop) or [(start1, stop1), (start2, stop2)]
+
+    Returns:
+    -------
+    xr.DataArray
+        A new xarray DataArray containing the concatenated slices.
+    """
+    # Ensure time_ranges is a list of tuples
+    if isinstance(time_ranges, tuple) and len(time_ranges) == 2:
+        time_ranges = [time_ranges]
+
+    # List to hold sliced data
+    slices = []
+
+    # Slice the data for each time range
+    for start, stop in time_ranges:
+        sliced_data = data.sel(time=slice(start, stop))
+        slices.append(sliced_data)
+
+    # Concatenate all slices along the time dimension if more than one slice
+    if len(slices) > 1:
+        return xr.concat(slices, dim='time')
+    else:
+        return slices[0]
+
+
+def fit_fooof(f: np.ndarray, pxx: np.ndarray, aperiodic_mode: str = 'fixed',
+              dB_threshold: float = 3.0, max_n_peaks: int = 10,
+              freq_range: tuple = None, peak_width_limits: tuple = None,
+              report: bool = False, plot: bool = False, 
+              plt_log: bool = False, plt_range: tuple = None,
+              figsize: tuple = None, title: str = None) -> tuple:
+    """
+    Fit a FOOOF model to power spectral density data.
+
+    Parameters:
+    ----------
+    f : array-like
+        Frequencies corresponding to the power spectral density data.
+    pxx : array-like
+        Power spectral density data to fit.
+    aperiodic_mode : str, optional
+        The mode for fitting aperiodic components ('fixed' or 'knee', default is 'fixed').
+    dB_threshold : float, optional
+        Minimum peak height in dB (default is 3).
+    max_n_peaks : int, optional
+        Maximum number of peaks to fit (default is 10).
+    freq_range : tuple, optional
+        Frequency range to fit (default is None, which uses the full range).
+    peak_width_limits : tuple, optional
+        Limits on the width of peaks (default is None).
+    report : bool, optional
+        If True, will print fitting results (default is False).
+    plot : bool, optional
+        If True, will plot the fitting results (default is False).
+    plt_log : bool, optional
+        If True, use a logarithmic scale for the y-axis in plots (default is False).
+    plt_range : tuple, optional
+        Range for plotting (default is None).
+    figsize : tuple, optional
+        Size of the figure (default is None).
+    title : str, optional
+        Title for the plot (default is None).
+
+    Returns:
+    -------
+    tuple
+        A tuple containing the fitting results and the FOOOF model object.
+    """
+    if aperiodic_mode != 'knee':
+        aperiodic_mode = 'fixed'
+    
+    def set_range(x, upper=f[-1]):
+        x = np.array(upper) if x is None else np.array(x)
+        return [f[2], x.item()] if x.size == 1 else x.tolist()
+    
+    freq_range = set_range(freq_range)
+    peak_width_limits = set_range(peak_width_limits, np.inf)
+
+    # Initialize a FOOOF object
+    fm = FOOOF(peak_width_limits=peak_width_limits, min_peak_height=dB_threshold / 10,
+               peak_threshold=0., max_n_peaks=max_n_peaks, aperiodic_mode=aperiodic_mode)
+    
+    # Fit the model
+    try:
+        fm.fit(f, pxx, freq_range)
+    except Exception as e:
+        fl = np.linspace(f[0], f[-1], int((f[-1] - f[0]) / np.min(np.diff(f))) + 1)
+        fm.fit(fl, np.interp(fl, f, pxx), freq_range)
+    
+    results = fm.get_results()
+
+    if report:
+        fm.print_results()
+        if aperiodic_mode == 'knee':
+            ap_params = results.aperiodic_params
+            if ap_params[1] <= 0:
+                print('Negative value of knee parameter occurred. Suggestion: Fit without knee parameter.')
+            knee_freq = np.abs(ap_params[1]) ** (1 / ap_params[2])
+            print(f'Knee location: {knee_freq:.2f} Hz')
+    
+    if plot:
+        plt_range = set_range(plt_range)
+        fm.plot(plt_log=plt_log)
+        plt.xlim(np.log10(plt_range) if plt_log else plt_range)
+        #plt.ylim(-8, -5.5)
+        if figsize:
+            plt.gcf().set_size_inches(figsize)
+        if title:
+            plt.title(title)
+        if is_notebook():
+            pass
+        else:
+            plt.show()
+    
+    return results, fm
+
+
+def generate_resd_from_fooof(fooof_model: FOOOF) -> tuple:
+    """
+    Generate residuals from a fitted FOOOF model.
+
+    Parameters:
+    ----------
+    fooof_model : FOOOF
+        A fitted FOOOF model object.
+
+    Returns:
+    -------
+    tuple
+        A tuple containing the residual power spectral density and the aperiodic fit.
+    """
+    results = fooof_model.get_results()
+    full_fit, _, ap_fit = gen_model(fooof_model.freqs[1:], results.aperiodic_params,
+                                     results.gaussian_params, return_components=True)
+    
+    full_fit, ap_fit = 10 ** full_fit, 10 ** ap_fit  # Convert back from log
+    res_psd = np.insert((10 ** fooof_model.power_spectrum[1:]) - ap_fit, 0, 0.)  # Convert back from log
+    res_fit = np.insert(full_fit - ap_fit, 0, 0.)
+    ap_fit = np.insert(ap_fit, 0, 0.)
+
+    return res_psd, ap_fit
+
+
+def calculate_SNR(fooof_model: FOOOF, freq_band: tuple) -> float:
+    """
+    Calculate the signal-to-noise ratio (SNR) from a fitted FOOOF model.
+
+    Parameters:
+    ----------
+    fooof_model : FOOOF
+        A fitted FOOOF model object.
+    freq_band : tuple
+        Frequency band (min, max) for SNR calculation.
+
+    Returns:
+    -------
+    float
+        The calculated SNR for the specified frequency band.
+    """
+    periodic, ap = generate_resd_from_fooof(fooof_model)
+    freq = fooof_model.freqs  # Get frequencies from model
+    indices = (freq >= freq_band[0]) & (freq <= freq_band[1])  # Get only the band we care about
+    band_periodic = periodic[indices]  # Filter based on band
+    band_ap = ap[indices]  # Filter
+    band_freq = freq[indices]  # Another filter
+    periodic_power = np.trapz(band_periodic, band_freq)  # Integrate periodic power
+    ap_power = np.trapz(band_ap, band_freq)  # Integrate aperiodic power
+    normalized_power = periodic_power / ap_power  # Compute the SNR
+    return normalized_power
+
+
+def wavelet_filter(x: np.ndarray, freq: float, fs: float, bandwidth: float = 1.0, axis: int = -1) -> np.ndarray:
+    """
+    Compute the Continuous Wavelet Transform (CWT) for a specified frequency using a complex Morlet wavelet.
+    """
+    wavelet = 'cmor' + str(2 * bandwidth ** 2) + '-1.0'
+    scale = pywt.scale2frequency(wavelet, 1) * fs / freq
+    x_a = pywt.cwt(x, [scale], wavelet=wavelet, axis=axis)[0][0]
+    return x_a
+
+
+def butter_bandpass_filter(data: np.ndarray, lowcut: float, highcut: float, fs: float, order: int = 5, axis: int = -1) -> np.ndarray:
+    """
+    Apply a Butterworth bandpass filter to the input data.
+    """
+    sos = signal.butter(order, [lowcut, highcut], fs=fs, btype='band', output='sos')
+    x_a = signal.sosfiltfilt(sos, data, axis=axis)
+    return x_a
+
+
+def calculate_plv(x1: np.ndarray, x2: np.ndarray, fs: float, freq_of_interest: float = None, 
+                  method: str = 'wavelet', lowcut: float = None, highcut: float = None, 
+                  bandwidth: float = 2.0) -> np.ndarray:
+    """
+    Calculate Phase Locking Value (PLV) between two signals using wavelet or Hilbert method.
+    
+    Parameters:
+    - x1, x2: Input signals (1D arrays, same length)
+    - fs: Sampling frequency
+    - freq_of_interest: Desired frequency for wavelet PLV calculation
+    - method: 'wavelet' or 'hilbert' to choose the PLV calculation method
+    - lowcut, highcut: Cutoff frequencies for the Hilbert method
+    - bandwidth: Bandwidth parameter for the wavelet
+    
+    Returns:
+    - plv: Phase Locking Value (1D array)
+    """
+    if len(x1) != len(x2):
+        raise ValueError("Input signals must have the same length.")
+    
+    if method == 'wavelet':
+        if freq_of_interest is None:
+            raise ValueError("freq_of_interest must be provided for the wavelet method.")
+        
+        # Apply CWT to both signals
+        theta1 = wavelet_filter(x=x1, freq=freq_of_interest, fs=fs, bandwidth=bandwidth)
+        theta2 = wavelet_filter(x=x2, freq=freq_of_interest, fs=fs, bandwidth=bandwidth)
+    
+    elif method == 'hilbert':
+        if lowcut is None or highcut is None:
+            print("Lowcut and or highcut were not definded, signal will not be filter and just take hilbert transform for plv calc")
+        
+        if lowcut and highcut:
+            # Bandpass filter and get the analytic signal using the Hilbert transform
+            x1 = butter_bandpass_filter(x1, lowcut, highcut, fs)
+            x2 = butter_bandpass_filter(x2, lowcut, highcut, fs)
+        
+        # Get phase using the Hilbert transform
+        theta1 = signal.hilbert(x1)
+        theta2 = signal.hilbert(x2)
+    
+    else:
+        raise ValueError("Invalid method. Choose 'wavelet' or 'hilbert'.")
+    
+    # Calculate phase difference
+    phase_diff = np.angle(theta1) - np.angle(theta2)
+    
+    # Calculate PLV from standard equation from Measuring phase synchrony in brain signals(1999)
+    plv = np.abs(np.mean(np.exp(1j * phase_diff), axis=-1))
+    
+    return plv
+
+
+def calculate_plv_over_time(x1: np.ndarray, x2: np.ndarray, fs: float, 
+                            window_size: float, step_size: float, 
+                            method: str = 'wavelet', freq_of_interest: float = None, 
+                            lowcut: float = None, highcut: float = None, 
+                            bandwidth: float = 2.0):
+    """
+    Calculate the time-resolved Phase Locking Value (PLV) between two signals using a sliding window approach.
+    
+    Parameters:
+    ----------
+    x1, x2 : array-like
+        Input signals (1D arrays, same length).
+    fs : float
+        Sampling frequency of the input signals.
+    window_size : float
+        Length of the window in seconds for PLV calculation.
+    step_size : float
+        Step size in seconds to slide the window across the signals.
+    method : str, optional
+        Method to calculate PLV ('wavelet' or 'hilbert'). Defaults to 'wavelet'.
+    freq_of_interest : float, optional
+        Frequency of interest for the wavelet method. Required if method is 'wavelet'.
+    lowcut, highcut : float, optional
+        Cutoff frequencies for the Hilbert method. Required if method is 'hilbert'.
+    bandwidth : float, optional
+        Bandwidth parameter for the wavelet. Defaults to 2.0.
+        
+    Returns:
+    -------
+    plv_over_time : 1D array
+        Array of PLV values calculated over each window.
+    times : 1D array
+        The center times of each window where the PLV was calculated.
+    """
+    # Convert window and step size from seconds to samples
+    window_samples = int(window_size * fs)
+    step_samples = int(step_size * fs)
+    
+    # Initialize results
+    plv_over_time = []
+    times = []
+    
+    # Iterate over the signal with a sliding window
+    for start in range(0, len(x1) - window_samples + 1, step_samples):
+        end = start + window_samples
+        window_x1 = x1[start:end]
+        window_x2 = x2[start:end]
+        
+        # Use the updated calculate_plv function within each window
+        plv = calculate_plv(x1=window_x1, x2=window_x2, fs=fs, 
+                            method=method, freq_of_interest=freq_of_interest, 
+                            lowcut=lowcut, highcut=highcut, bandwidth=bandwidth)
+        plv_over_time.append(plv)
+        
+        # Store the time at the center of the window
+        center_time = (start + end) / 2 / fs
+        times.append(center_time)
+    
+    return np.array(plv_over_time), np.array(times)
+
+

bmtool-0.6.7.1/bmtool/analysis/spikes.py

@@ -0,0 +1,181 @@
+"""
+Module for processing BMTK spikes output.
+"""
+
+import h5py
+import pandas as pd
+from bmtool.util.util import load_nodes_from_config
+from typing import Dict, Optional,Tuple, Union
+import numpy as np
+import os
+
+
+def load_spikes_to_df(spike_file: str, network_name: str, sort: bool = True, config: str = None, groupby: str = 'pop_name') -> pd.DataFrame:
+    """
+    Load spike data from an HDF5 file into a pandas DataFrame.
+
+    Args:
+        spike_file (str): Path to the HDF5 file containing spike data.
+        network_name (str): The name of the network within the HDF5 file from which to load spike data.
+        sort (bool, optional): Whether to sort the DataFrame by 'timestamps'. Defaults to True.
+        config (str, optional): Will label the cell type of each spike.
+        groupby (str or list of str, optional): The column(s) to group by. Defaults to 'pop_name'.
+
+    Returns:
+        pd.DataFrame: A pandas DataFrame containing 'node_ids' and 'timestamps' columns from the spike data.
+    
+    Example:
+        df = load_spikes_to_df("spikes.h5", "cortex")
+    """
+    with h5py.File(spike_file) as f:
+        spikes_df = pd.DataFrame({
+            'node_ids': f['spikes'][network_name]['node_ids'],
+            'timestamps': f['spikes'][network_name]['timestamps']
+        })
+
+        if sort:
+            spikes_df.sort_values(by='timestamps', inplace=True, ignore_index=True)
+        
+        if config:
+            nodes = load_nodes_from_config(config)
+            nodes = nodes[network_name]
+
+            # Check if 'groupby' is a string or a list of strings and handle accordingly
+            if isinstance(groupby, str):
+                spikes_df = spikes_df.merge(nodes[groupby], left_on='node_ids', right_index=True, how='left')
+            elif isinstance(groupby, list):
+                for group in groupby:
+                    spikes_df = spikes_df.merge(nodes[group], left_on='node_ids', right_index=True, how='left')
+
+    return spikes_df
+
+
+
+def _pop_spike_rate(spike_times: Union[np.ndarray, list], time: Optional[Tuple[float, float, float]] = None, 
+                   time_points: Optional[Union[np.ndarray, list]] = None, frequeny: bool = False) -> np.ndarray:
+    """
+    Calculate the spike count or frequency histogram over specified time intervals.
+
+    Args:
+        spike_times (Union[np.ndarray, list]): Array or list of spike times in milliseconds.
+        time (Optional[Tuple[float, float, float]], optional): Tuple specifying (start, stop, step) in milliseconds. 
+            Used to create evenly spaced time points if `time_points` is not provided. Default is None.
+        time_points (Optional[Union[np.ndarray, list]], optional): Array or list of specific time points for binning. 
+            If provided, `time` is ignored. Default is None.
+        frequeny (bool, optional): If True, returns spike frequency in Hz; otherwise, returns spike count. Default is False.
+
+    Returns:
+        np.ndarray: Array of spike counts or frequencies, depending on the `frequeny` flag.
+
+    Raises:
+        ValueError: If both `time` and `time_points` are None.
+    """
+    if time_points is None:
+        if time is None:
+            raise ValueError("Either `time` or `time_points` must be provided.")
+        time_points = np.arange(*time)
+        dt = time[2]
+    else:
+        time_points = np.asarray(time_points).ravel()
+        dt = (time_points[-1] - time_points[0]) / (time_points.size - 1)
+    
+    bins = np.append(time_points, time_points[-1] + dt)
+    spike_rate, _ = np.histogram(np.asarray(spike_times), bins)
+    
+    if frequeny:
+        spike_rate = 1000 / dt * spike_rate
+    
+    return spike_rate
+
+
+def get_population_spike_rate(spikes: pd.DataFrame, fs: float = 400.0, t_start: float = 0, t_stop: Optional[float] = None, 
+                              config: Optional[str] = None, network_name: Optional[str] = None,
+                              save: bool = False, save_path: Optional[str] = None,
+                              normalize: bool = False) -> Dict[str, np.ndarray]:
+    """
+    Calculate the population spike rate for each population in the given spike data, with an option to normalize.
+
+    Args:
+        spikes (pd.DataFrame): A DataFrame containing spike data with columns 'pop_name', 'timestamps', and 'node_ids'.
+        fs (float, optional): Sampling frequency in Hz, which determines the time bin size for calculating the spike rate. Default is 400.
+        t_start (float, optional): Start time (in milliseconds) for spike rate calculation. Default is 0.
+        t_stop (Optional[float], optional): Stop time (in milliseconds) for spike rate calculation. If None, defaults to the maximum timestamp in the data.
+        config (Optional[str], optional): Path to a configuration file containing node information, used to determine the correct number of nodes per population. 
+            If None, node count is estimated from unique node spikes. Default is None.
+        network_name (Optional[str], optional): Name of the network used in the configuration file, allowing selection of nodes for that network. 
+            Required if `config` is provided. Default is None.
+        save (bool, optional): Whether to save the calculated population spike rate to a file. Default is False.
+        save_path (Optional[str], optional): Directory path where the file should be saved if `save` is True. If `save` is True and `save_path` is None, a ValueError is raised.
+        normalize (bool, optional): Whether to normalize the spike rates for each population to a range of [0, 1]. Default is False.
+
+    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].
+
+    Raises:
+        ValueError: If `save` is True but `save_path` is not provided.
+
+    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.
+
+    """
+    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.")
+        print("You can provide a config to calculate the correct amount of nodes!")
+        
+    if config:
+        if not network_name:
+            print("Grabbing first network; specify a network name to ensure correct node population is selected.")
+
+    for pop_name in spikes['pop_name'].unique():
+        ps = spikes[spikes['pop_name'] == pop_name]
+        
+        if config:
+            nodes = load_nodes_from_config(config)
+            if network_name:
+                nodes = nodes[network_name]
+            else:
+                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 = spikes['timestamps'].max()
+
+        filtered_spikes = spikes[
+            (spikes['pop_name'] == pop_name) & 
+            (spikes['timestamps'] > t_start) & 
+            (spikes['timestamps'] < t_stop)
+        ]
+        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}
+
+    # Normalize each spike rate series if normalize=True
+    if normalize:
+        spike_rate = {p: (sr - sr.min()) / (sr.max() - sr.min()) for p, sr in spike_rate.items()}
+
+    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)
+
+    return spike_rate
+

{bmtool-0.6.7 → bmtool-0.6.7.1}/bmtool/bmplot.py

@@ -762,7 +762,7 @@ def connector_percent_matrix(csv_path: str = None, exclude_strings=None, assemb_
     plt.tight_layout()
     plt.show()
 
-def raster(spikes_df: Optional[pd.DataFrame] = None, config: Optional[str] = None, network_name: Optional[str] = None, 
+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:
     """
@@ -793,7 +793,7 @@ def raster(spikes_df: Optional[pd.DataFrame] = None, config: Optional[str] = Non
     Notes:
     -----
     - If `config` is provided, the function merges population names from the node data with `spikes_df`.
-    - Each unique population (`pop_name`) in `spikes_df` will be represented by a different color if `color_map` is not specified.
+    - Each unique population from groupby in `spikes_df` will be represented by a different color if `color_map` is not specified.
     - If `color_map` is provided, it should contain colors for all unique `pop_name` values in `spikes_df`.
     """
     # Initialize axes if none provided
@@ -822,11 +822,11 @@ def raster(spikes_df: Optional[pd.DataFrame] = None, config: Optional[str] = Non
         # 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['pop_name'], 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['pop_name'].unique()
+    unique_pop_names = spikes_df[groupby].unique()
     
     # Generate colors if no color_map is provided
     if color_map is None:
@@ -839,7 +839,7 @@ def raster(spikes_df: Optional[pd.DataFrame] = None, config: Optional[str] = Non
             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('pop_name'):
+    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)
 
     # Label axes

{bmtool-0.6.7 → bmtool-0.6.7.1}/bmtool/singlecell.py

@@ -90,7 +90,11 @@ class CurrentClamp(object):
         self.inj_dur = inj_dur
         self.inj_amp = inj_amp * 1e-3 # pA to nA
 
-        self.cell = self.create_cell()
+        # sometimes people may put a hoc object in for the template name 
+        if callable(template_name):
+            self.cell = template_name
+        else:    
+            self.cell = self.create_cell()
         if post_init_function:
             eval(f"self.cell.{post_init_function}")
 

{bmtool-0.6.7 → bmtool-0.6.7.1}/bmtool.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: bmtool
-Version: 0.6.7
+Version: 0.6.7.1
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 

{bmtool-0.6.7 → bmtool-0.6.7.1}/bmtool.egg-info/SOURCES.txt

@@ -17,6 +17,9 @@ bmtool.egg-info/dependency_links.txt
 bmtool.egg-info/entry_points.txt
 bmtool.egg-info/requires.txt
 bmtool.egg-info/top_level.txt
+bmtool/analysis/__init__.py
+bmtool/analysis/lfp.py
+bmtool/analysis/spikes.py
 bmtool/debug/__init__.py
 bmtool/debug/commands.py
 bmtool/debug/debug.py

{bmtool-0.6.7 → bmtool-0.6.7.1}/setup.py

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