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')