cosmetics

.gitignore

@@ -162,7 +162,4 @@ cython_debug/
 #.idea/
 
 # ignore created data files
-*.nix
-
-# ignore reource.py as it is created by pyside6-rcc resources.qrc -o resources.py
-resources.py
+*.nix

README.md

@@ -5,13 +5,9 @@ Relaxed ELectrophysiology Acquisition, Control, and Stimulation in python
 Implementing [relacs](https://github.com/relacs/relacs) with MCC USB 1608GX-2AO / 1808X devices ([multifunction-usb-daq-devices](https://digilent.com/shop/mcc-daq/data-acquisition/low-cost-daq/))
 
 # Installation 
-You have to install the MCC library (follow the installing instructions for [linux/macOS](https://github.com/mccdaq/uldaq) or [windows](https://github.com/mccdaq/mcculw)).
+You have to install the MCC library (follow the installing instructions for [linux](https://github.com/mccdaq/uldaq) or [windows](https://github.com/mccdaq/mcculw)). 
 
-For MacOs if you run into problems with the libusb library if installed with homebrew, there is an issue thread on the uldaq repository.
-
-[https://github.com/mccdaq/uldaq/issues/44](https://github.com/mccdaq/uldaq/issues/44)
-
-After successful installing, you can use clone the repository and install it with
+After successful installing, you can use clone the reposity and install it with 
 
 ```sh
 pip install -e .

pyrelacs/app.py

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

pyrelacs/devices/mccdac.py

@@ -12,32 +12,13 @@ log = config_logging()
 
 
 class MccDac:
-    """
-    Represents the Digital/Analog Converter from Meassuring Computing.
-    provides methods for writing and reading the Analog / Digital input and output.
-
-    Connects to the DAC device.
-
-    Attributes
-    ----------
-    daq_device : uldaq.DaqDevice
-        DaqDevice for handling connecting, releasing and disconnecting
-    ai_device : uldaq.AiDevice
-        The Analog input Device
-    ao_device :
-        Analog output Device
-    dio_device :
-        Digital Input Output
-    """
-
     def __init__(self) -> None:
         devices = uldaq.get_daq_device_inventory(uldaq.InterfaceType.USB)
         log.debug(f"Found daq devices {len(devices)}, connecting to the first one")
-        try:
-            self.daq_device = uldaq.DaqDevice(devices[0])
-        except uldaq.ul_exception.ULException as e:
+        if len(devices) == 0:
             log.error("Did not found daq devices, please connect one")
-            raise e
+            exit(1)
+        self.daq_device = uldaq.DaqDevice(devices[0])
         try:
             self.daq_device.connect()
         except uldaq.ul_exception.ULException:
@@ -49,10 +30,6 @@ class MccDac:
         log.debug("Connected")
 
     def connect_dac(self):
-        """
-        Connecting to the DAQ device
-
-        """
         devices = uldaq.get_daq_device_inventory(uldaq.InterfaceType.USB)
         log.debug(f"Found daq devices {len(devices)}, connecting to the first one")
         if len(devices) == 0:
@@ -75,40 +52,6 @@ class MccDac:
         ScanOption: uldaq.ScanOption = uldaq.ScanOption.DEFAULTIO,
         AInScanFlag: uldaq.AInScanFlag = uldaq.AInScanFlag.DEFAULT,
     ) -> Array[c_double]:
-        """
-        Reading the analog input of the DAC device
-        Creates a c_double Array for storing the acquired data
-
-        Parameters
-        ----------
-        channels : list[int]
-            channels to read from, provide only two int's in a list (ex [0, 1] or [0, 4])
-            for sampling from the range(channel0, channel4)
-
-        duration : int
-            duration of sampling period
-
-        samplerate : float
-            samplerate for the duration of sampling
-
-        AiInputMode : uldaq.AiInputMode = uldaq.AiInputMode.SINGLE_ENDED
-            Contains attributes indicating A/D channel input modes.
-            Compares to Ground
-
-        Range : uldaq.Range = uldaq.Range.BIP10VOLTS
-            Range of the output
-
-        ScanOption : uldaq.ScanOption = uldaq.ScanOption.DEFAULTIO
-            Specific Flags for acuiring the input
-
-        AInScanFlag : uldaq.AInScanFlag = uldaq.AInScanFlag.DEFAULT
-            Scaling of the data
-
-        Returns
-        -------
-        Array[c_double]
-
-        """
         assert len(channels) == 2, log.error("You can only provide two channels [0, 1]")
 
         if channels[0] != channels[1]:
@@ -142,37 +85,6 @@ class MccDac:
         ScanOption: uldaq.ScanOption = uldaq.ScanOption.DEFAULTIO,
         AOutScanFlag: uldaq.AOutScanFlag = uldaq.AOutScanFlag.DEFAULT,
     ) -> Array[c_double]:
-        """
-        Writes data to the DAC device.
-        Creates a c_double Array for writing the data
-
-        Parameters
-        ----------
-        data : Union[list, npt.NDArray]
-            data which should be written to the DAC
-
-        channels : list[int]
-            channels to read from, provide only two int's in a list (ex [0, 1])
-            for sampling from the range(channel0, channel1)
-            DAC USB 1608GX-2AO has only 2 output channels
-
-        samplerate : float
-            samplerate for the duration of sampling
-
-        Range : uldaq.Range = uldaq.Range.BIP10VOLTS
-            Range of the output
-
-        ScanOption : uldaq.ScanOption = uldaq.ScanOption.DEFAULTIO
-            Specific Flags for acuiring the input
-
-        AOutScanFlag : uldaq.AOutScanFlag = uldaq.AOutScanFlag.DEFAULT
-            For Scaling the data
-
-        Returns
-        -------
-        Array[c_double]
-        """
-
         assert len(channels) == 2, log.error("You can only provide two channels [0, 1]")
 
         buffer = c_double * len(data)
@@ -197,18 +109,7 @@ class MccDac:
 
         return data_analog_output
 
-    def set_analog_to_zero(self, channels: list[int] = [0, 1]) -> None:
-        """
-        Sets all analog outputs to zero
-
-        Parameters
-        ----------
-        channels : list[int]
-            channels to read from, provide only two int's in a list (ex [0, 1])
-            for sampling from the range(channel0, channel1)
-            DAC USB 1608GX-2AO has only 2 output channels
-
-        """
+    def set_analog_to_zero(self, channels: list[int] = [0, 1]):
         try:
             err = self.ao_device.a_out_list(
                 channels[0],
@@ -225,37 +126,16 @@ class MccDac:
             log.error("disconnection dac")
             self.disconnect_dac()
 
-    def digital_trigger(self, ch: int = 0) -> None:
-        """
-        Writes a 1 to a specified digital channel, if the channel is already on 1 switches it to
-        0 and after Nano second it writes a 1 to the specified digital channel
-
-        Parameters
-        ----------
-        ch : int
-            Channel to trigger
-        """
-        data = self.read_bit(channel=ch)
+    def diggital_trigger(self) -> None:
+        data = self.read_bit(channel=0)
         if data:
-            self.write_bit(channel=ch, bit=0)
+            self.write_bit(channel=0, bit=0)
             time.time_ns()
-            self.write_bit(channel=ch, bit=1)
+            self.write_bit(channel=0, bit=1)
         else:
-            self.write_bit(channel=ch, bit=1)
+            self.write_bit(channel=0, bit=1)
 
     def write_bit(self, channel: int = 0, bit: int = 1) -> None:
-        """
-        Writes a 0 / 1 to a specified digitial channel
-
-        Parameters
-        ----------
-        channel : int
-            Digital channel to write
-
-        bit : int
-            0 / 1 for writing to the digital channel
-
-        """
         self.dio_device.d_config_bit(
             uldaq.DigitalPortType.AUXPORT, channel, uldaq.DigitalDirection.OUTPUT
         )
@@ -263,36 +143,55 @@ class MccDac:
             uldaq.DigitalPortType.AUXPORT, bit_number=channel, data=bit
         )
 
-    def read_bit(self, channel: int = 0) -> int:
-        """
-        Reads a 0 / 1 from the specified digital channel
-
-        Parameters
-        ----------
-        channel : int
-            Digital channel to read from
-
-        Returns
-        -------
-        bit : int
-            0 or 1 from the digital channel
-        """
+    def read_bit(self, channel: int = 0):
         bit = self.dio_device.d_bit_in(uldaq.DigitalPortType.AUXPORT, channel)
         return bit
 
+    def read_digitalio(
+        self,
+        channels: list[int],
+        duration,
+        samplerate,
+        ScanOptions: uldaq.ScanOption = uldaq.ScanOption.DEFAULTIO,
+        DInScanFlag: uldaq.DInScanFlag = uldaq.DInScanFlag.DEFAULT,
+    ):
+        if channels[0] == channels[1]:
+            channel_len = 1
+        else:
+            channel_len = len(channels)
+
+        buffer_len = np.shape(np.arange(0, duration, 1 / samplerate))[0]
+        data_digital_input = uldaq.create_int_buffer(channel_len, buffer_len)
+
+        self.dio_device.d_config_port(
+            uldaq.DigitalPortType.AUXPORT, uldaq.DigitalDirection.INPUT
+        )
+        scan_rate = self.dio_device.d_in_scan(
+            uldaq.DigitalPortType.AUXPORT0,
+            uldaq.DigitalPortType.AUXPORT0,
+            len(data_digital_input),
+            samplerate,
+            ScanOptions,
+            DInScanFlag,
+            data_digital_input,
+        )
+        return data_digital_input
+
     def disconnect_dac(self):
         self.daq_device.disconnect()
         self.daq_device.release()
 
-    def check_attenuator(self) -> None:
+    def check_attenuator(self):
         """
-        For checking the attenuator in the DAC device that was implemented to attenuate the
-        analog signal to mV.
-
-        Writes to Channel 0 of the analog output with different attenuation levels
-        0, 0, -2, -5, -10, -20, -50 dB and the second 0 has a software mute
-
+        ident     : attdev-1
+        strobepin : 6
+        datainpin : 5
+        dataoutpin: -1
+        cspin     : 4
+        mutepin   : 7
+        zcenpin   : -1
         """
+
         SAMPLERATE = 40_000.0
         DURATION = 5
         AMPLITUDE = 1
@@ -302,6 +201,7 @@ class MccDac:
         # data_channels = np.concatenate((data, data))
 
         db_values = [0, 0, -2, -5, -10, -20, -50]
+        db_values = [0, -10, -20]
         for i, db_value in enumerate(db_values):
             log.info(f"Attenuating the Channels, with {db_value}")
             if i == 1:
@@ -319,7 +219,7 @@ class MccDac:
                 ScanOption=uldaq.ScanOption.EXTTRIGGER,
                 Range=uldaq.Range.BIP10VOLTS,
             )
-            self.digital_trigger()
+            self.diggital_trigger()
 
             try:
                 self.ao_device.scan_wait(uldaq.WaitType.WAIT_UNTIL_DONE, 15)
@@ -348,16 +248,6 @@ class MccDac:
         mute_channel2: bool = False,
     ):
         """
-        Setting the attenuation level of the chip that is connected to the DAQ
-        The attenuation level is set by writing to the connected digital output pin 5
-        where the strobepin 6 is signaling the when the bit was send.
-        The cspin is set from 1 to 0 for the start and 0 to 1 for signaling the end
-        of the data write process.
-
-        The mute pin should be set to 1 for the device to be working.
-
-        More information in the AttCS3310.pdf in the doc
-
         ident     : attdev-1
         strobepin : 6
         datainpin : 5
@@ -365,23 +255,8 @@ class MccDac:
         cspin     : 4
         mutepin   : 7
         zcenpin   : -1
-
-        Parameters
-        ----------
-        db_channel1 : float
-            dB Attenuation level for the first channel
-
-        db_channel2 : float
-            dB Attenuation level for the second channel
-
-        mute_channel1 : bool
-            Software mute for the first channel
-
-        mute_channel2 : bool
-            Software mute for the second channel
-
-
         """
+
         self.activate_attenuator()
         hardware_possible_db = np.arange(-95.5, 32.0, 0.5)
         byte_number = np.arange(1, 256)
@@ -408,18 +283,9 @@ class MccDac:
         self.write_bit(channel=4, bit=1)
 
     def activate_attenuator(self):
-        """
-        Activation of the attenuator, where the cspin and mute pin is set to 1,
-        and the datapin and strobpin to 0
-
-        """
         for ch, b in zip([4, 5, 6, 7], [1, 0, 0, 1]):
             self.write_bit(channel=ch, bit=b)
 
     def deactivate_attenuator(self):
-        """
-        Writes a 0 to the mute pin, which is deactivating the attenuator
-
-        """
         # mute should be enabled for starting calibration
         self.write_bit(channel=7, bit=0)

pyrelacs/repros/calbi.py

@@ -1,3 +1,5 @@
+import signal
+import sys
 import faulthandler
 import time
 
@@ -6,14 +8,13 @@ import uldaq
 from IPython import embed
 import numpy as np
 import matplotlib.pyplot as plt
-from scipy.signal import welch
+from scipy.signal import welch, csd
 from scipy.signal import find_peaks
 
 from pyrelacs.devices.mccdac import MccDac
 from pyrelacs.util.logging import config_logging
 
 log = config_logging()
-# for more information on seg faults
 faulthandler.enable()
 
 
@@ -59,7 +60,7 @@ class Calibration(MccDac):
             time.sleep(1)
 
             log.debug("Starting the Scan")
-            self.digital_trigger()
+            self.diggital_trigger()
 
             try:
                 self.ao_device.scan_wait(uldaq.WaitType.WAIT_UNTIL_DONE, 15)
@@ -108,7 +109,7 @@ class Calibration(MccDac):
                 self.SAMPLERATE,
                 ScanOption=uldaq.ScanOption.EXTTRIGGER,
             )
-            self.digital_trigger()
+            self.diggital_trigger()
             log.info(self.ao_device)
             ai_status = uldaq.ScanStatus.RUNNING
             ao_status = uldaq.ScanStatus.RUNNING
@@ -132,20 +133,15 @@ class Calibration(MccDac):
             channel1 = np.array(readout[::2])
             channel2 = np.array(readout[1::2])
 
-            stim_data = block.create_data_array(
+            block.create_data_array(
                 f"stimulus_{db_value}",
-                "nix.regular_sampled",
+                "Array",
                 shape=data.shape,
                 data=channel1,
                 label="Voltage",
                 unit="V",
             )
-            stim_data.append_sampled_dimension(
-                self.SAMPLERATE,
-                label="time",
-                unit="s",
-            )
-            fish_data = block.create_data_array(
+            block.create_data_array(
                 f"fish_{db_value}",
                 "Array",
                 shape=data.shape,
@@ -153,13 +149,88 @@ class Calibration(MccDac):
                 label="Voltage",
                 unit="V",
             )
-            fish_data.append_sampled_dimension(
-                self.SAMPLERATE,
-                label="time",
-                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,24 +1,15 @@
 import sys
 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()
 
+from IPython import embed
 
 class Repro:
-    """
-    Repro Class that searches in the repro folder for classes instances and executes the
-    the run function in the searched class
-
-    """
-
     def __init__(self) -> None:
         pass
 
@@ -34,27 +25,14 @@ class Repro:
                 log.error("Could not load the module of the repro")
             else:
                 sys.modules[name] = module
-                if spec.loader is not None:
-                    spec.loader.exec_module(module)
-                else:
-                    log.error(f"{spec.loader} is None")
+                spec.loader.exec_module(module)
                 if hasattr(module, name):
                     rep_class = getattr(module, name)
                     rep_class.run(nix_file)
                 else:
                     raise AttributeError(f"{file.name} has no {name} class")
 
-    def names_of_repros(self) -> Tuple[list, list]:
-        """
-        Searches for class names in the repro folder in all python files
-
-        Returns
-        -------
-        Tuple[list, list]
-            list of class names
-            list of file names from the class names
-        """
-
+    def names_of_repros(self):
         file_path_cur = pathlib.Path(__file__).parent
         python_files = list(file_path_cur.glob("**/*.py"))
         exclude_files = ["repros.py", "__init__.py"]

pyrelacs/resources.qrc

@@ -5,6 +5,5 @@
     <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

@@ -1,3 +1,5 @@
+import pathlib
+
 from PyQt6.QtGui import QPixmap
 from PyQt6.QtWidgets import QDialog, QDialogButtonBox, QLabel, QVBoxLayout, QWidget
 from PyQt6.QtCore import Qt
@@ -38,7 +40,8 @@ class About(QWidget):
         rtd_link.setAlignment(Qt.AlignmentFlag.AlignCenter)
 
         iconlabel = QLabel()
-        pixmap = QPixmap(":/icons/relacstuxheader.png")
+        _root = pathlib.Path(__file__).parent.parent
+        pixmap = QPixmap(str(pathlib.Path.joinpath(_root, "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)

pyrelacs/ui/mainwindow.py

@@ -8,7 +8,7 @@ from PyQt6.QtWidgets import (
     QMainWindow,
     QPlainTextEdit,
     QMenuBar,
-    QStatusBar,
+    QStatusBar
 )
 import uldaq
 import numpy as np
@@ -18,35 +18,22 @@ 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
-
+from ..worker import Worker
+from ..repros.repros import Repro
+from ..util.logging import config_logging
+from .about import AboutDialog
 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.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.setMinimumSize(1000, 1000)
+        self.plot_graph = pg.PlotWidget()
 
         self.threadpool = QThreadPool()
         self.repros = Repro()
@@ -61,70 +48,61 @@ class PyRelacs(QMainWindow):
         self.create_toolbars()
 
         layout = QGridLayout()
-        layout.addWidget(self.figure, 0, 0, 2, 2)
-        layout.addWidget(self.text, 2, 0, 1, 2)
-
+        layout.addWidget(self.plot_calibration_button, 0, 0)
+        layout.addWidget(self.daq_disconnect_button, 0, 1)
+        layout.addWidget(self.text, 3, 0, 1, 2)
+        layout.addWidget(self.plot_graph, 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.Overwrite
+        )
+
     def create_actions(self):
-        self._rlx_exitaction = QAction(QIcon(":/icons/exit.png"), "Exit", self)
+        self._rlx_exitaction = QAction(QIcon(str(path.joinpath(_root, "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 = QAction(QIcon(str(path.joinpath(_root, "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(str(path.joinpath(_root, "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(str(path.joinpath(_root, "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._daq_calibaction.triggered.connect(self.plot_calibration)
         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")
+        file_menu = menu.addMenu("&File")
+        file_menu.addAction(self._rlx_exitaction)
+        file_menu.addAction(self._rlx_aboutaction)
 
-            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()
+        device_menu = menu.addMenu("&DAQ")
+        device_menu.addAction(self._daq_connectaction)
+        device_menu.addAction(self._daq_disconnectaction)
+        device_menu.addSeparator()
+        device_menu.addAction(self._daq_calibaction)
 
+        help_menu = menu.addMenu("&Help")
+        help_menu.addSeparator()
+        # help_menu.addAction(self._help_action)
         self.setMenuBar(menu)
 
     def create_toolbars(self):
@@ -161,27 +139,76 @@ class PyRelacs(QMainWindow):
 
         self.plot_calibration_button = QPushButton("Plot Calibration")
         self.plot_calibration_button.setCheckable(True)
-        self.plot_calibration_button.clicked.connect(self.calibration_plot.plot)
+        self.plot_calibration_button.clicked.connect(self.plot_calibration)
+
+    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]
+        for stim, fish in 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()
+            self.plot_graph.plot(
+                np.arange(0, len(beat)) / 40_000.0, beat_squared, pen=pen
+            )
 
     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.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
+            log.debug("DAQ is not connected, closing")
+            self.on_exit()
+        self.daq_connect_button.setDisabled(True)
 
     def disconnect_dac(self):
         try:
@@ -194,6 +221,16 @@ class PyRelacs(QMainWindow):
         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):
         self.text.appendPlainText(f"started Repro {n}, {fn}")
         worker = Worker(self.repros.run_repro, self.nix_file, n, fn)
@@ -203,25 +240,19 @@ class PyRelacs(QMainWindow):
 
         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")
+        print("exit button!")
         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)
+        print(s)
 
     def thread_complete(self):
-        log.info("Thread complete!")
-        self.add_to_textfield("Thread complete!")
+        print("THREAD COMPLETE!")
 
     def progress_fn(self, n):
-        print("%d%% done" % n)
+        print("%d%% done" % n)

pyrelacs/ui/plots/calibration.py

@@ -1,113 +0,0 @@
-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