def handle_new_data(self):
""" Called during measurement thread wait loop"""
SyncRasterScan.handle_new_data(self)
ccd_dev = self.andor_ccd.ccd_dev
#print("get_number_new_images", ccd_dev.get_number_new_images()
#print("get_total_number_images_acquired", ccd_dev.get_total_number_images_acquired())
if ccd_dev.get_total_number_images_acquired() > 0:
#print("get_number_available_images", ccd_dev.get_number_available_images())
#print("get_number_new_images", ccd_dev.get_number_new_images())
#first, last = ccd_dev.get_number_new_images()
#validfirst, validlast, buf = ccd_dev.get_images(first, last, self.buffer[first-1:last-1,:])
#print("get_images", validfirst, validlast)
# Loop through available images in Andor buffer
while 1:
self.andor_ccd.settings.ccd_status.read_from_hardware()
if self.interrupt_measurement_called:
break
# new frame
frame_num = (self.andor_ccd_total_i // self.Npixels)
if self.andor_ccd_pixel_i == 0:
# stop if new frame is past requested frames
if (not self.settings['continuous_scan']
) and frame_num >= self.settings['n_frames']:
break
# extend H5 array to fit new frame
if self.settings['save_h5']:
self.extend_h5_framed_dataset(self.spec_map_h5,
frame_num)
# grab the next ccd image, place it into buffer
t0 = time.time()
arr = ccd_dev.get_oldest_image(
self.spec_buffer[self.andor_ccd_pixel_i, :])
if arr is None:
break
# copy data to image shaped map
i = self.andor_ccd_pixel_i
#x = self.scan_index_array[i,:]
#self.spec_map[x[0], x[1], x[2],:] = arr
kk, jj, ii = self.scan_index_array[i, :]
self.spec_map[kk, jj, ii, :] = arr
if self.settings['save_h5']:
#print('save h5', frame_num, kk,jj,ii, i)
self.spec_map_h5[frame_num, kk, jj, ii, :] = arr
self.andor_ccd_pixel_i += 1
self.andor_ccd_total_i += 1
self.andor_ccd_pixel_i %= self.Npixels
def setup(self):
SyncRasterScan.setup(self)
self.display_update_period = 0.1
self.disp_chan_choices += ['auger{}'.format(i)
for i in range(10)] + ['sum_auger']
self.settings.display_chan.change_choice_list(
tuple(self.disp_chan_choices))
self.settings.New('ke_start',
dtype=float,
initial=30,
unit='V',
vmin=5,
vmax=2200)
self.settings.New('ke_end',
dtype=float,
initial=600,
unit='V',
vmin=1,
vmax=2200)
self.settings.New('ke_delta',
dtype=float,
initial=0.5,
unit='V',
vmin=0.02979,
vmax=2200,
si=True)
self.settings.New('pass_energy',
dtype=float,
initial=50,
unit='V',
vmin=5,
vmax=500)
self.settings.New('crr_ratio',
dtype=float,
initial=5,
vmin=1.5,
vmax=20)
self.settings.New('CAE_mode', dtype=bool, initial=False)
for lq_name in ['ke_start', 'ke_end', 'ke_delta', 'CAE_mode']:
self.settings.get_lq(lq_name).add_listener(self.compute_ke)
self.settings.New('eht_off_at_end', dtype=bool, initial=False)
self.ui.details_groupBox.layout().addWidget(
self.settings.New_UI()) # comment out?
self.settings.New('No_dispersion', dtype=bool, initial=False)
self.settings.New('Chan_sum', dtype=bool, initial=True)
self.settings.New('auto_focus', dtype=bool, initial=False)
self.settings.New('frames_before_focus', dtype=int, initial=5, vmin=1)
def handle_new_data(self):
""" Called during measurement thread wait loop"""
SyncRasterScan.handle_new_data(self)
new_auger_data = self.auger_fpga_hw.read_fifo()
self.auger_queue.append(new_auger_data)
#ring_buf_index_array = (i + np.arange(n, dtype=int)) % self.Npixels
#self.auger_chan_pixels[ring_buf_index_array] = new_auger_data
while len(self.auger_queue) > 0:
# grab the next available data chunk
#print('new_adc_data_queue' + "[===] "*len(self.new_adc_data_queue))
new_data = self.auger_queue.pop(0)
i = self.auger_i
n = new_data.shape[0]
# grab only up to end of frame, put the rest back in the queue
if i + n > self.Npixels:
split_index = (self.Npixels - i)
print("split", i, n, split_index, self.Npixels)
self.auger_queue.append(new_data[split_index:])
new_data = new_data[0:split_index]
n = new_data.shape[0]
# copy data to image shaped map
self.auger_chan_pixels[i:i + n, :] = new_data
x = self.scan_index_array[i:i + n, :].T
self.auger_chan_map[x[0], x[1], x[2], :] = new_data
# new frame
if self.auger_i == 0:
frame_num = (self.auger_total_i // self.Npixels) - 1
if self.settings['save_h5']:
self.extend_h5_framed_dataset(self.auger_chan_map_h5,
frame_num)
self.auger_chan_map_h5[
frame_num, :, :, :, :] = self.auger_chan_map
if self.interrupt_measurement_called:
break
self.auger_i += n
self.auger_total_i += n
self.auger_i %= self.Npixels
print(new_auger_data.shape)
def get_display_pixels(self):
#SyncRasterScan.get_display_pixels(self)
#self.display_pixels = self.auger_chan_pixels[:,0:8].sum(axis=1)
#self.display_pixels[0] = 0
#self.display_pixels = self._pixels[:,0]
#DISPLAY_CHAN = 0
#self.display_pixels = self.adc_pixels[:,DISPLAY_CHAN]
#self.display_pixels[0] = 0
chan = self.settings['display_chan']
if 'auger' in chan:
if chan == 'sum_auger':
self.display_pixels = self.auger_chan_pixels[:,
0:8].sum(axis=1)
else:
self.display_pixels = self.auger_chan_pixels[:, int(chan[-1])]
else:
return SyncRasterScan.get_display_pixels(self)
def setup(self):
# SEM Hardware Components
from ScopeFoundryHW.xbox_controller.xbcontrol_hc import XboxControlHW
self.add_hardware(XboxControlHW(self))
from ScopeFoundryHW.xbox_controller.xbcontrol_mc import XboxControlMeasure
self.add_measurement(XboxControlMeasure(self))
#from ScopeFoundryHW.sem_analog.sem_singlechan_signal import SEMSingleChanSignal
#self.add_hardware_component(SEMSingleChanSignal(self))
#from ScopeFoundryHW.sem_analog.sem_dualchan_signal import SEMDualChanSignal
#self.add_hardware_component(SEMDualChanSignal(self))
#from ScopeFoundryHW.sem_analog.sem_slowscan_vout import SEMSlowscanVoutStage
#self.add_hardware_component(SEMSlowscanVoutStage(self))
from ScopeFoundryHW.sync_raster_daq import SyncRasterDAQ
self.add_hardware_component(SyncRasterDAQ(self))
from Auger.NIFPGA.auger_fpga_hw import AugerFPGA_HW
self.add_hardware(AugerFPGA_HW(self))
from Auger.hardware.auger_electron_analyzer_hw import AugerElectronAnalyzerHW
self.add_hardware(AugerElectronAnalyzerHW(self))
from ScopeFoundryHW.zeiss_sem.remcon32_hw import Auger_Remcon_HW
self.add_hardware(Auger_Remcon_HW(self))
########## Measurements
# self.add_measurement_component(AugerPointSpectrum(self))
# self.add_measurement_component(AugerQuadOptimizer(self))
#self.add_measurement_component(SEMSlowscanSingleChan(self))
# from Auger.sem_slowscan2d import SEMSlowScan
# self.add_measurement_component(SEMSlowScan(self))
# self.add_measurement_component(AugerSlowMap(self))
from Auger.auger_chan_history import AugerChanHistory
self.add_measurement_component(AugerChanHistory(self))
from Auger.auger_spectrum import AugerSpectrum
self.add_measurement_component(AugerSpectrum(self))
from ScopeFoundryHW.sync_raster_daq import SyncRasterScan
self.add_measurement_component(SyncRasterScan(self))
from Auger.auger_sync_scan import AugerSyncRasterScan, MultiSpecAugerScan
self.add_measurement(AugerSyncRasterScan(self))
self.add_measurement(MultiSpecAugerScan(self))
# from Auger.measurement.auger_pressure_history import AugerPressureHistory
# self.add_measurement_component(AugerPressureHistory(self))
from Auger.analyzer_quad_optimizer import AugerQuadOptimizer
self.add_measurement(AugerQuadOptimizer(self))
from Auger.analyzer_simplex_optimizer import AugerSimplexOptimizer
self.add_measurement(AugerSimplexOptimizer(self))
from Auger.hardware.sem_align import SEMAlignMeasure
self.add_measurement(SEMAlignMeasure)
from Auger.auger_quad_scan import AugerQuadSlowScan
self.add_measurement(AugerQuadSlowScan(self))
from Auger.sem_auto_focus import SEMAutoFocus
self.add_measurement(SEMAutoFocus(self))
from Auger.sem_auto_stig_measure import SEMAutoStigMeasure
self.add_measurement(SEMAutoStigMeasure(self))
# self.phi_ion_gun = self.add_hardware_component(PhiIonGunHardwareComponent(self))
# self.ion_gun_status = self.add_measurement_component(IonGunStatus(self))
self.hardware['xbox_controller'].settings.get_lq(
'connected').update_value(True)
self.settings_load_ini('auger_app_settings.ini')
self.ui.show()
def setup(self):
SyncRasterScan.setup(self)
self.settings['adc_oversample'] = 2500
self.settings.adc_oversample.change_min_max(100, 25e6)
self.settings['adc_rate'] = 200e3
def get_display_pixels(self):
#self.display_pixels = self.spec_buffer.mean(axis=1)
return SyncRasterScan.get_display_pixels(self)
def on_end_frame(self, frame_i):
SyncRasterScan.on_end_frame(self, frame_i)
def on_new_frame(self, frame_i):
SyncRasterScan.on_new_frame(self, frame_i)
self.analyzer_hw.settings['KE'] = self.ke[0, frame_i]