pymagnetos 0.1.0__py3-none-any.whl

pymagnetos/pytdo/gui/widgets/_configuration.py

@@ -0,0 +1,78 @@
+"""The Configuration section of the GUI."""
+
+from PyQt6.QtCore import pyqtSignal
+from pyqtgraph.parametertree import Parameter
+
+from pymagnetos.core.gui.widgets import BaseConfigurationWidget
+
+from ._param_content import ParamContent
+
+
+class ConfigurationWidget(BaseConfigurationWidget):
+    """
+    Configuration Parameter Tree for TDO experiments.
+
+    Signals
+    -------
+    sig_syncroi_changed : emitted when the "Sync ROI" checkbox is changed.
+    sig_timeoffset_changed : emitted when the "Time offset" parameter is changed.
+    sig_spectro_nperseg_changed : emittend when the "n/segment" parameter is changed.
+    sig_fitdeg_changed : emitted when the fit degree parameter is changed.
+    sig_npoints_interp_changed : emitted when the npoints for interlation is changed.
+    sig_curveoffset_changed : emitted when the curve offset is changed.
+    """
+
+    sig_syncroi_changed = pyqtSignal()
+    sig_timeoffset_changed = pyqtSignal()
+    sig_spectro_nperseg_changed = pyqtSignal()
+    sig_fitdeg_changed = pyqtSignal()
+    sig_npoints_interp_changed = pyqtSignal()
+    sig_curveoffset_changed = pyqtSignal()
+
+    def __init__(self, param_content: type[ParamContent]):
+        super().__init__(param_content)
+
+        self.add_extra_parameters()
+        self.connect_extras()
+
+    def add_extra_parameters(self):
+        """Add extra parameters used only in the GUI."""
+        # Sync ROIs parameter
+        self.syncroi_parameter = Parameter.create(
+            name="syncroi",
+            type="bool",
+            value=False,
+            title="Sync. fit and FFT field-window",
+        )
+        self.host_parameters.addChild(self.syncroi_parameter)
+
+        # Show nperseg parameter in µs
+        nperseg = Parameter.create(
+            name="spectro_time_window",
+            type="float",
+            readonly=True,
+            value=1024 / 100e6,
+            suffix="s",
+            siPrefix=True,
+            title="Spectro: time window (n/persegment)",
+        )
+        self.host_parameters.addChild(nperseg)
+
+    def connect_extras(self):
+        """Extra connections."""
+        self.syncroi_parameter.sigValueChanged.connect(self.sig_syncroi_changed.emit)
+        self.settings_parameters.child("time_offset").sigValueChanged.connect(
+            self.sig_timeoffset_changed.emit
+        )
+        self.settings_parameters.child("spectro_nperseg").sigValueChanged.connect(
+            self.sig_spectro_nperseg_changed.emit
+        )
+        self.settings_parameters.child("poly_deg").sigValueChanged.connect(
+            self.sig_fitdeg_changed.emit
+        )
+        self.settings_parameters.child(
+            "npoints_interp_inverse"
+        ).sigValueChanged.connect(self.sig_npoints_interp_changed.emit)
+        self.settings_parameters.child("offset").sigValueChanged.connect(
+            self.sig_curveoffset_changed.emit
+        )

pymagnetos/pytdo/gui/widgets/_graphs.py

@@ -0,0 +1,280 @@
+"""The graphs area that holds all the plots."""
+
+import pyqtgraph as pg
+from PyQt6 import QtCore, QtWidgets
+from PyQt6.QtCore import pyqtSignal, pyqtSlot
+
+from pymagnetos.core.gui.widgets import BaseGraphsWidget
+
+
+class GraphsWidget(BaseGraphsWidget):
+    """
+    The graphs area with all the plots.
+
+    There are two tabs, one with :
+    - dB/dt
+    - B(t)
+    - TDO(t)
+    - TDO(B)
+    The other with :
+    - B(t)
+    - TDO(B)
+    - TDO_detrended(B)
+    - TDO_detrended(1/B)
+    - FFT
+
+    Since B(t) and TDO(B) are re-used, placeholders plots are created. They are replaced
+    when the tab is selected.
+
+    Signals
+    -------
+    sig_roi1_changed : emits when the draggable field-window moved in tdo(B).
+    sig_roi2_changed : emits when the draggable field-window moved in tdo_detrend(B).
+    """
+
+    sig_roi1_changed = pyqtSignal()
+    sig_roi2_changed = pyqtSignal()
+
+    def __init__(self):
+        super().__init__()
+        # Flags
+        self._sync_roi = False
+
+        # Create layouts
+        widget1 = self.create_first_tab()
+        widget2 = self.create_second_tab()
+
+        # Create the tabs
+        tab = QtWidgets.QTabWidget(self)
+        tab.addTab(widget1, "TDO")
+        tab.addTab(widget2, "Oscillations")
+        tab.currentChanged.connect(self.move_plots)  # replace placeholders
+
+        layout = QtWidgets.QVBoxLayout(self)
+        layout.addWidget(tab)
+        self.setLayout(layout)
+
+        # Apply axes style
+        self.customize_axis()
+        self.init_coordinates_on_hover()
+
+    def create_first_tab(self) -> QtWidgets.QSplitter:
+        """Create the tab with the magnetic field and TDO signal."""
+        # Create the plots
+        self.create_field_plot()
+        self.create_signal_plot()
+
+        # Create splitter for the top row
+        self.tab1_top_splitter = QtWidgets.QSplitter(QtCore.Qt.Orientation.Horizontal)
+        self.tab1_top_splitter.addWidget(self.dfield)
+        self.tab1_top_splitter.addWidget(self.field)
+        self.tab1_top_splitter.addWidget(self.sig_time)
+
+        # Create splitter for the bottom row
+        self.tab1_main_splitter = QtWidgets.QSplitter(QtCore.Qt.Orientation.Vertical)
+        self.tab1_main_splitter.addWidget(self.tab1_top_splitter)
+        self.tab1_main_splitter.addWidget(self.sig_field)
+
+        # Adjust ratios
+        self.tab1_main_splitter.setStretchFactor(0, 1)
+        self.tab1_main_splitter.setStretchFactor(1, 2)
+
+        return self.tab1_main_splitter
+
+    def create_second_tab(self) -> QtWidgets.QSplitter:
+        """Create the tab with the detrended TDO signals and the FFT."""
+        self.create_tdo_plot()
+        self.create_fft_plot()
+
+        # Create splitter for the top row
+        self.tab2_top_splitter = QtWidgets.QSplitter(QtCore.Qt.Orientation.Horizontal)
+        # Add the placeholders plots, they will be replaced when the tab is shown
+        self.tab2_top_splitter.addWidget(self._v2field)
+        self.tab2_top_splitter.addWidget(self._v2sig_field)
+
+        # Create splitter for the bottom row
+        bottom_splitter = QtWidgets.QSplitter(QtCore.Qt.Orientation.Horizontal)
+        bottom_splitter.addWidget(self.tdo_field)
+        bottom_splitter.addWidget(self.tdo_inverse_field)
+        bottom_splitter.addWidget(self.fft)
+
+        # Create main splitter
+        self.tab2_main_splitter = QtWidgets.QSplitter(QtCore.Qt.Orientation.Vertical)
+        self.tab2_main_splitter.addWidget(self.tab2_top_splitter)
+        self.tab2_main_splitter.addWidget(bottom_splitter)
+
+        return self.tab2_main_splitter
+
+    def create_field_plot(self) -> None:
+        # magnetic field (integrated)
+        self.field = pg.PlotWidget(title="Magnetic field")
+        self.field.setLabel("bottom", "time (s)")
+        self.field.setLabel("left", "field (T)")
+        self.field.getAxis("left").enableAutoSIPrefix(False)
+        self._plots_list.add(self.field)
+        # magnetic field (placeholders)
+        self._v1field = pg.PlotWidget(title="Magnetic field")
+        self._v1field.setLabel("bottom", "time (s)")
+        self._v1field.setLabel("left", "field (T)")
+        self._v2field = pg.PlotWidget(title="Magnetic field")
+        self._v2field.setLabel("bottom", "time (s)")
+        self._v2field.setLabel("left", "field (T)")
+
+        # pickup coil voltage (measured)
+        self.dfield = pg.PlotWidget(title="Pickup")
+        self.dfield.setLabel("bottom", "time (s)")
+        self.dfield.setLabel("left", "pickup (V)")
+        self._plots_list.add(self.dfield)
+
+    def create_signal_plot(self):
+        # TDO signal versus field
+        self.sig_field = pg.PlotWidget(title="Signal versus field")
+        self.sig_field.setLabel("bottom", "field (T)")
+        self.sig_field.setLabel("left", "TDO frequency (Hz)")
+        # Field-window selector
+        self.roi = pg.LinearRegionItem(
+            brush=pg.mkBrush("#0000ff1a"), pen=self.pen_fitbounds
+        )
+        # Disable mouse drag
+        self.roi.hoverEvent = lambda *args, **kwargs: None  # ty:ignore[invalid-assignment]
+        self.roi.mouseDragEvent = lambda *args, **kwargs: None  # ty:ignore[invalid-assignment]
+        self.sig_field.addItem(self.roi, ignoreBounds=True)  # ty:ignore[unknown-argument]
+
+        self.roi.sigRegionChangeFinished.connect(self.roi1_changed)
+        self.sig_field.getPlotItem().addLegend()
+        self._plots_list.add(self.sig_field)
+
+        # TDO signal versus field (placeholders)
+        self._v1sig_field = pg.PlotWidget(title="Signal versus field")
+        self._v1sig_field.setLabel("bottom", "field (T)")
+        self._v1sig_field.setLabel("left", "TDO frequency (Hz)")
+        self._v2sig_field = pg.PlotWidget(title="Signal versus field")
+        self._v2sig_field.setLabel("bottom", "field (T)")
+        self._v2sig_field.setLabel("left", "TDO frequency (Hz)")
+
+        # TDO signal versus time
+        self.sig_time = pg.PlotWidget(title="Signal versus time")
+        self.sig_time.setLabel("bottom", "time (s)")
+        self.sig_time.setLabel("left", "TDO frequency (Hz)")
+        self._plots_list.add(self.sig_time)
+
+    def create_tdo_plot(self):
+        # vs field
+        self.tdo_field = pg.PlotWidget(title="Oscillatory part versus field")
+        self.tdo_field.setLabel("bottom", "field (T)")
+        self.tdo_field.setLabel("left", "TDO detrended")
+        self.tdo_field.getPlotItem().addLegend()
+        # Field-window selector for FFT range
+        self.roi2 = pg.LinearRegionItem(
+            brush=pg.mkBrush("#0000ff1a"), pen=self.pen_fftbounds
+        )
+        # Disable mouse drag
+        self.roi2.hoverEvent = lambda *args, **kwargs: None  # ty:ignore[invalid-assignment]
+        self.roi2.mouseDragEvent = lambda *args, **kwargs: None  # ty:ignore[invalid-assignment]
+
+        self.tdo_field.addItem(self.roi2, ignoreBounds=True)  # ty:ignore[unknown-argument]
+        self.roi2.sigRegionChangeFinished.connect(self.roi2_changed)
+
+        # Vertical lines to show polynomial fit range
+        self.fit_bounds1 = pg.InfiniteLine(pen=self.pen_fitbounds, movable=False)
+        self.fit_bounds2 = pg.InfiniteLine(pen=self.pen_fitbounds, movable=False)
+        self.tdo_field.addItem(self.fit_bounds1)
+        self.tdo_field.addItem(self.fit_bounds2)
+        self._plots_list.add(self.tdo_field)
+
+        # vs 1/B
+        self.tdo_inverse_field = pg.PlotWidget(title="Oscillatory part versus 1/B")
+        self.tdo_inverse_field.setLabel("bottom", "1/B (T^-1)")
+        self.tdo_inverse_field.setLabel("left", "TDO detrended")
+        # Vertical lines to show FFT range
+        self.fft_bounds1 = pg.InfiniteLine(pen=self.pen_fftbounds, movable=False)
+        self.fft_bounds2 = pg.InfiniteLine(pen=self.pen_fftbounds, movable=False)
+        self.tdo_inverse_field.addItem(self.fft_bounds1)
+        self.tdo_inverse_field.addItem(self.fft_bounds2)
+        self._plots_list.add(self.tdo_inverse_field)
+
+    def create_fft_plot(self):
+        # vs field
+        self.fft = pg.PlotWidget(title="Fourier transform")
+        self.fft.setLabel("bottom", "B-frequency (T)")
+        self.fft.setLabel("left", "magnitude")
+        self.fft.getPlotItem().addLegend()
+        self._plots_list.add(self.fft)
+
+    def customize_axis(self):
+        """Set a right axis and show the grid, for all the plots."""
+        for plot in self._plots_list:
+            plot.showAxis("right")
+            plot.getAxis("right").setTicks([])
+            plot.showGrid(y=True)
+
+    def init_plot_style(self):
+        """Set up PyQtGraph line styles."""
+        w0 = 1
+        w1 = 2
+        self.pen_field = pg.mkPen("#c7c7c7", width=w0)
+        self.pen_bup = pg.mkPen("#2ca02cff", width=w0)
+        self.pen_bdown = pg.mkPen("#d62728ff", width=w0)
+        self.pen_tdo = pg.mkPen("#fffc5c80", width=w0)
+        self.pen_fitbup = pg.mkPen("#2ca02cb1", width=w0)
+        self.pen_fitdown = pg.mkPen("#d62728b1", width=w0)
+        self.pen_fitbounds = pg.mkPen("#7477ed99", width=w1)
+        self.pen_fftbounds = pg.mkPen("#eddd86ff", width=w1)
+
+    @pyqtSlot()
+    def roi1_changed(self):
+        """Update ROI in the TDO detrended panel when the ROI in the TDO panel moved."""
+        roi1 = self.roi.getRegion()  # TDO panel
+        # Show the select fit range in the TDO detrended panel
+        self.fit_bounds1.setPos(roi1[0])
+        self.fit_bounds2.setPos(roi1[1])
+        self.sig_roi1_changed.emit()
+        if not self._sync_roi:
+            return
+
+        roi2 = self.roi2.getRegion()  # TDO detrend panel
+
+        if roi1 != roi2:
+            self.roi2.setRegion(self.roi.getRegion())
+
+    @pyqtSlot()
+    def roi2_changed(self):
+        """Update ROI in the TDO panel when the ROI in the TDO detrended panel moved."""
+        roi2 = self.roi2.getRegion()  # TDO detrend panel
+        # Show the FFT range in the TDO 1/B panel
+        self.fft_bounds1.setPos(1 / roi2[0])
+        self.fft_bounds2.setPos(1 / roi2[1])
+        self.sig_roi2_changed.emit()
+        if not self._sync_roi:
+            return
+
+        roi1 = self.roi.getRegion()  # TDO panel
+
+        if roi1 != roi2:
+            self.roi.setRegion(self.roi2.getRegion())
+
+    def enable_rois(self):
+        """Enable moving ROIs."""
+        self.roi.setMovable(True)
+        self.roi2.setMovable(True)
+
+    def disable_rois(self):
+        """Disable moving ROIs."""
+        self.roi.setMovable(False)
+        self.roi2.setMovable(False)
+
+    @pyqtSlot(int)
+    def move_plots(self, index: int):
+        """Move plots from one tab to another, because a widget can't be copied."""
+        if index == 0:
+            # First tab
+            self.tab2_top_splitter.replaceWidget(0, self._v2field)
+            self.tab2_top_splitter.replaceWidget(1, self._v2sig_field)
+            self.tab1_top_splitter.replaceWidget(1, self.field)
+            self.tab1_main_splitter.replaceWidget(1, self.sig_field)
+        elif index == 1:
+            # Second tab
+            self.tab1_top_splitter.replaceWidget(1, self._v1field)
+            self.tab1_main_splitter.replaceWidget(1, self._v1sig_field)
+            self.tab2_top_splitter.replaceWidget(0, self.field)
+            self.tab2_top_splitter.replaceWidget(1, self.sig_field)

pymagnetos/pytdo/gui/widgets/_param_content.py

@@ -0,0 +1,137 @@
+"""Parameters for the `pytdo` configuration."""
+
+import numpy as np
+
+from pymagnetos.core.gui.widgets import BaseParamContent
+
+
+class ParamContent(BaseParamContent):
+    PARAMS_TO_PARSE = ["poly_window", "fft_window"]
+    children_parameters = [
+        dict(
+            name="pickup_surface",
+            type="float",
+            limits=[0, np.inf],
+            value=None,
+            suffix="m²",
+            siPrefix=False,
+            readonly=True,
+            title="Pickup surface",
+            tip="Surface of the pickup coil in m²",
+        )
+    ]
+
+    children_settings = [
+        dict(
+            name="max_time",
+            type="float",
+            limits=[0, np.inf],
+            step=0.1,
+            value=1,
+            suffix="s",
+            siPrefix=True,
+            title="Max. time",
+            tip="Stop analysis after this duration (in seconds)",
+        ),
+        dict(
+            name="spectro_nperseg",
+            type="int",
+            limits=[0, np.inf],
+            value=1024,
+            step=512,
+            title="Spectro: n/segment",
+            tip="Number of samples per segment for the spectrogram",
+        ),
+        dict(
+            name="spectro_win_size",
+            type="int",
+            limits=[2, np.inf],
+            value=2048,
+            step=1024,
+            title="Spectro: FFT padding size",
+            tip="Padding size for the FFT in each segment for the spectrogram",
+        ),
+        dict(
+            name="spectro_noverlap",
+            type="int",
+            limits=[-1, np.inf],
+            value=-1,
+            step=512,
+            title="Spectro: n overlap (-1 : n/2)",
+        ),
+        dict(
+            name="barycenters_fwindow",
+            type="float",
+            limits=[0, np.inf],
+            step=1e3,
+            value=1,
+            suffix="Hz",
+            siPrefix=True,
+            title="Barycenters: frequency window",
+        ),
+        dict(
+            name="barycenters_fast",
+            type="bool",
+            limits=[True, False],
+            value=True,
+            title="Barycenters: fast algo.",
+        ),
+        dict(
+            name="time_offset",
+            type="float",
+            limits=[-np.inf, np.inf],
+            suffix="s",
+            siPrefix=True,
+            value=0e-6,
+            step=0.5e-6,
+            title="TDO/Pickup time offset",
+        ),
+        dict(name="poly_window", type="str", value="", title="Fit: field window"),
+        dict(
+            name="poly_deg",
+            type="int",
+            value=3,
+            step=1,
+            limits=[1, 10],
+            title="Fit: degree",
+        ),
+        dict(
+            name="npoints_interp_inverse",
+            type="int",
+            value=100000,
+            step=5e4,
+            limits=[1000, np.inf],
+            title="n points interp. 1/B",
+        ),
+        dict(
+            name="fft_window",
+            type="str",
+            value="",
+            title="FFT: field window",
+        ),
+        dict(
+            name="fft_pad_mult",
+            type="int",
+            value=100,
+            step=100,
+            title="FFT: padding size mult.",
+        ),
+        dict(
+            name="max_bfreq",
+            type="float",
+            value=70000,
+            step=1e4,
+            limits=[1, np.inf],
+            suffix="T",
+            siPrefix=True,
+            title="FFT : Max. B-frequency",
+        ),
+        dict(
+            name="offset",
+            type="float",
+            value=1000,
+            step=500,
+            limits=[0, np.inf],
+            title="Display: curve offset",
+        ),
+    ]

pymagnetos/pyuson/__init__.py

@@ -0,0 +1,7 @@
+"""The `pyuson` module, an app for ultra-sound echoes experiments."""
+
+from .. import core as core
+from ._config import EchoConfig
+from ._echoprocessor import EchoProcessor
+
+__all__ = ["EchoConfig", "EchoProcessor"]

pymagnetos/pyuson/_config.py

@@ -0,0 +1,26 @@
+"""Config class for the EchoProcessor object."""
+
+from pathlib import Path
+from typing import Any
+
+from ..core import BaseConfig
+from ._config_models import EchoConfigurationModel
+
+CONFIG_DEFAULT = Path(__file__).parent / "assets" / "config_default.toml"
+
+
+class EchoConfig(BaseConfig):
+    def __init__(
+        self,
+        user_file: str | Path | None = None,
+        default_file: str | Path | None = None,
+        **overrides: Any,
+    ) -> None:
+        if not default_file:
+            default_file = CONFIG_DEFAULT
+
+        super().__init__(EchoConfigurationModel, user_file, default_file, **overrides)
+
+    @classmethod
+    def loads(cls, json_data: str | bytes, **kwargs) -> "EchoConfig":
+        return super()._loads(EchoConfigurationModel, json_data, **kwargs)

pymagnetos/pyuson/_config_models.py

@@ -0,0 +1,71 @@
+"""Pydantic models for the EchoProcessor Config."""
+
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+from ..core import config_models
+
+
+class Parameters(config_models.Parameters):
+    """Parameters section, things related to the experiment itself."""
+
+    pickup_samplerate: float
+    sample_length: float
+    sample_speed: float
+    detection_mode: str
+    logamp_slope: float
+
+
+class Settings(BaseModel):
+    """Settings section, things related to the analysis."""
+
+    echo_index: int
+    frame_indices: Sequence[int]
+    rolling_mean_wlen: int
+    rolling_mean_subsample: bool
+    range_baseline: Sequence[float]
+    analysis_window: Sequence[float]
+    max_phase_jump: float
+
+
+class Demodulation(BaseModel):
+    """Demodulation section, things related to the digital demodulation process."""
+
+    f0: float
+    fft_nframes: int
+    detrend: bool
+    findsig_nframes: int
+    findsig_nstd: float
+    findsig_extend: float
+    chunksize: int
+    decimate_factor: int
+    filter_order: int
+    filter_fc: float
+
+
+class EchoConfigurationModel(BaseModel):
+    """A Model specialized for ultra-sound echoes experiment."""
+
+    expid: str
+    data_directory: Path
+
+    filenames: dict[str, str | Path] = dict()
+
+    files: dict[str, config_models.File]
+
+    measurements: dict[str, int]
+
+    parameters: Parameters
+    settings: Settings
+
+    metadata: config_models.Metadata
+
+    nx: dict[str, dict[str, Any]]
+    nexus: config_models.Nexus
+
+    demodulation: Demodulation | None = None
+
+    model_config = ConfigDict(validate_assignment=True)