[plotting] move calibrtion plot outside of main window

pyrelacs/app.py

@@ -6,11 +6,13 @@ from PyQt6.QtWidgets import QApplication
 from pyrelacs import info
 from pyrelacs.ui.mainwindow import PyRelacs
 from pyrelacs.util.logging import config_logging
-import resources
 
 log = config_logging()
 
-from . import resources  # best created with pyside6-rcc resources.qrc -o resources.py (rcc produces an error...)
+from pyrelacs import (
+    resources,
+)  # best created with pyside6-rcc resources.qrc -o resources.py (rcc produces an error...)
+
 
 def main():
     app = QApplication(sys.argv)

pyrelacs/ui/mainwindow.py

@@ -22,6 +22,7 @@ from pyrelacs.worker import Worker
 from pyrelacs.repros.repros import Repro
 from pyrelacs.util.logging import config_logging
 from pyrelacs.ui.about import AboutDialog
+from pyrelacs.ui.plots.calibration import CalibrationPlot
 
 log = config_logging()
 _root = path(__file__).parent.parent
@@ -37,13 +38,15 @@ class PyRelacs(QMainWindow):
         )  # Ensure icons are displayed with text
         self.setWindowTitle("PyRelacs")
 
-        self.beat_plot = pg.PlotWidget()
+        self.figure = pg.GraphicsLayoutWidget()
-        self.power_plot = pg.PlotWidget()
 
-        self.beat_plot.addLegend()
+        filename = path.joinpath(path.cwd(), "data.nix")
-        self.power_plot.addLegend()
+        if filename.exists():
-        self.beat_plot.setBackground("w")
+            self.nix_file = nix.File.open(str(filename), nix.FileMode.ReadOnly)
-        self.power_plot.setBackground("w")
+        else:
+            self.nix_file = nix.File.open(str(filename), nix.FileMode.Overwrite)
+
+        self.calibration_plot = CalibrationPlot(self.figure, self.nix_file)
 
         self.threadpool = QThreadPool()
         self.repros = Repro()
@@ -58,17 +61,13 @@ class PyRelacs(QMainWindow):
         self.create_toolbars()
 
         layout = QGridLayout()
-        layout.addWidget(self.beat_plot, 0, 0, 1, 2)
+        layout.addWidget(self.figure, 0, 0, 2, 2)
-        layout.addWidget(self.power_plot, 1, 0, 1, 2)
         layout.addWidget(self.text, 2, 0, 1, 2)
 
         widget = QWidget()
         widget.setLayout(layout)
         self.setCentralWidget(widget)
 
-        filename = path.joinpath(path.cwd(), "data.nix")
-        self.nix_file = nix.File.open(str(filename), nix.FileMode.ReadWrite)
-
     def create_actions(self):
         self._rlx_exitaction = QAction(QIcon(":/icons/exit.png"), "Exit", self)
         self._rlx_exitaction.setStatusTip("Close relacs")
@@ -80,20 +79,26 @@ class PyRelacs(QMainWindow):
         self._rlx_aboutaction.setEnabled(True)
         self._rlx_aboutaction.triggered.connect(self.on_about)
 
-        self._daq_connectaction = QAction(QIcon(":icons/connect.png"), "Connect DAQ", self)
+        self._daq_connectaction = QAction(
+            QIcon(":icons/connect.png"), "Connect DAQ", self
+        )
         self._daq_connectaction.setStatusTip("Connect to daq device")
         # self._daq_connectaction.setShortcut(QKeySequence("Alt+d"))
         self._daq_connectaction.triggered.connect(self.connect_dac)
 
-        self._daq_disconnectaction = QAction(QIcon(":/icons/disconnect.png"), "Disconnect DAQ", self)
+        self._daq_disconnectaction = QAction(
+            QIcon(":/icons/disconnect.png"), "Disconnect DAQ", self
+        )
         self._daq_disconnectaction.setStatusTip("Disconnect the DAQ device")
         # self._daq_connectaction.setShortcut(QKeySequence("Alt+d"))
         self._daq_disconnectaction.triggered.connect(self.disconnect_dac)
 
-        self._daq_calibaction = QAction(QIcon(":/icons/calibration.png"), "Plot calibration", self)
+        self._daq_calibaction = QAction(
+            QIcon(":/icons/calibration.png"), "Plot calibration", self
+        )
         self._daq_calibaction.setStatusTip("Calibrate the attenuator device")
         # self._daq_calibaction.setShortcut(QKeySequence("Alt+d"))
-        self._daq_calibaction.triggered.connect(self.plot_calibration)
+        self._daq_calibaction.triggered.connect(self.calibration_plot.plot)
         self.create_menu()
 
     def create_menu(self):
@@ -156,70 +161,7 @@ class PyRelacs(QMainWindow):
 
         self.plot_calibration_button = QPushButton("Plot Calibration")
         self.plot_calibration_button.setCheckable(True)
-        self.plot_calibration_button.clicked.connect(self.plot_calibration)
+        self.plot_calibration_button.clicked.connect(self.calibration_plot.plot)
-
-    def plot_calibration(self):
-        def decibel(power, ref_power=1.0, min_power=1e-20):
-            """Transform power to decibel relative to ref_power.
-
-            \\[ decibel = 10 \\cdot \\log_{10}(power/ref\\_power) \\]
-            Power values smaller than `min_power` are set to `-np.inf`.
-
-            Parameters
-            ----------
-            power: float or array
-                Power values, for example from a power spectrum or spectrogram.
-            ref_power: float or None or 'peak'
-                Reference power for computing decibel.
-                If set to `None` or 'peak', the maximum power is used.
-            min_power: float
-                Power values smaller than `min_power` are set to `-np.inf`.
-
-            Returns
-            -------
-            decibel_psd: array
-                Power values in decibel relative to `ref_power`.
-            """
-            if np.isscalar(power):
-                tmp_power = np.array([power])
-                decibel_psd = np.array([power])
-            else:
-                tmp_power = power
-                decibel_psd = power.copy()
-            if ref_power is None or ref_power == "peak":
-                ref_power = np.max(decibel_psd)
-            decibel_psd[tmp_power <= min_power] = float("-inf")
-            decibel_psd[tmp_power > min_power] = 10.0 * np.log10(
-                decibel_psd[tmp_power > min_power] / ref_power
-            )
-            if np.isscalar(power):
-                return decibel_psd[0]
-            else:
-                return decibel_psd
-
-        block = self.nix_file.blocks[0]
-        colors = ["red", "green", "blue", "black", "yellow"]
-        for i, (stim, fish) in enumerate(
-            zip(list(block.data_arrays)[::2], list(block.data_arrays)[1::2])
-        ):
-            beat = stim[:] + fish[:]
-            beat_squared = beat**2
-
-            f, powerspec = welch(beat, fs=40_000.0)
-            powerspec = decibel(powerspec)
-
-            f_sq, powerspec_sq = welch(beat_squared, fs=40_000.0)
-            powerspec_sq = decibel(powerspec_sq)
-            peaks = find_peaks(powerspec_sq, prominence=10)[0]
-            pen = pg.mkPen(colors[i])
-            self.beat_plot.plot(
-                np.arange(0, len(beat)) / 40_000.0,
-                beat_squared,
-                pen=pen,
-                name=stim.name,
-            )
-            self.power_plot.plot(f_sq, powerspec_sq, pen=pen, name=stim.name)
-            self.power_plot.plot(f[peaks], powerspec_sq[peaks], pen=None, symbol="x")
 
     def connect_dac(self):
         devices = uldaq.get_daq_device_inventory(uldaq.InterfaceType.USB)
@@ -261,8 +203,12 @@ class PyRelacs(QMainWindow):
 
         self.threadpool.start(worker)
 
+    def add_to_textfield(self, s: str):
+        self.text.appendPlainText(s)
+
     def on_exit(self):
-        print("exit button!")
+        log.info("exit button!")
+        self.add_to_textfield("exiting")
         self.close()
 
     def on_about(self, e):
@@ -270,10 +216,12 @@ class PyRelacs(QMainWindow):
         about.show()
 
     def print_output(self, s):
-        print(s)
+        log.info(s)
+        self.add_to_textfield(s)
 
     def thread_complete(self):
-        print("THREAD COMPLETE!")
+        log.info("Thread complete!")
+        self.add_to_textfield("Thread complete!")
 
     def progress_fn(self, n):
         print("%d%% done" % n)

pyrelacs/ui/plots/calibration.py

@@ -0,0 +1,113 @@
+from IPython import embed
+import pyqtgraph as pg
+import numpy as np
+from scipy.signal import welch, find_peaks
+from scipy.integrate import romb
+
+
+class CalibrationPlot:
+    def __init__(self, figure: pg.GraphicsLayoutWidget, nix_file):
+        self.figure = figure
+        self.nix_file = nix_file
+
+    def plot(self):
+        self.figure.setBackground("w")
+        self.beat_plot = self.figure.addPlot(row=0, col=0)
+        self.power_plot = self.figure.addPlot(row=1, col=0)
+        self.beat_plot.addLegend()
+        self.power_plot.addLegend()
+        # self.power_plot.setLogMode(x=False, y=True)
+
+        block = self.nix_file.blocks[0]
+        colors = ["red", "green", "blue", "black", "yellow"]
+        for i, (stim, fish) in enumerate(
+            zip(list(block.data_arrays)[::2], list(block.data_arrays)[1::2])
+        ):
+            f_stim, stim_power = welch(
+                stim[:],
+                fs=40_000.0,
+                window="flattop",
+                nperseg=100_000,
+            )
+            stim_power = self.decibel(stim_power)
+            stim_max_power_index = np.argmax(stim_power)
+            freq_stim = f_stim[stim_max_power_index]
+
+            f_fish, fish_power = welch(
+                fish[:],
+                fs=40_000.0,
+                window="flattop",
+                nperseg=100_000,
+            )
+            fish_power = self.decibel(fish_power)
+            fish_max_power_index = np.argmax(fish_power)
+            freq_fish = f_fish[fish_max_power_index]
+
+            beat_frequency = np.abs(freq_fish - freq_stim)
+
+            beat = stim[:] + fish[:]
+            beat_squared = beat**2
+
+            f, powerspec = welch(
+                beat_squared,
+                window="flattop",
+                fs=40_000.0,
+                nperseg=100_000,
+            )
+            powerspec = self.decibel(powerspec)
+
+            padding = 20
+            integration_window = powerspec[
+                (f > beat_frequency - padding) & (f < beat_frequency + padding)
+            ]
+
+            peaks = find_peaks(powerspec, prominence=40)[0]
+
+            pen = pg.mkPen(colors[i])
+
+            self.beat_plot.plot(
+                np.arange(0, len(beat)) / 40_000.0,
+                beat,
+                pen=pen,
+                name=stim.name,
+            )
+            self.power_plot.plot(f, powerspec, pen=pen, name=stim.name)
+            self.power_plot.plot(f[peaks], powerspec[peaks], pen=None, symbol="x")
+
+    def decibel(self, power, ref_power=1.0, min_power=1e-20):
+        """Transform power to decibel relative to ref_power.
+
+        \\[ decibel = 10 \\cdot \\log_{10}(power/ref\\_power) \\]
+        Power values smaller than `min_power` are set to `-np.inf`.
+
+        Parameters
+        ----------
+        power: float or array
+            Power values, for example from a power spectrum or spectrogram.
+        ref_power: float or None or 'peak'
+            Reference power for computing decibel.
+            If set to `None` or 'peak', the maximum power is used.
+        min_power: float
+            Power values smaller than `min_power` are set to `-np.inf`.
+
+        Returns
+        -------
+        decibel_psd: array
+            Power values in decibel relative to `ref_power`.
+        """
+        if np.isscalar(power):
+            tmp_power = np.array([power])
+            decibel_psd = np.array([power])
+        else:
+            tmp_power = power
+            decibel_psd = power.copy()
+        if ref_power is None or ref_power == "peak":
+            ref_power = np.max(decibel_psd)
+        decibel_psd[tmp_power <= min_power] = float("-inf")
+        decibel_psd[tmp_power > min_power] = 10.0 * np.log10(
+            decibel_psd[tmp_power > min_power] / ref_power
+        )
+        if np.isscalar(power):
+            return decibel_psd[0]
+        else:
+            return decibel_psd