pymodaq 4.2.4__py3-none-any.whl → 5.0.0__py3-none-any.whl

pymodaq/extensions/daq_scan.py

@@ -18,40 +18,48 @@ import numpy as np
 from qtpy import QtWidgets, QtCore, QtGui
 from qtpy.QtCore import QObject, Slot, QThread, Signal, QDateTime, QDate, QTime
 
-from pymodaq.utils import data as data_mod
-from pymodaq.utils.logger import set_logger, get_module_name
-from pymodaq.utils.config import Config, get_set_preset_path
-from pymodaq.utils.parameter import ioxml
-from pymodaq.utils.plotting.data_viewers import ViewersEnum
-from pymodaq.utils.managers.parameter_manager import ParameterManager, Parameter, ParameterTree
-
-from pymodaq.utils import exceptions
-from pymodaq.utils.plotting.data_viewers.viewer2D import Viewer2D
-from pymodaq.utils.plotting.data_viewers.viewer1D import Viewer1D
-from pymodaq.utils.plotting.navigator import Navigator
-from pymodaq.utils.plotting.scan_selector import ScanSelector, SelectorItem
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils.config import Config
+from pymodaq_utils import utils
+
+from pymodaq_data import data as data_mod
+from pymodaq_data.h5modules import data_saving
+
+from pymodaq_gui.parameter import ioxml
+from pymodaq_gui.plotting.data_viewers import ViewersEnum
+from pymodaq_gui.managers.parameter_manager import ParameterManager, Parameter, ParameterTree
+from pymodaq_gui.plotting.navigator import Navigator
+
+from pymodaq_gui.messenger import messagebox
+from pymodaq_gui import utils as gutils
+from pymodaq_gui.h5modules.saving import H5Saver
+
 from pymodaq.utils.scanner.scanner import Scanner, scanner_factory  #, adaptive, adaptive_losses
 from pymodaq.utils.managers.batchscan_manager import BatchScanner
 from pymodaq.utils.managers.modules_manager import ModulesManager
 from pymodaq.post_treatment.load_and_plot import LoaderPlotter
-from pymodaq.utils.messenger import messagebox
 from pymodaq.extensions.daq_scan_ui import DAQScanUI
+from pymodaq.utils.h5modules import module_saving
+
+from pymodaq.utils.scanner.scan_selector import ScanSelector, SelectorItem
+from pymodaq.utils.data import DataActuator
 
-from pymodaq.utils import daq_utils as utils
-from pymodaq.utils import gui_utils as gutils
-from pymodaq.utils.h5modules.saving import H5Saver
-from pymodaq.utils.h5modules import module_saving, data_saving
-from pymodaq.utils.data import DataToExport, DataActuator
 
 if TYPE_CHECKING:
     from pymodaq.dashboard import DashBoard
 
 config = Config()
+
 logger = set_logger(get_module_name(__file__))
 
 SHOW_POPUPS = config('scan', 'show_popups')
 
 
+class DAQ_ScanException(Exception):
+    """Raised when an error occur within the DAQScan"""
+    pass
+
+
 class ScanDataTemp:
     """Convenience class to hold temporary data to be plotted in the live plots"""
     def __init__(self, scan_index: int, indexes: Tuple[int], data: data_mod.DataToExport):
@@ -136,15 +144,15 @@ class DAQScan(QObject, ParameterManager):
         self.plot_colors = utils.plot_colors
 
         self.scan_thread: QThread = None
+        self._h5saver: H5Saver = None
+        self._module_and_data_saver: module_saving.ScanSaver = None
 
         self.modules_manager = ModulesManager(self.dashboard.detector_modules, self.dashboard.actuators_modules)
         self.modules_manager.settings.child('data_dimensions').setOpts(expanded=False)
         self.modules_manager.settings.child('actuators_positions').setOpts(expanded=False)
         self.modules_manager.detectors_changed.connect(self.clear_plot_from)
 
-        self.h5saver = H5Saver()
         self.module_and_data_saver = module_saving.ScanSaver(self)
-        self.module_and_data_saver.h5saver = self.h5saver
 
         self.extended_saver: data_saving.DataToExportExtendedSaver = None
         self.h5temp: H5Saver = None
@@ -276,7 +284,7 @@ class DAQScan(QObject, ParameterManager):
                 except Exception as e:
                     logger.exception(str(e))
 
-            self.h5saver.close_file()
+            self.close_file()
             self.mainwindow.close()
 
         except Exception as e:
@@ -384,8 +392,6 @@ class DAQScan(QObject, ParameterManager):
 
     def show_file_content(self):
         try:
-            self.h5saver.init_file(addhoc_file_path=
-                                   self.h5saver.settings.child('current_h5_file').value())
             self.h5saver.show_file_content()
         except Exception as e:
             logger.exception(str(e))
@@ -501,14 +507,42 @@ class DAQScan(QObject, ParameterManager):
     def create_new_file(self, new_file):
         if new_file:
             self._metada_dataset_set = False
-            self.h5saver.close_file()
-        self.h5saver.init_file(update_h5=new_file)
-        self.module_and_data_saver.h5saver = self.h5saver
+            self.close_file()
+
+        self.module_and_data_saver.h5saver = self.h5saver  # force it for detectors to update their h5saver
         res = self.update_file_settings()
         if new_file:
             self.ui.enable_start_stop()
         return res
 
+    @property
+    def h5saver(self):
+        if self._h5saver is None:
+            self._h5saver = H5Saver(backend=config('general', 'hdf5_backend'))
+        if self._h5saver.h5_file is None:
+            self._h5saver.init_file(update_h5=True)
+        if not self._h5saver.isopen():
+            self._h5saver.init_file(addhoc_file_path=self._h5saver.settings['current_h5_file'])
+        return self._h5saver
+
+    @h5saver.setter
+    def h5saver(self, h5saver_temp: H5Saver):
+        self._h5saver = h5saver_temp
+
+    def close_file(self):
+        self.h5saver.close_file()
+
+    @property
+    def module_and_data_saver(self):
+        if not self._module_and_data_saver.h5saver.isopen():
+            self._module_and_data_saver.h5saver = self.h5saver
+        return self._module_and_data_saver
+
+    @module_and_data_saver.setter
+    def module_and_data_saver(self, mod: module_saving.ScanSaver):
+        self._module_and_data_saver = mod
+        self._module_and_data_saver.h5saver = self.h5saver
+
     def update_file_settings(self):
         try:
             res = True
@@ -520,18 +554,6 @@ class DAQScan(QObject, ParameterManager):
                 self.navigator.update_h5file(self.h5saver.h5_file)
                 self.navigator.settings.child('settings', 'filepath').setValue(self.h5saver.h5_file.filename)
 
-            # # set attributes to the current group, such as scan_type....
-            # self.scan_attributes.child('scan_info', 'scan_type').setValue(
-            #     self.scanner.settings.child('scan_type').value())
-            # self.scan_attributes.child('scan_info', 'scan_sub_type').setValue(
-            #     self.scanner.settings.child('scan_sub_type').value())
-            #
-            # scan_node = self.module_and_data_saver.get_set_node()
-            # self.scan_attributes.child('scan_info', 'scan_name').setValue(scan_node.name)
-            # self.scan_attributes.child('scan_info', 'description').setValue('')
-            #
-            # res = self.set_metadata_about_current_scan()
-
             return res
 
         except Exception as e:
@@ -550,6 +572,7 @@ class DAQScan(QObject, ParameterManager):
             scan_name = scan_node.name
         self.scan_attributes.child('scan_info', 'scan_name').setValue(scan_name)
         self.scan_attributes.child('scan_info', 'description').setValue('')
+        self.h5saver.settings.child('current_scan_name').setValue(scan_name)
 
         res = self.set_metadata_about_current_scan()
         return res
@@ -572,7 +595,7 @@ class DAQScan(QObject, ParameterManager):
         positions = [posx, posy]
         positions = positions[:self.scanner.n_axes]
         actuators = self.modules_manager.actuators
-        dte = DataToExport(name="move_at")
+        dte = data_mod.DataToExport(name="move_at")
         for ind, pos in enumerate(positions):
             dte.append(DataActuator(actuators[ind].title, data=float(pos)))
 
@@ -614,54 +637,50 @@ class DAQScan(QObject, ParameterManager):
             data_names.extend(self.settings['plot_options', 'plot_1d']['selected'][:])
         self.live_plotter.prepare_viewers(viewers_enum, viewers_name=data_names)
 
-    def update_status(self, txt, wait_time=0, log_type=None):
-        """
-            Show the txt message in the status bar with a delay of wait_time ms.
+    def update_status(self, txt: str, wait_time=0):
+        """ Show the txt message in the status bar with a delay of wait_time ms.
 
-            =============== =========== =======================
-            **Parameters**    **Type**    **Description**
-            *txt*             string      The message to show
-            *wait_time*       int         the delay of showing
-            *log_type*        string      the type of the log
-            =============== =========== =======================
+        add an info log in the logger
+
+        Parameters
+        ----------
+        txt: str
+            the message to log
+        wait_time: int
+            leave the message apparent in the status bar for this duration in ms
         """
         self.ui.display_status(txt, wait_time)
         self.status_signal.emit(txt)
         logger.info(txt)
 
-    @Slot(list)
-    def thread_status(self, status):  # general function to get datas/infos from all threads back to the main
-        """
-            | General function to get datas/infos from all threads back to the main.
-            |
+    def thread_status(self, status: utils.ThreadCommand):
+        """ General function to get datas/infos from child thread back to the main.
 
-            Switch the status with :
-                * *"Update status"* : Update the status bar with the status attribute txt message
-                * *"Update_scan_index"* : Set the value of the User Interface - indice_scan_sb attribute.
-                * *"Scan_done"* : Save the scan and init the positions
-                * *"Timeout"* : Set the "Timeout occured" in the User Interface-log message
+        Possible commands are:
 
-            See Also
-            --------
-            update_status, save_scan, set_ini_positions
+        * "Update_Status"
+        * "Update_scan_index"
+        * "Scan_done"
+        * "Timeout"
         """
-        if status[0] == "Update_Status":
-            self.update_status(status[1], wait_time=self.wait_time)
+        if status.command == "Update_Status":
+            self.update_status(status.attribute, wait_time=self.wait_time)
 
-        elif status[0] == "Update_scan_index":
+        elif status.command == "Update_scan_index":
             # status[1] = [ind_scan,ind_average]
-            self.ind_scan = status[1][0]
-            self.ui.set_scan_step(status[1][0] + 1)
-            self.ind_average = status[1][1]
-            self.ui.set_scan_step_average(status[1][1] + 1)
+            self.ind_scan = status.attribute[0]
+            self.ui.set_scan_step(status.attribute[0] + 1)
+            self.ind_average = status.attribute[1]
+            self.ui.set_scan_step_average(status.attribute[1] + 1)
 
-        elif status[0] == "Scan_done":
+        elif status.command == "Scan_done":
             self.modules_manager.reset_signals()
             self.live_timer.stop()
             self.ui.set_scan_done()
             scan_node = self.module_and_data_saver.get_last_node()
             scan_node.attrs['scan_done'] = True
             self.module_and_data_saver.flush()
+            self.close_file()
 
             if not self.batch_started:
                 if not self.dashboard.overshoot:
@@ -669,7 +688,7 @@ class DAQScan(QObject, ParameterManager):
                 self.ui.set_action_enabled('ini_positions', True)
                 self.ui.set_action_enabled('start', True)
 
-                # reactivate module controls usiong remote_control
+                # reactivate module controls using remote_control
                 if hasattr(self.dashboard, 'remote_manager'):
                     remote_manager = getattr(self.dashboard, 'remote_manager')
                     remote_manager.activate_all(True)
@@ -679,9 +698,15 @@ class DAQScan(QObject, ParameterManager):
                 self.ind_batch += 1
                 self.loop_scan_batch()
 
-        elif status[0] == "Timeout":
+        elif status.command == "Timeout":
             self.ui.set_permanent_status('Timeout occurred')
 
+        elif status.command == 'add_data':
+            self.module_and_data_saver.add_data(**status.attribute)
+
+        elif status.command == 'add_nav_axes':
+            self.module_and_data_saver.add_nav_axes(status.attribute)
+
     ############
     #  PLOTTING
 
@@ -726,35 +751,36 @@ class DAQScan(QObject, ParameterManager):
 
     def set_scan(self, scan=None) -> bool:
         """
-        Sets the current scan given the selected settings. Makes some checks, increments the h5 file scans.
+        Sets the current scan given the selected settings. Makes some checks,
+        increments the h5 file scans.
         In case the dialog is cancelled, return False and aborts the scan
         """
         try:
-            # set the filename and path
-            if self.h5saver.h5_file is None:  # only the first time start scan is called
-                self.create_new_file(True)
             res = self.update_scan_info()
             if not res:
                 return False
 
             is_oversteps = self.scanner.set_scan()
             if is_oversteps:
-                messagebox(text=f"An error occurred when establishing the scan steps. Actual settings "
-                                f"gives approximately {int(self.scanner.n_steps)} steps."
-                                f" Please check the steps number "
-                                f"limit in the config file ({config['scan']['steps_limit']}) or modify"
-                                f" your scan settings.")
+                messagebox(
+                    text=f"An error occurred when establishing the scan steps. Actual settings "
+                         f"gives approximately {int(self.scanner.n_steps)} steps."
+                         f" Please check the steps number "
+                         f"limit in the config file ({config['scan']['steps_limit']}) or modify"
+                         f" your scan settings.")
 
             if self.modules_manager.Nactuators != self.scanner.n_axes:
-                messagebox(text="There are not enough or too much selected move modules for this scan")
+                messagebox(
+                    text="There are not enough or too much selected move modules for this scan")
                 return False
 
             if self.scanner.scan_sub_type == 'Adaptive':
                 #todo include this in scanners objects for the adaptive scanners
                 if len(self.modules_manager.get_selected_probed_data('0D')) == 0:
-                    messagebox(text="In adaptive mode, you have to pick a 0D signal from which the algorithm will"
-                                    " determine the next positions to scan, see 'probe_data' in the modules selector"
-                                    " panel")
+                    messagebox(
+                        text="In adaptive mode, you have to pick a 0D signal from which the "
+                             "algorithm will determine the next positions to scan, see 'probe_data'"
+                             " in the modules selector panel")
                     return False
 
             self.ui.n_scan_steps = self.scanner.n_steps
@@ -762,11 +788,11 @@ class DAQScan(QObject, ParameterManager):
             # check if the modules are initialized
             for module in self.modules_manager.actuators:
                 if not module.initialized_state:
-                    raise exceptions.DAQ_ScanException('module ' + module.title + " is not initialized")
+                    raise DAQ_ScanException('module ' + module.title + " is not initialized")
 
             for module in self.modules_manager.detectors:
                 if not module.initialized_state:
-                    raise exceptions.DAQ_ScanException('module ' + module.title + " is not initialized")
+                    raise DAQ_ScanException('module ' + module.title + " is not initialized")
 
             self.ui.enable_start_stop(True)
             return True
@@ -831,12 +857,15 @@ class DAQScan(QObject, ParameterManager):
                 remote_manager = getattr(self.dashboard, 'remote_manager')
                 remote_manager.activate_all(False)
 
-            self.module_and_data_saver.h5saver = self.h5saver
             new_scan = self.module_and_data_saver.get_last_node().attrs['scan_done'] # get_last_node
             scan_node = self.module_and_data_saver.get_set_node(new=new_scan)
             self.save_metadata(scan_node, 'scan_info')
 
             self._init_live()
+            for det in self.modules_manager.detectors:
+                det.module_and_data_saver = (
+                    module_saving.DetectorExtendedSaver(det, self.scanner.get_scan_shape()))
+            self.module_and_data_saver.h5saver = self.h5saver  # force the update as the h5saver ill also be set on each detectors
 
             # mandatory to deal with multithreads
             if self.scan_thread is not None:
@@ -849,14 +878,14 @@ class DAQScan(QObject, ParameterManager):
 
             self.scan_thread = QThread()
 
-            scan_acquisition = DAQScanAcquisition(self.settings, self.scanner, self.h5saver.settings,
-                                                  self.modules_manager,
-                                                  module_saver=self.module_and_data_saver)
+            scan_acquisition = DAQScanAcquisition(self.settings, self.scanner, self.modules_manager,
+                                                  )
+
             if config['scan']['scan_in_thread']:
                 scan_acquisition.moveToThread(self.scan_thread)
             self.command_daq_signal[utils.ThreadCommand].connect(scan_acquisition.queue_command)
             scan_acquisition.scan_data_tmp[ScanDataTemp].connect(self.save_temp_live_data)
-            scan_acquisition.status_sig[list].connect(self.thread_status)
+            scan_acquisition.status_sig[utils.ThreadCommand].connect(self.thread_status)
 
             self.scan_thread.scan_acquisition = scan_acquisition
             self.scan_thread.start()
@@ -920,7 +949,7 @@ class DAQScan(QObject, ParameterManager):
         else:
             status = 'Data Acquisition has been stopped due to overshoot'
 
-        self.update_status(status, log_type='log')
+        self.update_status(status)
         self.ui.set_permanent_status('')
 
         self.ui.set_action_enabled('ini_positions', True)
@@ -945,18 +974,17 @@ class DAQScanAcquisition(QObject):
 
     """
     scan_data_tmp = Signal(ScanDataTemp)
-    status_sig = Signal(list)
+    status_sig = Signal(utils.ThreadCommand)
 
     def __init__(self, scan_settings: Parameter = None, scanner: Scanner = None,
-                 h5saver_settings: Parameter = None, modules_manager: ModulesManager = None,
-                 module_saver: module_saving.ScanSaver = None):
+                 modules_manager: ModulesManager = None,):
 
         """
         DAQScanAcquisition deal with the acquisition part of daq_scan, that is transferring commands to modules,
         getting back data, saviong and letting know th UI about the scan status
 
         """
-        
+
         super().__init__()
 
         self.scan_settings = scan_settings
@@ -979,14 +1007,6 @@ class DAQScanAcquisition(QObject):
 
         self.det_done_datas = data_mod.DataToExport('ScanData')
 
-        self.h5saver = H5Saver()
-        self.h5saver.settings.restoreState(h5saver_settings.saveState())
-        self.h5saver.init_file(addhoc_file_path=self.h5saver.settings['current_h5_file'])
-
-        self.module_and_data_saver: module_saving.ScanSaver = module_saver
-
-        # update the DAQ_Viewer's detector saver to DetectorExtendedSaver to take into account extended
-        # arrays due to scan shape and eventual averaging
         scan_shape = self.scanner.get_scan_shape()
         if self.Naverage > 1:
             self.scan_shape = [self.Naverage]
@@ -994,12 +1014,7 @@ class DAQScanAcquisition(QObject):
         else:
             self.scan_shape = scan_shape
 
-        for det in self.modules_manager.detectors:
-            det.module_and_data_saver = module_saving.DetectorExtendedSaver(det, self.scan_shape)
-        self.module_and_data_saver.h5saver = self.h5saver  # will update its h5saver and all submodules's h5saver
-
-    @Slot(utils.ThreadCommand)
-    def queue_command(self, command):
+    def queue_command(self, command: utils.ThreadCommand):
         """Process the commands sent by the main ui
 
         Parameters
@@ -1039,7 +1054,8 @@ class DAQScanAcquisition(QObject):
             Naxes = self.scanner.n_axes
             scan_type = self.scanner.scan_type
             self.navigation_axes = self.scanner.get_nav_axes()
-            self.status_sig.emit(["Update_Status", "Acquisition has started", 'log'])
+            self.status_sig.emit(utils.ThreadCommand("Update_Status",
+                                                     attribute="Acquisition has started"))
 
             self.timeout_scan_flag = False
             for ind_average in range(self.Naverage):
@@ -1068,7 +1084,9 @@ class DAQScanAcquisition(QObject):
                         #     position = (vec.vectorize() * frac_curvilinear).translate_to(vec.p1()).p2()
                         #     positions = [position.x(), position.y()]
 
-                    self.status_sig.emit(["Update_scan_index", [self.ind_scan, ind_average]])
+                    self.status_sig.emit(
+                        utils.ThreadCommand("Update_scan_index",
+                                            attribute=[self.ind_scan, ind_average]))
 
                     if self.stop_scan_flag or self.timeout_scan_flag:
                         break
@@ -1098,16 +1116,15 @@ class DAQScanAcquisition(QObject):
                     # daq_scan wait time
                     QThread.msleep(self.scan_settings.child('time_flow', 'wait_time').value())
 
-            self.h5saver.flush()
             self.modules_manager.connect_actuators(False)
             self.modules_manager.connect_detectors(False)
 
-            self.status_sig.emit(["Update_Status", "Acquisition has finished", 'log'])
-            self.status_sig.emit(["Scan_done"])
+            self.status_sig.emit(utils.ThreadCommand("Update_Status",
+                                                     attribute="Acquisition has finished"))
+            self.status_sig.emit(utils.ThreadCommand("Scan_done"))
 
         except Exception as e:
             logger.exception(str(e))
-            # self.status_sig.emit(["Update_Status", getLineInfo() + str(e), 'log'])
 
     def det_done(self, det_done_datas: data_mod.DataToExport, positions):
         """
@@ -1125,9 +1142,11 @@ class DAQScanAcquisition(QObject):
                         nav_axis.index += 1
                     nav_axes.append(data_mod.Axis('Average', data=np.linspace(0, self.Naverage - 1, self.Naverage),
                                                   index=0))
-                self.module_and_data_saver.add_nav_axes(nav_axes)
+                self.status_sig.emit(utils.ThreadCommand("add_nav_axes", nav_axes))
 
-            self.module_and_data_saver.add_data(indexes=indexes, distribution=self.scanner.distribution)
+            self.status_sig.emit(
+                utils.ThreadCommand("add_data",
+                                    dict(indexes=indexes, distribution=self.scanner.distribution)))
 
             #todo related to adaptive (solution lies along the Enlargeable data saver)
             if self.isadaptive:
@@ -1145,144 +1164,31 @@ class DAQScanAcquisition(QObject):
 
         except Exception as e:
             logger.exception(str(e))
-            # self.status_sig.emit(["Update_Status", getLineInfo() + str(e), 'log'])
 
     def timeout(self):
         """
             Send the status signal *'Time out during acquisition'*.
         """
         self.timeout_scan_flag = True
-        self.status_sig.emit(["Update_Status", "Timeout during acquisition", 'log'])
-        self.status_sig.emit(["Timeout"])
-
-
-
-def main_test(init_qt=True):
-    from pymodaq.utils.data import DataToExport
-
-    LABEL = 'A Label'
-    UNITS = 'units'
-    OFFSET = -20.4
-    SCALING = 0.22
-    SIZE = 20
-    DATA = OFFSET + SCALING * np.linspace(0, SIZE - 1, SIZE)
-
-    DATA0D = np.array([2.7])
-    DATA1D = np.arange(0, 10)
-    DATA2D = np.arange(0, 5 * 6).reshape((5, 6))
-    DATAND = np.arange(0, 5 * 6 * 3).reshape((5, 6, 3))
-
-    def init_axis(data=None, index=0):
-        if data is None:
-            data = DATA
-        return data_mod.Axis(label=LABEL, units=UNITS, data=data, index=index)
-
-    def init_data(data=None, Ndata=1, axes=[], name='myData') -> data_mod.DataWithAxes:
-        if data is None:
-            data = DATA2D
-        return data_mod.DataWithAxes(name, data_mod.DataSource(0), data=[data for ind in range(Ndata)],
-                                     axes=axes)
-
-    class ActuatorMock(QtCore.QObject):
-        mod_name = 'act'
-        move_done_signal = Signal(str, float)
-        command_hardware = Signal(utils.ThreadCommand)
-
-        def __init__(self, ind):
-            super().__init__()
-            self.title = f'{self.mod_name}_{ind:02d}'
-            self.units = f'unit_{ind:02d}'
-            self.initialized_state = True
-            self.module_and_data_saver = module_saving.ActuatorSaver(self)
-            self.settings = Parameter.create(name='settings', type='str', value='mysettings')
-            self.ui = None
-            self.command_hardware.connect(self.move_done)
-
-
-        def move_done(self, command: utils.ThreadCommand):
-            self.move_done_signal.emit(self.title, command.attribute[0])
-
-    class DetectorMock(QtCore.QObject):
-        mod_name = 'det'
-        grab_done_signal = Signal(DataToExport)
-        command_hardware = Signal(utils.ThreadCommand)
-
-        def __init__(self, ind):
-            super().__init__()
-            self.title = f'{self.mod_name}_{ind:02d}'
-            self.initialized_state = True
-            self.module_and_data_saver = module_saving.DetectorSaver(self)
-            self.settings = Parameter.create(name='settings', type='str', value='mysettings')
-            self.ui = None
-            self.command_hardware.connect(self.grab_done)
-
-        def grab_done(self):
-            dat1 = init_data(data=DATA2D, Ndata=2, name=f'{self.title}/data2D')
-            dat2 = init_data(data=DATA1D, Ndata=3, name=f'{self.title}/data1D')
-            data = data_mod.DataToExport(name=f'{self.title}', data=[dat1, dat2])
-            self.grab_done_signal.emit(data)
-
-    class DashBoardTest:
-        def __init__(self):
-            self.title = 'DashBoardTest'
-            self.detector_modules = [DetectorMock(ind) for ind in range(2)]
-            self.actuators_modules = [ActuatorMock(ind) for ind in range(3)]
-
-    if init_qt:  # used for the test suite
-        app = QtWidgets.QApplication(sys.argv)
-        if config['style']['darkstyle']:
-            import qdarkstyle
-            app.setStyleSheet(qdarkstyle.load_stylesheet())
-
-    win = QtWidgets.QMainWindow()
-    area = gutils.dock.DockArea()
-    win.setCentralWidget(area)
-    #win.resize(1000, 500)
-    win.setWindowTitle('PyMoDAQ Dashboard')
-
-    dashboard = DashBoardTest()
-    daq_scan = DAQScan(dockarea=area, dashboard=dashboard)
-    win.show()
-
-    if init_qt:
-        sys.exit(app.exec_())
-    return dashboard, daq_scan, win
-
-
-def main(init_qt=True):
-    if init_qt:  # used for the test suite
-        app = QtWidgets.QApplication(sys.argv)
-        if config['style']['darkstyle']:
-            import qdarkstyle
-            app.setStyleSheet(qdarkstyle.load_stylesheet())
+        self.status_sig.emit(utils.ThreadCommand("Update_Status",
+                                                 attribute="Timeout during acquisition"))
+        self.status_sig.emit(utils.ThreadCommand("Timeout"))
 
-    from pymodaq.dashboard import DashBoard
 
-    win = QtWidgets.QMainWindow()
-    area = gutils.dock.DockArea()
-    win.setCentralWidget(area)
-    win.resize(1000, 500)
-    win.setWindowTitle('PyMoDAQ Dashboard')
-
-    dashboard = DashBoard(area)
-    daq_scan = None
-    file = Path(get_set_preset_path()).joinpath(f"{config('presets', 'default_preset_for_scan')}.xml")
-    if file.exists():
-        dashboard.set_preset_mode(file)
-        daq_scan = dashboard.load_scan_module()
-    else:
-        msgBox = QtWidgets.QMessageBox()
-        msgBox.setText(f"The default file specified in the configuration file does not exists!\n"
-                       f"{file}\n"
-                       f"Impossible to load the DAQScan Module")
-        msgBox.setStandardButtons(msgBox.Ok)
-        ret = msgBox.exec()
-
-    if init_qt:
-        sys.exit(app.exec_())
-    return dashboard, daq_scan, win
+def main():
+    from pymodaq_gui.utils.utils import mkQApp
+    from pymodaq.utils.gui_utils.loader_utils import load_dashboard_with_preset
+
+    app = mkQApp('DAQScan')
+    preset_file_name = config('presets', f'default_preset_for_scan')
+
+    dashboard, extension, win = load_dashboard_with_preset(preset_file_name, 'DAQScan')
+
+    app.exec()
+
+    return dashboard, extension, win
 
 
 if __name__ == '__main__':
     main()
-    #main_test()
+