def make_particles_from_block(self, block):
''' Take a block and use simple rules to construct particles
'''
#take a block and find its parents (clusters and tracks)
parents = block.element_uniqueids
if (len(parents) == 1) & (Identifier.is_ecal(parents[0])):
#print "make photon"
self.make_photon(parents)
elif ( (len(parents) == 2) & (block.count_ecal() == 1 ) & (block.count_tracks() == 1)):
#print "make hadron"
self.make_hadron(parents)
elif ((len(parents) == 3) & (block.count_ecal() == 1) & (block.count_tracks() == 1) & (block.count_hcal() == 1)):
#print "make hadron and photon"
#probably not right but illustrates splitting of parents for more than one particle
hparents = [] # will contain parents for the Hadron which gets everything except the
#hcal which is used for the photom
for elem in parents:
if (Identifier.is_hcal(elem)):
self.make_photon({elem})
else :
hparents.append(elem)
self.make_hadron(hparents)
else :
pass
def make_particles_from_block(self, block):
''' Take a block and use simple rules to construct particles
'''
#take a block and find its parents (clusters and tracks)
parents = block.element_uniqueids
if (len(parents) == 1) & (Identifier.is_ecal(parents[0])):
#print "make photon"
self.make_photon(parents)
elif ((len(parents) == 2) & (block.count_ecal() == 1) &
(block.count_tracks() == 1)):
#print "make hadron"
self.make_hadron(parents)
elif ((len(parents) == 3) & (block.count_ecal() == 1) &
(block.count_tracks() == 1) & (block.count_hcal() == 1)):
#print "make hadron and photon"
#probably not right but illustrates splitting of parents for more than one particle
hparents = [
] # will contain parents for the Hadron which gets everything except the
#hcal which is used for the photom
for elem in parents:
if (Identifier.is_hcal(elem)):
self.make_photon({elem})
else:
hparents.append(elem)
self.make_hadron(hparents)
else:
pass
def simplify_blocks(self, block, history_nodes=None):
''' Block: a block which contains list of element ids and set of edges that connect them
history_nodes: optional dictionary of Nodes with element identifiers in each node
returns None or a dictionary of new split blocks
The goal is to remove, if needed, some links from the block so that each track links to
at most one hcal within a block. In some cases this may separate a block into smaller
blocks (splitblocks). The BlockSplitter is used to return the new smaller blocks.
If history_nodes are provided then the history will be updated. Split blocks will
have the tracks and cluster elements as parents, and also the original block as a parent
'''
ids=block.element_uniqueids
if len(ids)<=1 : #no links to remove
return None
# work out any links that need to be removed
# - for tracks unink all hcals except the closest hcal
# - for ecals unlink hcals
to_unlink = []
for id in ids :
if Identifier.is_track(id):
linked = block.linked_edges(id,"hcal_track") # NB already sorted from small to large distance
if linked!=None and len(linked)>1 :
first_hcal = True
for elem in linked:
if first_hcal:
first_dist=elem.distance
first_hcal = False
else:
if (elem.distance==first_dist):
pass
to_unlink.append(elem)
elif Identifier.is_ecal(id):
# this is now handled elsewhere and so could be removed
# remove all ecal-hcal links. ecal linked to hcal give rise to a photon anyway.
linked = block.linked_edges(id,"ecal_hcal")
to_unlink.extend(linked)
#if there is something to unlink then use the BlockSplitter
splitblocks=None
if len(to_unlink):
splitblocks= BlockSplitter(block, to_unlink, history_nodes).blocks
return splitblocks
def reconstruct_block(self, block):
''' see class description for summary of reconstruction approach
'''
uids = block.element_uniqueids #ids are already stored in sorted order inside block
self.locked = dict((uid, False) for uid in uids)
# first reconstruct muons and electrons
self.reconstruct_muons(block)
self.reconstruct_electrons(block)
# keeping only the elements that have not been used so far
uids = [uid for uid in uids if not self.locked[uid]]
if len(uids) == 1: #TODO WARNING!!! LOTS OF MISSING CASES
uid = uids[0]
parent_ids = [block.uniqueid, uid]
if Identifier.is_ecal(uid):
self.reconstruct_cluster(self.papasevent.get_object(uid),
"ecal_in", parent_ids)
elif Identifier.is_hcal(uid):
self.reconstruct_cluster(self.papasevent.get_object(uid),
"hcal_in", parent_ids)
elif Identifier.is_track(uid):
self.reconstruct_track(self.papasevent.get_object(uid), 211,
parent_ids)
else: #TODO
for uid in uids: #already sorted to have higher energy things first (see pfblock)
if Identifier.is_hcal(uid):
self.reconstruct_hcal(block, uid)
for uid in uids: #already sorted to have higher energy things first
if Identifier.is_track(uid) and not self.locked[uid]:
# unused tracks, so not linked to HCAL
# reconstructing charged hadrons.
# ELECTRONS TO BE DEALT WITH.
parent_ids = [block.uniqueid, uid]
self.reconstruct_track(self.papasevent.get_object(uid),
211, parent_ids)
# tracks possibly linked to ecal->locking cluster
for idlink in block.linked_ids(uid, "ecal_track"):
#ask colin what happened to possible photons here:
self.locked[idlink] = True
#TODO add in extra photonsbut decide where they should go?
self.unused.extend(
[uid for uid in block.element_uniqueids if not self.locked[uid]])
def reconstruct_block(self, block):
''' see class description for summary of reconstruction approach
'''
particles = dict()
ids = block.element_uniqueids
self.locked = dict()
for id in ids:
self.locked[id] = False
self.debugprint = False
if (self.debugprint and len(block.element_uniqueids)> 4):
print block
if len(ids) == 1: #TODO WARNING!!! LOTS OF MISSING CASES
id = ids[0]
if Identifier.is_ecal(id):
self.insert_particle(block, self.reconstruct_cluster(block.pfevent.ecal_clusters[id],"ecal_in"))
elif Identifier.is_hcal(id):
self.insert_particle(block, self.reconstruct_cluster(block.pfevent.hcal_clusters[id],"hcal_in"))
elif Identifier.is_track(id):
self.insert_particle(block, self.reconstruct_track(block.pfevent.tracks[id]))
# ask Colin about energy balance - what happened to the associated clusters that one would expect?
else: #TODO
for id in ids :
if Identifier.is_hcal(id):
self.reconstruct_hcal(block,id)
for id in ids :
if Identifier.is_track(id) and not self.locked[id]:
# unused tracks, so not linked to HCAL
# reconstructing charged hadrons.
# ELECTRONS TO BE DEALT WITH.
self.insert_particle(block, self.reconstruct_track(block.pfevent.tracks[id]))
# tracks possibly linked to ecal->locking cluster
for idlink in block.linked_ids(id,"ecal_track"):
#ask colin what happened to possible photons here:
self.locked[idlink] = True
def reconstruct_block(self, block):
''' see class description for summary of reconstruction approach
'''
particles = dict()
ids = block.element_uniqueids
#ids = sorted( ids, key = lambda id: Identifier.type_short_code )
self.locked = dict()
for id in ids:
self.locked[id] = False
self.debugprint = False
if (self.debugprint and len(block.element_uniqueids)> 4):
print block
if len(ids) == 1: #TODO WARNING!!! LOTS OF MISSING CASES
id = ids[0]
if Identifier.is_ecal(id):
self.insert_particle(block, self.reconstruct_cluster(block.pfevent.ecal_clusters[id],"ecal_in"))
elif Identifier.is_hcal(id):
self.insert_particle(block, self.reconstruct_cluster(block.pfevent.hcal_clusters[id],"hcal_in"))
elif Identifier.is_track(id):
self.insert_particle(block, self.reconstruct_track(block.pfevent.tracks[id]))
# ask Colin about energy balance - what happened to the associated clusters that one would expect?
else: #TODO
for id in sorted(ids) : #newsort
if Identifier.is_hcal(id):
self.reconstruct_hcal(block,id)
for id in sorted(ids) : #newsort
if Identifier.is_track(id) and not self.locked[id]:
# unused tracks, so not linked to HCAL
# reconstructing charged hadrons.
# ELECTRONS TO BE DEALT WITH.
self.insert_particle(block, self.reconstruct_track(block.pfevent.tracks[id]))
# tracks possibly linked to ecal->locking cluster
for idlink in block.linked_ids(id,"ecal_track"):
#ask colin what happened to possible photons here:
self.locked[idlink] = True
def reconstruct_block(self, block):
''' see class description for summary of reconstruction approach
'''
uids = block.element_uniqueids #ids are already stored in sorted order inside block
self.locked = dict( (uid, False) for uid in uids )
# first reconstruct muons and electrons
self.reconstruct_muons(block)
self.reconstruct_electrons(block)
# keeping only the elements that have not been used so far
uids = [uid for uid in uids if not self.locked[uid]]
if len(uids) == 1: #TODO WARNING!!! LOTS OF MISSING CASES
uid = uids[0]
parent_ids = [block.uniqueid, uid]
if Identifier.is_ecal(uid):
self.reconstruct_cluster(self.papasevent.get_object(uid),
"ecal_in", parent_ids)
elif Identifier.is_hcal(uid):
self.reconstruct_cluster(self.papasevent.get_object(uid),
"hcal_in", parent_ids)
elif Identifier.is_track(uid):
self.reconstruct_track(self.papasevent.get_object(uid), 211,
parent_ids)
else: #TODO
for uid in uids: #already sorted to have higher energy things first (see pfblock)
if Identifier.is_hcal(uid):
self.reconstruct_hcal(block, uid)
for uid in uids: #already sorted to have higher energy things first
if Identifier.is_track(uid) and not self.locked[uid]:
# unused tracks, so not linked to HCAL
# reconstructing charged hadrons.
# ELECTRONS TO BE DEALT WITH.
parent_ids = [block.uniqueid, uid]
self.reconstruct_track(self.papasevent.get_object(uid),
211, parent_ids)
# tracks possibly linked to ecal->locking cluster
for idlink in block.linked_ids(uid, "ecal_track"):
#ask colin what happened to possible photons here:
self.locked[idlink] = True
#TODO add in extra photonsbut decide where they should go?
self.unused.extend([uid for uid in block.element_uniqueids if not self.locked[uid]])
def summary_of_linked_elems(self, id):
#find everything that is linked to this id
#and write a summary of what is found
#the BFS search returns a list of the ids that are connected to the id of interest
BFS = BreadthFirstSearchIterative(self.history_nodes[id], "undirected")
#collate the string descriptions
track_descrips = []
ecal_descrips = []
hcal_descrips = []
#sim_particle_descrips = []
rec_particle_descrips = []
block_descrips = []
for n in BFS.result :
z = n.get_value()
obj = self.pfevent.get_object(z)
descrip = obj.__str__()
# if (Identifier.is_particle(z)):
# sim_particle_descrips.append(descrip)
if (Identifier.is_block(z)):
block_descrips.append(descrip)
elif (Identifier.is_track(z)):
track_descrips.append(descrip)
elif (Identifier.is_ecal(z)):
ecal_descrips.append(descrip)
elif (Identifier.is_hcal(z)):
hcal_descrips.append(descrip)
elif (Identifier.is_rec_particle(z)):
rec_particle_descrips.append(descrip)
print "history connected to node:", id
print "block", block_descrips
print " tracks", track_descrips
print " ecals", ecal_descrips
print " hcals", hcal_descrips
print "rec particles", rec_particle_descrips
def summary_of_linked_elems(self, id):
# find everything that is linked to this id
# and write a summary of what is found
# the BFS search returns a list of the ids that are connected to the id of interest
BFS = BreadthFirstSearchIterative(self.history_nodes[id], "undirected")
# collate the string descriptions
track_descrips = []
ecal_descrips = []
hcal_descrips = []
# sim_particle_descrips = []
rec_particle_descrips = []
block_descrips = []
for n in BFS.result:
z = n.get_value()
obj = self.pfevent.get_object(z)
descrip = obj.__str__()
# if (Identifier.is_particle(z)):
# sim_particle_descrips.append(descrip)
if Identifier.is_block(z):
block_descrips.append(descrip)
elif Identifier.is_track(z):
track_descrips.append(descrip)
elif Identifier.is_ecal(z):
ecal_descrips.append(descrip)
elif Identifier.is_hcal(z):
hcal_descrips.append(descrip)
elif Identifier.is_rec_particle(z):
rec_particle_descrips.append(descrip)
print "history connected to node:", id
print "block", block_descrips
print " tracks", track_descrips
print " ecals", ecal_descrips
print " hcals", hcal_descrips
print "rec particles", rec_particle_descrips
def count_ecal(self):
''' Counts how many ecal cluster ids are in the block '''
count = 0
for elem in self.element_uniqueids:
count += Identifier.is_ecal(elem)
return count
def count_ecal(self):
''' Counts how many ecal cluster ids are in the block '''
count=0
for elem in self.element_uniqueids:
count += Identifier.is_ecal(elem)
return count
