[plotting] move calibrtion plot outside of main window

.gitignore

@@ -161,3 +161,8 @@ cython_debug/
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
 
+# ignore created data files
+*.nix
+
+# ignore reource.py as it is created by pyside6-rcc resources.qrc -o resources.py
+resources.py

pyproject.toml

@@ -16,11 +16,12 @@ classifiers = [
     "Intended Audience :: End Users/Desktop",
 ]
 include = [
-    { path = "pyproject.toml" }
+    { path = "pyproject.toml" },
+    "pyrelacs/resources.py"
 ]
 
 [tool.poetry.dependencies]
-python = "^3.12"
+python = "^3.10"
 uldaq = "^1.2.3"
 typer = "^0.12.5"
 matplotlib = "^3.9.2"

pyrelacs/app.py

@@ -1,186 +1,17 @@
-import pathlib
-from PyQt6.QtGui import QAction
 import sys
 
-from PyQt6.QtCore import QSize, QThreadPool, QSettings
-from PyQt6.QtWidgets import (
-    QApplication,
-    QGridLayout,
-    QPushButton,
-    QToolBar,
-    QWidget,
-    QMainWindow,
-    QPlainTextEdit,
-)
-import pyqtgraph as pg
-import uldaq
-from IPython import embed
-from scipy.signal import welch, find_peaks
-import numpy as np
-import nixio as nix
+from PyQt6.QtCore import QSettings
+from PyQt6.QtWidgets import QApplication
 
+from pyrelacs import info
+from pyrelacs.ui.mainwindow import PyRelacs
 from pyrelacs.util.logging import config_logging
-import pyrelacs.info as info
-from pyrelacs.worker import Worker
-from pyrelacs.repros.repros import Repro
 
 log = config_logging()
 
-
-class PyRelacs(QMainWindow):
-    def __init__(self):
-        super().__init__()
-        self.setWindowTitle("PyRelacs")
-        self.beat_plot = pg.PlotWidget()
-        self.power_plot = pg.PlotWidget()
-
-        self.threadpool = QThreadPool()
-        self.repros = Repro()
-
-        self.daq_connect_button = QPushButton("Connect Daq")
-        self.daq_connect_button.setCheckable(True)
-        self.daq_connect_button.clicked.connect(self.connect_dac)
-
-        self.daq_disconnect_button = QPushButton("Disconnect Daq")
-        self.daq_disconnect_button.setCheckable(True)
-        self.daq_disconnect_button.clicked.connect(self.disconnect_dac)
-
-        self.plot_calibration_button = QPushButton("Plot Calibration")
-        self.plot_calibration_button.setCheckable(True)
-        self.plot_calibration_button.clicked.connect(self.plot_calibration)
-
-        layout = QGridLayout()
-        layout.addWidget(self.plot_calibration_button, 0, 0)
-        layout.addWidget(self.daq_disconnect_button, 0, 1)
-        layout.addWidget(self.beat_plot, 2, 0, 1, 2)
-        layout.addWidget(self.power_plot, 3, 0, 1, 2)
-
-        self.toolbar = QToolBar("Repros")
-        self.addToolBar(self.toolbar)
-        self.repros_to_toolbar()
-
-        # self.setFixedSize(QSize(400, 300))
-        widget = QWidget()
-        widget.setLayout(layout)
-        self.setCentralWidget(widget)
-
-        self.nix_file = nix.File.open(
-            str(pathlib.Path(__file__).parent / "data"), nix.FileMode.ReadOnly
-        )
-
-    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=20)[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)
-            # 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)
-        try:
-            self.daq_device = uldaq.DaqDevice(devices[0])
-            log.debug(f"Found daq devices {len(devices)}, connecting to the first one")
-            self.daq_device.connect()
-            log.debug("Connected")
-        except IndexError:
-            log.debug("DAQ is not connected, closing")
-            QApplication.quit()
-        self.daq_connect_button.setDisabled(True)
-
-    def disconnect_dac(self):
-        try:
-            log.debug(f"{self.daq_device}")
-            self.daq_device.disconnect()
-            self.daq_device.release()
-            log.debug(f"{self.daq_device}")
-            self.daq_disconnect_button.setDisabled(True)
-            self.daq_connect_button.setEnabled(True)
-        except AttributeError:
-            log.debug("DAQ was not connected")
-
-    def repros_to_toolbar(self):
-        repro_names, file_names = self.repros.names_of_repros()
-        for rep, fn in zip(repro_names, file_names):
-            individual_repro_button = QAction(rep, self)
-            individual_repro_button.setStatusTip("Button")
-            individual_repro_button.triggered.connect(
-                lambda checked, n=rep, f=fn: self.run_repro(n, f)
-            )
-            self.toolbar.addAction(individual_repro_button)
-
-    def run_repro(self, n, fn):
-        log.debug(f"Running repro {n} in the file {fn}")
-        worker = Worker(self.repros.run_repro, self.nix_file, n, fn)
-        worker.signals.result.connect(self.print_output)
-        worker.signals.finished.connect(self.thread_complete)
-        worker.signals.progress.connect(self.progress_fn)
-
-        self.threadpool.start(worker)
-
-    def print_output(self, s):
-        print(s)
-
-    def thread_complete(self):
-        print("THREAD COMPLETE!")
-
-    def progress_fn(self, n):
-        print("%d%% done" % n)
+from pyrelacs import (
+    resources,
+)  # best created with pyside6-rcc resources.qrc -o resources.py (rcc produces an error...)
 
 
 def main():
@@ -188,6 +19,7 @@ def main():
     app.setApplicationName(info.NAME)
     app.setApplicationVersion(str(info.VERSION))
     app.setOrganizationDomain(info.ORGANIZATION)
+    # app.setAttribute(Qt.ApplicationAttribute.AA_DontShowIconsInMenus, False)
 
     # read window settings
     settings = QSettings(info.ORGANIZATION, info.NAME)

pyrelacs/info.py

@@ -3,6 +3,7 @@ import pathlib
 
 
 def load_project_settings(project_root):
+    print(project_root)
     # Read the pyproject.toml file
     with open(pathlib.Path.joinpath(project_root, "pyproject.toml"), "r") as f:
         pyproject_content = f.read()

pyrelacs/repros/calbi.py

@@ -159,87 +159,7 @@ class Calibration(MccDac):
                 unit="s",
             )
 
-            beat = channel1 + channel2
-            beat_square = beat**2
-
-            f, powerspec = welch(beat, fs=self.SAMPLERATE)
-            powerspec = decibel(powerspec)
-
-            f_sq, powerspec_sq = welch(beat_square, fs=self.SAMPLERATE)
-            powerspec_sq = decibel(powerspec_sq)
-            peaks = find_peaks(powerspec_sq, prominence=20)[0]
-
-            f_stim, powerspec_stim = welch(channel1, fs=self.SAMPLERATE)
-            powerspec_stim = decibel(powerspec_stim)
-
-            f_in, powerspec_in = welch(channel2, fs=self.SAMPLERATE)
-            powerspec_in = decibel(powerspec_in)
-
-        #     axes[0, 0].plot(
-        #         t,
-        #         channel1,
-        #         label=f"{db_value} Readout Channel0",
-        #         color=colors[i],
-        #     )
-        #     axes[0, 0].plot(
-        #         t,
-        #         channel2,
-        #         label=f"{db_value} Readout Channel1",
-        #         color=colors_in[i],
-        #     )
-        #
-        #     axes[0, 1].plot(
-        #         f_stim,
-        #         powerspec_stim,
-        #         label=f"{db_value} powerspec Channel0",
-        #         color=colors[i],
-        #     )
-        #     axes[0, 1].plot(
-        #         f_in,
-        #         powerspec_in,
-        #         label=f"{db_value} powerspec Channel2",
-        #         color=colors_in[i],
-        #     )
-        #     axes[0, 1].set_xlabel("Freq [HZ]")
-        #     axes[0, 1].set_ylabel("dB")
-        #
-        #     axes[1, 0].plot(
-        #         t,
-        #         beat,
-        #         label="Beat",
-        #         color=colors[i],
-        #     )
-        #     axes[1, 0].plot(
-        #         t,
-        #         beat**2,
-        #         label="Beat squared",
-        #         color=colors_in[i],
-        #     )
-        #     axes[1, 0].legend()
-        #
-        #     axes[1, 1].plot(
-        #         f,
-        #         powerspec,
-        #         color=colors[i],
-        #     )
-        #     axes[1, 1].plot(
-        #         f_sq,
-        #         powerspec_sq,
-        #         color=colors_in[i],
-        #         label=f"dB {db_value}, first peak {np.min(f_sq[peaks])}",
-        #     )
-        #     axes[1, 1].scatter(
-        #         f_sq[peaks],
-        #         powerspec_sq[peaks],
-        #         color="maroon",
-        #     )
-        #     axes[1, 1].set_xlabel("Freq [HZ]")
-        #     axes[1, 1].set_ylabel("dB")
-        #     axes[0, 0].legend()
-        #     axes[1, 1].legend()
-        # plt.show()
         self.set_analog_to_zero()
-        self.disconnect_dac()
 
 
 def decibel(power, ref_power=1.0, min_power=1e-20):

pyrelacs/repros/repros.py

@@ -1,11 +1,12 @@
 import sys
-import importlib.util
 import ast
 import pathlib
 from typing import Tuple
 
 from IPython import embed
 import nixio as nix
+import importlib.util
+
 from pyrelacs.util.logging import config_logging
 
 log = config_logging()
@@ -24,7 +25,6 @@ class Repro:
     def run_repro(
         self, nix_file: nix.File, name: str, file: pathlib.Path, *args, **kwargs
     ) -> None:
-
         spec = importlib.util.spec_from_file_location("rep", file)
         if not spec:
             log.error("Could not load the file")
@@ -34,7 +34,10 @@ class Repro:
                 log.error("Could not load the module of the repro")
             else:
                 sys.modules[name] = module
-                spec.loader.exec_module(module)
+                if spec.loader is not None:
+                    spec.loader.exec_module(module)
+                else:
+                    log.error(f"{spec.loader} is None")
                 if hasattr(module, name):
                     rep_class = getattr(module, name)
                     rep_class.run(nix_file)

pyrelacs/resources.qrc

@@ -0,0 +1,10 @@
+<!DOCTYPE RCC><RCC version="1.0">
+<qresource>
+    <file>icons/exit.png</file>
+    <file>icons/connect.png</file>
+    <file>icons/disconnect.png</file>
+    <file>icons/record.png</file>
+    <file>icons/stop.png</file>
+    <file>icons/relacstuxheader.png</file>
+</qresource>
+</RCC>

pyrelacs/ui/about.py

@@ -0,0 +1,54 @@
+from PyQt6.QtGui import QPixmap
+from PyQt6.QtWidgets import QDialog, QDialogButtonBox, QLabel, QVBoxLayout, QWidget
+from PyQt6.QtCore import Qt
+
+
+class AboutDialog(QDialog):
+
+    def __init__(self, parent=None) -> None:
+        super().__init__(parent=parent)
+        self.setModal(True)
+        about = About(self)
+        self.setLayout(QVBoxLayout())
+        self.layout().addWidget(about)
+        bbox = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok)
+        bbox.accepted.connect(self.accept)
+        self.layout().addWidget(bbox)
+
+
+class About(QWidget):
+
+    def __init__(self, parent=None) -> None:
+        super().__init__(parent=parent)
+        self.setLayout(QVBoxLayout())
+
+        heading = QLabel("pyRelacs")
+        font = heading.font()
+        font.setPointSize(18)
+        font.setBold(True)
+        heading.setFont(font)
+        heading.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        subheading = QLabel("relacsed electrophysiological recordings")
+        subheading.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        nix_link = QLabel("https://github.com/relacs")
+        nix_link.setOpenExternalLinks(True)
+        nix_link.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        rtd_link = QLabel("https://relacs.net")
+        rtd_link.setOpenExternalLinks(True)
+        rtd_link.setAlignment(Qt.AlignmentFlag.AlignCenter)
+
+        iconlabel = QLabel()
+        pixmap = QPixmap(":/icons/relacstuxheader.png")
+        s = pixmap.size()
+        new_height = int(s.height() * 300/s.width())
+        pixmap = pixmap.scaled(300, new_height, Qt.AspectRatioMode.KeepAspectRatio, Qt.TransformationMode.FastTransformation)
+        iconlabel.setPixmap(pixmap)
+        iconlabel.setMaximumWidth(300)
+        iconlabel.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        iconlabel.setScaledContents(True)
+
+        self.layout().addWidget(heading)
+        self.layout().addWidget(subheading)
+        self.layout().addWidget(iconlabel)
+        self.layout().addWidget(nix_link)
+        self.layout().addWidget(rtd_link)

pyrelacs/ui/mainwindow.py

@@ -0,0 +1,227 @@
+from PyQt6.QtGui import QAction, QIcon, QKeySequence
+from PyQt6.QtCore import Qt, QSize, QThreadPool
+from PyQt6.QtWidgets import (
+    QGridLayout,
+    QPushButton,
+    QToolBar,
+    QWidget,
+    QMainWindow,
+    QPlainTextEdit,
+    QMenuBar,
+    QStatusBar,
+)
+import uldaq
+import numpy as np
+import nixio as nix
+import pyqtgraph as pg
+
+from pathlib import Path as path
+from scipy.signal import welch, find_peaks
+
+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
+
+from IPython import embed
+
+
+class PyRelacs(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setToolButtonStyle(
+            Qt.ToolButtonStyle.ToolButtonTextBesideIcon
+        )  # Ensure icons are displayed with text
+        self.setWindowTitle("PyRelacs")
+
+        self.figure = pg.GraphicsLayoutWidget()
+
+        filename = path.joinpath(path.cwd(), "data.nix")
+        if filename.exists():
+            self.nix_file = nix.File.open(str(filename), nix.FileMode.ReadOnly)
+        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()
+
+        self.text = QPlainTextEdit()
+        self.text.setReadOnly(True)
+
+        self.setMenuBar(QMenuBar(self))
+        self.setStatusBar(QStatusBar(self))
+        self.create_actions()
+        self.create_buttons()
+        self.create_toolbars()
+
+        layout = QGridLayout()
+        layout.addWidget(self.figure, 0, 0, 2, 2)
+        layout.addWidget(self.text, 2, 0, 1, 2)
+
+        widget = QWidget()
+        widget.setLayout(layout)
+        self.setCentralWidget(widget)
+
+    def create_actions(self):
+        self._rlx_exitaction = QAction(QIcon(":/icons/exit.png"), "Exit", self)
+        self._rlx_exitaction.setStatusTip("Close relacs")
+        self._rlx_exitaction.setShortcut(QKeySequence("Alt+q"))
+        self._rlx_exitaction.triggered.connect(self.on_exit)
+
+        self._rlx_aboutaction = QAction("about")
+        self._rlx_aboutaction.setStatusTip("Show about dialog")
+        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.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.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.setStatusTip("Calibrate the attenuator device")
+        # self._daq_calibaction.setShortcut(QKeySequence("Alt+d"))
+        self._daq_calibaction.triggered.connect(self.calibration_plot.plot)
+        self.create_menu()
+
+    def create_menu(self):
+        menu = self.menuBar()
+        if menu is not None:
+            file_menu = menu.addMenu("&File")
+            device_menu = menu.addMenu("&DAQ")
+            help_menu = menu.addMenu("&Help")
+
+            if file_menu is not None:
+                file_menu.addAction(self._rlx_exitaction)
+                file_menu.addAction(self._rlx_aboutaction)
+
+            if device_menu is not None:
+                device_menu.addAction(self._daq_connectaction)
+                device_menu.addAction(self._daq_disconnectaction)
+                device_menu.addSeparator()
+                device_menu.addAction(self._daq_calibaction)
+
+            if help_menu is not None:
+                help_menu.addSeparator()
+                # help_menu.addAction(self._help_action)
+        else:
+            log.error("could not create file menu and device menu")
+            self.on_exit()
+
+        self.setMenuBar(menu)
+
+    def create_toolbars(self):
+        rlx_toolbar = QToolBar("Relacs")
+        rlx_toolbar.addAction(self._rlx_exitaction)
+        rlx_toolbar.setIconSize(QSize(24, 24))
+
+        self.addToolBar(Qt.ToolBarArea.TopToolBarArea, rlx_toolbar)
+        daq_toolbar = QToolBar("DAQ")
+        daq_toolbar.addAction(self._daq_connectaction)
+        daq_toolbar.addAction(self._daq_disconnectaction)
+        daq_toolbar.addAction(self._daq_calibaction)
+        self.addToolBar(Qt.ToolBarArea.TopToolBarArea, daq_toolbar)
+
+        repro_toolbar = QToolBar("Repros")
+        repro_names, file_names = self.repros.names_of_repros()
+        for rep, fn in zip(repro_names, file_names):
+            repro_action = QAction(rep, self)
+            repro_action.setStatusTip(rep)
+            repro_action.triggered.connect(
+                lambda checked, n=rep, f=fn: self.run_repro(n, f)
+            )
+            repro_toolbar.addAction(repro_action)
+        self.addToolBar(Qt.ToolBarArea.TopToolBarArea, repro_toolbar)
+
+    def create_buttons(self):
+        self.daq_connect_button = QPushButton("Connect Daq")
+        self.daq_connect_button.setCheckable(True)
+        self.daq_connect_button.clicked.connect(self.connect_dac)
+
+        self.daq_disconnect_button = QPushButton("Disconnect Daq")
+        self.daq_disconnect_button.setCheckable(True)
+        self.daq_disconnect_button.clicked.connect(self.disconnect_dac)
+
+        self.plot_calibration_button = QPushButton("Plot Calibration")
+        self.plot_calibration_button.setCheckable(True)
+        self.plot_calibration_button.clicked.connect(self.calibration_plot.plot)
+
+    def connect_dac(self):
+        devices = uldaq.get_daq_device_inventory(uldaq.InterfaceType.USB)
+        try:
+            self.daq_device = uldaq.DaqDevice(devices[0])
+            log.debug(f"Found daq devices {len(devices)}, connecting to the first one")
+        except IndexError:
+            log.error("DAQ is not connected")
+            log.error("Please connect a DAQ device to the system")
+
+        if hasattr(PyRelacs, "daq_device"):
+            try:
+                self.daq_device.connect()
+                log.debug("Connected")
+            except uldaq.ul_exception.ULException as e:
+                log.error(f"Could not Connect to DAQ: {e}")
+            self.daq_connect_button.setDisabled(True)
+        else:
+            log.debug("Already handeld the error")
+            pass
+
+    def disconnect_dac(self):
+        try:
+            log.debug(f"{self.daq_device}")
+            self.daq_device.disconnect()
+            self.daq_device.release()
+            log.debug(f"{self.daq_device}")
+            self.daq_disconnect_button.setDisabled(True)
+            self.daq_connect_button.setEnabled(True)
+        except AttributeError:
+            log.debug("DAQ was not connected")
+
+    def run_repro(self, n, fn):
+        self.text.appendPlainText(f"started Repro {n}, {fn}")
+        worker = Worker(self.repros.run_repro, self.nix_file, n, fn)
+        worker.signals.result.connect(self.print_output)
+        worker.signals.finished.connect(self.thread_complete)
+        worker.signals.progress.connect(self.progress_fn)
+
+        self.threadpool.start(worker)
+
+    def add_to_textfield(self, s: str):
+        self.text.appendPlainText(s)
+
+    def on_exit(self):
+        log.info("exit button!")
+        self.add_to_textfield("exiting")
+        self.close()
+
+    def on_about(self, e):
+        about = AboutDialog(self)
+        about.show()
+
+    def print_output(self, s):
+        log.info(s)
+        self.add_to_textfield(s)
+
+    def thread_complete(self):
+        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