def test_get_voxel_track_relations():
relations = [0, 0, 1, 2, 2, 2, np.nan]
assert relations == get_voxel_track_relations(voxels_df2, event_tracks)
def fanal_ana(det_name, # Detector name: 'new', 'next100', 'next500'
event_type, # Event type: 'bb0nu', 'Tl208', 'Bi214'
fwhm, # FWHM at Qbb
spatial_def, # Spatial definition: 'low', 'high'
voxel_Eth, # Voxel energy threshold
track_Eth, # Track energy threshold
max_num_tracks, # Maximum number of tracks
blob_radius, # Blob radius
blob_Eth, # Blob energy threshold
roi_Emin, # ROI minimum energy
roi_Emax, # ROI maximum energy
files_in, # Input files
event_range, # Range of events to analyze: all, ... ??
file_out, # Output file
compression, # Compression of output file: 'ZLIB1', 'ZLIB4',
# 'ZLIB5', 'ZLIB9', 'BLOSC5', 'BLZ4HC5'
verbosity_level):
### LOGGER
logger = get_logger('FanalAna', verbosity_level)
### DETECTOR NAME
det_name = getattr(DetName, det_name)
### SPATIAL DEFINITION
spatial_def = getattr(SpatialDef, spatial_def)
### PRINTING GENERAL INFO
print('\n***********************************************************************************')
print('***** Detector: {}'.format(det_name.name))
print('***** Analizing {} events'.format(event_type))
print('***** Energy Resolution: {:.2f}% FWFM at Qbb'.format(fwhm / units.perCent))
print('***** Spatial definition: {}'.format(spatial_def.name))
print('***********************************************************************************\n')
print('* Voxel Eth: {:4.1f} keV Track Eth: {:4.1f} keV Max Num Tracks: {}\n'
.format(voxel_Eth/units.keV, track_Eth/units.keV, max_num_tracks))
print('* Blob radius: {:.1f} mm Blob Eth: {:4.1f} keV\n'
.format(blob_radius, blob_Eth / units.keV))
print('* ROI limits: [{:4.1f}, {:4.1f}] keV\n'
.format(roi_Emin/units.keV, roi_Emax/units.keV))
### INPUT RECONSTRUCTION FILE AND GROUP
reco_group_name = get_reco_group_name(fwhm/units.perCent, spatial_def)
print('* Input reco file name:', files_in)
print(' Reco group name: {}\n'.format(reco_group_name))
### OUTPUT FILE, ITS GROUPS & ATTRIBUTES
# Output analysis file
oFile = tb.open_file(file_out, 'w', filters=tbl_filters(compression))
# Analysis group Name
ana_group_name = get_ana_group_name(fwhm/units.perCent, spatial_def)
oFile.create_group('/', 'FANALIC')
oFile.create_group('/FANALIC', ana_group_name[9:])
print('* Output analysis file name:', file_out)
print(' Ana group name: {}\n'.format(ana_group_name))
# Attributes
oFile.set_node_attr(ana_group_name, 'input_reco_file', files_in[0])
oFile.set_node_attr(ana_group_name, 'input_reco_group', reco_group_name)
oFile.set_node_attr(ana_group_name, 'event_type', event_type)
oFile.set_node_attr(ana_group_name, 'energy_resolution', fwhm / units.perCent)
oFile.set_node_attr(ana_group_name, 'voxel_Eth', voxel_Eth)
oFile.set_node_attr(ana_group_name, 'track_Eth', track_Eth)
oFile.set_node_attr(ana_group_name, 'max_num_tracks', max_num_tracks)
oFile.set_node_attr(ana_group_name, 'blob_radius', blob_radius)
oFile.set_node_attr(ana_group_name, 'blob_Eth', blob_Eth)
oFile.set_node_attr(ana_group_name, 'roi_Emin', roi_Emin)
oFile.set_node_attr(ana_group_name, 'roi_Emax', roi_Emax)
### DATA TO STORE
# Dictionaries for events & voxels data
events_dict = get_events_ana_dict()
voxels_dict = get_voxels_ana_dict()
### ANALYSIS PROCEDURE
# Getting the events & voxels data from the reconstruction phase
# This is the option a little bit slower that requires less memory ... (TO BE CHECKED!!)
# event_numbers_toAnalize = pd.read_hdf(files_in[0], reco_group_name + '/events',
# where=['fid_filter = True']).index
# And this is the fastest option requiring more memory
events_df = pd.read_hdf(files_in[0], reco_group_name + '/events')
voxels_df = pd.read_hdf(files_in[0], reco_group_name + '/voxels')
# Identifying as negligible all the voxels with energy lower than threshold
voxels_df['negli'] = voxels_df.E < voxel_Eth
print('* Total Voxels in File: {0} Negligible Voxels (below {1:3.1f} keV): {2}\n'
.format(len(voxels_df), voxel_Eth / units.keV,
len(voxels_df[voxels_df.negli == True])))
# Analyzing only the fiducial events ...
print('* Analyzing events ...\n')
# Counter of analyzed events for verbosing pourpouses
num_analyzed_events = 0
# Looping through all the events that passed the fiducial filter
for event_id in events_df[events_df.fid_filter].index:
# Updating counter of analyzed events
num_analyzed_events += 1
if not int(str(num_analyzed_events)[-int(math.log10(num_analyzed_events)):]):
print('* Num analyzed events: {}'.format(num_analyzed_events))
# Verbosing
logger.info('Analyzing event Id: {0} ...'.format(event_id))
# Getting the voxels of current event and their sizes
event_voxels = voxels_df[voxels_df.event_id == event_id]
num_event_voxels = len(event_voxels)
num_event_voxels_negli = len(event_voxels[event_voxels.negli == True])
event_data = events_df.loc[event_id]
voxel_dimensions = (event_data.voxel_sizeX, event_data.voxel_sizeY,
event_data.voxel_sizeZ)
logger.info(' Total Voxels: {} Negli. Voxels: {} Voxels Size: ({:3.1f}, {:3.1f}, {:3.1f}) mm'
.format(num_event_voxels, num_event_voxels_negli,
voxel_dimensions[0], voxel_dimensions[1],
voxel_dimensions[2]))
# If there is any negligible Voxel,
# distribute its energy between its neighbours,
# if not, all voxels maintain their previous energies
if num_event_voxels_negli:
event_voxels_newE = get_new_energies(event_voxels)
else:
event_voxels_newE = event_voxels.E.tolist()
# Translate fanalIC voxels info to IC voxels to make tracks
ic_voxels = [Voxel(event_voxels.iloc[i].X, event_voxels.iloc[i].Y,
event_voxels.iloc[i].Z, event_voxels_newE[i],
voxel_dimensions) for i in range(num_event_voxels)]
# Make tracks
event_tracks = make_track_graphs(ic_voxels)
num_event_tracks = len(event_tracks)
logger.info(' Num initial tracks: {:2}'.format(num_event_tracks))
# Appending to every voxel, the track it belongs to
event_voxels_tracks = get_voxel_track_relations(event_voxels, event_tracks)
# Appending info of this event voxels
extend_voxels_ana_data(voxels_dict, event_voxels.index,
event_voxels_newE, event_voxels_tracks)
# Processing tracks: Getting energies, sorting and filtering ...
event_sorted_tracks = process_tracks(event_tracks, track_Eth)
num_event_tracks = len(event_sorted_tracks)
# Storing 3 hottest track info
if num_event_tracks >= 1:
track0_E = event_sorted_tracks[0][0]
track0_voxels = len(event_sorted_tracks[0][1].nodes())
track0_length = track_length(event_sorted_tracks[0][1])
else:
track0_E = track0_voxels = track0_length = np.nan
if num_event_tracks >= 2:
track1_E = event_sorted_tracks[1][0]
track1_voxels = len(event_sorted_tracks[1][1].nodes())
track1_length = track_length(event_sorted_tracks[1][1])
else:
track1_E = track1_voxels = track1_length = np.nan
if num_event_tracks >= 3:
track2_E = event_sorted_tracks[2][0]
track2_voxels = len(event_sorted_tracks[2][1].nodes())
track2_length = track_length(event_sorted_tracks[2][1])
else:
track2_E = track2_voxels = track2_length = np.nan
# Applying the tracks filter
tracks_filter = ((num_event_tracks > 0) &
(num_event_tracks <= max_num_tracks))
# Verbosing
logger.info(' Num final tracks: {:2} --> tracks_filter: {}'
.format(num_event_tracks, tracks_filter))
# For those events NOT passing the tracks filter:
# Storing data of NON tracks_filter vents
if not tracks_filter:
extend_events_ana_data(events_dict, event_id, num_event_tracks,
track0_E, track0_voxels, track0_length,
track1_E, track1_voxels, track1_length,
track2_E, track2_voxels, track2_length,
tracks_filter)
# Only for those events passing the tracks filter:
else:
# Getting the blob energies of the track with highest energy
blobs_E = blob_energies(event_sorted_tracks[0][1], blob_radius)
blob1_E = blobs_E[1]
blob2_E = blobs_E[0]
# Applying the blobs filter
blobs_filter = (blob2_E > blob_Eth)
# Verbosing
logger.info(' Blob 1 energy: {:4.1f} keV Blob 2 energy: {:4.1f} keV --> Blobs filter: {}'
.format(blob1_E/units.keV, blob2_E/units.keV, blobs_filter))
# For those events NOT passing the blobs filter:
# Storing data of NON blobs_filter vents
if not blobs_filter:
extend_events_ana_data(events_dict, event_id, num_event_tracks,
track0_E, track0_voxels, track0_length,
track1_E, track1_voxels, track1_length,
track2_E, track2_voxels, track2_length,
tracks_filter, blob1_E = blob1_E,
blob2_E = blob2_E, blobs_filter = blobs_filter)
# Only for those events passing the blobs filter:
else:
# Getting the total event smeared energy
event_smE = events_df.loc[event_id].smE
# Applying the ROI filter
roi_filter = ((event_smE >= roi_Emin) & (event_smE <= roi_Emax))
# Verbosing
logger.info(' Event energy: {:6.1f} keV --> ROI filter: {}'
.format(event_smE / units.keV, roi_filter))
# Storing all the events (as this is the last filter)
extend_events_ana_data(events_dict, event_id, num_event_tracks,
track0_E, track0_voxels, track0_length,
track1_E, track1_voxels, track1_length,
track2_E, track2_voxels, track2_length,
tracks_filter, blob1_E = blob1_E,
blob2_E = blob2_E, blobs_filter = blobs_filter,
roi_filter = roi_filter)
### STORING DATA
# Storing events and voxels dataframes
print('\n* Storing data in the output file ...\n {}\n'.format(file_out))
store_events_ana_data(file_out, ana_group_name, events_df, events_dict)
store_voxels_ana_data(file_out, ana_group_name, voxels_df, voxels_dict)
# Storing event counters as attributes
tracks_filter_events, blobs_filter_events, roi_filter_events = \
store_events_ana_counters(oFile, ana_group_name, events_df)
### Ending ...
oFile.close()
print('* Analysis done !!\n')
# Printing analysis numbers
with tb.open_file(files_in[0], mode='r') as iFile:
simulated_events = iFile.get_node_attr(reco_group_name, 'simulated_events')
stored_events = iFile.get_node_attr(reco_group_name, 'stored_events')
smE_filter_events = iFile.get_node_attr(reco_group_name, 'smE_filter_events')
fid_filter_events = iFile.get_node_attr(reco_group_name, 'fid_filter_events')
print('''* Event counters:
Simulated events: {0:9}
Stored events: {1:9}
smE_filter events: {2:9}
fid_filter events: {3:9}
tracks_filter events: {4:9}
blobs_filter events: {5:9}
roi_filter events: {6:9}\n'''
.format(simulated_events, stored_events, smE_filter_events,
fid_filter_events, tracks_filter_events, blobs_filter_events,
roi_filter_events))
def fanal_ana(
det_name, # Detector name: 'new', 'next100', 'next500'
event_type, # Event type: 'bb0nu', 'Tl208', 'Bi214'
fwhm, # FWHM at Qbb
voxel_size, # Voxel size (x, y, z)
track_Eth, # Track energy threshold
max_num_tracks, # Maximum number of tracks
blob_radius, # Blob radius
blob_Eth, # Blob energy threshold
roi_Emin, # ROI minimum energy
roi_Emax, # ROI maximum energy
files_in, # Input files
event_range, # Range of events to analyze: all, ... ??
file_out, # Output file
compression, # Compression of output file: 'ZLIB1', 'ZLIB4',
# 'ZLIB5', 'ZLIB9', 'BLOSC5', 'BLZ4HC5'
verbosity_level):
### LOGGER
logger = get_logger('FanalAna', verbosity_level)
### DETECTOR NAME
det_name = getattr(DetName, det_name)
### PRINTING GENERAL INFO
print(
'\n***********************************************************************************'
)
print('***** Detector: {}'.format(det_name.name))
print('***** Analizing {} events'.format(event_type))
print('***** Energy Resolution: {:.2f}% FWFM at Qbb'.format(fwhm /
units.perCent))
print('***** Voxel Size: ({}, {}, {}) mm'.format(voxel_size[0] / units.mm,
voxel_size[1] / units.mm,
voxel_size[2] / units.mm))
print(
'***********************************************************************************\n'
)
print('* Track Eth: {:4.1f} keV Max Num Tracks: {}\n'.format(
track_Eth / units.keV, max_num_tracks))
print('* Blob radius: {:.1f} mm Blob Eth: {:4.1f} keV\n'.format(
blob_radius, blob_Eth / units.keV))
print('* ROI limits: [{:4.1f}, {:4.1f}] keV\n'.format(
roi_Emin / units.keV, roi_Emax / units.keV))
### INPUT RECONSTRUCTION FILE AND GROUP
reco_group_name = get_reco_group_name(fwhm / units.perCent, voxel_size)
print('* {} {} input reco file names:'.format(len(files_in), event_type))
for iFileName in files_in:
print(' ', iFileName)
print(' Reco group name: {}\n'.format(reco_group_name))
### OUTPUT FILE, ITS GROUPS & ATTRIBUTES
# Output analysis file
oFile = tb.open_file(file_out, 'w', filters=tbl_filters(compression))
# Analysis group Name
ana_group_name = get_ana_group_name(fwhm / units.perCent, voxel_size)
oFile.create_group('/', 'FANALIC')
oFile.create_group('/FANALIC', ana_group_name[9:])
print('* Output analysis file name:', file_out)
print(' Ana group name: {}\n'.format(ana_group_name))
# Attributes
oFile.set_node_attr(ana_group_name, 'input_reco_files', files_in)
oFile.set_node_attr(ana_group_name, 'input_reco_group', reco_group_name)
oFile.set_node_attr(ana_group_name, 'event_type', event_type)
oFile.set_node_attr(ana_group_name, 'energy_resolution',
fwhm / units.perCent)
oFile.set_node_attr(ana_group_name, 'track_Eth', track_Eth)
oFile.set_node_attr(ana_group_name, 'max_num_tracks', max_num_tracks)
oFile.set_node_attr(ana_group_name, 'blob_radius', blob_radius)
oFile.set_node_attr(ana_group_name, 'blob_Eth', blob_Eth)
oFile.set_node_attr(ana_group_name, 'roi_Emin', roi_Emin)
oFile.set_node_attr(ana_group_name, 'roi_Emax', roi_Emax)
### DATA TO STORE
# Event counters
simulated_events = 0
stored_events = 0
smE_filter_events = 0
fid_filter_events = 0
tracks_filter_events = 0
blobs_filter_events = 0
roi_filter_events = 0
analyzed_events = 0
toUpdate_events = 1
# Dictionaries for events & voxels data
events_dict = get_events_ana_dict()
voxels_dict = get_voxels_ana_dict()
events_reco_df = pd.DataFrame()
voxels_reco_df = pd.DataFrame()
### ANALYSIS PROCEDURE
print('* Analyzing events ...\n')
# Looping through all the input files
for iFileName in files_in:
# Updating reconstruction counters
with tb.open_file(iFileName, mode='r') as reco_file:
simulated_events += reco_file.get_node_attr(
reco_group_name, 'simulated_events')
stored_events += reco_file.get_node_attr(reco_group_name,
'stored_events')
smE_filter_events += reco_file.get_node_attr(
reco_group_name, 'smE_filter_events')
fid_filter_events += reco_file.get_node_attr(
reco_group_name, 'fid_filter_events')
# Getting the events & voxels data from the reconstruction phase
file_events = pd.read_hdf(iFileName, reco_group_name + '/events')
file_voxels = pd.read_hdf(iFileName, reco_group_name + '/voxels')
# Updating reconstruction dataframes
events_reco_df = pd.concat([events_reco_df, file_events], axis=0)
voxels_reco_df = pd.concat([voxels_reco_df, file_voxels], axis=0)
print('* Processing {} ...'.format(iFileName))
### Looping through all the events that passed the fiducial filter
for event_number, event_df in file_events[
file_events.fid_filter].iterrows():
# Updating counter of analyzed events
analyzed_events += 1
logger.info('Analyzing event Id: {0} ...'.format(event_number))
# Getting event data
event_data = get_event_ana_data()
event_data['event_id'] = event_number
event_voxels = file_voxels.loc[event_number]
num_event_voxels = len(event_voxels)
num_event_voxels_negli = len(event_voxels[event_voxels.negli])
voxel_dimensions = (event_df.voxel_sizeX, event_df.voxel_sizeY,
event_df.voxel_sizeZ)
logger.info(' Total Voxels: {} Negli. Voxels: {} Voxels Size: ({:3.1f}, {:3.1f}, {:3.1f}) mm'\
.format(num_event_voxels, num_event_voxels_negli, voxel_dimensions[0],
voxel_dimensions[1], voxel_dimensions[2]))
# If there is any negligible Voxel, distribute its energy between its neighbours,
# if not, all voxels maintain their previous energies
if num_event_voxels_negli:
event_voxels_newE = get_new_energies(event_voxels)
else:
event_voxels_newE = event_voxels.E.tolist()
# Translate fanalIC voxels info to IC voxels to make tracks
#ic_voxels = [Voxel(event_voxels.iloc[i].X, event_voxels.iloc[i].Y, event_voxels.iloc[i].Z,
# event_voxels_newE[i], voxel_dimensions) for i in range(num_event_voxels)]
ic_voxels = []
for i, voxel in event_voxels.iterrows():
ic_voxel = Voxel(voxel.X, voxel.Y, voxel.Z,
event_voxels_newE[i], voxel_dimensions)
ic_voxels.append(ic_voxel)
# Make tracks
event_tracks = make_track_graphs(ic_voxels)
num_ini_tracks = len(event_tracks)
logger.info(' Num initial tracks: {:2}'.format(num_ini_tracks))
# Appending to every voxel, the track it belongs to
event_voxels_tracks = get_voxel_track_relations(
event_voxels, event_tracks)
# Appending ana-info to this event voxels
extend_voxels_ana_dict(voxels_dict, event_number,
event_voxels.index.tolist(),
event_voxels_newE, event_voxels_tracks)
# Processing tracks: Getting energies, sorting and filtering ...
event_sorted_tracks = process_tracks(event_tracks, track_Eth)
event_data['num_tracks'] = len(event_sorted_tracks)
# Getting 3 hottest tracks info
if event_data['num_tracks'] >= 1:
event_data['track0_E'] = event_sorted_tracks[0][0]
event_data['track0_length'] = event_sorted_tracks[0][1]
event_data['track0_voxels'] = len(
event_sorted_tracks[0][2].nodes())
if event_data['num_tracks'] >= 2:
event_data['track1_E'] = event_sorted_tracks[1][0]
event_data['track1_length'] = event_sorted_tracks[1][1]
event_data['track1_voxels'] = len(
event_sorted_tracks[1][2].nodes())
if event_data['num_tracks'] >= 3:
event_data['track2_E'] = event_sorted_tracks[2][0]
event_data['track2_length'] = event_sorted_tracks[2][1]
event_data['track2_voxels'] = len(
event_sorted_tracks[2][2].nodes())
# Applying the tracks filter consisting on:
# 0 < num tracks < max_num_tracks
# the track length must be longer than 2 times the blob_radius
event_data['tracks_filter'] = (
(event_data['num_tracks'] > 0) &
(event_data['num_tracks'] <= max_num_tracks) &
(event_data['track0_length'] >= 2. * blob_radius))
# Verbosing
logger.info(' Num final tracks: {:2} --> tracks_filter: {}' \
.format(event_data['num_tracks'], event_data['tracks_filter']))
### For those events passing the tracks filter:
if event_data['tracks_filter']:
# Getting the blob energies of the track with highest energy
event_data['blob1_E'], event_data['blob2_E'] = \
blob_energies(event_sorted_tracks[0][2], blob_radius)
# Applying the blobs filter
event_data['blobs_filter'] = (event_data['blob2_E'] > blob_Eth)
# Verbosing
logger.info(' Blob 1 energy: {:4.1f} keV Blob 2 energy: {:4.1f} keV --> Blobs filter: {}'\
.format(event_data['blob1_E']/units.keV, event_data['blob2_E']/units.keV,
event_data['blobs_filter']))
### For those events passing the blobs filter:
if event_data['blobs_filter']:
# Getting the total event smeared energy
event_smE = file_events.loc[event_number].smE
# Applying the ROI filter
event_data['roi_filter'] = ((event_smE >= roi_Emin) &
(event_smE <= roi_Emax))
# Verbosing
logger.info(' Event energy: {:6.1f} keV --> ROI filter: {}'\
.format(event_smE / units.keV, event_data['roi_filter']))
# Storing event_data
extend_events_ana_dict(events_dict, event_data)
# Verbosing
if (not (analyzed_events % toUpdate_events)):
print('* Num analyzed events: {}'.format(analyzed_events))
if (analyzed_events == (10 * toUpdate_events)):
toUpdate_events *= 10
### STORING ANALYSIS DATA
print('* Total analyzed events: {}'.format(analyzed_events))
# Storing events and voxels dataframes
print('\n* Storing data in the output file ...\n {}\n'.format(file_out))
store_events_ana_dict(file_out, ana_group_name, events_reco_df,
events_dict)
store_voxels_ana_dict(file_out, ana_group_name, voxels_reco_df,
voxels_dict)
# Storing event counters as attributes
tracks_filter_events = sum(events_dict['tracks_filter'])
blobs_filter_events = sum(events_dict['blobs_filter'])
roi_filter_events = sum(events_dict['roi_filter'])
store_events_ana_counters(oFile, ana_group_name, simulated_events,
stored_events, smE_filter_events,
fid_filter_events, tracks_filter_events,
blobs_filter_events, roi_filter_events)
### Ending ...
oFile.close()
print('* Analysis done !!\n')
print('''* Event counters:
Simulated events: {0:9}
Stored events: {1:9}
smE_filter events: {2:9}
fid_filter events: {3:9}
tracks_filter events: {4:9}
blobs_filter events: {5:9}
roi_filter events: {6:9}'''.format(simulated_events, stored_events,
smE_filter_events, fid_filter_events,
tracks_filter_events,
blobs_filter_events,
roi_filter_events))
# Translate fanalIC voxels info to IC voxels to make tracks
ic_voxels = [
Voxel(event_voxels.iloc[i].X, event_voxels.iloc[i].Y,
event_voxels.iloc[i].Z, event_voxels_newE[i], voxel_dimensions)
for i in range(num_event_voxels)
]
# Make tracks
event_tracks = make_track_graphs(ic_voxels)
num_event_tracks = len(event_tracks)
if VERBOSITY_LEVEL >= 2:
print(' Num initial tracks: {:2}'.format(num_event_tracks))
# Appending to every voxel, the track it belongs to
event_voxels_tracks = get_voxel_track_relations(event_voxels, event_tracks)
# Appending info of this event voxels
extend_voxels_ana_data(voxels_dict, event_voxels.index, event_voxels_newE,
event_voxels_tracks)
# Processing tracks: Getting energies, sorting and filtering ...
event_sorted_tracks = process_tracks(event_tracks, TRACK_E_THRESHOLD,
(VERBOSITY_LEVEL >= 3))
num_event_tracks = len(event_sorted_tracks)
# Storing 3 hottest track info
if num_event_tracks >= 1:
track0_E = event_sorted_tracks[0][0]
track0_voxels = len(event_sorted_tracks[0][1].nodes())
else: