Added docs + rescaled logos.

src/nqrduck_spectrometer/base_spectrometer_model.py

@@ -31,6 +31,16 @@ class BaseSpectrometerModel(ModuleModel):
         
 
     class PulseParameter:
+        """A pulse parameter is a value that can be different for each event in a pulse sequence.
+        E.g. the transmit pulse power or the phase of the transmit pulse.
+        
+        Arguments:
+            name (str) -- The name of the pulse parameter
+            
+        Attributes:
+            name (str) -- The name of the pulse parameter
+            options (OrderedDict) -- The options of the pulse parameter
+        """
         def __init__(self, name):
             self.name = name
             self.options = OrderedDict()

src/nqrduck_spectrometer/controller.py

@@ -17,7 +17,7 @@ class SpectrometerController(ModuleController):
         super().__init__(module)
 
     def _load_spectrometer_modules(self):
-        """This method loads the spectrometer modules and adds them to the spectrometer model."""
+        """This method loads the spectrometer (sub-)modules and adds them to the spectrometer model."""
         # Get the modules with entry points in the nqrduck group
         modules = MainController._get_modules()
         logger.debug("Found modules: %s", modules)
@@ -41,10 +41,13 @@ class SpectrometerController(ModuleController):
         self._module.view.create_menu_entry()
 
     def process_signals(self, key: str, value: None):
+        # This signal starts a measurement
         if key == "start_measurement":
             self.on_measurement_start()
+        # This signal sets the frequency
         elif key == "set_frequency":
             self.module.model.active_spectrometer.controller.set_frequency(value)
+        # This signal sets the number of averages
         elif key == "set_averages":
             self.module.model.active_spectrometer.controller.set_averages(value)
 

src/nqrduck_spectrometer/pulseparameters.py

@@ -2,16 +2,17 @@ from PyQt6.QtGui import QPixmap
 from pathlib import Path
 from .base_spectrometer_model import BaseSpectrometerModel
 
-class Option():
+
-    """Defines options for the pulse parameters which can then be set accordingly.
+class Option:
-    """
+    """Defines options for the pulse parameters which can then be set accordingly."""
+
     def set_value(self):
         raise NotImplementedError
 
 
 class BooleanOption(Option):
-    """Defines a boolean option for a pulse parameter option.
+    """Defines a boolean option for a pulse parameter option."""
-    """
+
     def __init__(self, value) -> None:
         super().__init__()
         self.value = value
@@ -19,9 +20,10 @@ class BooleanOption(Option):
     def set_value(self, value):
         self.value = value
 
+
 class NumericOption(Option):
-    """Defines a numeric option for a pulse parameter option.
+    """Defines a numeric option for a pulse parameter option."""
-    """
+
     def __init__(self, value) -> None:
         super().__init__()
         self.value = value
@@ -29,9 +31,10 @@ class NumericOption(Option):
     def set_value(self, value):
         self.value = float(value)
 
+
 class WidgetSelectionOption(Option):
-    """Defines a widget selection option for a pulse parameter option.
+    """Defines a widget selection option for a pulse parameter option."""
-    """
+
     def __init__(self, widgets) -> None:
         super().__init__()
 
@@ -45,24 +48,25 @@ class TXPulse(BaseSpectrometerModel.PulseParameter):
     def get_pixmap(self):
         self_path = Path(__file__).parent
         if self.options["TX Amplitude"].value > 0:
-            image_path = self_path / "resources/pulseparameter/TX_Pulse.png"
+            image_path = self_path / "resources/pulseparameter/TXOn.png"
         else:
-            image_path = self_path / "resources/pulseparameter/NoPulse.png"
+            image_path = self_path / "resources/pulseparameter/TXOff.png"
         pixmap = QPixmap(str(image_path))
         return pixmap
 
-    class RectPulse():
+    class RectPulse:
         def __init__(self, name) -> None:
             super().__init__(name)
 
-    class SincPulse():
+    class SincPulse:
         def __init__(self, name) -> None:
             super().__init__(name)
 
-    class GaussianPulse():
+    class GaussianPulse:
         def __init__(self, name) -> None:
             super().__init__(name)
 
+
 class RXReadout(BaseSpectrometerModel.PulseParameter):
     def __init__(self, name) -> None:
         super().__init__(name)
@@ -80,8 +84,8 @@ class RXReadout(BaseSpectrometerModel.PulseParameter):
     def set_options(self, options):
         self.state = options
 
-class Gate(BaseSpectrometerModel.PulseParameter):
 
+class Gate(BaseSpectrometerModel.PulseParameter):
     def __init__(self, name) -> None:
         super().__init__(name)
         self.add_option("Gate State", BooleanOption(False))
@@ -97,5 +101,3 @@ class Gate(BaseSpectrometerModel.PulseParameter):
 
     def set_options(self, options):
         self.state = options
-
-    

src/nqrduck_spectrometer/pulsesequence.py

@@ -3,8 +3,10 @@ from collections import OrderedDict
 
 logger = logging.getLogger(__name__)
 
+
 class PulseSequence:
     """A pulse sequence is a collection of events that are executed in a certain order."""
+
     def __init__(self, name) -> None:
         self.name = name
         self.events = list()
@@ -29,50 +31,76 @@ class PulseSequence:
 
         @classmethod
         def load_event(cls, event, pulse_parameter_options):
-            """Loads an event from a dict. The pulse paramter options are needed to load the parameters
+            """
-              and determine if the correct spectrometer is active."""
+            Loads an event from a dict. The pulse paramter options are needed to load the parameters
+            and determine if the correct spectrometer is active.
+
+            Args:
+                event (dict): The dict with the event data
+                pulse_parameter_options (dict): The dict with the pulse parameter options
+
+            Returns:
+                Event: The loaded event
+            """
             obj = cls(event["name"], event["duration"])
             for parameter in event["parameters"]:
                 for pulse_parameter_option in pulse_parameter_options.keys():
                     # This checks if the pulse paramter options are the same as the ones in the pulse sequence
                     if pulse_parameter_option == parameter["name"]:
-                        pulse_paramter_class = pulse_parameter_options[pulse_parameter_option]
+                        pulse_paramter_class = pulse_parameter_options[
-                        obj.parameters[pulse_parameter_option] = pulse_paramter_class(parameter["name"])
+                            pulse_parameter_option
+                        ]
+                        obj.parameters[pulse_parameter_option] = pulse_paramter_class(
+                            parameter["name"]
+                        )
                         for option in parameter["value"]:
-                            obj.parameters[pulse_parameter_option].options[option["name"]].value = option["value"]
+                            obj.parameters[pulse_parameter_option].options[
+                                option["name"]
+                            ].value = option["value"]
 
             return obj
 
     def dump_sequence_data(self):
-        """Returns a dict with all the data in the pulse sequence"""
+        """Returns a dict with all the data in the pulse sequence
-        data = {
+
-            "name": self.name,
+        Returns:
-            "events": []
+            dict: The dict with the sequence data"""
-        }
+        data = {"name": self.name, "events": []}
         for event in self.events:
             event_data = {
                 "name": event.name,
                 "duration": event.duration,
-                "parameters": []
+                "parameters": [],
             }
             for parameter in event.parameters.keys():
-                event_data["parameters"].append({
+                event_data["parameters"].append({"name": parameter, "value": []})
-                    "name": parameter,
-                    "value": []
-                })
                 for option in event.parameters[parameter].options.keys():
-                    event_data["parameters"][-1]["value"].append({
+                    event_data["parameters"][-1]["value"].append(
+                        {
                             "name": option,
-                        "value": event.parameters[parameter].options[option].value
+                            "value": event.parameters[parameter].options[option].value,
-                    })
+                        }
+                    )
             data["events"].append(event_data)
         return data
 
     @classmethod
     def load_sequence(cls, sequence, pulse_parameter_options):
+        """Loads a pulse sequence from a dict. The pulse paramter options are needed to load the parameters
+        and make sure the correct spectrometer is active.
+
+        Args:
+            sequence (dict): The dict with the sequence data
+            pulse_parameter_options (dict): The dict with the pulse parameter options
+
+        Returns:
+            PulseSequence: The loaded pulse sequence
+
+        Raises:
+            KeyError: If the pulse parameter options are not the same as the ones in the pulse sequence
+        """
         obj = cls(sequence["name"])
         for event_data in sequence["events"]:
             obj.events.append(cls.Event.load_event(event_data, pulse_parameter_options))
 
         return obj
-