From 8b8093b2d9b8dc6898855a18f07a91a10ea81951 Mon Sep 17 00:00:00 2001 From: jupfi Date: Mon, 29 Apr 2024 19:31:41 +0200 Subject: [PATCH] Linting. --- src/nqrduck_broadband/__init__.py | 1 + src/nqrduck_broadband/broadband.py | 1 + src/nqrduck_broadband/controller.py | 69 +++++--- src/nqrduck_broadband/model.py | 243 ++++++++++++++++++++-------- src/nqrduck_broadband/view.py | 137 ++++++++++++---- 5 files changed, 332 insertions(+), 119 deletions(-) diff --git a/src/nqrduck_broadband/__init__.py b/src/nqrduck_broadband/__init__.py index 883938d..15631af 100644 --- a/src/nqrduck_broadband/__init__.py +++ b/src/nqrduck_broadband/__init__.py @@ -1 +1,2 @@ +"""Init file for the nqrduck_broadband package.""" from .broadband import Broadband as Module diff --git a/src/nqrduck_broadband/broadband.py b/src/nqrduck_broadband/broadband.py index 9871878..3bd93a6 100644 --- a/src/nqrduck_broadband/broadband.py +++ b/src/nqrduck_broadband/broadband.py @@ -1,3 +1,4 @@ +"""Module creation for the Broadband module.""" from nqrduck.module.module import Module from .model import BroadbandModel from .view import BroadbandView diff --git a/src/nqrduck_broadband/controller.py b/src/nqrduck_broadband/controller.py index 164d53b..9e1d844 100644 --- a/src/nqrduck_broadband/controller.py +++ b/src/nqrduck_broadband/controller.py @@ -1,3 +1,5 @@ +"""This module contains the BroadbandController class.""" + import logging import numpy as np import json @@ -10,11 +12,20 @@ logger = logging.getLogger(__name__) class BroadbandController(ModuleController): + """Controller class for the Broadband module. + + Signals: + start_broadband_measurement: Signal to start a broadband measurement. + set_averages_failure: Signal that the set averages command failed. + set_frequency_step_failure: Signal that the set frequency step command failed. + """ + start_broadband_measurement = pyqtSignal() set_averages_failure = pyqtSignal() set_frequency_step_failure = pyqtSignal() def __init__(self, module): + """Initializes the BroadbandController.""" super().__init__(module) @pyqtSlot(str, object) @@ -27,7 +38,10 @@ class BroadbandController(ModuleController): """ logger.debug(self.module.model.waiting_for_tune_and_match) - if key == "measurement_data" and self.module.model.current_broadband_measurement is not None: + if ( + key == "measurement_data" + and self.module.model.current_broadband_measurement is not None + ): logger.debug("Received single measurement.") self.module.model.current_broadband_measurement.add_measurement(value) @@ -38,22 +52,27 @@ class BroadbandController(ModuleController): logger.debug("Received set averages failure.") self.set_averages_failure.emit() # receive LUT data - elif key == "LUT_finished": + elif key == "LUT_finished": self.received_LUT(value) - elif key == "confirm_tune_and_match" and self.module.model.waiting_for_tune_and_match: + elif ( + key == "confirm_tune_and_match" + and self.module.model.waiting_for_tune_and_match + ): logger.debug("Confirmed tune and match.") reflection = value logger.debug("Reflection: " + str(reflection)) if reflection is not None: - self.module.model.current_broadband_measurement.add_tune_and_match(reflection) + self.module.model.current_broadband_measurement.add_tune_and_match( + reflection + ) self.module.nqrduck_signal.emit("start_measurement", None) QApplication.processEvents() self.module.model.waiting_for_tune_and_match = False - def received_LUT(self, LUT : Measurement) -> None: + def received_LUT(self, LUT: Measurement) -> None: """This slot is called when the LUT data is received from the nqrduck module. - + Args: LUT (Measurement): LUT data. """ @@ -62,7 +81,7 @@ class BroadbandController(ModuleController): self.change_start_frequency(self.module.model.LUT.start_frequency) self.change_stop_frequency(self.module.model.LUT.stop_frequency) self.change_frequency_step(self.module.model.LUT.frequency_step) - + @pyqtSlot(str) def set_frequency(self, value: str) -> None: """Emits the set frequency signal to the nqrduck module. @@ -150,6 +169,7 @@ class BroadbandController(ModuleController): @pyqtSlot() def on_broadband_measurement_added(self) -> None: """This slot is called when a single measurement is added to the broadband measurement. + It then checks if there are more frequencies to measure and if so, starts the next measurement. Furthermore it updates the plots. """ @@ -157,11 +177,11 @@ class BroadbandController(ModuleController): # Check if there are more frequencies to measure if not self.module.model.current_broadband_measurement.is_complete(): # Get the next frequency to measure - next_frequency = ( - self.module.model.current_broadband_measurement.get_next_measurement_frequency() - ) + next_frequency = self.module.model.current_broadband_measurement.get_next_measurement_frequency() logger.debug("Next frequency: " + str(next_frequency)) - QTimer.singleShot(500, lambda: self.start_single_measurement(next_frequency)) + QTimer.singleShot( + 500, lambda: self.start_single_measurement(next_frequency) + ) QApplication.processEvents() else: self.module.view.add_info_text("Broadband measurement finished.") @@ -171,14 +191,16 @@ class BroadbandController(ModuleController): """This slot is called when the LUT is deleted.""" self.module.model.LUT = None - def start_single_measurement(self, frequency : float) -> None: + def start_single_measurement(self, frequency: float) -> None: """Starts a single measurement. - + Args: frequency (float): Frequency in MHz. """ logger.debug("Starting single measurement.") - self.module.view.add_info_text("Starting measurement at frequency: " + str(frequency)) + self.module.view.add_info_text( + "Starting measurement at frequency: " + str(frequency) + ) # First set the frequency of the spectrometer self.module.nqrduck_signal.emit("set_frequency", str(frequency)) QApplication.processEvents() @@ -186,7 +208,7 @@ class BroadbandController(ModuleController): if self.module.model.LUT is not None: self.module.model.waiting_for_tune_and_match = True # We need the entry number of the LUT for the current frequency - + self.module.nqrduck_signal.emit("set_tune_and_match", frequency * 1e-6) QApplication.processEvents() else: @@ -194,31 +216,32 @@ class BroadbandController(ModuleController): self.module.model.waiting_for_tune_and_match = False QApplication.processEvents() - def save_measurement(self, file_name : str) -> None: + def save_measurement(self, file_name: str) -> None: """Saves the current broadband measurement to a file. - + Args: file_name (str): Name of the file. """ logger.debug("Saving measurement to file: " + file_name) self.module.view.add_info_text("Saving measurement to file: " + file_name) QApplication.processEvents() - + with open(file_name, "w") as f: json.dump(self.module.model.current_broadband_measurement.to_json(), f) - - def load_measurement(self, file_name : str) -> None: + def load_measurement(self, file_name: str) -> None: """Loads a broadband measurement from a file. - + Args: file_name (str): Name of the file. """ logger.debug("Loading measurement from file: " + file_name) - with open(file_name, "r") as f: + with open(file_name) as f: measurement = json.load(f) - self.module.model.current_broadband_measurement = self.module.model.BroadbandMeasurement.from_json(measurement) + self.module.model.current_broadband_measurement = ( + self.module.model.BroadbandMeasurement.from_json(measurement) + ) self.module.view.add_info_text("Measurement loaded.") self.module.view.on_broadband_measurement_added() QApplication.processEvents() diff --git a/src/nqrduck_broadband/model.py b/src/nqrduck_broadband/model.py index dad814b..5cd55e9 100644 --- a/src/nqrduck_broadband/model.py +++ b/src/nqrduck_broadband/model.py @@ -1,3 +1,5 @@ +"""This module contains the BroadbandModel class which is the model for the Broadband module.""" + import logging import numpy as np from collections import OrderedDict @@ -8,7 +10,23 @@ from nqrduck_spectrometer.measurement import Measurement logger = logging.getLogger(__name__) + class BroadbandModel(ModuleModel): + """Model class for the Broadband module. + + Attributes: + FILE_EXTENSION (str): The file extension for the broadband module. + MIN_FREQUENCY (float): The minimum frequency for the broadband module. + MAX_FREQUENCY (float): The maximum frequency for the broadband module. + DEFAULT_FREQUENCY_STEP (float): The default frequency step for the broadband module. + + Signals: + start_frequency_changed: Signal that the start frequency has changed. + stop_frequency_changed: Signal that the stop frequency has changed. + frequency_step_changed: Signal that the frequency step has changed. + LUT_changed: Signal that the LUT has changed. + """ + FILE_EXTENSION = "broad" MIN_FREQUENCY = 30.0 @@ -21,6 +39,7 @@ class BroadbandModel(ModuleModel): LUT_changed = pyqtSignal() def __init__(self, module) -> None: + """Initializes the BroadbandModel.""" super().__init__(module) self.start_frequency = self.MIN_FREQUENCY self.stop_frequency = self.MAX_FREQUENCY @@ -31,6 +50,7 @@ class BroadbandModel(ModuleModel): @property def start_frequency(self): + """The start frequency for the broadband measurement.""" return self._start_frequency @start_frequency.setter @@ -40,6 +60,7 @@ class BroadbandModel(ModuleModel): @property def stop_frequency(self): + """The stop frequency for the broadband measurement.""" return self._stop_frequency @stop_frequency.setter @@ -49,8 +70,9 @@ class BroadbandModel(ModuleModel): @property def frequency_step(self): + """The frequency step for the broadband measurement.""" return self._frequency_step - + @frequency_step.setter def frequency_step(self, value): self._frequency_step = value @@ -58,27 +80,34 @@ class BroadbandModel(ModuleModel): @property def current_broadband_measurement(self): + """The current broadband measurement.""" return self._current_broadband_measurement - + @current_broadband_measurement.setter def current_broadband_measurement(self, value): self._current_broadband_measurement = value @property def LUT(self): + """The LUT for the broadband measurement.""" return self._LUT - + @LUT.setter def LUT(self, value): self._LUT = value self.LUT_changed.emit() class BroadbandMeasurement(QObject): - """This class represents a single broadband measurement.""" + """This class represents a single broadband measurement. + + Signals: + received_measurement: Signal that a measurement has been received. + """ received_measurement = pyqtSignal() - + def __init__(self, frequencies, frequency_step) -> None: + """Initializes the BroadbandMeasurement.""" super().__init__() self._single_frequency_measurements = OrderedDict() for frequency in frequencies: @@ -87,58 +116,69 @@ class BroadbandModel(ModuleModel): self.frequency_step = frequency_step self.reflection = {} - def add_measurement(self, measurement : "Measurement") -> None: + def add_measurement(self, measurement: "Measurement") -> None: """This method adds a single measurement to the broadband measurement. - + Args: - measurement (Measurement): The measurement object.""" - logger.debug("Adding measurement to broadband measurement at frequency: %s" % str(measurement.target_frequency)) - self._single_frequency_measurements[measurement.target_frequency] = measurement + measurement (Measurement): The measurement object. + """ + logger.debug( + f"Adding measurement to broadband measurement at frequency: {str(measurement.target_frequency)}" + ) + self._single_frequency_measurements[measurement.target_frequency] = ( + measurement + ) self.assemble_broadband_spectrum() self.received_measurement.emit() QApplication.processEvents() def is_complete(self) -> bool: """This method checks if all frequencies have been measured. - + Returns: - bool: True if all frequencies have been measured, False otherwise.""" + bool: True if all frequencies have been measured, False otherwise. + """ for measurement in self._single_frequency_measurements.values(): if measurement is None: return False return True - + def get_next_measurement_frequency(self) -> float: """This method returns the next frequency that has to be measured. - + Returns: - float: The next frequency that has to be measured.""" + float: The next frequency that has to be measured. + """ for frequency, measurement in self._single_frequency_measurements.items(): if measurement is None: return frequency - + def get_last_completed_measurement(self) -> "Measurement": - """ This method returns the last completed measurement. - + """This method returns the last completed measurement. + Returns: - Measurement: The last completed measurement.""" - - for frequency, measurement in reversed(self._single_frequency_measurements.items()): + Measurement: The last completed measurement. + """ + for frequency, measurement in reversed( + self._single_frequency_measurements.items() + ): if measurement is not None: return measurement - + def get_finished_percentage(self) -> float: """Get the percentage of measurements that have been finished. - + Returns: - float: The percentage of measurements that have been finished.""" - + float: The percentage of measurements that have been finished. + """ finished_measurements = 0 for measurement in self._single_frequency_measurements.values(): if measurement is not None: finished_measurements += 1 - return finished_measurements / len(self._single_frequency_measurements) * 100 - + return ( + finished_measurements / len(self._single_frequency_measurements) * 100 + ) + def assemble_broadband_spectrum(self) -> None: """This method assembles the broadband spectrum from the single frequency measurement data in frequency domain.""" # First we get all of the single frequency measurements that have already been measured @@ -147,89 +187,152 @@ class BroadbandModel(ModuleModel): if measurement is not None: single_frequency_measurements.append(measurement) - logger.debug("Assembling broadband spectrum from %d single frequency measurements." % len(single_frequency_measurements)) + logger.debug( + "Assembling broadband spectrum from %d single frequency measurements." + % len(single_frequency_measurements) + ) fdy_assembled = np.array([]) fdx_assembled = np.array([]) # We cut out step_size / 2 around the IF of the spectrum and assemble the broadband spectrum for measurement in single_frequency_measurements: # This finds the center of the spectrum if the IF is not 0 it will cut out step_size / 2 around the IF - logger.debug("IF frequency: %f" % measurement.IF_frequency) + logger.debug(f"IF frequency: {measurement.IF_frequency:f}") logger.debug(measurement.fdx) offset = measurement.IF_frequency * 1e-6 - logger.debug("Offset: %f" % offset) + logger.debug(f"Offset: {offset:f}") - #center = np.where(measurement.fdx == offset)[0][0] + # center = np.where(measurement.fdx == offset)[0][0] # Find closest to offset center = self.find_nearest(measurement.fdx, offset) - + logger.debug("Center: %d" % center) # This finds the nearest index of the lower and upper frequency step - logger.debug("Frequency step: %f" % self.frequency_step) + logger.debug(f"Frequency step: {self.frequency_step:f}") logger.debug(measurement.fdx) - idx_xf_lower = self.find_nearest(measurement.fdx, offset - ((self.frequency_step/2) * 1e-6)) - idx_xf_upper = self.find_nearest(measurement.fdx, offset + ((self.frequency_step/2) * 1e-6)) + idx_xf_lower = self.find_nearest( + measurement.fdx, offset - ((self.frequency_step / 2) * 1e-6) + ) + idx_xf_upper = self.find_nearest( + measurement.fdx, offset + ((self.frequency_step / 2) * 1e-6) + ) # This interpolates the y values of the lower and upper frequency step - yf_interp_lower = np.interp(offset-self.frequency_step/2 * 1e-6, [measurement.fdx[idx_xf_lower], measurement.fdx[center]], - [abs(measurement.fdy)[idx_xf_lower], abs(measurement.fdy)[center]]) - - yf_interp_upper = np.interp(offset+self.frequency_step/2 * 1e-6, [measurement.fdx[center], measurement.fdx[idx_xf_upper]], - [abs(measurement.fdy)[center], abs(measurement.fdy)[idx_xf_lower]]) - + yf_interp_lower = np.interp( + offset - self.frequency_step / 2 * 1e-6, + [measurement.fdx[idx_xf_lower], measurement.fdx[center]], + [abs(measurement.fdy)[idx_xf_lower], abs(measurement.fdy)[center]], + ) + + yf_interp_upper = np.interp( + offset + self.frequency_step / 2 * 1e-6, + [measurement.fdx[center], measurement.fdx[idx_xf_upper]], + [abs(measurement.fdy)[center], abs(measurement.fdy)[idx_xf_lower]], + ) + try: # We take the last point of the previous spectrum and the first point of the current spectrum and average them fdy_assembled[-1] = (fdy_assembled[-1] + yf_interp_lower) / 2 # Then we append the data from idx_xf_lower + 1 (because of the averaged datapoint) to idx_xf_upper - fdy_assembled = np.append(fdy_assembled, abs(measurement.fdy)[idx_xf_lower+1:idx_xf_upper-1]) + fdy_assembled = np.append( + fdy_assembled, + abs(measurement.fdy)[idx_xf_lower + 1 : idx_xf_upper - 1], + ) fdy_assembled = np.append(fdy_assembled, yf_interp_upper) - + # We append the frequency values of the current spectrum and shift them by the target frequency - fdx_assembled = np.append(fdx_assembled, -self.frequency_step/2 * 1e-6 + measurement.target_frequency * 1e-6) - fdx_assembled = np.append(fdx_assembled, measurement.fdx[idx_xf_lower + 1:idx_xf_upper - 1] + measurement.target_frequency * 1e-6 - offset) + fdx_assembled = np.append( + fdx_assembled, + -self.frequency_step / 2 * 1e-6 + + measurement.target_frequency * 1e-6, + ) + fdx_assembled = np.append( + fdx_assembled, + measurement.fdx[idx_xf_lower + 1 : idx_xf_upper - 1] + + measurement.target_frequency * 1e-6 + - offset, + ) # On the first run we will get an Index Error except IndexError: fdy_assembled = np.array([yf_interp_lower]) - fdy_assembled = np.append(fdy_assembled, abs(measurement.fdy)[idx_xf_lower+1:idx_xf_upper-1]) + fdy_assembled = np.append( + fdy_assembled, + abs(measurement.fdy)[idx_xf_lower + 1 : idx_xf_upper - 1], + ) fdy_assembled = np.append(fdy_assembled, yf_interp_upper) - first_time_values = (measurement.fdx[idx_xf_lower:idx_xf_upper] + measurement.target_frequency * 1e-6 - offset) - first_time_values[0] = -self.frequency_step/2 * 1e-6 + measurement.target_frequency * 1e-6 - first_time_values[-1] = +self.frequency_step/2 * 1e-6 + measurement.target_frequency * 1e-6 - + first_time_values = ( + measurement.fdx[idx_xf_lower:idx_xf_upper] + + measurement.target_frequency * 1e-6 + - offset + ) + first_time_values[0] = ( + -self.frequency_step / 2 * 1e-6 + + measurement.target_frequency * 1e-6 + ) + first_time_values[-1] = ( + +self.frequency_step / 2 * 1e-6 + + measurement.target_frequency * 1e-6 + ) + fdx_assembled = np.array(first_time_values) - + self.broadband_data_fdx = fdx_assembled.flatten() self.broadband_data_fdy = fdy_assembled.flatten() - + def add_tune_and_match(self, magnitude) -> None: """This method adds the tune and match values to the last completed measurement. - + Args: - magnitude (float): The magnitude of the tune and match values.""" + magnitude (float): The magnitude of the tune and match values. + """ logger.debug("Adding tune and match values toat next measurement frequency") next_measurement_frequency = self.get_next_measurement_frequency() self.reflection[next_measurement_frequency] = magnitude + def find_nearest(self, array: np.array, value: float) -> int: + """This method finds the nearest value in an array to a given value. - def find_nearest(self, array, value) -> int: + Args: + array (np.array): The array to search in. + value (float): The value to search for. + + Returns: + int: The index of the nearest value in the array. + """ array = np.asarray(array) idx = (np.abs(array - value)).argmin() return idx - + def to_json(self): - """Converts the broadband measurement to a json-compatible format.""" + """Converts the broadband measurement to a json-compatible format. + + Returns: + dict: The json-compatible format of the broadband measurement. + """ return { - "single_frequency_measurements": [measurement.to_json() for measurement in self.single_frequency_measurements.values()], - "reflection": self.reflection + "single_frequency_measurements": [ + measurement.to_json() + for measurement in self.single_frequency_measurements.values() + ], + "reflection": self.reflection, } - + @classmethod - def from_json(cls, json): - """Converts the json format to a broadband measurement.""" + def from_json(cls, json: dict): + """Converts the json format to a broadband measurement. + + Args: + json (dict): The json format of the broadband measurement. + + Returns: + BroadbandMeasurement: The broadband measurement object. + """ # We create a broadband measurement object with the frequencies and frequency step from the first single frequency measurement - frequencies = [measurement["target_frequency"] for measurement in json["single_frequency_measurements"]] - + frequencies = [ + measurement["target_frequency"] + for measurement in json["single_frequency_measurements"] + ] # We need to calculate the frequency step from the first two measurements frequency_step = frequencies[1] - frequencies[0] @@ -238,7 +341,9 @@ class BroadbandModel(ModuleModel): # We add all of the single frequency measurements to the broadband measurement for measurement in json["single_frequency_measurements"]: - broadband_measurement.add_measurement(Measurement.from_json(measurement)) + broadband_measurement.add_measurement( + Measurement.from_json(measurement) + ) # We assemble the broadband spectrum broadband_measurement.assemble_broadband_spectrum() @@ -249,14 +354,14 @@ class BroadbandModel(ModuleModel): def single_frequency_measurements(self) -> dict: """This property contains the dict of all frequencies that have to be measured.""" return self._single_frequency_measurements - + @single_frequency_measurements.setter def single_frequency_measurements(self, value): self._single_frequency_measurements = value @property def broadband_data_fdx(self): - """ This property contains the broadband data and is assembled by the differen single_frequency measurements in frequency domain.""" + """This property contains the broadband data and is assembled by the different single_frequency measurements in frequency domain.""" return self._broadband_data_fdx @broadband_data_fdx.setter @@ -265,9 +370,9 @@ class BroadbandModel(ModuleModel): @property def broadband_data_fdy(self): - """ This property contains the broadband data and is assembled by the differen single_frequency measurements in frequency domain.""" + """This property contains the broadband data and is assembled by the different single_frequency measurements in frequency domain.""" return self._broadband_data_fdy - + @broadband_data_fdy.setter def broadband_data_fdy(self, value): self._broadband_data_fdy = value diff --git a/src/nqrduck_broadband/view.py b/src/nqrduck_broadband/view.py index 171f8b4..7941eb4 100644 --- a/src/nqrduck_broadband/view.py +++ b/src/nqrduck_broadband/view.py @@ -1,3 +1,4 @@ +"""This module contains the view of the broadband module.""" import logging from datetime import datetime from PyQt6.QtCore import pyqtSlot, pyqtSignal, Qt @@ -10,9 +11,15 @@ logger = logging.getLogger(__name__) class BroadbandView(ModuleView): + """View class for the Broadband module. + + Signals: + start_broadband_measurement: Signal to start a broadband measurement. + """ start_broadband_measurement = pyqtSignal() def __init__(self, module): + """Initializes the BroadbandView.""" super().__init__(module) widget = QWidget() @@ -21,14 +28,16 @@ class BroadbandView(ModuleView): self.widget = widget logger.debug( - "Facecolor %s" % str(self._ui_form.broadbandPlot.canvas.ax.get_facecolor()) + f"Facecolor {str(self._ui_form.broadbandPlot.canvas.ax.get_facecolor())}" ) self.connect_signals() # Add logos self._ui_form.start_measurementButton.setIcon(Logos.Play_16x16()) - self._ui_form.start_measurementButton.setIconSize(self._ui_form.start_measurementButton.size()) + self._ui_form.start_measurementButton.setIconSize( + self._ui_form.start_measurementButton.size() + ) self._ui_form.exportButton.setIcon(Logos.Save16x16()) self._ui_form.exportButton.setIconSize(self._ui_form.exportButton.size()) @@ -67,9 +76,13 @@ class BroadbandView(ModuleView): ) self.module.model.stop_frequency_changed.connect(self.on_stop_frequency_change) self.module.model.frequency_step_changed.connect(self.on_frequency_step_change) - - self._ui_form.start_measurementButton.clicked.connect(self.start_measurement_clicked) - self.start_broadband_measurement.connect(self.module._controller.start_broadband_measurement) + + self._ui_form.start_measurementButton.clicked.connect( + self.start_measurement_clicked + ) + self.start_broadband_measurement.connect( + self.module._controller.start_broadband_measurement + ) self._ui_form.averagesEdit.editingFinished.connect( lambda: self.on_editing_finished(self._ui_form.averagesEdit.text()) @@ -95,10 +108,10 @@ class BroadbandView(ModuleView): @pyqtSlot() def start_measurement_clicked(self) -> None: """This method is called when the start measurement button is clicked. + It shows a dialog asking the user if he really wants to start the measurement. If the user clicks yes the start_broadband_measurement signal is emitted. """ - # Create a QMessageBox object msg_box = QMessageBox(parent=self) msg_box.setText("Start the measurement?") @@ -119,10 +132,13 @@ class BroadbandView(ModuleView): @pyqtSlot() def on_save_button_clicked(self) -> None: """This method is called when the save button is clicked. + It shows a file dialog to the user to select a file to save the measurement to. """ logger.debug("Save button clicked.") - file_manager = self.QFileManager(self.module.model.FILE_EXTENSION, parent=self.widget) + file_manager = self.QFileManager( + self.module.model.FILE_EXTENSION, parent=self.widget + ) file_name = file_manager.saveFileDialog() if file_name: self.module.controller.save_measurement(file_name) @@ -130,10 +146,13 @@ class BroadbandView(ModuleView): @pyqtSlot() def on_load_button_clicked(self) -> None: """This method is called when the load button is clicked. + It shows a file dialog to the user to select a file to load the measurement from. """ logger.debug("Load button clicked.") - file_manager = self.QFileManager(self.module.model.FILE_EXTENSION, parent=self.widget) + file_manager = self.QFileManager( + self.module.model.FILE_EXTENSION, parent=self.widget + ) file_name = file_manager.loadFileDialog() if file_name: self.module.controller.load_measurement(file_name) @@ -176,7 +195,11 @@ class BroadbandView(ModuleView): @pyqtSlot(float) def on_start_frequency_change(self, start_frequency: float) -> None: """This method is called when the start frequency is changed. + It adjusts the view to the new start frequency. + + Args: + start_frequency (float) : The new start frequency. """ logger.debug( "Adjusting view to new start frequency: " + str(start_frequency * 1e-6) @@ -189,7 +212,11 @@ class BroadbandView(ModuleView): @pyqtSlot(float) def on_stop_frequency_change(self, stop_frequency: float) -> None: """This method is called when the stop frequency is changed. + It adjusts the view to the new stop frequency. + + Args: + stop_frequency (float) : The new stop frequency. """ logger.debug( "Adjusting view to new stop frequency: " + str(stop_frequency * 1e-6) @@ -200,22 +227,32 @@ class BroadbandView(ModuleView): self._ui_form.stop_frequencyField.setText(str(stop_frequency * 1e-6)) @pyqtSlot(float) - def on_frequency_step_change(self, frequency_step : float) -> None: + def on_frequency_step_change(self, frequency_step: float) -> None: """This method is called when the frequency step is changed. + It adjusts the view to the new frequency step. + + Args: + frequency_step (float) : The new frequency step. """ - logger.debug("Adjusting view to new frequency step: " + str(frequency_step * 1e-6)) - self._ui_form.broadbandPlot.canvas.ax.set_xlim(right=frequency_step*1e-6) + logger.debug( + "Adjusting view to new frequency step: " + str(frequency_step * 1e-6) + ) + self._ui_form.broadbandPlot.canvas.ax.set_xlim(right=frequency_step * 1e-6) self._ui_form.broadbandPlot.canvas.draw() self._ui_form.broadbandPlot.canvas.flush_events() # Fix float representation - frequency_step = str("{:.2f}".format(frequency_step * 1e-6)) + frequency_step = str(f"{frequency_step * 1e-6:.2f}") self._ui_form.frequencystepEdit.setText(frequency_step) @pyqtSlot() def on_editing_finished(self, value: str) -> None: """This method is called when the user finished editing a field. + It sets the value of the field in the model. + + Args: + value (str) : The value of the field. """ logger.debug("Editing finished by.") self.sender().setStyleSheet("") @@ -225,6 +262,7 @@ class BroadbandView(ModuleView): @pyqtSlot() def on_set_averages_failure(self) -> None: """This method is called when the averages could not be set. + It sets the border of the averages field to red indicating that the entered value was not valid. """ logger.debug("Set averages failure.") @@ -233,6 +271,7 @@ class BroadbandView(ModuleView): @pyqtSlot() def on_set_frequency_step_failure(self) -> None: """This method is called when the frequency step could not be set. + It sets the border of the frequency step field to red indicating that the entered value was not valid. """ logger.debug("Set frequency step failure.") @@ -241,13 +280,12 @@ class BroadbandView(ModuleView): @pyqtSlot() def on_broadband_measurement_added(self) -> None: """This method is called when a new broadband measurement is added to the model. + It updates the plots and the progress bar. """ # Get last measurement from the broadband measurement object that is not None logger.debug("Updating broadband plot.") - measurement = ( - self.module.model.current_broadband_measurement.get_last_completed_measurement() - ) + measurement = self.module.model.current_broadband_measurement.get_last_completed_measurement() td_plotter = self._ui_form.time_domainPlot.canvas.ax fd_plotter = self._ui_form.frequency_domainPlot.canvas.ax @@ -257,14 +295,49 @@ class BroadbandView(ModuleView): fd_plotter.clear() broadband_plotter.clear() - td_plotter.plot(measurement.tdx, measurement.tdy.real, label="Real", linestyle="-", alpha=0.35, color="red") - td_plotter.plot(measurement.tdx, measurement.tdy.imag, label="Imaginary", linestyle="-", alpha=0.35, color="green") - td_plotter.plot(measurement.tdx, abs(measurement.tdy), label="Magnitude", color="blue") + td_plotter.plot( + measurement.tdx, + measurement.tdy.real, + label="Real", + linestyle="-", + alpha=0.35, + color="red", + ) + td_plotter.plot( + measurement.tdx, + measurement.tdy.imag, + label="Imaginary", + linestyle="-", + alpha=0.35, + color="green", + ) + td_plotter.plot( + measurement.tdx, abs(measurement.tdy), label="Magnitude", color="blue" + ) td_plotter.legend() - fd_plotter.plot(measurement.fdx * 1e-6, measurement.fdy.real, label="Real", linestyle="-", alpha=0.35, color="red") - fd_plotter.plot(measurement.fdx * 1e-6, measurement.fdy.imag, label="Imaginary", linestyle="-", alpha=0.35, color="green") - fd_plotter.plot(measurement.fdx * 1e-6, abs(measurement.fdy), label="Magnitude", color="blue") + fd_plotter.plot( + measurement.fdx * 1e-6, + measurement.fdy.real, + label="Real", + linestyle="-", + alpha=0.35, + color="red", + ) + fd_plotter.plot( + measurement.fdx * 1e-6, + measurement.fdy.imag, + label="Imaginary", + linestyle="-", + alpha=0.35, + color="green", + ) + fd_plotter.plot( + measurement.fdx * 1e-6, + abs(measurement.fdy), + label="Magnitude", + color="blue", + ) fd_plotter.legend() # Plot real and imag part again here in time and frequency domain @@ -274,18 +347,28 @@ class BroadbandView(ModuleView): ) # Plot S11 values on the twin axis of the broadband plot - frequencies = self.module.model.current_broadband_measurement.reflection.keys() + frequencies = self.module.model.current_broadband_measurement.reflection.keys() frequencies = [frequency * 1e-6 for frequency in frequencies] - reflection_values = self.module.model.current_broadband_measurement.reflection.values() + reflection_values = ( + self.module.model.current_broadband_measurement.reflection.values() + ) if reflection_values: - self._ui_form.broadbandPlot.canvas.S11ax = self._ui_form.broadbandPlot.canvas.ax.twinx() + self._ui_form.broadbandPlot.canvas.S11ax = ( + self._ui_form.broadbandPlot.canvas.ax.twinx() + ) S11plotter = self._ui_form.broadbandPlot.canvas.S11ax S11plotter.clear() # Make second axis for S11 value self._ui_form.broadbandPlot.canvas.S11ax.set_ylabel("S11 in dB") self._ui_form.broadbandPlot.canvas.S11ax.set_ylim([-40, 0]) - S11plotter.plot(frequencies, reflection_values, color="red", marker="x", linestyle="None") + S11plotter.plot( + frequencies, + reflection_values, + color="red", + marker="x", + linestyle="None", + ) self.set_timedomain_labels() self.set_frequencydomain_labels() @@ -320,14 +403,14 @@ class BroadbandView(ModuleView): self._ui_form.frequencystepEdit.setEnabled(True) self._ui_form.activeLUTLabel.setText("None") - def add_info_text(self, text : str) -> None: + def add_info_text(self, text: str) -> None: """Add a text to the info box with a timestamp. Args: text (str): The text to add to the info box. """ timestamp = datetime.now().strftime("%H:%M:%S") - text = "[%s] %s" % (timestamp, text) + text = f"[{timestamp}] {text}" text_label = QLabel(text) text_label.setStyleSheet("font-size: 25px;") self._ui_form.scrollAreaWidgetContents.layout().addWidget(text_label)