def grab_data(self, Naverage=1, **kwargs):
"""
| Start new acquisition.
| grab the current values.
| Send the data_grabed_signal once done.
=============== ======== ===============================================
**Parameters** **Type** **Description**
*Naverage* int Number of values to average
=============== ======== ===============================================
"""
data_tot = []
for channel in self.settings.child('config',
'channels').value()['selected']:
if self.settings.child('config', 'separate_viewers').value():
data_tot.append(
DataFromPlugins(name=channel,
data=[self.query_data(channel + '.')[2]],
dim='Data0D'))
else:
data_tot.append(self.query_data(channel + '.')[2])
if self.settings.child('config', 'separate_viewers').value():
self.data_grabed_signal.emit(data_tot)
else:
self.data_grabed_signal.emit([
DataFromPlugins(name='Keithley', data=data_tot, dim='Data0D')
])
def grab_data(self, Naverage=1, **kwargs):
"""
| grab the current values with NIDAQ profile procedure.
|
| Send the data_grabed_signal once done.
=============== ======== ===============================================
**Parameters** **Type** **Description**
*Naverage* int Number of values to average
=============== ======== ===============================================
See Also
--------
DAQ_NIDAQ_source
"""
if self.settings.child(
('NIDAQ_type')).value() == DAQ_NIDAQ_source(0).name: #analog input
channels = [
child.opts['title'] for child in self.settings.child(
'ai_settings', 'ai_channels').children()
]
data_tot = []
read = self.PyDAQmx.int32()
N = self.settings.child('ai_settings', 'Nsamples').value()
data = np.zeros(N * len(channels), dtype=np.float64)
#self.task.StartTask()
self.task.ReadAnalogF64(self.PyDAQmx.DAQmx_Val_Auto, 50.0,
self.PyDAQmx.DAQmx_Val_GroupByChannel,
data, len(data), self.PyDAQmx.byref(read),
None)
#self.task.StopTask()
if self.control_type == "0D":
for ind in range(len(channels)):
data_tot.append(
np.array([np.mean(data[ind * N:(ind + 1) * N])]))
self.data_grabed_signal.emit([
DataFromPlugins(name='NI AI',
data=data_tot,
dim='Data0D',
labels=channels)
])
else:
for ind in range(len(channels)):
data_tot.append(data[ind * N:(ind + 1) * N])
self.data_grabed_signal.emit([
DataFromPlugins(name='NI AI',
data=data_tot,
dim='Data1D',
labels=channels)
])
elif self.settings.child(
('NIDAQ_type'
)).value() == DAQ_NIDAQ_source(1).name: #counter input
self.task.StartTask()
self.timer.start(
self.settings.child('counter_settings',
'counting_time').value())
def grab_data(self, Naverage=1, **kwargs):
"""
| Start new acquisition.
|
For each data on data_mock :
* shift right data of ind_data positions
* if naverage parameter is defined append the mean of the current data to the data to be grabbed.
|
| Send the data_grabed_signal once done.
=============== ======== ===============================================
**Parameters** **Type** **Description**
*Naverage* int specify the threshold of the mean calculation
=============== ======== ===============================================
"""
data_tot = []
for ind, data in enumerate(self.data_mock):
data = np.roll(data, self.ind_data)
if Naverage > 1:
data_tot.append(np.array([np.mean(data[0:Naverage - 1])]))
else:
data_tot.append(np.array([data[0]]))
if self.settings.child(('sep_viewers')).value():
dat = [DataFromPlugins(name=f'Mock_{ind:03}', data=[data], dim='Data0D',
labels=[f'mock data {ind:03}']) for ind, data in enumerate(data_tot)]
self.data_grabed_signal.emit(dat)
else:
self.data_grabed_signal.emit([DataFromPlugins(name='Mock1', data=data_tot,
dim='Data0D', labels=['dat0', 'data1'])])
self.ind_data += 1
def commit_settings(self, param):
"""
Activate the parameters changes in the hardware.
=============== ================================= ============================
**Parameters** **Type** **Description**
*param* instance of pyqtgraph.parameter The parameter to be checked.
=============== ================================= ============================
See Also
--------
daq_utils.ThreadCommand
"""
try:
if param.name() == 'timeout':
self.controller.timeout = self.settings.child(
('timeout')).value()
if param.name() == 'load_setup':
self.controller.write('RSET{:d};'.format(
self.settings.child('config', 'setup',
'setup_number').value()))
param.setValue(False)
if param.name() == 'save_setup':
self.controller.write('SSET{:d};'.format(
self.settings.child('config', 'setup',
'setup_number').value()))
param.setValue(False)
elif param.name() == 'channels':
data_init = []
for channel in param.value()['selected']:
if self.settings.child('config',
'separate_viewers').value():
data_init.append(
DataFromPlugins(name=channel,
data=[np.array([0])],
dim='Data0D'))
else:
data_init.append(np.array([0]))
if self.settings.child('config', 'separate_viewers').value():
self.data_grabed_signal_temp.emit(data_init)
else:
self.data_grabed_signal_temp.emit([
DataFromPlugins(name='SR830',
data=data_init,
dim='Data0D')
])
elif param.name() == 'reset':
self.reset()
param.setValue(False)
except Exception as e:
self.emit_status(
ThreadCommand('Update_Status',
[getLineInfo() + str(e), 'log']))
def emit_data(self):
if self.grabbing:
with self.controller.fetch_buffer() as buffer:
payload = buffer.payload
component = payload.components[0]
width = component.width
height = component.height
data_format = component.data_format
if self.settings.child('ROIselect', 'use_ROI').value():
offsetx = self.controller.device.node_map.get_node(
'OffsetX').value
offsety = self.controller.device.node_map.get_node(
'OffsetY').value
else:
offsetx = 0
offsety = 0
if data_format in mono_location_formats:
data_tmp = component.data.reshape(height, width)
self.data[offsety:offsety + height,
offsetx:offsetx + width] = data_tmp
self.data_grabed_signal.emit([
DataFromPlugins(name='GenICam ',
data=[self.data],
dim='Data2D'),
])
else:
# The image requires you to reshape it to draw it on the canvas:
if data_format in rgb_formats or \
data_format in rgba_formats or \
data_format in bgr_formats or \
data_format in bgra_formats:
#
content = component.data.reshape(
height,
width,
int(component.num_components_per_pixel
) # Set of R, G, B, and Alpha
)
#
if data_format in bgr_formats:
# Swap every R and B:
content = content[:, :, ::-1]
self.data_grabed_signal.emit([
DataFromPlugins(
name='GenICam ',
data=[
self.data[:, :, ind] for ind in range(
min(3, component.num_components_per_pixel))
],
dim='Data2D'),
])
self.grabbing = False
def init_data(self, Nx=None, Ny=None):
#%%%%%% Initialize data: self.data_stem for the memory to store new data and self.data_stem_average to store the average data
if not self.settings.child(('do_hyperspectroscopy')).value():
self.SIZEX = Nx
self.SIZEY = Ny
self.stem_scan.setImageSize(Nx, Ny)
self.stem_scan.setImageArea(Nx, Ny, 0, Nx, 0, Ny)
else:
Nx = self.settings.child('hyperspectroscopy',
'camera_mode_settings', 'spim_x').value()
Ny = self.settings.child('hyperspectroscopy',
'camera_mode_settings', 'spim_y').value()
startx = self.settings.child('ROIselect', 'x0').value()
starty = self.settings.child('ROIselect', 'y0').value()
endx = startx + self.settings.child('ROIselect', 'width').value()
endy = starty + self.settings.child('ROIselect', 'height').value()
self.SIZEX = Nx
self.SIZEY = Ny
self.spim_scan.setImageArea(Nx, Ny, startx, endx, starty, endy)
self.data_spectrum_spim = [
DataFromPlugins(
name='SPIM ',
data=[
np.zeros((self.settings.child('hyperspectroscopy',
'image_size', 'Nx').value(),
self.settings.child('hyperspectroscopy',
'camera_mode_settings',
'spim_y').value(),
self.settings.child('hyperspectroscopy',
'camera_mode_settings',
'spim_x').value()))
],
dim='DataND'),
DataFromPlugins(name='Spectrum',
data=[
np.zeros((self.settings.child(
'hyperspectroscopy', 'image_size',
'Nx').value(), ))
],
dim='Data1D')
]
self.data_stem = np.zeros((2 * Nx * Ny), dtype=np.int16)
self.data_stem_current = np.zeros((2, Nx, Ny), dtype=np.int16)
self.data_stem_pointer = self.data_stem.ctypes.data_as(ctypes.c_void_p)
def data_ready(self):
"""
| Cast the raw data (from Picoscope's communication channel) to export considering time axis in ms.
| Send the data grabed signal once done.
See Also
--------
get_active_channels, daq_utils.ThreadCommand
"""
try:
Nsegments=self.settings.child('main_settings','Nsegments').value()
channels=self.get_active_channels()
ind_channels=[picoscope.DAQ_Picoscope_trigger_channel[channel].value for channel in channels]
data=np.zeros((len(channels),self.Nsample_available,Nsegments))
status,Nsamples=self.pico.get_value_bulk(Nsamples_required=self.Nsample_available,start_segment=0,stop_segment=Nsegments-1)
if status!="PICO_OK":
self.emit_status(ThreadCommand("Update_Status",[status,'log']))
window_ms=self.settings.child('main_settings','temporal','window').value()
self.x_axis,self.Nsample_available=self.get_xaxis(self.settings.child('main_settings','temporal','Nsamples').value(),window_ms*1000) #get time axis in ms
self.emit_x_axis()
for ind_segment in range(Nsegments):
for ind,ind_channel in enumerate(ind_channels):
status,data_channel=self.pico.get_data(channel=ind_channel,buffer=self.buffers[ind_segment][ind])
data[ind,:,ind_segment]=data_channel['data']
data_export=[np.sum(data[ind,:,:],axis=1)/Nsegments for ind in range(len(channels))]
self.data_grabed_signal.emit([DataFromPlugins(name='picoscope',data=data_export, dim='Data1D')])
except Exception as e:
self.emit_status(ThreadCommand("Update_Status",[getLineInfo()+ str(e),'log']))
def counter_done(self):
channels = [
child.opts['title'] for child in self.settings.child(
'counter_settings', 'counter_channels').children()
]
data_counter = np.zeros(len(channels), dtype='uint32')
read = self.PyDAQmx.int32()
self.task.ReadCounterU32Ex(self.PyDAQmx.DAQmx_Val_Auto, 10.0,
self.PyDAQmx.DAQmx_Val_GroupByChannel,
data_counter, len(data_counter),
self.PyDAQmx.byref(read), None)
self.task.StopTask()
data_counter = data_counter.astype(float)
data_counter = data_counter / (self.settings.child(
'counter_settings', 'counting_time').value() * 1e-3)
self.data_grabed_signal.emit([
DataFromPlugins(name='NI Counter',
data=[data_counter],
dim='Data0D',
labels=channels)
])
def grab_data(self, Naverage=1, **kwargs):
"""
"""
Naverage = 1
if not self.controller_ready:
ret = self.controller.prepare_N_acquisition(
self.settings.child('acq_params', 'npts_map').value())
if ret == 'ready':
self.controller_ready = True
else:
self.emit_status(
ThreadCommand(
'Update_Status',
['Spectrometer not ready to grab data...', 'log']))
if self.controller_ready:
data = self.controller.grab_spectrum()
else:
data = self.controller.wavelength_axis * 0
if data is None:
self.emit_status(
ThreadCommand('Update_Status',
['No data from spectrometer', 'log']))
data = self.controller.wavelength_axis * 0
self.data_grabed_signal.emit([
DataFromPlugins(name='LabSpec6',
data=[data],
dim='Data1D',
x_axis=Axis(data=self.controller.wavelength_axis,
units='nm',
label='Wavelength'))
])
def grab_data(self, Naverage=1, **kwargs):
"""
Parameters
----------
kwargs: (dict) of others optionals arguments
"""
##synchrone version (blocking function)
if self.calib_on and self.calib_file_ok:
label = ["Irradiance (W/m2)"]
else:
label = ["Signal (counts)"]
data_tot = [self.get_data()]
if self.snapshot is not None:
data_tot.append(self.snapshot)
label.append("Snapshot")
self.data_grabed_signal.emit([
DataFromPlugins(name="StellarNet",
data=data_tot,
dim="Data1D",
labels=label,
x_axis=self.x_axis[0])
])
def grab_data(self, Naverage=1, **kwargs):
"""
| Start new acquisition
For each integer step of naverage range:
* set mock data
* wait 100 ms
* update the data_tot array
| Send the data_grabed_signal once done.
=============== ======== ===============================================
**Parameters** **Type** **Description**
*Naverage* int Number of spectrum to average.
Specify the threshold of the mean calculation
=============== ======== ===============================================
See Also
--------
set_Mock_data
"""
Naverage = 1
data_tot = self.set_Mock_data()
for ind in range(Naverage - 1):
data_tmp = self.set_Mock_data()
QThread.msleep(self.settings.child('exposure_ms').value())
for ind, data in enumerate(data_tmp):
data_tot[ind] += data
data_tot = [data / Naverage for data in data_tot]
QThread.msleep(self.settings.child('exposure_ms').value())
self.data_grabed_signal.emit(
[DataFromPlugins(name='Mock1', data=data_tot, dim='Data1D')])
def grab_data(self, Naverage=1, **kwargs):
"""
| Start new acquisition.
| grab the current values with keithley profile procedure.
| Send the data_grabed_signal once done.
=============== ======== ===============================================
**Parameters** **Type** **Description**
*Naverage* int Number of values to average
=============== ======== ===============================================
"""
data_tot = []
x_axis = None
for ind, channel in enumerate(
self.settings.child(('channels')).value()['selected']):
if ind == 0:
x_axis, data_tmp = self.read_channel_data(channel,
x_axis_out=True)
else:
data_tmp = self.read_channel_data(channel, x_axis_out=False)
data_tot.append(data_tmp)
self.data_grabed_signal.emit([
DataFromPlugins(name='Tektronix',
data=data_tot,
dim='Data1D',
x_axis=Axis(data=x_axis, label='Time', units='s'))
])
def grab_data(self, Naverage=1, **kwargs):
"""
Parameters
----------
Naverage: (int) Number of hardware averaging
kwargs: (dict) of others optionals arguments
"""
nlc = self.settings.child('advanced').child(
'correct_non_linearity').value()
c0 = self.settings.child('advanced').child('dark_channels').value()
# synchrone version (blocking function)
# Pseudo-hardware-averaging
if Naverage > 1:
data = [
self.controller.intensities(correct_nonlinearity=nlc)[c0:]
for i in range(Naverage)
]
data = np.array(data)
data = data.mean(0)
# Otherwise normal single-acquisition
else:
data = self.controller.intensities(correct_nonlinearity=nlc)[c0:]
data_emit = DataFromPlugins(name='oceanseabreeze',
data=[data],
dim='Data1D',
labels=['spectrum'])
self.data_grabed_signal.emit([data_emit])
def ini_detector(self, controller=None):
"""
Initialisation procedure of the detector updating the status dictionnary.
See Also
--------
set_Mock_data, daq_utils.ThreadCommand
"""
self.status.update(edict(initialized=False,info="",x_axis=None,y_axis=None,controller=None))
try:
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.set_x_axis()
self.set_Mock_data()
# initialize viewers with the future type of data
self.data_grabed_signal_temp.emit([DataFromPlugins(name='Mock1', data=self.data_mock, dim='Data1D',
x_axis= self.x_axis, labels=['Mock1', 'label2']),])
self.status.initialized=True
self.status.controller=self.controller
self.status.x_axis = self.x_axis
return self.status
except Exception as e:
self.emit_status(ThreadCommand('Update_Status',[getLineInfo()+ str(e),'log']))
self.status.info=getLineInfo()+ str(e)
self.status.initialized=False
return self.status
def emit_data(self):
"""
Fonction used to emit data obtained by callback.
See Also
--------
daq_utils.ThreadCommand
"""
try:
self.ind_grabbed += 1
sizey = self.settings.child('camera_settings', 'image_size',
'Ny').value()
sizex = self.settings.child('camera_settings', 'image_size',
'Nx').value()
self.controller.GetAcquiredDataNumpy(self.data_pointer,
sizex * sizey)
self.data_grabed_signal.emit([
DataFromPlugins(name='Camera',
data=[
np.squeeze(
self.data.reshape(
(sizey, sizex)).astype(np.float))
],
dim=self.data_shape)
])
QtWidgets.QApplication.processEvents(
) # here to be sure the timeevents are executed even if in continuous grab mode
except Exception as e:
self.emit_status(ThreadCommand('Update_Status', [str(e), 'log']))
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.set_Mock_data()
self.emit_status(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.emit([DataFromPlugins(name='Mock1',data=[np.array(0)], dim='Data0D', labels=['Mock1', 'label2'])])
self.status.initialized = True
self.status.controller = self.controller
return self.status
def data_ready(self, data):
"""
Send the grabed data signal.
"""
self.data_grabed_signal.emit(
[DataFromPlugins(name='TCPServer', data=data, dim='Data0D')])
def grab_data(self, Naverage=1, **kwargs):
"""
"""
try:
datas = []
for ind_spectro in range(len(self.spectro_names)):
if self.settings.child('spectrometers',
'spectro{:d}'.format(ind_spectro),
'grab').value():
self.controller.setScansToAverage(ind_spectro, Naverage)
data_chelou = self.controller.getSpectrum(ind_spectro)
data = np.array(
[data_chelou[ind] for ind in range(len(data_chelou))])
datas.append(
DataFromPlugins(name=self.spectro_names[ind_spectro],
data=[data],
dim='Data1D'))
QtWidgets.QApplication.processEvents()
self.data_grabed_signal.emit(datas)
except Exception as e:
self.emit_status(
ThreadCommand('Update_Status',
[getLineInfo() + str(e), "log"]))
def emit_data(self):
"""
"""
try:
mode = self.settings.child('acquisition', 'acq_type').value()
if mode == 'Counting' or mode == 'Histo' or mode == 'T3':
super(DAQ_2DViewer_FLIM, self).emit_data()
elif mode == 'FLIM':
self.stop_scanner.emit()
self.h5saver.h5_file.flush()
datas = self.process_histo_from_h5_and_correct_shifts(
self.Nx, self.Ny, channel=0, marker=65)
self.data_grabed_signal.emit([
DataFromPlugins(name='TH260',
data=datas,
dim='DataND',
nav_axes=(0, 1),
nav_x_axis=self.get_nav_xaxis(),
nav_y_axis=self.get_nav_yaxis(),
xaxis=self.get_xaxis(),
external_h5=self.h5saver.h5_file)
])
self.stop()
except Exception as e:
self.emit_status(
ThreadCommand('Update_Status',
[getLineInfo() + str(e), 'log']))
def grab_data(self, Naverage=1, **kwargs):
"""
Start a new acquisition.
Grab the current values.
Send the
Parameters
----------
Naverage: (int) Number of hardware averaging
kwargs: (dict) of others optionals arguments
"""
# The following seems to be important to refresh the scope buffer.
# Otherwise a long scan will crash the daq_scan.
self.controller.DeviceClear(False)
QtWidgets.QApplication.processEvents()
QThread.msleep(100)
QtWidgets.QApplication.processEvents()
channel = self.settings.child('channels').value()['selected']
waveform = self.controller.GetScaledWaveformWithTimes(
channel[0], 1e8, 0)
if self.sample_mode == "Sequence":
while True:
self.controller.WriteString(
r"""vbs? 'return=app.acquisition.horizontal.acquiredsegments' """,
1)
acquired_segments = self.controller.ReadString(8)
if acquired_segments == self.number_of_segments:
break
time.sleep(0.01)
else:
pass
# The ErrorFlag property checks that there is no error concerning ActiveDSO.
# If the user changes some parameters on the oscilloscope (for example the
# horizontal scale) while pymodaq acquisition is running, it will raise this
# error. We do not know how to deal with this problem.
# If the error is raised you will probably have to restart the oscilloscope to
# get the communication back.
# Restarting can be done with a little script using the DeviceClear(True) method
# of ActiveDSO. It is much faster than doing it manually.
#
# To prevent the error, the user should use the STOP button on pymodaq GUI, then
# change the parameter of his choice on the oscilloscope and then RUN pymodaq
# acquisition.
if self.controller.ErrorFlag:
raise Exception(self.controller.ErrorString)
data = [np.array(waveform[1])]
self.data_grabed_signal.emit([
DataFromPlugins(name='Lecroy Waverunner',
data=data,
type='Data1D',
labels=["", ""])
])
def ini_detector(self, controller=None):
"""Detector communication initialization
Parameters
----------
controller: (object) custom object of a PyMoDAQ plugin (Slave case). None if only one detector by controller (Master case)
Returns
-------
self.status (edict): with initialization status: three fields:
* info (str)
* controller (object) initialized controller
*initialized: (bool): False if initialization failed otherwise True
"""
try:
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:
## TODO for your custom plugin
self.controller = python_wrapper_of_your_instrument(
) # any object that will control the stages
#####################################
## TODO for your custom plugin
#initialize viewers pannel with the future type of data
self.data_grabed_signal_temp.emit([
DataFromPlugins(name='Mock1',
data=[np.array([0]),
np.array([0])],
dim='Data0D',
labels=['Mock1', 'label2'])
])
##############################
self.status.info = "Whatever info you want to log"
self.status.initialized = True
self.status.controller = self.controller
return self.status
except Exception as e:
self.emit_status(
ThreadCommand('Update_Status',
[getLineInfo() + str(e), 'log']))
self.status.info = getLineInfo() + str(e)
self.status.initialized = False
return self.status
def _data_ready(self, handle_ptr, p_data, frame_num, data):
dat = self.controller.get_image_data()
data = np.array(dat[0][:], dtype=np.uint8)
data = data.reshape((dat[2], dat[1], 3))
self.data_grabed_signal.emit([
DataFromPlugins(name='TIS ',
data=[data[:, :, 0], data[:, :, 1], data[:, :, 2]],
dim='Data2D'),
])
def callback(self):
"""optional asynchrone method called when the detector has finished its acquisition of data"""
data_tot = self.controller.your_method_to_get_data_from_buffer()
self.data_grabed_signal.emit([
DataFromPlugins(name='Mock1',
data=data_tot,
dim='Data1D',
labels=['dat0', 'data1'])
])
def emit_data(self, data):
channels_name = [ch.name for ch in self.channels]
data_tot = []
if self.settings.child('diodes').value():
for ind in range(len(self.channels)):
data_tot.append(np.array([np.mean(data[ind*self.Nsamples:(ind+1)*self.Nsamples])]))
self.data_grabed_signal.emit([DataFromPlugins(name='NI AI', data=data_tot, dim='Data0D',
labels=channels_name)])
else:
for ind in range(len(self.channels)):
data_tot.append(data[ind*self.Nsamples:(ind+1)*self.Nsamples])
ind_cycles = self.settings.child('Ncycles').value()
if self.settings.child('plot_cycles').value():
Bfield = data_tot[0] / self.settings.child('resistance').value() * \
self.settings.child('solenoid').value()
delta_diode = data_tot[1]
diode = (data_tot[2] + data_tot[3]) / 2
else:
length = int(1 / self.settings.child('frequency_magnet').value() *
self.settings.child('frequency').value())
Bfields = [data_tot[0][ind*length:(ind+1)*length] / self.settings.child('resistance').value() *
self.settings.child('solenoid').value() for ind in range(4)]
delta_diodes = [data_tot[1][ind*length:(ind+1)*length] for ind in range(4)]
diodes = [(data_tot[2][ind*length:(ind+1)*length] + data_tot[3][ind*length:(ind+1)*length]) / 2
for ind in range(4)]
if self.settings.child('average_cycles').value():
Bfield = np.mean(np.array(Bfields[ind_cycles:]), 0)
delta_diode = np.mean(np.array(delta_diodes[ind_cycles:]), 0)
diode = np.mean(np.array(diodes[ind_cycles:]), 0)
else:
Bfield = Bfields[ind_cycles]
delta_diode = delta_diodes[ind_cycles]
diode = diodes[ind_cycles]
rotation = 180 / np.pi / (self.settings.child('gain').value() * 4) * np.arctan(delta_diode / diode)
self.data_grabed_signal.emit([DataFromPlugins(name='NI AI', data=[Bfield, rotation], dim='Data1D',
labels=['Bfield', 'Rotation'],
x_axis=Axis(data=np.linspace(0, self.Nsamples /
self.clock_settings_ai.frequency, self.Nsamples),
label='Time', units='s'))])
def emit_data(self):
# data_stem = self.data_stem.reshape((2, self.SIZEX,
# self.SIZEY)).astype(np.float64)
if not self.settings.child(('do_hyperspectroscopy')).value():
data_stem = [
DataFromPlugins(name=self.settings.child(
'stem_settings', 'inputs', 'input1').value(),
data=[self.data_stem_current[0]],
dim='Data2D'),
DataFromPlugins(name=self.settings.child(
'stem_settings', 'inputs', 'input2').value(),
data=[self.data_stem_current[1]],
dim='Data2D'),
]
if self.data_stem_ready:
if self.stem_scan_finished:
self.data_grabed_signal.emit(data_stem)
self.stem_scan.stopImaging(True)
else:
self.data_grabed_signal_temp.emit(data_stem)
else:
data_stem = [
DataFromPlugins(name='SPIM ' + self.settings.child(
'stem_settings', 'inputs', 'input1').value(),
data=[self.data_stem_current[0]],
dim='Data2D'),
DataFromPlugins(name='SPIM ' + self.settings.child(
'stem_settings', 'inputs', 'input2').value(),
data=[self.data_stem_current[1]],
dim='Data2D'),
]
if self.data_spectrum_spim_ready and self.stem_scan_finished: #all data have been taken
self.spim_scan.stopImaging(True)
self.data_grabed_signal.emit(self.data_stem_STEM_as_reference +
data_stem +
self.data_spectrum_spim)
else:
self.data_grabed_signal_temp.emit(
self.data_stem_STEM_as_reference + data_stem +
self.data_spectrum_spim)
def update_camera_mode(self, mode='Camera'):
sizex = self.settings.child('image_size', 'Nx').value()
sizey = self.settings.child('image_size', 'Ny').value()
image_size = sizex * sizey
if image_size == 1:
self.data_shape = 'Data0D'
elif sizex == 1 or sizey == 1:
self.data_shape = 'Data1D'
else:
self.data_shape = 'Data2D'
if mode == "Camera":
# %%%%%% Initialize data: self.data for the memory to store new data and self.data_average to store the average data
self.data = np.zeros((image_size,), dtype=np.float32)
self.data_pointer = self.data.ctypes.data_as(ctypes.c_void_p)
elif mode == "SPIM":
Ny = self.settings.child('image_size', 'Ny').value()
self.settings.child('binning_settings', 'bin_y').setValue(
Ny * self.settings.child('binning_settings', 'bin_y').value())
self.commit_settings(self.settings.child('binning_settings', 'bin_y'))
QtWidgets.QApplication.processEvents()
# %%%%%% Initialize data: self.data for the memory to store new data and self.data_average to store the average data
SPIMX = self.settings.child('camera_mode_settings', 'spim_x').value()
SPIMY = self.settings.child('camera_mode_settings', 'spim_y').value()
spimsize = sizex * SPIMY * SPIMX
self.spimdata = np.zeros((spimsize,), dtype=np.float32)
self.pointeurspim = self.spimdata.ctypes.data_as(ctypes.c_void_p)
self.spectrumdata = np.zeros((sizex,), dtype=np.float32)
self.pointeurspectrum = self.spectrumdata.ctypes.data_as(ctypes.c_void_p)
# init the viewers
self.data_grabed_signal_temp.emit([DataFromPlugins(name='SPIM ', data=[self.spimdata.reshape((
self.settings.child('image_size', 'Nx').value(),
self.settings.child('camera_mode_settings', 'spim_y').value(),
self.settings.child('camera_mode_settings', 'spim_x').value()))],
dim='DataND', nav_axes=(1, 2)),
DataFromPlugins(name='Spectrum', data=[self.spectrumdata], dim='Data1D')])
def emit_data_live(self):
"""
temporary datas emitter when acquisition is running
"""
data_stem = self.data_stem.reshape(
(2, self.settings.child('stem_settings', 'pixels_settings',
'Ny').value(),
self.settings.child('stem_settings', 'pixels_settings',
'Nx').value())).astype(np.float64)
#print('livedata')
self.data_grabed_signal_temp.emit([
DataFromPlugins(name=self.settings.child('stem_settings', 'inputs',
'input1').value(),
data=[data_stem[0]],
dim='Data2D'),
DataFromPlugins(name=self.settings.child('stem_settings', 'inputs',
'input2').value(),
data=[data_stem[1]],
dim='Data2D')
])
def ini_detector(self, controller=None):
"""
Initialisation procedure of the detector.
Returns
-------
the initialized status.
"""
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:
if self.settings.child(('device')).value() != 'no devices':
try:
self.controller = Keithley2110(
self.settings.child(('device')).value())
except Exception as e:
raise Exception(
'No controller could be defined because an error occurred\
while connecting to the instrument. Error: {}'.format(
str(e)))
self.controller.set_mode(
self.settings.child('KeithleyParams', 'mode').value())
# initialize viewers with the future type of data
self.data_grabed_signal.emit([
DataFromPlugins(name='Keithley2110',
data=[np.array([0])],
dim='Data0D',
labels=['Meas', 'Time'])
])
self.status.initialized = True
self.status.controller = self.controller
return self.status
def average_data(self, Naverage):
data = [] # list of image (at most 3 for red, green and blue channels)
data_tmp = np.zeros_like(self.image)
for ind in range(Naverage):
data_tmp += self.set_Mock_data()
data_tmp = data_tmp / Naverage
data_tmp = data_tmp * (data_tmp >= self.settings.child('threshold').value())
for ind in range(self.settings.child(('Nimagespannel')).value()):
datatmptmp = []
for indbis in range(self.settings.child(('Nimagescolor')).value()):
datatmptmp.append(data_tmp)
data.append(DataFromPlugins(name='Mock2D_{:d}'.format(ind), data=datatmptmp, dim='Data2D'))
# data.append(OrderedDict(name='Mock2D_1D',data=[np.mean(data_tmp,axis=0)], type='Data1D'))
return data
def grab_data(self, Naverage=1, **kwargs):
"""
| Start new acquisition.
| grab the current values.
| Send the data_grabed_signal once done.
=============== ======== ===============================================
**Parameters** **Type** **Description**
*Naverage* int Number of values to average
=============== ======== ===============================================
"""
data_tot = []
data = self.controller.query_ascii_values('SNAP ? 1,2,3,4,5,6')
data.extend(self.controller.query_ascii_values('SNAP ? 7,8,9,10,11'))
selected_channels = self.settings.child('config',
'channels').value()['selected']
data_to_export = [
np.array([data[ind]])
for ind in [self.channels.index(sel) for sel in selected_channels]
]
if self.settings.child('config', 'separate_viewers').value():
for ind_channel, dat in enumerate(data_to_export):
data_tot.append(
DataFromPlugins(name=selected_channels[ind_channel],
data=[dat],
dim='Data0D',
labels=[selected_channels[ind_channel]]))
self.data_grabed_signal.emit(data_tot)
else:
self.data_grabed_signal.emit([
DataFromPlugins(name='SR830',
data=data_to_export,
dim='Data0D',
labels=selected_channels)
])
