pymodaq 4.4.7__py3-none-any.whl → 5.0.1__py3-none-any.whl

pymodaq/utils/logger.py

@@ -1,78 +1,6 @@
-# -*- coding: utf-8 -*-
-"""
-Created the 27/10/2022
+from pymodaq_utils.logger import set_logger, get_module_name, get_set_config_dir, get_base_logger
 
-@author: Sebastien Weber
-"""
-import logging
-import warnings
-from logging.handlers import TimedRotatingFileHandler
-from pathlib import Path
+from pymodaq_utils.warnings import deprecation_msg
 
-from pymodaq.utils.config import get_set_config_dir, Config
-
-config = Config()
-
-
-def set_logger(logger_name, add_handler=False, base_logger=False, add_to_console=False, log_level=None,
-               logger_base_name='pymodaq') -> logging.Logger:
-    """defines a logger of a given name and eventually add an handler to it
-
-    Parameters
-    ----------
-    logger_name: (str) the name of the logger (usually it is the module name as returned by get_module_name
-    add_handler (bool) if True adds a TimedRotatingFileHandler to the logger instance (should be True if logger set from
-                main app
-    base_logger: (bool) specify if this is the parent logger (usually where one defines the handler)
-
-    Returns
-    -------
-    logger: (logging.Logger) logger instance
-    See Also
-    --------
-    get_module_name, logging.handlers.TimedRotatingFileHandler
-    """
-    if not base_logger:
-        logger_name = f'{logger_base_name}.{logger_name}'
-
-    logger = logging.getLogger(logger_name)
-    log_path = get_set_config_dir('log', user=True)
-    if log_level is None:
-        log_level = config('general', 'debug_level')
-    logger.setLevel(log_level)
-    if add_handler:
-        log_file_path = log_path.joinpath(f'{logger_base_name}.log')
-        if not log_file_path.is_file():
-            log_file_path.touch(mode=0o777)
-        handler = TimedRotatingFileHandler(log_file_path, when='midnight')
-        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-        handler.setFormatter(formatter)
-        logger.addHandler(handler)
-
-        logging.captureWarnings(True)
-        # only catch DeprecationWarning in DEBUG level
-        if log_level == 'DEBUG':
-            warnings.filterwarnings('default', category=DeprecationWarning)
-        else:
-            warnings.filterwarnings('ignore', category=DeprecationWarning)
-        warnings_logger = logging.getLogger("py.warnings")
-        warnings_logger.addHandler(handler)
-
-    if add_to_console:
-        console_handler = logging.StreamHandler()
-        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-        console_handler.setFormatter(formatter)
-        logger.addHandler(console_handler)
-    return logger
-
-
-def get_base_logger(logger: logging.Logger) -> logging.Logger:
-    while logger.name != 'pymodaq':
-        logger = logger.parent
-    return logger
-
-
-def get_module_name(module__file__path):
-    """from the full path of a module extract its name"""
-    path = Path(module__file__path)
-    return path.stem
+deprecation_msg('Importing logger stuff from pymodaq is deprecated in pymodaq>5.0.0,'
+                'please use the pymodaq_utils package')

pymodaq/utils/managers/batchscan_manager.py

@@ -1,29 +1,26 @@
+from collections import OrderedDict
+from pathlib import Path
+import sys
 from typing import List
 
-import pymodaq.utils.config
-import pymodaq.utils.gui_utils.dock
-import pymodaq.utils.gui_utils.file_io
-import pymodaq.utils.messenger
 from qtpy import QtWidgets, QtCore
-import sys
-import os
 
-from pymodaq.utils.managers.parameter_manager import ParameterManager
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils import config as config_mod
+
+from pymodaq_gui.managers.parameter_manager import ParameterManager
+from pymodaq_gui.utils import Dock, file_io, DockArea
+from pymodaq_gui.parameter import ioxml
+from pymodaq_gui.messenger import messagebox
+
 from pymodaq.utils.managers.modules_manager import ModulesManager
-from pymodaq.utils.gui_utils import Dock
-from pymodaq.utils.logger import set_logger, get_module_name
-from pymodaq.utils import config as config_mod
-from pymodaq.utils.parameter import ioxml
 from pymodaq.utils.scanner import Scanner
 from pymodaq.utils.scanner.scan_factory import ScannerBase
-from pymodaq.utils.scanner.utils import ScanType #, adaptive_losses
-from pathlib import Path
-from collections import OrderedDict
-from pymodaq.utils.messenger import messagebox
+from pymodaq.utils.config import get_set_batch_path
 
 logger = set_logger(get_module_name(__file__))
 
-batch_path = config_mod.get_set_batch_path()
+batch_path = get_set_batch_path()
 
 params = [
     {'title': 'Actuators/Detectors Selection', 'name': 'modules', 'type': 'group', 'children': [
@@ -92,7 +89,7 @@ class BatchManager(ParameterManager):
 
         """
         if filename is None or filename is False:
-            filename = pymodaq.utils.gui_utils.file_io.select_file(start_path=self.batch_path, save=False, ext='xml')
+            filename = file_io.select_file(start_path=self.batch_path, save=False, ext='xml')
             if filename == '':
                 return
 
@@ -301,7 +298,7 @@ class BatchScanner(QtCore.QObject):
 
     def load_file(self, filepath=None):
         if filepath is None:
-            path = pymodaq.utils.gui_utils.file_io.select_file(start_path=batch_path, save=False, ext='xml')
+            path = file_io.select_file(start_path=batch_path, save=False, ext='xml')
             if path != '':
                 filepath = path
             else:
@@ -319,7 +316,7 @@ def main_batch_scanner():
     from pymodaq.control_modules.mocks import MockDAQMove, MockDAQViewer
     app = QtWidgets.QApplication(sys.argv)
     win = QtWidgets.QMainWindow()
-    area = pymodaq.utils.gui_utils.dock.DockArea()
+    area = DockArea()
     win.setCentralWidget(area)
 
     # prog = BatchManager(msgbox=False, actuators=['Xaxis', 'Yaxis'], detectors=['Det0D', 'Det1D'])

pymodaq/utils/managers/modules_manager.py

@@ -5,12 +5,16 @@ from qtpy.QtCore import QObject, Signal, Slot, QThread
 from qtpy import QtWidgets
 import time
 
-from pymodaq.utils.logger import set_logger, get_module_name, get_module_name
-from pymodaq.utils import daq_utils as utils
-from pymodaq.utils.config import Config
-from pymodaq.utils.data import DataToExport, DataFromPlugins, DataActuator
-from pyqtgraph.parametertree import Parameter, ParameterTree
-from pymodaq.utils.managers.parameter_manager import ParameterManager
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils import utils
+from pymodaq_utils.config import Config
+
+from pymodaq_data.data import DataToExport
+
+from pymodaq_gui.managers.parameter_manager import ParameterManager
+from pymodaq_gui.utils import Dock
+
+from pymodaq.utils.data import DataActuator
 
 
 if TYPE_CHECKING:
@@ -35,6 +39,7 @@ class ModulesManager(QObject, ParameterManager):
     selected_actuators: list of DAQ_Move
         sublist of actuators
     """
+    settings_name = 'ModulesManagerSettings'
     detectors_changed = Signal(list)
     actuators_changed = Signal(list)
     det_done_signal = Signal(DataToExport)  # dte here contains DataWithAxes
@@ -113,7 +118,7 @@ class ModulesManager(QObject, ParameterManager):
             modules = [modules]
         return [mod.title for mod in modules]
 
-    def get_mods_from_names(self, names, mod='det'):
+    def get_mods_from_names(self, names, mod='det') -> List[Union['DAQ_Move', 'DAQ_Viewer']]:
         """Getter of a list of given modules from their name (title)
 
         Parameters
@@ -168,9 +173,14 @@ class ModulesManager(QObject, ParameterManager):
 
     @property
     def detectors_all(self):
-        """Get the list of all detectors"""
+        """Get/Set the list of all detectors"""
         return self._detectors
 
+    @detectors_all.setter
+    def detectors_all(self, detectors: List['DAQ_Viewer']):
+        self._detectors = detectors
+
+
     @property
     def actuators(self) -> List['DAQ_Move']:
         """Get the list of selected actuators"""
@@ -181,6 +191,10 @@ class ModulesManager(QObject, ParameterManager):
         """Get the list of all actuators"""
         return self._actuators
 
+    @actuators_all.setter
+    def actuators_all(self, actuators: List['DAQ_Move']):
+        self._actuators = actuators
+
     @property
     def modules(self):
         """Get the list of all detectors and actuators"""
@@ -240,11 +254,11 @@ class ModulesManager(QObject, ParameterManager):
         elif param.name() == 'actuators':
             self.actuators_changed.emit(param.value()['selected'])
 
-    def get_det_data_list(self):
+    def get_det_data_list(self) -> DataToExport:
         """Do a snap of selected detectors, to get the list of all the data and processed data"""
 
         self.connect_detectors()
-        datas: DataToExport = self.grab_datas()
+        datas: DataToExport = self.grab_data()
 
         data_list0D = datas.get_full_names('data0D')
         data_list1D = datas.get_full_names('data1D')
@@ -261,6 +275,7 @@ class ModulesManager(QObject, ParameterManager):
             dict(all_items=data_listND, selected=[]))
 
         self.connect_detectors(False)
+        return datas
 
     def get_selected_probed_data(self, dim='0D'):
         """Get the name of selected data names of a given dimensionality
@@ -272,7 +287,7 @@ class ModulesManager(QObject, ParameterManager):
         """
         return self.settings.child('data_dimensions', f'det_data_list{dim.upper()}').value()['selected']
 
-    def grab_datas(self, **kwargs):
+    def grab_data(self, **kwargs):
         """Do a single grab of connected and selected detectors"""
         self.det_done_datas = DataToExport(name=__class__.__name__, control_module='DAQ_Viewer')
         self._received_data = 0
@@ -296,6 +311,10 @@ class ModulesManager(QObject, ParameterManager):
         self.det_done_signal.emit(self.det_done_datas)
         return self.det_done_datas
 
+    def grab_datas(self, **kwargs):
+        """ For back compatibility but use self.grab_data"""
+        return self.grab_data(**kwargs)
+
     def connect_actuators(self, connect=True, slot=None, signal='move_done'):
         """Connect the selected actuators signal to a given or default slot
 
@@ -478,11 +497,6 @@ class ModulesManager(QObject, ParameterManager):
                 self.det_done_flag = True
                 self.settings.child('det_done').setValue(self.det_done_flag)
 
-        # if data.name not in list(self.det_done_datas.keys()):
-        #     self.det_done_datas[data['name']] = data
-        # if len(self.det_done_datas.items()) == len(self.detectors):
-        #     self.det_done_flag = True
-
 
 if __name__ == '__main__':
     import sys
@@ -490,7 +504,6 @@ if __name__ == '__main__':
     app = QtWidgets.QApplication(sys.argv)
     from qtpy.QtCore import QThread
     from pymodaq.utils.gui_utils import DockArea
-    from pyqtgraph.dockarea import Dock
     from pymodaq.control_modules.daq_viewer import DAQ_Viewer
     from pymodaq.control_modules.daq_move import DAQ_Move
 

pymodaq/utils/managers/overshoot_manager.py

@@ -2,11 +2,9 @@ from qtpy import QtWidgets
 import sys
 import os
 
-from pymodaq.utils.parameter import ioxml
-from pymodaq.utils.parameter import ParameterTree, Parameter
-from pyqtgraph.parametertree.Parameter import registerParameterType
-from pyqtgraph.parametertree.parameterTypes.basetypes import GroupParameter
-from pymodaq.utils.gui_utils import select_file
+from pymodaq_gui.parameter import ioxml, Parameter, ParameterTree
+from pymodaq_gui.parameter.pymodaq_ptypes import registerParameterType, GroupParameter
+from pymodaq_gui.utils import select_file
 
 # check if overshoot_configurations directory exists on the drive
 from pymodaq.utils.config import get_set_overshoot_path
@@ -120,6 +118,8 @@ class OvershootManager:
         self.det_modules = det_modules
         self.actuators_modules = actuators_modules
 
+        self._activated = False
+
         if msgbox:
             msgBox = QtWidgets.QMessageBox()
             msgBox.setText("Overshoot Manager?")
@@ -140,12 +140,21 @@ class OvershootManager:
             else:  # cancel
                 pass
 
+    @property
+    def activated(self) -> bool:
+        return self._activated
+
+    @activated.setter
+    def activated(self, status: bool):
+        self._activated = status
+
     def set_file_overshoot(self, filename, show=True):
         """
 
         """
         children = ioxml.XML_file_to_parameter(filename)
-        self.overshoot_params = Parameter.create(title='Overshoot', name='Overshoot', type='group', children=children)
+        self.overshoot_params = Parameter.create(title='Overshoot', name='Overshoot', type='group',
+                                                 children=children)
         if show:
             self.show_overshoot()
 
@@ -191,6 +200,39 @@ class OvershootManager:
             ioxml.parameter_to_xml_file(
                 self.overshoot_params, os.path.join(overshoot_path, self.overshoot_params.child('filename').value()))
 
+    def activate_overshoot(self, det_modules, act_modules, status: bool):
+        det_titles = [det.title for det in det_modules]
+        move_titles = [move.title for move in act_modules]
+
+        if self.overshoot_params is not None:
+            for det_param in self.overshoot_params.child(
+                    'Detectors').children():
+                if det_param['trig_overshoot']:
+                    det_index = det_titles.index(det_param.opts['title'])
+                    det_module = det_modules[det_index]
+                    det_module.settings.child(
+                        'main_settings', 'overshoot', 'stop_overshoot').setValue(status)
+                    det_module.settings.child(
+                        'main_settings', 'overshoot', 'overshoot_value').setValue(
+                        det_param['overshoot_value'])
+                    for move_param in det_param.child('params').children():
+                        if move_param['move_overshoot']:
+                            move_index = move_titles.index(move_param.opts['title'])
+                            move_module = act_modules[move_index]
+                            if status:
+                                det_module.overshoot_signal.connect(
+                                    self.create_overshoot_fun(
+                                        move_module, move_param['position']))
+                            else:
+                                try:
+                                    det_module.overshoot_signal.disconnect()
+                                except Exception as e:
+                                    pass
+
+    @staticmethod
+    def create_overshoot_fun(move_module, position):
+        return lambda: move_module.move_abs(position)
+
 
 if __name__ == '__main__':
     app = QtWidgets.QApplication(sys.argv)

pymodaq/utils/managers/preset_manager.py

@@ -1,26 +1,27 @@
-from pymodaq.extensions import get_models
-import pymodaq.utils.config
-from pymodaq.utils.logger import set_logger, get_module_name, get_module_name
-from pymodaq.utils.gui_utils.file_io import select_file
-from qtpy import QtWidgets
-import sys
 import os
-from pymodaq.utils.parameter import ParameterTree, Parameter
-from pymodaq.utils.parameter import ioxml
-from pymodaq.utils.messenger import dialog as dialogbox
-from pymodaq.utils import daq_utils as utils
 from pathlib import Path
+import sys
+
+from qtpy import QtWidgets
+
+import pymodaq_utils.config as config_mod
+from pymodaq_utils.logger import set_logger, get_module_name
+
+from pymodaq_gui.utils.file_io import select_file
+from pymodaq_gui.parameter import ParameterTree, Parameter
+from pymodaq_gui.parameter import ioxml
+from pymodaq_gui.messenger import dialog as dialogbox
+from pymodaq.utils import config as config_mod_pymodaq
+from pymodaq.extensions import get_models
+
 import pymodaq.utils.managers.preset_manager_utils  # to register move and det types
 
 logger = set_logger(get_module_name(__file__))
 
 # check if preset_mode directory exists on the drive
-pid_path = pymodaq.utils.config.get_set_pid_path()
-preset_path = pymodaq.utils.config.get_set_preset_path()
-overshoot_path = pymodaq.utils.config.get_set_overshoot_path()
-layout_path = pymodaq.utils.config.get_set_layout_path()
-
-pid_models = [mod['name'] for mod in get_models()]
+preset_path = config_mod_pymodaq.get_set_preset_path()
+overshoot_path = config_mod_pymodaq.get_set_overshoot_path()
+layout_path = config_mod_pymodaq.get_set_layout_path()
 
 
 class PresetManager:
@@ -34,8 +35,8 @@ class PresetManager:
         self.extra_params = extra_params
         self.param_options = param_options
         self.preset_path = path
-        self.preset_params = None
-        self.pid_type = False
+        self.preset_params: Parameter = None
+
         if msgbox:
             msgBox = QtWidgets.QMessageBox()
             msgBox.setText("Preset Manager?")
@@ -56,33 +57,28 @@ class PresetManager:
             else:  # cancel
                 pass
 
+    @property
+    def filename(self) -> str:
+        try:
+            return self.preset_params['filename']
+        except:
+            return None
+
     def set_file_preset(self, filename, show=True):
         """
 
         """
         status = False
-        self.pid_type = False
         children = ioxml.XML_file_to_parameter(filename)
         self.preset_params = Parameter.create(title='Preset', name='Preset', type='group', children=children)
         if show:
             status = self.show_preset()
         return status
 
-    def get_set_pid_model_params(self, model_file):
-        self.preset_params.child('model_settings').clearChildren()
-        model = get_models(model_file)
-        if model is not None:
-            params = model['class'].params
-            self.preset_params.child('model_settings').addChildren(params)
 
     def set_new_preset(self):
-        self.pid_type = False
         param = [
             {'title': 'Filename:', 'name': 'filename', 'type': 'str', 'value': 'preset_default'},
-            {'title': 'Use PID as actuator:', 'name': 'use_pid', 'type': 'bool', 'value': False},
-            # {'title': 'Saving options:', 'name': 'saving_options', 'type': 'group', 'children': H5Saver.params},
-            {'title': 'PID models:', 'name': 'pid_models', 'type': 'list', 'visible': False,
-             'limits': pid_models},
             {'title': 'Model Settings:', 'name': 'model_settings', 'type': 'group', 'visible': False, 'children': []},
         ]
         params_move = [
@@ -98,9 +94,6 @@ class PresetManager:
         except Exception as e:
             logger.exception(str(e))
 
-        if len(pid_models) != 0:
-            self.get_set_pid_model_params(pid_models[0])
-
         self.preset_params.sigTreeStateChanged.connect(self.parameter_tree_changed)
 
         status = self.show_preset()
@@ -125,12 +118,6 @@ class PresetManager:
                         data[0].child('params', 'main_settings', 'module_name').setValue(data[0].child('name').value())
 
             elif change == 'value':
-
-                if param.name() == 'use_pid':
-                    self.preset_params.child('pid_models').show(param.value())
-                    self.preset_params.child('model_settings').show(param.value())
-                if param.name() == 'pid_models' and param.value() != '':
-                    self.get_set_pid_model_params(param.value())
                 if param.name() == 'name':
                     param.parent().child('params', 'main_settings', 'module_name').setValue(param.value())
 
@@ -144,8 +131,8 @@ class PresetManager:
         dialog = QtWidgets.QDialog()
         vlayout = QtWidgets.QVBoxLayout()
         tree = ParameterTree()
-        tree.setMinimumWidth(400)
-        tree.setMinimumHeight(500)
+        # tree.setMinimumWidth(400)
+        # tree.setMinimumHeight(500)
         tree.setParameters(self.preset_params, showTop=False)
 
         vlayout.addWidget(tree)
@@ -161,20 +148,18 @@ class PresetManager:
         dialog.setWindowTitle('Fill in information about this manager')
         res = dialog.exec()
 
-        if self.pid_type:
-            path = pid_path
-        else:
-            path = self.preset_path
+        path = self.preset_path
+        file= None
 
         if res == dialog.Accepted:
             # save managers parameters in a xml file
             # start = os.path.split(os.path.split(os.path.realpath(__file__))[0])[0]
             # start = os.path.join("..",'daq_scan')
-            filename_without_extension = self.preset_params.child('filename').value()
+            filename_without_extension = self.filename
 
             try:
                 ioxml.parameter_to_xml_file(self.preset_params,
-                                            os.path.join(path, filename_without_extension),
+                                            path.joinpath(filename_without_extension),
                                             overwrite=False)
             except FileExistsError as currenterror:
                 # logger.warning(str(currenterror)+"File " + filename_without_extension + ".xml exists")
@@ -183,24 +168,19 @@ class PresetManager:
                                         message="File exist do you want to overwrite it ?")
                 if user_agreed:
                     ioxml.parameter_to_xml_file(self.preset_params,
-                                                os.path.join(path, filename_without_extension))
+                                                path.joinpath(filename_without_extension))
                     logger.warning(f"File {filename_without_extension}.xml overwriten at user request")
                 else:
                     logger.warning(f"File {filename_without_extension}.xml wasn't saved at user request")
                     # emit status signal to dashboard to write : did not save ?
                 pass
 
-            if not self.pid_type:
-                # check if overshoot configuration and layout configuration with same name exists => delete them if yes
-                file = os.path.splitext(self.preset_params.child('filename').value())[0]
-                file = os.path.join(overshoot_path, file + '.xml')
-                if os.path.isfile(file):
-                    os.remove(file)
-
-                file = os.path.splitext(self.preset_params.child('filename').value())[0]
-                file = os.path.join(layout_path, file + '.dock')
-                if os.path.isfile(file):
-                    os.remove(file)
+            # check if overshoot configuration and layout configuration with same name exists => delete them if yes
+            over_shoot_file = overshoot_path.joinpath(self.filename + '.xml')
+            over_shoot_file.unlink(missing_ok=True)
+
+            layout_file = layout_path.joinpath(self.filename + '.dock')
+            layout_file.unlink(missing_ok=True)
 
         return res == dialog.Accepted
 

pymodaq/utils/managers/preset_manager_utils.py

@@ -1,19 +1,22 @@
 import random
 
-from pymodaq.utils.logger import set_logger, get_module_name
-from pymodaq.utils import daq_utils as utils
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils import utils
+
+from pymodaq_gui.parameter.pymodaq_ptypes import registerParameterType, GroupParameter
+from pymodaq_gui.parameter.utils import get_param_dict_from_name
+
 from pymodaq.control_modules.move_utility_classes import params as daq_move_params
 from pymodaq.control_modules.viewer_utility_classes import params as daq_viewer_params
+from pymodaq.utils.daq_utils import get_plugins
 
-from pyqtgraph.parametertree.Parameter import registerParameterType
-from pyqtgraph.parametertree.parameterTypes.basetypes import GroupParameter
 logger = set_logger(get_module_name(__file__))
 
-DAQ_Move_Stage_type = utils.get_plugins('daq_move')
-DAQ_0DViewer_Det_types = utils.get_plugins('daq_0Dviewer')
-DAQ_1DViewer_Det_types = utils.get_plugins('daq_1Dviewer')
-DAQ_2DViewer_Det_types = utils.get_plugins('daq_2Dviewer')
-DAQ_NDViewer_Det_types = utils.get_plugins('daq_NDviewer')
+DAQ_Move_Stage_type = get_plugins('daq_move')
+DAQ_0DViewer_Det_types = get_plugins('daq_0Dviewer')
+DAQ_1DViewer_Det_types = get_plugins('daq_1Dviewer')
+DAQ_2DViewer_Det_types = get_plugins('daq_2Dviewer')
+DAQ_NDViewer_Det_types = get_plugins('daq_NDviewer')
 
 
 def iterative_show_pb(params):
@@ -74,20 +77,23 @@ class PresetScalableGroupMove(GroupParameter):
         for main_child in params:
             if main_child['name'] == 'move_settings':
                 main_child['children'] = params_hardware
+                controller_dict = get_param_dict_from_name(params_hardware, 'controller_ID')
+                controller_dict['value'] = random.randint(0, 9999)
+
             elif main_child['name'] == 'main_settings':
-                for child in main_child['children']:
-                    if child['name'] == 'move_type':
-                        child['value'] = typ
-                    if child['name'] == 'controller_ID':
-                        child['value'] = random.randint(0, 9999)
+                typ_dict = get_param_dict_from_name(main_child['children'], 'move_type')
+                typ_dict['value'] = typ
 
-        child = {'title': 'Actuator {:02.0f}'.format(newindex), 'name': f'{name_prefix}{newindex:02.0f}',
+        child = {'title': 'Actuator {:02.0f}'.format(newindex),
+                 'name': f'{name_prefix}{newindex:02.0f}',
                  'type': 'group',
-                 'removable': True, 'children': [
-                {'title': 'Name:', 'name': 'name', 'type': 'str', 'value': 'Move {:02.0f}'.format(newindex)},
-                {'title': 'Init?:', 'name': 'init', 'type': 'bool', 'value': True},
-                {'title': 'Settings:', 'name': 'params', 'type': 'group', 'children': params
-                 }], 'removable': True, 'renamable': False}
+                 'removable': True, 'renamable': False,
+                 'children': [
+                     {'title': 'Name:', 'name': 'name', 'type': 'str',
+                      'value': 'Move {:02.0f}'.format(newindex)},
+                     {'title': 'Init?:', 'name': 'init', 'type': 'bool', 'value': True},
+                     {'title': 'Settings:', 'name': 'params', 'type': 'group', 'children': params},
+                 ]}
 
         self.addChild(child)
 
@@ -153,8 +159,6 @@ class PresetScalableGroupDet(GroupParameter):
                             child['value'] = typ[6:]
                         if child['name'] == 'controller_status':
                             child['visible'] = True
-                        if child['name'] == 'controller_ID':
-                            child['value'] = random.randint(0, 9999)
 
             if '0D' in typ:
                 parent_module = utils.find_dict_in_list_from_key_val(DAQ_0DViewer_Det_types, 'name', typ[6:])
@@ -184,6 +188,8 @@ class PresetScalableGroupDet(GroupParameter):
                             main_child['children'].remove(child)
 
                     main_child['children'].extend(params_hardware)
+            controller_dict = get_param_dict_from_name(main_child['children'], 'controller_ID')
+            controller_dict['value'] = random.randint(0, 9999)
 
             child = {'title': 'Det {:02.0f}'.format(newindex), 'name': f'{name_prefix}{newindex:02.0f}',
                      'type': 'group', 'children': [