Belle II Software prerelease-10-00-00a
Public Member Functions | Public Attributes | List of all members
SVDGroupingPerformance Class Reference
Inheritance diagram for SVDGroupingPerformance:
Inheritance graph
[legend]
Collaboration diagram for SVDGroupingPerformance:
Collaboration graph
[legend]

Public Member Functions

 initialize (self)
 
 event (self)
 
 terminate (self)
 

Public Attributes

dict TH1F_Index = {}
 dictionary of TH1F indices
 
list TH1F_Store = []
 list of TH1F histograms
 
dict TH2F_Index = {}
 dictionary of TH2F indices
 
list TH2F_Store = []
 list of TH2F histograms
 
dict reso_TH2D_Histogram_Index = {}
 dictionary of TH2D indices
 
list reso_TH2D_Histograms = []
 list of TH2D histograms
 
 outputFileName = str(args.fileDir) + str(args.moduleName) + outputFileTag
 output file name
 
 f = TFile(self.outputFileName + ".root", "RECREATE")
 output file
 

Detailed Description

 check cluster grouping

Definition at line 108 of file svdGroupingPerformance.py.

Member Function Documentation

◆ event()

event ( self) 
 Event loop

Definition at line 393 of file svdGroupingPerformance.py.

393 def event(self):
394 ''' Event loop'''
395
396 EventT0 = Belle2.PyStoreObj('EventT0')
397 svdEventT0 = math.nan
398 cdcEventT0 = math.nan
399 svd = Belle2.Const.DetectorSet(Belle2.Const.SVD)
400 cdc = Belle2.Const.DetectorSet(Belle2.Const.CDC)
401 top = Belle2.Const.DetectorSet(Belle2.Const.TOP)
402 if EventT0.hasTemporaryEventT0(svd):
403 tmp = EventT0.getTemporaryEventT0s(Belle2.Const.SVD)
404 svdEventT0 = tmp.back().eventT0
405 if EventT0.hasTemporaryEventT0(cdc):
406 tmp = EventT0.getTemporaryEventT0s(Belle2.Const.CDC)
407 cdcEventT0 = tmp.back().eventT0
408
409 if not math.isnan(svdEventT0):
410 self.TH1F_Store[self.TH1F_Index["th1f_svdEventT0"]].Fill(svdEventT0)
411 self.TH1F_Store[self.TH1F_Index["th1f_svdEventT0_State"]].Fill(1)
412 else:
413 self.TH1F_Store[self.TH1F_Index["th1f_svdEventT0_State"]].Fill(0)
414 if not math.isnan(cdcEventT0):
415 self.TH1F_Store[self.TH1F_Index["th1f_cdcEventT0"]].Fill(cdcEventT0)
416 self.TH1F_Store[self.TH1F_Index["th1f_cdcEventT0_State"]].Fill(1)
417 else:
418 self.TH1F_Store[self.TH1F_Index["th1f_cdcEventT0_State"]].Fill(0)
419
420 if not math.isnan(svdEventT0) and not math.isnan(cdcEventT0):
421 self.TH2F_Store[self.TH2F_Index["th2f_svdEventT0_vs_cdcEventT0"]].Fill(svdEventT0, cdcEventT0)
422 self.TH2F_Store[self.TH2F_Index["th2f_svdEventT0_vs_cdcEventT0_rot45pos"]].Fill(
423 svdEventT0 * TMath.Cos(TMath.PiOver4()) + cdcEventT0 * TMath.Sin(TMath.PiOver4()),
424 - svdEventT0 * TMath.Sin(TMath.PiOver4()) + cdcEventT0 * TMath.Cos(TMath.PiOver4()))
425 self.TH2F_Store[self.TH2F_Index["th2f_svdEventT0_vs_cdcEventT0_rot45neg"]].Fill(
426 svdEventT0 * TMath.Cos(-TMath.PiOver4()) + cdcEventT0 * TMath.Sin(-TMath.PiOver4()),
427 - svdEventT0 * TMath.Sin(-TMath.PiOver4()) + cdcEventT0 * TMath.Cos(-TMath.PiOver4()))
428
429 OnlineEventT0 = []
430 if not args.isMC:
431 OnlineEventT0 = Belle2.PyStoreArray('OnlineEventT0s')
432 topOnlineEventT0 = math.nan
433 for evt in OnlineEventT0:
434 if evt.getOnlineEventT0Detector() == top:
435 topOnlineEventT0 = evt.getOnlineEventT0()
436
437 if not math.isnan(topOnlineEventT0) and not math.isnan(svdEventT0):
438 self.TH1F_Store[self.TH1F_Index["th1f_svdEventT0topRef"]].Fill(svdEventT0 - topOnlineEventT0)
439
440 TRGECLData = []
441 if not args.isMC:
442 TRGECLData = Belle2.PyStoreArray('TRGECLUnpackerStores')
443 eclTCEmax = 0
444 for trgHit in TRGECLData:
445 hitWin = trgHit.getHitWin()
446 if hitWin != 3 and hitWin != 4:
447 continue
448 if trgHit.getTCEnergy() > eclTCEmax:
449 eclTCEmax = trgHit.getTCEnergy()
450
451 if eclTCEmax:
452 self.TH1F_Store[self.TH1F_Index["th1f_eclTCEmax"]].Fill(eclTCEmax)
453 self.TH1F_Store[self.TH1F_Index["th1f_eclTCEmax_State"]].Fill(1)
454 if not math.isnan(topOnlineEventT0) and not math.isnan(svdEventT0):
455 self.reso_TH2D_Histograms[self.reso_TH2D_Histogram_Index["reso_eclTCEmax_vs_svdEventT0TopRef"]].Fill(
456 eclTCEmax, svdEventT0 - topOnlineEventT0)
457 else:
458 self.TH1F_Store[self.TH1F_Index["th1f_eclTCEmax_State"]].Fill(0)
459
460 # Pre Tracking
461
462 clusterList = Belle2.PyStoreArray("SVDClusters")
463 if eclTCEmax:
464 self.reso_TH2D_Histograms[self.reso_TH2D_Histogram_Index["reso_eclTCEmax_vs_totalClusters_PreTracking"]].Fill(
465 eclTCEmax, len(clusterList))
466 fillOnce = 0
467 for d in clusterList:
468 clsTime = d.getClsTime()
469
470 self.TH1F_Store[self.TH1F_Index["th1f_clsTime_PreTracking"]].Fill(clsTime)
471 if not math.isnan(cdcEventT0):
472 self.TH1F_Store[self.TH1F_Index["th1f_clsTimeCdcRef_PreTracking"]].Fill(clsTime - cdcEventT0)
473 if not math.isnan(topOnlineEventT0) and eclTCEmax:
474 self.reso_TH2D_Histograms[self.reso_TH2D_Histogram_Index["reso_eclTCEmax_vs_clsTimeTopRef_PreTracking"]].Fill(
475 eclTCEmax, clsTime - topOnlineEventT0)
476
477 groupIds = d.getTimeGroupId()
478 groupInfo = d.getTimeGroupInfo()
479
480 minId = 1000
481 par0 = -1000
482 par1 = -1000
483 par2 = -1000
484 for id in range(len(groupIds)):
485 gr = groupIds[id]
486 if gr < minId:
487 minId = gr
488 if len(groupInfo) > 0:
489 par0, par1, par2 = groupInfo[id]
490
491 if len(groupIds) == 0:
492 minId = -1
493
494 self.TH2F_Store[self.TH2F_Index["th2f_timeGr_vs_clsTime"]].Fill(clsTime, minId)
495 self.TH2F_Store[self.TH2F_Index["th2f_timeGr_vs_grAmp"]].Fill(par0, minId)
496 self.TH2F_Store[self.TH2F_Index["th2f_timeGr_vs_grCenter"]].Fill(par1, minId)
497 self.TH2F_Store[self.TH2F_Index["th2f_timeGr_vs_grWidth"]].Fill(par2, minId)
498
499 if fillOnce == minId and fillOnce < 4:
500 if not math.isnan(cdcEventT0):
501 hname = "th2f_sig" + str(fillOnce) + "GrMean_vs_cdcEventT0"
502 self.TH2F_Store[self.TH2F_Index[hname]].Fill(par1, cdcEventT0)
503 hname = "th2f_sig" + str(fillOnce) + "GrMean_vs_cdcEventT0_rot45neg"
504 self.TH2F_Store[self.TH2F_Index[hname]].Fill(
505 par1 * TMath.Cos(-TMath.PiOver4()) + cdcEventT0 * TMath.Sin(-TMath.PiOver4()),
506 - par1 * TMath.Sin(-TMath.PiOver4()) + cdcEventT0 * TMath.Cos(-TMath.PiOver4()))
507 hname = "th2f_sig" + str(fillOnce) + "GrMean_vs_cdcEventT0_rot45pos"
508 self.TH2F_Store[self.TH2F_Index[hname]].Fill(
509 par1 * TMath.Cos(TMath.PiOver4()) + cdcEventT0 * TMath.Sin(TMath.PiOver4()),
510 - par1 * TMath.Sin(TMath.PiOver4()) + cdcEventT0 * TMath.Cos(TMath.PiOver4()))
511 fillOnce += 1
512
513 if minId == 0:
514 self.TH1F_Store[self.TH1F_Index["th1f_sigClsTime_PreTracking"]].Fill(clsTime)
515 else:
516 self.TH1F_Store[self.TH1F_Index["th1f_bkgClsTime_PreTracking"]].Fill(clsTime)
517
518 # Post Tracking
519
520 recoTrackList = Belle2.PyStoreArray('RecoTracks')
521 nTracks = len(recoTrackList)
522 nClusters = 0
523 for recoTrk in recoTrackList:
524 if not recoTrk.wasFitSuccessful():
525 nTracks -= 1
526 continue
527
528 trackList = recoTrk.getRelationsFrom('Tracks')
529 if len(trackList) == 0:
530 nTracks -= 1
531 continue
532 trkTime0 = trackList[0].getTrackTime()
533
534 self.TH1F_Store[self.TH1F_Index["th1f_trackTime"]].Fill(trkTime0)
535 if not math.isnan(cdcEventT0):
536 self.TH1F_Store[self.TH1F_Index["th1f_trackTimeCDCRef"]].Fill(trkTime0 - cdcEventT0)
537
538 clusterList = recoTrk.getRelationsFrom("SVDClusters")
539 nClusters += len(clusterList)
540 if len(clusterList) == 0:
541 continue
542
543 trkTime = 0
544 for d in clusterList:
545 trkTime += d.getClsTime()
546 trkTime /= len(clusterList)
547
548 for d in clusterList:
549 clsTime = d.getClsTime()
550 groupIds = d.getTimeGroupId()
551 groupInfo = d.getTimeGroupInfo()
552
553 if not math.isnan(svdEventT0):
554 self.TH2F_Store[self.TH2F_Index["th2f_trkTime_vs_clsTime_inSVDEventT0"]].Fill(
555 trkTime0 - clsTime, svdEventT0 - trkTime0)
556 if not math.isnan(cdcEventT0):
557 self.TH2F_Store[self.TH2F_Index["th2f_trkTime_vs_clsTime_inCDCEventT0"]].Fill(
558 trkTime0 - clsTime, cdcEventT0 - trkTime0)
559 self.TH2F_Store[self.TH2F_Index["th2f_aveClsTimeInTrk_vs_cdcEventT0"]].Fill(trkTime, cdcEventT0)
560 if not math.isnan(svdEventT0):
561 self.TH2F_Store[self.TH2F_Index["th2f_aveClsTimeInTrk_vs_clsTime_inSVDEventT0"]].Fill(
562 trkTime - clsTime, svdEventT0 - trkTime)
563 if not math.isnan(cdcEventT0):
564 self.TH2F_Store[self.TH2F_Index["th2f_aveClsTimeInTrk_vs_clsTime_inCDCEventT0"]].Fill(
565 trkTime - clsTime, cdcEventT0 - trkTime)
566
567 self.TH1F_Store[self.TH1F_Index["th1f_clsTime_PostTracking"]].Fill(clsTime)
568 if not math.isnan(cdcEventT0):
569 self.TH1F_Store[self.TH1F_Index["th1f_clsTimeCdcRef_PostTracking"]].Fill(clsTime - cdcEventT0)
570 if not math.isnan(topOnlineEventT0) and eclTCEmax:
571 self.reso_TH2D_Histograms[self.reso_TH2D_Histogram_Index["reso_eclTCEmax_vs_clsTimeTopRef_PostTracking"]].Fill(
572 eclTCEmax, clsTime - topOnlineEventT0)
573
574 minId = 1000
575 par0 = -1000
576 par1 = -1000
577 par2 = -1000
578 if len(groupIds) == 0:
579 minId = -1
580 for id in range(len(groupIds)):
581 gr = groupIds[id]
582 if gr < minId:
583 minId = gr
584 if len(groupInfo) > 0:
585 par0, par1, par2 = groupInfo[id]
586
587 self.TH2F_Store[self.TH2F_Index["th2f_timeGr_vs_clsTime_PostTracking"]].Fill(clsTime, minId)
588
589 if par1 > sigMin and par1 < sigMax:
590 self.TH1F_Store[self.TH1F_Index["th1f_sigClsTime_PostTracking"]].Fill(clsTime)
591 else:
592 self.TH1F_Store[self.TH1F_Index["th1f_bkgClsTime_PostTracking"]].Fill(clsTime)
593
594 if eclTCEmax:
595 self.reso_TH2D_Histograms[self.reso_TH2D_Histogram_Index["reso_eclTCEmax_vs_totalTracks"]].Fill(eclTCEmax, nTracks)
596 self.reso_TH2D_Histograms[self.reso_TH2D_Histogram_Index["reso_eclTCEmax_vs_totalClusters_PostTracking"]].Fill(
597 eclTCEmax, nClusters)
598
Belle2::Const::DetectorSet
The DetectorSet class for sets of detector IDs in the form of EDetector values.
Definition Const.h:80
Belle2::PyStoreArray
A (simplified) python wrapper for StoreArray.
Definition PyStoreArray.h:73
Belle2::PyStoreObj
a (simplified) python wrapper for StoreObjPtr.
Definition PyStoreObj.h:67

◆ initialize()

initialize ( self) 
define histograms

Definition at line 111 of file svdGroupingPerformance.py.

111 def initialize(self):
112 '''define histograms'''
113
114 usedBin1 = 100
115 usedBin2 = 2000
116 eclMinVal = 19.5
117 eclMaxVal = 1100.5
118
119 timeBin = int(maxTime - minTime)
120
121
122 self.TH1F_Index = {}
123
124 self.TH1F_Store = []
125 TH1F_Store_Count = 0
126
127
128 self.TH2F_Index = {}
129
130 self.TH2F_Store = []
131 TH2F_Store_Count = 0
132
133
134 self.reso_TH2D_Histogram_Index = {}
135
136 self.reso_TH2D_Histograms = []
137 reso_TH2D_Histograms_Count = 0
138
139
140 self.outputFileName = str(args.fileDir) + str(args.moduleName) + outputFileTag
141
142 self.f = TFile(self.outputFileName + ".root", "RECREATE")
143
144 # EventT0s
145
146 self.TH1F_Store.append(TH1F("th1f_svdEventT0", "SVD EventT0", 500, -50., 50.))
147 self.TH1F_Store[-1].GetXaxis().SetTitle("SVD EventT0 (ns)")
148 self.TH1F_Index["th1f_svdEventT0"] = TH1F_Store_Count
149 TH1F_Store_Count += 1
150 self.TH1F_Store.append(TH1F("th1f_svdEventT0_State", "SVD EventT0 Availability", 2, -0.5, 1.5))
151 self.TH1F_Store[-1].GetXaxis().SetBinLabel(1, "Not Available")
152 self.TH1F_Store[-1].GetXaxis().SetBinLabel(2, "Available")
153 self.TH1F_Index["th1f_svdEventT0_State"] = TH1F_Store_Count
154 TH1F_Store_Count += 1
155
156 self.TH1F_Store.append(TH1F("th1f_cdcEventT0", "CDC EventT0", 500, -50., 50.))
157 self.TH1F_Store[-1].GetXaxis().SetTitle("CDC EventT0 (ns)")
158 self.TH1F_Index["th1f_cdcEventT0"] = TH1F_Store_Count
159 TH1F_Store_Count += 1
160 self.TH1F_Store.append(TH1F("th1f_cdcEventT0_State", "CDC EventT0 Availability", 2, -0.5, 1.5))
161 self.TH1F_Store[-1].GetXaxis().SetBinLabel(1, "Not Available")
162 self.TH1F_Store[-1].GetXaxis().SetBinLabel(2, "Available")
163 self.TH1F_Index["th1f_cdcEventT0_State"] = TH1F_Store_Count
164 TH1F_Store_Count += 1
165
166 # EventT0 - TOP Online EventT0
167
168 self.TH1F_Store.append(TH1F("th1f_svdEventT0topRef", "SVD EventT0 - TOP Online EventT0", 500, -20., 20.))
169 self.TH1F_Store[-1].GetXaxis().SetTitle("SVD EventT0 - TOP Online EventT0 (ns)")
170 self.TH1F_Index["th1f_svdEventT0topRef"] = TH1F_Store_Count
171 TH1F_Store_Count += 1
172
173 # Cluster Time
174
175 self.TH1F_Store.append(TH1F("th1f_clsTime_PreTracking", "(PreTracking) Cluster Time", timeBin, minTime, maxTime))
176 self.TH1F_Store[-1].GetXaxis().SetTitle("Cluster Time (ns)")
177 self.TH1F_Store[-1].SetLineColor(1)
178 self.TH1F_Index["th1f_clsTime_PreTracking"] = TH1F_Store_Count
179 TH1F_Store_Count += 1
180 self.TH1F_Store.append(TH1F("th1f_bkgClsTime_PreTracking", "(PreTracking) Bkg Cluster Time", timeBin, minTime, maxTime))
181 self.TH1F_Store[-1].GetXaxis().SetTitle("Cluster Time (ns)")
182 self.TH1F_Store[-1].SetLineColor(2)
183 self.TH1F_Index["th1f_bkgClsTime_PreTracking"] = TH1F_Store_Count
184 TH1F_Store_Count += 1
185 self.TH1F_Store.append(TH1F("th1f_sigClsTime_PreTracking", "(PreTracking) Sig Cluster Time", timeBin, minTime, maxTime))
186 self.TH1F_Store[-1].GetXaxis().SetTitle("Cluster Time (ns)")
187 self.TH1F_Store[-1].SetLineColor(3)
188 self.TH1F_Index["th1f_sigClsTime_PreTracking"] = TH1F_Store_Count
189 TH1F_Store_Count += 1
190
191 self.TH1F_Store.append(TH1F("th1f_clsTime_PostTracking", "(PostTracking) Cluster Time", timeBin, minTime, maxTime))
192 self.TH1F_Store[-1].GetXaxis().SetTitle("Cluster Time (ns)")
193 self.TH1F_Store[-1].SetLineColor(1)
194 self.TH1F_Index["th1f_clsTime_PostTracking"] = TH1F_Store_Count
195 TH1F_Store_Count += 1
196 self.TH1F_Store.append(TH1F("th1f_bkgClsTime_PostTracking", "(PostTracking) Bkg Cluster Time", timeBin, minTime, maxTime))
197 self.TH1F_Store[-1].GetXaxis().SetTitle("Cluster Time (ns)")
198 self.TH1F_Store[-1].SetLineColor(2)
199 self.TH1F_Index["th1f_bkgClsTime_PostTracking"] = TH1F_Store_Count
200 TH1F_Store_Count += 1
201 self.TH1F_Store.append(TH1F("th1f_sigClsTime_PostTracking", "(PostTracking) Sig Cluster Time", timeBin, minTime, maxTime))
202 self.TH1F_Store[-1].GetXaxis().SetTitle("Cluster Time (ns)")
203 self.TH1F_Store[-1].SetLineColor(3)
204 self.TH1F_Index["th1f_sigClsTime_PostTracking"] = TH1F_Store_Count
205 TH1F_Store_Count += 1
206
207 self.TH1F_Store.append(TH1F("th1f_trackTime", "Track Time", timeBin * 10, minTime, maxTime))
208 self.TH1F_Store[-1].GetXaxis().SetTitle("Track Time (ns)")
209 self.TH1F_Index["th1f_trackTime"] = TH1F_Store_Count
210 TH1F_Store_Count += 1
211 self.TH1F_Store.append(TH1F("th1f_trackTimeCDCRef", "Track Time - CDC EventT0", 10000, -50, 50))
212 self.TH1F_Store[-1].GetXaxis().SetTitle("Track Time - CDC EventT0 (ns)")
213 self.TH1F_Index["th1f_trackTimeCDCRef"] = TH1F_Store_Count
214 TH1F_Store_Count += 1
215
216 # Cluster Time - TOP Online EventT0
217
218 self.TH1F_Store.append(TH1F("th1f_clsTimeCdcRef_PreTracking", "(PreTracking) Cluster Time - CDC EventT0",
219 timeBin * 2, minTime, maxTime))
220 self.TH1F_Store[-1].GetXaxis().SetTitle("Cluster Time - CDC EventT0 (ns)")
221 self.TH1F_Store[-1].SetLineColor(1)
222 self.TH1F_Index["th1f_clsTimeCdcRef_PreTracking"] = TH1F_Store_Count
223 TH1F_Store_Count += 1
224
225 self.TH1F_Store.append(TH1F("th1f_clsTimeCdcRef_PostTracking", "(PostTracking) Cluster Time - CDC EventT0",
226 timeBin * 2, minTime, maxTime))
227 self.TH1F_Store[-1].GetXaxis().SetTitle("Cluster Time - CDC EventT0 (ns)")
228 self.TH1F_Store[-1].SetLineColor(1)
229 self.TH1F_Index["th1f_clsTimeCdcRef_PostTracking"] = TH1F_Store_Count
230 TH1F_Store_Count += 1
231
232 # ECL TC Emax
233
234 self.TH1F_Store.append(TH1F("th1f_eclTCEmax", "ECL E_{max}^{TC}", 1250, 0.5, 1250.5))
235 self.TH1F_Store[-1].GetXaxis().SetTitle("ECL E_{max}^{TC} (ADC)")
236 self.TH1F_Index["th1f_eclTCEmax"] = TH1F_Store_Count
237 TH1F_Store_Count += 1
238 self.TH1F_Store.append(TH1F("th1f_eclTCEmax_State", "ECL E_{max}^{TC} Availability", 2, -0.5, 1.5))
239 self.TH1F_Store[-1].GetXaxis().SetBinLabel(1, "Not Available")
240 self.TH1F_Store[-1].GetXaxis().SetBinLabel(2, "Available")
241 self.TH1F_Index["th1f_eclTCEmax_State"] = TH1F_Store_Count
242 TH1F_Store_Count += 1
243
244 self.TH2F_Store.append(TH2F("th2f_timeGr_vs_grAmp", "Time Group vs Group Amplitude", 60, 0., 300, 21, -1.5, 19.5))
245 self.TH2F_Store[-1].GetXaxis().SetTitle("Group Amplitude")
246 self.TH2F_Store[-1].GetYaxis().SetTitle("Time Group")
247 self.TH2F_Index["th2f_timeGr_vs_grAmp"] = TH2F_Store_Count
248 TH2F_Store_Count += 1
249 self.TH2F_Store.append(TH2F("th2f_timeGr_vs_grCenter", "Time Group vs Group Center", 80, minTime, maxTime, 21, -1.5, 19.5))
250 self.TH2F_Store[-1].GetXaxis().SetTitle("Group Center (ns)")
251 self.TH2F_Store[-1].GetYaxis().SetTitle("Time Group")
252 self.TH2F_Index["th2f_timeGr_vs_grCenter"] = TH2F_Store_Count
253 TH2F_Store_Count += 1
254 self.TH2F_Store.append(TH2F("th2f_timeGr_vs_grWidth", "Time Group vs Group Width", 50, 1, 11, 21, -1.5, 19.5))
255 self.TH2F_Store[-1].GetXaxis().SetTitle("Group Width (ns)")
256 self.TH2F_Store[-1].GetYaxis().SetTitle("Time Group")
257 self.TH2F_Index["th2f_timeGr_vs_grWidth"] = TH2F_Store_Count
258 TH2F_Store_Count += 1
259 self.TH2F_Store.append(TH2F("th2f_timeGr_vs_clsTime", "Time Group vs Cluster Time",
260 timeBin, minTime, maxTime, 21, -1.5, 19.5))
261 self.TH2F_Store[-1].GetXaxis().SetTitle("Cluster Time (ns)")
262 self.TH2F_Store[-1].GetYaxis().SetTitle("Time Group")
263 self.TH2F_Index["th2f_timeGr_vs_clsTime"] = TH2F_Store_Count
264 TH2F_Store_Count += 1
265 self.TH2F_Store.append(TH2F("th2f_timeGr_vs_clsTime_PostTracking", "(PostTracking) Time Group vs Cluster Time",
266 timeBin, minTime, maxTime, 21, -1.5, 19.5))
267 self.TH2F_Store[-1].GetXaxis().SetTitle("Cluster Time (ns)")
268 self.TH2F_Store[-1].GetYaxis().SetTitle("Time Group")
269 self.TH2F_Index["th2f_timeGr_vs_clsTime_PostTracking"] = TH2F_Store_Count
270 TH2F_Store_Count += 1
271
272 for i in range(4):
273 self.TH2F_Store.append(TH2F("th2f_sig" + str(i) + "GrMean_vs_cdcEventT0", "Center of 'Group " +
274 str(i) + "' vs CDC EventT0", 500, -50., 50., 500, -50., 50.))
275 self.TH2F_Store[-1].GetXaxis().SetTitle("Center of 'Group " + str(i) + "' (ns)")
276 self.TH2F_Store[-1].GetYaxis().SetTitle("CDC EventT0 (ns)")
277 self.TH2F_Index["th2f_sig" + str(i) + "GrMean_vs_cdcEventT0"] = TH2F_Store_Count
278 TH2F_Store_Count += 1
279 self.TH2F_Store.append(TH2F("th2f_sig" + str(i) + "GrMean_vs_cdcEventT0_rot45pos",
280 "Center of 'Group " + str(i) + "' vs CDC EventT0 (Rotated 45)",
281 500, -50., 50., 500, -50., 50.))
282 self.TH2F_Store[-1].GetXaxis().SetTitle("Center of 'Group " + str(i) + "' (ns)")
283 self.TH2F_Store[-1].GetYaxis().SetTitle("CDC EventT0 (ns)")
284 self.TH2F_Index["th2f_sig" + str(i) + "GrMean_vs_cdcEventT0_rot45pos"] = TH2F_Store_Count
285 TH2F_Store_Count += 1
286 self.TH2F_Store.append(TH2F("th2f_sig" + str(i) + "GrMean_vs_cdcEventT0_rot45neg",
287 "Center of 'Group " + str(i) + "' vs CDC EventT0 (Rotated -45)",
288 500, -50., 50., 500, -50., 50.))
289 self.TH2F_Store[-1].GetXaxis().SetTitle("Center of 'Group " + str(i) + "' (ns)")
290 self.TH2F_Store[-1].GetYaxis().SetTitle("CDC EventT0 (ns)")
291 self.TH2F_Index["th2f_sig" + str(i) + "GrMean_vs_cdcEventT0_rot45neg"] = TH2F_Store_Count
292 TH2F_Store_Count += 1
293
294 self.TH2F_Store.append(TH2F("th2f_aveClsTimeInTrk_vs_cdcEventT0",
295 "Track Time vs CDC EventT0", 500, -50., 50., 500, -50., 50.))
296 self.TH2F_Store[-1].GetXaxis().SetTitle("<Cluster Time> in Track (ns)")
297 self.TH2F_Store[-1].GetYaxis().SetTitle("CDC EventT0 (ns)")
298 self.TH2F_Index["th2f_aveClsTimeInTrk_vs_cdcEventT0"] = TH2F_Store_Count
299 TH2F_Store_Count += 1
300 self.TH2F_Store.append(TH2F("th2f_svdEventT0_vs_cdcEventT0", "SVD EventT0 vs CDC EventT0",
301 500, -50., 50., 500, -50., 50.))
302 self.TH2F_Store[-1].GetXaxis().SetTitle("SVD EventT0 (ns)")
303 self.TH2F_Store[-1].GetYaxis().SetTitle("CDC EventT0 (ns)")
304 self.TH2F_Index["th2f_svdEventT0_vs_cdcEventT0"] = TH2F_Store_Count
305 TH2F_Store_Count += 1
306 self.TH2F_Store.append(TH2F("th2f_svdEventT0_vs_cdcEventT0_rot45pos",
307 "SVD EventT0 vs CDC EventT0 (Rotated 45)", 500, -50., 50., 500, -50., 50.))
308 self.TH2F_Store[-1].GetXaxis().SetTitle("SVD EventT0 (ns)")
309 self.TH2F_Store[-1].GetYaxis().SetTitle("CDC EventT0 (ns)")
310 self.TH2F_Index["th2f_svdEventT0_vs_cdcEventT0_rot45pos"] = TH2F_Store_Count
311 TH2F_Store_Count += 1
312 self.TH2F_Store.append(TH2F("th2f_svdEventT0_vs_cdcEventT0_rot45neg",
313 "SVD EventT0 vs CDC EventT0 (Rotated -45)", 500, -50., 50., 500, -50., 50.))
314 self.TH2F_Store[-1].GetXaxis().SetTitle("SVD EventT0 (ns)")
315 self.TH2F_Store[-1].GetYaxis().SetTitle("CDC EventT0 (ns)")
316 self.TH2F_Index["th2f_svdEventT0_vs_cdcEventT0_rot45neg"] = TH2F_Store_Count
317 TH2F_Store_Count += 1
318
319 self.TH2F_Store.append(TH2F("th2f_trkTime_vs_clsTime_inCDCEventT0", "Track Time vs Cluster Time",
320 timeBin, minTime, maxTime, timeBin, minTime, maxTime))
321 self.TH2F_Store[-1].GetXaxis().SetTitle("Track Time - Cluster Time (ns)")
322 self.TH2F_Store[-1].GetYaxis().SetTitle("CDC EventT0 - Track Time (ns)")
323 self.TH2F_Index["th2f_trkTime_vs_clsTime_inCDCEventT0"] = TH2F_Store_Count
324 TH2F_Store_Count += 1
325 self.TH2F_Store.append(TH2F("th2f_trkTime_vs_clsTime_inSVDEventT0", "Track Time vs Cluster Time",
326 timeBin, minTime, maxTime, timeBin, minTime, maxTime))
327 self.TH2F_Store[-1].GetXaxis().SetTitle("Track Time - Cluster Time (ns)")
328 self.TH2F_Store[-1].GetYaxis().SetTitle("SVD EventT0 - Track Time (ns)")
329 self.TH2F_Index["th2f_trkTime_vs_clsTime_inSVDEventT0"] = TH2F_Store_Count
330 TH2F_Store_Count += 1
331
332 self.TH2F_Store.append(TH2F("th2f_aveClsTimeInTrk_vs_clsTime_inCDCEventT0", "<Cluster Time> in Track vs Cluster Time",
333 timeBin, minTime, maxTime, timeBin, minTime, maxTime))
334 self.TH2F_Store[-1].GetXaxis().SetTitle("<Cluster Time> in Track - Cluster Time (ns)")
335 self.TH2F_Store[-1].GetYaxis().SetTitle("CDC EventT0 - <Cluster Time> in Track (ns)")
336 self.TH2F_Index["th2f_aveClsTimeInTrk_vs_clsTime_inCDCEventT0"] = TH2F_Store_Count
337 TH2F_Store_Count += 1
338 self.TH2F_Store.append(TH2F("th2f_aveClsTimeInTrk_vs_clsTime_inSVDEventT0", "<Cluster Time> in Track vs Cluster Time",
339 timeBin, minTime, maxTime, timeBin, minTime, maxTime))
340 self.TH2F_Store[-1].GetXaxis().SetTitle("<Cluster Time> in Track - Cluster Time (ns)")
341 self.TH2F_Store[-1].GetYaxis().SetTitle("SVD EventT0 - <Cluster Time> in Track (ns)")
342 self.TH2F_Index["th2f_aveClsTimeInTrk_vs_clsTime_inSVDEventT0"] = TH2F_Store_Count
343 TH2F_Store_Count += 1
344
345 # Resolution w.r.t. ECL TC Emax
346
347 self.reso_TH2D_Histograms.append(TH2F("reso_eclTCEmax_vs_clsTimeTopRef_PreTracking",
348 "(PreTracking) ECL E_{max}^{TC} vs Cluster Time - TOP Online EventT0",
349 usedBin1, eclMinVal, eclMaxVal, usedBin2, -50, 50.))
350 self.reso_TH2D_Histograms[-1].GetXaxis().SetTitle("ECL E_{max}^{TC} (ADC)")
351 self.reso_TH2D_Histograms[-1].GetYaxis().SetTitle("Cluster Time - TOP Online EventT0 (ns)")
352 self.reso_TH2D_Histogram_Index["reso_eclTCEmax_vs_clsTimeTopRef_PreTracking"] = reso_TH2D_Histograms_Count
353 reso_TH2D_Histograms_Count += 1
354 self.reso_TH2D_Histograms.append(TH2F("reso_eclTCEmax_vs_clsTimeTopRef_PostTracking",
355 "(PostTracking) ECL E_{max}^{TC} vs Cluster Time - TOP Online EventT0",
356 usedBin1, eclMinVal, eclMaxVal, usedBin2, -50, 50.))
357 self.reso_TH2D_Histograms[-1].GetXaxis().SetTitle("ECL E_{max}^{TC} (ADC)")
358 self.reso_TH2D_Histograms[-1].GetYaxis().SetTitle("Cluster Time - TOP Online EventT0 (ns)")
359 self.reso_TH2D_Histogram_Index["reso_eclTCEmax_vs_clsTimeTopRef_PostTracking"] = reso_TH2D_Histograms_Count
360 reso_TH2D_Histograms_Count += 1
361
362 self.reso_TH2D_Histograms.append(TH2F("reso_eclTCEmax_vs_svdEventT0TopRef",
363 "ECL E_{max}^{TC} vs SVD EventT0 - TOP Online EventT0",
364 usedBin1, eclMinVal, eclMaxVal, usedBin2, -50, 50.))
365 self.reso_TH2D_Histograms[-1].GetXaxis().SetTitle("ECL E_{max}^{TC} (ADC)")
366 self.reso_TH2D_Histograms[-1].GetYaxis().SetTitle("SVD EventT0 - TOP Online EventT0 (ns)")
367 self.reso_TH2D_Histogram_Index["reso_eclTCEmax_vs_svdEventT0TopRef"] = reso_TH2D_Histograms_Count
368 reso_TH2D_Histograms_Count += 1
369
370 self.reso_TH2D_Histograms.append(TH2F("reso_eclTCEmax_vs_totalTracks",
371 "ECL E_{max}^{TC} vs Total SVD Tracks",
372 usedBin1, eclMinVal, eclMaxVal, 36, -0.5, 35.5))
373 self.reso_TH2D_Histograms[-1].GetXaxis().SetTitle("ECL E_{max}^{TC} (ADC)")
374 self.reso_TH2D_Histograms[-1].GetYaxis().SetTitle("Total SVD Tracks")
375 self.reso_TH2D_Histogram_Index["reso_eclTCEmax_vs_totalTracks"] = reso_TH2D_Histograms_Count
376 reso_TH2D_Histograms_Count += 1
377
378 self.reso_TH2D_Histograms.append(TH2F("reso_eclTCEmax_vs_totalClusters_PreTracking",
379 "(PreTracking) ECL E_{max}^{TC} vs Total SVD Clusters",
380 usedBin1, eclMinVal, eclMaxVal, 1000, 0.5, 1000.5))
381 self.reso_TH2D_Histograms[-1].GetXaxis().SetTitle("ECL E_{max}^{TC} (ADC)")
382 self.reso_TH2D_Histograms[-1].GetYaxis().SetTitle("Total SVD Clusters")
383 self.reso_TH2D_Histogram_Index["reso_eclTCEmax_vs_totalClusters_PreTracking"] = reso_TH2D_Histograms_Count
384 reso_TH2D_Histograms_Count += 1
385 self.reso_TH2D_Histograms.append(TH2F("reso_eclTCEmax_vs_totalClusters_PostTracking",
386 "(PostTracking) ECL E_{max}^{TC} vs Total SVD Clusters",
387 usedBin1, eclMinVal, eclMaxVal, 1000, 0.5, 1000.5))
388 self.reso_TH2D_Histograms[-1].GetXaxis().SetTitle("ECL E_{max}^{TC} (ADC)")
389 self.reso_TH2D_Histograms[-1].GetYaxis().SetTitle("Total SVD Clusters")
390 self.reso_TH2D_Histogram_Index["reso_eclTCEmax_vs_totalClusters_PostTracking"] = reso_TH2D_Histograms_Count
391 reso_TH2D_Histograms_Count += 1
392

◆ terminate()

terminate ( self) 
write

Definition at line 599 of file svdGroupingPerformance.py.

599 def terminate(self):
600 '''write'''
601
602 self.f.mkdir("objects")
603 self.f.cd("objects")
604
605 for hist in self.TH1F_Store:
606 if "_State" in hist.GetName():
607 hist.Scale(1./hist.GetSumOfWeights())
608 hist.Write()
609
610 for hist in self.TH2F_Store:
611 hist.Write()
612
613 for hist in self.reso_TH2D_Histograms:
614 hist.Write()
615
616 self.f.Close()
617
618

Member Data Documentation

◆ f

f = TFile(self.outputFileName + ".root", "RECREATE")

output file

Definition at line 142 of file svdGroupingPerformance.py.

◆ outputFileName

outputFileName = str(args.fileDir) + str(args.moduleName) + outputFileTag

output file name

Definition at line 140 of file svdGroupingPerformance.py.

◆ reso_TH2D_Histogram_Index

dict reso_TH2D_Histogram_Index = {}

dictionary of TH2D indices

Definition at line 134 of file svdGroupingPerformance.py.

◆ reso_TH2D_Histograms

list reso_TH2D_Histograms = []

list of TH2D histograms

Definition at line 136 of file svdGroupingPerformance.py.

◆ TH1F_Index

dict TH1F_Index = {}

dictionary of TH1F indices

Definition at line 122 of file svdGroupingPerformance.py.

◆ TH1F_Store

list TH1F_Store = []

list of TH1F histograms

Definition at line 124 of file svdGroupingPerformance.py.

◆ TH2F_Index

dict TH2F_Index = {}

dictionary of TH2F indices

Definition at line 128 of file svdGroupingPerformance.py.

◆ TH2F_Store

list TH2F_Store = []

list of TH2F histograms

Definition at line 130 of file svdGroupingPerformance.py.

The documentation for this class was generated from the following file: