pymodaq 3.6.13__py3-none-any.whl → 4.0.1__py3-none-any.whl

pymodaq/utils/scanner/__init__.py

@@ -0,0 +1,10 @@
+from importlib import import_module
+from pathlib import Path
+
+here = Path(__file__).parent.joinpath('scanners')
+for path in here.iterdir():
+    if path.is_file():
+        import_module(f'.{path.stem}', 'pymodaq.utils.scanner.scanners')
+
+
+from .scanner import Scanner  # import this one after the scanners because they have to first be registered

pymodaq/utils/scanner/scan_factory.py

@@ -0,0 +1,204 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 05/12/2022
+
+@author: Sebastien Weber
+"""
+from __future__ import annotations
+
+from abc import ABCMeta, abstractmethod
+from typing import Callable, Union, List, Tuple, TYPE_CHECKING
+
+
+import numpy as np
+
+from pymodaq.utils.managers.parameter_manager import ParameterManager, Parameter
+from pymodaq.utils.factory import ObjectFactory
+from pymodaq.utils.logger import set_logger, get_module_name
+from pymodaq.utils.data import Axis, DataDistribution
+from pymodaq.utils.abstract import abstract_attribute
+from pymodaq.utils import math_utils as mutils
+from pymodaq.utils import config as configmod
+
+if TYPE_CHECKING:
+    from pymodaq.control_modules.daq_move import DAQ_Move
+    from pymodaq.utils.plotting.scan_selector import Selector
+
+
+logger = set_logger(get_module_name(__file__))
+config = configmod.Config()
+
+
+class ScanParameterManager(ParameterManager):
+    settings_name = 'scanner_settings'
+
+    def __init__(self):
+        super().__init__()
+        self.settings_tree.header().setVisible(False)
+        self.settings_tree.setMinimumHeight(150)
+
+
+class ScannerBase(ScanParameterManager, metaclass=ABCMeta):
+    """Abstract class for all Scanners
+
+    Attributes
+    ----------
+    params: List[dict]
+        list specifying the scanner set of parameters to properly configure all the scan steps
+    positions: np.ndarray
+        ndarray of all positions. First dimension is number of actuators, second is positions of a given actuator at
+        each step
+    axes_unique: List[np.ndarray]
+        list of ndarrays representing unique values of steps for each actuator in the scan
+    axes_indexes: np.ndarray
+        ndarray of indexes from axes_unique for each value in positions
+    n_steps: int
+        Number of scan steps. Equal to the second dimension of positions
+    n_axes: int
+        Number of actuators/scan axes. Equal to the first dimension of positions
+    """
+    params: List[dict] = abstract_attribute()
+    axes_unique: List[np.ndarray] = abstract_attribute()
+    axes_indexes: np.ndarray = abstract_attribute()
+    n_steps: int = abstract_attribute()
+    n_axes: int = abstract_attribute()
+    distribution: DataDistribution = abstract_attribute()
+
+    def __init__(self, actuators: List[DAQ_Move] = None):
+        super().__init__()
+        self.positions: np.ndarray = None
+        self.n_steps = 1
+        self._actuators: List[DAQ_Move] = None
+
+        self.actuators = actuators
+
+        self.set_settings_titles()
+
+        if self.check_steps():
+            self.set_scan()
+
+    def set_settings_titles(self):
+        """Update the settings accordingly with the selected actuators"""
+        ...
+
+    @property
+    def actuators(self):
+        return self._actuators
+
+    @actuators.setter
+    def actuators(self, actuators_name: List[DAQ_Move]):
+        self._actuators = actuators_name
+
+    def check_steps(self):
+        steps_limit = config('scan', 'steps_limit')
+        n_steps = self.evaluate_steps()
+        return n_steps <= steps_limit
+
+    def __call__(self, **kwargs):
+        return self(**kwargs)
+
+    @abstractmethod
+    def set_scan(self):
+        """To be reimplemented. Calculations of all mandatory attributes from the settings"""
+        ...
+
+    @abstractmethod
+    def get_nav_axes(self) -> List[Axis]:
+        """To be reimplemented. Calculations of all navigation axes from attributes"""
+        ...
+
+    @abstractmethod
+    def get_scan_shape(self) -> Tuple[int]:
+        """To be reimplemented. Calculations of all the final shape of the scan"""
+        ...
+
+    @abstractmethod
+    def get_indexes_from_scan_index(self, scan_index: int) -> Tuple[int]:
+        """To be reimplemented. Calculations of indexes within the scan"""
+        ...
+
+    def get_info_from_positions(self, positions: np.ndarray):
+        """Set mandatory attributes from a ndarray of positions"""
+        if positions is not None:
+            if len(positions.shape) == 1:
+                positions = np.expand_dims(positions, 1)
+            axes_unique = []
+            for ax in positions.T:
+                axes_unique.append(np.unique(ax))
+            axes_indexes = np.zeros_like(positions, dtype=int)
+            for ind in range(positions.shape[0]):
+                for ind_pos, pos in enumerate(positions[ind]):
+                    axes_indexes[ind, ind_pos] = mutils.find_index(axes_unique[ind_pos], pos)[0][0]
+
+            self.n_axes = len(axes_unique)
+            self.axes_unique = axes_unique
+            self.axes_indexes = axes_indexes
+            self.positions = positions
+            self.n_steps = positions.shape[0]
+
+    @abstractmethod
+    def evaluate_steps(self):
+        """To be reimplemented. Quick evaluation of the current numbers of scan steps from the settings
+        """
+        ...
+
+    def update_model(self):
+        """Method to reimplement and use for scanners using table_view types Parameters to set and apply the underlying
+        model
+
+        See Also
+        --------
+        SequentialScanner, TabularScanner, pymodaq.utils.parameter.pymodaq_ptypes.tableview
+        """
+        ...
+
+    def value_changed(self, param):
+        self.evaluate_steps()
+
+    @abstractmethod
+    def update_from_scan_selector(self, scan_selector: Selector):
+        """To be reimplemented. Process the Selector object to set the Scanner settings
+
+        See Also
+        --------
+        Selector, ScanSelector
+        """
+        ...
+
+
+class ScannerFactory(ObjectFactory):
+    """Factory class registering and storing Scanners"""
+
+    @classmethod
+    def register(cls, key: str, sub_key: str = '') -> Callable:
+        def inner_wrapper(wrapped_class: Union[Callable]) -> Callable:
+            if cls.__name__ not in cls._builders:
+                cls._builders[cls.__name__] = {}
+            if key not in cls._builders[cls.__name__]:
+                cls._builders[cls.__name__][key] = {}
+            if sub_key not in cls._builders[cls.__name__][key]:
+                cls._builders[cls.__name__][key][sub_key] = wrapped_class
+            else:
+                logger.warning(f'The {cls.__name__}/{key}/{sub_key} builder is already registered. Replacing it')
+            return wrapped_class
+
+        return inner_wrapper
+
+    @classmethod
+    def create(cls, key, sub_key, **kwargs) -> ScannerBase:
+        builder = cls._builders[cls.__name__].get(key).get(sub_key)
+        if not builder:
+            raise ValueError(key)
+        return builder(**kwargs)
+
+    def get(self, scan_type, scan_sub_type, **kwargs):
+        return self.create(scan_type, scan_sub_type, **kwargs)
+
+    def scan_types(self) -> List[str]:
+        """Returns the list of scan types, main identifier of a given scanner"""
+        return sorted(list(self.builders[self.__class__.__name__].keys()))
+
+    def scan_sub_types(self, scan_type: str) -> List[str]:
+        """Returns the list of scan subtypes, second identifier of a given scanner of type scan_type"""
+        return list(self.builders[self.__class__.__name__][scan_type].keys())
+

pymodaq/utils/scanner/scanner.py

@@ -0,0 +1,271 @@
+from __future__ import annotations
+from typing import Tuple, List, TYPE_CHECKING
+from collections import OrderedDict
+
+
+from qtpy import QtWidgets, QtCore
+from qtpy.QtCore import QObject, Signal, Slot
+
+from pymodaq.utils.logger import set_logger, get_module_name
+from pymodaq.utils.config import Config
+from pymodaq.utils.scanner.scan_factory import ScannerFactory, ScannerBase
+from pymodaq.utils.managers.parameter_manager import ParameterManager, Parameter
+import pymodaq.utils.daq_utils as utils
+from pymodaq.utils.scanner.utils import ScanInfo
+from pymodaq.utils.plotting.scan_selector import Selector
+
+if TYPE_CHECKING:
+    from pymodaq.control_modules.daq_move import DAQ_Move
+
+
+logger = set_logger(get_module_name(__file__))
+config = Config()
+scanner_factory = ScannerFactory()
+
+
+class Scanner(QObject, ParameterManager):
+    """Main Object to define a PyMoDAQ scan and create a UI to set it
+
+    Parameters
+    ----------
+    parent_widget: QtWidgets.QWidget
+    scanner_items: list of GraphicItems
+        used by ScanSelector for chosing scan area or linear traces
+    actuators: List[DAQ_Move]
+        list actuators names
+
+    See Also
+    --------
+    ScanSelector, ScannerBase, TableModelSequential, TableModelTabular, pymodaq_types.TableViewCustom
+    """
+    scanner_updated_signal = Signal()
+    settings_name = 'scanner'
+
+    params = [
+        {'title': 'Calculate positions:', 'name': 'calculate_positions', 'type': 'action'},
+        {'title': 'N steps:', 'name': 'n_steps', 'type': 'int', 'value': 0, 'readonly': True},
+        {'title': 'Scan type:', 'name': 'scan_type', 'type': 'list', 'limits': scanner_factory.scan_types()},
+        {'title': 'Scan subtype:', 'name': 'scan_sub_type', 'type': 'list',
+         'limits': scanner_factory.scan_sub_types(scanner_factory.scan_types()[0])},
+    ]
+
+    def __init__(self, parent_widget: QtWidgets.QWidget = None, scanner_items=OrderedDict([]),
+                 actuators: List[DAQ_Move] = []):
+        QObject.__init__(self)
+        ParameterManager.__init__(self)
+        if parent_widget is None:
+            parent_widget = QtWidgets.QWidget()
+        self.parent_widget = parent_widget
+        self._scanner_settings_widget = None
+
+        self.connect_things()
+        self._scanner: ScannerBase = None
+
+        self.setup_ui()
+        self.actuators = actuators
+        self.settings.child('n_steps').setValue(self._scanner.evaluate_steps())
+
+    def setup_ui(self):
+        self.parent_widget.setLayout(QtWidgets.QVBoxLayout())
+        self.parent_widget.layout().setContentsMargins(0, 0, 0, 0)
+        self.parent_widget.layout().addWidget(self.settings_tree)
+        self._scanner_settings_widget = QtWidgets.QWidget()
+        self._scanner_settings_widget.setLayout(QtWidgets.QVBoxLayout())
+        self._scanner_settings_widget.layout().setContentsMargins(0, 0, 0, 0)
+        self.parent_widget.layout().addWidget(self._scanner_settings_widget)
+        self.settings_tree.setMinimumHeight(110)
+        self.settings_tree.header().setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
+
+    def set_scanner(self):
+        try:
+            self._scanner: ScannerBase = scanner_factory.get(self.settings['scan_type'],
+                                                             self.settings['scan_sub_type'], actuators=self.actuators)
+
+            while True:
+                child = self._scanner_settings_widget.layout().takeAt(0)
+                if not child:
+                    break
+                child.widget().deleteLater()
+                QtWidgets.QApplication.processEvents()
+
+            self._scanner_settings_widget.layout().addWidget(self._scanner.settings_tree)
+            self._scanner.settings.sigTreeStateChanged.connect(self._update_steps)
+
+        except ValueError:
+            pass
+
+    def get_scanner_sub_settings(self):
+        """Get the current ScannerBase implementation's settings"""
+        return self._scanner.settings
+
+    def value_changed(self, param: Parameter):
+        if param.name() == 'scan_type':
+            self.settings.child('scan_sub_type').setOpts(
+                limits=scanner_factory.scan_sub_types(param.value()))
+        if param.name() in ['scan_type', 'scan_sub_type']:
+            self.set_scanner()
+
+        self.settings.child('n_steps').setValue(self._scanner.evaluate_steps())
+
+    @property
+    def actuators(self):
+        """list of str: Returns as a list the name of the selected actuators to describe the actual scan"""
+        return self._actuators
+
+    @actuators.setter
+    def actuators(self, act_list):
+        self._actuators = act_list
+        self.set_scanner()
+
+    def set_scan_type_and_subtypes(self, scan_type: str, scan_subtype: str):
+        """Convenience function to set the main scan type
+
+        Parameters
+        ----------
+        scan_type: str
+            one of registered Scanner main identifier
+        scan_subtype: list of str or None
+            one of registered Scanner second identifier for a given main identifier
+
+        See Also
+        --------
+        ScannerFactory
+        """
+        if scan_type in scanner_factory.scan_types():
+            self.settings.child('scan_type').setValue(scan_type)
+
+            if scan_subtype is not None:
+                if scan_subtype in scanner_factory.scan_sub_types(scan_type):
+                    self.settings.child('scan_sub_type').setValue(scan_subtype)
+
+    def set_scan_from_settings(self, settings: Parameter, scanner_settings: Parameter):
+
+        self.set_scan_type_and_subtypes(settings['scan_type'],
+                                        settings['scan_sub_type'])
+        self.settings.restoreState(settings.saveState())
+        self._scanner.settings.restoreState(scanner_settings.saveState())
+
+    @property
+    def scan_type(self) -> str:
+        return self.settings['scan_type']
+
+    @property
+    def scan_sub_type(self) -> str:
+        return self.settings['scan_sub_type']
+
+    def connect_things(self):
+        self.settings.child('calculate_positions').sigActivated.connect(self.set_scan)
+
+    def get_scan_info(self) -> ScanInfo:
+        """Get a summary of the configured scan as a ScanInfo object"""
+        return ScanInfo(self._scanner.n_steps, positions=self._scanner.positions,
+                        axes_indexes=self._scanner.axes_indexes, axes_unique=self._scanner.axes_unique,
+                        selected_actuators=[act.title for act in self.actuators])
+
+    def get_nav_axes(self):
+        return self._scanner.get_nav_axes()
+
+    def get_scan_shape(self):
+        return self._scanner.get_scan_shape()
+
+    def get_indexes_from_scan_index(self, scan_index: int) -> Tuple[int]:
+        """To be reimplemented. Calculations of indexes within the scan"""
+        return self._scanner.get_indexes_from_scan_index(scan_index)
+
+    def _update_steps(self):
+        self.settings.child('n_steps').setValue(self.n_steps)
+
+    @property
+    def n_steps(self):
+        return self._scanner.evaluate_steps()
+
+    @property
+    def n_axes(self):
+        return self._scanner.n_axes
+
+    @property
+    def positions(self):
+        return self._scanner.positions
+
+    @property
+    def axes_indexes(self):
+        return self._scanner.axes_indexes
+
+    @property
+    def axes_unique(self):
+        return self._scanner.axes_unique
+
+    @property
+    def distribution(self):
+        return self._scanner.distribution
+
+    def set_scan(self):
+        """Process the settings options to calculate the scan positions
+
+        Returns
+        -------
+        bool: True if the processed number of steps if **higher** than the configured number of steps
+        """
+        oversteps = config('scan', 'steps_limit')
+        if self._scanner.evaluate_steps() > oversteps:
+            return True
+        self._scanner.set_scan()
+        self.settings.child('n_steps').setValue(self.n_steps)
+        self.scanner_updated_signal.emit()
+        return False
+
+    def update_from_scan_selector(self, scan_selector: Selector):
+        self._scanner.update_from_scan_selector(scan_selector)
+
+
+def main():
+    from pymodaq.utils.parameter import ParameterTree
+    app = QtWidgets.QApplication(sys.argv)
+
+    class MoveMock:
+        def __init__(self, ind: int = 0):
+            self.title = f'act_{ind}'
+            self.units = f'units_{ind}'
+
+    actuators = [MoveMock(ind) for ind in range(3)]
+
+    params = [{'title': 'Actuators', 'name': 'actuators', 'type': 'itemselect',
+               'value': dict(all_items=[act.title for act in actuators], selected=[])},
+              {'title': 'Set Scan', 'name': 'set_scan', 'type': 'action'},
+              ]
+    settings = Parameter.create(name='settings', type='group', children=params)
+    settings_tree = ParameterTree()
+    settings_tree.setParameters(settings)
+
+    widget_main = QtWidgets.QWidget()
+    widget_main.setLayout(QtWidgets.QVBoxLayout())
+    widget_scanner = QtWidgets.QWidget()
+    widget_main.layout().addWidget(settings_tree)
+    widget_main.layout().addWidget(widget_scanner)
+    scanner = Scanner(widget_scanner, actuators=actuators)
+
+    def update_actuators(param):
+        scanner.actuators = [utils.find_objects_in_list_from_attr_name_val(actuators, 'title', act_str,
+                                                                           return_first=True)[0]
+                             for act_str in param.value()['selected']]
+
+    def print_info():
+        print('info:')
+        print(scanner.get_scan_info())
+        print('positions:')
+        print(scanner.positions)
+        print('nav:')
+        print(scanner.get_nav_axes())
+
+    settings.child('actuators').sigValueChanged.connect(update_actuators)
+    settings.child('set_scan').sigActivated.connect(scanner.set_scan)
+    scanner.scanner_updated_signal.connect(print_info)
+    widget_main.show()
+    sys.exit(app.exec_())
+
+
+if __name__ == '__main__':
+    import sys
+    from qtpy import QtWidgets
+    main()
+

pymodaq/utils/scanner/scanners/_1d_scanners.py

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 05/12/2022
+
+@author: Sebastien Weber
+"""
+from typing import List, Tuple
+
+import numpy as np
+from pymodaq.utils.data import Axis, DataDistribution
+from pymodaq.utils.logger import set_logger, get_module_name
+from pymodaq.utils import math_utils as mutils
+from pymodaq.utils import config as configmod
+from pymodaq.utils.plotting.scan_selector import Selector
+
+from ..scan_factory import ScannerFactory, ScannerBase, ScanParameterManager
+
+
+logger = set_logger(get_module_name(__file__))
+config = configmod.Config()
+
+
+@ScannerFactory.register('Scan1D', 'Linear')
+class Scan1DLinear(ScannerBase):
+    params = [
+        {'title': 'Start:', 'name': 'start', 'type': 'float', 'value': config('scan', 'scan1D', 'start')},
+        {'title': 'Stop:', 'name': 'stop', 'type': 'float', 'value': config('scan', 'scan1D', 'stop')},
+        {'title': 'Step:', 'name': 'step', 'type': 'float', 'value': config('scan', 'scan1D', 'step')}
+        ]
+    n_axes = 1
+    distribution = DataDistribution['uniform']
+
+    def __init__(self, actuators: List = None, **_ignored):
+        ScannerBase.__init__(self, actuators=actuators)
+
+    def set_scan(self):
+        self.positions = mutils.linspace_step(self.settings['start'], self.settings['stop'],
+                                              self.settings['step'])
+        self.get_info_from_positions(self.positions)
+
+    def set_settings_titles(self):
+        if len(self.actuators) == 1:
+            self.settings.child('start').setOpts(title=f'{self.actuators[0].title} start:')
+            self.settings.child('stop').setOpts(title=f'{self.actuators[0].title} stop:')
+            self.settings.child('step').setOpts(title=f'{self.actuators[0].title} step:')
+
+    def evaluate_steps(self) -> int:
+        n_steps = int(np.abs((self.settings['stop'] - self.settings['start']) / self.settings['step']) + 1)
+        return n_steps
+
+    def get_nav_axes(self) -> List[Axis]:
+        return [Axis(label=f'{self.actuators[0].title}',
+                     units=f'{self.actuators[0].units}',
+                     data=np.squeeze(self.positions))]
+
+    def get_scan_shape(self) -> Tuple[int]:
+        return len(self.positions),
+
+    def get_indexes_from_scan_index(self, scan_index: int) -> Tuple[int]:
+        """To be reimplemented. Calculations of indexes within the scan"""
+        return tuple(self.axes_indexes[scan_index])
+
+    def update_from_scan_selector(self, scan_selector: Selector):
+        coordinates = scan_selector.get_coordinates()
+        if coordinates.shape == (2, 2) or coordinates.shape == (2, 1):
+            self.settings.child('start').setValue(coordinates[0, 0])
+            self.settings.child('stop').setValue(coordinates[1, 0])
+
+
+@ScannerFactory.register('Scan1D', 'Random')
+class Scan1DRandom(Scan1DLinear):
+    def __init__(self, actuators: List = None, **_ignored):
+        super().__init__(actuators=actuators)
+
+    def set_scan(self):
+        self.positions = mutils.linspace_step(self.settings['start'], self.settings['stop'],
+                                              self.settings['step'])
+        np.random.shuffle(self.positions)
+        self.get_info_from_positions(self.positions)
+        self.set_settings_titles()
+
+try:
+    import adaptive
+
+
+    @ScannerFactory.register('Scan1D', 'Adaptive')
+    class Scan1DAdaptive(Scan1DLinear):
+        params = [
+            {'title': 'Loss type', 'name': 'scan_loss', 'type': 'list',
+             'limits': ['default', 'curvature', 'uniform'], 'tip': 'Type of loss used by the algo. to determine next points'},
+            {'title': 'Start:', 'name': 'start', 'type': 'float', 'value': config('scan', 'scan1D', 'start')},
+            {'title': 'Stop:', 'name': 'stop', 'type': 'float', 'value': config('scan', 'scan1D', 'stop')},
+            ]
+        distribution = DataDistribution['spread']
+
+        def __init__(self, actuators: List = None, **_ignored):
+            super().__init__(actuators=actuators)
+
+        def set_scan(self):
+            self.axes_unique = [np.array([])]
+            self.axes_indexes = np.array([], dtype=int)
+            self.positions = np.array([self.settings['start'], self.settings['stop']])
+
+        def evaluate_steps(self) -> int:
+            return 1
+
+        def get_nav_axes(self) -> List[Axis]:
+            return [Axis(label=f'{self.actuators[0].mod_name} axis',
+                         units=f'{self.actuators[0].units}',
+                         data=self.positions[0])]
+
+        def get_scan_shape(self) -> Tuple[int]:
+            return len(self.positions),
+
+except ModuleNotFoundError:
+    logger.info('adaptive module is not present, no adaptive scan possible')
+