FrequencyDomainSpikeAnalysisResult#

class neurodent.visualization.FrequencyDomainSpikeAnalysisResult(result_sas: list[SortingAnalyzer] | None = None, result_mne: RawArray | None = None, spike_indices: list[ndarray] | None = None, detection_params: dict | None = None, animal_id: str | None = None, genotype: str | None = None, animal_day: str | None = None, bin_folder_name: str | None = None, metadata: RecordingMetadata | None = None, channel_names: list[str] | None = None, assume_from_number=False)[source]#

Bases: AnimalFeatureParser

Wrapper for frequency-domain spike detection results.

This class mirrors the SpikeAnalysisResult interface to ensure compatibility with existing WindowAnalysisResult.read_sars_spikes() infrastructure.

__init__(result_sas: list[SortingAnalyzer] | None = None, result_mne: RawArray | None = None, spike_indices: list[ndarray] | None = None, detection_params: dict | None = None, animal_id: str | None = None, genotype: str | None = None, animal_day: str | None = None, bin_folder_name: str | None = None, metadata: RecordingMetadata | None = None, channel_names: list[str] | None = None, assume_from_number=False) → None[source]#

Initialize FrequencyDomainSpikeAnalysisResult.

Parameters:

  • result_sas (list[si.SortingAnalyzer], optional) – SpikeInterface SortingAnalyzers for compatibility

  • result_mne (mne.io.RawArray, optional) – MNE RawArray with spike annotations

  • spike_indices (list[np.ndarray], optional) – Raw spike detection results per channel

  • detection_params (dict, optional) – Parameters used for spike detection

  • animal_id (str, optional) – Identifier for the animal

  • genotype (str, optional) – Genotype of animal

  • animal_day (str, optional) – Recording day identifier

  • bin_folder_name (str, optional) – Binary folder name

  • metadata (core.RecordingMetadata, optional) – Recording metadata

  • channel_names (list[str], optional) – List of channel names

  • assume_from_number (bool, optional) – Assume channel names from numbers

classmethod from_detection_results(spike_indices_per_channel: list[ndarray], mne_raw_with_annotations: RawArray, detection_params: dict, animal_id: str | None = None, genotype: str | None = None, animal_day: str | None = None, bin_folder_name: str | None = None, metadata: RecordingMetadata | None = None, assume_from_number: bool = False)[source]#

Create FrequencyDomainSpikeAnalysisResult from raw detection outputs.

Parameters:

  • spike_indices_per_channel – List of spike sample indices per channel

  • mne_raw_with_annotations – MNE RawArray with spike annotations

  • detection_params – Parameters used for detection

  • animal_id – Identifier for the animal

  • genotype – Genotype of animal

  • animal_day – Recording day identifier

  • bin_folder_name – Binary folder name

  • metadata – Recording metadata

  • assume_from_number – Assume channel names from numbers

Returns:

Initialized result object

Return type:

FrequencyDomainSpikeAnalysisResult

convert_to_mne(chunk_duration_s: float = 60, save_raw=True, multiprocess_mode: Literal['dask', 'serial'] = 'serial') → RawArray[source]#

Convert SortingAnalyzers to MNE RawArray.

Parameters:

  • chunk_duration_s (float, optional) – Duration in seconds of each chunk read during conversion. Smaller values reduce peak RAM; larger values improve throughput. Defaults to 60.

  • save_raw – Whether to save the result internally

  • multiprocess_mode – Whether to use Dask for parallel per-channel conversion. Defaults to “serial”.

Returns:

MNE RawArray with spike annotations

Return type:

mne.io.RawArray

save_fif_and_json(folder: str | Path, convert_to_mne=True, make_folder=True, slugify_filebase=True, save_abbrevs_as_chnames=False, overwrite=False, multiprocess_mode: Literal['dask', 'serial'] = 'serial', chunk_duration_s: float = 60)[source]#

Archive frequency domain spike analysis result as fif and json files. Mirrors the SpikeAnalysisResult.save_fif_and_json interface.

Parameters:

  • folder – Destination folder to save results

  • convert_to_mne – If True, convert to MNE if needed

  • make_folder – If True, create folder if it doesn’t exist

  • slugify_filebase – If True, slugify the filename base

  • save_abbrevs_as_chnames – If True, save abbreviations as channel names

  • overwrite – If True, overwrite existing files

  • multiprocess_mode – Whether to use Dask for parallel conversion. Defaults to “serial”.

  • chunk_duration_s (float, optional) – Duration in seconds of each chunk read when converting SortingAnalyzers to a NumPy trace array. Smaller values reduce peak RAM at the cost of more I/O round-trips; larger values improve throughput on high-memory systems. Only used when result_mne is None and convert_to_mne is True. Defaults to 60.

classmethod load_fif_and_json(folder: str | Path)[source]#

Load FrequencyDomainSpikeAnalysisResult from fif and json files. Mirrors the SpikeAnalysisResult.load_fif_and_json interface.

Parameters:

folder – Folder containing the saved files

Returns:

Loaded result object

Return type:

FrequencyDomainSpikeAnalysisResult

plot_spike_averaged_traces(tmin=-0.5, tmax=0.5, baseline=None, save_dir=None, animal_id=None, save_epoch=True)[source]#

Plot spike-triggered averages for each channel.

Based on plot_spike_evoked_by_channel from the pipeline script.

Parameters:

  • tmin – Start time for epochs (seconds)

  • tmax – End time for epochs (seconds)

  • baseline – Baseline correction period

  • save_dir – Directory to save plots and epoch data

  • animal_id – Animal identifier for filenames

  • save_epoch – Whether to save epoch data

Returns:

Spike counts per channel, keyed by channel index

Return type:

dict

get_spike_counts_per_channel() → list[int][source]#

Get spike counts per channel.

Returns:

Number of detected spikes per channel

Return type:

list

get_total_spike_count() → int[source]#

Get total number of detected spikes across all channels.

static convert_sas_to_mne(sas: list[SortingAnalyzer], chunk_duration_s: float = 60, multiprocess_mode: Literal['dask', 'serial'] = 'serial') → RawArray[source]#

Convert a list of SortingAnalyzers to a MNE RawArray.

Parameters:

  • sas (list[si.SortingAnalyzer]) – The list of SortingAnalyzers to convert

  • chunk_duration_s (float, optional) – Duration in seconds of each chunk read during conversion. Defaults to 60.

  • multiprocess_mode (Literal["dask", "serial"], optional) – Whether to use Dask for parallel per-channel conversion. Defaults to “serial”.

Returns:

The converted RawArray, with spikes labeled as annotations

Return type:

mne.io.RawArray

static convert_sa_to_np(sa: SortingAnalyzer, chunk_duration_s: float = 60, multiprocess_mode: Literal['dask', 'serial'] = 'serial') → ndarray[source]#

Convert a SortingAnalyzer to a numpy array of traces.

Parameters:

  • sa (si.SortingAnalyzer) – The SortingAnalyzer to convert. Must have only 1 channel.

  • chunk_duration_s (float, optional) – Duration in seconds of each chunk read during conversion. Defaults to 60.

  • multiprocess_mode (Literal["dask", "serial"], optional) – Whether to use Dask for parallel per-chunk reads. Defaults to “serial”. Note: avoid using “dask” when this method is already called from convert_sas_to_mne in Dask mode, as that parallelizes across channels and nested Dask may not improve performance.

Returns:

The converted traces

Return type:

np.ndarray

__str__()[source]#

String representation of the result object.