spectre-core 0.0.1__py3-none-any.whl

spectre_core/receivers/library/test/receiver.py

@@ -0,0 +1,174 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from spectre_core.receivers import validators
+from spectre_core.receivers.base import SPECTREReceiver
+from spectre_core.receivers.receiver_register import register_receiver
+from spectre_core.receivers.library.test.gr import cosine_signal_1
+from spectre_core.receivers.library.test.gr import tagged_staircase
+from spectre_core.file_handlers.configs import CaptureConfig
+
+
+@register_receiver("test")
+class Receiver(SPECTREReceiver):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+
+    def _set_capture_methods(self) -> None:
+        self._capture_methods = {
+            "cosine-signal-1": self.__cosine_signal_1,
+            "tagged-staircase": self.__tagged_staircase
+        }
+    
+
+    def _set_validators(self) -> None:
+        self._validators = {
+            "cosine-signal-1": self.__cosine_signal_1_validator,
+            "tagged-staircase": self.__tagged_staircase_validator
+        }
+    
+
+    def _set_type_templates(self) -> None:
+        self._type_templates = {
+            "cosine-signal-1": {
+                'samp_rate': int, # [Hz]
+                'frequency': float, # [Hz]
+                'amplitude': float, # unitless
+                'chunk_size': int, # [s]
+                'joining_time': int, # [s]
+                'time_resolution': float, # [s]
+                'frequency_resolution': float, # [Hz]
+                'window_type': str, # the window type for the STFFT
+                'window_kwargs': dict, # keyword arguments for scipy get window function. Must be in order as in scipy documentation.
+                'window_size': int, # number of samples for the window
+                'STFFT_kwargs': dict, # keyword arguments for scipy STFFT class
+                'chunk_key': str, # tag will map to the chunk with this key
+                'event_handler_key': str # tag will map to event handler with this key during post processing
+            },
+            "tagged-staircase": {
+                'samp_rate': int, # [Hz]
+                'min_samples_per_step': int, # [samples]
+                'max_samples_per_step': int, # [samples]
+                'freq_step': float, # [Hz]
+                'step_increment': int, # [samples]
+                'chunk_size': int, # [s]
+                'joining_time': int, # [s]
+                'time_resolution': float, # [s]
+                'frequency_resolution': float, # [Hz]
+                'window_type': str, # the window type for the STFFT
+                'window_kwargs': dict, # keyword arguments for scipy get window function. Must be in order as in scipy documentation.
+                'window_size': int, # number of samples for the window
+                'STFFT_kwargs': dict, # keyword arguments for scipy STFFT class
+                'chunk_key': str, # tag will map to the chunk with this key
+                'event_handler_key': str, # tag will map to event handler with this key during post processing
+            }
+        }
+    
+    def _set_specifications(self) -> None:
+        self._specifications = {
+        } 
+
+
+    def __cosine_signal_1(self, capture_config: CaptureConfig) -> None:
+        cosine_signal_1.main(capture_config)
+    
+
+    def __tagged_staircase(self, capture_config: CaptureConfig) -> None:
+        tagged_staircase.main(capture_config)
+    
+
+    def __cosine_signal_1_validator(self, capture_config: CaptureConfig) -> None:
+        # unpack the capture config
+        samp_rate = capture_config["samp_rate"]
+        frequency = capture_config["frequency"]
+        amplitude = capture_config["amplitude"]
+        chunk_size = capture_config["chunk_size"]
+        window_type = capture_config["window_type"]
+        window_size = capture_config["window_size"]
+        STFFT_kwargs = capture_config["STFFT_kwargs"]
+        chunk_key = capture_config["chunk_key"]
+        event_handler_key = capture_config["event_handler_key"]
+        time_resolution = capture_config["time_resolution"]
+        frequency_resolution = capture_config["frequency_resolution"]
+
+        validators.samp_rate_strictly_positive(samp_rate)
+        validators.chunk_size_strictly_positive(chunk_size)
+        validators.time_resolution(time_resolution, chunk_size) 
+        validators.window(window_type, 
+                                          {}, 
+                                          window_size,
+                                          chunk_size,
+                                          samp_rate)
+        validators.STFFT_kwargs(STFFT_kwargs)
+        validators.chunk_key(chunk_key, "fixed")
+        validators.event_handler_key(event_handler_key, "fixed")
+
+        if time_resolution != 0:
+            raise ValueError(f"Time resolution must be zero. Received: {time_resolution}")
+        
+        if frequency_resolution != 0:
+            raise ValueError(f"Frequency resolution must be zero. Received {frequency_resolution}")
+        
+        # check that the sample rate is an integer multiple of the underlying signal frequency
+        if samp_rate % frequency != 0:
+            raise ValueError("The sampling rate must be some integer multiple of frequency")
+
+        a = samp_rate/frequency
+        if a < 2:
+            raise ValueError(f"The ratio of sampling rate over frequency must be a natural number greater than two.  Received: {a}")
+        
+        # ensuring the window type is rectangular
+        if window_type != "boxcar":
+            raise ValueError(f"The window type must be \"boxcar\". Received: {window_type}")
+        
+        # analytical requirement
+        # if p is the number of sampled cycles, we can find that p = window_size / a
+        # the number of sampled cycles must be a positive natural number.
+        p = window_size / a
+        if window_size % a != 0:
+            raise ValueError(f"The number of sampled cycles must be a positive natural number. Computed that p={p}")
+    
+    
+        if amplitude <= 0:
+            raise ValueError(f"The amplitude must be strictly positive. Received: {amplitude}")
+    
+
+    def __tagged_staircase_validator(self, capture_config: CaptureConfig) -> None:
+        samp_rate = capture_config["samp_rate"]
+        min_samples_per_step = capture_config["min_samples_per_step"]
+        max_samples_per_step = capture_config["max_samples_per_step"]
+        freq_step = capture_config["freq_step"]
+        step_increment = capture_config["step_increment"]
+        chunk_size = capture_config["chunk_size"]
+        window_type = capture_config["window_type"]
+        window_kwargs = capture_config["window_kwargs"]
+        window_size = capture_config["window_size"]
+        STFFT_kwargs = capture_config["STFFT_kwargs"]
+        chunk_key = capture_config["chunk_key"]
+        event_handler_key = capture_config["event_handler_key"]
+        time_resolution = capture_config["time_resolution"]
+
+        validators.samp_rate_strictly_positive(samp_rate)
+        validators.chunk_size_strictly_positive(chunk_size)
+        validators.time_resolution(time_resolution, chunk_size)
+        validators.window(window_type, window_kwargs, window_size, chunk_size, samp_rate)
+        validators.STFFT_kwargs(STFFT_kwargs)
+        validators.chunk_key(chunk_key, "sweep")
+        validators.event_handler_key(event_handler_key, "sweep")
+
+        if freq_step != samp_rate:
+            raise ValueError(f"The frequency step must be equal to the sampling rate")
+        
+        if min_samples_per_step <= 0:
+            raise ValueError(f"Minimum samples per step must be strictly positive. Received: {min_samples_per_step}")
+        
+        if max_samples_per_step <= 0:
+            raise ValueError(f"Maximum samples per step must be strictly positive. Received: {max_samples_per_step}")
+        
+        if step_increment <= 0:
+            raise ValueError(f"Step increment must be strictly positive. Received: {step_increment}")
+        
+        if min_samples_per_step > max_samples_per_step:
+            raise ValueError(f"Minimum samples per step cannot be greater than the maximum samples per step. Received: {min_samples_per_step} > {max_samples_per_step}")

spectre_core/receivers/receiver_register.py

@@ -0,0 +1,22 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+# Global dictionaries to hold the mappings
+receivers = {}
+
+# classes decorated with @register_receiver("<receiver_name>")
+# will be added to the global map of receivers with key "receiver_name"
+def register_receiver(receiver_name: str):
+    def decorator(cls):
+        receivers[receiver_name] = cls
+        return cls
+    return decorator
+
+# return a list of all receiver names
+def list_all_receiver_names() -> list[str]:
+    return list(receivers.keys())
+
+
+
+

spectre_core/receivers/validators.py

@@ -0,0 +1,205 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from logging import getLogger
+_LOGGER = getLogger(__name__)
+
+from math import floor
+import warnings
+
+from scipy.signal import get_window
+
+
+def closed_upper_bound_RF_gain(RF_gain: float, 
+                               RF_gain_upper_bound: float) -> None:
+    if not (RF_gain <= RF_gain_upper_bound):
+        raise ValueError(f"RF gain must be strictly less than or equal to {RF_gain_upper_bound} [dB]. Got {RF_gain} [dB]")
+
+
+def closed_upper_bound_IF_gain(IF_gain: float, 
+                               IF_gain_upper_bound: float) -> None:
+    if not (IF_gain <= IF_gain_upper_bound):
+        raise ValueError(f"IF gain must be strictly less than or equal to {IF_gain_upper_bound} [dB]. Got {IF_gain} [dB]")
+
+
+def closed_confine_center_freq(center_freq: float, 
+                               center_freq_lower_bound: float, 
+                               center_freq_upper_bound: float) -> None:
+    if not (center_freq_lower_bound <= center_freq <= center_freq_upper_bound):
+        raise ValueError(f"Center frequency must be between {center_freq_lower_bound*1e-3} [kHz] and {center_freq_upper_bound*1e-9} [GHz]. Received {center_freq*1e-6} [MHz]")
+    
+
+def closed_confine_samp_rate(samp_rate: int, 
+                             samp_rate_lower_bound: int, 
+                             samp_rate_upper_bound: int) -> None:
+    if not (samp_rate_lower_bound <= samp_rate <= samp_rate_upper_bound):
+        raise ValueError(f"Sampling rate must be between {samp_rate_lower_bound*1e-6} [MHz] and {samp_rate_upper_bound*1e-6} [MHz]. Received {samp_rate*1e-6} [MHz]")
+    
+
+def closed_confine_bandwidth(bandwidth: float, 
+                             bandwidth_lower_bound: float, 
+                             bandwidth_upper_bound: float) -> None:
+    if not (bandwidth_lower_bound <= bandwidth <= bandwidth_upper_bound):
+        raise ValueError(f"Bandwidth must be between {bandwidth_lower_bound*1e-3} [kHz] and {bandwidth_upper_bound*1e-6} [MHz]. Received {bandwidth*1e-6} [MHz]")
+    
+    
+def is_power_of_two(n):
+    return (n != 0) and (n & (n-1) == 0)
+
+
+def window(window_type: str, 
+           window_kwargs: dict, 
+           window_size: int,
+           chunk_size: int,
+           samp_rate: float) -> None:
+    
+    if not is_power_of_two(window_size):
+        raise ValueError(f"Window size must be some power of two. Received: {window_size}")
+    
+
+    if window_size*(1/samp_rate) > chunk_size:
+        raise ValueError("Windowing interval must be strictly less than the chunk size")
+    
+    try:
+        window_params = (window_type, 
+                         *window_kwargs.values())
+        _ = get_window(window_params, window_size)
+    except Exception as e:
+        raise Exception(f"An error has occurred while validating the window. Received: {str(e)}")
+    
+
+def STFFT_kwargs(STFFT_kwargs: dict):
+    if len(STFFT_kwargs) == 0:
+        raise ValueError("STFFT kwargs cannot be empty")
+    
+    STFFT_keys = STFFT_kwargs.keys()
+    if "hop" not in STFFT_keys:
+        raise KeyError(f"\"hop\" is a required key in STFFT kwargs. Received: {STFFT_keys}")
+    
+    hop_value = STFFT_kwargs.get("hop")
+    hop_value_type = type(hop_value)
+    if hop_value_type != int:
+        raise TypeError(f"\"hop\" must be specified as an integer. Received: {hop_value_type}")
+    
+    if hop_value < 0:
+        raise ValueError(f"\"hop\" must be strictly positive. Received: {hop_value}")
+    
+    
+def center_freq_strictly_positive(center_freq: float):
+    if center_freq <= 0:
+        raise ValueError(f"Center frequency must be strictly positive. Received: {center_freq*1e-6} [MHz]")
+    
+
+def bandwidth_strictly_positive(bandwidth: float) -> None:
+    if bandwidth < 0:
+        raise ValueError(f"Bandwidth must be non-negative. Received: {bandwidth*1e-6} [MHz]")
+    
+
+def nyquist_criterion(samp_rate: int, 
+                      bandwidth: float) -> None:
+    if samp_rate < bandwidth:
+        raise ValueError("Sample rate must be greater than or equal to the bandwidth")
+    
+
+def samp_rate_strictly_positive(samp_rate: int) -> None:
+    if samp_rate < 0:
+        raise ValueError(f"Sample rate must be strictly positive. Received: {samp_rate} [Hz]")
+    
+
+def chunk_size_strictly_positive(chunk_size: int) -> None:
+    if chunk_size <= 0:
+        raise ValueError(f"Chunk size must be strictly positive. Received: {chunk_size} [s]")
+    
+
+def time_resolution(time_resolution: float, 
+                    chunk_size: int) -> None:
+    if time_resolution < 0:
+        raise ValueError(f"Time resolution must be non-negative. Received: {time_resolution} [s]")
+    
+    if time_resolution > chunk_size:
+        raise ValueError("Time resolution must be less than or equal to chunk size")
+    
+
+def frequency_resolution(frequency_resolution: float,
+                         bandwidth: float = None) -> None:
+    if frequency_resolution < 0:
+        raise ValueError(f"Frequency resolution must be non-negative. Received {frequency_resolution} [Hz]")
+    
+    if bandwidth is not None and frequency_resolution >= bandwidth:
+        raise ValueError(f"Frequency resolution must be less than the bandwidth. Received frequency resolution to be {frequency_resolution} [Hz], with bandwidth {bandwidth} [Hz]")
+    
+
+def chunk_key(chunk_key: str, 
+              expected_chunk_key: str) -> None:
+    if chunk_key != expected_chunk_key:
+        raise ValueError(f"Expected \"{expected_chunk_key}\" for the chunk_key, received: {chunk_key}")
+    
+
+def event_handler_key(event_handler_key: str, 
+                      expected_event_handler_key: str) -> None:
+    if event_handler_key != expected_event_handler_key:
+        raise ValueError(f"Expected \"{expected_event_handler_key}\" for the event_handler_key, received: {event_handler_key}")
+    
+
+def gain_is_negative(gain: float) -> None:
+    if gain > 0:
+        raise ValueError(f"Gain must be non-positive. Received {gain} [dB]")
+    
+
+def _compute_num_steps_per_sweep(min_freq: float, 
+                                 max_freq: float,
+                                 samp_rate: int,
+                                 freq_step: float) -> int:
+     return floor((max_freq - min_freq + samp_rate/2) / freq_step)
+
+
+def num_steps_per_sweep(min_freq: float, 
+                        max_freq: float, 
+                        samp_rate: int, 
+                        freq_step: float) -> None:
+    num_steps_per_sweep = _compute_num_steps_per_sweep(min_freq, 
+                                                       max_freq, 
+                                                       samp_rate, 
+                                                       freq_step)
+    if num_steps_per_sweep <= 1:
+        raise ValueError(f"We need strictly greater than one sample per step. Computed: {num_steps_per_sweep}")
+    
+
+def sweep_interval(min_freq: float, 
+                  max_freq: float, 
+                  samp_rate: int, 
+                  freq_step: float,
+                  samples_per_step: int,
+                  chunk_size: float) -> None: 
+    num_steps_per_sweep = _compute_num_steps_per_sweep(min_freq, 
+                                                       max_freq, 
+                                                       samp_rate, 
+                                                       freq_step)
+    num_samples_per_sweep = num_steps_per_sweep * samples_per_step
+    sweep_interval = num_samples_per_sweep * 1/samp_rate
+    if sweep_interval > chunk_size:
+        raise ValueError(f"Sweep interval must be less than the chunk size. Computed sweep interval: {sweep_interval} [s] is greater than the given chunk size {chunk_size} [s]")
+    
+
+def num_samples_per_step(samples_per_step: int, 
+                         window_size: int) -> None:
+    if window_size >= samples_per_step:
+        raise ValueError(f"Window size must be strictly less than the number of samples per step. Received window size {window_size} [samples], which is more than or equal to the number of samples per step {samples_per_step}")
+    
+
+def non_overlapping_steps(freq_step: float, 
+                          samp_rate: int) -> None:
+    if freq_step < samp_rate:
+        raise NotImplementedError(f"SPECTRE does not yet support spectral steps overlapping in frequency. Received frequency step {freq_step/1e6} [MHz] which is less than the sample rate {samp_rate/1e6} [MHz]")
+    
+
+def step_interval(samples_per_step: int, 
+                  samp_rate: int, 
+                  api_latency: float) -> None:
+    step_interval = samples_per_step * 1/samp_rate # [s]
+    if step_interval < api_latency:
+        warning_message = f"The computed step interval of {step_interval} [s] is of the order of empirically derived api latency {api_latency} [s]; you may experience undefined behaviour!"
+        warnings.warn(warning_message)
+        _LOGGER.warning(warning_message)
+    

spectre_core/spectrograms/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later

spectre_core/spectrograms/analytical.py

@@ -0,0 +1,205 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from typing import Callable
+from dataclasses import dataclass
+
+import numpy as np
+
+from spectre_core.file_handlers.configs import CaptureConfig
+from spectre_core.spectrograms.spectrogram import Spectrogram
+from spectre_core.spectrograms.array_operations import is_close
+from spectre_core.exceptions import ModeNotFoundError
+
+
+
+@dataclass
+class TestResults:
+    # Whether the times array matches analytically 
+    times_validated: bool = False  
+    # Whether the frequencies array matches analytically
+    frequencies_validated: bool = False  
+    # Maps each time to whether the corresponding spectrum matched analytically
+    spectrum_validated: dict[float, bool] = None
+
+    @property
+    def num_validated_spectrums(self) -> int:
+        """Counts the number of validated spectrums."""
+        return sum(is_validated for is_validated in self.spectrum_validated.values())
+
+    @property
+    def num_invalid_spectrums(self) -> int:
+        """Counts the number of spectrums that are not validated."""
+        return len(self.spectrum_validated) - self.num_validated_spectrums
+
+
+class _AnalyticalFactory:
+    def __init__(self):
+        self._builders: dict[str, Callable] = {
+            "cosine-signal-1": self.cosine_signal_1,
+            "tagged-staircase": self.tagged_staircase
+        }
+        self._test_modes = list(self.builders.keys())
+
+
+    @property
+    def builders(self) -> dict[str, Callable]:
+        return self._builders
+    
+
+    @property
+    def test_modes(self) -> list[str]:
+        return self._test_modes
+    
+
+    def get_spectrogram(self, 
+                        num_spectrums: int, 
+                        capture_config: CaptureConfig) -> Spectrogram:
+        """Get an analytical spectrogram based on a test receiver capture config.
+        
+        The anaytically derived spectrogram should be able to be fully determined
+        by parameters in the corresponding capture config and the number of spectrums
+        in the output spectrogram.
+        """
+        receiver_name, test_mode = capture_config['receiver'], capture_config['mode']
+
+        if receiver_name != "test":
+            raise ValueError(f"Input capture config must correspond to the test receiver")
+        
+        builder_method = self.builders.get(test_mode)
+        if builder_method is None:
+            raise ModeNotFoundError(f"Test mode not found. Expected one of {self.test_modes}, but received {test_mode}")
+        return builder_method(num_spectrums, 
+                              capture_config)
+    
+
+    def cosine_signal_1(self, 
+                        num_spectrums: int,
+                        capture_config: CaptureConfig) -> Spectrogram:
+        # Extract necessary parameters from the capture configuration.
+        window_size = capture_config['window_size']
+        samp_rate = capture_config['samp_rate']
+        amplitude = capture_config['amplitude']
+        frequency = capture_config['frequency']
+        hop = capture_config['STFFT_kwargs']['hop']
+
+        # Calculate derived parameters a (sampling rate ratio) and p (sampled periods).
+        a = int(samp_rate / frequency)
+        p = int(window_size / a)
+
+        # Create the analytical spectrum, which is constant in time.
+        spectrum = np.zeros(window_size)
+        spectral_amplitude = amplitude * window_size / 2
+        spectrum[p] = spectral_amplitude
+        spectrum[window_size - p] = spectral_amplitude
+
+        # Align spectrum to naturally ordered frequency array.
+        spectrum = np.fft.fftshift(spectrum)
+
+        # Populate the spectrogram with identical spectra.
+        analytical_dynamic_spectra = np.ones((window_size, num_spectrums)) * spectrum[:, np.newaxis]
+
+        # Compute time array.
+        sampling_interval = 1 / samp_rate
+        times = np.arange(num_spectrums) * hop * sampling_interval
+
+        # compute the frequency array.
+        frequencies = np.fft.fftshift(np.fft.fftfreq(window_size, sampling_interval))
+
+        # Return the spectrogram.
+        return Spectrogram(analytical_dynamic_spectra,
+                           times,
+                           frequencies,
+                           'analytically-derived-spectrogram',
+                           spectrum_type="amplitude")
+
+
+    def tagged_staircase(self, 
+                        num_spectrums: int,
+                        capture_config: CaptureConfig) -> Spectrogram:
+        # Extract necessary parameters from the capture configuration.
+        window_size = capture_config['window_size']
+        min_samples_per_step = capture_config['min_samples_per_step']
+        max_samples_per_step = capture_config['max_samples_per_step']
+        step_increment = capture_config['step_increment']
+        samp_rate = capture_config['samp_rate']
+
+        # Calculate step sizes and derived parameters.
+        num_samples_per_step = np.arange(min_samples_per_step, max_samples_per_step + 1, step_increment)
+        num_steps = len(num_samples_per_step)
+
+        # Create the analytical spectrum, constant in time.
+        spectrum = np.zeros(window_size * num_steps)
+        step_count = 0
+        for i in range(num_steps):
+            step_count += 1
+            spectral_amplitude = window_size * step_count
+            spectrum[int(window_size/2) + i*window_size] = spectral_amplitude
+
+        # Populate the spectrogram with identical spectra.
+        analytical_dynamic_spectra = np.ones((window_size * num_steps, num_spectrums)) * spectrum[:, np.newaxis]
+
+        # Compute time array
+        num_samples_per_sweep = sum(num_samples_per_step)
+        midpoint_sample = sum(num_samples_per_step) // 2
+        sampling_interval = 1 / samp_rate
+        # compute the sample index we are "assigning" to each spectrum
+        # and multiply by the sampling interval to get the equivalent physical time
+        times = np.array([ midpoint_sample + (i * num_samples_per_sweep) for i in range(num_spectrums) ]) * sampling_interval
+
+        # Compute the frequency array
+        baseband_frequencies = np.fft.fftshift(np.fft.fftfreq(window_size, sampling_interval))
+        frequencies = np.empty((window_size * num_steps))
+        for i in range(num_steps):
+            lower_bound = i * window_size
+            upper_bound = (i + 1) * window_size
+            frequencies[lower_bound:upper_bound] = baseband_frequencies + (samp_rate / 2) + (samp_rate * i)
+
+        # Return the spectrogram.
+        return Spectrogram(analytical_dynamic_spectra,
+                           times,
+                           frequencies,
+                           'analytically-derived-spectrogram',
+                           spectrum_type="amplitude")
+    
+
+def get_analytical_spectrogram(num_spectrums: int,
+                               capture_config: CaptureConfig) -> Spectrogram:
+    
+    factory = _AnalyticalFactory()
+    return factory.get_spectrogram(num_spectrums,
+                                   capture_config)
+
+
+def validate_analytically(spectrogram: Spectrogram,
+                          capture_config: CaptureConfig,
+                          absolute_tolerance: float) -> TestResults:
+
+    analytical_spectrogram = get_analytical_spectrogram(spectrogram.num_times,
+                                                        capture_config)
+
+
+    test_results = TestResults()
+
+    if is_close(analytical_spectrogram.times,
+                spectrogram.times,
+                absolute_tolerance):
+        test_results.times_validated = True
+
+
+    if is_close(analytical_spectrogram.frequencies,
+                spectrogram.frequencies,
+                absolute_tolerance):
+        test_results.frequencies_validated = True
+
+    test_results.spectrum_validated = {}
+    for i in range(spectrogram.num_times):
+        time = spectrogram.times[i]
+        analytical_spectrum = analytical_spectrogram.dynamic_spectra[:, i]
+        spectrum = spectrogram.dynamic_spectra[:, i]
+        test_results.spectrum_validated[time] = is_close(analytical_spectrum, 
+                                                         spectrum,
+                                                         absolute_tolerance)
+
+    return test_results

spectre_core/spectrograms/array_operations.py

@@ -0,0 +1,77 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from datetime import datetime
+
+import numpy as np
+
+
+def is_close(ar: np.ndarray, 
+             ar_comparison: np.ndarray,
+             absolute_tolerance: float) -> bool:
+    """Close enough accounts for wiggle-room equating floats."""
+    return np.all(np.isclose(ar, 
+                             ar_comparison, 
+                             atol=absolute_tolerance))
+
+
+def find_closest_index(
+    target_value: float | datetime, 
+    array: np.ndarray, 
+    enforce_strict_bounds: bool = False
+) -> int:
+    # Ensure input array is a numpy array
+    array = np.asarray(array)
+
+    # Convert to datetime64 if necessary
+    if isinstance(target_value, datetime) or np.issubdtype(array.dtype, np.datetime64):
+        target_value = np.datetime64(target_value)
+        array = array.astype('datetime64[ns]')
+    else:
+        target_value = float(target_value)
+        array = array.astype(float)
+
+    # Check bounds if strict enforcement is required
+    if enforce_strict_bounds:
+        max_value, min_value = np.nanmax(array), np.nanmin(array)
+        if target_value > max_value:
+            raise ValueError(f"Target value {target_value} exceeds max array value {max_value}")
+        if target_value < min_value:
+            raise ValueError(f"Target value {target_value} is less than min array value {min_value}")
+
+    # Find the index of the closest value
+    return np.argmin(np.abs(array - target_value))
+
+
+def normalise_peak_intensity(array: np.ndarray) -> np.ndarray:
+    return array/np.nanmax(array)
+
+
+def compute_resolution(array: np.ndarray) -> float:
+    # Check that the array is one-dimensional
+    if array.ndim != 1:
+        raise ValueError("Input array must be one-dimensional")
+    
+    if len(array) < 2:
+        raise ValueError("Input array must contain at least two elements")
+    
+    # Calculate differences between consecutive elements.
+    resolutions = np.diff(array)
+
+    return np.nanmedian(resolutions)
+
+
+def compute_range(array: np.ndarray) -> float:
+    # Check that the array is one-dimensional
+    if array.ndim != 1:
+        raise ValueError("Input array must be one-dimensional")
+    
+    if len(array) < 2:
+        raise ValueError("Input array must contain at least two elements")
+    return array[-1] - array[0]
+
+
+def subtract_background(array: np.ndarray, start_index: int, end_index: int) -> np.ndarray:
+    array -= np.nanmean(array[start_index:end_index+1])
+    return array