pymagnetos 0.1.0__py3-none-any.whl

pymagnetos/pyuson/assets/config_default.toml

@@ -0,0 +1,92 @@
+# This configuration file specifies the default values if they are not filled in the
+# per-experiment config.toml file.
+
+expid = ""
+data_directory = "."  # path or "."
+
+[files]
+[files.pickup]
+# Pickup coil binary file
+ext = "-pickup.bin"
+header = 0
+precision = 8       # number of bytes/element
+endian = "<"        # endian, ">" for big-endian, "<" for little-endian
+order = "F"         # order style in the binary file, "F" for Fortran, "C" for C
+[files.oscillo]
+# Oscilloscope binary file
+ext = ".bin"
+header = 0
+precision = 4 # number of bytes/element
+endian = ">"  # endian, ">" for big-endian, "<" for little-endian
+order = "F"   # order style in the binary file, "F" for Fortran, "C" for C
+[files.reference_time]
+# Reference time text file
+ext = ".txt"
+header = 8  # number of lines composing the header (data should start at header + 1)
+delimiter = "\t"
+
+[measurements]
+# Measurements settings
+# Link a physical measurement to a channel of the oscilloscope
+# For oscillo data saved with LabVIEW, they correspond to the columns in the file (0-based)
+# For WFM files they correspond to the file number (..._chX.wfm)
+amplitude = 0
+in_phase = 1
+out_phase = 2
+
+# Parameters are values that should be fixed once and for all for a given experiment
+[parameters]
+pickup_surface = 1  # surface of the pickup coil (m²)
+pickup_samplerate = 1  # pickup coil acquisition rate (Hz)
+sample_length = 1  # length of the sample (m)
+sample_speed = 1 # (estimated) speed in the measured mode (m/s)
+detection_mode = "reflection"  # "reflection" or "transmission"
+
+pickup_number = 1  # number of pickup(s) used and save in the pickup bin file
+pickup_index = 0  # index of the pickup to use for analysis, 0-based
+logamp_slope = 24.75e-3  # logarithmic amplificator slope
+
+# Settings are analysis-specific and can be changed afterwards
+[settings]
+echo_index = 1  # number of the analyzed echo (1-based)
+frame_indices = [0, 1]  # frame index to plot
+rolling_mean_wlen = 3  # rolling-average time window size (in indices)
+rolling_mean_subsample = false  # sub-sample resulting time trace
+range_baseline = [0.01, 0.02]  # range in which the baseline of amplitude and phase are estimated in seconds
+analysis_window = []  # frame time-range in which to perform attenuation and phase-shift computation
+max_phase_jump = 0.5  # maximum allowed phase-jump (multiplied by pi)
+
+[metadata]
+# Parameters on how to handle time reference text file (only for bin files)
+[metadata.index_map]
+# map a metadata to its line index in the header (0-based)
+timestamp = 0
+sample_name = 1
+sample_angle = 2
+polarisation = 3
+rf_frequency = 4
+dt_acq = 5
+temperature = 6
+[metadata.conversion_map]
+# determine whether conversion to numeric is required
+timestamp = false
+sample_name = false
+sample_angle = false
+polarisation = false
+rf_frequency = true
+dt_acq = true
+temperature = true
+
+[nx]
+# NeXus file consolidation
+
+[nexus]
+[nexus.groups]
+# NeXus groups attributes
+root = {name = ""}
+# processed/analysis
+analysis = {}
+# data
+data = {}
+[nexus.datasets]
+# NeXus datasets attributes

pymagnetos/pyuson/gui/__init__.py

@@ -0,0 +1,26 @@
+"""Application for ultra-sound echoes experiments during high-magnetic field."""
+
+from PyQt6 import QtWidgets
+
+from .main import MainWindow
+
+
+def run(exec: bool = True) -> None | MainWindow:
+    """
+    Build and run the app.
+
+    Set `exec=False` in an interactive prompt to interact with the GUI from the shell.
+
+    Parameters
+    ----------
+    exec : bool, optional
+        Execute the process thread. Set to False in an interactive prompt. Default is
+        True.
+    """
+    app = QtWidgets.QApplication([])
+    win = MainWindow()
+    win.show()
+    if exec:
+        app.exec()
+    else:
+        return win

pymagnetos/pyuson/gui/_worker.py

@@ -0,0 +1,135 @@
+"""Worker that connects to an EchoProcessor object."""
+
+from pathlib import Path
+
+from PyQt6.QtCore import QObject, pyqtSignal, pyqtSlot
+
+from pymagnetos.pyuson import EchoProcessor
+
+
+class ProcessorWorker(QObject):
+    """
+    Wrapper around the EchoProcessor class.
+
+    It exposes the EchoProcessor methods as slots and emits a signal when the task is
+    finished.
+
+    pyqtSignals
+    -------
+    sig_load_finished : emits when loading data is finished.
+    sig_align_finished : emits when aligning magnetic field is finished.
+    sig_rolling_finished : emits when rolling average is finished.
+    sig_find_f0_finished : emits f0 when finding center frequency is finished.
+    sig_demodulate_finished : emits when demodulation is finished.
+    sig_average_finished : emits when averaging frames and computing is finished.
+    sig_batch_finished : emits when batch-processing is finished.
+
+    sig_export_csv_finished : emits when exporting as CSV is finished.
+    sig_save_nexus_finished : emits when saving as NeXus file is finished.
+
+    sig_demodulation_progress : emits step index during demodulation.
+    sig_batch_process_progress : emits step index during batch-processing.
+    """
+
+    sig_load_finished = pyqtSignal()
+    sig_align_finished = pyqtSignal()
+    sig_rolling_finished = pyqtSignal()
+    sig_find_f0_finished = pyqtSignal(float)
+    sig_demodulate_finished = pyqtSignal()
+    sig_average_finished = pyqtSignal(bool)
+    sig_batch_finished = pyqtSignal()
+
+    sig_export_csv_finished = pyqtSignal()
+    sig_save_nexus_finished = pyqtSignal()
+
+    sig_demodulation_progress = pyqtSignal(int)
+    sig_batch_progress = pyqtSignal(int)
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__()
+        self.proc = EchoProcessor(*args, **kwargs)
+        if self.proc.is_nexus_file:
+            # From file : data should already be loaded and ready to use
+            self.is_dataloaded = True
+        else:
+            self.is_dataloaded = False
+
+    @pyqtSlot()
+    def load_data(self) -> None:
+        """Load data."""
+        self.proc.load_oscillo(scale=True)
+        self.is_dataloaded = True
+        self.proc.align_field()  # use the Processor method directly to not emit signal
+        self.sig_load_finished.emit()
+
+    @pyqtSlot()
+    def rolling_average(self) -> None:
+        """Apply moving average."""
+        self.proc.rolling_average()
+        self.sig_rolling_finished.emit()
+
+    def align_field(self) -> None:
+        """Align magnetic field on data."""
+        self.proc.align_field()
+        self.sig_align_finished.emit()
+
+    @pyqtSlot()
+    def find_f0(self) -> None:
+        """Find F0."""
+        self.proc.find_f0()
+        self.sig_find_f0_finished.emit(self.proc.metadata["rf_frequency"])
+
+    @pyqtSlot()
+    def demodulate(self) -> None:
+        """Apply digital demodulation."""
+        self.proc.demodulate(progress_emitter=self.sig_demodulation_progress)
+        self.sig_demodulate_finished.emit()
+
+    @pyqtSlot()
+    def average_frame(self) -> None:
+        """Average in the time window, comptue attenuation and phase-shift."""
+        self.proc.average_frame_range().compute_attenuation().compute_phase_shift()
+        # Check it went fine
+        if self.proc.is_averaged:
+            self.sig_average_finished.emit(True)
+        else:
+            self.sig_average_finished.emit(False)
+
+    @pyqtSlot(list, bool, bool, bool, bool)
+    def batch_process(
+        self,
+        expids: list,
+        rolling_average: bool,
+        save_csv: bool,
+        to_cm: bool,
+        find_f0: bool,
+    ) -> None:
+        """Batch-process several datasets."""
+        self.proc.batch_process(
+            expids,
+            rolling_average=rolling_average,
+            save_csv=save_csv,
+            save_csv_kwargs=dict(to_cm=to_cm),
+            find_f0=find_f0,
+            batch_progress_emitter=self.sig_batch_progress,
+            demodulation_progress_emitter=self.sig_demodulation_progress,
+        )
+
+        # Emit signals
+        self.sig_load_finished.emit()
+        if self.proc.is_digital:
+            self.sig_demodulate_finished.emit()
+        self.sig_average_finished.emit(True)
+        self.sig_batch_finished.emit()
+
+    @pyqtSlot(str, bool)
+    def export_as_csv(self, fname: str, to_cm: bool) -> None:
+        """Export results as CSV."""
+        self.proc.to_csv(fname=fname, to_cm=to_cm)
+        self.sig_export_csv_finished.emit()
+
+    @pyqtSlot(str)
+    def save_as_nexus(self, fname: str | Path) -> None:
+        """Save data as NeXus."""
+        self.proc.save(filename=fname)
+        self.sig_save_nexus_finished.emit()