def run_scan(scan, run_conf=None): run_manager = RunManager(_configuration_folder) run_manager.run_run(scan, run_conf=run_conf) error_msg = '' try: error_msg = str(run_manager._current_run.err_queue.get(timeout=1)[1]) except Empty: pass return run_manager._current_run._run_status == 'FINISHED', error_msg, run_manager._current_run.output_filename, run_manager._current_run._default_run_conf, run_manager._current_run.__class__.__name__
def test_global_register(self, mock_configure_pixel, mock_send_commands): run_manager = RunManager('test_interface/configuration.yaml') run_manager.run_run(RegisterTest, run_conf={'test_pixel': False}) error_msg = 'Global register test failed. ' try: error_msg += str( run_manager._current_run.err_queue.get(timeout=1)[1]) except Empty: pass ok = (run_manager._current_run._run_status == 'FINISHED') self.assertTrue(ok, msg=error_msg)
self.occ_mask[occ_hist >= n_largest_elements[0]] = 1 # make inverse self.inv_occ_mask = invert_pixel_mask(self.occ_mask) if self.overwrite_mask: for mask in self.disable_for_mask: self.register.set_pixel_register_value(mask, self.inv_occ_mask) else: for mask in self.disable_for_mask: enable_mask = np.logical_and(self.inv_occ_mask, self.register.get_pixel_register_value(mask)) self.register.set_pixel_register_value(mask, enable_mask) if self.overwrite_mask: for mask in self.enable_for_mask: self.register.set_pixel_register_value(mask, self.occ_mask) else: for mask in self.enable_for_mask: disable_mask = np.logical_or(self.occ_mask, self.register.get_pixel_register_value(mask)) self.register.set_pixel_register_value(mask, disable_mask) plot_occupancy(self.occ_mask.T, title='Noisy Pixels', z_max=1, filename=analyze_raw_data.output_pdf) plot_fancy_occupancy(self.occ_mask.T, z_max=1, filename=analyze_raw_data.output_pdf) for mask in self.disable_for_mask: mask_name = self.register.pixel_registers[mask]['name'] plot_occupancy(self.register.get_pixel_register_value(mask).T, title='%s Mask' % mask_name, z_max=1, filename=analyze_raw_data.output_pdf) for mask in self.enable_for_mask: mask_name = self.register.pixel_registers[mask]['name'] plot_occupancy(self.register.get_pixel_register_value(mask).T, title='%s Mask' % mask_name, z_max=1, filename=analyze_raw_data.output_pdf) if __name__ == "__main__": RunManager('../configuration.yaml').run_run(HotPixelTuning)
if index == 0: actual_scan_parameters = { 'PlsrDAC': self.scan_parameters.PlsrDAC, self.scan_parameters._fields[1]: parameter_value } else: self.minimum_data_points = self.data_points # Take settings from last fast threshold scan for speed up actual_scan_parameters = { 'PlsrDAC': (self.scan_parameter_start, None), self.scan_parameters._fields[1]: parameter_value } # Start the PlsrDAC at last start point to save time self.set_scan_parameters(**actual_scan_parameters) super(ThresholdCalibration, self).scan() logging.info("Finished!") def handle_data(self, data): self.raw_data_file.append_item( data, scan_parameters=self.scan_parameters._asdict(), new_file=[self.scan_parameters._fields[1]], flush=False) # Create new file for each scan parameter change def analyze(self): create_threshold_calibration(self.output_filename, create_plots=self.create_plots) if __name__ == "__main__": RunManager('../configuration.yaml').run_run(ThresholdCalibration)
output_pdf.savefig(fig) data_table.append(data_array) # Store valid data if not np.any(data_array['error_rate'] != 0): logging.warning('There is no delay setting without errors') logging.info('ERRORS: %s', str(data_array['error_rate'])) # Determine best delay setting (center of working delay settings) good_indices = np.where(np.logical_and(data_array['error_rate'][:-1] == 0, np.diff(data_array['error_rate']) == 0))[0] best_index = good_indices[good_indices.shape[0] / 2] best_delay_setting = data_array['TRIGGER_DATA_DELAY'][best_index] logging.info('The best delay setting for this setup is %d', best_delay_setting) # Plot error rate plot fig = Figure() FigureCanvas(fig) ax = fig.add_subplot(111) ax.plot(data_array['TRIGGER_DATA_DELAY'], data_array['error_rate'], '.-', label='data') ax.plot([best_delay_setting, best_delay_setting], [0, 1], '--', label='best delay setting') ax.set_title('Trigger word error rate for different data delays') ax.set_xlabel('TRIGGER_DATA_DELAY') ax.set_ylabel('Error rate') ax.grid(True) ax.legend(loc=0) output_pdf.savefig(fig) if __name__ == "__main__": with RunManager('configuration.yaml') as runmngr: runmngr.run_run(TluTuning)
"Triggering stop condition: %d pixel(s) with %d hits or more >= %d pixel(s)" % (pixels_with_full_hits_count, self.n_injections, stop_pixel_cnt)) self.stop_condition_triggered = True # start precise scanning actions pixels_with_hits = np.ma.array( occupancy_array_select, mask=(occupancy_array_select != 0)) # select pixels that see at least one hit pixels_with_hits_count = np.ma.count_masked( pixels_with_hits) # count pixels that see hits start_pixel_cnt = int( np.product(occupancy_array_select.shape) * self.start_at) if pixels_with_hits_count >= start_pixel_cnt and not self.start_condition_triggered: # start precise scanning if this is true logging.info( "Triggering start condition: %d pixel(s) with more than 0 hits >= %d pixel(s)" % (pixels_with_hits_count, start_pixel_cnt)) self.start_condition_triggered = True def start_readout(self, **kwargs): if kwargs: self.set_scan_parameters(**kwargs) self.fifo_readout.start(reset_sram_fifo=True, clear_buffer=True, callback=None, errback=self.handle_err) if __name__ == "__main__": RunManager('../configuration.yaml').run_run(FastThresholdScan)
plot_three_way(self.occ_array_sel_pixel.transpose(), title="Occupancy after GDAC tuning (GDAC " + str(self.scan_parameters.GDAC) + ")", x_axis_title='Occupancy', filename=self.plots_filename, maximum=self.n_injections_gdac) if self.close_plots: self.plots_filename.close() def write_target_threshold(self): commands = [] commands.extend(self.register.get_commands("ConfMode")) self.register.set_global_register_value("PlsrDAC", self.target_threshold) commands.extend( self.register.get_commands("WrRegister", name="PlsrDAC")) self.register_utils.send_commands(commands) def set_gdac_bit(self, bit_position, bit_value=1, send_command=True): gdac = self.register_utils.get_gdac() if bit_value: gdac |= (1 << bit_position) else: gdac &= ~(1 << bit_position) self.register_utils.set_gdac(gdac, send_command=send_command) if __name__ == "__main__": RunManager('../configuration.yaml').run_run(GdacTuning)
from pybar.run_manager import RunManager # importing run manager from pybar.scans.scan_analog import AnalogScan from pybar.scans.scan_ext_trigger_gdac import ExtTriggerGdacScan from pybar.run_manager import run_status if __name__ == "__main__": runmngr = RunManager('../../pybar/configuration.yaml') # loading configuration file, specifying hardware configuration and module configuration. # # Running primlist: runmngr.run_primlist('example_run_manager.plst', skip_remaining=True) # executing primlist.plst file, specific scan parameters are set inside the primlist file, skip remaining scans on error # Each scan has a default configuration, which is defined inside the corresponding scan file in /host/pybar/scans/. It is not necessary to define scan parameters inside primlist file. # # Running single scan and changing scan parameters: join = runmngr.run_run(run=AnalogScan, run_conf={"scan_parameters": [('PlsrDAC', 500)], "n_injections": 1000}, use_thread=True) # run_run returns a function object when use_thread is True status = join() print 'Status:', status # will wait for scan to be finished and returns run status # # Or use a run configuration file: status = runmngr.run_run(run=AnalogScan, run_conf="run_configuration.txt") # using no thread print 'Status:', status # # Example for a loop: for gdac in range(50, 200, 10): join = runmngr.run_run(ExtTriggerGdacScan, run_conf={'scan_parameters': {'GDAC': gdac}}, use_thread=True) # use thread print 'Status:', join(timeout=5) # join has a timeout, return None if run has not yet finished runmngr.abort_current_run() # stopping/aborting run from outside if join() != run_status.finished: # status OK? print 'ERROR!' break # jump out # # After finishing the primlist/run: you will find the module data relative to the configuration.yaml file.
self.register.set_pixel_register_value(mask, self.occ_mask) else: for mask in self.enable_for_mask: disable_mask = np.logical_or( self.occ_mask, self.register.get_pixel_register_value(mask)) self.register.set_pixel_register_value(mask, disable_mask) plot_occupancy(self.occ_mask.T, title='Noisy Pixels', z_max=1, filename=analyze_raw_data.output_pdf) plot_fancy_occupancy(self.occ_mask.T, z_max=1, filename=analyze_raw_data.output_pdf) for mask in self.disable_for_mask: mask_name = self.register.pixel_registers[mask]['name'] plot_occupancy(self.register.get_pixel_register_value(mask).T, title='%s Mask' % mask_name, z_max=1, filename=analyze_raw_data.output_pdf) for mask in self.enable_for_mask: mask_name = self.register.pixel_registers[mask]['name'] plot_occupancy(self.register.get_pixel_register_value(mask).T, title='%s Mask' % mask_name, z_max=1, filename=analyze_raw_data.output_pdf) if __name__ == "__main__": RunManager('../configuration.yaml').run_run(NoiseOccupancyScan)
self.gdacs = self.scan_parameters.GDAC logging.info("Scanning %s from %d to %d in %d steps" % ('GDAC', self.gdacs[0], self.gdacs[-1], len(self.gdacs))) def scan(self): for gdac in self.gdacs: if self.stop_run.is_set(): break self.register_utils.set_gdac(gdac) self.set_scan_parameters(GDAC=gdac) ExtTriggerScan.scan(self) self.stop_run.clear() def handle_data(self, data): self.raw_data_file.append_item(data, scan_parameters=self.scan_parameters._asdict(), new_file=True, flush=False) def get_gdacs_from_interpolated_calibration(self, calibration_file, thresholds): logging.info('Interpolate GDAC calibration for the thresholds %s' % str(thresholds)) with tb.openFile(calibration_file, mode="r") as in_file_calibration_h5: # read calibration file from calibrate_threshold_gdac scan interpolation = interp1d(in_file_calibration_h5.root.MeanThresholdCalibration[:]['mean_threshold'], in_file_calibration_h5.root.MeanThresholdCalibration[:]['gdac'], kind='slinear', bounds_error=True) return np.unique(interpolation(thresholds).astype(np.uint32)) def get_gdacs_from_calibration_file(self, calibration_file): logging.info('Take GDAC values from calibration file') with tb.openFile(calibration_file, mode="r") as in_file_calibration_h5: # read calibration file from calibrate_threshold_gdac scan return in_file_calibration_h5.root.MeanThresholdCalibration[:]['gdac'] if __name__ == "__main__": RunManager('../configuration.yaml').run_run(ExtTriggerGdacScan)
self.register.get_pixel_register_value('Enable')) if self.use_enable_mask else None, double_column_correction=self.pulser_dac_correction) def analyze(self): with AnalyzeRawData(raw_data_file=self.output_filename, create_pdf=True) as analyze_raw_data: analyze_raw_data.create_tot_hist = False analyze_raw_data.create_fitted_threshold_hists = True analyze_raw_data.create_threshold_mask = True analyze_raw_data.n_injections = 100 analyze_raw_data.interpreter.set_warning_output( False ) # so far the data structure in a threshold scan was always bad, too many warnings given analyze_raw_data.interpret_word_table() analyze_raw_data.interpreter.print_summary() analyze_raw_data.plot_histograms() with tb.open_file(analyze_raw_data._analyzed_data_file, 'r') as out_file_h5: thr_hist = out_file_h5.root.HistThresholdFitted[:, :].T xtalk_mask = np.zeros(shape=thr_hist.shape, dtype=np.dtype('>u1')) xtalk_mask[thr_hist > 0.0] = 1 plot_occupancy(xtalk_mask.T, title='Crosstalk', z_max=1, filename=analyze_raw_data.output_pdf) if __name__ == "__main__": RunManager('../configuration.yaml').run_run(CrosstalkScan)
} def configure(self): commands = [] commands.extend(self.register.get_commands("ConfMode")) self.register.set_global_register_value("PrmpVbp", 0) self.register.set_global_register_value("Amp2Vbp", 0) self.register.set_global_register_value("DisVbn", 0) commands.extend(self.register.get_commands("WrRegister", name=["PrmpVbp", "Amp2Vbp", "DisVbn"])) self.register.set_pixel_register_value("C_High", 0) commands.extend(self.register.get_commands("WrFrontEnd", same_mask_for_all_dc=True, name="C_High")) self.register.set_pixel_register_value("C_Low", 0) commands.extend(self.register.get_commands("WrFrontEnd", same_mask_for_all_dc=True, name="C_Low")) self.register_utils.send_commands(commands) def scan(self): with self.readout(): cal_lvl1_command = self.register.get_commands("CAL")[0] + self.register.get_commands("zeros", length=40)[0] + self.register.get_commands("LV1")[0] scan_loop(self, cal_lvl1_command, repeat_command=self.n_injections, use_delay=True, mask_steps=self.mask_steps, enable_mask_steps=None, enable_double_columns=None, same_mask_for_all_dc=True, eol_function=None, digital_injection=True, enable_shift_masks=["Enable", "EnableDigInj"], restore_shift_masks=False, mask=invert_pixel_mask(self.register.get_pixel_register_value('Enable')) if self.use_enable_mask else None) def analyze(self): with AnalyzeRawData(raw_data_file=self.output_filename, create_pdf=True) as analyze_raw_data: analyze_raw_data.interpreter.set_warning_output(True) analyze_raw_data.create_tot_hist = False analyze_raw_data.interpret_word_table() analyze_raw_data.plot_histograms() analyze_raw_data.interpreter.print_summary() if __name__ == "__main__": RunManager('../configuration.yaml').run_run(DigitalScan)
data_array['voltage_step'][index] = median_baseline - median_peak # Plot waveform + fit plt.clf() plt.grid() plt.plot(times * 1e9, voltages * 1e3, label='PlsrDAC Pulse') plt.axhline(y=trigger_level * 1e3, linewidth=2, linestyle="--", color='r', label='Trigger (%0.f mV)' % (trigger_level * 1e3)) plt.plot(times_baseline * 1e9, np.repeat(median_baseline * 1e3, times_baseline.size), '-', linewidth=2, label='Baseline (%.1f mV)' % (median_baseline * 1e3)) plt.plot(times_peak * 1e9, np.repeat(median_peak * 1e3, times_peak.size), '-', linewidth=2, label='Peak (%.1f mV)' % (median_peak * 1e3)) plt.title('PulserDAC=%d Waveform' % plsr_dac) plt.xlabel('Time [ns]') plt.ylabel('Voltage [mV]') plt.legend(loc=4) # lower right output_pdf.savefig() progress_bar.update(index) data_table.append(data_array[np.isfinite(data_array['voltage_step'])]) # store valid data # Plot, fit and store linear PlsrDAC transfer function select = np.isfinite(data_array['voltage_step']) x = data_array[select]['PlsrDAC'] y = data_array[select]['voltage_step'] slope_fit, slope_err, plateau_fit, plateau_err = plot_pulser_dac(x, y, output_pdf=output_pdf, title_suffix="(DC %d)" % (enable_double_columns[0],)) # Store result in file self.register.calibration_parameters['Vcal_Coeff_0'] = np.nan_to_num(slope_fit[0] * 1000.0) # store in mV self.register.calibration_parameters['Vcal_Coeff_1'] = np.nan_to_num(slope_fit[1] * 1000.0) # store in mV/DAC progress_bar.finish() if __name__ == "__main__": RunManager('../configuration.yaml').run_run(PlsrDacTransientCalibrationAdvanced)
scan_par_name, scan_parameter_value) commands.extend( self.register.get_commands("WrRegister", name=[scan_par_name])) commands.extend(self.register.get_commands("RunMode")) self.register_utils.send_commands(commands) self.dut['TDC']['EN_ARMING'] = True with self.readout(column=column, row=row, **{scan_par_name: scan_parameter_value}): self.register_utils.send_command( command=cal_lvl1_command, repeat=self.repeat_command) self.dut['TDC']['EN_ARMING'] = False self.dut['TDC']['ENABLE'] = False def handle_data(self, data): self.raw_data_file.append_item( data, scan_parameters=self.scan_parameters._asdict(), new_file=['column'], flush=False) # Create new file for each scan parameter change def analyze(self): create_hitor_calibration(self.output_filename) if __name__ == "__main__": RunManager('../configuration.yaml').run_run(HitOrCalibration)
self.register.restore() self.register_utils.configure_all() def analyze(self, show=False): logging.info('Analyze and plot results') x = self.data[:, 0] y = self.data[:, 1] yerr = self.data[:, 2] fit = polyfit( x[np.logical_and(x >= self.fit_range[0], x <= self.fit_range[1])], y[np.logical_and(x >= self.fit_range[0], x <= self.fit_range[1])], 1) fit_fn = poly1d(fit) data_plt = plt.errorbar(x, y, yerr) fit_plt, = plt.plot(x, fit_fn(x), '--k') plt.title(self.scan_parameter + ' calibration') plt.xlabel(self.scan_parameter) plt.ylabel('voltage [mV]') plt.grid(True) plt.legend([data_plt, fit_plt], ["data", str(fit_fn)], loc=0) if show: plt.show() else: plt.savefig(self.scan_data_filename + '.pdf') plt.close() if __name__ == "__main__": RunManager('../configuration.yaml').run_run(PlsrDacScan)
# Plot, fit and store linear PlsrDAC transfer function x, y = data_array[np.isfinite( data_array['voltage_step'])]['PlsrDAC'], data_array[ np.isfinite( data_array['voltage_step'])]['voltage_step'] fit = polyfit( x[np.logical_and(x >= fit_range[0], x <= fit_range[1])], y[np.logical_and(x >= fit_range[0], x <= fit_range[1])], 1) fit_fn = poly1d(fit) plt.clf() plt.plot(x, y, '.-', label='data') plt.plot(x, fit_fn(x), '--k', label=str(fit_fn)) plt.title('PlsrDAC calibration') plt.xlabel('PlsrDAC') plt.ylabel('Voltage step [V]') plt.grid(True) plt.legend(loc=0) output_pdf.savefig() # Store result in file self.register.calibration_parameters[ 'Vcal_Coeff_0'] = fit[1] * 1000. # store in mV self.register.calibration_parameters[ 'Vcal_Coeff_1'] = fit[0] * 1000. # store in mV/DAC progress_bar.finish() if __name__ == "__main__": RunManager('../configuration.yaml').run_run(PlsrDacTransientScan)
self.register_utils.send_commands(commands) def set_prmp_vbpf_bit(self, bit_position, bit_value=1): commands = [] commands.extend(self.register.get_commands("ConfMode")) if bit_value == 1: self.register.set_global_register_value( "PrmpVbpf", self.register.get_global_register_value("PrmpVbpf") | (1 << bit_position)) else: self.register.set_global_register_value( "PrmpVbpf", self.register.get_global_register_value("PrmpVbpf") & ~(1 << bit_position)) commands.extend( self.register.get_commands("WrRegister", name=["PrmpVbpf"])) self.register_utils.send_commands(commands) def start_readout(self, **kwargs): if kwargs: self.set_scan_parameters(**kwargs) self.fifo_readout.start(reset_sram_fifo=True, clear_buffer=True, callback=None, errback=self.handle_err) if __name__ == "__main__": RunManager('../configuration.yaml').run_run(FeedbackTuning)
callback=self.handle_data, errback=self.handle_err, no_data_timeout=self.no_data_timeout) self.dut['tdc_rx2']['ENABLE'] = self.enable_tdc self.dut['tlu'].RESET self.dut['tlu']['TRIGGER_MODE'] = self.trigger_mode self.dut['tlu']['EN_WRITE_TIMESTAMP'] = True self.dut['cmd']['EN_EXT_TRIGGER'] = True def timeout(): try: self.progressbar.finish() except AttributeError: pass self.stop(msg='Scan timeout was reached') self.scan_timeout_timer = Timer(self.scan_timeout, timeout) if self.scan_timeout: self.scan_timeout_timer.start() def stop_readout(self): self.scan_timeout_timer.cancel() self.dut['tdc_rx2']['ENABLE'] = False self.dut['cmd']['EN_EXT_TRIGGER'] = False self.dut['tlu']['TRIGGER_MODE'] = 0 self.fifo_readout.stop() if __name__ == "__main__": RunManager('../configuration.yaml').run_run(StopModeExtTriggerScan)
self.register_utils.configure_pixel() commands = [] commands.extend(self.register.get_commands("ConfMode")) self.register_utils.send_commands(commands) self.fifo_readout.reset_sram_fifo() plots = PdfPages(self.output_filename + ".pdf") for i, result in enumerate( read_pixel_register(self, pix_regs=pix_regs, dcs=dcs)): result_array = np.ones_like(result) result_array.data[result == self.register.get_pixel_register_value( pix_regs[i])] = 0 logging.info("Pixel register %s: %d pixel error" % (pix_regs[i], np.count_nonzero(result_array == 1))) plotting.plotThreeWay( result_array.T, title=str(pix_regs[i]) + " register test with " + str(np.count_nonzero(result_array == 1)) + '/' + str(26880 - np.ma.count_masked(result_array)) + " pixel failing", x_axis_title="0:OK, 1:FAIL", maximum=1, filename=plots) plots.close() if __name__ == "__main__": RunManager('../configuration.yaml').run_run(RegisterTest)
if np.all(np.isfinite( charge_calibration[column, row, :, 1])) and np.all( np.isfinite(charge_calibration[column, row, :, 3])): mean_signal_to_noise += ( charge_calibration[column, row, :, 1] / charge_calibration[column, row, :, 3]) mean_signal_to_noise /= valid_pixel[0].shape[0] return mean_signal_to_noise if __name__ == "__main__": plsr_dacs = [40, 50, 60, 80, 130, 180, 230, 280, 340, 440, 540, 640, 740] # PlsrDAC setting for hit OR calibration scan runmngr = RunManager(r'../../pybar/configuration.yaml') runmngr.run_run(run=FastThresholdScan) # initial threshold check actual_vthin_alt_fine = runmngr.current_run.register.get_global_register_value( "Vthin_AltFine") sns = [] # SN values # Take data for dis_vbn in [ 40, ]: # analog discriminator bias loop for vthin_alt_fine in range(actual_vthin_alt_fine, 256, 100): # threshold loop for prmp_vbpf in range(0, 256, 32): # feedback current loop runmngr.current_run.register.set_global_register_value( "PrmpVbpf", prmp_vbpf) runmngr.current_run.register.set_global_register_value(
import logging from pybar.fei4_run_base import Fei4RunBase from pybar.run_manager import RunManager class Init(Fei4RunBase): '''Init scan ''' _default_run_conf = {} def configure(self): pass def scan(self): logging.info('Init run...') def analyze(self): pass if __name__ == "__main__": RunManager('../configuration.yaml').run_run(Init)
if self.enable_tdc: # activate TDC arming self.dut['TDC']['EN_ARMING'] = True scan_loop(self, cal_lvl1_command, repeat_command=self.n_injections, use_delay=True, mask_steps=self.mask_steps, enable_mask_steps=self.enable_mask_steps, enable_double_columns=self.enable_double_columns, same_mask_for_all_dc=self.same_mask_for_all_dc, bol_function=self.activate_tdc, eol_function=self.deactivate_tdc, digital_injection=False, enable_shift_masks=self.enable_shift_masks, disable_shift_masks=self.disable_shift_masks, restore_shift_masks=False, mask=invert_pixel_mask(self.register.get_pixel_register_value('Enable')) if self.use_enable_mask else None, double_column_correction=self.pulser_dac_correction) else: scan_loop(self, cal_lvl1_command, repeat_command=self.n_injections, use_delay=True, mask_steps=self.mask_steps, enable_mask_steps=self.enable_mask_steps, enable_double_columns=self.enable_double_columns, same_mask_for_all_dc=self.same_mask_for_all_dc, digital_injection=False, enable_shift_masks=self.enable_shift_masks, disable_shift_masks=self.disable_shift_masks, restore_shift_masks=False, mask=invert_pixel_mask(self.register.get_pixel_register_value('Enable')) if self.use_enable_mask else None, double_column_correction=self.pulser_dac_correction) # plotting data # plot_occupancy(hist=make_occupancy_hist(*convert_data_array(data_array_from_data_dict_iterable(self.fifo_readout.data), filter_func=is_data_record, converter_func=get_col_row_array_from_data_record_array)), z_max='median', filename=self.scan_data_filename + "_occupancy.pdf") def analyze(self): with AnalyzeRawData(raw_data_file=self.output_filename, create_pdf=True) as analyze_raw_data: analyze_raw_data.create_tot_hist = True if self.enable_tdc: analyze_raw_data.create_tdc_counter_hist = True # histogram all TDC words analyze_raw_data.create_tdc_hist = True # histogram the hit TDC information analyze_raw_data.interpreter.use_tdc_word(True) # align events at the TDC word analyze_raw_data.interpret_word_table() analyze_raw_data.plot_histograms() analyze_raw_data.interpreter.print_summary() def activate_tdc(self): self.dut['TDC']['ENABLE'] = True def deactivate_tdc(self): self.dut['TDC']['ENABLE'] = False if __name__ == "__main__": RunManager('../configuration.yaml').run_run(AnalogScan)
corr = [thr_masked[:, 0].mean()] corr.extend([ thr_masked[:, i * 2 + 1:i * 2 + 3].mean() for i in range(0, 38) ]) corr.extend([thr_masked[:, 77:79].mean()]) corr = np.array(corr) corr -= corr.min() corr = np.around(corr, decimals=2) if "C_High".lower() in map( lambda x: x.lower(), self.enable_shift_masks) and "C_Low".lower() in map( lambda x: x.lower(), self.enable_shift_masks): self.register.calibration_parameters[ 'Pulser_Corr_C_Inj_High'] = list(corr) elif "C_High".lower() in map(lambda x: x.lower(), self.enable_shift_masks): self.register.calibration_parameters[ 'Pulser_Corr_C_Inj_Med'] = list(corr) elif "C_Low".lower() in map(lambda x: x.lower(), self.enable_shift_masks): self.register.calibration_parameters[ 'Pulser_Corr_C_Inj_Low'] = list(corr) else: raise ValueError('Unknown C_Inj') if __name__ == "__main__": RunManager('../configuration.yaml').run_run(PulserDacCorrectionCalibration)
for pulse_delay in [i for j in (range(0, 100, 5), range(100, 500, 500)) for i in j]: logging.info('Test TDC for a pulse delay of %d', pulse_delay) for _ in range(10): self.start_pulser(pulse_width=100, n_pulses=1, pulse_delay=pulse_delay) time.sleep(0.1) data = self.fifo_readout.read_data() if data[is_tdc_word(data)].shape[0] != 0: if len(is_tdc_word(data)) != 10: logging.warning('%d TDC words instead of %d ', len(is_tdc_word(data)), 10) tdc_values = np.bitwise_and(data[is_tdc_word(data)], 0x00000FFF) tdc_delay = np.bitwise_and(data[is_tdc_word(data)], 0x0FF00000) tdc_delay = np.right_shift(tdc_delay, 20) x.append(pulse_delay) y.append(np.mean(tdc_delay)) y_err.append(np.std(tdc_delay)) y2.append(np.mean(tdc_values)) y2_err.append(np.std(tdc_values)) else: logging.warning('No TDC words, check connection!') plotting.plot_scatter(x, y2, y2_err, title='FPGA TDC for different delays, ' + str(self.n_pulses) + ' each', x_label='Pulse delay [ns]', y_label='TDC value', filename=output_pdf) plotting.plot_scatter(x, y, y_err, title='FPGA TDC trigger delay, ' + str(10) + ' each', x_label='Pulse delay [ns]', y_label='TDC trigger delay', filename=output_pdf) plotting.plot_scatter(x, y_err, title='FPGA TDC trigger delay RMS, ' + str(10) + ' each', x_label='Pulse delay [ns]', y_label='TDC trigger delay RMS', filename=output_pdf) def analyze(self): pass if __name__ == "__main__": RunManager('../configuration.yaml').run_run(TdcTest)
def start_readout(self, **kwargs): if kwargs: self.set_scan_parameters(**kwargs) self.fifo_readout.start(reset_sram_fifo=False, clear_buffer=True, callback=self.handle_data, errback=self.handle_err, no_data_timeout=self.no_data_timeout) self.set_self_trigger(True) def timeout(): try: self.progressbar.finish() except AttributeError: pass self.stop(msg='Scan timeout was reached') self.scan_timeout_timer = Timer(self.scan_timeout, timeout) if self.scan_timeout: self.scan_timeout_timer.start() def stop_readout(self, timeout=10.0): self.set_self_trigger(False) self.scan_timeout_timer.cancel() self.fifo_readout.stop(timeout=timeout) if __name__ == "__main__": RunManager('../configuration.yaml').run_run(FEI4SelfTriggerScan)
self.register.set_pixel_register_value('Imon', mask) commands.extend( self.register.get_commands("WrFrontEnd", same_mask_for_all_dc=False, name='Imon')) self.register_utils.send_commands(commands) # Read and store voltage voltage_string = self.dut['Multimeter'].get_voltage() voltage = float(voltage_string.split(',')[0][:-4]) self.ileakmap[column - 1, row - 1] = voltage progress_bar.update(pixel_index) progress_bar.finish() data_out[:] = self.ileakmap def analyze(self): with tb.open_file(self.output_filename + '.h5', 'r') as in_file_h5: data = in_file_h5.root.Ileak_map[:] data = np.ma.masked_where(data == 0, data) plot_three_way(hist=data.transpose(), title="Ileak", x_axis_title="Ileak", filename=self.output_filename + '.pdf') # , minimum=0, maximum=np.amax(data)) if __name__ == "__main__": RunManager('../configuration.yaml').run_run(IleakScan)
"zeros", length=40)[0] + self.register.get_commands("LV1")[0] with self.readout(plsr_dac_value, delay_parameter_value): scan_loop( self, cal_lvl1_command, repeat_command=self.n_injections, use_delay=True, mask_steps=self.mask_steps, enable_mask_steps=None, enable_double_columns=None, same_mask_for_all_dc=True, eol_function=None, digital_injection=False, enable_shift_masks=self.enable_shift_masks, disable_shift_masks=self.disable_shift_masks, restore_shift_masks=False, mask=invert_pixel_mask( self.register.get_pixel_register_value('Enable')) if self.use_enable_mask else None, double_column_correction=self.pulser_dac_correction) def analyze(self): analyze_hit_delay(self.output_filename) if __name__ == "__main__": RunManager('..\configuration.yaml').run_run(HitDelayScan) # analyze_hit_delay(r'L:\hitdelay\2_scc_99_hit_delay_scan')
title='TDAC at Vthin_AltFine %d Step %d' % (self.last_reg_val, self.last_step), x_axis_title="TDAC", filename=analyze_raw_data.output_pdf, maximum=31, bins=32) plot_occupancy(self.last_tdac_distribution.T, title='TDAC at Vthin_AltFine %d Step %d' % (self.last_reg_val, self.last_step), z_max=31, filename=analyze_raw_data.output_pdf) plot_occupancy(self.register.get_pixel_register_value('Enable').T, title='Enable Mask', z_max=1, filename=analyze_raw_data.output_pdf) plot_fancy_occupancy( self.register.get_pixel_register_value('Enable').T, filename=analyze_raw_data.output_pdf) def start_readout(self, **kwargs): if kwargs: self.set_scan_parameters(**kwargs) self.fifo_readout.start(reset_sram_fifo=True, reset_rx=False, clear_buffer=True, callback=None, errback=self.handle_err) if __name__ == "__main__": RunManager('../configuration.yaml').run_run(ThresholdBaselineTuning)
pp = PyProducer("PyBAR", rcaddr) while not pp.Error and not pp.Terminating: # wait for configure cmd from RunControl while not pp.Configuring and not pp.Terminating: if pp.StartingRun: break sleep(1) # check if configuration received if pp.Configuring: print "Configuring..." # for item in run_conf: # try: # run_conf[item] = pp.GetConfigParameter(item) # except: # pass rmngr = RunManager( '../configuration.yaml') # TODO: get conf from EUDAQ pp.Configuring = True # check for start of run cmd from RunControl while not pp.StartingRun and not pp.Terminating: if pp.Configuring: break sleep(1) # check if we are starting: if pp.StartingRun: print "Starting run..." # join = rmngr.run_run(EudaqExtTriggerScan, run_conf=run_conf, use_thread=True) join = rmngr.run_run(EudaqExtTriggerScan, use_thread=True) sleep(5) pp.StartingRun = True # set status and send BORE # starting to run while join(timeout=1) is None:
# use this if no FE-I4 is connected # self.dut['TLU']['TRIGGER_ENABLE'] = True def timeout(): try: self.progressbar.finish() except AttributeError: pass self.stop(msg='Scan timeout was reached') self.scan_timeout_timer = Timer(self.scan_timeout, timeout) if self.scan_timeout: self.scan_timeout_timer.start() def stop_readout(self, timeout=10.0): self.scan_timeout_timer.cancel() self.dut['TLU']['TRIGGER_ENABLE'] = False self.dut['CMD']['EN_EXT_TRIGGER'] = False self.dut['M26_RX1'].set_en(False) self.dut['M26_RX2'].set_en(False) self.dut['M26_RX3'].set_en(False) self.dut['M26_RX4'].set_en(False) self.dut['M26_RX5'].set_en(False) self.dut['M26_RX6'].set_en(False) self.fifo_readout.stop(timeout=timeout) if __name__ == "__main__": RunManager('../configuration.yaml').run_run(M26TelescopeScan)