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 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_send_commands, mock_configure_pixel):
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)
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)
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)
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)
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)
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)
"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)
def pre_run(self):
# clear error queue in case run is executed a second time
self.err_queue.queue.clear()
# opening ZMQ context and binding socket
if self._conf['send_data'] and not self._conf['zmq_context']:
logging.info('Creating ZMQ context')
self._conf['zmq_context'] = zmq.Context() # contexts are thread safe unlike sockets
else:
logging.info('Using existing socket')
# scan parameters
if 'scan_parameters' in self._run_conf:
if isinstance(self._run_conf['scan_parameters'], basestring):
self._run_conf['scan_parameters'] = ast.literal_eval(self._run_conf['scan_parameters'])
sp = namedtuple('scan_parameters', field_names=zip(*self._run_conf['scan_parameters'])[0])
self.scan_parameters = sp(*zip(*self._run_conf['scan_parameters'])[1])
else:
sp = namedtuple_with_defaults('scan_parameters', field_names=[])
self.scan_parameters = sp()
logging.info('Scan parameter(s): %s', ', '.join(['%s=%s' % (key, value) for (key, value) in self.scan_parameters._asdict().items()]) if self.scan_parameters else 'None')
# init DUT
if not isinstance(self._conf['dut'], Dut):
module_path = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
if isinstance(self._conf['dut'], basestring):
# dirty fix for Windows pathes
self._conf['dut'] = os.path.normpath(self._conf['dut'].replace('\\', '/'))
# abs path
if os.path.isabs(self._conf['dut']):
dut = self._conf['dut']
# working dir
elif os.path.exists(os.path.join(self._conf['working_dir'], self._conf['dut'])):
dut = os.path.join(self._conf['working_dir'], self._conf['dut'])
# path of this file
elif os.path.exists(os.path.join(module_path, self._conf['dut'])):
dut = os.path.join(module_path, self._conf['dut'])
else:
raise ValueError('dut parameter not a valid path: %s' % self._conf['dut'])
else:
dut = self._conf['dut']
dut = Dut(dut)
# only initialize when DUT was not initialized before
if 'dut_configuration' in self._conf and self._conf['dut_configuration']:
if isinstance(self._conf['dut_configuration'], basestring):
# dirty fix for Windows pathes
self._conf['dut_configuration'] = os.path.normpath(self._conf['dut_configuration'].replace('\\', '/'))
# abs path
if os.path.isabs(self._conf['dut_configuration']):
dut_configuration = self._conf['dut_configuration']
# working dir
elif os.path.exists(os.path.join(self._conf['working_dir'], self._conf['dut_configuration'])):
dut_configuration = os.path.join(self._conf['working_dir'], self._conf['dut_configuration'])
# path of dut file
elif os.path.exists(os.path.join(os.path.dirname(dut.conf_path), self._conf['dut_configuration'])):
dut_configuration = os.path.join(os.path.dirname(dut.conf_path), self._conf['dut_configuration'])
# path of this file
elif os.path.exists(os.path.join(module_path, self._conf['dut_configuration'])):
dut_configuration = os.path.join(module_path, self._conf['dut_configuration'])
else:
raise ValueError('dut_configuration parameter not a valid path: %s' % self._conf['dut_configuration'])
# make dict
dut_configuration = RunManager.open_conf(dut_configuration)
# change bit file path
if 'USB' in dut_configuration and 'bit_file' in dut_configuration['USB'] and dut_configuration['USB']['bit_file']:
bit_file = os.path.normpath(dut_configuration['USB']['bit_file'].replace('\\', '/'))
# abs path
if os.path.isabs(bit_file):
pass
# working dir
elif os.path.exists(os.path.join(self._conf['working_dir'], bit_file)):
bit_file = os.path.join(self._conf['working_dir'], bit_file)
# path of dut file
elif os.path.exists(os.path.join(os.path.dirname(dut.conf_path), bit_file)):
bit_file = os.path.join(os.path.dirname(dut.conf_path), bit_file)
# path of this file
elif os.path.exists(os.path.join(module_path, bit_file)):
bit_file = os.path.join(module_path, bit_file)
else:
raise ValueError('bit_file parameter not a valid path: %s' % bit_file)
dut_configuration['USB']['bit_file'] = bit_file
else:
dut_configuration = self._conf['dut_configuration']
else:
dut_configuration = None
dut.init(dut_configuration)
# assign dut after init in case of exceptions during init
self._conf['dut'] = dut
# additional init of the DUT
self.init_dut()
else:
pass # do nothing, already initialized
# FIFO readout
self.fifo_readout = FifoReadout(self.dut)
# initialize the FE
self.init_fe()
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.
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)
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)
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)
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)
# 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.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)
# 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)
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:
# Settings
bias_voltage = -80
max_iv_voltage = -100
# Tuning
cref = 12
target_threshold = 34
target_charge = 300
target_tot = 9
# TDC measurements
plsr_dacs = [target_threshold, 40, 50, 60, 80, 100, 120, 150, 200, 250, 300, 350, 400, 500, 600, 700, 800] # PlsrDAC range for TDC calibration, should start at threshold
col_span = [55, 75]#[50, 78] # pixel column range to use in TDC scans
row_span = [125, 225]#[20, 315] # pixel row range to use in TDC scans
tdc_pixel = make_box_pixel_mask_from_col_row(column=[col_span[0], col_span[1]], row=[row_span[0], row_span[1]]) # edge pixel are not used in analysis
runmngr = RunManager('configuration.yaml')
# IV scan
runmngr.run_run(run=IVScan, run_conf={"voltages": np.arange(-1, max_iv_voltage - 1, -1), "max_voltage": max_iv_voltage, "bias_voltage": bias_voltage, "minimum_delay": 0.5})
# FE check and complete tuning
runmngr.run_run(run=RegisterTest)
runmngr.run_run(run=DigitalScan) # digital scan with std. settings
if runmngr.current_run.register.flavor == 'fei4a': # FEI4 A related config changes, Deactivate noisy edge columns if FE-I4A
runmngr.current_run.register.set_global_register_value("DisableColumnCnfg", 549755813891) # Disable noisy columns
runmngr.current_run.register.set_global_register_value("Cref", cref) # Set correct cref
runmngr.current_run.register.save_configuration(runmngr.current_run.register.configuration_file)
runmngr.run_run(run=DigitalScan) # repeat digital scan with specific settings
runmngr.run_run(run=Fei4Tuning, run_conf={'target_threshold': target_threshold, 'target_tot': target_tot, 'target_charge': target_charge}, catch_exception=False)
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)
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)
}
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)
with tb.open_file(filename + '_calibration.h5', 'r') as in_file_h5:
charge_calibration = in_file_h5.root.HitOrCalibration[:]
plsr_dacs = in_file_h5.root.HitOrCalibration._v_attrs.scan_parameter_values
valid_pixel = np.where(charge_calibration.sum(axis=(2, 3)) > 0) # valid pixel have data and a calibration (that is any charge(TDC) calibration != 0)
mean_signal_to_noise = np.zeros(len(plsr_dacs))
for (column, row) in np.column_stack(valid_pixel):
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]
runmngr = RunManager(r'../../pybar/configuration.yaml')
runmngr.run_run(run=FastThresholdScan)
sns = []
actual_vthin_alt_fine = runmngr.current_run.register.get_global_register_value("Vthin_AltFine")
for dis_vbn in [40, ]:
for vthin_alt_fine in range(actual_vthin_alt_fine, 256, 100):
for prmp_vbpf in range(0, 256, 32):
runmngr.current_run.register.set_global_register_value("PrmpVbpf", prmp_vbpf)
runmngr.current_run.register.set_global_register_value("Vthin_AltFine", vthin_alt_fine)
runmngr.current_run.register.set_global_register_value("DisVbn", dis_vbn)
runmngr.run_run(run=HitOrCalibration, run_conf={
'reset_rx_on_error': True,
"pixels": ((10, 10), (30, 100), (50, 200), (70, 300)),
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)
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)
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)
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)
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)
from pybar.run_manager import RunManager # importing run manager
from pybar.scans.scan_digital import DigitalScan
from pybar.scans.scan_analog import AnalogScan
from pybar.scans.scan_threshold import ThresholdScan
from pybar.scans.tune_fei4 import Fei4Tuning
from pybar.scans.tune_stuck_pixel import StuckPixelScan
from pybar.scans.tune_noise_occupancy import NoiseOccupancyScan
from pybar.scans.tune_merged_pixels import MergedPixelsTuning
# additional run configuration (optinal)
run_conf = None # use path to YAML file, or dict
if __name__ == "__main__":
runmngr = RunManager('../../pybar/configuration.yaml') # configuration YAML file, open it for more details, it may contain run configuration
# pre tuning
status = runmngr.run_run(run=DigitalScan, run_conf=run_conf)
print 'Status:', status
status = runmngr.run_run(run=ThresholdScan, run_conf=run_conf)
print 'Status:', status
status = runmngr.run_run(run=AnalogScan, run_conf=run_conf)
print 'Status:', status
# tuning
status = runmngr.run_run(run=Fei4Tuning, run_conf=run_conf)
print 'Status:', status
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)
from pybar.run_manager import run_status
# Execute this script from the shell: python example_run_manager.py
#
# This script can also be run from a Python interactive shell (e.g. IPython).
if __name__ == "__main__":
# The FE flavor can be set inside configuration.yaml (set the value to fei4a or fei4b).
# The initial FE configuration will be created during the first run.
#
# (from configuration.yaml)
# fe_flavor : fei4a
# ...
#
# Initializing the run manager:
runmngr = RunManager('../../pybar/configuration.yaml') # loading configuration file, specifying hardware configuration and module configuration.
#
# During the first run, an module data directory relative to the configuration.yaml file will be created.
# If configuration.yaml is placed inside /host/pybar/ the module data will be stored inside /host/pybar/<module_id> (where <module_id> is defined inside configuration.yaml).
#
# If fe_configuration inside configuration.yaml is not given, the latest valid FE configuration file will be taken (the file with the highest run number and run status 'FINISHED').
#
# (from configuration.yaml)
# fe_configuration:
# ...
#
# If no configuration file exists, a initial configuration will be create according to fe_flavor.
# To load a specific configuration file, a path to FE configuration file or a run number (e.g. 5) can be given:
#
# (from configuration.yaml)
# fe_configuration: 1
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)
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)
"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')
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(
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:
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)
