def analyze(self):
with tb.open_file(self.output_filename + '.h5', 'r') as in_file_h5:
scan_parameters = in_file_h5.root.scan_parameters[:] # Table with the scan parameter value for every readout
meta_data = in_file_h5.root.meta_data[:]
data_words = in_file_h5.root.raw_data[:]
if data_words.shape[0] == 0:
raise RuntimeError('No trigger words recorded')
readout_indices = [i[1] for i in analysis_utils.get_meta_data_index_at_scan_parameter(scan_parameters, 'TRIGGER_DATA_DELAY')] # Readout indices where the scan parameter changed
with tb.open_file(self.output_filename + '_interpreted.h5', 'w') as out_file_h5:
with PdfPages(self.output_filename + '_interpreted.pdf') as output_pdf:
description = [('TRIGGER_DATA_DELAY', np.uint8), ('error_rate', np.float)] # Output data table description
data_array = np.zeros((len(readout_indices),), dtype=description)
data_table = out_file_h5.create_table(out_file_h5.root, name='error_rate', description=np.zeros((1,), dtype=description).dtype, title='Trigger number error rate for different data delay values')
for index, (index_low, index_high) in enumerate(analysis_utils.get_ranges_from_array(readout_indices)): # Loop over the scan parameter data
data_array['TRIGGER_DATA_DELAY'][index] = scan_parameters['TRIGGER_DATA_DELAY'][index_low]
word_index_start = meta_data[index_low]['index_start']
word_index_stop = meta_data[index_high]['index_start'] if index_high is not None else meta_data[-1]['index_stop']
actual_raw_data = data_words[word_index_start:word_index_stop]
selection = np.logical_and(actual_raw_data, 0x80000000) # Select the trigger words in the data stream
trigger_words = np.bitwise_and(actual_raw_data[selection], 0x7FFFFFFF) # Get the trigger values
if selection.shape[0] != word_index_stop - word_index_start:
logging.warning('There are not only trigger words in the data stream')
actual_errors = np.count_nonzero(np.diff(trigger_words[trigger_words != 0x7FFFFFFF]) != 1)
data_array['error_rate'][index] = float(actual_errors) / selection.shape[0]
# Plot trigger number
fig = Figure()
FigureCanvas(fig)
ax = fig.add_subplot(111)
ax.plot(range(trigger_words.shape[0]), trigger_words, '-', label='data')
ax.set_title('Trigger words for delay setting index %d' % index)
ax.set_xlabel('Trigger word index')
ax.set_ylabel('Trigger word')
ax.grid(True)
ax.legend(loc=0)
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)
def analyze_cluster_size_per_scan_parameter(input_file_hits,
output_file_cluster_size,
parameter='GDAC',
max_chunk_size=10000000,
overwrite_output_files=False,
output_pdf=None):
''' This method takes multiple hit files and determines the cluster size for different scan parameter values of
Parameters
----------
input_files_hits: string
output_file_cluster_size: string
The data file with the results
parameter: string
The name of the parameter to separate the data into (e.g.: PlsrDAC)
max_chunk_size: int
the maximum chunk size used during read, if too big memory error occurs, if too small analysis takes longer
overwrite_output_files: bool
Set to true to overwrite the output file if it already exists
output_pdf: PdfPages
PdfPages file object, if none the plot is printed to screen, if False nothing is printed
'''
logging.info('Analyze the cluster sizes for different ' + parameter +
' settings for ' + input_file_hits)
if os.path.isfile(
output_file_cluster_size
) and not overwrite_output_files: # skip analysis if already done
logging.info('Analyzed cluster size file ' + output_file_cluster_size +
' already exists. Skip cluster size analysis.')
else:
with tb.open_file(
output_file_cluster_size,
mode="w") as out_file_h5: # file to write the data into
filter_table = tb.Filters(
complib='blosc', complevel=5,
fletcher32=False) # compression of the written data
parameter_goup = out_file_h5.create_group(
out_file_h5.root, parameter,
title=parameter) # note to store the data
cluster_size_total = None # final array for the cluster size per GDAC
with tb.open_file(
input_file_hits,
mode="r+") as in_hit_file_h5: # open the actual hit file
meta_data_array = in_hit_file_h5.root.meta_data[:]
scan_parameter = analysis_utils.get_scan_parameter(
meta_data_array) # get the scan parameters
if scan_parameter: # if a GDAC scan parameter was used analyze the cluster size per GDAC setting
scan_parameter_values = scan_parameter[
parameter] # scan parameter settings used
if len(
scan_parameter_values
) == 1: # only analyze per scan step if there are more than one scan step
logging.warning('The file ' + str(input_file_hits) +
' has no different ' + str(parameter) +
' parameter values. Omit analysis.')
else:
logging.info('Analyze ' + input_file_hits +
' per scan parameter ' + parameter +
' for ' +
str(len(scan_parameter_values)) +
' values from ' +
str(np.amin(scan_parameter_values)) +
' to ' +
str(np.amax(scan_parameter_values)))
event_numbers = analysis_utils.get_meta_data_at_scan_parameter(
meta_data_array, parameter
)['event_number'] # get the event numbers in meta_data where the scan parameter changes
parameter_ranges = np.column_stack(
(scan_parameter_values,
analysis_utils.get_ranges_from_array(
event_numbers)))
hit_table = in_hit_file_h5.root.Hits
analysis_utils.index_event_number(hit_table)
total_hits, total_hits_2, index = 0, 0, 0
chunk_size = max_chunk_size
# initialize the analysis and set settings
analyze_data = AnalyzeRawData()
analyze_data.create_cluster_size_hist = True
analyze_data.create_cluster_tot_hist = True
analyze_data.histogram.set_no_scan_parameter(
) # one has to tell histogram the # of scan parameters for correct occupancy hist allocation
progress_bar = progressbar.ProgressBar(
widgets=[
'',
progressbar.Percentage(), ' ',
progressbar.Bar(marker='*',
left='|',
right='|'), ' ',
progressbar.AdaptiveETA()
],
maxval=hit_table.shape[0],
term_width=80)
progress_bar.start()
for parameter_index, parameter_range in enumerate(
parameter_ranges
): # loop over the selected events
analyze_data.reset(
) # resets the data of the last analysis
logging.debug(
'Analyze GDAC = ' + str(parameter_range[0]) +
' ' + str(
int(
float(
float(parameter_index) /
float(len(parameter_ranges)) *
100.0))) + '%')
start_event_number = parameter_range[1]
stop_event_number = parameter_range[2]
logging.debug('Data from events = [' +
str(start_event_number) + ',' +
str(stop_event_number) + '[')
actual_parameter_group = out_file_h5.create_group(
parameter_goup,
name=parameter + '_' + str(parameter_range[0]),
title=parameter + '_' +
str(parameter_range[0]))
# loop over the hits in the actual selected events with optimizations: variable chunk size, start word index given
readout_hit_len = 0 # variable to calculate a optimal chunk size value from the number of hits for speed up
for hits, index in analysis_utils.data_aligned_at_events(
hit_table,
start_event_number=start_event_number,
stop_event_number=stop_event_number,
start_index=index,
chunk_size=chunk_size):
total_hits += hits.shape[0]
analyze_data.analyze_hits(
hits
) # analyze the selected hits in chunks
readout_hit_len += hits.shape[0]
progress_bar.update(index)
chunk_size = int(1.05 * readout_hit_len) if int(
1.05 * readout_hit_len
) < max_chunk_size else max_chunk_size # to increase the readout speed, estimated the number of hits for one read instruction
if chunk_size < 50: # limit the lower chunk size, there can always be a crazy event with more than 20 hits
chunk_size = 50
# get occupancy hist
occupancy = analyze_data.histogram.get_occupancy(
) # just check here if histogram is consistent
# store and plot cluster size hist
cluster_size_hist = analyze_data.clusterizer.get_cluster_size_hist(
)
cluster_size_hist_table = out_file_h5.create_carray(
actual_parameter_group,
name='HistClusterSize',
title='Cluster Size Histogram',
atom=tb.Atom.from_dtype(
cluster_size_hist.dtype),
shape=cluster_size_hist.shape,
filters=filter_table)
cluster_size_hist_table[:] = cluster_size_hist
if output_pdf is not False:
plotting.plot_cluster_size(
hist=cluster_size_hist,
title='Cluster size (' +
str(np.sum(cluster_size_hist)) +
' entries) for ' + parameter + ' = ' +
str(scan_parameter_values[parameter_index]
),
filename=output_pdf)
if cluster_size_total is None: # true if no data was appended to the array yet
cluster_size_total = cluster_size_hist
else:
cluster_size_total = np.vstack(
[cluster_size_total, cluster_size_hist])
total_hits_2 += np.sum(occupancy)
progress_bar.finish()
if total_hits != total_hits_2:
logging.warning(
'Analysis shows inconsistent number of hits. Check needed!'
)
logging.info('Analyzed %d hits!', total_hits)
cluster_size_total_out = out_file_h5.create_carray(
out_file_h5.root,
name='AllHistClusterSize',
title='All Cluster Size Histograms',
atom=tb.Atom.from_dtype(cluster_size_total.dtype),
shape=cluster_size_total.shape,
filters=filter_table)
cluster_size_total_out[:] = cluster_size_total
def analyze_hits_per_scan_parameter(analyze_data,
scan_parameters=None,
chunk_size=50000):
'''Takes the hit table and analyzes the hits per scan parameter
Parameters
----------
analyze_data : analysis.analyze_raw_data.AnalyzeRawData object with an opened hit file (AnalyzeRawData.out_file_h5) or a
file name with the hit data given (AnalyzeRawData._analyzed_data_file)
scan_parameters : list of strings:
The names of the scan parameters to use
chunk_size : int:
The chunk size of one hit table read. The bigger the faster. Too big causes memory errors.
Returns
-------
yields the analysis.analyze_raw_data.AnalyzeRawData for each scan parameter
'''
if analyze_data.out_file_h5 is None or analyze_data.out_file_h5.isopen == 0:
in_hit_file_h5 = tb.open_file(analyze_data._analyzed_data_file, 'r+')
close_file = True
else:
in_hit_file_h5 = analyze_data.out_file_h5
close_file = False
meta_data = in_hit_file_h5.root.meta_data[:] # get the meta data table
try:
hit_table = in_hit_file_h5.root.Hits # get the hit table
except tb.NoSuchNodeError:
logging.error(
'analyze_hits_per_scan_parameter needs a hit table, but no hit table found.'
)
return
meta_data_table_at_scan_parameter = analysis_utils.get_unique_scan_parameter_combinations(
meta_data, scan_parameters=scan_parameters)
parameter_values = analysis_utils.get_scan_parameters_table_from_meta_data(
meta_data_table_at_scan_parameter, scan_parameters)
event_number_ranges = analysis_utils.get_ranges_from_array(
meta_data_table_at_scan_parameter['event_number']
) # get the event number ranges for the different scan parameter settings
analysis_utils.index_event_number(
hit_table
) # create a event_numer index to select the hits by their event number fast, no needed but important for speed up
# variables for read speed up
index = 0 # index where to start the read out of the hit table, 0 at the beginning, increased during looping
best_chunk_size = chunk_size # number of hits to copy to RAM during looping, the optimal chunk size is determined during looping
# loop over the selected events
for parameter_index, (start_event_number,
stop_event_number) in enumerate(event_number_ranges):
logging.info('Analyze hits for ' + str(scan_parameters) + ' = ' +
str(parameter_values[parameter_index]))
analyze_data.reset(
) # resets the front end data of the last analysis step but not the options
readout_hit_len = 0 # variable to calculate a optimal chunk size value from the number of hits for speed up
# loop over the hits in the actual selected events with optimizations: determine best chunk size, start word index given
for hits, index in analysis_utils.data_aligned_at_events(
hit_table,
start_event_number=start_event_number,
stop_event_number=stop_event_number,
start_index=index,
chunk_size=best_chunk_size):
analyze_data.analyze_hits(
hits,
scan_parameter=False) # analyze the selected hits in chunks
readout_hit_len += hits.shape[0]
best_chunk_size = int(
1.5 * readout_hit_len
) if int(1.05 * readout_hit_len) < chunk_size and int(
1.05 * readout_hit_len
) > 1e3 else chunk_size # to increase the readout speed, estimated the number of hits for one read instruction
file_name = " ".join(re.findall(
"[a-zA-Z0-9]+", str(scan_parameters))) + '_' + " ".join(
re.findall("[a-zA-Z0-9]+",
str(parameter_values[parameter_index])))
analyze_data._create_additional_hit_data(safe_to_file=False)
analyze_data._create_additional_cluster_data(safe_to_file=False)
yield analyze_data, file_name
if close_file:
in_hit_file_h5.close()
def analyze_beam_spot(scan_base,
combine_n_readouts=1000,
chunk_size=10000000,
plot_occupancy_hists=False,
output_pdf=None,
output_file=None):
''' Determines the mean x and y beam spot position as a function of time. Therefore the data of a fixed number of read outs are combined ('combine_n_readouts'). The occupancy is determined
for the given combined events and stored into a pdf file. At the end the beam x and y is plotted into a scatter plot with absolute positions in um.
Parameters
----------
scan_base: list of str
scan base names (e.g.: ['//data//SCC_50_fei4_self_trigger_scan_390', ]
combine_n_readouts: int
the number of read outs to combine (e.g. 1000)
max_chunk_size: int
the maximum chunk size used during read, if too big memory error occurs, if too small analysis takes longer
output_pdf: PdfPages
PdfPages file object, if none the plot is printed to screen
'''
time_stamp = []
x = []
y = []
for data_file in scan_base:
with tb.open_file(data_file + '_interpreted.h5',
mode="r+") as in_hit_file_h5:
# get data and data pointer
meta_data_array = in_hit_file_h5.root.meta_data[:]
hit_table = in_hit_file_h5.root.Hits
# determine the event ranges to analyze (timestamp_start, start_event_number, stop_event_number)
parameter_ranges = np.column_stack(
(analysis_utils.get_ranges_from_array(
meta_data_array['timestamp_start'][::combine_n_readouts]),
analysis_utils.get_ranges_from_array(
meta_data_array['event_number'][::combine_n_readouts])))
# create a event_numer index (important)
analysis_utils.index_event_number(hit_table)
# initialize the analysis and set settings
analyze_data = AnalyzeRawData()
analyze_data.create_tot_hist = False
analyze_data.create_bcid_hist = False
analyze_data.histogram.set_no_scan_parameter()
# variables for read speed up
index = 0 # index where to start the read out, 0 at the beginning, increased during looping
best_chunk_size = chunk_size
progress_bar = progressbar.ProgressBar(widgets=[
'',
progressbar.Percentage(), ' ',
progressbar.Bar(marker='*', left='|', right='|'), ' ',
progressbar.AdaptiveETA()
],
maxval=hit_table.shape[0],
term_width=80)
progress_bar.start()
# loop over the selected events
for parameter_index, parameter_range in enumerate(
parameter_ranges):
logging.debug('Analyze time stamp ' + str(parameter_range[0]) +
' and data from events = [' +
str(parameter_range[2]) + ',' +
str(parameter_range[3]) + '[ ' + str(
int(
float(
float(parameter_index) /
float(len(parameter_ranges)) *
100.0))) + '%')
analyze_data.reset() # resets the data of the last analysis
# loop over the hits in the actual selected events with optimizations: determine best chunk size, start word index given
readout_hit_len = 0 # variable to calculate a optimal chunk size value from the number of hits for speed up
for hits, index in analysis_utils.data_aligned_at_events(
hit_table,
start_event_number=parameter_range[2],
stop_event_number=parameter_range[3],
start_index=index,
chunk_size=best_chunk_size):
analyze_data.analyze_hits(
hits) # analyze the selected hits in chunks
readout_hit_len += hits.shape[0]
progress_bar.update(index)
best_chunk_size = int(1.5 * readout_hit_len) if int(
1.05 * readout_hit_len
) < chunk_size else chunk_size # to increase the readout speed, estimated the number of hits for one read instruction
# get and store results
occupancy_array = analyze_data.histogram.get_occupancy()
projection_x = np.sum(occupancy_array, axis=0).ravel()
projection_y = np.sum(occupancy_array, axis=1).ravel()
x.append(
analysis_utils.get_mean_from_histogram(projection_x,
bin_positions=range(
0, 80)))
y.append(
analysis_utils.get_mean_from_histogram(projection_y,
bin_positions=range(
0, 336)))
time_stamp.append(parameter_range[0])
if plot_occupancy_hists:
plotting.plot_occupancy(
occupancy_array[:, :, 0],
title='Occupancy for events between ' + time.strftime(
'%H:%M:%S', time.localtime(parameter_range[0])) +
' and ' + time.strftime(
'%H:%M:%S', time.localtime(parameter_range[1])),
filename=output_pdf)
progress_bar.finish()
plotting.plot_scatter([i * 250 for i in x], [i * 50 for i in y],
title='Mean beam position',
x_label='x [um]',
y_label='y [um]',
marker_style='-o',
filename=output_pdf)
if output_file:
with tb.open_file(output_file, mode="a") as out_file_h5:
rec_array = np.array(zip(time_stamp, x, y),
dtype=[('time_stamp', float), ('x', float),
('y', float)])
try:
beam_spot_table = out_file_h5.create_table(
out_file_h5.root,
name='Beamspot',
description=rec_array,
title='Beam spot position',
filters=tb.Filters(complib='blosc',
complevel=5,
fletcher32=False))
beam_spot_table[:] = rec_array
except tb.exceptions.NodeError:
logging.warning(
output_file +
' has already a Beamspot note, do not overwrite existing.')
return time_stamp, x, y
def analyse_n_cluster_per_event(scan_base,
include_no_cluster=False,
time_line_absolute=True,
combine_n_readouts=1000,
chunk_size=10000000,
plot_n_cluster_hists=False,
output_pdf=None,
output_file=None):
''' Determines the number of cluster per event as a function of time. Therefore the data of a fixed number of read outs are combined ('combine_n_readouts').
Parameters
----------
scan_base: list of str
scan base names (e.g.: ['//data//SCC_50_fei4_self_trigger_scan_390', ]
include_no_cluster: bool
Set to true to also consider all events without any hit.
combine_n_readouts: int
the number of read outs to combine (e.g. 1000)
max_chunk_size: int
the maximum chunk size used during read, if too big memory error occurs, if too small analysis takes longer
output_pdf: PdfPages
PdfPages file object, if none the plot is printed to screen
'''
time_stamp = []
n_cluster = []
start_time_set = False
for data_file in scan_base:
with tb.open_file(data_file + '_interpreted.h5',
mode="r+") as in_cluster_file_h5:
# get data and data pointer
meta_data_array = in_cluster_file_h5.root.meta_data[:]
cluster_table = in_cluster_file_h5.root.Cluster
# determine the event ranges to analyze (timestamp_start, start_event_number, stop_event_number)
parameter_ranges = np.column_stack(
(analysis_utils.get_ranges_from_array(
meta_data_array['timestamp_start'][::combine_n_readouts]),
analysis_utils.get_ranges_from_array(
meta_data_array['event_number'][::combine_n_readouts])))
# create a event_numer index (important for speed)
analysis_utils.index_event_number(cluster_table)
# initialize the analysis and set settings
analyze_data = AnalyzeRawData()
analyze_data.create_tot_hist = False
analyze_data.create_bcid_hist = False
# variables for read speed up
index = 0 # index where to start the read out, 0 at the beginning, increased during looping
best_chunk_size = chunk_size
total_cluster = cluster_table.shape[0]
progress_bar = progressbar.ProgressBar(widgets=[
'',
progressbar.Percentage(), ' ',
progressbar.Bar(marker='*', left='|', right='|'), ' ',
progressbar.AdaptiveETA()
],
maxval=total_cluster,
term_width=80)
progress_bar.start()
# loop over the selected events
for parameter_index, parameter_range in enumerate(
parameter_ranges):
logging.debug('Analyze time stamp ' + str(parameter_range[0]) +
' and data from events = [' +
str(parameter_range[2]) + ',' +
str(parameter_range[3]) + '[ ' + str(
int(
float(
float(parameter_index) /
float(len(parameter_ranges)) *
100.0))) + '%')
analyze_data.reset() # resets the data of the last analysis
# loop over the cluster in the actual selected events with optimizations: determine best chunk size, start word index given
readout_cluster_len = 0 # variable to calculate a optimal chunk size value from the number of hits for speed up
hist = None
for clusters, index in analysis_utils.data_aligned_at_events(
cluster_table,
start_event_number=parameter_range[2],
stop_event_number=parameter_range[3],
start_index=index,
chunk_size=best_chunk_size):
n_cluster_per_event = analysis_utils.get_n_cluster_in_events(
clusters['event_number']
)[:,
1] # array with the number of cluster per event, cluster per event are at least 1
if hist is None:
hist = np.histogram(n_cluster_per_event,
bins=10,
range=(0, 10))[0]
else:
hist = np.add(
hist,
np.histogram(n_cluster_per_event,
bins=10,
range=(0, 10))[0])
if include_no_cluster and parameter_range[
3] is not None: # happend for the last readout
hist[0] = (parameter_range[3] -
parameter_range[2]) - len(
n_cluster_per_event
) # add the events without any cluster
readout_cluster_len += clusters.shape[0]
total_cluster -= len(clusters)
progress_bar.update(index)
best_chunk_size = int(1.5 * readout_cluster_len) if int(
1.05 * readout_cluster_len
) < chunk_size else chunk_size # to increase the readout speed, estimated the number of hits for one read instruction
if plot_n_cluster_hists:
plotting.plot_1d_hist(
hist,
title='Number of cluster per event at ' +
str(parameter_range[0]),
x_axis_title='Number of cluster',
y_axis_title='#',
log_y=True,
filename=output_pdf)
hist = hist.astype('f4') / np.sum(
hist) # calculate fraction from total numbers
if time_line_absolute:
time_stamp.append(parameter_range[0])
else:
if not start_time_set:
start_time = parameter_ranges[0, 0]
start_time_set = True
time_stamp.append((parameter_range[0] - start_time) / 60.0)
n_cluster.append(hist)
progress_bar.finish()
if total_cluster != 0:
logging.warning(
'Not all clusters were selected during analysis. Analysis is therefore not exact'
)
if time_line_absolute:
plotting.plot_scatter_time(
time_stamp,
n_cluster,
title='Number of cluster per event as a function of time',
marker_style='o',
filename=output_pdf,
legend=('0 cluster', '1 cluster', '2 cluster',
'3 cluster') if include_no_cluster else
('0 cluster not plotted', '1 cluster', '2 cluster', '3 cluster'))
else:
plotting.plot_scatter(
time_stamp,
n_cluster,
title='Number of cluster per event as a function of time',
x_label='time [min.]',
marker_style='o',
filename=output_pdf,
legend=('0 cluster', '1 cluster', '2 cluster',
'3 cluster') if include_no_cluster else
('0 cluster not plotted', '1 cluster', '2 cluster', '3 cluster'))
if output_file:
with tb.open_file(output_file, mode="a") as out_file_h5:
cluster_array = np.array(n_cluster)
rec_array = np.array(zip(time_stamp, cluster_array[:, 0],
cluster_array[:, 1], cluster_array[:, 2],
cluster_array[:, 3], cluster_array[:, 4],
cluster_array[:, 5]),
dtype=[('time_stamp', float),
('cluster_0', float),
('cluster_1', float),
('cluster_2', float),
('cluster_3', float),
('cluster_4', float),
('cluster_5', float)
]).view(np.recarray)
try:
n_cluster_table = out_file_h5.create_table(
out_file_h5.root,
name='n_cluster',
description=rec_array,
title='Cluster per event',
filters=tb.Filters(complib='blosc',
complevel=5,
fletcher32=False))
n_cluster_table[:] = rec_array
except tb.exceptions.NodeError:
logging.warning(
output_file +
' has already a Beamspot note, do not overwrite existing.')
return time_stamp, n_cluster
def create_hitor_calibration(output_filename):
logging.info('Analyze and plot results of %s', output_filename)
def plot_calibration(col_row_combinations, scan_parameter,
calibration_data,
filename): # Result calibration plot function
for index, (column, row) in enumerate(col_row_combinations):
logging.info("Plot calibration for pixel " + str(column) + '/' +
str(row))
fig = Figure()
FigureCanvas(fig)
ax = fig.add_subplot(111)
fig.patch.set_facecolor('white')
ax.grid(True)
ax.errorbar(scan_parameter,
calibration_data[column - 1, row - 1, :, 0] * 25. +
25.,
yerr=[
calibration_data[column - 1, row - 1, :, 2] * 25,
calibration_data[column - 1, row - 1, :, 2] * 25
],
fmt='o',
label='FE-I4 ToT [ns]')
ax.errorbar(
scan_parameter,
calibration_data[column - 1, row - 1, :, 1] * 1.5625,
yerr=[
calibration_data[column - 1, row - 1, :, 3] * 1.5625,
calibration_data[column - 1, row - 1, :, 3] * 1.5625
],
fmt='o',
label='TDC ToT [ns]')
ax.set_title('Calibration for pixel ' + str(column) + '/' +
str(row))
ax.set_xlabel('Charge [PlsrDAC]')
ax.set_ylabel('TOT')
ax.legend(loc=0)
filename.savefig(fig)
if index > 100: # stop for too many plots
logging.info(
'Do not create pixel plots for more than 100 pixels to safe time'
)
break
with AnalyzeRawData(raw_data_file=output_filename, create_pdf=True
) as analyze_raw_data: # Interpret the raw data file
analyze_raw_data.create_occupancy_hist = False # too many scan parameters to do in ram histograming
analyze_raw_data.create_hit_table = True
analyze_raw_data.create_tdc_hist = True
analyze_raw_data.align_at_tdc = True # align events at TDC words, first word of event has to be a tdc word
analyze_raw_data.interpret_word_table()
analyze_raw_data.interpreter.print_summary()
analyze_raw_data.plot_histograms()
n_injections = analyze_raw_data.n_injections # store number of injections for later cross check
with tb.open_file(
output_filename + '_interpreted.h5',
'r') as in_file_h5: # Get scan parameters from interpreted file
meta_data = in_file_h5.root.meta_data[:]
hits = in_file_h5.root.Hits[:]
scan_parameters_dict = get_scan_parameter(meta_data)
inner_loop_parameter_values = scan_parameters_dict[next(
reversed(
scan_parameters_dict))] # inner loop parameter name is unknown
scan_parameter_names = scan_parameters_dict.keys()
col_row_combinations = get_unique_scan_parameter_combinations(
in_file_h5.root.meta_data[:],
scan_parameters=('column', 'row'),
scan_parameter_columns_only=True)
meta_data_table_at_scan_parameter = get_unique_scan_parameter_combinations(
meta_data, scan_parameters=scan_parameter_names)
parameter_values = get_scan_parameters_table_from_meta_data(
meta_data_table_at_scan_parameter, scan_parameter_names)
event_number_ranges = get_ranges_from_array(
meta_data_table_at_scan_parameter['event_number'])
event_ranges_per_parameter = np.column_stack(
(parameter_values, event_number_ranges))
event_numbers = hits['event_number'].copy(
) # create contigous array, otherwise np.searchsorted too slow, http://stackoverflow.com/questions/15139299/performance-of-numpy-searchsorted-is-poor-on-structured-arrays
with tb.openFile(output_filename + "_calibration.h5",
mode="w") as calibration_data_file:
logging.info('Create calibration')
output_pdf = PdfPages(output_filename + "_calibration.pdf")
calibration_data = np.zeros(
shape=(80, 336, len(inner_loop_parameter_values), 4),
dtype='f4'
) # result of the calibration is a histogram with col_index, row_index, plsrDAC value, mean discrete tot, rms discrete tot, mean tot from TDC, rms tot from TDC
progress_bar = progressbar.ProgressBar(
widgets=[
'',
progressbar.Percentage(), ' ',
progressbar.Bar(marker='*', left='|', right='|'), ' ',
progressbar.AdaptiveETA()
],
maxval=len(event_ranges_per_parameter),
term_width=80)
progress_bar.start()
for index, (parameter_values, event_start,
event_stop) in enumerate(event_ranges_per_parameter):
if event_stop is None: # happens for the last chunk
event_stop = hits[-1]['event_number']
array_index = np.searchsorted(
event_numbers, np.array([event_start, event_stop]))
actual_hits = hits[array_index[0]:array_index[1]]
actual_col, actual_row, parameter_value = parameter_values
if len(hits[np.logical_and(actual_hits['column'] != actual_col,
actual_hits['row'] != actual_row)]):
logging.warning(
'There are %d hits from not selected pixels in the data',
len(actual_hits[np.logical_and(
actual_hits['column'] != actual_col,
actual_hits['row'] != actual_row)]))
actual_hits = actual_hits[np.logical_and(
actual_hits['column'] == actual_col,
actual_hits['row'] == actual_row)]
actual_tdc_hits = actual_hits[
(actual_hits['event_status'] & 0b0000111110011100) ==
0b0000000100000000] # only take hits from good events (one TDC word only, no error)
actual_tot_hits = actual_hits[
(actual_hits['event_status'] & 0b0000100010011100) ==
0b0000000000000000] # only take hits from good events for tot
tot, tdc = actual_tot_hits['tot'], actual_tdc_hits['TDC']
if tdc.shape[
0] != n_injections and index == event_ranges_per_parameter.shape[
0] - 1:
logging.warning('There are %d != %d TDC hits for %s = %s',
tdc.shape[0], n_injections,
str(scan_parameter_names),
str(parameter_values))
inner_loop_scan_parameter_index = np.where(
parameter_value == inner_loop_parameter_values
)[0][
0] # translate the scan parameter value to an index for the result histogram
calibration_data[actual_col - 1, actual_row - 1,
inner_loop_scan_parameter_index,
0] = np.mean(tot)
calibration_data[actual_col - 1, actual_row - 1,
inner_loop_scan_parameter_index,
1] = np.mean(tdc)
calibration_data[actual_col - 1, actual_row - 1,
inner_loop_scan_parameter_index,
2] = np.std(tot)
calibration_data[actual_col - 1, actual_row - 1,
inner_loop_scan_parameter_index,
3] = np.std(tdc)
progress_bar.update(index)
calibration_data_out = calibration_data_file.createCArray(
calibration_data_file.root,
name='HitOrCalibration',
title='Hit OR calibration data',
atom=tb.Atom.from_dtype(calibration_data.dtype),
shape=calibration_data.shape,
filters=tb.Filters(complib='blosc',
complevel=5,
fletcher32=False))
calibration_data_out[:] = calibration_data
calibration_data_out.attrs.dimensions = scan_parameter_names
calibration_data_out.attrs.scan_parameter_values = inner_loop_parameter_values
plot_calibration(col_row_combinations,
scan_parameter=inner_loop_parameter_values,
calibration_data=calibration_data,
filename=output_pdf)
output_pdf.close()
progress_bar.finish()
def analyze_event_rate(scan_base,
combine_n_readouts=1000,
time_line_absolute=True,
output_pdf=None,
output_file=None):
''' Determines the number of events as a function of time. Therefore the data of a fixed number of read outs are combined ('combine_n_readouts'). The number of events is taken from the meta data info
and stored into a pdf file.
Parameters
----------
scan_base: list of str
scan base names (e.g.: ['//data//SCC_50_fei4_self_trigger_scan_390', ]
combine_n_readouts: int
the number of read outs to combine (e.g. 1000)
time_line_absolute: bool
if true the analysis uses absolute time stamps
output_pdf: PdfPages
PdfPages file object, if none the plot is printed to screen
'''
time_stamp = []
rate = []
start_time_set = False
for data_file in scan_base:
with tb.open_file(data_file + '_interpreted.h5',
mode="r") as in_file_h5:
meta_data_array = in_file_h5.root.meta_data[:]
parameter_ranges = np.column_stack(
(analysis_utils.get_ranges_from_array(
meta_data_array['timestamp_start'][::combine_n_readouts]),
analysis_utils.get_ranges_from_array(
meta_data_array['event_number'][::combine_n_readouts])))
if time_line_absolute:
time_stamp.extend(parameter_ranges[:-1, 0])
else:
if not start_time_set:
start_time = parameter_ranges[0, 0]
start_time_set = True
time_stamp.extend(
(parameter_ranges[:-1, 0] - start_time) / 60.0)
rate.extend((parameter_ranges[:-1, 3] - parameter_ranges[:-1, 2]) /
(parameter_ranges[:-1, 1] -
parameter_ranges[:-1, 0])) # d#Events / dt
if time_line_absolute:
plotting.plot_scatter_time(time_stamp,
rate,
title='Event rate [Hz]',
marker_style='o',
filename=output_pdf)
else:
plotting.plot_scatter(time_stamp,
rate,
title='Events per time',
x_label='Progressed time [min.]',
y_label='Events rate [Hz]',
marker_style='o',
filename=output_pdf)
if output_file:
with tb.open_file(output_file, mode="a") as out_file_h5:
rec_array = np.array(zip(time_stamp, rate),
dtype=[('time_stamp', float),
('rate', float)]).view(np.recarray)
try:
rate_table = out_file_h5.create_table(out_file_h5.root,
name='Eventrate',
description=rec_array,
title='Event rate',
filters=tb.Filters(
complib='blosc',
complevel=5,
fletcher32=False))
rate_table[:] = rec_array
except tb.exceptions.NodeError:
logging.warning(
output_file +
' has already a Eventrate note, do not overwrite existing.'
)
return time_stamp, rate
def analyze_cluster_size_per_scan_parameter(
input_file_hits,
output_file_cluster_size,
parameter="GDAC",
max_chunk_size=10000000,
overwrite_output_files=False,
output_pdf=None,
):
""" This method takes multiple hit files and determines the cluster size for different scan parameter values of
Parameters
----------
input_files_hits: string
output_file_cluster_size: string
The data file with the results
parameter: string
The name of the parameter to separate the data into (e.g.: PlsrDAC)
max_chunk_size: int
the maximum chunk size used during read, if too big memory error occurs, if too small analysis takes longer
overwrite_output_files: bool
Set to true to overwrite the output file if it already exists
output_pdf: PdfPages
PdfPages file object, if none the plot is printed to screen, if False nothing is printed
"""
logging.info("Analyze the cluster sizes for different " + parameter + " settings for " + input_file_hits)
if os.path.isfile(output_file_cluster_size) and not overwrite_output_files: # skip analysis if already done
logging.info(
"Analyzed cluster size file " + output_file_cluster_size + " already exists. Skip cluster size analysis."
)
else:
with tb.openFile(output_file_cluster_size, mode="w") as out_file_h5: # file to write the data into
filter_table = tb.Filters(complib="blosc", complevel=5, fletcher32=False) # compression of the written data
parameter_goup = out_file_h5.createGroup(
out_file_h5.root, parameter, title=parameter
) # note to store the data
cluster_size_total = None # final array for the cluster size per GDAC
with tb.openFile(input_file_hits, mode="r+") as in_hit_file_h5: # open the actual hit file
meta_data_array = in_hit_file_h5.root.meta_data[:]
scan_parameter = analysis_utils.get_scan_parameter(meta_data_array) # get the scan parameters
if scan_parameter: # if a GDAC scan parameter was used analyze the cluster size per GDAC setting
scan_parameter_values = scan_parameter[parameter] # scan parameter settings used
if (
len(scan_parameter_values) == 1
): # only analyze per scan step if there are more than one scan step
logging.warning(
"The file "
+ str(input_file_hits)
+ " has no different "
+ str(parameter)
+ " parameter values. Omit analysis."
)
else:
logging.info(
"Analyze "
+ input_file_hits
+ " per scan parameter "
+ parameter
+ " for "
+ str(len(scan_parameter_values))
+ " values from "
+ str(np.amin(scan_parameter_values))
+ " to "
+ str(np.amax(scan_parameter_values))
)
event_numbers = analysis_utils.get_meta_data_at_scan_parameter(meta_data_array, parameter)[
"event_number"
] # get the event numbers in meta_data where the scan parameter changes
parameter_ranges = np.column_stack(
(scan_parameter_values, analysis_utils.get_ranges_from_array(event_numbers))
)
hit_table = in_hit_file_h5.root.Hits
analysis_utils.index_event_number(hit_table)
total_hits, total_hits_2, index = 0, 0, 0
chunk_size = max_chunk_size
# initialize the analysis and set settings
analyze_data = AnalyzeRawData()
analyze_data.create_cluster_size_hist = True
analyze_data.create_cluster_tot_hist = True
analyze_data.histograming.set_no_scan_parameter() # one has to tell the histogramer the # of scan parameters for correct occupancy hist allocation
progress_bar = progressbar.ProgressBar(
widgets=[
"",
progressbar.Percentage(),
" ",
progressbar.Bar(marker="*", left="|", right="|"),
" ",
analysis_utils.ETA(),
],
maxval=hit_table.shape[0],
term_width=80,
)
progress_bar.start()
for parameter_index, parameter_range in enumerate(
parameter_ranges
): # loop over the selected events
analyze_data.reset() # resets the data of the last analysis
logging.debug(
"Analyze GDAC = "
+ str(parameter_range[0])
+ " "
+ str(int(float(float(parameter_index) / float(len(parameter_ranges)) * 100.0)))
+ "%"
)
start_event_number = parameter_range[1]
stop_event_number = parameter_range[2]
logging.debug(
"Data from events = [" + str(start_event_number) + "," + str(stop_event_number) + "["
)
actual_parameter_group = out_file_h5.createGroup(
parameter_goup,
name=parameter + "_" + str(parameter_range[0]),
title=parameter + "_" + str(parameter_range[0]),
)
# loop over the hits in the actual selected events with optimizations: variable chunk size, start word index given
readout_hit_len = (
0
) # variable to calculate a optimal chunk size value from the number of hits for speed up
for hits, index in analysis_utils.data_aligned_at_events(
hit_table,
start_event_number=start_event_number,
stop_event_number=stop_event_number,
start=index,
chunk_size=chunk_size,
):
total_hits += hits.shape[0]
analyze_data.analyze_hits(hits) # analyze the selected hits in chunks
readout_hit_len += hits.shape[0]
progress_bar.update(index)
chunk_size = (
int(1.05 * readout_hit_len)
if int(1.05 * readout_hit_len) < max_chunk_size
else max_chunk_size
) # to increase the readout speed, estimated the number of hits for one read instruction
if (
chunk_size < 50
): # limit the lower chunk size, there can always be a crazy event with more than 20 hits
chunk_size = 50
# get occupancy hist
occupancy = (
analyze_data.histograming.get_occupancy()
) # just here to check histograming is consistend
# store and plot cluster size hist
cluster_size_hist = analyze_data.clusterizer.get_cluster_size_hist()
cluster_size_hist_table = out_file_h5.createCArray(
actual_parameter_group,
name="HistClusterSize",
title="Cluster Size Histogram",
atom=tb.Atom.from_dtype(cluster_size_hist.dtype),
shape=cluster_size_hist.shape,
filters=filter_table,
)
cluster_size_hist_table[:] = cluster_size_hist
if output_pdf is not False:
plotting.plot_cluster_size(
hist=cluster_size_hist,
title="Cluster size ("
+ str(np.sum(cluster_size_hist))
+ " entries) for "
+ parameter
+ " = "
+ str(scan_parameter_values[parameter_index]),
filename=output_pdf,
)
if cluster_size_total is None: # true if no data was appended to the array yet
cluster_size_total = cluster_size_hist
else:
cluster_size_total = np.vstack([cluster_size_total, cluster_size_hist])
total_hits_2 += np.sum(occupancy)
progress_bar.finish()
if total_hits != total_hits_2:
logging.warning("Analysis shows inconsistent number of hits. Check needed!")
logging.info("Analyzed %d hits!", total_hits)
cluster_size_total_out = out_file_h5.createCArray(
out_file_h5.root,
name="AllHistClusterSize",
title="All Cluster Size Histograms",
atom=tb.Atom.from_dtype(cluster_size_total.dtype),
shape=cluster_size_total.shape,
filters=filter_table,
)
cluster_size_total_out[:] = cluster_size_total
def analyze_hits_per_scan_parameter(analyze_data, scan_parameters=None, chunk_size=50000):
"""Takes the hit table and analyzes the hits per scan parameter
Parameters
----------
analyze_data : analysis.analyze_raw_data.AnalyzeRawData object with an opened hit file (AnalyzeRawData.out_file_h5) or a
file name with the hit data given (AnalyzeRawData._analyzed_data_file)
scan_parameters : list of strings:
The names of the scan parameters to use
chunk_size : int:
The chunk size of one hit table read. The bigger the faster. Too big causes memory errors.
Returns
-------
yields the analysis.analyze_raw_data.AnalyzeRawData for each scan parameter
"""
if analyze_data.out_file_h5 is None or analyze_data.out_file_h5.isopen == 0:
in_hit_file_h5 = tb.open_file(analyze_data._analyzed_data_file, "r+")
opened_file = True
else:
in_hit_file_h5 = analyze_data.out_file_h5
opened_file = False
meta_data = in_hit_file_h5.root.meta_data[:] # get the meta data table
try:
hit_table = in_hit_file_h5.root.Hits # get the hit table
except tb.NoSuchNodeError:
logging.error("analyze_hits_per_scan_parameter needs a hit table, but no hit table found.")
return
meta_data_table_at_scan_parameter = analysis_utils.get_unique_scan_parameter_combinations(
meta_data, scan_parameters=scan_parameters
)
parameter_values = analysis_utils.get_scan_parameters_table_from_meta_data(
meta_data_table_at_scan_parameter, scan_parameters
)
event_number_ranges = analysis_utils.get_ranges_from_array(
meta_data_table_at_scan_parameter["event_number"]
) # get the event number ranges for the different scan parameter settings
analysis_utils.index_event_number(
hit_table
) # create a event_numer index to select the hits by their event number fast, no needed but important for speed up
# variables for read speed up
index = 0 # index where to start the read out of the hit table, 0 at the beginning, increased during looping
best_chunk_size = (
chunk_size
) # number of hits to copy to RAM during looping, the optimal chunk size is determined during looping
# loop over the selected events
for parameter_index, (start_event_number, stop_event_number) in enumerate(event_number_ranges):
logging.info("Analyze hits for " + str(scan_parameters) + " = " + str(parameter_values[parameter_index]))
analyze_data.reset() # resets the front end data of the last analysis step but not the options
readout_hit_len = 0 # variable to calculate a optimal chunk size value from the number of hits for speed up
# loop over the hits in the actual selected events with optimizations: determine best chunk size, start word index given
for hits, index in analysis_utils.data_aligned_at_events(
hit_table,
start_event_number=start_event_number,
stop_event_number=stop_event_number,
start=index,
chunk_size=best_chunk_size,
):
analyze_data.analyze_hits(hits, scan_parameter=False) # analyze the selected hits in chunks
readout_hit_len += hits.shape[0]
best_chunk_size = (
int(1.5 * readout_hit_len)
if int(1.05 * readout_hit_len) < chunk_size and int(1.05 * readout_hit_len) > 1e3
else chunk_size
) # to increase the readout speed, estimated the number of hits for one read instruction
file_name = (
" ".join(re.findall("[a-zA-Z0-9]+", str(scan_parameters)))
+ "_"
+ " ".join(re.findall("[a-zA-Z0-9]+", str(parameter_values[parameter_index])))
)
analyze_data._create_additional_hit_data(safe_to_file=False)
analyze_data._create_additional_cluster_data(safe_to_file=False)
yield analyze_data, file_name
if opened_file:
in_hit_file_h5.close()
def analyse_n_cluster_per_event(
scan_base,
include_no_cluster=False,
time_line_absolute=True,
combine_n_readouts=1000,
chunk_size=10000000,
plot_n_cluster_hists=False,
output_pdf=None,
output_file=None,
):
""" Determines the number of cluster per event as a function of time. Therefore the data of a fixed number of read outs are combined ('combine_n_readouts').
Parameters
----------
scan_base: list of str
scan base names (e.g.: ['//data//SCC_50_fei4_self_trigger_scan_390', ]
include_no_cluster: bool
Set to true to also consider all events without any hit.
combine_n_readouts: int
the number of read outs to combine (e.g. 1000)
max_chunk_size: int
the maximum chunk size used during read, if too big memory error occurs, if too small analysis takes longer
output_pdf: PdfPages
PdfPages file object, if none the plot is printed to screen
"""
time_stamp = []
n_cluster = []
start_time_set = False
for data_file in scan_base:
with tb.openFile(data_file + "_interpreted.h5", mode="r+") as in_cluster_file_h5:
# get data and data pointer
meta_data_array = in_cluster_file_h5.root.meta_data[:]
cluster_table = in_cluster_file_h5.root.Cluster
# determine the event ranges to analyze (timestamp_start, start_event_number, stop_event_number)
parameter_ranges = np.column_stack(
(
analysis_utils.get_ranges_from_array(meta_data_array["timestamp_start"][::combine_n_readouts]),
analysis_utils.get_ranges_from_array(meta_data_array["event_number"][::combine_n_readouts]),
)
)
# create a event_numer index (important for speed)
analysis_utils.index_event_number(cluster_table)
# initialize the analysis and set settings
analyze_data = AnalyzeRawData()
analyze_data.create_tot_hist = False
analyze_data.create_bcid_hist = False
# variables for read speed up
index = 0 # index where to start the read out, 0 at the beginning, increased during looping
best_chunk_size = chunk_size
total_cluster = cluster_table.shape[0]
progress_bar = progressbar.ProgressBar(
widgets=[
"",
progressbar.Percentage(),
" ",
progressbar.Bar(marker="*", left="|", right="|"),
" ",
analysis_utils.ETA(),
],
maxval=total_cluster,
term_width=80,
)
progress_bar.start()
# loop over the selected events
for parameter_index, parameter_range in enumerate(parameter_ranges):
logging.debug(
"Analyze time stamp "
+ str(parameter_range[0])
+ " and data from events = ["
+ str(parameter_range[2])
+ ","
+ str(parameter_range[3])
+ "[ "
+ str(int(float(float(parameter_index) / float(len(parameter_ranges)) * 100.0)))
+ "%"
)
analyze_data.reset() # resets the data of the last analysis
# loop over the cluster in the actual selected events with optimizations: determine best chunk size, start word index given
readout_cluster_len = (
0
) # variable to calculate a optimal chunk size value from the number of hits for speed up
hist = None
for clusters, index in analysis_utils.data_aligned_at_events(
cluster_table,
start_event_number=parameter_range[2],
stop_event_number=parameter_range[3],
start=index,
chunk_size=best_chunk_size,
):
n_cluster_per_event = analysis_utils.get_n_cluster_in_events(clusters["event_number"])[
:, 1
] # array with the number of cluster per event, cluster per event are at least 1
if hist is None:
hist = np.histogram(n_cluster_per_event, bins=10, range=(0, 10))[0]
else:
hist = np.add(hist, np.histogram(n_cluster_per_event, bins=10, range=(0, 10))[0])
if include_no_cluster and parameter_range[3] is not None: # happend for the last readout
hist[0] = (parameter_range[3] - parameter_range[2]) - len(
n_cluster_per_event
) # add the events without any cluster
readout_cluster_len += clusters.shape[0]
total_cluster -= len(clusters)
progress_bar.update(index)
best_chunk_size = (
int(1.5 * readout_cluster_len) if int(1.05 * readout_cluster_len) < chunk_size else chunk_size
) # to increase the readout speed, estimated the number of hits for one read instruction
if plot_n_cluster_hists:
plotting.plot_1d_hist(
hist,
title="Number of cluster per event at " + str(parameter_range[0]),
x_axis_title="Number of cluster",
y_axis_title="#",
log_y=True,
filename=output_pdf,
)
hist = hist.astype("f4") / np.sum(hist) # calculate fraction from total numbers
if time_line_absolute:
time_stamp.append(parameter_range[0])
else:
if not start_time_set:
start_time = parameter_ranges[0, 0]
start_time_set = True
time_stamp.append((parameter_range[0] - start_time) / 60.0)
n_cluster.append(hist)
progress_bar.finish()
if total_cluster != 0:
logging.warning("Not all clusters were selected during analysis. Analysis is therefore not exact")
if time_line_absolute:
plotting.plot_scatter_time(
time_stamp,
n_cluster,
title="Number of cluster per event as a function of time",
marker_style="o",
filename=output_pdf,
legend=("0 cluster", "1 cluster", "2 cluster", "3 cluster")
if include_no_cluster
else ("0 cluster not plotted", "1 cluster", "2 cluster", "3 cluster"),
)
else:
plotting.plot_scatter(
time_stamp,
n_cluster,
title="Number of cluster per event as a function of time",
x_label="time [min.]",
marker_style="o",
filename=output_pdf,
legend=("0 cluster", "1 cluster", "2 cluster", "3 cluster")
if include_no_cluster
else ("0 cluster not plotted", "1 cluster", "2 cluster", "3 cluster"),
)
if output_file:
with tb.openFile(output_file, mode="a") as out_file_h5:
cluster_array = np.array(n_cluster)
rec_array = np.array(
zip(
time_stamp,
cluster_array[:, 0],
cluster_array[:, 1],
cluster_array[:, 2],
cluster_array[:, 3],
cluster_array[:, 4],
cluster_array[:, 5],
),
dtype=[
("time_stamp", float),
("cluster_0", float),
("cluster_1", float),
("cluster_2", float),
("cluster_3", float),
("cluster_4", float),
("cluster_5", float),
],
).view(np.recarray)
try:
n_cluster_table = out_file_h5.createTable(
out_file_h5.root,
name="n_cluster",
description=rec_array,
title="Cluster per event",
filters=tb.Filters(complib="blosc", complevel=5, fletcher32=False),
)
n_cluster_table[:] = rec_array
except tb.exceptions.NodeError:
logging.warning(output_file + " has already a Beamspot note, do not overwrite existing.")
return time_stamp, n_cluster
def analyze_beam_spot(
scan_base,
combine_n_readouts=1000,
chunk_size=10000000,
plot_occupancy_hists=False,
output_pdf=None,
output_file=None,
):
""" Determines the mean x and y beam spot position as a function of time. Therefore the data of a fixed number of read outs are combined ('combine_n_readouts'). The occupancy is determined
for the given combined events and stored into a pdf file. At the end the beam x and y is plotted into a scatter plot with absolute positions in um.
Parameters
----------
scan_base: list of str
scan base names (e.g.: ['//data//SCC_50_fei4_self_trigger_scan_390', ]
combine_n_readouts: int
the number of read outs to combine (e.g. 1000)
max_chunk_size: int
the maximum chunk size used during read, if too big memory error occurs, if too small analysis takes longer
output_pdf: PdfPages
PdfPages file object, if none the plot is printed to screen
"""
time_stamp = []
x = []
y = []
for data_file in scan_base:
with tb.openFile(data_file + "_interpreted.h5", mode="r+") as in_hit_file_h5:
# get data and data pointer
meta_data_array = in_hit_file_h5.root.meta_data[:]
hit_table = in_hit_file_h5.root.Hits
# determine the event ranges to analyze (timestamp_start, start_event_number, stop_event_number)
parameter_ranges = np.column_stack(
(
analysis_utils.get_ranges_from_array(meta_data_array["timestamp_start"][::combine_n_readouts]),
analysis_utils.get_ranges_from_array(meta_data_array["event_number"][::combine_n_readouts]),
)
)
# create a event_numer index (important)
analysis_utils.index_event_number(hit_table)
# initialize the analysis and set settings
analyze_data = AnalyzeRawData()
analyze_data.create_tot_hist = False
analyze_data.create_bcid_hist = False
analyze_data.histograming.set_no_scan_parameter()
# variables for read speed up
index = 0 # index where to start the read out, 0 at the beginning, increased during looping
best_chunk_size = chunk_size
progress_bar = progressbar.ProgressBar(
widgets=[
"",
progressbar.Percentage(),
" ",
progressbar.Bar(marker="*", left="|", right="|"),
" ",
analysis_utils.ETA(),
],
maxval=hit_table.shape[0],
term_width=80,
)
progress_bar.start()
# loop over the selected events
for parameter_index, parameter_range in enumerate(parameter_ranges):
logging.debug(
"Analyze time stamp "
+ str(parameter_range[0])
+ " and data from events = ["
+ str(parameter_range[2])
+ ","
+ str(parameter_range[3])
+ "[ "
+ str(int(float(float(parameter_index) / float(len(parameter_ranges)) * 100.0)))
+ "%"
)
analyze_data.reset() # resets the data of the last analysis
# loop over the hits in the actual selected events with optimizations: determine best chunk size, start word index given
readout_hit_len = (
0
) # variable to calculate a optimal chunk size value from the number of hits for speed up
for hits, index in analysis_utils.data_aligned_at_events(
hit_table,
start_event_number=parameter_range[2],
stop_event_number=parameter_range[3],
start=index,
chunk_size=best_chunk_size,
):
analyze_data.analyze_hits(hits) # analyze the selected hits in chunks
readout_hit_len += hits.shape[0]
progress_bar.update(index)
best_chunk_size = (
int(1.5 * readout_hit_len) if int(1.05 * readout_hit_len) < chunk_size else chunk_size
) # to increase the readout speed, estimated the number of hits for one read instruction
# get and store results
occupancy_array = analyze_data.histograming.get_occupancy()
projection_x = np.sum(occupancy_array, axis=0).ravel()
projection_y = np.sum(occupancy_array, axis=1).ravel()
x.append(analysis_utils.get_mean_from_histogram(projection_x, bin_positions=range(0, 80)))
y.append(analysis_utils.get_mean_from_histogram(projection_y, bin_positions=range(0, 336)))
time_stamp.append(parameter_range[0])
if plot_occupancy_hists:
plotting.plot_occupancy(
occupancy_array[:, :, 0],
title="Occupancy for events between "
+ time.strftime("%H:%M:%S", time.localtime(parameter_range[0]))
+ " and "
+ time.strftime("%H:%M:%S", time.localtime(parameter_range[1])),
filename=output_pdf,
)
progress_bar.finish()
plotting.plot_scatter(
[i * 250 for i in x],
[i * 50 for i in y],
title="Mean beam position",
x_label="x [um]",
y_label="y [um]",
marker_style="-o",
filename=output_pdf,
)
if output_file:
with tb.openFile(output_file, mode="a") as out_file_h5:
rec_array = np.array(zip(time_stamp, x, y), dtype=[("time_stamp", float), ("x", float), ("y", float)])
try:
beam_spot_table = out_file_h5.createTable(
out_file_h5.root,
name="Beamspot",
description=rec_array,
title="Beam spot position",
filters=tb.Filters(complib="blosc", complevel=5, fletcher32=False),
)
beam_spot_table[:] = rec_array
except tb.exceptions.NodeError:
logging.warning(output_file + " has already a Beamspot note, do not overwrite existing.")
return time_stamp, x, y
def analyze_event_rate(scan_base, combine_n_readouts=1000, time_line_absolute=True, output_pdf=None, output_file=None):
""" Determines the number of events as a function of time. Therefore the data of a fixed number of read outs are combined ('combine_n_readouts'). The number of events is taken from the meta data info
and stored into a pdf file.
Parameters
----------
scan_base: list of str
scan base names (e.g.: ['//data//SCC_50_fei4_self_trigger_scan_390', ]
combine_n_readouts: int
the number of read outs to combine (e.g. 1000)
time_line_absolute: bool
if true the analysis uses absolute time stamps
output_pdf: PdfPages
PdfPages file object, if none the plot is printed to screen
"""
time_stamp = []
rate = []
start_time_set = False
for data_file in scan_base:
with tb.openFile(data_file + "_interpreted.h5", mode="r") as in_file_h5:
meta_data_array = in_file_h5.root.meta_data[:]
parameter_ranges = np.column_stack(
(
analysis_utils.get_ranges_from_array(meta_data_array["timestamp_start"][::combine_n_readouts]),
analysis_utils.get_ranges_from_array(meta_data_array["event_number"][::combine_n_readouts]),
)
)
if time_line_absolute:
time_stamp.extend(parameter_ranges[:-1, 0])
else:
if not start_time_set:
start_time = parameter_ranges[0, 0]
start_time_set = True
time_stamp.extend((parameter_ranges[:-1, 0] - start_time) / 60.0)
rate.extend(
(parameter_ranges[:-1, 3] - parameter_ranges[:-1, 2])
/ (parameter_ranges[:-1, 1] - parameter_ranges[:-1, 0])
) # d#Events / dt
if time_line_absolute:
plotting.plot_scatter_time(time_stamp, rate, title="Event rate [Hz]", marker_style="o", filename=output_pdf)
else:
plotting.plot_scatter(
time_stamp,
rate,
title="Events per time",
x_label="Progressed time [min.]",
y_label="Events rate [Hz]",
marker_style="o",
filename=output_pdf,
)
if output_file:
with tb.openFile(output_file, mode="a") as out_file_h5:
rec_array = np.array(zip(time_stamp, rate), dtype=[("time_stamp", float), ("rate", float)]).view(
np.recarray
)
try:
rate_table = out_file_h5.createTable(
out_file_h5.root,
name="Eventrate",
description=rec_array,
title="Event rate",
filters=tb.Filters(complib="blosc", complevel=5, fletcher32=False),
)
rate_table[:] = rec_array
except tb.exceptions.NodeError:
logging.warning(output_file + " has already a Eventrate note, do not overwrite existing.")
return time_stamp, rate
def create_hitor_calibration(output_filename, plot_pixel_calibrations=False):
'''Generating HitOr calibration file (_calibration.h5) from raw data file and plotting of calibration data.
Parameters
----------
output_filename : string
Input raw data file name.
plot_pixel_calibrations : bool, iterable
If True, genearating additional pixel calibration plots. If list of column and row tuples (from 1 to 80 / 336), print selected pixels.
Returns
-------
nothing
'''
logging.info('Analyze HitOR calibration data and plot results of %s',
output_filename)
with AnalyzeRawData(raw_data_file=output_filename, create_pdf=True
) as analyze_raw_data: # Interpret the raw data file
analyze_raw_data.create_occupancy_hist = False # too many scan parameters to do in ram histogramming
analyze_raw_data.create_hit_table = True
analyze_raw_data.create_tdc_hist = True
analyze_raw_data.align_at_tdc = True # align events at TDC words, first word of event has to be a tdc word
analyze_raw_data.interpret_word_table()
analyze_raw_data.interpreter.print_summary()
analyze_raw_data.plot_histograms()
n_injections = analyze_raw_data.n_injections # use later
with tb.open_file(
analyze_raw_data._analyzed_data_file, 'r'
) as in_file_h5: # Get scan parameters from interpreted file
meta_data = in_file_h5.root.meta_data[:]
scan_parameters_dict = get_scan_parameter(meta_data)
inner_loop_parameter_values = scan_parameters_dict[next(
reversed(scan_parameters_dict)
)] # inner loop parameter name is unknown
scan_parameter_names = scan_parameters_dict.keys()
# col_row_combinations = get_unique_scan_parameter_combinations(in_file_h5.root.meta_data[:], scan_parameters=('column', 'row'), scan_parameter_columns_only=True)
meta_data_table_at_scan_parameter = get_unique_scan_parameter_combinations(
meta_data, scan_parameters=scan_parameter_names)
scan_parameter_values = get_scan_parameters_table_from_meta_data(
meta_data_table_at_scan_parameter, scan_parameter_names)
event_number_ranges = get_ranges_from_array(
meta_data_table_at_scan_parameter['event_number'])
event_ranges_per_parameter = np.column_stack(
(scan_parameter_values, event_number_ranges))
hits = in_file_h5.root.Hits[:]
event_numbers = hits['event_number'].copy(
) # create contigous array, otherwise np.searchsorted too slow, http://stackoverflow.com/questions/15139299/performance-of-numpy-searchsorted-is-poor-on-structured-arrays
output_filename = os.path.splitext(output_filename)[0]
with tb.open_file(output_filename + "_calibration.h5",
mode="w") as calibration_data_file:
logging.info('Create calibration')
calibration_data = np.full(
shape=(80, 336, len(inner_loop_parameter_values), 4),
fill_value=np.nan,
dtype='f4'
) # result of the calibration is a histogram with col_index, row_index, plsrDAC value, mean discrete tot, rms discrete tot, mean tot from TDC, rms tot from TDC
progress_bar = progressbar.ProgressBar(
widgets=[
'',
progressbar.Percentage(), ' ',
progressbar.Bar(marker='*', left='|', right='|'), ' ',
progressbar.AdaptiveETA()
],
maxval=len(event_ranges_per_parameter),
term_width=80)
progress_bar.start()
for index, (
actual_scan_parameter_values, event_start,
event_stop) in enumerate(event_ranges_per_parameter):
if event_stop is None: # happens for the last chunk
event_stop = hits[-1]['event_number'] + 1
array_index = np.searchsorted(
event_numbers, np.array([event_start, event_stop]))
actual_hits = hits[array_index[0]:array_index[1]]
for item_index, item in enumerate(scan_parameter_names):
if item == "column":
actual_col = actual_scan_parameter_values[
item_index]
elif item == "row":
actual_row = actual_scan_parameter_values[
item_index]
elif item == "PlsrDAC":
plser_dac = actual_scan_parameter_values[
item_index]
else:
raise ValueError("Unknown scan parameter %s" %
item)
# Only pixel of actual column/row should be in the actual data chunk but since SRAM is not cleared for each scan step due to speed reasons and there might be noisy pixels this is not always the case
n_wrong_pixel = np.count_nonzero(
np.logical_or(actual_hits['column'] != actual_col,
actual_hits['row'] != actual_row))
if n_wrong_pixel != 0:
logging.warning(
'%d hit(s) from other pixels for scan parameters %s',
n_wrong_pixel, ', '.join([
'%s=%s' % (name, value)
for (name, value
) in zip(scan_parameter_names,
actual_scan_parameter_values)
]))
actual_hits = actual_hits[np.logical_and(
actual_hits['column'] == actual_col, actual_hits['row']
== actual_row)] # Only take data from selected pixel
actual_tdc_hits = actual_hits[
(actual_hits['event_status'] & 0b0000111110011100) ==
0b0000000100000000] # only take hits from good events (one TDC word only, no error)
actual_tot_hits = actual_hits[
(actual_hits['event_status'] & 0b0000100010011100) ==
0b0000000000000000] # only take hits from good events for tot
tot, tdc = actual_tot_hits['tot'], actual_tdc_hits['TDC']
if tdc.shape[0] < n_injections:
logging.info(
'%d of %d expected TDC hits for scan parameters %s',
tdc.shape[0], n_injections, ', '.join([
'%s=%s' % (name, value)
for (name, value
) in zip(scan_parameter_names,
actual_scan_parameter_values)
]))
if tot.shape[0] < n_injections:
logging.info(
'%d of %d expected hits for scan parameters %s',
tot.shape[0], n_injections, ', '.join([
'%s=%s' % (name, value)
for (name, value
) in zip(scan_parameter_names,
actual_scan_parameter_values)
]))
inner_loop_scan_parameter_index = np.where(
plser_dac == inner_loop_parameter_values
)[0][
0] # translate the scan parameter value to an index for the result histogram
# numpy mean and std return nan if array is empty
calibration_data[actual_col - 1, actual_row - 1,
inner_loop_scan_parameter_index,
0] = np.mean(tot)
calibration_data[actual_col - 1, actual_row - 1,
inner_loop_scan_parameter_index,
1] = np.mean(tdc)
calibration_data[actual_col - 1, actual_row - 1,
inner_loop_scan_parameter_index,
2] = np.std(tot)
calibration_data[actual_col - 1, actual_row - 1,
inner_loop_scan_parameter_index,
3] = np.std(tdc)
progress_bar.update(index)
progress_bar.finish()
calibration_data_out = calibration_data_file.create_carray(
calibration_data_file.root,
name='HitOrCalibration',
title='Hit OR calibration data',
atom=tb.Atom.from_dtype(calibration_data.dtype),
shape=calibration_data.shape,
filters=tb.Filters(complib='blosc',
complevel=5,
fletcher32=False))
calibration_data_out[:] = calibration_data
calibration_data_out.attrs.dimensions = scan_parameter_names
calibration_data_out.attrs.scan_parameter_values = inner_loop_parameter_values
calibration_data_out.flush()
# with PdfPages(output_filename + "_calibration.pdf") as output_pdf:
plot_scurves(calibration_data[:, :, :, 0],
inner_loop_parameter_values,
"ToT calibration",
"ToT",
15,
"Charge [PlsrDAC]",
filename=analyze_raw_data.output_pdf)
plot_scurves(calibration_data[:, :, :, 1],
inner_loop_parameter_values,
"TDC calibration",
"TDC [ns]",
None,
"Charge [PlsrDAC]",
filename=analyze_raw_data.output_pdf)
tot_mean_all_pix = np.nanmean(calibration_data[:, :, :, 0],
axis=(0, 1))
tot_error_all_pix = np.nanstd(calibration_data[:, :, :, 0],
axis=(0, 1))
tdc_mean_all_pix = np.nanmean(calibration_data[:, :, :, 1],
axis=(0, 1))
tdc_error_all_pix = np.nanstd(calibration_data[:, :, :, 1],
axis=(0, 1))
plot_tot_tdc_calibration(
scan_parameters=inner_loop_parameter_values,
tot_mean=tot_mean_all_pix,
tot_error=tot_error_all_pix,
tdc_mean=tdc_mean_all_pix,
tdc_error=tdc_error_all_pix,
filename=analyze_raw_data.output_pdf,
title="Mean charge calibration of %d pixel(s)" %
np.count_nonzero(~np.all(
np.isnan(calibration_data[:, :, :, 0]), axis=2)))
# plotting individual pixels
if plot_pixel_calibrations is True:
# selecting pixels with non-nan entries
col_row_non_nan = np.nonzero(~np.all(
np.isnan(calibration_data[:, :, :, 0]), axis=2))
plot_pixel_calibrations = np.dstack(col_row_non_nan)[0]
elif plot_pixel_calibrations is False:
plot_pixel_calibrations = np.array([], dtype=np.int)
else: # assuming list of column / row tuples
plot_pixel_calibrations = np.array(
plot_pixel_calibrations) - 1
# generate index array
pixel_indices = np.arange(plot_pixel_calibrations.shape[0])
plot_n_pixels = 10 # number of pixels at the beginning, center and end of the array
np.random.seed(0)
# select random pixels
if pixel_indices.size - 2 * plot_n_pixels >= 0:
random_pixel_indices = np.sort(
np.random.choice(
pixel_indices[plot_n_pixels:-plot_n_pixels],
min(plot_n_pixels,
pixel_indices.size - 2 * plot_n_pixels),
replace=False))
else:
random_pixel_indices = np.array([], dtype=np.int)
selected_pixel_indices = np.unique(
np.hstack([
pixel_indices[:plot_n_pixels], random_pixel_indices,
pixel_indices[-plot_n_pixels:]
]))
# plotting individual pixels
for (column,
row) in plot_pixel_calibrations[selected_pixel_indices]:
logging.info(
"Plotting charge calibration for pixel column " +
str(column + 1) + " / row " + str(row + 1))
tot_mean_single_pix = calibration_data[column, row, :, 0]
tot_std_single_pix = calibration_data[column, row, :, 2]
tdc_mean_single_pix = calibration_data[column, row, :, 1]
tdc_std_single_pix = calibration_data[column, row, :, 3]
plot_tot_tdc_calibration(
scan_parameters=inner_loop_parameter_values,
tot_mean=tot_mean_single_pix,
tot_error=tot_std_single_pix,
tdc_mean=tdc_mean_single_pix,
tdc_error=tdc_std_single_pix,
filename=analyze_raw_data.output_pdf,
title="Charge calibration for pixel column " +
str(column + 1) + " / row " + str(row + 1))
def create_hitor_calibration(output_filename):
logging.info('Analyze and plot results of %s', output_filename)
def plot_calibration(col_row_combinations, scan_parameter, calibration_data, filename): # Result calibration plot function
for index, (column, row) in enumerate(col_row_combinations):
logging.info("Plot calibration for pixel " + str(column) + '/' + str(row))
fig = Figure()
FigureCanvas(fig)
ax = fig.add_subplot(111)
fig.patch.set_facecolor('white')
ax.grid(True)
ax.errorbar(scan_parameter, calibration_data[column - 1, row - 1, :, 0] * 25. + 25., yerr=[calibration_data[column - 1, row - 1, :, 2] * 25, calibration_data[column - 1, row - 1, :, 2] * 25], fmt='o', label='FE-I4 ToT [ns]')
ax.errorbar(scan_parameter, calibration_data[column - 1, row - 1, :, 1] * 1.5625, yerr=[calibration_data[column - 1, row - 1, :, 3] * 1.5625, calibration_data[column - 1, row - 1, :, 3] * 1.5625], fmt='o', label='TDC ToT [ns]')
ax.set_title('Calibration for pixel ' + str(column) + '/' + str(row))
ax.set_xlabel('Charge [PlsrDAC]')
ax.set_ylabel('TOT')
ax.legend(loc=0)
filename.savefig(fig)
if index > 100: # stop for too many plots
logging.info('Do not create pixel plots for more than 100 pixels to safe time')
break
with AnalyzeRawData(raw_data_file=output_filename, create_pdf=True) as analyze_raw_data: # Interpret the raw data file
analyze_raw_data.create_occupancy_hist = False # too many scan parameters to do in ram histograming
analyze_raw_data.create_hit_table = True
analyze_raw_data.create_tdc_hist = True
analyze_raw_data.align_at_tdc = True # align events at TDC words, first word of event has to be a tdc word
analyze_raw_data.interpret_word_table()
analyze_raw_data.interpreter.print_summary()
analyze_raw_data.plot_histograms()
n_injections = analyze_raw_data.n_injections # store number of injections for later cross check
with tb.open_file(output_filename + '_interpreted.h5', 'r') as in_file_h5: # Get scan parameters from interpreted file
meta_data = in_file_h5.root.meta_data[:]
hits = in_file_h5.root.Hits[:]
scan_parameters_dict = get_scan_parameter(meta_data)
inner_loop_parameter_values = scan_parameters_dict[next(reversed(scan_parameters_dict))] # inner loop parameter name is unknown
scan_parameter_names = scan_parameters_dict.keys()
col_row_combinations = get_unique_scan_parameter_combinations(in_file_h5.root.meta_data[:], scan_parameters=('column', 'row'), scan_parameter_columns_only=True)
meta_data_table_at_scan_parameter = get_unique_scan_parameter_combinations(meta_data, scan_parameters=scan_parameter_names)
parameter_values = get_scan_parameters_table_from_meta_data(meta_data_table_at_scan_parameter, scan_parameter_names)
event_number_ranges = get_ranges_from_array(meta_data_table_at_scan_parameter['event_number'])
event_ranges_per_parameter = np.column_stack((parameter_values, event_number_ranges))
event_numbers = hits['event_number'].copy() # create contigous array, otherwise np.searchsorted too slow, http://stackoverflow.com/questions/15139299/performance-of-numpy-searchsorted-is-poor-on-structured-arrays
with tb.openFile(output_filename + "_calibration.h5", mode="w") as calibration_data_file:
logging.info('Create calibration')
output_pdf = PdfPages(output_filename + "_calibration.pdf")
calibration_data = np.zeros(shape=(80, 336, len(inner_loop_parameter_values), 4), dtype='f4') # result of the calibration is a histogram with col_index, row_index, plsrDAC value, mean discrete tot, rms discrete tot, mean tot from TDC, rms tot from TDC
progress_bar = progressbar.ProgressBar(widgets=['', progressbar.Percentage(), ' ', progressbar.Bar(marker='*', left='|', right='|'), ' ', progressbar.AdaptiveETA()], maxval=len(event_ranges_per_parameter), term_width=80)
progress_bar.start()
for index, (parameter_values, event_start, event_stop) in enumerate(event_ranges_per_parameter):
if event_stop is None: # happens for the last chunk
event_stop = hits[-1]['event_number']
array_index = np.searchsorted(event_numbers, np.array([event_start, event_stop]))
actual_hits = hits[array_index[0]:array_index[1]]
actual_col, actual_row, parameter_value = parameter_values
if len(hits[np.logical_and(actual_hits['column'] != actual_col, actual_hits['row'] != actual_row)]):
logging.warning('There are %d hits from not selected pixels in the data', len(actual_hits[np.logical_and(actual_hits['column'] != actual_col, actual_hits['row'] != actual_row)]))
actual_hits = actual_hits[np.logical_and(actual_hits['column'] == actual_col, actual_hits['row'] == actual_row)]
actual_tdc_hits = actual_hits[(actual_hits['event_status'] & 0b0000111110011100) == 0b0000000100000000] # only take hits from good events (one TDC word only, no error)
actual_tot_hits = actual_hits[(actual_hits['event_status'] & 0b0000100010011100) == 0b0000000000000000] # only take hits from good events for tot
tot, tdc = actual_tot_hits['tot'], actual_tdc_hits['TDC']
if tdc.shape[0] != n_injections and index == event_ranges_per_parameter.shape[0] - 1:
logging.warning('There are %d != %d TDC hits for %s = %s', tdc.shape[0], n_injections, str(scan_parameter_names), str(parameter_values))
inner_loop_scan_parameter_index = np.where(parameter_value == inner_loop_parameter_values)[0][0] # translate the scan parameter value to an index for the result histogram
calibration_data[actual_col - 1, actual_row - 1, inner_loop_scan_parameter_index, 0] = np.mean(tot)
calibration_data[actual_col - 1, actual_row - 1, inner_loop_scan_parameter_index, 1] = np.mean(tdc)
calibration_data[actual_col - 1, actual_row - 1, inner_loop_scan_parameter_index, 2] = np.std(tot)
calibration_data[actual_col - 1, actual_row - 1, inner_loop_scan_parameter_index, 3] = np.std(tdc)
progress_bar.update(index)
calibration_data_out = calibration_data_file.createCArray(calibration_data_file.root, name='HitOrCalibration', title='Hit OR calibration data', atom=tb.Atom.from_dtype(calibration_data.dtype), shape=calibration_data.shape, filters=tb.Filters(complib='blosc', complevel=5, fletcher32=False))
calibration_data_out[:] = calibration_data
calibration_data_out.attrs.dimensions = scan_parameter_names
calibration_data_out.attrs.scan_parameter_values = inner_loop_parameter_values
plot_calibration(col_row_combinations, scan_parameter=inner_loop_parameter_values, calibration_data=calibration_data, filename=output_pdf)
output_pdf.close()
progress_bar.finish()
