bmtool 0.6.7__tar.gz → 0.6.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: bmtool
-Version: 0.6.7
+Version: 0.6.8
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 
@@ -53,6 +53,7 @@ A collection of modules to make developing [Neuron](https://www.neuron.yale.edu/
 - [Synapses](#synapses-module)
 - [Connectors](#connectors-module)
 - [Bmplot](#bmplot-module)
+- [Analysis](#analysis-module)
 - [SLURM](#slurm-module)
 - [Graphs](#graphs-module)
 
@@ -471,7 +472,11 @@ bmplot.plot_network_graph(config='config.json',sources='LA',targets='LA',tids='p
 
     
 ![png](readme_figures/output_35_0.png)
-    
+
+
+## Analysis Module
+### A notebook example of how to use the spikes module can be found [here](examples/analysis/using_spikes.ipynb)
+
 ## SLURM Module
 ### This is an extremely helpful module that can simplify using SLURM too submit your models. There is also features to enable doing a seedSweep. This will vary the parameters of the simulation and make tuning the model easier. An example can be found [here](examples/SLURM/using_BlockRunner.ipynb) 
 

{bmtool-0.6.7 → bmtool-0.6.8}/README.md

@@ -10,6 +10,7 @@ A collection of modules to make developing [Neuron](https://www.neuron.yale.edu/
 - [Synapses](#synapses-module)
 - [Connectors](#connectors-module)
 - [Bmplot](#bmplot-module)
+- [Analysis](#analysis-module)
 - [SLURM](#slurm-module)
 - [Graphs](#graphs-module)
 
@@ -428,7 +429,11 @@ bmplot.plot_network_graph(config='config.json',sources='LA',targets='LA',tids='p
 
     
 ![png](readme_figures/output_35_0.png)
-    
+
+
+## Analysis Module
+### A notebook example of how to use the spikes module can be found [here](examples/analysis/using_spikes.ipynb)
+
 ## SLURM Module
 ### This is an extremely helpful module that can simplify using SLURM too submit your models. There is also features to enable doing a seedSweep. This will vary the parameters of the simulation and make tuning the model easier. An example can be found [here](examples/SLURM/using_BlockRunner.ipynb) 
 

{bmtool-0.6.7 → bmtool-0.6.8}/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.8/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.8/bmtool/analysis/spikes.py

@@ -0,0 +1,254 @@
+"""
+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, List
+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]
+
+            # Convert single string to a list for uniform handling
+            if isinstance(groupby, str):
+                groupby = [groupby]
+
+            # Ensure all requested columns exist
+            missing_cols = [col for col in groupby if col not in nodes.columns]
+            if missing_cols:
+                raise KeyError(f"Columns {missing_cols} not found in nodes DataFrame.")
+
+            spikes_df = spikes_df.merge(nodes[groupby], left_on='node_ids', right_index=True, how='left')
+
+    return spikes_df
+
+
+def compute_firing_rate_stats(df: pd.DataFrame, groupby: Union[str, List[str]] = "pop_name", start_time: float = None, stop_time: float = None) -> Tuple[pd.DataFrame, pd.DataFrame]:
+    """
+    Computes the firing rates of individual nodes and the mean and standard deviation of firing rates per group.
+
+    Args:
+        df (pd.DataFrame): Dataframe containing spike timestamps and node IDs.
+        groupby (str or list of str, optional): Column(s) to group by (e.g., 'pop_name' or ['pop_name', 'layer']).
+        start_time (float, optional): Start time for the analysis window. Defaults to the minimum timestamp in the data.
+        stop_time (float, optional): Stop time for the analysis window. Defaults to the maximum timestamp in the data.
+
+    Returns:
+        Tuple[pd.DataFrame, pd.DataFrame]: 
+            - The first DataFrame (`pop_stats`) contains the mean and standard deviation of firing rates per group.
+            - The second DataFrame (`individual_stats`) contains the firing rate of each individual node.
+    """
+
+    # Ensure groupby is a list
+    if isinstance(groupby, str):
+        groupby = [groupby]
+    
+    # Ensure all columns exist in the dataframe
+    for col in groupby:
+        if col not in df.columns:
+            raise ValueError(f"Column '{col}' not found in dataframe.")
+
+    # Filter dataframe based on start/stop time
+    if start_time is not None:
+        df = df[df["timestamps"] >= start_time]
+    if stop_time is not None:
+        df = df[df["timestamps"] <= stop_time]
+
+    # Compute total duration for firing rate calculation
+    if start_time is None:
+        min_time = df["timestamps"].min()
+    else:
+        min_time = start_time
+    
+    if stop_time is None: 
+        max_time = df["timestamps"].max()
+    else:
+        max_time = stop_time
+ 
+    duration = max_time - min_time  # Avoid division by zero
+
+    if duration <= 0:
+        raise ValueError("Invalid time window: Stop time must be greater than start time.")
+
+    # Compute firing rate for each node
+    import pandas as pd
+
+    # Compute spike counts per node
+    spike_counts = df["node_ids"].value_counts().reset_index()
+    spike_counts.columns = ["node_ids", "spike_count"]  # Rename columns
+
+    # Merge with original dataframe to get corresponding labels (e.g., 'pop_name')
+    spike_counts = spike_counts.merge(df[["node_ids"] + groupby].drop_duplicates(), on="node_ids", how="left")
+
+    # Compute firing rate
+    spike_counts["firing_rate"] = spike_counts["spike_count"] / duration * 1000 # scale to Hz
+    indivdual_stats = spike_counts
+    
+    # Compute mean and standard deviation per group
+    pop_stats = spike_counts.groupby(groupby)["firing_rate"].agg(["mean", "std"]).reset_index()
+
+    # Rename columns
+    pop_stats.rename(columns={"mean": "firing_rate_mean", "std": "firing_rate_std"}, inplace=True)
+
+    return pop_stats,indivdual_stats
+
+
+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.8}/bmtool/bmplot.py

@@ -13,6 +13,7 @@ import matplotlib.colors as colors
 import matplotlib.gridspec as gridspec
 from mpl_toolkits.mplot3d import Axes3D
 from matplotlib.axes import Axes
+import seaborn as sns
 from IPython import get_ipython
 from IPython.display import display, HTML
 import statistics
@@ -20,7 +21,7 @@ import pandas as pd
 import os
 import sys
 import re
-from typing import Optional, Dict
+from typing import Optional, Dict, Union, List
 
 from .util.util import CellVarsFile,load_nodes_from_config #, missing_units
 from bmtk.analyzer.utils import listify
@@ -762,7 +763,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 +794,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 +823,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 +840,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
@@ -849,6 +850,169 @@ def raster(spikes_df: Optional[pd.DataFrame] = None, config: Optional[str] = Non
     
     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:
+    """
+    Plots a bar graph of mean firing rates with error bars (standard deviation).
+
+    Parameters:
+    ----------
+    firing_stats : pd.DataFrame
+        Dataframe containing 'firing_rate_mean' and 'firing_rate_std'.
+    groupby : str or list of str
+        Column(s) used for grouping.
+    ax : matplotlib.axes.Axes, optional
+        Axes on which to plot the bar chart; if None, a new figure and axes are created.
+    color_map : dict, optional
+        Dictionary specifying colors for each group. Keys should be group names, and values should be color values.
+
+    Returns:
+    -------
+    matplotlib.axes.Axes
+        Axes with the bar plot.
+    """
+    # Ensure groupby is a list for consistent handling
+    if isinstance(groupby, str):
+        groupby = [groupby]
+
+    # Create a categorical column for grouping
+    firing_stats["group"] = firing_stats[groupby].astype(str).agg("_".join, axis=1)
+
+    # Get unique group names
+    unique_groups = firing_stats["group"].unique()
+
+    # Generate colors if no color_map is provided
+    if color_map is None:
+        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
+        missing_colors = [group for group in unique_groups if group not in color_map]
+        if missing_colors:
+            raise ValueError(f"color_map is missing colors for groups: {missing_colors}")
+
+    # Create new figure and axes if ax is not provided
+    if ax is None:
+        fig, ax = plt.subplots(figsize=(10, 6))
+
+    # Sort data for consistent plotting
+    firing_stats = firing_stats.sort_values(by="group")
+
+    # Extract values for plotting
+    x_labels = firing_stats["group"]
+    means = firing_stats["firing_rate_mean"]
+    std_devs = firing_stats["firing_rate_std"]
+
+    # Get colors for each group
+    colors = [color_map[group] for group in x_labels]
+
+    # Create bar plot
+    bars = ax.bar(x_labels, means, yerr=std_devs, capsize=5, color=colors, edgecolor="black")
+
+    # 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"
+    )
+
+    # Formatting
+    ax.set_xticks(np.arange(len(x_labels)))
+    ax.set_xticklabels(x_labels, rotation=45, ha="right")
+    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)
+
+    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:
+    """
+    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.
+
+    Parameters:
+    ----------
+    individual_stats : pd.DataFrame
+        Dataframe containing individual firing rates and corresponding group labels.
+    groupby : str or list of str
+        Column(s) used for grouping.
+    ax : matplotlib.axes.Axes, optional
+        Axes on which to plot the graph; if None, a new figure and axes are created.
+    color_map : dict, optional
+        Dictionary specifying colors for each group. Keys should be group names, and values should be color values.
+    plot_type : str or list of str, optional
+        List of plot types to generate. Options: "box", "violin", "swarm". Default is "box".
+    swarm_alpha : float, optional
+        Transparency of swarm plot points. Default is 0.6.
+
+    Returns:
+    -------
+    matplotlib.axes.Axes
+        Axes with the selected plot type(s) overlayed.
+    """
+    # Ensure groupby is a list for consistent handling
+    if isinstance(groupby, str):
+        groupby = [groupby]
+
+    # Create a categorical column for grouping
+    individual_stats["group"] = individual_stats[groupby].astype(str).agg("_".join, axis=1)
+
+    # 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'.")
+
+    # Get unique groups for coloring
+    unique_groups = individual_stats["group"].unique()
+
+    # Generate colors if no color_map is provided
+    if color_map is None:
+        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:
+        raise ValueError(f"color_map is missing colors for groups: {missing_colors}")
+
+    # Create new figure and axes if ax is not provided
+    if ax is None:
+        fig, ax = plt.subplots(figsize=(10, 6))
+
+    # Sort data for consistent plotting
+    individual_stats = individual_stats.sort_values(by="group")
+
+    # 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)
+        elif pt == "violin":
+            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)
+
+    # 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 by Population")
+    ax.grid(axis='y', linestyle='--', alpha=0.7)
+
+    return ax
+  
+    
 def plot_3d_positions(config=None, populations_list=None, group_by=None, title=None, save_file=None, subset=None):
     """
     Plots a 3D graph of all cells with x, y, z location.
@@ -1154,164 +1318,3 @@ def plot_report_default(config, report_name, variables, gids):
     plot_report(config_file=config, report_file=report_file, report_name=report_name, variables=variables, gids=gids);
     
     return
-
-# The following code was developed by Matthew Stroud 7/15/21 neural engineering supervisor: Satish Nair
-# This is an extension of bmtool: a development of Tyler Banks. 
-# The goal of the sim_setup() function is to output relevant simulation information that can be gathered by providing only the main configuration file.
-
-
-def sim_setup(config_file='simulation_config.json',network=None):
-    if "JPY_PARENT_PID" in os.environ:
-        print("Inside a notebook:")
-        get_ipython().run_line_magic('matplotlib', 'tk')
-
-    
-    # Output tables that contain the cells involved in the configuration file given. Also returns the first biophysical network found
-    bio=plot_basic_cell_info(config_file)
-    if network == None:
-        network=bio
-
-    print("Please wait. This may take a while depending on your network size...")
-    # Plot connection probabilities
-    plt.close(1)
-    probability_connection_matrix(config=config_file,sources=network,targets=network, no_prepend_pop=True,sids= 'pop_name', tids= 'pop_name', bins=10,line_plot=True,verbose=False)
-    # Gives current clamp information
-    plot_I_clamps(config_file)
-    # Plot spike train info
-    plot_inspikes(config_file)
-    # Using bmtool, print total number of connections between cell groups
-    total_connection_matrix(config=config_file,sources='all',targets='all',sids='pop_name',tids='pop_name',title='All Connections found', size_scalar=2, no_prepend_pop=True, synaptic_info='0')
-    # Plot 3d positions of the network
-    plot_3d_positions(populations='all',config=config_file,group_by='pop_name',title='3D Positions',save_file=None)
-
-def plot_I_clamps(fp):
-    print("Plotting current clamp info...")
-    clamps = util.load_I_clamp_from_config(fp)
-    if not clamps:
-        print("     No current clamps were found.")
-        return
-    time=[]
-    num_clamps=0
-    fig, ax = plt.subplots()
-    ax = plt.gca()
-    for clinfo in clamps:
-        simtime=len(clinfo[0])*clinfo[1]
-        time.append(np.arange(0,simtime,clinfo[1]).tolist())
-
-        line,=ax.plot(time[num_clamps],clinfo[0],drawstyle='steps')
-        line.set_label('I Clamp to: '+str(clinfo[2]))
-        plt.legend()
-        num_clamps=num_clamps+1
-
-def plot_basic_cell_info(config_file):
-    print("Network and node info:")
-    nodes=util.load_nodes_from_config(config_file)
-    if not nodes:
-        print("No nodes were found.")
-        return
-    pd.set_option("display.max_rows", None, "display.max_columns", None)
-    bio=[]
-    i=0
-    j=0
-    for j in nodes:
-        node=nodes[j]
-        node_type_id=node['node_type_id']
-        num_cells=len(node['node_type_id'])
-        if node['model_type'][0]=='virtual':
-            CELLS=[]
-            count=1
-            for i in range(num_cells-1):
-                if(node_type_id[i]==node_type_id[i+1]):
-                    count+=1
-                else:
-                    node_type=node_type_id[i]
-                    pop_name=node['pop_name'][i]
-                    model_type=node['model_type'][i]
-                    CELLS.append([node_type,pop_name,model_type,count])
-                    count=1
-            else:
-                node_type=node_type_id[i]
-                pop_name=node['pop_name'][i]
-                model_type=node['model_type'][i]
-                CELLS.append([node_type,pop_name,model_type,count])
-                count=1
-            df1 = pd.DataFrame(CELLS, columns = ["node_type","pop_name","model_type","count"])
-            print(j+':')
-            notebook = is_notebook()
-            if notebook == True:
-                display(HTML(df1.to_html()))
-            else:
-                print(df1)
-        elif node['model_type'][0]=='biophysical':
-            CELLS=[]
-            count=1
-            node_type_id=node['node_type_id']
-            num_cells=len(node['node_type_id'])
-            for i in range(num_cells-1):
-                if(node_type_id[i]==node_type_id[i+1]):
-                    count+=1
-                else:
-                    node_type=node_type_id[i]
-                    pop_name=node['pop_name'][i]
-                    model_type=node['model_type'][i]
-                    model_template=node['model_template'][i]
-                    morphology=node['morphology'][i] if node['morphology'][i] else ''
-                    CELLS.append([node_type,pop_name,model_type,model_template,morphology,count])
-                    count=1
-            else:
-                node_type=node_type_id[i]
-                pop_name=node['pop_name'][i]
-                model_type=node['model_type'][i]
-                model_template=node['model_template'][i]
-                morphology=node['morphology'][i] if node['morphology'][i] else ''
-                CELLS.append([node_type,pop_name,model_type,model_template,morphology,count])
-                count=1
-            df2 = pd.DataFrame(CELLS, columns = ["node_type","pop_name","model_type","model_template","morphology","count"])
-            print(j+':')
-            bio.append(j)
-            notebook = is_notebook()
-            if notebook == True:
-                display(HTML(df2.to_html()))
-            else:
-                print(df2)
-    if len(bio)>0:      
-        return bio[0]        
-
-def plot_inspikes(fp):
-    
-    print("Plotting spike Train info...")
-    trains = util.load_inspikes_from_config(fp)
-    if not trains:
-        print("No spike trains were found.")
-    num_trains=len(trains)
-
-    time=[]
-    node=[]
-    fig, ax = plt.subplots(num_trains, figsize=(12,12),squeeze=False)
-    fig.subplots_adjust(hspace=0.5, wspace=0.5)
-
-    pos=0
-    for tr in trains:
-        node_group=tr[0][2]
-        if node_group=='':
-            node_group='Defined by gids (y-axis)'
-        time=[]
-        node=[]
-        for sp in tr:
-            node.append(sp[1])
-            time.append(sp[0])
-
-        #plotting spike train
-        
-        ax[pos,0].scatter(time,node,s=1)
-        ax[pos,0].title.set_text('Input Spike Train to: '+node_group)
-        plt.xticks(rotation = 45)
-        if num_trains <=4:
-            ax[pos,0].xaxis.set_major_locator(plt.MaxNLocator(20))
-        if num_trains <=9 and num_trains >4:
-            ax[pos,0].xaxis.set_major_locator(plt.MaxNLocator(4))
-        elif num_trains <9:
-            ax[pos,0].xaxis.set_major_locator(plt.MaxNLocator(2))
-        #fig.suptitle('Input Spike Train to: '+node_group, fontsize=14)
-        fig.show()
-        pos+=1

{bmtool-0.6.7 → bmtool-0.6.8}/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.8}/bmtool.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: bmtool
-Version: 0.6.7
+Version: 0.6.8
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 
@@ -53,6 +53,7 @@ A collection of modules to make developing [Neuron](https://www.neuron.yale.edu/
 - [Synapses](#synapses-module)
 - [Connectors](#connectors-module)
 - [Bmplot](#bmplot-module)
+- [Analysis](#analysis-module)
 - [SLURM](#slurm-module)
 - [Graphs](#graphs-module)
 
@@ -471,7 +472,11 @@ bmplot.plot_network_graph(config='config.json',sources='LA',targets='LA',tids='p
 
     
 ![png](readme_figures/output_35_0.png)
-    
+
+
+## Analysis Module
+### A notebook example of how to use the spikes module can be found [here](examples/analysis/using_spikes.ipynb)
+
 ## SLURM Module
 ### This is an extremely helpful module that can simplify using SLURM too submit your models. There is also features to enable doing a seedSweep. This will vary the parameters of the simulation and make tuning the model easier. An example can be found [here](examples/SLURM/using_BlockRunner.ipynb) 
 

{bmtool-0.6.7 → bmtool-0.6.8}/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.8}/setup.py

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