spectre-core 0.0.9__py3-none-any.whl → 0.0.11__py3-none-any.whl

spectre_core/receivers/gr/_test.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+#
+# SPDX-License-Identifier: GPL-3.0
+#
+# GNU Radio Python Flow Graph
+# Title: Test receiver
+# GNU Radio version: 3.10.1.1
+
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+#
+# Test receiver top blocks
+#
+
+from functools import partial
+from dataclasses import dataclass
+
+from gnuradio import gr
+from gnuradio import blocks
+from gnuradio import spectre
+from gnuradio import analog
+
+from spectre_core.capture_configs import Parameters, PNames
+from spectre_core.config import get_chunks_dir_path
+from ._base import capture
+
+
+class _cosine_signal_1(gr.top_block):
+    def __init__(self, 
+                 tag: str,
+                 parameters: Parameters):
+        gr.top_block.__init__(self, catch_exceptions=True)
+
+        ##################################################
+        # Unpack capture config
+        ##################################################
+        samp_rate   = parameters.get_parameter_value(PNames.SAMPLE_RATE)
+        batch_size  = parameters.get_parameter_value(PNames.BATCH_SIZE)
+        frequency   = parameters.get_parameter_value(PNames.FREQUENCY)
+        amplitude   = parameters.get_parameter_value(PNames.AMPLITUDE)
+
+        ##################################################
+        # Blocks
+        ##################################################
+        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_chunks_dir_path(), 
+                                                                     tag, 
+                                                                     batch_size, 
+                                                                     samp_rate)
+        self.blocks_throttle_0_1 = blocks.throttle(gr.sizeof_float*1, 
+                                                   samp_rate,
+                                                   True)
+        self.blocks_throttle_0 = blocks.throttle(gr.sizeof_float*1, 
+                                                 samp_rate,
+                                                 True)
+        self.blocks_null_source_1 = blocks.null_source(gr.sizeof_float*1)
+        self.blocks_float_to_complex_1 = blocks.float_to_complex(1)
+        self.analog_sig_source_x_0 = analog.sig_source_f(samp_rate, 
+                                                         analog.GR_COS_WAVE, 
+                                                         frequency, 
+                                                         amplitude, 
+                                                         0, 
+                                                         0)
+
+
+        ##################################################
+        # Connections
+        ##################################################
+        self.connect((self.analog_sig_source_x_0, 0), (self.blocks_throttle_0, 0))
+        self.connect((self.blocks_float_to_complex_1, 0), (self.spectre_batched_file_sink_0, 0))
+        self.connect((self.blocks_null_source_1, 0), (self.blocks_throttle_0_1, 0))
+        self.connect((self.blocks_throttle_0, 0), (self.blocks_float_to_complex_1, 0))
+        self.connect((self.blocks_throttle_0_1, 0), (self.blocks_float_to_complex_1, 1))
+
+
+class _tagged_staircase(gr.top_block):
+    def __init__(self, 
+                 tag: str,
+                 parameters: Parameters):
+        gr.top_block.__init__(self, catch_exceptions=True)
+
+        ##################################################
+        # Unpack capture config
+        ##################################################
+        step_increment       = parameters.get_parameter_value(PNames.STEP_INCREMENT)
+        samp_rate            = parameters.get_parameter_value(PNames.SAMPLE_RATE)
+        min_samples_per_step = parameters.get_parameter_value(PNames.MIN_SAMPLES_PER_STEP)
+        max_samples_per_step = parameters.get_parameter_value(PNames.MAX_SAMPLES_PER_STEP)
+        frequency_step       = parameters.get_parameter_value(PNames.FREQUENCY_STEP)
+        batch_size           = parameters.get_parameter_value(PNames.BATCH_SIZE)
+
+        ##################################################
+        # Blocks
+        ##################################################
+        self.spectre_tagged_staircase_0 = spectre.tagged_staircase(min_samples_per_step, 
+                                                                   max_samples_per_step, 
+                                                                   frequency_step,
+                                                                   step_increment, 
+                                                                   samp_rate)
+        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_chunks_dir_path(),
+                                                                     tag, 
+                                                                     batch_size, 
+                                                                     samp_rate, 
+                                                                     True,
+                                                                     'rx_freq',
+                                                                     0) # zero means the center frequency is unset
+        self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, samp_rate, True)
+
+
+        ##################################################
+        # Connections
+        ##################################################
+        self.connect((self.blocks_throttle_0, 0), (self.spectre_batched_file_sink_0, 0))
+        self.connect((self.spectre_tagged_staircase_0, 0), (self.blocks_throttle_0, 0))
+
+
+@dataclass(frozen=True)
+class CaptureMethods:
+    cosine_signal_1  = partial(capture, top_block_cls=_cosine_signal_1)
+    tagged_staircase = partial(capture, top_block_cls=_tagged_staircase)

spectre_core/receivers/library/_rsp1a.py

@@ -0,0 +1,61 @@
+# 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 Optional
+from dataclasses import dataclass
+from functools import partial
+
+from spectre_core.capture_configs import (
+    CaptureModes
+)
+from ..gr._rsp1a import CaptureMethods
+from .._spec_names import SpecNames
+from ._sdrplay_receiver import SDRPlayReceiver
+from .._register import register_receiver
+
+@dataclass
+class Modes:
+    FIXED_CENTER_FREQUENCY  = CaptureModes.FIXED_CENTER_FREQUENCY
+    SWEPT_CENTER_FREQUENCY  = CaptureModes.SWEPT_CENTER_FREQUENCY
+
+@register_receiver("rsp1a")
+class _Receiver(SDRPlayReceiver):
+    def __init__(self, 
+                 name: str,
+                 mode: Optional[str]):
+        super().__init__(name,
+                         mode)
+        
+
+    def _add_specs(self) -> None:
+        self.add_spec( SpecNames.SAMPLE_RATE_LOWER_BOUND, 200e3     ) # Hz
+        self.add_spec( SpecNames.SAMPLE_RATE_UPPER_BOUND, 10e6      ) # Hz
+        self.add_spec( SpecNames.FREQUENCY_LOWER_BOUND  , 1e3       ) # Hz
+        self.add_spec( SpecNames.FREQUENCY_UPPER_BOUND  , 2e9       ) # Hz
+        self.add_spec( SpecNames.IF_GAIN_UPPER_BOUND    , -20       ) # dB
+        self.add_spec( SpecNames.RF_GAIN_UPPER_BOUND    , 0         ) # dB
+        self.add_spec( SpecNames.API_RETUNING_LATENCY   , 50 * 1e-3 ) # s
+        self.add_spec( SpecNames.BANDWIDTH_OPTIONS, 
+                      [200000, 300000, 600000, 1536000, 5000000, 6000000, 7000000, 8000000])
+
+
+    def _add_capture_methods(self) -> None:
+        self.add_capture_method(Modes.FIXED_CENTER_FREQUENCY, 
+                                CaptureMethods.fixed_center_frequency)
+        self.add_capture_method(Modes.SWEPT_CENTER_FREQUENCY,
+                                CaptureMethods.swept_center_frequency)
+    
+
+    def _add_capture_templates(self):
+        self.add_capture_template(Modes.FIXED_CENTER_FREQUENCY,
+                                  self._get_capture_template_fixed_center_frequency())
+        self.add_capture_template(Modes.SWEPT_CENTER_FREQUENCY,
+                                  self._get_capture_template_swept_center_frequency())
+        
+    
+    def _add_pvalidators(self):
+        self.add_pvalidator(Modes.FIXED_CENTER_FREQUENCY,
+                            self._get_pvalidator_fixed_center_frequency())
+        self.add_pvalidator(Modes.SWEPT_CENTER_FREQUENCY,
+                            self._get_pvalidator_swept_center_frequency())

spectre_core/receivers/library/_rspduo.py

@@ -0,0 +1,69 @@
+# 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 Optional
+from dataclasses import dataclass
+from functools import partial
+
+from spectre_core.capture_configs import (
+    CaptureModes
+)
+from ..gr._rspduo import CaptureMethods
+from .._spec_names import SpecNames
+from ._sdrplay_receiver import SDRPlayReceiver
+from .._register import register_receiver
+
+@dataclass
+class Modes:
+    TUNER_1_FIXED_CENTER_FREQUENCY  = f"tuner-1-{CaptureModes.FIXED_CENTER_FREQUENCY}"
+    TUNER_2_FIXED_CENTER_FREQUENCY  = f"tuner-2-{CaptureModes.FIXED_CENTER_FREQUENCY}"
+    TUNER_1_SWEPT_CENTER_FREQUENCY  = f"tuner-1-{CaptureModes.SWEPT_CENTER_FREQUENCY}"
+
+
+@register_receiver("rspduo")
+class _Receiver(SDRPlayReceiver):
+    def __init__(self, 
+                 name: str,
+                 mode: Optional[str]):
+        super().__init__(name,
+                         mode)
+        
+
+    def _add_specs(self) -> None:
+        self.add_spec( SpecNames.SAMPLE_RATE_LOWER_BOUND, 200e3     ) # Hz
+        self.add_spec( SpecNames.SAMPLE_RATE_UPPER_BOUND, 10e6      ) # Hz
+        self.add_spec( SpecNames.FREQUENCY_LOWER_BOUND  , 1e3       ) # Hz
+        self.add_spec( SpecNames.FREQUENCY_UPPER_BOUND  , 2e9       ) # Hz
+        self.add_spec( SpecNames.IF_GAIN_UPPER_BOUND    , -20       ) # dB
+        self.add_spec( SpecNames.RF_GAIN_UPPER_BOUND    , 0         ) # dB
+        self.add_spec( SpecNames.API_RETUNING_LATENCY   , 50 * 1e-3 ) # s
+        self.add_spec( SpecNames.BANDWIDTH_OPTIONS, 
+                      [200000, 300000, 600000, 1536000, 5000000, 6000000, 7000000, 8000000])
+
+
+    def _add_capture_methods(self) -> None:
+        self.add_capture_method(Modes.TUNER_1_FIXED_CENTER_FREQUENCY, 
+                                CaptureMethods.tuner_1_fixed_center_frequency)
+        self.add_capture_method(Modes.TUNER_2_FIXED_CENTER_FREQUENCY, 
+                                CaptureMethods.tuner_2_fixed_center_frequency)
+        self.add_capture_method(Modes.TUNER_1_SWEPT_CENTER_FREQUENCY, 
+                                CaptureMethods.tuner_1_swept_center_frequency)
+    
+
+    def _add_capture_templates(self):
+        self.add_capture_template(Modes.TUNER_1_FIXED_CENTER_FREQUENCY,
+                                  self._get_capture_template_fixed_center_frequency())
+        self.add_capture_template(Modes.TUNER_2_FIXED_CENTER_FREQUENCY,
+                                  self._get_capture_template_fixed_center_frequency())
+        self.add_capture_template(Modes.TUNER_1_SWEPT_CENTER_FREQUENCY,
+                                  self._get_capture_template_swept_center_frequency())
+        
+    
+    def _add_pvalidators(self):
+        self.add_pvalidator(Modes.TUNER_1_FIXED_CENTER_FREQUENCY,
+                            self._get_pvalidator_fixed_center_frequency())
+        self.add_pvalidator(Modes.TUNER_2_FIXED_CENTER_FREQUENCY,
+                            self._get_pvalidator_fixed_center_frequency())
+        self.add_pvalidator(Modes.TUNER_1_SWEPT_CENTER_FREQUENCY,
+                            self._get_pvalidator_swept_center_frequency())

spectre_core/receivers/library/_sdrplay_receiver.py

@@ -0,0 +1,185 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from abc import ABC, abstractmethod
+from typing import Callable, Optional
+from numbers import Number
+
+from spectre_core.capture_configs import (
+    CaptureTemplate, CaptureModes, Parameters, Bound, PValidators, PNames,
+    get_base_capture_template, get_base_ptemplate, OneOf, CaptureConfig
+)
+from .._base import BaseReceiver
+from .._spec_names import SpecNames
+
+class SDRPlayReceiver(BaseReceiver):
+    def _get_pvalidator_fixed_center_frequency(self) -> Callable:
+        def pvalidator(parameters: Parameters):
+            PValidators.fixed_center_frequency(parameters)
+        return pvalidator
+
+
+    def _get_pvalidator_swept_center_frequency(self) -> None:
+        def pvalidator(parameters: Parameters):
+            PValidators.swept_center_frequency(parameters,
+                                               self.get_spec(SpecNames.API_RETUNING_LATENCY))
+        return pvalidator
+
+
+    def _get_capture_template_fixed_center_frequency(self) -> CaptureTemplate:
+        #
+        # Create the base template
+        #
+        capture_template = get_base_capture_template( CaptureModes.FIXED_CENTER_FREQUENCY )
+        capture_template.add_ptemplate( get_base_ptemplate(PNames.BANDWIDTH) )
+        capture_template.add_ptemplate( get_base_ptemplate(PNames.IF_GAIN) )
+        capture_template.add_ptemplate( get_base_ptemplate(PNames.RF_GAIN) )
+
+        #
+        # Update the defaults
+        #
+        capture_template.set_defaults(
+            (PNames.BATCH_SIZE,            3.0),
+            (PNames.CENTER_FREQUENCY,      95800000),
+            (PNames.SAMPLE_RATE,           600000),
+            (PNames.BANDWIDTH,             600000),
+            (PNames.WINDOW_HOP,            512),
+            (PNames.WINDOW_SIZE,           1024),
+            (PNames.WINDOW_TYPE,           "blackman"),
+            (PNames.RF_GAIN,               -30),
+            (PNames.IF_GAIN,               -30)
+        )   
+
+        #
+        # Adding pconstraints
+        #
+        capture_template.add_pconstraint(
+            PNames.CENTER_FREQUENCY,
+            [
+                Bound(
+                    lower_bound=self.get_spec(SpecNames.FREQUENCY_LOWER_BOUND),
+                    upper_bound=self.get_spec(SpecNames.FREQUENCY_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.SAMPLE_RATE,
+            [
+                Bound(
+                    lower_bound=self.get_spec(SpecNames.SAMPLE_RATE_LOWER_BOUND),
+                    upper_bound=self.get_spec(SpecNames.SAMPLE_RATE_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.BANDWIDTH,
+            [
+                OneOf(
+                    self.get_spec( SpecNames.BANDWIDTH_OPTIONS )
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.IF_GAIN,
+            [
+                Bound(
+                    upper_bound=self.get_spec(SpecNames.IF_GAIN_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.RF_GAIN,
+            [
+                Bound(
+                    upper_bound=self.get_spec(SpecNames.RF_GAIN_UPPER_BOUND)
+                )
+            ]
+        )
+        return capture_template
+
+
+    def _get_capture_template_swept_center_frequency(self) -> CaptureTemplate:
+        #
+        # Create the base template
+        #
+        capture_template = get_base_capture_template( CaptureModes.SWEPT_CENTER_FREQUENCY )
+        capture_template.add_ptemplate( get_base_ptemplate(PNames.BANDWIDTH) )
+        capture_template.add_ptemplate( get_base_ptemplate(PNames.IF_GAIN) )
+        capture_template.add_ptemplate( get_base_ptemplate(PNames.RF_GAIN) )
+
+
+        #
+        # Update the defaults
+        #
+        capture_template.set_defaults(
+            (PNames.BATCH_SIZE,            4.0),
+            (PNames.MIN_FREQUENCY,         95000000),
+            (PNames.MAX_FREQUENCY,         100000000),
+            (PNames.SAMPLES_PER_STEP,      80000),
+            (PNames.FREQUENCY_STEP,        1536000),
+            (PNames.SAMPLE_RATE,           1536000),
+            (PNames.BANDWIDTH,             1536000),
+            (PNames.WINDOW_HOP,            512),
+            (PNames.WINDOW_SIZE,           1024),
+            (PNames.WINDOW_TYPE,           "blackman"),
+            (PNames.RF_GAIN,               -30),
+            (PNames.IF_GAIN,               -30)
+        )   
+
+
+        #
+        # Adding pconstraints
+        #
+        capture_template.add_pconstraint(
+            PNames.MIN_FREQUENCY,
+            [
+                Bound(
+                    lower_bound=self.get_spec(SpecNames.FREQUENCY_LOWER_BOUND),
+                    upper_bound=self.get_spec(SpecNames.FREQUENCY_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.MAX_FREQUENCY,
+            [
+                Bound(
+                    lower_bound=self.get_spec(SpecNames.FREQUENCY_LOWER_BOUND),
+                    upper_bound=self.get_spec(SpecNames.FREQUENCY_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.SAMPLE_RATE,
+            [
+                Bound(
+                    lower_bound=self.get_spec(SpecNames.SAMPLE_RATE_LOWER_BOUND),
+                    upper_bound=self.get_spec(SpecNames.SAMPLE_RATE_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.BANDWIDTH,
+            [
+                OneOf(
+                    self.get_spec( SpecNames.BANDWIDTH_OPTIONS )
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.IF_GAIN,
+            [
+                Bound(
+                    upper_bound=self.get_spec(SpecNames.IF_GAIN_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.RF_GAIN,
+            [
+                Bound(
+                    upper_bound=self.get_spec(SpecNames.RF_GAIN_UPPER_BOUND)
+                )
+            ]
+        )
+        return capture_template

spectre_core/receivers/library/_test.py

@@ -0,0 +1,221 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from dataclasses import dataclass
+from typing import Optional, Callable
+
+from spectre_core.capture_configs import (
+    CaptureTemplate, CaptureModes, Parameters, Bound, PValidators, PNames,
+    get_base_capture_template, make_base_capture_template, get_base_ptemplate
+)
+from ..gr._test import CaptureMethods
+from .._spec_names import SpecNames
+from .._base import BaseReceiver
+from .._register import register_receiver
+
+
+@dataclass
+class Modes:
+    COSINE_SIGNAL_1  = "cosine-signal-1"
+    TAGGED_STAIRCASE = "tagged-staircase"
+
+
+@register_receiver("test")
+class _Receiver(BaseReceiver):
+    def __init__(self, 
+                 name: str,
+                 mode: Optional[str]):
+        super().__init__(name,
+                         mode)
+        
+
+    def _add_specs(self) -> None:
+        self.add_spec( SpecNames.SAMPLE_RATE_LOWER_BOUND, 64000  )
+        self.add_spec( SpecNames.SAMPLE_RATE_UPPER_BOUND, 640000 )
+        self.add_spec( SpecNames.FREQUENCY_LOWER_BOUND  , 16000  )
+        self.add_spec( SpecNames.FREQUENCY_UPPER_BOUND  , 160000 )
+
+
+    def _add_capture_methods(self) -> None:
+        self.add_capture_method( Modes.COSINE_SIGNAL_1 , CaptureMethods.cosine_signal_1 )
+        self.add_capture_method( Modes.TAGGED_STAIRCASE, CaptureMethods.tagged_staircase)
+    
+
+    def _add_pvalidators(self) -> None:
+        self.add_pvalidator( Modes.COSINE_SIGNAL_1 , self.__get_pvalidator_cosine_signal_1()  )
+        self.add_pvalidator( Modes.TAGGED_STAIRCASE, self.__get_pvalidator_tagged_staircase() )
+
+
+    def _add_capture_templates(self) -> None:
+        self.add_capture_template( Modes.COSINE_SIGNAL_1 , self.__get_capture_template_cosine_signal_1()  )
+        self.add_capture_template( Modes.TAGGED_STAIRCASE, self.__get_capture_template_tagged_staircase() )
+        
+
+    def __get_capture_template_cosine_signal_1(self) -> CaptureTemplate:
+        #
+        # Create the base template
+        #
+        capture_template = get_base_capture_template( CaptureModes.FIXED_CENTER_FREQUENCY )
+        capture_template.add_ptemplate( get_base_ptemplate(PNames.AMPLITUDE) )
+        capture_template.add_ptemplate( get_base_ptemplate(PNames.FREQUENCY) )
+
+        #
+        # Update the defaults
+        #
+        capture_template.set_defaults(
+            (PNames.BATCH_SIZE,            3.0),
+            (PNames.CENTER_FREQUENCY,      16000),
+            (PNames.AMPLITUDE,             2.0),
+            (PNames.FREQUENCY,             32000),
+            (PNames.SAMPLE_RATE,           128000),
+            (PNames.WINDOW_HOP,            512),
+            (PNames.WINDOW_SIZE,           512),
+            (PNames.WINDOW_TYPE,           "boxcar")
+        )
+
+        #
+        # Enforce defaults
+        #
+        capture_template.enforce_defaults(
+            PNames.TIME_RESOLUTION,
+            PNames.TIME_RANGE,
+            PNames.FREQUENCY_RESOLUTION,
+            PNames.WINDOW_TYPE
+        )
+
+
+        #
+        # Adding pconstraints
+        #
+        capture_template.add_pconstraint(
+            PNames.SAMPLE_RATE,
+            [
+                Bound(
+                    lower_bound=self.get_spec(SpecNames.SAMPLE_RATE_LOWER_BOUND),
+                    upper_bound=self.get_spec(SpecNames.SAMPLE_RATE_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.FREQUENCY,
+            [
+                Bound(
+                    lower_bound=self.get_spec(SpecNames.FREQUENCY_LOWER_BOUND),
+                    upper_bound=self.get_spec(SpecNames.FREQUENCY_UPPER_BOUND)
+                )
+            ]
+        )
+        return capture_template
+
+
+    def __get_capture_template_tagged_staircase(self) -> CaptureTemplate:
+        #
+        # Make the base template
+        #
+        capture_template = make_base_capture_template(
+                PNames.TIME_RESOLUTION,
+                PNames.FREQUENCY_RESOLUTION,
+                PNames.TIME_RANGE,
+                PNames.SAMPLE_RATE,
+                PNames.BATCH_SIZE,
+                PNames.WINDOW_TYPE,
+                PNames.WINDOW_HOP,
+                PNames.WINDOW_SIZE,
+                PNames.EVENT_HANDLER_KEY,
+                PNames.CHUNK_KEY,
+                PNames.WATCH_EXTENSION,
+                PNames.MIN_SAMPLES_PER_STEP,
+                PNames.MAX_SAMPLES_PER_STEP,
+                PNames.FREQUENCY_STEP,
+                PNames.STEP_INCREMENT,
+                PNames.OBS_ALT,
+                PNames.OBS_LAT,
+                PNames.OBS_LON,
+                PNames.OBJECT,
+                PNames.ORIGIN,
+                PNames.TELESCOPE,
+                PNames.INSTRUMENT
+        )
+
+        #
+        # Update the defaults
+        #
+        capture_template.set_defaults(
+            (PNames.BATCH_SIZE,            3.0),
+            (PNames.FREQUENCY_STEP,        128000),
+            (PNames.MAX_SAMPLES_PER_STEP,  5000),
+            (PNames.MIN_SAMPLES_PER_STEP,  4000),
+            (PNames.SAMPLE_RATE,           128000),
+            (PNames.STEP_INCREMENT,        200),
+            (PNames.WINDOW_HOP,            512),
+            (PNames.WINDOW_SIZE,           512),
+            (PNames.WINDOW_TYPE,           "boxcar"),
+            (PNames.EVENT_HANDLER_KEY,     CaptureModes.SWEPT_CENTER_FREQUENCY),
+            (PNames.CHUNK_KEY,             CaptureModes.SWEPT_CENTER_FREQUENCY),
+            (PNames.WATCH_EXTENSION,       "bin")
+        )
+
+
+        #
+        # Enforce defaults
+        #
+        capture_template.enforce_defaults(
+            PNames.TIME_RESOLUTION,
+            PNames.TIME_RANGE,
+            PNames.FREQUENCY_RESOLUTION,
+            PNames.WINDOW_TYPE,
+            PNames.EVENT_HANDLER_KEY,
+            PNames.CHUNK_KEY,
+            PNames.WATCH_EXTENSION
+        )
+
+        return capture_template
+    
+    
+    def __get_pvalidator_cosine_signal_1(self) -> Callable:
+        def pvalidator(parameters: Parameters):
+            PValidators.window(parameters)
+
+            sample_rate          = parameters.get_parameter_value(PNames.SAMPLE_RATE)
+            frequency            = parameters.get_parameter_value(PNames.FREQUENCY)
+            window_size          = parameters.get_parameter_value(PNames.WINDOW_SIZE)
+
+            # check that the sample rate is an integer multiple of the underlying signal frequency
+            if sample_rate % frequency != 0:
+                raise ValueError("The sampling rate must be some integer multiple of frequency")
+
+            a = sample_rate/frequency
+            if a < 2:
+                raise ValueError((f"The ratio of sampling rate over frequency must be greater than two. "
+                                f"Got {a}"))
+            
+            # 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. "
+                                  f"Computed that p={p}"))
+        return pvalidator
+
+
+    def __get_pvalidator_tagged_staircase(self) -> None:
+        def pvalidator(parameters: Parameters):
+            PValidators.window(parameters)
+
+            freq_step            = parameters.get_parameter_value(PNames.FREQUENCY_STEP)
+            sample_rate          = parameters.get_parameter_value(PNames.SAMPLE_RATE)
+            min_samples_per_step = parameters.get_parameter_value(PNames.MIN_SAMPLES_PER_STEP)
+            max_samples_per_step = parameters.get_parameter_value(PNames.MAX_SAMPLES_PER_STEP)
+
+            if freq_step != sample_rate:
+                raise ValueError(f"The frequency step must be equal to the sampling rate")
+            
+            
+            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. "
+                                f"Got {min_samples_per_step}, which is greater than {max_samples_per_step}"))
+            
+        return pvalidator
+        

spectre_core/spectrograms/__init__.py

@@ -1,3 +1,21 @@
 # SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
 # This file is part of SPECTRE
 # SPDX-License-Identifier: GPL-3.0-or-later
+
+from ._analytical import (
+    get_analytical_spectrogram, validate_analytically, TestResults
+)
+from ._spectrogram import (
+    Spectrogram, FrequencyCut, TimeCut, SpectrumTypes, TimeTypes
+)
+from ._transform import (
+    frequency_chop, time_chop, frequency_average, time_average, 
+    join_spectrograms
+)
+
+__all__ = [
+    "get_analytical_spectrogram", "validate_analytically", "TestResults",
+    "Spectrogram", "FrequencyCut", "TimeCut", "SpectrumTypes", "frequency_chop",
+    "time_chop", "frequency_average","time_average", "join_spectrograms",
+    "TimeTypes"
+]