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

pymodaq/utils/scanner/scanners/_2d_scanners.py

@@ -0,0 +1,293 @@
+# -*- 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('Scan2D', 'Linear')
+class Scan2DLinear(ScannerBase):
+    params = [{'title': 'Start Ax1:', 'name': 'start_axis1', 'type': 'float',
+               'value': config('scan', 'scan2D', 'linear', 'start1')},
+              {'title': 'Start Ax2:', 'name': 'start_axis2', 'type': 'float',
+               'value': config('scan', 'scan2D', 'linear', 'start2')},
+              {'title': 'Step Ax1:', 'name': 'step_axis1', 'type': 'float',
+               'value': config('scan', 'scan2D', 'linear', 'step1')},
+              {'title': 'Step Ax2:', 'name': 'step_axis2', 'type': 'float',
+               'value': config('scan', 'scan2D', 'linear', 'step2')},
+              {'title': 'Stop Ax1:', 'name': 'stop_axis1', 'type': 'float',
+               'value': config('scan', 'scan2D', 'linear', 'stop1')},
+              {'title': 'Stop Ax2:', 'name': 'stop_axis2', 'type': 'float',
+               'value': config('scan', 'scan2D', 'linear', 'stop2')},
+              ]
+    n_axes = 2
+    distribution = DataDistribution['uniform']
+
+    def __init__(self, actuators: List = None, **_ignored):
+        super().__init__(actuators=actuators)
+
+    def get_pos(self):
+        starts = np.array([self.settings['start_axis1'], self.settings['start_axis2']])
+        stops = np.array([self.settings['stop_axis1'], self.settings['stop_axis2']])
+        steps = np.array([self.settings['step_axis1'], self.settings['step_axis2']])
+        return starts, stops, steps
+
+    def evaluate_steps(self) -> int:
+        starts, stops, steps = self.get_pos()
+        n_steps = 1
+        for ind in range(starts.size):
+            n_steps *= np.abs((stops[ind] - starts[ind]) / steps[ind]) + 1
+        return int(n_steps)
+
+    def set_scan(self):
+        starts, stops, steps = self.get_pos()
+        if np.any(np.abs(steps) < 1e-12) or \
+                np.any(np.sign(stops - starts) != np.sign(steps)) or \
+                np.any(starts == stops):
+
+            return np.array([starts])
+
+        else:
+            axis_1_unique = mutils.linspace_step(starts[0], stops[0], steps[0])
+            axis_2_unique = mutils.linspace_step(starts[1], stops[1], steps[1])
+
+            positions = []
+            for ind_x, pos1 in enumerate(axis_1_unique):
+                for ind_y, pos2 in enumerate(axis_2_unique):
+                    positions.append([pos1, pos2])
+
+        self.get_info_from_positions(np.array(positions))
+
+    def set_settings_titles(self):
+        if len(self.actuators) == 2:
+            self.settings.child('start_axis1').setOpts(title=f'{self.actuators[0].title} start:')
+            self.settings.child('stop_axis1').setOpts(title=f'{self.actuators[0].title} stop:')
+            self.settings.child('step_axis1').setOpts(title=f'{self.actuators[0].title} step:')
+            self.settings.child('start_axis2').setOpts(title=f'{self.actuators[1].title} start:')
+            self.settings.child('stop_axis2').setOpts(title=f'{self.actuators[1].title} stop:')
+            self.settings.child('step_axis2').setOpts(title=f'{self.actuators[1].title} step:')
+
+    def get_nav_axes(self) -> List[Axis]:
+        return [Axis(label=f'{act.title}',
+                     units=f'{act.units}',
+                     data=self.axes_unique[ind],
+                     index=ind) for ind, act in enumerate(self.actuators)]
+
+    def get_scan_shape(self) -> Tuple[int]:
+        return tuple([len(axis) for axis in self.axes_unique])
+
+    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):
+            self.settings.child('start_axis1').setValue(coordinates[0, 0])
+            self.settings.child('start_axis2').setValue(coordinates[0, 1])
+            self.settings.child('stop_axis1').setValue(coordinates[1, 0])
+            self.settings.child('stop_axis2').setValue(coordinates[1, 1])
+
+
+@ScannerFactory.register('Scan2D', 'LinearBack&Force')
+class Scan2DLinearBF(Scan2DLinear):
+    def __init__(self, actuators: List = None, **_ignored):
+        super().__init__(actuators=actuators)
+
+    def set_scan(self):
+        starts, stops, steps = self.get_pos()
+        if np.any(np.abs(steps) < 1e-12) or \
+                np.any(np.sign(stops - starts) != np.sign(steps)) or \
+                np.any(starts == stops):
+
+            return np.array([starts])
+
+        else:
+            axis_1_unique = mutils.linspace_step(starts[0], stops[0], steps[0])
+            axis_2_unique = mutils.linspace_step(starts[1], stops[1], steps[1])
+
+            positions = []
+            for ind_x, pos1 in enumerate(axis_1_unique):
+                for ind_y, pos2 in enumerate(axis_2_unique):
+                    if not mutils.odd_even(ind_x):
+                        positions.append([pos1, pos2])
+                    else:
+                        positions.append([pos1, axis_2_unique[len(axis_2_unique) - ind_y - 1]])
+
+        self.get_info_from_positions(np.array(positions))
+
+
+@ScannerFactory.register('Scan2D', 'Random')
+class Scan2DRandom(Scan2DLinear):
+    def __init__(self, actuators: List = None, **_ignored):
+        super().__init__(actuators=actuators)
+
+    def set_scan(self):
+        super().set_scan()
+        np.random.shuffle(self.positions)
+        self.get_info_from_positions(self.positions)
+
+
+@ScannerFactory.register('Scan2D', 'Spiral')
+class Scan2DSpiral(Scan2DLinear):
+    params = [{'title': 'Center Ax1:', 'name': 'center_axis1', 'type': 'float',
+               'value': config('scan', 'scan2D', 'spiral', 'center1')},
+              {'title': 'Center Ax2:', 'name': 'center_axis2', 'type': 'float',
+               'value': config('scan', 'scan2D', 'spiral', 'center2')},
+              {'title': 'Rmax Ax1:', 'name': 'rmax_axis1', 'type': 'float',
+               'value': config('scan', 'scan2D', 'spiral', 'rmax1')},
+              {'title': 'Rmax Ax2:', 'name': 'rmax_axis2', 'type': 'float',
+               'value': config('scan', 'scan2D', 'spiral', 'rmax2')},
+              {'title': 'Npts/axis', 'name': 'npts_by_axis', 'type': 'int', 'min': 1,
+               'value': config('scan', 'scan2D', 'spiral', 'npts')},
+              {'title': 'Step Ax1:', 'name': 'step_axis1', 'type': 'float', 'value': 0., 'readonly': True},
+              {'title': 'Step Ax2:', 'name': 'step_axis2', 'type': 'float', 'value': 0., 'readonly': True},
+              ]
+
+    def __init__(self, actuators: List = None, **_ignored):
+        super().__init__(actuators=actuators)
+
+    def set_settings_titles(self):
+        if len(self.actuators) == 2:
+            self.settings.child('center_axis1').setOpts(title=f'Center {self.actuators[0].title}:')
+            self.settings.child('rmax_axis1').setOpts(title=f'Rmax {self.actuators[0].title}:')
+            self.settings.child('step_axis1').setOpts(title=f'Step {self.actuators[0].title}:')
+            self.settings.child('center_axis2').setOpts(title=f'Center {self.actuators[1].title}:')
+            self.settings.child('rmax_axis2').setOpts(title=f'Rmax {self.actuators[1].title}:')
+            self.settings.child('step_axis2').setOpts(title=f'Step {self.actuators[1].title}:')
+
+    def value_changed(self, param):
+        starts, rmaxs, rsteps = self.get_pos()
+        self.settings.child('step_axis1').setValue(rsteps[0])
+        self.settings.child('step_axis2').setValue(rsteps[1])
+
+    def get_pos(self):
+        """Get centers, radius and n steps from settings
+
+        Returns
+        ----------
+        centers: np.ndarray
+            containing the center positions of the scan
+        rmaxs: np.ndarray
+            containing the maximum radius (ellipse axes) in each direction
+        r_steps: np.ndarray
+            steps size in both directions
+        """
+        centers = np.array([self.settings['center_axis1'], self.settings['center_axis2']])
+        rmaxs = np.array([self.settings['rmax_axis1'], self.settings['rmax_axis2']])
+        r_steps = 2 * rmaxs / self.settings['npts_by_axis']
+        return centers, rmaxs, r_steps
+
+    def evaluate_steps(self) -> int:
+        return int(self.settings['npts_by_axis'] + 1) ** 2
+
+    def set_scan(self):
+        starts, rmaxs, rsteps = self.get_pos()
+
+        if np.any(np.array(rmaxs) == 0) or np.any(np.abs(rmaxs) < 1e-12) or np.any(np.abs(rsteps) < 1e-12):
+            positions = np.array([starts])
+
+        else:
+            Nlin = self.settings['npts_by_axis'] / 2
+            axis_1_indexes = [0]
+            axis_2_indexes = [0]
+            ind = 0
+            flag = True
+
+            while flag:
+                if mutils.odd_even(ind):
+                    step = 1
+                else:
+                    step = -1
+                if flag:
+
+                    for ind_step in range(ind):
+                        axis_1_indexes.append(axis_1_indexes[-1] + step)
+                        axis_2_indexes.append(axis_2_indexes[-1])
+                        if len(axis_1_indexes) >= (2 * Nlin + 1) ** 2:
+                            flag = False
+                            break
+                if flag:
+                    for ind_step in range(ind):
+                        axis_1_indexes.append(axis_1_indexes[-1])
+                        axis_2_indexes.append(axis_2_indexes[-1] + step)
+                        if len(axis_1_indexes) >= (2 * Nlin + 1) ** 2:
+                            flag = False
+                            break
+                ind += 1
+
+            positions = []
+            for ind in range(len(axis_1_indexes)):
+                positions.append(np.array([axis_1_indexes[ind] * rsteps[0] + starts[0],
+                                           axis_2_indexes[ind] * rsteps[1] + starts[1]]))
+
+        self.get_info_from_positions(np.array(positions))
+
+    def update_from_scan_selector(self, scan_selector: Selector):
+        coordinates = scan_selector.get_coordinates()
+        if coordinates.shape == (2, 2):
+            self.settings.child('center_axis1').setValue((coordinates[0, 0] + coordinates[1, 0]) / 2)
+            self.settings.child('center_axis2').setValue((coordinates[0, 1] + coordinates[1, 1]) / 2)
+            self.settings.child('rmax_axis1').setValue(abs(coordinates[1, 0] - coordinates[0, 0]) / 2)
+            self.settings.child('rmax_axis2').setValue(abs(coordinates[1, 1] - coordinates[0, 1]) / 2)
+
+
+try:
+    import adaptive
+
+    @ScannerFactory.register('Scan2D', 'Adaptive')
+    class Scan2DAdaptive(Scan2DLinear):
+        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 Ax1:', 'name': 'start_axis1', 'type': 'float',
+             'value': config('scan', 'scan2D', 'linear', 'start1')},
+            {'title': 'Start Ax2:', 'name': 'start_axis2', 'type': 'float',
+             'value': config('scan', 'scan2D', 'linear', 'start2')},
+            {'title': 'Stop Ax1:', 'name': 'stop_axis1', 'type': 'float',
+             'value': config('scan', 'scan2D', 'linear', 'stop1')},
+            {'title': 'Stop Ax2:', 'name': 'stop_axis2', 'type': 'float',
+             'value': config('scan', 'scan2D', 'linear', 'stop2')},
+            ]
+        distribution = DataDistribution['spread']
+
+        def __init__(self, actuators: List = None, **_ignored):
+            super().__init__(actuators=actuators)
+
+        def set_scan(self):
+
+            self.axes_unique = [np.array([]), np.array([])]
+            self.axes_indexes = np.array([], dtype=int)
+            self.positions = np.zeros((0, 2))
+
+        def evaluate_steps(self) -> int:
+            return 1
+
+        def get_nav_axes(self) -> List[Axis]:
+            return [Axis(label=f'{act.mod_name} axis',
+                         units=f'{act.units}',
+                         data=self.positions[:, ind],
+                         index=ind) for ind, act in enumerate(self.actuators)]
+
+        def get_scan_shape(self) -> Tuple[int]:
+            return ()  # unknown shape
+
+except ModuleNotFoundError:
+    logger.info('adaptive module is not present, no adaptive scan possible')
+

pymodaq/utils/scanner/scanners/sequential.py

@@ -0,0 +1,192 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 05/12/2022
+
+@author: Sebastien Weber
+"""
+from typing import List, Tuple
+
+import numpy as np
+
+from qtpy import QtCore, QtWidgets
+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 import gui_utils as gutils
+from ..scan_factory import ScannerFactory, ScannerBase, ScanParameterManager
+from pymodaq.utils.parameter import utils as putils
+from pymodaq.utils.parameter.pymodaq_ptypes import TableViewCustom
+from pymodaq.utils.plotting.scan_selector import Selector
+
+logger = set_logger(get_module_name(__file__))
+config = configmod.Config()
+
+
+class TableModelSequential(gutils.TableModel):
+    """Table Model for the Model/View Qt framework dedicated to the Sequential scan mode"""
+    def __init__(self, data, **kwargs):
+        header = ['Actuator', 'Start', 'Stop', 'Step']
+        if 'header' in kwargs:
+            header = kwargs.pop('header')
+        editable = [False, True, True, True]
+        if 'editable' in kwargs:
+            editable = kwargs.pop('editable')
+        super().__init__(data, header, editable=editable, **kwargs)
+
+    def __repr__(self):
+        return f'{self.__class__.__name__} from module {self.__class__.__module__}'
+
+    def validate_data(self, row, col, value):
+        """
+        make sure the values and signs of the start, stop and step values are "correct"
+        Parameters
+        ----------
+        row: (int) row within the table that is to be changed
+        col: (int) col within the table that is to be changed
+        value: (float) new value for the value defined by row and col
+
+        Returns
+        -------
+        bool: True is the new value is fine (change some other values if needed) otherwise False
+        """
+        start = self.data(self.index(row, 1), QtCore.Qt.DisplayRole)
+        stop = self.data(self.index(row, 2), QtCore.Qt.DisplayRole)
+        step = self.data(self.index(row, 3), QtCore.Qt.DisplayRole)
+        isstep = False
+        if col == 1:  # the start
+            start = value
+        elif col == 2:  # the stop
+            stop = value
+        elif col == 3:  # the step
+            isstep = True
+            step = value
+
+        if np.abs(step) < 1e-12 or start == stop:
+            return False
+        if np.sign(stop - start) != np.sign(step):
+            if isstep:
+                self._data[row][2] = -stop
+            else:
+                self._data[row][3] = -step
+        return True
+
+
+@ScannerFactory.register('Sequential', 'Linear')
+class SequentialScanner(ScannerBase):
+    params = [
+        {'title': 'Sequences', 'name': 'seq_table', 'type': 'table_view', 'delegate': gutils.SpinBoxDelegate},
+              ]
+    distribution = DataDistribution['uniform']
+    n_axes = 1
+
+    def __init__(self, actuators: List[str]):
+
+        self.table_model: TableModelSequential = None
+        self.table_view: TableViewCustom = None
+        super().__init__(actuators)
+        self.update_model()
+
+    @property
+    def actuators(self):
+        return self._actuators
+
+    @actuators.setter
+    def actuators(self, actuators_name):
+        self._actuators = actuators_name
+        self.update_model()
+
+    def update_model(self, init_data=None):
+        if init_data is None:
+            if self.table_model is not None:
+                init_data = []
+                names = [row[0] for row in self.table_model.get_data_all()]
+                for act in self._actuators:
+                    if act.title in names:
+                        ind_row = names.index(act.title)
+                        init_data.append(self.table_model.get_data_all()[ind_row])
+                    else:
+                        init_data.append([act.title, 0., 1., 0.1])
+            else:
+                init_data = [[act.title, 0., 1., 0.1] for act in self._actuators]
+        self.table_model = TableModelSequential(init_data, )
+        self.table_view = putils.get_widget_from_tree(self.settings_tree, TableViewCustom)[0]
+        self.settings.child('seq_table').setValue(self.table_model)
+        self.n_axes = len(self._actuators)
+        self.update_table_view()
+
+    def get_pos(self):
+        starts = np.array([self.table_model.get_data(ind, 1) for ind in range(self.table_model.rowCount(None))])
+        stops = np.array([self.table_model.get_data(ind, 2) for ind in range(self.table_model.rowCount(None))])
+        steps = np.array([self.table_model.get_data(ind, 3) for ind in range(self.table_model.rowCount(None))])
+        return starts, stops, steps
+
+    def evaluate_steps(self) -> int:
+        starts, stops, steps = self.get_pos()
+        n_steps = 1
+        for ind in range(starts.size):
+            n_steps *= np.abs((stops[ind] - starts[ind]) / steps[ind]) + 1
+        return int(n_steps)
+
+    @staticmethod
+    def pos_above_stops(positions, steps, stops):
+        state = []
+        for pos, step, stop in zip(positions, steps, stops):
+            if step >= 0:
+                state.append(pos > stop)
+            else:
+                state.append(pos < stop)
+        return state
+
+    def update_table_view(self):
+        self.table_view.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
+        self.table_view.horizontalHeader().setStretchLastSection(True)
+        self.table_view.setSelectionBehavior(QtWidgets.QTableView.SelectRows)
+        self.table_view.setSelectionMode(QtWidgets.QTableView.SingleSelection)
+        styledItemDelegate = QtWidgets.QStyledItemDelegate()
+        styledItemDelegate.setItemEditorFactory(gutils.SpinBoxDelegate())
+        self.table_view.setItemDelegate(styledItemDelegate)
+
+        self.table_view.setDragEnabled(True)
+        self.table_view.setDropIndicatorShown(True)
+        self.table_view.setAcceptDrops(True)
+        self.table_view.viewport().setAcceptDrops(True)
+        self.table_view.setDefaultDropAction(QtCore.Qt.MoveAction)
+        self.table_view.setDragDropMode(QtWidgets.QTableView.InternalMove)
+        self.table_view.setDragDropOverwriteMode(False)
+
+    def set_scan(self):
+        starts, stops, steps = self.get_pos()
+        all_positions = [starts.copy()]
+        positions = starts.copy()
+        state = self.pos_above_stops(positions, steps, stops)
+        if len(state) != 0:
+            while not state[0]:
+                if not np.any(np.array(state)):
+                    positions[-1] += steps[-1]
+
+                else:
+                    indexes_true = np.where(np.array(state))
+                    positions[indexes_true[-1][0]] = starts[indexes_true[-1][0]]
+                    positions[indexes_true[-1][0] - 1] += steps[indexes_true[-1][0] - 1]
+
+                state = self.pos_above_stops(positions, steps, stops)
+                if not np.any(np.array(state)):
+                    all_positions.append(positions.copy())
+
+        self.get_info_from_positions(np.array(all_positions))
+
+    def get_nav_axes(self) -> List[Axis]:
+        return [Axis(label=f'{act.title}', units=act.units, data=self.axes_unique[ind], index=ind)
+                for ind, act in enumerate(self.actuators)]
+
+    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 get_scan_shape(self) -> Tuple[int]:
+        return tuple([len(axis) for axis in self.axes_unique])
+
+    def update_from_scan_selector(self, scan_selector: Selector):
+        coordinates = scan_selector.get_coordinates()
+        pass