def process_roi_lineouts(self, roi_dict): roi_dict = self.scale_lineout_dicts(roi_dict) self.view.display_roi_lineouts(roi_dict) self.measure_data_dict = dict([]) for roi_key, lineout_data in roi_dict.items(): if not self._display_temporary: self.data_to_export['data1D'][f'{self.title}_Hlineout_{roi_key}'] = \ utils.DataToExport(name=self.title, data=lineout_data.hor_data, source='roi', x_axis=utils.Axis(data=lineout_data.hor_axis, units=self.x_axis.axis_units, label=self.x_axis.axis_label)) self.data_to_export['data1D'][f'{self.title}_Vlineout_{roi_key}'] = \ utils.DataToExport(name=self.title, data=lineout_data.ver_data, source='roi', x_axis=utils.Axis(data=lineout_data.ver_axis, units=self.y_axis.axis_units, label=self.y_axis.axis_units)) self.data_to_export['data0D'][f'{self.title}_Integrated_{roi_key}'] = \ utils.DataToExport(name=self.title, data=lineout_data.int_data, source='roi', ) self.measure_data_dict[f'{roi_key}:'] = lineout_data.int_data QtWidgets.QApplication.processEvents() self.view.roi_manager.settings.child('measurements').setValue( self.measure_data_dict) if not self._display_temporary: self.data_to_export_signal.emit(self.data_to_export) self.ROI_changed.emit()
def test_Data(self): name = 'data_test' x = utils.linspace_step(1, 100, 1) y = utils.linspace_step(0.01, 1, 0.01) data_test = utils.Data(name=name, x_axis=x, y_axis=y) assert isinstance(data_test, utils.Data) assert data_test['name'] == name assert data_test['x_axis'] == utils.Axis(data=x) assert data_test['y_axis'] == utils.Axis(data=y) x = utils.Axis(x) y = utils.Axis(y) kwargs = [1, 2.0, 'kwargs', True, None] data_test = utils.Data(name=name, x_axis=x, y_axis=y, kwargs=kwargs) assert data_test['x_axis'] == x assert data_test['y_axis'] == y assert data_test['kwargs'] == kwargs with pytest.raises(TypeError): utils.Data(name=None) with pytest.raises(TypeError): utils.Data(source=None) with pytest.raises(ValueError): utils.Data(source='source') with pytest.raises(TypeError): utils.Data(distribution=None) with pytest.raises(ValueError): utils.Data(distribution='distribution') with pytest.raises(TypeError): utils.Data(x_axis=10) with pytest.raises(TypeError): utils.Data(y_axis=10)
def test_DataFromPlugins(self): data = [ utils.linspace_step(1, 100, 1), utils.linspace_step(0.01, 1, 0.01) ] nav_axes = ["test"] x_axis = utils.Axis(data=utils.linspace_step(1, 100, 1)) y_axis = utils.Axis(data=utils.linspace_step(1, 100, 1)) data_test = utils.DataFromPlugins(data=data, nav_axes=nav_axes, nav_x_axis=x_axis, nav_y_axis=y_axis) assert isinstance(data_test, utils.DataFromPlugins) assert data_test['data'] == data assert data_test['nav_axes'] == nav_axes assert data_test['nav_x_axis'] == x_axis assert data_test['nav_y_axis'] == y_axis assert data_test['dim'] == 'Data1D' data = [np.array([1])] data_test = utils.DataFromPlugins(data=data) assert data_test['dim'] == 'Data0D' data = [np.array([[1, 1], [1, 2]])] data_test = utils.DataFromPlugins(data=data) assert data_test['dim'] == 'Data2D' data = [np.array([[[1, 1], [1, 2]], [[2, 1], [2, 2]]])] data_test = utils.DataFromPlugins(data=data) assert data_test['dim'] == 'DataND' with pytest.raises(TypeError): utils.DataFromPlugins(data=[1, 2, 3, 4, 5]) with pytest.raises(TypeError): utils.DataFromPlugins(data="str")
def test_Axis(): ax = utils.Axis() assert 'data' in ax assert 'label' in ax assert 'units' in ax ax = utils.Axis(np.array([1, 2, 3, 5, 7]), 'a label', 'seconds') assert np.all(ax['data'] == np.array([1, 2, 3, 5, 7])) assert ax['label'] == 'a label' assert ax['units'] == 'seconds'
def ini_detector(self, controller=None): """ Initialisation procedure of the detector. Returns ------- ??? the initialized status. See Also -------- set_Mock_data """ self.status.update( edict(initialized=False, info="", x_axis=None, y_axis=None, controller=None)) if self.settings.child(('controller_status')).value() == "Slave": if controller is None: raise Exception( 'no controller has been defined externally while this detector is a slave one' ) else: self.controller = controller else: self.controller = "Mock controller" self.emit_status( utils.ThreadCommand('update_main_settings', [['wait_time'], self.settings.child( ('wait_time')).value(), 'value'])) # initialize viewers with the future type of data self.data_grabed_signal_temp.emit([ utils.DataFromPlugins(name='MockScanner', data=[self.datas], dim='Data2D', labels=['RandomGaussians'], x_axis=utils.Axis(data=xaxis), y_axis=utils.Axis(data=yaxis)) ]) self.status.initialized = True self.status.x_axis = self.x_axis self.status.y_axis = self.y_axis self.status.controller = self.controller return self.status
def grab_data(self, Naverage=1, **kwargs): """ """ coeff = self.settings.child(('width_coeff')).value() fun_type = self.settings.child(('fun_type')).value() self.datas = np.zeros((self.Ny, self.Nx)) self.stop_flag = False if self.scan_parameters is not None: for ind in range(self.scan_parameters.Nsteps): if self.stop_flag: break positions = (self.x_axis[self.scan_parameters.axes_indexes[ind, 0]], self.y_axis[self.scan_parameters.axes_indexes[ind, 1]]) if fun_type == 'Gaussians': self.datas[self.scan_parameters.axes_indexes[ind, 1], self.scan_parameters.axes_indexes[ ind, 0]] = random_hypergaussians2D_signal( positions, coeff) else: self.datas[self.scan_parameters.axes_indexes[ind, 1], self.scan_parameters.axes_indexes[ ind, 0]] = diverging2D_signal(positions, coeff) if ind % 100 == 0: # refresh plot every 100 grabed points self.data_grabed_signal_temp.emit([ utils.DataFromPlugins( name='MockScanner', data=[self.datas], dim='Data2D', x_axis=utils.Axis(data=self.x_axis), y_axis=utils.Axis(data=self.y_axis)) ]) QtWidgets.QApplication.processEvents() QThread.msleep(100) self.data_grabed_signal.emit([ utils.DataFromPlugins(name='MockScanner', data=[self.datas], dim='Data2D', x_axis=utils.Axis(data=self.x_axis), y_axis=utils.Axis(data=self.y_axis)) ]) self.ind_data += 1
def show_data(self, data): """ do stuff with data from the detector if its grab_done_signal has been connected Parameters ---------- data: (OrderedDict) #OrderedDict(name=self.title,x_axis=None,y_axis=None,z_axis=None,data0D=None,data1D=None,data2D=None) """ self.data_dict = data if 'data1D' in data: self.raw_data = [] for key in data['data1D']: self.raw_data.append(data['data1D'][key]['data']) if 'x_axis' in data['data1D'][key]: x_axis = data['data1D'][key]['x_axis'] else: x_axis = utils.Axis(data=np.linspace( 0, len(data['data1D'][key]['data']) - 1, len(data['data1D'][key]['data'])), units='pxls', label='') if self.viewer_freq_axis['data'] is None: self.viewer_freq_axis.update(x_axis) elif np.any(x_axis['data'] != self.viewer_freq_axis['data'] ) and self.current_det['calib']: self.viewer_freq_axis.update(x_axis) self.viewer.show_data(self.raw_data) self.update_axis()
def update_axis(self): axis = utils.Axis() unit = self.settings.child('acq_settings', 'units').value() if unit == 'nm': axis['data'] = self.viewer_freq_axis['data'] elif unit == 'cm-1': axis['data'] = Enm2cmrel( self.viewer_freq_axis['data'], self.settings.child('config_settings', 'laser_wl').value()) elif unit == 'eV': axis['data'] = nm2eV(self.viewer_freq_axis['data']) axis['units'] = unit axis['label'] = 'Photon energy' self.viewer.x_axis = axis
def __init__(self, parent): QLocale.setDefault(QLocale(QLocale.English, QLocale.UnitedStates)) super().__init__() if not isinstance(parent, DockArea): raise Exception('no valid parent container, expected a DockArea') self.wait_time = 2000 #ms self.offline = True self.dockarea = parent self.mainwindow = parent.parent() self.spectro_widget = QtWidgets.QWidget() self.data_dict = None """ List of the possible plugins that could be used with Spectrometer module type : dimensionality of the detector name: name of the plugin calib = True means there is a builtin calibration of the frequency axis movable : tells if the dispersion can be set (for instance by moving a grating) unit: valid only if calib is True. Unit of the calibration axis (x_axis of the detector), most often in nanometers. Possible values are 'nm', 'radfs' (rad/femtosecond), 'eV' laser: if False, laser cannot be changed by the program, do it manually laser_list: if laser is True, laser_list gives a list of selectable lasers """ self.current_det = None # will be after initialization self.laser_set_manual = True #init the object parameters self.detector = None self.save_file_pathname = None self._spectro_wl = 550 # center wavelngth of the spectrum self.viewer_freq_axis = utils.Axis(data=None, label='Photon energy', units='') self.raw_data = [] #init the user interface self.dashboard = self.set_dashboard() self.dashboard.preset_loaded_signal.connect( lambda: self.show_detector(False)) self.dashboard.preset_loaded_signal.connect(self.set_detector) self.dashboard.preset_loaded_signal.connect(self.initialized) self.set_GUI() self.dashboard.new_preset_created.connect( lambda: self.create_menu(self.menubar)) self.show_detector(False) self.dockarea.setEnabled(False)
def test_Axis(): ax = utils.Axis() assert 'data' in ax assert 'label' in ax assert 'units' in ax assert ax.label == ax['label'] ax = utils.Axis(np.array([1, 2, 3, 5, 7]), 'a label', 'seconds') assert np.all(ax['data'] == np.array([1, 2, 3, 5, 7])) assert ax['label'] == 'a label' assert ax['units'] == 'seconds' ax = utils.Axis(label=None, units=None) assert ax['label'] == '' assert ax['units'] == '' with pytest.raises(TypeError): utils.Axis(10) with pytest.raises(TypeError): utils.Axis(label=10) with pytest.raises(TypeError): utils.Axis(units=10)
def update_graph1D(self, datas): # self.data_to_export=OrderedDict(data0D=OrderedDict(),data1D=OrderedDict(),data2D=None) try: pens = [] symbolBrushs = [] symbolSize = 5 for ind, ch in enumerate(self.plot_channels): if self.ui.scatter.isChecked(): pens.append(None) symbol = 'o' symbolBrushs.append(self.plot_colors[ind]) else: pens.append(self.plot_colors[ind]) symbol = None symbolBrushs.append(None) for ind_plot, data in enumerate(datas): if self.x_axis is None: self._x_axis = np.linspace(0, len(data), len(data), endpoint=False) elif len(self.x_axis) != len(data): self._x_axis = np.linspace(0, len(data), len(data), endpoint=False) self.plot_channels[ind_plot].setData( x=self.x_axis, y=data, pen=pens[ind_plot], symbol=symbol, symbolBrush=symbolBrushs[ind_plot], symbolSize=symbolSize, pxMode=True) if self.ui.zoom_pb.isChecked(): self.zoom_plot[ind_plot].setData(x=self.x_axis, y=data) x_axis = utils.Axis(data=self.x_axis, units=self.axis_settings['units'], label=self.axis_settings['label']) self.data_to_export['data1D']['CH{:03d}'.format( ind_plot)].update( OrderedDict(name=self.title, data=data, x_axis=x_axis, source='raw')) # to be saved or exported if not self.ui.Do_math_pb.isChecked( ): #otherwise math is done and then data is exported self.data_to_export['acq_time_s'] = datetime.datetime.now( ).timestamp() self.data_to_export_signal.emit(self.data_to_export) else: self.measurement_dict['datas'] = datas data_lo = self.math_module.update_math(self.measurement_dict) self.show_math(data_lo) except Exception as e: self.update_status(str(e), self.wait_time)
def create_test_file(request, qtbot): bck = H5Saver(backend=request.param) filepath = f'./data/data_test_{request.param}.h5' bck.init_file(update_h5=True, addhoc_file_path=filepath) Nx = 12 Nnavx = 5 Nnavy = 10 scan_shape = (Nnavx, Nnavy) x_axis = dict(label='this is data axis', units='no units', data=np.arange(Nx)) data1D = dict(data=np.arange(Nx) * 1.0 + 7, x_axis=x_axis) nav_x_axis = dict(label='this is nav x axis', units='x units', data=np.arange(Nnavx)) nav_y_axis = utils.Axis(label='this is nav y axis', units='y units', data=np.arange(Nnavy)) d = datetime(year=2020, month=5, day=24, hour=10, minute=52, second=55) raw_group = bck.add_group( 'Agroup', 'data', '/', metadata=dict( date_time=d, author='Seb Weber', settings='this should be xml', scan_settings=b'scan binary setting', type='scan', shape=(10, 45), pixmap_1D=b'this should be binary png in reality', pixmap_2D=b'this should be another binary png in reality')) bck.add_data(raw_group, data1D) scan_group = bck.add_scan_group( 'first scan', settings_as_xml='this should dbe xml settings') params = [{ 'title': 'Main Settings:', 'name': 'main_settings', 'expanded': False, 'type': 'group', 'children': [ { 'title': 'DAQ type:', 'name': 'DAQ_type', 'type': 'list', 'values': ['DAQ0D', 'DAQ1D', 'DAQ2D', 'DAQND'], 'readonly': True }, { 'title': 'Detector type:', 'name': 'detector_type', 'type': 'str', 'value': '', 'readonly': True }, { 'title': 'Nviewers:', 'name': 'Nviewers', 'type': 'int', 'value': 1, 'min': 1, 'default': 1, 'readonly': True }, ] }] settings = Parameter.create(name='settings', type='group', children=params) settings_xml = ctree.parameter_to_xml_string(settings) det_group = bck.add_det_group(scan_group, 'det group', settings_as_xml=settings_xml) data_group = bck.add_data_group(det_group, 'data1D') ch_group = bck.add_CH_group(data_group) data = np.arange(Nx * Nnavx * Nnavy) data = data.reshape(Nnavx, Nnavy, Nx) data_dict = dict(data=data, x_axis=x_axis) bck.add_data(ch_group, data_dict, scan_type='scan2D', scan_shape=scan_shape, add_scan_dim=False) bck.add_navigation_axis(nav_x_axis.pop('data'), scan_group, 'x_axis', metadata=nav_x_axis) bck.add_navigation_axis(nav_y_axis.pop('data'), scan_group, 'y_axis', metadata=nav_y_axis) bck.logger_array.append('log1 to check') bck.logger_array.append('log2 to check') bck.close_file() return bck
def test_info_neg_scaling(self): axis = utils.Axis(label='mylabel', units='myunits', data=np.array([35, 20, 5])) assert pymodaq.daq_utils.plotting.utils.plot_utils.AxisInfosExtractor.extract_axis_info( axis) == (-15, 35, 'mylabel', 'myunits')
def test_info_data_is_None(self): axis = utils.Axis(label='mylabel', units='myunits') assert pymodaq.daq_utils.plotting.utils.plot_utils.AxisInfosExtractor.extract_axis_info( axis) == (1, 0, 'mylabel', 'myunits')