def create_virtual_plane_dict(file_reader, virtual_plane_dict):
"""
Matches up scifitrackpoints to virtual planes to make a lookup dictionary
"""
# virtual_plane_dict = {}
for num in range(-15, 0, 1):
virtual_plane_dict[num] = (-1, (ALIGNMENT_TOLERANCE * 100.0))
for num in range(1, 16, 1):
virtual_plane_dict[num] = (-1, (ALIGNMENT_TOLERANCE * 100.0))
while file_reader.next_event():
scifi_event = file_reader.get_event('scifi')
mc_event = file_reader.get_event('mc')
tracks = scifi_event.scifitracks()
for track in tracks:
trackpoints = track.scifitrackpoints()
for trkpt in trackpoints:
z_pos = trkpt.pos().z()
plane_id = tools.calculate_plane_id(trkpt.tracker(), trkpt.station(), \
trkpt.plane() )
for vhit_num in xrange(mc_event.GetVirtualHitsSize()):
vhit = mc_event.GetAVirtualHit(vhit_num)
diff = math.fabs(vhit.GetPosition().z() - z_pos)
if diff < virtual_plane_dict[plane_id][1]:
virtual_plane_dict[plane_id] = (vhit.GetStationId(),
diff)
# print plane_id, vhit.GetStationId(), diff
done = True
num_found = 0
for plane in virtual_plane_dict:
if virtual_plane_dict[plane][1] > ALIGNMENT_TOLERANCE:
# print plane, virtual_plane_dict[plane]
done = False
else:
num_found += 1
sys.stdout.write(
"- Finding Virtual Planes : Running ({0} of {1})\r".format(
num_found, 30))
sys.stdout.flush()
if done:
break
else:
if REQUIRE_ALL_VIRTUALS:
raise ValueError("Could not locate all virtuals planes")
file_reader.reset()
return virtual_plane_dict
def make_spacepoint_mc_pairs(plot_dict, data_dict, virtual_plane_dict, \
scif_event, mc_event) :
"""
Make pairs of SciFiSpacepoints and MC VirtualHits
"""
paired_hits = []
spacepoints = scifi_event.spacepoints()
# Find a reference spacepoint
for spacepoint in spacepoints:
for plane in range(3):
pl_id = tools.calculate_plane_id(spacepoint.get_tracker(),
spacepoint.get_station(), plane)
expected_virtual_plane = virtual_plane_dict[pl_id][0]
# Find the virtual hit
for vhit_num in xrange(mc_event.GetVirtualHitsSize()):
vhit = mc_event.GetAVirtualHit(vhit_num)
if vhit.GetStationId() == expected_virtual_plane and \
abs(vhit.GetParticleId()) == MUON_PID :
virtual_hit = vhit
break
else:
data_dict['counters']['missing_virtual_hits'] += 1
continue
# Add to list
new_spacepoint = { 'pos' : [], 'mom' : [0.0, 0.0, 200.0], 'grad' : [0.0, 0.0], 'id' : pl_id, 'pull' : 0.0, \
'pos_err' : [-1.0, -1.0, -1.0], 'mom_err' : [-1.0, -1.0, -1.0], 'grad_err' : [-1.0, -1.0] }
new_spacepoint['pos'].append(spacepoint.get_global_position().x())
new_spacepoint['pos'].append(spacepoint.get_global_position().y())
new_spacepoint['pos'].append(spacepoint.get_global_position().z())
paired_hits.append((new_spacepoint, virtual_hit))
data_dict['counters']['found_pairs'] += 1
found_up = 0
found_down = 0
for scifi_hit, virt_hit in paired_hits:
if scifi_hit['id'] < 0:
found_up += 1
else:
found_down += 1
data_dict['counters']['found_tracks_up'] += found_up
data_dict['counters']['found_tracks_down'] += found_down
return paired_hits
def make_spacepoint_mc_pairs(plot_dict, data_dict, virtual_plane_dict, \
scif_event, mc_event) :
"""
Make pairs of SciFiSpacepoints and MC VirtualHits
"""
paired_hits = []
spacepoints = scifi_event.spacepoints()
# Find a reference spacepoint
for spacepoint in spacepoints :
for plane in range( 3 ) :
pl_id = tools.calculate_plane_id(spacepoint.get_tracker(), spacepoint.get_station(), plane)
expected_virtual_plane = virtual_plane_dict[pl_id][0]
# Find the virtual hit
for vhit_num in xrange(mc_event.GetVirtualHitsSize()) :
vhit = mc_event.GetAVirtualHit(vhit_num)
if vhit.GetStationId() == expected_virtual_plane and \
abs(vhit.GetParticleId()) == MUON_PID :
virtual_hit = vhit
break
else :
data_dict['counters']['missing_virtual_hits'] += 1
continue
# Add to list
new_spacepoint = { 'pos' : [], 'mom' : [0.0, 0.0, 200.0], 'grad' : [0.0, 0.0], 'id' : pl_id, 'pull' : 0.0, \
'pos_err' : [-1.0, -1.0, -1.0], 'mom_err' : [-1.0, -1.0, -1.0], 'grad_err' : [-1.0, -1.0] }
new_spacepoint['pos'].append(spacepoint.get_global_position().x())
new_spacepoint['pos'].append(spacepoint.get_global_position().y())
new_spacepoint['pos'].append(spacepoint.get_global_position().z())
paired_hits.append((new_spacepoint, virtual_hit))
data_dict['counters']['found_pairs'] += 1
found_up = 0
found_down = 0
for scifi_hit, virt_hit in paired_hits :
if scifi_hit['id'] < 0 :
found_up += 1
else :
found_down += 1
data_dict['counters']['found_tracks_up'] += found_up
data_dict['counters']['found_tracks_down'] += found_down
return paired_hits
def create_virtual_plane_dict(file_reader, virtual_plane_dict) :
"""
Matches up scifitrackpoints to virtual planes to make a lookup dictionary
"""
# virtual_plane_dict = {}
for num in range( -15, 0, 1 ) :
virtual_plane_dict[ num ] = ( -1, (ALIGNMENT_TOLERANCE * 100.0) )
for num in range( 1, 16, 1 ) :
virtual_plane_dict[ num ] = ( -1, (ALIGNMENT_TOLERANCE * 100.0) )
while file_reader.next_event() :
scifi_event = file_reader.get_event( 'scifi' )
mc_event = file_reader.get_event( 'mc' )
tracks = scifi_event.scifitracks()
for track in tracks :
trackpoints = track.scifitrackpoints()
for trkpt in trackpoints :
z_pos = trkpt.pos().z()
plane_id = tools.calculate_plane_id(trkpt.tracker(), trkpt.station(), \
trkpt.plane() )
for vhit_num in xrange(mc_event.GetVirtualHitsSize()) :
vhit = mc_event.GetAVirtualHit(vhit_num)
diff = math.fabs(vhit.GetPosition().z() - z_pos)
if diff < virtual_plane_dict[ plane_id ][1] :
virtual_plane_dict[ plane_id ] = ( vhit.GetStationId(), diff )
# print plane_id, vhit.GetStationId(), diff
done = True
num_found = 0
for plane in virtual_plane_dict :
if virtual_plane_dict[plane][1] > ALIGNMENT_TOLERANCE :
# print plane, virtual_plane_dict[plane]
done = False
else :
num_found += 1
sys.stdout.write( "- Finding Virtual Planes : Running ({0} of {1})\r".format(num_found, 30) )
sys.stdout.flush()
if done :
break
else :
if REQUIRE_ALL_VIRTUALS :
raise ValueError("Could not locate all virtuals planes")
file_reader.reset()
return virtual_plane_dict
def cut_scifi_event( plot_dict, event ) :
"""
Examine a SciFi Event to see if it should be vetoed
"""
digits = event.digits()
tracks = event.scifitracks()
saturation_counter = 0
for digit in digits :
if digit.get_adc() == 255 :
saturation_counter += 1
if saturation_counter > 1000 :
return True
upstream_tracks = 0
downstream_tracks = 0
for track in tracks :
if track.P_value() < P_VALUE_CUT :
return True
if track.tracker() == 0 :
upstream_tracks += 1
else :
downstream_tracks += 1
trackpoints = track.scifitrackpoints()
count_trackpoints = 0
for tp in trackpoints :
if tp.has_data() :
count_trackpoints += 1
elif tools.calculate_plane_id( tp.tracker(), tp.station(), tp.plane()) \
in IGNORE_PLANES :
count_trackpoints += 1
if count_trackpoints < MIN_NUM_TRACKPOINTS :
return True
if (upstream_tracks != 1) or (downstream_tracks != 1) :
return True
return False
def cut_scifi_event(plot_dict, event):
"""
Examine a SciFi Event to see if it should be vetoed
"""
digits = event.digits()
tracks = event.scifitracks()
saturation_counter = 0
for digit in digits:
if digit.get_adc() == 255:
saturation_counter += 1
if saturation_counter > 1000:
return True
upstream_tracks = 0
downstream_tracks = 0
for track in tracks:
if track.P_value() < P_VALUE_CUT:
return True
if track.tracker() == 0:
upstream_tracks += 1
else:
downstream_tracks += 1
trackpoints = track.scifitrackpoints()
count_trackpoints = 0
for tp in trackpoints:
if tp.has_data():
count_trackpoints += 1
elif tools.calculate_plane_id( tp.tracker(), tp.station(), tp.plane()) \
in IGNORE_PLANES :
count_trackpoints += 1
if count_trackpoints < MIN_NUM_TRACKPOINTS:
return True
if (upstream_tracks != 1) or (downstream_tracks != 1):
return True
return False
def fill_plots_tracks(plot_dict, data_dict, tracks) :
"""
Fill the track specific plots
"""
track_plots = plot_dict['track_plots']
reco_plots = plot_dict['recon_plots']
# comp_plots = plot_dict['comparison_plots']
track_plots['tracks_event'].Fill( len(tracks) )
upstream_good = 0
downstream_good = 0
straight_counter = 0
helical_counter = 0
for track in tracks :
trackpoints = track.scifitrackpoints()
if track.P_value() < P_VALUE_CUT :
continue
count_trackpoints = 0
for tp in trackpoints :
if tp.has_data() :
count_trackpoints += 1
elif tools.calculate_plane_id( tp.tracker(), tp.station(), tp.plane()) \
in IGNORE_PLANES :
count_trackpoints += 1
if count_trackpoints < MIN_NUM_TRACKPOINTS :
continue
tracker = track.tracker()
track_plots['tracks_tracker'].Fill( track.tracker() )
shape = track.GetAlgorithmUsed()
shape_plots = None
# pr_track = None
if shape == 0 :
shape_plots = track_plots['straight']
# pr_track = track.pr_track_pointer_straight()
straight_counter += 1
elif shape == 1 :
shape_plots = track_plots['helical']
# pr_track = track.pr_track_pointer_helical()
helical_counter += 1
data_dict['counters']['N_tracks'] += 1
shape_plots['tracks_tracker'].Fill( track.tracker() )
shape_plots['chi_squared'].Fill( track.chi2() )
shape_plots['chi_squared_ndf'].Fill( track.chi2() / track.ndf() )
shape_plots['p_value'].Fill( track.P_value() )
shape_plots['ndf'].Fill( track.ndf() )
if tracker == 0 :
shape_plots['chi_squared_up'].Fill( track.chi2() )
shape_plots['chi_squared_ndf_up'].Fill( track.chi2() / track.ndf() )
shape_plots['p_value_up'].Fill( track.P_value() )
shape_plots['ndf_up'].Fill( track.ndf() )
data_dict['counters']['N_tracks_up'] += 1
upstream_good += 1
elif tracker == 1 :
shape_plots['chi_squared_down'].Fill( track.chi2() )
shape_plots['chi_squared_ndf_down'].Fill( track.chi2() / track.ndf() )
shape_plots['p_value_down'].Fill( track.P_value() )
shape_plots['ndf_down'].Fill( track.ndf() )
data_dict['counters']['N_tracks_down'] += 1
downstream_good += 1
# pr_track = None
# if track.GetAlgorithmUsed() == 0 :
# pr_track = track.pr_track_pointer_straight()
# elif track.GetAlgorithmUsed() == 1 :
# pr_track = track.pr_track_pointer_helical()
for tp in trackpoints :
station = tp.station()
plane = tp.plane()
dir_name = str(tracker) + "." + str(station) + "." + str(plane)
plane_plots = plot_dict['plane_plots']
plane_id = ( 1 + plane + ( station - 1) * 3 ) * \
( -1.0 if tracker == 0 else 1.0 )
reco_plots['plane_hits'].Fill( plane_id )
if tp.has_data() :
pull = tp.pull()
residual = tp.residual()
s_residual = tp.smoothed_residual()
shape_plots['plane_pulls'].Fill( plane_id, pull )
shape_plots['plane_residuals'].Fill( plane_id, residual )
shape_plots['plane_s_residuals'].Fill( plane_id, s_residual )
plane_plots[dir_name]['pull'].Fill( pull )
plane_plots[dir_name]['s_residual'].Fill( s_residual )
pos = tp.pos()
mom = tp.mom()
plane_plots[dir_name]['xy'].Fill( pos.x(), pos.y() )
plane_plots[dir_name]['pxpy'].Fill( mom.x(), mom.y() )
plane_plots[dir_name]['xpx'].Fill( pos.x(), mom.x() )
plane_plots[dir_name]['ypy'].Fill( pos.y(), mom.y() )
plane_plots[dir_name]['mxmy'].Fill( mom.x() / mom.z(), mom.y() / mom.z() )
plane_plots[dir_name]['xmx'].Fill( pos.x(), mom.x() / mom.z() )
plane_plots[dir_name]['ymy'].Fill( pos.y(), mom.y() / mom.z() )
# if station == REFERENCE_STATION and plane == REFERENCE_PLANE :
# prefix = ""
# if tracker == 0 :
# prefix = 'up_'
# elif tracker == 1 :
# prefix = 'down_'
# pr_pos = pr_track.get_reference_position()
# pr_mom = pr_track.get_reference_momentum()
#
# diff_pos = [ pos.x() - pr_pos.x(), pos.y() - pr_pos.y() ]
# diff_mom = [ mom.x() - pr_mom.x(), mom.y() - pr_mom.y() ]
#
# comp_plots[prefix+'patrec_kalman_xy'].Fill( \
# diff_pos[0], diff_pos[1] )
# comp_plots[prefix+'patrec_kalman_mxmy'].Fill( \
# diff_mom[0] / mom.z(), diff_mom[1] / mom.z() )
# comp_plots[prefix+'patrec_kalman_pxpy'].Fill( \
# diff_mom[0], diff_mom[1] )
if upstream_good == 1 and downstream_good == 1 :
data_dict['counters']['N_track_pairs'] += 1
track_plots['trackpoints_track'].Fill( count_trackpoints )
shape_plots['trackpoints_track'].Fill( count_trackpoints )
track_plots['straight']['tracks_event'].Fill(straight_counter)
track_plots['helical']['tracks_event'].Fill(helical_counter)
def make_patrec_mc_pairs(plot_dict, data_dict, virtual_plane_dict, \
scif_event, mc_event) :
"""
Make pairs of Pattern Recognition Tracks and MC VirtualHits
"""
paired_hits = []
if TRACK_ALGORITHM == 0:
tracks = scifi_event.straightprtracks()
elif TRACK_ALGORITHM == 1:
tracks = scifi_event.helicalprtracks()
# Find a reference spacepoint
for track in tracks:
pl_id = tools.calculate_plane_id(track.get_tracker(), 1,
0) # Only examine ref plane atm
expected_virtual_plane = virtual_plane_dict[pl_id][0]
# Find the virtual hit
for vhit_num in xrange(mc_event.GetVirtualHitsSize()):
vhit = mc_event.GetAVirtualHit(vhit_num)
if vhit.GetStationId() == expected_virtual_plane and \
abs(vhit.GetParticleId()) == MUON_PID :
virtual_hit = vhit
break
else:
data_dict['counters']['missing_virtual_hits'] += 1
continue
# Add to list
new_pr_point = { 'pos' : [], 'mom' : [], 'grad' : [], 'id' : pl_id, 'pull' : 0.0, \
'pos_err' : [-1.0, -1.0, -1.0], 'mom_err' : [-1.0, -1.0, -1.0], grad_err : [-1.0, -1.0] }
new_pr_point['pos'].append(track.get_reference_position().x())
new_pr_point['pos'].append(track.get_reference_position().y())
new_pr_point['pos'].append(track.get_reference_position().z())
new_pr_point['mom'].append(track.get_reference_momentum().x())
new_pr_point['mom'].append(track.get_reference_momentum().y())
new_pr_point['mom'].append(track.get_reference_momentum().z())
new_pr_point['grad'].append(track.get_reference_momentum().x() /
track.get_reference_momentum.z())
new_pr_point['grad'].append(track.get_reference_momentum().y() /
track.get_reference_momentum.z())
paired_hits.append((new_pr_point, virtual_hit))
data_dict['counters']['found_pairs'] += 1
if track.get_tracker() == 0:
plot_dict['statistics']['up_p_value'].Fill(
ROOT.TMath.Prob(track.get_chi_squared(), track.get_ndf()))
plot_dict['statistics']['up_chi_sq'].Fill(track.get_chi_squared())
plot_dict['statistics']['up_chi_sq_df'].Fill(
track.get_chi_squared() / track.get_ndf())
plot_dict['statistics']['up_ndf'].Fill(track.get_ndf())
else:
plot_dict['statistics']['down_p_value'].Fill(
ROOT.TMath.Prob(track.get_chi_squared(), track.get_ndf()))
plot_dict['statistics']['down_chi_sq'].Fill(
track.get_chi_squared())
plot_dict['statistics']['down_chi_sq_df'].Fill(
track.get_chi_squared() / track.get_ndf())
plot_dict['statistics']['down_ndf'].Fill(track.get_ndf())
found_up = 0
found_down = 0
for scifi_hit, virt_hit in paired_hits:
if scifi_hit['id'] < 0:
found_up += 1
else:
found_down += 1
data_dict['counters']['found_tracks_up'] += found_up
data_dict['counters']['found_tracks_down'] += found_down
return paired_hits
def make_scifi_mc_pairs(plot_dict, data_dict, virtual_plane_dict, \
scif_event, mc_event) :
"""
Make pairs of SciFiTrackpoints and MC VirtualHits
"""
paired_hits = []
tracks = scifi_event.scifitracks()
for track in tracks:
if track.GetAlgorithmUsed() != TRACK_ALGORITHM:
continue
if track.tracker() == 0:
plot_dict['statistics']['up_p_value'].Fill(track.P_value())
plot_dict['statistics']['up_chi_sq'].Fill(track.chi2())
plot_dict['statistics']['up_chi_sq_df'].Fill(track.chi2() /
track.ndf())
plot_dict['statistics']['up_ndf'].Fill(track.ndf())
else:
plot_dict['statistics']['down_p_value'].Fill(track.P_value())
plot_dict['statistics']['down_chi_sq'].Fill(track.chi2())
plot_dict['statistics']['down_chi_sq_df'].Fill(track.chi2() /
track.ndf())
plot_dict['statistics']['down_ndf'].Fill(track.ndf())
trackpoints = track.scifitrackpoints()
trackpoint = None
# Find a reference trackpoint
for trackpoint in trackpoints:
if trackpoint.station() == REFERENCE_STATION and trackpoint.plane(
) == REFERENCE_PLANE:
pt = math.sqrt(trackpoint.mom().x()**2 +
trackpoint.mom().y()**2)
pz = trackpoint.mom().z()
if track.tracker() == 0:
plot_dict['statistics']['up_p_value_pt'].Fill(
track.P_value(), pt)
plot_dict['statistics']['up_p_value_pz'].Fill(
track.P_value(), math.fabs(pz))
else:
plot_dict['statistics']['down_p_value_pt'].Fill(
track.P_value(), pt)
plot_dict['statistics']['down_p_value_pz'].Fill(
track.P_value(), math.fabs(pz))
# If no data then give up!
if REQUIRE_DATA and not trackpoint.has_data():
data_dict['counters']['missing_reference_hits'] += 1
continue
expected_virtual_plane = virtual_plane_dict[tools.calculate_plane_id( \
trackpoint.tracker(), trackpoint.station(), trackpoint.plane())][0]
# Find the virtual hit
for vhit_num in xrange(mc_event.GetVirtualHitsSize()):
vhit = mc_event.GetAVirtualHit(vhit_num)
if vhit.GetStationId() == expected_virtual_plane and \
abs(vhit.GetParticleId()) == MUON_PID :
virtual_hit = vhit
break
else:
data_dict['counters']['missing_virtual_hits'] += 1
continue
momentum = math.sqrt(vhit.GetMomentum().x()**2 +
vhit.GetMomentum().y()**2 +
vhit.GetMomentum().z()**2)
if momentum < MOMENTUM_WINDOW[0] or momentum > MOMENTUM_WINDOW[1]:
continue
# Add to list
pl_id = tools.calculate_plane_id(trackpoint.tracker(),
trackpoint.station(),
trackpoint.plane())
if trackpoint.has_data():
new_trackpoint = {
'pos': [],
'mom': [],
'grad': [],
'id': pl_id,
'pull': trackpoint.pull(),
'pos_err': [],
'mom_err': [],
'grad_err': []
}
else:
new_trackpoint = {
'pos': [],
'mom': [],
'grad': [],
'id': pl_id,
'pull': None,
'pos_err': [],
'mom_err': [],
'grad_err': []
}
new_trackpoint['pos'].append(trackpoint.pos().x())
new_trackpoint['pos'].append(trackpoint.pos().y())
new_trackpoint['pos'].append(trackpoint.pos().z())
new_trackpoint['mom'].append(trackpoint.mom().x())
new_trackpoint['mom'].append(trackpoint.mom().y())
new_trackpoint['mom'].append(trackpoint.mom().z())
new_trackpoint['grad'].append(trackpoint.gradient().x())
new_trackpoint['grad'].append(trackpoint.gradient().y())
new_trackpoint['pos_err'].append(trackpoint.pos_error().x())
new_trackpoint['pos_err'].append(trackpoint.pos_error().y())
new_trackpoint['pos_err'].append(trackpoint.pos_error().z())
new_trackpoint['mom_err'].append(trackpoint.mom_error().x())
new_trackpoint['mom_err'].append(trackpoint.mom_error().y())
new_trackpoint['mom_err'].append(trackpoint.mom_error().z())
new_trackpoint['grad_err'].append(trackpoint.gradient_error().x())
new_trackpoint['grad_err'].append(trackpoint.gradient_error().y())
paired_hits.append((new_trackpoint, virtual_hit))
data_dict['counters']['found_pairs'] += 1
found_up = 0
found_down = 0
for scifi_hit, virt_hit in paired_hits:
# if scifi_hit.tracker() == 0 :
if new_trackpoint['id'] < 0:
found_up += 1
else:
found_down += 1
for track in tracks:
if track.GetAlgorithmUsed() != TRACK_ALGORITHM:
continue
data_dict['counters']['found_tracks_up'] += found_up
data_dict['counters']['found_tracks_down'] += found_down
return paired_hits
def __init__( self, x = 0.0, y = 0.0, z = 0.0, \
px = 0.0, py = 0.0, pz = 0.0, station = 0, \
time = 0.0, mass = 105.6583715, p_value = 1.0, pid = 13, \
weight = 1.0, \
scifi_track_point = None, virtual_track_point = None ) :
"""
Initialise the object. this can be done in three ways:
1. Specify all components by hand
2. Build from a sci-fr trackpoint
3. Build from a virtual trackpoint
"""
if scifi_track_point is None and virtual_track_point is None:
self.__x = x
self.__y = y
self.__z = z
self.__px = px
self.__py = py
self.__pz = pz
self.__time = time
self.__mass = mass
self.__p_value = p_value
self.__pid = pid
self.__station = station
self.__weight = weight
# self.__reference = reference
elif scifi_track_point is not None and virtual_track_point is None:
self.__x = scifi_track_point.pos().x()
self.__y = scifi_track_point.pos().y()
self.__z = scifi_track_point.pos().z()
self.__px = scifi_track_point.mom().x()
self.__py = scifi_track_point.mom().y()
self.__pz = scifi_track_point.mom().z()
self.__time = time
self.__mass = mass
self.__p_value = p_value
self.__pid = pid
self.__station = tools.calculate_plane_id(scifi_track_point.tracker(), \
scifi_track_point.station(), scifi_track_point.plane())
self.__weight = weight
# if reference is None :
# self.__reference = str(scifi_track_point.tracker())+"."+\
# str(scifi_track_point.station())+"."+str(scifi_track_point.plane())
# else :
# self.__reference = reference
elif scifi_track_point is None and virtual_track_point is not None:
self.__x = virtual_track_point.GetPosition().x()
self.__y = virtual_track_point.GetPosition().y()
self.__z = virtual_track_point.GetPosition().z()
self.__px = virtual_track_point.GetMomentum().x()
self.__py = virtual_track_point.GetMomentum().y()
self.__pz = virtual_track_point.GetMomentum().z()
self.__time = virtual_track_point.GetTime()
self.__mass = mass
self.__p_value = 1.0
self.__pid = virtual_track_point.GetParticleId()
self.__station = virtual_track_point.GetStationId()
self.__weight = weight
# self.__reference = reference
# if reference is None :
# self.__reference = virtual_track_point.GetStationId()
# else :
# self.__reference = reference
else:
print "WTF!"
raise ValueError( 'Please supply precisely one of "virtual_track_point"'+\
' or "scifi_track_point", or specify all values explicitly.' )
# if math.isnan(self.__x) or math.isnan(self.__px) or math.isnan(self.__y) or math.isnan(self.__py) :
if math.isnan(self.__x) or math.isnan(self.__px) or math.isinf(
self.__x) or math.isinf(self.__px):
raise ValueError("NaN Values Received from Scifi Track Point")
def fill_plots_tracks(plot_dict, data_dict, tracks):
"""
Fill the track specific plots
"""
track_plots = plot_dict['track_plots']
reco_plots = plot_dict['recon_plots']
# comp_plots = plot_dict['comparison_plots']
track_plots['tracks_event'].Fill(len(tracks))
upstream_good = 0
downstream_good = 0
straight_counter = 0
helical_counter = 0
for track in tracks:
trackpoints = track.scifitrackpoints()
if track.P_value() < P_VALUE_CUT:
continue
count_trackpoints = 0
for tp in trackpoints:
if tp.has_data():
count_trackpoints += 1
elif tools.calculate_plane_id( tp.tracker(), tp.station(), tp.plane()) \
in IGNORE_PLANES :
count_trackpoints += 1
if count_trackpoints < MIN_NUM_TRACKPOINTS:
continue
tracker = track.tracker()
track_plots['tracks_tracker'].Fill(track.tracker())
shape = track.GetAlgorithmUsed()
shape_plots = None
# pr_track = None
if shape == 0:
shape_plots = track_plots['straight']
# pr_track = track.pr_track_pointer_straight()
straight_counter += 1
elif shape == 1:
shape_plots = track_plots['helical']
# pr_track = track.pr_track_pointer_helical()
helical_counter += 1
data_dict['counters']['N_tracks'] += 1
shape_plots['tracks_tracker'].Fill(track.tracker())
shape_plots['chi_squared'].Fill(track.chi2())
shape_plots['chi_squared_ndf'].Fill(track.chi2() / track.ndf())
shape_plots['p_value'].Fill(track.P_value())
shape_plots['ndf'].Fill(track.ndf())
if tracker == 0:
shape_plots['chi_squared_up'].Fill(track.chi2())
shape_plots['chi_squared_ndf_up'].Fill(track.chi2() / track.ndf())
shape_plots['p_value_up'].Fill(track.P_value())
shape_plots['ndf_up'].Fill(track.ndf())
data_dict['counters']['N_tracks_up'] += 1
upstream_good += 1
elif tracker == 1:
shape_plots['chi_squared_down'].Fill(track.chi2())
shape_plots['chi_squared_ndf_down'].Fill(track.chi2() /
track.ndf())
shape_plots['p_value_down'].Fill(track.P_value())
shape_plots['ndf_down'].Fill(track.ndf())
data_dict['counters']['N_tracks_down'] += 1
downstream_good += 1
# pr_track = None
# if track.GetAlgorithmUsed() == 0 :
# pr_track = track.pr_track_pointer_straight()
# elif track.GetAlgorithmUsed() == 1 :
# pr_track = track.pr_track_pointer_helical()
for tp in trackpoints:
station = tp.station()
plane = tp.plane()
dir_name = str(tracker) + "." + str(station) + "." + str(plane)
plane_plots = plot_dict['plane_plots']
plane_id = ( 1 + plane + ( station - 1) * 3 ) * \
( -1.0 if tracker == 0 else 1.0 )
reco_plots['plane_hits'].Fill(plane_id)
if tp.has_data():
pull = tp.pull()
residual = tp.residual()
s_residual = tp.smoothed_residual()
shape_plots['plane_pulls'].Fill(plane_id, pull)
shape_plots['plane_residuals'].Fill(plane_id, residual)
shape_plots['plane_s_residuals'].Fill(plane_id, s_residual)
plane_plots[dir_name]['pull'].Fill(pull)
plane_plots[dir_name]['s_residual'].Fill(s_residual)
pos = tp.pos()
mom = tp.mom()
plane_plots[dir_name]['xy'].Fill(pos.x(), pos.y())
plane_plots[dir_name]['pxpy'].Fill(mom.x(), mom.y())
plane_plots[dir_name]['xpx'].Fill(pos.x(), mom.x())
plane_plots[dir_name]['ypy'].Fill(pos.y(), mom.y())
plane_plots[dir_name]['mxmy'].Fill(mom.x() / mom.z(),
mom.y() / mom.z())
plane_plots[dir_name]['xmx'].Fill(pos.x(), mom.x() / mom.z())
plane_plots[dir_name]['ymy'].Fill(pos.y(), mom.y() / mom.z())
# if station == REFERENCE_STATION and plane == REFERENCE_PLANE :
# prefix = ""
# if tracker == 0 :
# prefix = 'up_'
# elif tracker == 1 :
# prefix = 'down_'
# pr_pos = pr_track.get_reference_position()
# pr_mom = pr_track.get_reference_momentum()
#
# diff_pos = [ pos.x() - pr_pos.x(), pos.y() - pr_pos.y() ]
# diff_mom = [ mom.x() - pr_mom.x(), mom.y() - pr_mom.y() ]
#
# comp_plots[prefix+'patrec_kalman_xy'].Fill( \
# diff_pos[0], diff_pos[1] )
# comp_plots[prefix+'patrec_kalman_mxmy'].Fill( \
# diff_mom[0] / mom.z(), diff_mom[1] / mom.z() )
# comp_plots[prefix+'patrec_kalman_pxpy'].Fill( \
# diff_mom[0], diff_mom[1] )
if upstream_good == 1 and downstream_good == 1:
data_dict['counters']['N_track_pairs'] += 1
track_plots['trackpoints_track'].Fill(count_trackpoints)
shape_plots['trackpoints_track'].Fill(count_trackpoints)
track_plots['straight']['tracks_event'].Fill(straight_counter)
track_plots['helical']['tracks_event'].Fill(helical_counter)
def make_patrec_mc_pairs(plot_dict, data_dict, virtual_plane_dict, \
scif_event, mc_event) :
"""
Make pairs of Pattern Recognition Tracks and MC VirtualHits
"""
paired_hits = []
if TRACK_ALGORITHM == 0 :
tracks = scifi_event.straightprtracks()
elif TRACK_ALGORITHM == 1 :
tracks = scifi_event.helicalprtracks()
# Find a reference spacepoint
for track in tracks :
pl_id = tools.calculate_plane_id(track.get_tracker(), 1, 0) # Only examine ref plane atm
expected_virtual_plane = virtual_plane_dict[pl_id][0]
# Find the virtual hit
for vhit_num in xrange(mc_event.GetVirtualHitsSize()) :
vhit = mc_event.GetAVirtualHit(vhit_num)
if vhit.GetStationId() == expected_virtual_plane and \
abs(vhit.GetParticleId()) == MUON_PID :
virtual_hit = vhit
break
else :
data_dict['counters']['missing_virtual_hits'] += 1
continue
# Add to list
new_pr_point = { 'pos' : [], 'mom' : [], 'grad' : [], 'id' : pl_id, 'pull' : 0.0, \
'pos_err' : [-1.0, -1.0, -1.0], 'mom_err' : [-1.0, -1.0, -1.0], grad_err : [-1.0, -1.0] }
new_pr_point['pos'].append(track.get_reference_position().x())
new_pr_point['pos'].append(track.get_reference_position().y())
new_pr_point['pos'].append(track.get_reference_position().z())
new_pr_point['mom'].append(track.get_reference_momentum().x())
new_pr_point['mom'].append(track.get_reference_momentum().y())
new_pr_point['mom'].append(track.get_reference_momentum().z())
new_pr_point['grad'].append(track.get_reference_momentum().x()/track.get_reference_momentum.z())
new_pr_point['grad'].append(track.get_reference_momentum().y()/track.get_reference_momentum.z())
paired_hits.append((new_pr_point, virtual_hit))
data_dict['counters']['found_pairs'] += 1
if track.get_tracker() == 0 :
plot_dict['statistics']['up_p_value'].Fill(ROOT.TMath.Prob(track.get_chi_squared(), track.get_ndf()))
plot_dict['statistics']['up_chi_sq'].Fill(track.get_chi_squared())
plot_dict['statistics']['up_chi_sq_df'].Fill(track.get_chi_squared()/track.get_ndf())
plot_dict['statistics']['up_ndf'].Fill(track.get_ndf())
else :
plot_dict['statistics']['down_p_value'].Fill(ROOT.TMath.Prob(track.get_chi_squared(), track.get_ndf()))
plot_dict['statistics']['down_chi_sq'].Fill(track.get_chi_squared())
plot_dict['statistics']['down_chi_sq_df'].Fill(track.get_chi_squared()/track.get_ndf())
plot_dict['statistics']['down_ndf'].Fill(track.get_ndf())
found_up = 0
found_down = 0
for scifi_hit, virt_hit in paired_hits :
if scifi_hit['id'] < 0 :
found_up += 1
else :
found_down += 1
data_dict['counters']['found_tracks_up'] += found_up
data_dict['counters']['found_tracks_down'] += found_down
return paired_hits
def make_scifi_mc_pairs(plot_dict, data_dict, virtual_plane_dict, \
scif_event, mc_event) :
"""
Make pairs of SciFiTrackpoints and MC VirtualHits
"""
paired_hits = []
tracks = scifi_event.scifitracks()
for track in tracks :
if track.GetAlgorithmUsed() != TRACK_ALGORITHM :
continue
if track.tracker() == 0 :
plot_dict['statistics']['up_p_value'].Fill(track.P_value())
plot_dict['statistics']['up_chi_sq'].Fill(track.chi2())
plot_dict['statistics']['up_chi_sq_df'].Fill(track.chi2()/track.ndf())
plot_dict['statistics']['up_ndf'].Fill(track.ndf())
else :
plot_dict['statistics']['down_p_value'].Fill(track.P_value())
plot_dict['statistics']['down_chi_sq'].Fill(track.chi2())
plot_dict['statistics']['down_chi_sq_df'].Fill(track.chi2()/track.ndf())
plot_dict['statistics']['down_ndf'].Fill(track.ndf())
trackpoints = track.scifitrackpoints()
trackpoint = None
# Find a reference trackpoint
for trackpoint in trackpoints :
if trackpoint.station() == REFERENCE_STATION and trackpoint.plane() == REFERENCE_PLANE :
pt = math.sqrt( trackpoint.mom().x()**2 + trackpoint.mom().y()**2 )
pz = trackpoint.mom().z()
if track.tracker() == 0 :
plot_dict['statistics']['up_p_value_pt'].Fill(track.P_value(), pt)
plot_dict['statistics']['up_p_value_pz'].Fill(track.P_value(), math.fabs(pz))
else :
plot_dict['statistics']['down_p_value_pt'].Fill(track.P_value(), pt)
plot_dict['statistics']['down_p_value_pz'].Fill(track.P_value(), math.fabs(pz))
# If no data then give up!
if REQUIRE_DATA and not trackpoint.has_data() :
data_dict['counters']['missing_reference_hits'] += 1
continue
expected_virtual_plane = virtual_plane_dict[tools.calculate_plane_id( \
trackpoint.tracker(), trackpoint.station(), trackpoint.plane())][0]
# Find the virtual hit
for vhit_num in xrange(mc_event.GetVirtualHitsSize()) :
vhit = mc_event.GetAVirtualHit(vhit_num)
if vhit.GetStationId() == expected_virtual_plane and \
abs(vhit.GetParticleId()) == MUON_PID :
virtual_hit = vhit
break
else :
data_dict['counters']['missing_virtual_hits'] += 1
continue
momentum = math.sqrt( vhit.GetMomentum().x()**2 + vhit.GetMomentum().y()**2 + vhit.GetMomentum().z()**2 )
if momentum < MOMENTUM_WINDOW[0] or momentum > MOMENTUM_WINDOW[1] :
continue
# Add to list
pl_id = tools.calculate_plane_id( trackpoint.tracker(), trackpoint.station(), trackpoint.plane() )
if trackpoint.has_data() :
new_trackpoint = { 'pos' : [], 'mom' : [], 'grad': [], 'id' : pl_id, 'pull' : trackpoint.pull(), 'pos_err' : [], 'mom_err' : [], 'grad_err' : [] }
else :
new_trackpoint = { 'pos' : [], 'mom' : [], 'grad': [], 'id' : pl_id, 'pull' : None, 'pos_err' : [], 'mom_err' : [], 'grad_err' : [] }
new_trackpoint['pos'].append(trackpoint.pos().x())
new_trackpoint['pos'].append(trackpoint.pos().y())
new_trackpoint['pos'].append(trackpoint.pos().z())
new_trackpoint['mom'].append(trackpoint.mom().x())
new_trackpoint['mom'].append(trackpoint.mom().y())
new_trackpoint['mom'].append(trackpoint.mom().z())
new_trackpoint['grad'].append(trackpoint.gradient().x())
new_trackpoint['grad'].append(trackpoint.gradient().y())
new_trackpoint['pos_err'].append(trackpoint.pos_error().x())
new_trackpoint['pos_err'].append(trackpoint.pos_error().y())
new_trackpoint['pos_err'].append(trackpoint.pos_error().z())
new_trackpoint['mom_err'].append(trackpoint.mom_error().x())
new_trackpoint['mom_err'].append(trackpoint.mom_error().y())
new_trackpoint['mom_err'].append(trackpoint.mom_error().z())
new_trackpoint['grad_err'].append(trackpoint.gradient_error().x())
new_trackpoint['grad_err'].append(trackpoint.gradient_error().y())
paired_hits.append((new_trackpoint, virtual_hit))
data_dict['counters']['found_pairs'] += 1
found_up = 0
found_down = 0
for scifi_hit, virt_hit in paired_hits :
# if scifi_hit.tracker() == 0 :
if new_trackpoint['id'] < 0 :
found_up += 1
else :
found_down += 1
for track in tracks :
if track.GetAlgorithmUsed() != TRACK_ALGORITHM :
continue
data_dict['counters']['found_tracks_up'] += found_up
data_dict['counters']['found_tracks_down'] += found_down
return paired_hits
def __init__( self, x = 0.0, y = 0.0, z = 0.0, \
px = 0.0, py = 0.0, pz = 0.0, station = 0, \
time = 0.0, mass = 105.6583715, p_value = 1.0, pid = 13, \
weight = 1.0, \
scifi_track_point = None, virtual_track_point = None ) :
"""
Initialise the object. this can be done in three ways:
1. Specify all components by hand
2. Build from a sci-fr trackpoint
3. Build from a virtual trackpoint
"""
if scifi_track_point is None and virtual_track_point is None :
self.__x = x
self.__y = y
self.__z = z
self.__px = px
self.__py = py
self.__pz = pz
self.__time = time
self.__mass = mass
self.__p_value = p_value
self.__pid = pid
self.__station = station
self.__weight = weight
# self.__reference = reference
elif scifi_track_point is not None and virtual_track_point is None :
self.__x = scifi_track_point.pos().x()
self.__y = scifi_track_point.pos().y()
self.__z = scifi_track_point.pos().z()
self.__px = scifi_track_point.mom().x()
self.__py = scifi_track_point.mom().y()
self.__pz = scifi_track_point.mom().z()
self.__time = time
self.__mass = mass
self.__p_value = p_value
self.__pid = pid
self.__station = tools.calculate_plane_id(scifi_track_point.tracker(), \
scifi_track_point.station(), scifi_track_point.plane())
self.__weight = weight
# if reference is None :
# self.__reference = str(scifi_track_point.tracker())+"."+\
# str(scifi_track_point.station())+"."+str(scifi_track_point.plane())
# else :
# self.__reference = reference
elif scifi_track_point is None and virtual_track_point is not None :
self.__x = virtual_track_point.GetPosition().x()
self.__y = virtual_track_point.GetPosition().y()
self.__z = virtual_track_point.GetPosition().z()
self.__px = virtual_track_point.GetMomentum().x()
self.__py = virtual_track_point.GetMomentum().y()
self.__pz = virtual_track_point.GetMomentum().z()
self.__time = virtual_track_point.GetTime()
self.__mass = mass
self.__p_value = 1.0
self.__pid = virtual_track_point.GetParticleId()
self.__station = virtual_track_point.GetStationId()
self.__weight = weight
# self.__reference = reference
# if reference is None :
# self.__reference = virtual_track_point.GetStationId()
# else :
# self.__reference = reference
else :
print "WTF!"
raise ValueError( 'Please supply precisely one of "virtual_track_point"'+\
' or "scifi_track_point", or specify all values explicitly.' )
# if math.isnan(self.__x) or math.isnan(self.__px) or math.isnan(self.__y) or math.isnan(self.__py) :
if math.isnan(self.__x) or math.isnan(self.__px) or math.isinf(self.__x) or math.isinf(self.__px) :
raise ValueError("NaN Values Received from Scifi Track Point")