ATLAS Offline Software
Functions | Variables
BSMonitoringAlgorithm Namespace Reference

Functions

def BSMonitoringConfig (inputFlags)
 

Variables

 inputs
 
 flags
 
 Files
 
 HISTFileName
 
 cfg
 
 BSMonitorCfg
 
 OutputLevel
 
 withDetails
 
 False
 
 summariseProps
 
 nevents
 

Function Documentation

◆ BSMonitoringConfig()

def BSMonitoringAlgorithm.BSMonitoringConfig (   inputFlags) 
Function to configure LVL1 BSMonitoring algorithm in the monitoring system.

Definition at line 5 of file BSMonitoringAlgorithm.py.

5 def BSMonitoringConfig(inputFlags):
6  '''Function to configure LVL1 BSMonitoring algorithm in the monitoring system.'''
7 
8  import logging
9  local_logger = logging.getLogger('AthenaMonitoringCfg')
10  info = local_logger.info
11  from AthenaConfiguration.ComponentFactory import CompFactory
12  from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
13  result = ComponentAccumulator()
14 
15  # make the athena monitoring helper
16  from AthenaMonitoring import AthMonitorCfgHelper
17  helper = AthMonitorCfgHelper(inputFlags,'BSMonitoringCfg')
18 
19  # get any algorithms
20  BSMonAlg = helper.addAlgorithm(CompFactory.TrigT1CTMonitoring.BSMonitoringAlgorithm,'BSMonAlg')
21 
22  # default values:
23  ProcessRoIBResult = True
24  InclusiveTriggerThresholds = True
25  ProcessMuctpiData = True
26  ProcessMuctpiDataRIO = True
27  RunOnESD = False
28  CompareRerun = False
29  ProcessCTPData = True
30  isSimulation = inputFlags.Input.isMC
31 
32  info('In BSMonitoringConfig SIM or not?: %s', isSimulation)
33  #-----------ONLINE CODE---------------------
34  if inputFlags.Common.isOnline:
35  #info('In BSMonitoringConfig: isOnline')
36  ProcessRoIBResult = True
37  InclusiveTriggerThresholds = True
38  ProcessMuctpiData = True #True
39  ProcessMuctpiDataRIO = False #True
40  RunOnESD = False
41  CompareRerun = False
42  #-----------OFFLINE CODE---------------------
43  else:
44  #info('In BSMonitoringConfig: NOT isOnline')
45 
52 
53  #none of these 2 work - pretty unsatisfying! - to be fixed asap!!!!!
54  #if inputFlags.DQ.Environment not in ('online', 'tier0', 'tier0Raw'): #, 'tier0ESD'):
55 
58 
59 
63 
64  #from TrigT1MuctpiPhase1.TrigT1MuctpiPhase1Config import L1MuctpiPhase1_on_Data #MUCTPI_AthAlgCfg #L1MuctpiPhase1 #L1MuctpiPhase1_on_Data
65  #CTPMonSeq += L1MuctpiPhase1_on_Data("MUCTPI_AthTool") # MUCTPI_AthAlgCfg(inputFlags) #L1MuctpiPhase1() #L1MuctpiPhase1_on_Data()
66 
67  # check if global muons are on
68  if not inputFlags.Reco.EnableCombinedMuon:
69  if isSimulation:
70  info('In BSMonitoringConfig: rec.doMuon=True & SIM')
71  ProcessRoIBResult = False
72  InclusiveTriggerThresholds = False
73  ProcessMuctpiData = False
74  ProcessMuctpiDataRIO = False
75  CompareRerun = False #True
76  else:
77  info('In BSMonitoringConfig: rec.doMuon=True & DATA')
78  ProcessRoIBResult = False
79  InclusiveTriggerThresholds = False
80  ProcessMuctpiData = False
81  ProcessMuctpiDataRIO = False
82  RunOnESD = False
83  CompareRerun = False
84  else:
85  if isSimulation:
86  info('In BSMonitoringConfig: rec.doMuon=False & SIM')
87  ProcessRoIBResult = True
88  ProcessMuctpiData = False #True
89  ProcessMuctpiDataRIO = False #True
90  RunOnESD = True
91  CompareRerun = False #True
92  else:
93  info('In BSMonitoringConfig: rec.doMuon=False & DATA')
94  ProcessRoIBResult = True
95  ProcessMuctpiData = True
96  ProcessMuctpiDataRIO = False
97  RunOnESD = False
98  CompareRerun = False
99 
100  # ------ DET MASK ---------------------------------------------------
101  from AthenaConfiguration.AutoConfigFlags import GetFileMD
102  metadata = GetFileMD(inputFlags.Input.Files)
103  if len(inputFlags.Input.Files)!=1: print("INFO: more than one file. DetMask check may fail")
104 
105  #else, the det mask check is invalid => don't assume MUCTPI is OUT
106  if 'detectorMask' in metadata:
107  import eformat #eformat includes DetectorMask and is a tdaq package
108  detmask_unformatted=metadata['detectorMask'][0]
109  detmask=f'{detmask_unformatted:032x}' #detmask needs to be 32 hex chars
110  x = eformat.helper.DetectorMask(detmask)
111  if not x.is_set(eformat.helper.SubDetector.TDAQ_MUON_CTP_INTERFACE):
112  ProcessMuctpiData=False
113  print("INFO: MUCTPI is not in det mask; skipping muctpi algos")
114  # ------------------------------------------------------------------
115 
116  from AthenaConfiguration.Enums import LHCPeriod
117  isRun3 = inputFlags.GeoModel.Run is LHCPeriod.Run3
118  BSMonAlg.isRun3 = isRun3
119  if not isRun3:
120  BSMonAlg.ProcessMuctpiData = False
121  BSMonAlg.ProcessMuctpiDataRIO = False
122 
123  BSMonAlg.isSimulation = isSimulation
124  BSMonAlg.ProcessRoIBResult = ProcessRoIBResult
125  BSMonAlg.InclusiveTriggerThresholds = InclusiveTriggerThresholds
126  BSMonAlg.ProcessMuctpiData = ProcessMuctpiData
127  BSMonAlg.ProcessMuctpiDataRIO = ProcessMuctpiDataRIO
128  BSMonAlg.RunOnESD = RunOnESD
129  BSMonAlg.CompareRerun = CompareRerun
130  BSMonAlg.ProcessCTPData = ProcessCTPData
131  DefaultBcIntervalInNs = 24.9507401
132  BSMonAlg.DefaultBcIntervalInNs = DefaultBcIntervalInNs
133  BSMonAlg.BCsPerTurn = 3564
134  LumiBlockTimeCoolFolderName = '/TRIGGER/LUMI/LBLB"'
135  BSMonAlg.LumiBlockTimeCoolFolderName = LumiBlockTimeCoolFolderName
136  #should not use online
137  #FillStateCoolFolderName = '/LHC/DCS/FILLSTATE'
138  #BSMonAlg.FillStateCoolFolderName = FillStateCoolFolderName
139  DataTakingModeCoolFolderName = '/TDAQ/RunCtrl/DataTakingMode'
140  BSMonAlg.DataTakingModeCoolFolderName = DataTakingModeCoolFolderName
141  IgnorePatterns = ["L1_TRT", "L1_ZB", "_AFP", "L1_BPTX", "L1_BCM", "L1_LUCID"]
142  BSMonAlg.IgnorePatterns = IgnorePatterns
143 
144  # add monitoring algorithm to group, with group name and main directory
145  groupName = 'CTPMonitor' # the monitoring group name is also used for the package name
146  BSMonAlg.PackageName = groupName
147  mainDir = 'CT'
148  myGroup = helper.addGroup(BSMonAlg, groupName , mainDir)
149 
150  if isRun3 and ProcessMuctpiData:
151  #add the phase1 algorithm
152  from TrigT1ResultByteStream.TrigT1ResultByteStreamConfig import MuCTPIPhase1ByteStreamAlgoCfg
153  result.merge( MuCTPIPhase1ByteStreamAlgoCfg(inputFlags) )
154 
155 
156  if(not isRun3):
157 
158  errorSummaryBinLabels = [
159  "CTP/ROD BCID Offset",
160  "No BCs in Readout",
161  "CTP/MuCTPI BCID Offset",
162  "Wrong Cand Word Number",
163  "Wrong Pt in Mult Word",
164  "Wrong Num of RoI",
165  "No Cand for RoI",
166  "Cand BC Out of Range",
167  "Invalid Lumi Block",
168  "LB Out of Time",
169  "Nanosec > 1e9",
170  "TAP w/out TBP",
171  "TAV w/out TAP",
172  "CTP sim. mismatch",
173  "Incomplete fragment",
174  "Missing orbit pulse",
175  "MuCTPI/noRPC candidate mismatch",
176  "MuCTPI/noTGC candidate mismatch",
177  "RPC/noMuCTPI candidate mismatch",
178  "GC/noMuCTPI candidate mismatch"
179  ]
180  incompleteFragmentTypeBinLabels = [
181  "CTP RIO",
182  "CTP RDO",
183  #"MuCTPI RIO",
184  "MuCTPI RDO",
185  "RoIBResult",
186  "TGC SL RDO",
187  "RPC SL RDO"
188  ]
189 
190  # ERRORS
191  # TProfile or TEfficiency? I guess both work as we only casre about he value not correct errors
192  # CHECK( registerTProfile("errorSummary", "CTP and MuCTPI errors; ; Error rate", 20, 0.5, 20.5, -1, 2) );
193  myGroup.defineHistogram('errorSummaryX,errorSummaryY;errorSummary',title='CTP and MuCTPI errors; ; Error ratio',
194  type='TProfile', path="", xbins=20, xmin=0.5, xmax=20.5, ymin=-1., ymax=2., xlabels=errorSummaryBinLabels, opt='kAlwaysCreate')
195  # 2D
196  # CHECK( registerTH2("errorSummaryPerLumiBlock", "Errors per lumi block; LB number; Errors", 2000, 0.5, 2000.5, 20, 0.5, 20.5) );
197  myGroup.defineHistogram('errorSummaryPerLumiBlockX,errorSummaryPerLumiBlockY;errorSummaryPerLumiBlock',title='Errors per lumi block; LB number; Errors',
198  type='TH2F',path='',xbins=2000,xmin=0.5,xmax=2000.5,ybins=20,ymin=0.5,ymax=20.5,ylabels=errorSummaryBinLabels, opt='kAlwaysCreate')
199  # 1d
200  # CHECK( registerTH1("errorPerLumiBlock", "Number of errors per lumi block; LB number; Errors", 2001, -0.5, 2000.5) );
201  myGroup.defineHistogram('errorPerLumiBlockX;errorPerLumiBlock', title='Number of errors per lumi block; LB number; Errors',
202  path='',xbins=2001,xmin=-0.5,xmax=2000.5,opt='kAlwaysCreate')
203  # CHECK( registerTH1("incompleteFragmentType", "Number of missing fragments per type; Fragment type; Number of incomplete fragments", 8, -0.5, 7.5) );
204  myGroup.defineHistogram('incompleteFragmentTypeX;incompleteFragmentType', title='Number of missing fragments per type; Fragment type; Number of incomplete fragments ',
205  path='',xbins=7,xmin=-0.5,xmax=7.5, xlabels=incompleteFragmentTypeBinLabels, opt='kAlwaysCreate')
206 
207  monCTPPath="/CTP/"
208  # CHECK( registerTH1("deltaBcid", "CTP Data BCID - ROD Header BCID; #DeltaBCID; Entries", 401, -200.5, 200.5) );
209  myGroup.defineHistogram('deltaBcidX;deltaBcid', title='CTP Data BCID - ROD Header BCID; #DeltaBCID; Entries',
210  path=monCTPPath,xbins=401,xmin=-200.5,xmax=200.5,opt='kAlwaysCreate')
211  # CHECK( registerTH1("triggerType", "Trigger Type; Trigger Type; Entries", 256, -0.5, 255.5) );
212  myGroup.defineHistogram('triggerTypeX;triggerType', title='Trigger Type; Trigger Type; Entries',
213  path=monCTPPath,xbins=256,xmin=-0.5,xmax=255.5,opt='kAlwaysCreate')
214  # CHECK( registerTH1("timeSinceLBStart", "Time Since LB Start; Time After New LB (ms); Entries", 1000, -500, 1500) );
215  myGroup.defineHistogram('timeSinceLBStartX;timeSinceLBStart', title='Time Since LB Start; Time After New LB (ms); Entries',
216  path=monCTPPath,xbins=1000,xmin=-500,xmax=1500,opt='kAlwaysCreate')
217  # CHECK( registerTH1("timeUntilLBEnd", "Time Until LB End; Time Until Next LB (ms); Entries", 1000, -500, 1500) );
218  myGroup.defineHistogram('timeUntilLBEndX;timeUntilLBEnd', title='Time Until LB End; Time Until Next LB (ms); Entries',
219  path=monCTPPath,xbins=1000,xmin=-500,xmax=1500,opt='kAlwaysCreate')
220  # CHECK( registerTH1("timeSinceL1A", "Time since last L1A; Time since last L1A (ms); Entries", 2000, -1, 30) );
221  myGroup.defineHistogram('timeSinceL1AX;timeSinceL1A', title='Time since last L1A; Time since last L1A (ms); Entries',
222  path=monCTPPath,xbins=2000,xmin=-1,xmax=30,opt='kAlwaysCreate')
223  # CHECK( registerTH1("turnCounterTimeError", "Error of time based on turn counter and BCID; t_{TC+BCID}-t_{GPS} [#mus]; Entries", 2000, -1000., 1000.) );
224  myGroup.defineHistogram('turnCounterTimeErrorX;turnCounterTimeError', title='Error of time based on turn counter and BCID; t_{TC+BCID}-t_{GPS} [#mus]; Entries',
225  path=monCTPPath,xbins=2000,xmin=-1000.,xmax=1000.,opt='kAlwaysCreate')
226  #patrick check how this one now looks and used to look! - compare to error Profile!
227  # CHECK( registerTProfile("turnCounterTimeErrorVsLb", "Error of (TC+BCID)-based time vs. LB; LB; t_{TC+BCID}-t_{GPS} [#mus]", 2001, -0.5, 2000.5, -1000., 1000.) );
228  myGroup.defineHistogram('turnCounterTimeErrorVsLbX,turnCounterTimeErrorVsLbY,turnCounterTimeErrorVsLbZ;turnCounterTimeErrorVsLb',
229  title='Error of (TC+BCID)-based time vs. LB; LB; t_{TC+BCID}-t_{GPS} [#mus]',
230  type='TProfile2D', path=monCTPPath, xbins=2001, ybins=2001, xmin=-0.5, xmax=2000.5, ymin=-1000., ymax=1000, opt='kAlwaysCreate')
231  # CHECK( registerTH2("pitBC", "CTP BC vs. PIT; PIT; BC", 320, -0.5, 319.5, 127, -63.5, 63.5) );
232  myGroup.defineHistogram('pitBCX,pitBCY;pitBC',title='CTP BC vs. PIT; PIT; BC',
233  type='TH2F',path=monCTPPath, xbins=320,xmin=-0.5,xmax=319.5,ybins=127,ymin=-63.5,ymax=63.5,opt='kAlwaysCreate')
234  # CHECK( registerTH2("pitFirstBC", "First CTP BC vs. PIT; PIT; BC", 320, -0.5, 319.5, 127, -63.5, 63.5) );
235  myGroup.defineHistogram('pitFirstBCX,pitFirstBCY;pitFirstBC',title='First CTP BC vs. PIT; PIT; BC',
236  type='TH2F',path=monCTPPath, xbins=320,xmin=-0.5,xmax=319.5,ybins=127,ymin=-63.5,ymax=63.5,opt='kAlwaysCreate')
237  # CHECK( registerTH1("tav", "Trigger Items After Veto; CTP TAV; Entries", 512, -0.5, 511.5) );
238  myGroup.defineHistogram('tavX;tav', title='Trigger Items After Veto; CTP TAV; Entries',
239  path=monCTPPath,xbins=512,xmin=-0.5,xmax=511.5,opt='kAlwaysCreate')
240  # CHECK( registerTH1("ctpStatus1", "CTP Status Word 1; Bit; Number of times ON", 24, -0.5, 23.5) );
241  myGroup.defineHistogram('ctpStatus1X;ctpStatus1', title='CTP Status Word 1; Bit; Number of times ON',
242  path=monCTPPath,xbins=24,xmin=-0.5,xmax=23.5,opt='kAlwaysCreate')
243  # CHECK( registerTH1("ctpStatus2", "CTP Status Word 2; Bit; Number of times ON", 24, -0.5, 23.5) );
244  myGroup.defineHistogram('ctpStatus2X;ctpStatus2', title='CTP Status Word 2; Bit; Number of times ON',
245  path=monCTPPath,xbins=24,xmin=-0.5,xmax=23.5,opt='kAlwaysCreate')
246  # CHECK( registerTH1("l1ItemsBPSimMismatch","Sim mismatch L1 Items before prescale", 512, 0, 512) );
247  myGroup.defineHistogram('l1ItemsBPSimMismatchX;l1ItemsBPSimMismatch', title='Sim mismatch L1 Items before prescale',
248  path=monCTPPath,xbins=512,xmin=0,xmax=512,opt='kAlwaysCreate')
249  # CHECK( registerTH1("l1ItemsBPSimMismatchItems","Sim mismatch L1 Items before prescale, mismatched ones only", 512, 0, 512) );
250  myGroup.defineHistogram('l1ItemsBPSimMismatchItemsX;l1ItemsBPSimMismatchItems', title='Sim mismatch L1 Items before prescale, mismatched ones only',
251  path=monCTPPath,xbins=512,xmin=0,xmax=512,opt='kAlwaysCreate')
252 
253 
254 
255 
256  monMUCTPIPath="/MUCTPI/"
257  # CHECK( registerTH1("nCandidates", "Number of MuCTPI candidates from mult word; Multiplicity; Entries", 11, -0.5, 10.5) );
258  myGroup.defineHistogram('nCandidatesX;nCandidates', title='Number of MuCTPI candidates from mult word; Multiplicity; Entries',
259  path=monMUCTPIPath,xbins=11,xmin=-0.5,xmax=10.5,opt='kAlwaysCreate')
260  # CHECK( registerTH1("nCandidatesDataWord", "Number of MuCTPI candidates from data word; Multiplicity; Entries", 100, -0.5, 99.5) );
261  myGroup.defineHistogram('nCandidatesDataWordX;nCandidatesDataWord', title='Number of MuCTPI candidates from data word; Multiplicity; Entries',
262  path=monMUCTPIPath,xbins=100,xmin=-0.5,xmax=99.5,opt='kAlwaysCreate')
263  # CHECK( registerTH1("pt", "Candidate p_{T} distribution from mult word; p_{T} threshold; Entries", 6, 0.5, 6.5) );
264  myGroup.defineHistogram('ptX;pt', title='Candidate p_{T} distribution from mult word; p_{T} threshold; Entries',
265  path=monMUCTPIPath,xbins=6,xmin=0.5,xmax=6.5,opt='kAlwaysCreate')
266  # CHECK( registerTH2("nCandidatesPt", "Number of MuCTPI candidates from mult word vs p_{T}; p_{T} threshold; MuCTPI candidates", 6, 0.5, 6.5, 8, -0.5, 7.5) );
267  myGroup.defineHistogram('nCandidatesPtX,nCandidatesPtY;nCandidatesPt', title='Number of MuCTPI candidates from mult word vs p_{T}; p_{T} threshold; MuCTPI candidates',
268  type='TH2F',path=monMUCTPIPath,xbins=6,xmin=0.5,xmax=6.5,ybins=8,ymin=-0.5,ymax=7.5,opt='kAlwaysCreate')
269  # CHECK( registerTH2("nCandidatesDataWordPt", "Number of MuCTPI candidates from data word vs p_{T}; p_{T} threshold; MuCTPI candidates", 6, 0.5, 6.5, 25, -0.5, 99.5) );
270  myGroup.defineHistogram('nCandidatesDataWordPtX,nCandidatesDataWordPtY;nCandidatesDataWordPt', title='Number of MuCTPI candidates from data word vs p_{T}; p_{T} threshold; MuCTPI candidates',
271  type='TH2F',path=monMUCTPIPath,xbins=6,xmin=0.5,xmax=6.5,ybins=8,ymin=-0.5,ymax=7.5,opt='kAlwaysCreate')
272  # CHECK( registerTH1("nCandidatesMictpMioct", "Diff between MICTP and MIOCT candidates (same BC); MICTP - MIOCT; Entries", 21, -10.5, 10.5) );
273  myGroup.defineHistogram('nCandidatesMictpMioctX;nCandidatesMictpMioct', title='Diff between MICTP and MIOCT candidates (same BC); MICTP - MIOCT; Entries',
274  path=monMUCTPIPath,xbins=21,xmin=-10.5,xmax=12.5,opt='kAlwaysCreate')
275  # CHECK( registerTH1("bcidMictpMioct", "BCID diff between MICTP and all MIOCT candidate words; MIOCT - MICTP; Entries", 8, -3.5, 4.5) );
276  myGroup.defineHistogram('bcidMictpMioctX;bcidMictpMioct', title='BCID diff between MICTP and all MIOCT candidate words; MIOCT - MICTP; Entries',
277  path=monMUCTPIPath,xbins=8,xmin=-3.5,xmax=4.5,opt='kAlwaysCreate')
278  # CHECK( registerTH1("bcidMictpHeader", "BCID Diff between MICTP and ROD header; MICTP - ROD header; Entries", 15, -7.5, 7.5) );
279  #myGroup.defineHistogram('bcidMictpHeaderX;bcidMictpHeader', title='BCID Diff between MICTP and ROD header; MICTP - ROD header; Entries',
280  # path=monMUCTPIPath,xbins=15,xmin=-7.5,xmax=7.5,opt='kAlwaysCreate')
281  # CHECK( registerTH1("muctpiStatus1", "MuCTPI Status Word 1; Bit; Number of times ON", 24, -0.5, 23.5) );
282  #myGroup.defineHistogram('muctpiStatus1X;muctpiStatus1', title='MuCTPI Status Word 1; Bit; Number of times ON',
283  # path=monMUCTPIPath,xbins=24,xmin=-0.5,xmax=23.5,opt='kAlwaysCreate')
284  # CHECK( registerTH1("muctpiStatus2", "MuCTPI Status Word 2; Bit; Number of times ON", 24, -0.5, 23.5) );
285  #myGroup.defineHistogram('muctpiStatus2X;muctpiStatus2', title='MuCTPI Status Word 2; Bit; Number of times ON',
286  # path=monMUCTPIPath,xbins=24,xmin=-0.5,xmax=23.5,opt='kAlwaysCreate')
287 
288  # //RoI numbers
289  # CHECK( registerTH2("barrelRoiSectorID", "MIOCT RoI Number vs Barrel Sector ID (Trigger BC); Sector ID; RoI Number", 64, -0.5, 63.5, 32, -0.5, 31.5) );
290  myGroup.defineHistogram('barrelRoiSectorIDX,barrelRoiSectorIDY;barrelRoiSectorID', title='MIOCT RoI Number vs Barrel Sector ID (Trigger BC); Sector ID; RoI Number',
291  type='TH2F',path=monMUCTPIPath,xbins=64,xmin=-0.5,xmax=63.5,ybins=32,ymin=-0.5,ymax=31.5,opt='kAlwaysCreate')
292  # CHECK( registerTH2("endcapRoiSectorID", "MIOCT RoI Number vs Endcap Sector ID (Trigger BC); Sector ID; RoI Number", 96, -0.5, 95.5, 32, -0.5, 31.5) );
293  myGroup.defineHistogram('endcapRoiSectorIDX,endcapRoiSectorIDY;endcapRoiSectorID', title='MIOCT RoI Number vs Endcap Sector ID (Trigger BC); Sector ID; RoI Number',
294  type='TH2F',path=monMUCTPIPath,xbins=96,xmin=-0.5,xmax=95.5,ybins=32,ymin=-0.5,ymax=31.5,opt='kAlwaysCreate')
295  # CHECK( registerTH2("forwardRoiSectorID", "MIOCT RoI Number vs Forward Sector ID (Trigger BC); Sector ID; RoI Number", 48, -0.5, 47.5, 32, -0.5, 31.5) );
296  myGroup.defineHistogram('forwardRoiSectorIDX,forwardRoiSectorIDY;forwardRoiSectorID', title='MIOCT RoI Number vs Forward Sector ID (Trigger BC); Sector ID; RoI Number',
297  type='TH2F',path=monMUCTPIPath,xbins=48,xmin=-0.5,xmax=47.5,ybins=32,ymin=-0.5,ymax=31.5,opt='kAlwaysCreate')
298  # CHECK( registerTH2("barrelRoiSectorIDAll", "MIOCT RoI Number vs Barrel Sector ID (All BC); Sector ID; RoI Number", 64, -0.5, 63.5, 32, -0.5, 31.5) );
299  myGroup.defineHistogram('barrelRoiSectorIDAllX,barrelRoiSectorIDAllY;barrelRoiSectorIDAll', title='MIOCT RoI Number vs Barrel Sector ID (All BC); Sector ID; RoI Number',
300  type='TH2F',path=monMUCTPIPath,xbins=64,xmin=-0.5,xmax=63.5,ybins=32,ymin=-0.5,ymax=31.5,opt='kAlwaysCreate')
301  # CHECK( registerTH2("endcapRoiSectorIDAll", "MIOCT RoI Number vs Endcap Sector ID (All BC); Sector ID; RoI Number", 96, -0.5, 95.5, 32, -0.5, 31.5) );
302  myGroup.defineHistogram('endcapRoiSectorIDAllX,endcapRoiSectorIDAllY;endcapRoiSectorIDAll', title='MIOCT RoI Number vs Endcap Sector ID (All BC); Sector ID; RoI Number',
303  type='TH2F',path=monMUCTPIPath,xbins=96,xmin=-0.5,xmax=95.5,ybins=32,ymin=-0.5,ymax=31.5,opt='kAlwaysCreate')
304  # CHECK( registerTH2("forwardRoiSectorIDAll", "MIOCT RoI Number vs Forward Sector ID (All BC); Sector ID; RoI Number", 48, -0.5, 47.5, 32, -0.5, 31.5) );
305  myGroup.defineHistogram('forwardRoiSectorIDAllX,forwardRoiSectorIDAllY;forwardRoiSectorIDAll', title='MIOCT RoI Number vs Forward Sector ID (All BC); Sector ID; RoI Number',
306  type='TH2F',path=monMUCTPIPath,xbins=48,xmin=-0.5,xmax=47.5,ybins=32,ymin=-0.5,ymax=31.5,opt='kAlwaysCreate')
307 
308  # //Candidate multiplicity within sectors
309  # CHECK( registerTH2("barrelNCandSectorID", "MIOCT Candidate mult vs Sector ID (barrel); Sector ID; Candidates", 64, -0.5, 63.5, 8, -0.5, 7.5) );
310  myGroup.defineHistogram('barrelNCandSectorIDX,barrelNCandSectorIDY;barrelNCandSectorID', title='MIOCT Candidate mult vs Sector ID (barrel); Sector ID; Candidates',
311  type='TH2F',path=monMUCTPIPath,xbins=64,xmin=-0.5,xmax=63.5,ybins=8,ymin=-0.5,ymax=7.5,opt='kAlwaysCreate')
312  # CHECK( registerTH2("endcapNCandSectorID", "MIOCT Candidate mult vs Sector ID (endcap); Sector ID; Candidates", 96, -0.5, 95.5, 8, -0.5, 7.5) );
313  myGroup.defineHistogram('endcapNCandSectorIDX,endcapNCandSectorIDY;endcapNCandSectorID', title='MIOCT Candidate mult vs Sector ID (endcap); Sector ID; Candidates',
314  type='TH2F',path=monMUCTPIPath,xbins=96,xmin=-0.5,xmax=95.5,ybins=8,ymin=-0.5,ymax=7.5,opt='kAlwaysCreate')
315  # CHECK( registerTH2("forwardNCandSectorID", "MIOCT Candidate mult vs Sector ID (forward); Sector ID; Candidates", 48, -0.5, 47.5, 8, -0.5, 7.5) );
316  myGroup.defineHistogram('forwardNCandSectorIDX,forwardNCandSectorIDY;forwardNCandSectorID', title='MIOCT Candidate mult vs Sector ID (forward); Sector ID; Candidates',
317  type='TH2F',path=monMUCTPIPath,xbins=48,xmin=-0.5,xmax=47.5,ybins=8,ymin=-0.5,ymax=7.5,opt='kAlwaysCreate')
318 
319  # //Overlap regions
320  # CHECK( registerTH2("barrelSectorIDOverlapBits", "Barrel Sector ID vs overlap bits; Sector ID; Overlap bits", 64, -0.5, 63.5, 3, 0.5, 3.5) );
321  myGroup.defineHistogram('barrelSectorIDOverlapBitsX,barrelSectorIDOverlapBitsY;barrelSectorIDOverlapBits', title='Barrel Sector ID vs overlap bits; Sector ID; Overlap bits',
322  type='TH2F',path=monMUCTPIPath,xbins=64,xmin=-0.5,xmax=63.5,ybins=3,ymin=0.5,ymax=3.5,opt='kAlwaysCreate')
323  # CHECK( registerTH1("endcapSectorIDOverlapBit", "Endcap Sector ID vs number of candidates with overlap; Sector ID; Candidates", 48, -0.5, 47.5) );
324  myGroup.defineHistogram('endcapSectorIDOverlapBitX;endcapSectorIDOverlapBit', title='Endcap Sector ID vs number of candidates with overlap; Sector ID; Candidates',
325  path=monMUCTPIPath,xbins=48,xmin=-0.5,xmax=47.5,opt='kAlwaysCreate')
326 
327  # //Sector occupancy
328  # CHECK( registerTH1("barrelSectorID", "Barrel Sector ID (Trigger BC); Sector ID; Candidates", 64, -0.5, 63.5) );
329  myGroup.defineHistogram('barrelSectorIDX;barrelSectorID', title='Barrel Sector ID (Trigger BC); Sector ID; Candidates',
330  path=monMUCTPIPath,xbins=64,xmin=-0.5,xmax=63.5,opt='kAlwaysCreate')
331  # CHECK( registerTH1("endcapSectorID", "Endcap Sector ID (Trigger BC); Sector ID; Candidates", 96, -0.5, 95.5) );
332  myGroup.defineHistogram('endcapSectorIDX;endcapSectorID', title='Endcap Sector ID (Trigger BC); Sector ID; Candidates',
333  path=monMUCTPIPath,xbins=96,xmin=-0.5,xmax=95.5,opt='kAlwaysCreate')
334  # CHECK( registerTH1("forwardSectorID", "Forward Sector ID (Trigger BC); Sector ID; Candidates", 48, -0.5, 47.5) );
335  myGroup.defineHistogram('forwardSectorIDX;forwardSectorID', title='Forward Sector ID (Trigger BC); Sector ID; Candidates',
336  path=monMUCTPIPath,xbins=48,xmin=-0.5,xmax=47.5,opt='kAlwaysCreate')
337  # CHECK( registerTH1("barrelSectorIDAll", "Barrel Sector ID (All BC); Sector ID; Candidates", 64, -0.5, 63.5) );
338  myGroup.defineHistogram('barrelSectorIDAllX;barrelSectorIDAll', title='Barrel Sector ID (All BC); Sector ID; Candidates',
339  path=monMUCTPIPath,xbins=64,xmin=-0.5,xmax=63.5,opt='kAlwaysCreate')
340  # CHECK( registerTH1("endcapSectorIDAll", "Endcap Sector ID (All BC); Sector ID; Candidates", 96, -0.5, 95.5) );
341  myGroup.defineHistogram('endcapSectorIDAllX;endcapSectorIDAll', title='Endcap Sector ID (All BC); Sector ID; Candidates',
342  path=monMUCTPIPath,xbins=96,xmin=-0.5,xmax=95.5,opt='kAlwaysCreate')
343  # CHECK( registerTH1("forwardSectorIDAll", "Forward Sector ID (All BC); Sector ID; Candidates", 48, -0.5, 47.5) );
344  myGroup.defineHistogram('forwardSectorIDAllX;forwardSectorIDAll', title='Forward Sector ID (All BC); Sector ID; Candidates',
345  path=monMUCTPIPath,xbins=48,xmin=-0.5,xmax=47.5,opt='kAlwaysCreate')
346 
347  # //Candidate word pT
348  # CHECK( registerTH1("barrelPt", "Barrel candidate p_{T} (all candidates); p_{T} threshold; Candidates", 6, 0.5, 6.5) );
349  myGroup.defineHistogram('barrelPtX;barrelPt', title='Barrel candidate p_{T} (all candidates); p_{T} threshold; Candidates',
350  path=monMUCTPIPath,xbins=6,xmin=0.5,xmax=6.5,opt='kAlwaysCreate')
351  # CHECK( registerTH1("endcapPt", "Endcap candidate p_{T} (all candidates); p_{T} threshold; Candidates", 6, 0.5, 6.5) );
352  myGroup.defineHistogram('endcapPtX;endcapPt', title='Endcap candidate p_{T} (all candidates); p_{T} threshold; Candidates',
353  path=monMUCTPIPath,xbins=6,xmin=0.5,xmax=6.5,opt='kAlwaysCreate')
354  # CHECK( registerTH1("forwardPt", "Forward candidate p_{T} (all candidates); p_{T} threshold; Candidates", 6, 0.5, 6.5) );
355  myGroup.defineHistogram('forwardPtX;forwardPt', title='Forward candidate p_{T} (all candidates); p_{T} threshold; Candidates',
356  path=monMUCTPIPath,xbins=6,xmin=0.5,xmax=6.5,opt='kAlwaysCreate')
357  nCandidates_secLocBinabels = [
358  "Barrel",
359  "Endcap",
360  "Forward"
361  ]
362  # //Number of candidates in each region
363  # CHECK( registerTH1("nCandidates_secLoc", "All candidates by sector location; Sector location; Candidates", 3, -0.5, 2.5) );
364  myGroup.defineHistogram('nCandidates_secLocX;nCandidates_secLoc', title='"All candidates by sector location; Sector location; Candidates',
365  path=monMUCTPIPath,xbins=3,xmin=-0.5,xmax=2.5,xlabels=nCandidates_secLocBinabels,opt='kAlwaysCreate')
366  #
367  # //Plots for comparing MuCTPI output to output of RPC and TGC SL
368  # CHECK( registerTH2("muctpiNoRPCCandfound", "MuCTPI BA candidate with no equivalent candidate in RPC SL r/o, Sector ID vs. RoI number", 30, -0.5, 29.5, 64, -0.5, 63.5) );
369  myGroup.defineHistogram('muctpiNoRPCCandfoundX,muctpiNoRPCCandfoundY;muctpiNoRPCCandfound', title='MuCTPI BA candidate with no equivalent candidate in RPC SL r/o, Sector ID vs. RoI number',
370  type='TH2F',path=monMUCTPIPath,xbins=30,xmin=-0.5,xmax=29.5,ybins=64,ymin=-0.5,ymax=63.5,opt='kAlwaysCreate')
371  # CHECK( registerTH2("rpcNoMuCTPICandfound", "RPC SL r/o candidate with no equivalent candidate in MuCTPI r/o, Sector ID vs. RoI number", 30, -0.5, 29.5, 64, -0.5, 63.5) );
372  myGroup.defineHistogram('rpcNoMuCTPICandfoundX,rpcNoMuCTPICandfoundY;rpcNoMuCTPICandfound', title='RPC SL r/o candidate with no equivalent candidate in MuCTPI r/o, Sector ID vs. RoI number',
373  type='TH2F',path=monMUCTPIPath,xbins=30,xmin=-0.5,xmax=29.5,ybins=64,ymin=-0.5,ymax=63.5,opt='kAlwaysCreate')
374  #
375  # CHECK( registerTH2("muctpiNoTGCecCandfound", "MuCTPI EC candidate with no equivalent candidate in TGC SL r/o, Sector ID vs. RoI number", 150, -0.5, 149.5, 100, -0.5, 99.5) );
376  myGroup.defineHistogram('muctpiNoTGCecCandfoundX,muctpiNoTGCecCandfoundY;muctpiNoTGCecCandfound', title='MuCTPI EC candidate with no equivalent candidate in TGC SL r/o, Sector ID vs. RoI number',
377  type='TH2F',path=monMUCTPIPath,xbins=150,xmin=-0.5,xmax=149.5,ybins=100,ymin=-0.5,ymax=99.5,opt='kAlwaysCreate')
378  # CHECK( registerTH2("tgcecNoMuCTPICandfound", "TGC EC SL r/o candidate with no equivalent candidate in MuCTPI r/o, Sector ID vs. RoI number", 150, -0.5, 149.5, 100, -0.5, 99.5) );
379  myGroup.defineHistogram('tgcecNoMuCTPICandfoundX,tgcecNoMuCTPICandfoundY;tgcecNoMuCTPICandfound', title='TGC EC SL r/o candidate with no equivalent candidate in MuCTPI r/o, Sector ID vs. RoI number',
380  type='TH2F',path=monMUCTPIPath,xbins=150,xmin=-0.5,xmax=149.5,ybins=100,ymin=-0.5,ymax=99.5,opt='kAlwaysCreate')
381  # CHECK( registerTH2("muctpiNoTGCfwCandfound", "MuCTPI FW candidate with no equivalent candidate in TGC SL r/o, Sector ID vs. RoI number", 64, -0.5, 63.5, 50, -0.5, 49.5) );
382  myGroup.defineHistogram('muctpiNoTGCfwCandfoundX,muctpiNoTGCfwCandfoundY;muctpiNoTGCfwCandfound', title='MuCTPI FW candidate with no equivalent candidate in TGC SL r/o, Sector ID vs. RoI number',
383  type='TH2F',path=monMUCTPIPath,xbins=150,xmin=-0.5,xmax=149.5,ybins=100,ymin=-0.5,ymax=99.5,opt='kAlwaysCreate')
384  # CHECK( registerTH2("tgcfwNoMuCTPICandfound", "TGC FW SL r/o candidate with no equivalent candidate in MuCTPI r/o, Sector ID vs. RoI number", 64, -0.5, 63.5, 50, -0.5, 49.5) );
385  myGroup.defineHistogram('tgcfwNoMuCTPICandfoundX,tgcfwNoMuCTPICandfoundY;tgcfwNoMuCTPICandfound', title='TGC FW SL r/o candidate with no equivalent candidate in MuCTPI r/o, Sector ID vs. RoI number',
386  type='TH2F',path=monMUCTPIPath,xbins=150,xmin=-0.5,xmax=149.5,ybins=100,ymin=-0.5,ymax=99.5,opt='kAlwaysCreate')
387 
388  monCTPMUCTPIPath="/CTPMUCTPI/"
389  # CHECK( registerTH1("headerL1IdDifference", "ROD header LVL1 ID CTP - MuCTPI; #DeltaL1ID; Entries", 101, -50.5, 50.5) );
390  myGroup.defineHistogram('headerL1IdDifferenceX;headerL1IdDifference', title='ROD header LVL1 ID CTP - MuCTPI; #DeltaL1ID; Entries',
391  path=monCTPMUCTPIPath,xbins=101,xmin=-50.5,xmax=50.5,opt='kAlwaysCreate')
392  # CHECK( registerTH1("headerBCIDDifference", "ROD header BCID CTP - MuCTPI; #DeltaBCID; Entries", 401, -200.5, 200.5) );
393  myGroup.defineHistogram('headerBCIDDifferenceX;headerBCIDDifference', title='ROD header BCID CTP - MuCTPI; #DeltaBCID; Entries',
394  path=monCTPMUCTPIPath,xbins=401,xmin=-200.5,xmax=200.5,opt='kAlwaysCreate')
395  # CHECK( registerTH1("bcidDifference", "BCID CTP - MICTP; #DeltaBCID; Entries", 15, -7.5, 7.5) );
396  myGroup.defineHistogram('bcidDifferenceX;bcidDifference', title='BCID CTP - MICTP; #DeltaBCID; Entries',
397  path=monCTPMUCTPIPath,xbins=15,xmin=-7.5,xmax=7.5,opt='kAlwaysCreate')
398 
399  monROIPath="/ROI/"
400  #keeping histo definitions for now commented. May re-include in upcoming update
401  # //RoI eta / phi
402  # CHECK( registerTH2("roiEtaPhi","Coordinates of all RoIs; #eta; #phi",32,-2.5,2.5,32,-TMath::Pi(),TMath::Pi()) );
403  #myGroup.defineHistogram('roiEtaPhiX,roiEtaPhiY;roiEtaPhi', title='Coordinates of all RoIs; #eta; #phi',
404  # type='TH2F',path=monROIPath,xbins=32,xmin=-2.5,xmax=2.5,ybins=32,ymin=-math.pi,ymax=math.pi,opt='kAlwaysCreate')
405  # CHECK( registerTH1("roiEta","#eta of all RoI's; #eta; Entries",32,-2.5,2.5) );
406  #myGroup.defineHistogram('roiEtaX;roiEta', title="#eta of all RoI's; #eta; Entries",
407  # path=monROIPath,xbins=32,xmin=-2.5,xmax=2.5,opt='kAlwaysCreate')
408  # CHECK( registerTH1("roiPhi","#phi of all RoI's; #phi; Entries",32,-TMath::Pi(),TMath::Pi()) );
409  #myGroup.defineHistogram('roiPhiX;roiPhi', title="#phi of all RoI's; #phi; Entries",
410  # path=monROIPath,xbins=32,xmin=-math.pi,xmax=math.pi,opt='kAlwaysCreate')
411  #
412  # //Sector vs. RoI
413  # CHECK( registerTH2("barrelSectorIDRoi","Sector ID vs. RoI for barrel muons (matched cand only); Sector ID; RoI", 64,-0.5,63.5,32,-0.5,31.5) );
414  myGroup.defineHistogram('barrelSectorIDRoiX,barrelSectorIDRoiY;barrelSectorIDRoi', title='Sector ID vs. RoI for barrel muons (matched cand only); Sector ID; RoI',
415  type='TH2F',path=monROIPath,xbins=64,xmin=-0.5,xmax=63.5,ybins=32,ymin=-0.5,ymax=31.5,opt='kAlwaysCreate')
416  # CHECK( registerTH2("endcapSectorIDRoi","Sector ID vs. RoI for endcap muons (matched cand only); Sector ID; RoI", 96,-0.5,95.5,32,-0.5,31.5) );
417  myGroup.defineHistogram('endcapSectorIDRoiX,endcapSectorIDRoiY;endcapSectorIDRoi', title='Sector ID vs. RoI for endcap muons (matched cand only); Sector ID; RoI',
418  type='TH2F',path=monROIPath,xbins=96,xmin=-0.5,xmax=95.5,ybins=32,ymin=-0.5,ymax=31.5,opt='kAlwaysCreate')
419  # CHECK( registerTH2("forwardSectorIDRoi","Sector ID vs. RoI for forward muons (matched cand only); Sector ID; RoI", 48,-0.5,47.5,32,-0.5,31.5) );
420  myGroup.defineHistogram('forwardSectorIDRoiX,forwardSectorIDRoiY;forwardSectorIDRoi', title='Sector ID vs. RoI for forward muons (matched cand only); Sector ID; RoI',
421  type='TH2F',path=monROIPath,xbins=48,xmin=-0.5,xmax=47.5,ybins=32,ymin=-0.5,ymax=31.5,opt='kAlwaysCreate')
422  #
423  # //Sector vs. RoI Eta
424  # CHECK( registerTH2("barrelSectorIDRoiEta","Sector ID vs. RoI #eta for barrel muons (matched cand only); Sector ID; #eta", 64,-0.5,63.5,32,-2.5,2.5) );
425  #myGroup.defineHistogram('barrelSectorIDRoiEtaX,barrelSectorIDRoiEtaY;barrelSectorIDRoiEta', title='Sector ID vs. RoI #eta for barrel muons (matched cand only); Sector ID; #eta',
426  # type='TH2F',path=monROIPath,xbins=64,xmin=-0.5,xmax=63.5,ybins=32,ymin=-0.5,ymax=31.5,opt='kAlwaysCreate')
427  myGroup.defineHistogram('barrelSectorIDRoiEtaX;barrelSectorIDRoiEta', title='Sector ID for barrel muons (matched cand only); Sector ID',
428  path=monROIPath,xbins=64,xmin=-0.5,xmax=63.5,opt='kAlwaysCreate')
429  # CHECK( registerTH2("endcapSectorIDRoiEta","Sector ID vs. RoI #eta for endcap muons (matched cand only); Sector ID; #eta", 96,-0.5,95.5,32,-2.5,2.5) );
430  #myGroup.defineHistogram('endcapSectorIDRoiEtaX,endcapSectorIDRoiEtaY;endcapSectorIDRoiEta', title='Sector ID vs. RoI #eta for endcap muons (matched cand only); Sector ID; #eta',
431  # type='TH2F',path=monROIPath,xbins=96,xmin=-0.5,xmax=95.5,ybins=32,ymin=-0.5,ymax=31.5,opt='kAlwaysCreate')
432  myGroup.defineHistogram('endcapSectorIDRoiEtaX;endcapSectorIDRoiEta', title='Sector ID for endcap muons (matched cand only); Sector ID',
433  path=monROIPath,xbins=96,xmin=-0.5,xmax=95.5,opt='kAlwaysCreate')
434  # CHECK( registerTH2("forwardSectorIDRoiEta","Sector ID vs. RoI #eta for forward muons (matched cand only); Sector ID; #eta", 48,-0.5,47.5,32,-2.5,2.5) );
435  #myGroup.defineHistogram('forwardSectorIDRoiEtaX,forwardSectorIDRoiEtaY;forwardSectorIDRoiEta', title='Sector ID vs. RoI #eta for forward muons (matched cand only); Sector ID; #eta',
436  # type='TH2F',path=monROIPath,xbins=48,xmin=-0.5,xmax=47.5,ybins=32,ymin=-0.5,ymax=31.5,opt='kAlwaysCreate')
437  myGroup.defineHistogram('forwardSectorIDRoiEtaX;forwardSectorIDRoiEta', title='Sector IDfor forward muons (matched cand only); Sector ID',
438  path=monROIPath,xbins=48,xmin=-0.5,xmax=47.5,opt='kAlwaysCreate')
439  #
440  # //Sector vs. RoI Phi
441  # CHECK( registerTH2("barrelSectorIDRoiPhi","Sector ID vs. RoI #phi for barrel (matched cand only); Sector ID; #phi", 64,-0.5,63.5,32,-TMath::Pi(),TMath::Pi()) );
442  #myGroup.defineHistogram('barrelSectorIDRoiPhiX,barrelSectorIDRoiPhiY;barrelSectorIDRoiPhi', title='Sector ID vs. RoI #phi for barrel (matched cand only); Sector ID; #phi',
443  # type='TH2F',path=monROIPath,xbins=64,xmin=-0.5,xmax=63.5,ybins=32,ymin=-math.pi,ymax=math.pi,opt='kAlwaysCreate')
444  myGroup.defineHistogram('barrelSectorIDRoiPhiX;barrelSectorIDRoiPhi', title='Sector ID for barrel (matched cand only); Sector ID',
445  path=monROIPath,xbins=64,xmin=-0.5,xmax=63.5,opt='kAlwaysCreate')
446  # CHECK( registerTH2("endcapSectorIDRoiPhi","Sector ID vs. RoI #phi for endcap (matched cand only); Sector ID; #phi", 96,-0.5,95.5,32,-TMath::Pi(),TMath::Pi()) );
447  #myGroup.defineHistogram('endcapSectorIDRoiPhiX,endcapSectorIDRoiPhiY;endcapSectorIDRoiPhi', title='Sector ID vs. RoI #phi for endcap (matched cand only); Sector ID; #phi',
448  # type='TH2F',path=monROIPath,xbins=96,xmin=-0.5,xmax=95.5,ybins=32,ymin=-math.pi,ymax=math.pi,opt='kAlwaysCreate')
449  myGroup.defineHistogram('endcapSectorIDRoiPhiX;endcapSectorIDRoiPhi', title='Sector ID for endcap (matched cand only); Sector ID',
450  path=monROIPath,xbins=96,xmin=-0.5,xmax=95.5,opt='kAlwaysCreate')
451  # CHECK( registerTH2("forwardSectorIDRoiPhi","Sector ID vs. RoI #phi for forward (matched cand only); Sector ID; #phi", 48,-0.5,47.5,32,-TMath::Pi(),TMath::Pi()) );
452  #myGroup.defineHistogram('forwardSectorIDRoiPhiX,forwardSectorIDRoiPhiY;forwardSectorIDRoiPhi', title='Sector ID vs. RoI #phi for forward (matched cand only); Sector ID; #phi',
453  # type='TH2F',path=monROIPath,xbins=48,xmin=-0.5,xmax=47.5,ybins=32,ymin=-math.pi,ymax=math.pi,opt='kAlwaysCreate')
454  myGroup.defineHistogram('forwardSectorIDRoiPhiX;forwardSectorIDRoiPhi', title='Sector ID for forward (matched cand only); Sector ID',
455  path=monROIPath,xbins=48,xmin=-0.5,xmax=47.5,opt='kAlwaysCreate')
456 
457  else: #=> is Run3 here below
458 
459  errorSummaryCTPBinLabels = [ # .cxx indices
460  "CTP/ROD BCID Offset", #1
461  "No BCs in Readout", #2
462  "Invalid Lumi Block", #3
463  "LB Out of Time", #4
464  "Nanosec > 1e9", #5
465  "TAP w/out TBP", #6
466  "TAV w/out TAP", #7
467  "CTP sim. mismatch", #8
468  "Incomplete fragment", #9
469  "Missing orbit pulse" #10
470  ]
471  incompleteFragmentTypeBinLabels = [
472  "CTP RIO",
473  "CTP RDO",
474  #"MuCTPI RIO",
475  "MuCTPI RDO",
476  "RoIBResult",
477  "TGC SL RDO",
478  "RPC SL RDO"
479  ]
480 
481  # ERRORS - COMMON
482 
483  # 1d
484  # CHECK( registerTH1("errorPerLumiBlock", "Number of errors per lumi block; LB number; Errors", 2001, -0.5, 2000.5) );
485  myGroup.defineHistogram('errorPerLumiBlockCTPX;errorPerLumiBlock', title='Number of errors per lumi block; LB number; Errors',
486  path='',xbins=2001,xmin=-0.5,xmax=2000.5,opt='kAlwaysCreate')
487 
488  # -------------------- CTP
489 
490  monPath="/CTP/"
491  myGroup.defineHistogram('errorSummaryCTPX,errorSummaryCTPY;errorSummaryCTP',title='CTP errors; ; Error ratio', type='TProfile', path=monPath, xbins=len(errorSummaryCTPBinLabels), xmin=0.5, xmax=len(errorSummaryCTPBinLabels)+0.5, ymin=-1., ymax=2., xlabels=errorSummaryCTPBinLabels, opt='kAlwaysCreate')
492  myGroup.defineHistogram('errorSummaryPerLumiBlockCTPX,errorSummaryPerLumiBlockCTPY;errorSummaryPerLumiBlockCTP',title='Errors per lumi block; LB number; Errors', type='TH2F', path=monPath, xbins=2000, xmin=0.5, xmax=2000.5, ybins=len(errorSummaryCTPBinLabels), ymin=0.5, ymax=len(errorSummaryCTPBinLabels)+0.5, ylabels=errorSummaryCTPBinLabels, opt='kAlwaysCreate')
493  myGroup.defineHistogram('incompleteFragmentTypeX;incompleteFragmentType', title='Number of missing fragments per type; Fragment type; Number of incomplete fragments ', path=monPath, xbins=7, xmin=-0.5, xmax=7.5, xlabels=incompleteFragmentTypeBinLabels, opt='kAlwaysCreate')
494  myGroup.defineHistogram('deltaBcidX;deltaBcid', title='CTP Data BCID - ROD Header BCID; #DeltaBCID; Entries',
495  path=monPath,xbins=401,xmin=-200.5,xmax=200.5,opt='kAlwaysCreate')
496  myGroup.defineHistogram('triggerTypeX;triggerType', title='Trigger Type; Trigger Type; Entries',
497  path=monPath,xbins=256,xmin=-0.5,xmax=255.5,opt='kAlwaysCreate')
498  myGroup.defineHistogram('timeSinceLBStartX;timeSinceLBStart', title='Time Since LB Start; Time After New LB (ms); Entries',
499  path=monPath,xbins=1000,xmin=-500,xmax=1500,opt='kAlwaysCreate')
500  myGroup.defineHistogram('timeUntilLBEndX;timeUntilLBEnd', title='Time Until LB End; Time Until Next LB (ms); Entries',
501  path=monPath,xbins=1000,xmin=-500,xmax=1500,opt='kAlwaysCreate')
502  myGroup.defineHistogram('timeSinceL1AX;timeSinceL1A', title='Time since last L1A; Time since last L1A (ms); Entries',
503  path=monPath,xbins=2000,xmin=-1,xmax=30,opt='kAlwaysCreate')
504  myGroup.defineHistogram('turnCounterTimeErrorX;turnCounterTimeError', title='Error of time based on turn counter and BCID; t_{TC+BCID}-t_{GPS} [#mus]; Entries',
505  path=monPath,xbins=2000,xmin=-1000.,xmax=1000.,opt='kAlwaysCreate')
506  #patrick check how this one now looks and used to look! - compare to error Profile!
507  myGroup.defineHistogram('turnCounterTimeErrorVsLbX,turnCounterTimeErrorVsLbY,turnCounterTimeErrorVsLbZ;turnCounterTimeErrorVsLb',
508  title='Error of (TC+BCID)-based time vs. LB; LB; t_{TC+BCID}-t_{GPS} [#mus]',
509  type='TProfile2D', path=monPath, xbins=2001, ybins=2001, xmin=-0.5, xmax=2000.5, ymin=-1000., ymax=1000, opt='kAlwaysCreate')
510  myGroup.defineHistogram('pitBCX,pitBCY;pitBC',title='CTP BC vs. PIT; PIT; BC',
511  type='TH2F',path=monPath, xbins=320,xmin=-0.5,xmax=319.5,ybins=127,ymin=-63.5,ymax=63.5,opt='kAlwaysCreate')
512  myGroup.defineHistogram('pitFirstBCX,pitFirstBCY;pitFirstBC',title='First CTP BC vs. PIT; PIT; BC',
513  type='TH2F',path=monPath, xbins=320,xmin=-0.5,xmax=319.5,ybins=127,ymin=-63.5,ymax=63.5,opt='kAlwaysCreate')
514  myGroup.defineHistogram('tavX;tav', title='Trigger Items After Veto; CTP TAV; Entries',
515  path=monPath,xbins=512,xmin=-0.5,xmax=511.5,opt='kAlwaysCreate')
516  myGroup.defineHistogram('ctpStatus1X;ctpStatus1', title='CTP Status Word 1; Bit; Number of times ON',
517  path=monPath,xbins=24,xmin=-0.5,xmax=23.5,opt='kAlwaysCreate')
518  myGroup.defineHistogram('ctpStatus2X;ctpStatus2', title='CTP Status Word 2; Bit; Number of times ON',
519  path=monPath,xbins=24,xmin=-0.5,xmax=23.5,opt='kAlwaysCreate')
520  myGroup.defineHistogram('l1ItemsBPSimMismatchX;l1ItemsBPSimMismatch', title='Sim mismatch L1 Items before prescale',
521  path=monPath,xbins=512,xmin=0,xmax=512,opt='kAlwaysCreate')
522  myGroup.defineHistogram('l1ItemsBPSimMismatchItemsX;l1ItemsBPSimMismatchItems', title='Sim mismatch L1 Items before prescale, mismatched ones only', path=monPath,xbins=512,xmin=0,xmax=512,opt='kAlwaysCreate')
523 
524  errorSummaryMUCTPIBinLabels = [ #cxx indices
525  "Event - MuCTPI BCID Mismatch", #1
526  "Wrong Cand Word Number", #2
527  "Wrong TOB Word Number", #3
528  "Unequal Cand - TOB Number", #4
529  "Mismatch (Eta,Phi) Cand - TOB", #5
530  "Incomplete fragment", #6
531  "MuCTPI/noRPC candidate mismatch", #7
532  "MuCTPI/noTGC candidate mismatch", #8
533  "RPC/noMuCTPI candidate mismatch", #9
534  "TGC/noMuCTPI candidate mismatch" #10
535  ]
536 
537  statusDataWordMUCTPIBinLabels = [ #cxx indices - ROD format indices
538  "Event# mismatch (MSPA vs TRP) (central)", #1 #0
539  "Event# mismatch (MSPC vs TRP) (central)", #2 #1
540  "Event# mismatch (MSPA vs MSPC)" , #3 #2
541  "BCID mismatch (TRP vs MSPA) (central)" , #4 #3
542  "BCID mismatch (TRP vs MSPC) (central)" , #5 #4
543  "BCID mismatch (MSPA vs MSPC)" , #6 #5
544  "MSPA multiplicity LVDS link CRC error" , #7 #6
545  "MSPC multiplicity LVDS link CRC error" , #8 #7
546  "SL error flag on any MSPA sector" , #9 #8
547  "SL error flag on any MSPC sector" , #10 #9
548  "Error flag in muon cand after ZS" , #11 #10
549  "CRC error on MSPA DAQ link" , #12 #11
550  "CRC error on MSPC DAQ link" , #13 #12
551  "TriggerType reception timeout error" , #14 #13
552  "MSPA DAQ link input FIFO full flag" , #15 #14
553  "MSPC DAQ link input FIFO full flag" #16 #15
554  ]
555 
556  monPath="/MUCTPI/"
557  from TrigT1CTMonitoring.BSMonDefinitions import barrelEtaLowBinEdges
558  from TrigT1CTMonitoring.BSMonDefinitions import barrelPhiLowBinEdges
559  from TrigT1CTMonitoring.BSMonDefinitions import endcapEtaLowBinEdges
560  from TrigT1CTMonitoring.BSMonDefinitions import endcapPhiLowBinEdges
561  from TrigT1CTMonitoring.BSMonDefinitions import forwardEtaLowBinEdges
562  from TrigT1CTMonitoring.BSMonDefinitions import forwardPhiLowBinEdges
563  from TrigT1CTMonitoring.BSMonDefinitions import candidateWordsPerTimeslice
564  from TrigT1CTMonitoring.BSMonDefinitions import tobWordsPerTimeslice
565  #from TrigT1CTMonitoring.BSMonDefinitions import muctpiErrorBins
566  # TODO: import a vector for the 15 pt indexes
567 
568  #general errors, defined in this code
569  myGroup.defineHistogram('errorSummaryMUCTPI',title='MUCTPI errors;', type='TH1I', path=monPath, xbins=len(errorSummaryMUCTPIBinLabels), xmin=0.5, xmax=0.5+len(errorSummaryMUCTPIBinLabels), xlabels=errorSummaryMUCTPIBinLabels, opt='kAlwaysCreate')
570  myGroup.defineHistogram('errorSummaryPerLumiBlockMUCTPIX,errorSummaryPerLumiBlockMUCTPIY;errorSummaryPerLumiBlockMUCTPI',title='Errors per lumi block; LB number; Errors', type='TH2F', path=monPath, xbins=2000, xmin=0.5, xmax=2000.5, ybins=len(errorSummaryMUCTPIBinLabels), ymin=0.5, ymax=len(errorSummaryMUCTPIBinLabels)+0.5, ylabels=errorSummaryMUCTPIBinLabels, opt='kAlwaysCreate')
571  #error bits defined in the last word of the ROD fragment
572  myGroup.defineHistogram('statusDataWordMUCTPI',title='Status word bits;', type='TH1I', path=monPath, xbins=len(statusDataWordMUCTPIBinLabels), xmin=0.5, xmax=0.5+len(statusDataWordMUCTPIBinLabels), xlabels=statusDataWordMUCTPIBinLabels, opt='kAlwaysCreate')
573  myGroup.defineHistogram('statusDataWordPerLumiBlockMUCTPIX,statusDataWordPerLumiBlockMUCTPIY;statusDataWordPerLumiBlockMUCTPI',title='Status word bits per lumi block; LB number; Errors', type='TH2F', path=monPath, xbins=2000, xmin=0.5, xmax=2000.5, ybins=len(statusDataWordMUCTPIBinLabels), ymin=0.5, ymax=len(statusDataWordMUCTPIBinLabels)+0.5, ylabels=statusDataWordMUCTPIBinLabels, opt='kAlwaysCreate')
574 
575  #mult
576  monPath="/MUCTPI/Mult"
577  myGroup.defineHistogram('multThrX;multThr',title='MLT thresholds total count;',type='TH1I',path=monPath,xbins=32,xmin=-0.5,xmax=31.5,opt='kAlwaysCreate')
578  myGroup.defineHistogram('multThrVsLBX,multThrVsLBY;multThrVsLB', title='MLT thresholds total count - per LB', type='TH2F',path=monPath,xbins=2000,xmin=0,xmax=2000,ybins=32,ymin=-0.5,ymax=31.5,opt='kAlwaysCreate')
579 
580  myGroup.defineHistogram('multBitsX;multBits', title='MLT bits total count', path=monPath,xbins=64,xmin=-0.5,xmax=63.5,opt='kAlwaysCreate')
581  myGroup.defineHistogram('multBitsVsLBX,multBitsVsLBY;multBitsVsLB', title='MLT bits total count - per LB', type='TH2F',path=monPath,xbins=2000,xmin=0,xmax=2000,ybins=64,ymin=-0.5,ymax=63.5,opt='kAlwaysCreate')
582 
583  #cand
584  monPath="/MUCTPI/Cand"
585  myGroup.defineHistogram('candPtBAX;candPtBA', title='BA cand pT;pT index;candidates', path=monPath,xbins=6, xmin=0.5, xmax=6.5, opt='kAlwaysCreate')
586  myGroup.defineHistogram('candPtECX;candPtEC', title='EC cand pT;pT index;candidates', path=monPath,xbins=15,xmin=0.5,xmax=15.5,opt='kAlwaysCreate')
587  myGroup.defineHistogram('candPtFWX;candPtFW', title='FW cand pT;pT index;candidates', path=monPath,xbins=15,xmin=0.5,xmax=15.5,opt='kAlwaysCreate')
588  myGroup.defineHistogram('candCount',title='Candidates distrib. per event (central slice);candidates',type='TH1I',path=monPath,xbins=candidateWordsPerTimeslice,opt='kAlwaysCreate')
589  myGroup.defineHistogram('candCountVsLBX,candCountVsLBY;candCountVsLB',title='Candidates distrib. per event (central slice) vs LB;LB;candidates',type='TH2I',path=monPath,xmin=0.5,xmax=2000.5,xbins=2000,ybins=candidateWordsPerTimeslice,opt='kAlwaysCreate')
590 
591  monPath="/MUCTPI/Cand/Expert"
592  myGroup.defineHistogram('candSLVsLBBAX,candSLVsLBBAY;candSLVsLBBA', title='BA cand SL vs LB;LB;BA sect. number', type='TH2F', path=monPath,xbins=2000,xmin=0.5,xmax=2000.5, ybins=64,ymin=-0.5,ymax=63.5 ,opt='kAlwaysCreate')
593  myGroup.defineHistogram('candSLVsLBECX,candSLVsLBECY;candSLVsLBEC', title='EC cand SL vs LB;LB;EC sect. number', type='TH2F', path=monPath,xbins=2000,xmin=0.5,xmax=2000.5, ybins=96,ymin=-0.5,ymax=95.5 ,opt='kAlwaysCreate')
594  myGroup.defineHistogram('candSLVsLBFWX,candSLVsLBFWY;candSLVsLBFW', title='FW cand SL vs LB;LB;FW sect. number', type='TH2F', path=monPath,xbins=2000,xmin=0.5,xmax=2000.5, ybins=48,ymin=-0.5,ymax=47.5 ,opt='kAlwaysCreate')
595  myGroup.defineHistogram('candVetoFlag_RoiVsSLBAX,candVetoFlag_RoiVsSLBAY;candVetoFlag_RoiVsSLBA', title='BA cand VetoFlag | RoI vs SL;BA sect. number;RoI', type='TH2F', path=monPath,xbins=64,xmin=-0.5,xmax=63.5,ybins=32,ymin=-0.5,ymax=31.5,opt='kAlwaysCreate')
596  myGroup.defineHistogram('candVetoFlag_RoiVsSLECX,candVetoFlag_RoiVsSLECY;candVetoFlag_RoiVsSLEC', title='EC cand VetoFlag | RoI vs SL;EC sect. number;RoI', type='TH2F', path=monPath,xbins=96,xmin=-0.5,xmax=95.5,ybins=148,ymin=-0.5,ymax=147.5,opt='kAlwaysCreate')
597  myGroup.defineHistogram('candVetoFlag_RoiVsSLFWX,candVetoFlag_RoiVsSLFWY;candVetoFlag_RoiVsSLFW', title='FW cand VetoFlag | RoI vs SL;FW sect. number;RoI', type='TH2F', path=monPath,xbins=48,xmin=-0.5,xmax=47.5,ybins=64,ymin=-0.5,ymax=63.5,opt='kAlwaysCreate')
598  myGroup.defineHistogram('candVetoFlag_EtaPhiBAX,candVetoFlag_EtaPhiBAY;candVetoFlag_EtaPhiBA', title='BA cand Overlap Veto Flag;Eta;Phi', type='TH2F', path=monPath, xbins=barrelEtaLowBinEdges, ybins=barrelPhiLowBinEdges, opt='kAlwaysCreate')
599  myGroup.defineHistogram('candVetoFlag_EtaPhiECX,candVetoFlag_EtaPhiECY;candVetoFlag_EtaPhiEC', title='EC cand Overlap Veto Flag;Eta;Phi', type='TH2F', path=monPath, xbins=endcapEtaLowBinEdges, ybins=endcapPhiLowBinEdges, opt='kAlwaysCreate')
600  myGroup.defineHistogram('candVetoFlag_EtaPhiFWX,candVetoFlag_EtaPhiFWY;candVetoFlag_EtaPhiFW', title='FW cand Overlap Veto Flag;Eta;Phi', type='TH2F', path=monPath, xbins=forwardEtaLowBinEdges, ybins=forwardPhiLowBinEdges, opt='kAlwaysCreate')
601  myGroup.defineHistogram('candRoiVsSLBACentralSliceX,candRoiVsSLBACentralSliceY;candRoiVsSLBACentralSlice', title='BA cand RoI vs SL (central slice);BA sect. number;RoI', type='TH2F', path=monPath,xbins=64,xmin=-0.5,xmax=63.5,ybins=32,ymin=-0.5,ymax=31.5,opt='kAlwaysCreate')
602  myGroup.defineHistogram('candRoiVsSLECCentralSliceX,candRoiVsSLECCentralSliceY;candRoiVsSLECCentralSlice', title='EC cand RoI vs SL (central slice);EC sect. number;RoI', type='TH2F', path=monPath,xbins=96,xmin=-0.5,xmax=95.5,ybins=148,ymin=-0.5,ymax=147.5,opt='kAlwaysCreate')
603  myGroup.defineHistogram('candRoiVsSLFWCentralSliceX,candRoiVsSLFWCentralSliceY;candRoiVsSLFWCentralSlice', title='FW cand RoI vs SL (central slice);FW sect. number;RoI', type='TH2F', path=monPath,xbins=48,xmin=-0.5,xmax=47.5,ybins=64,ymin=-0.5,ymax=63.5,opt='kAlwaysCreate')
604  myGroup.defineHistogram('candRoiVsSLBAOtherSliceX,candRoiVsSLBAOtherSliceY;candRoiVsSLBAOtherSlice', title='BA cand RoI vs SL (other slice);BA sect. number;RoI', type='TH2F', path=monPath,xbins=64,xmin=-0.5,xmax=63.5,ybins=32,ymin=-0.5,ymax=29.5,opt='kAlwaysCreate')
605  myGroup.defineHistogram('candRoiVsSLECOtherSliceX,candRoiVsSLECOtherSliceY;candRoiVsSLECOtherSlice', title='EC cand RoI vs SL (other slice);EC sect. number;RoI', type='TH2F', path=monPath,xbins=96,xmin=-0.5,xmax=95.5,ybins=148,ymin=-0.5,ymax=147.5,opt='kAlwaysCreate')
606  myGroup.defineHistogram('candRoiVsSLFWOtherSliceX,candRoiVsSLFWOtherSliceY;candRoiVsSLFWOtherSlice', title='FW cand RoI vs SL (other slice);FW sect. number;RoI', type='TH2F', path=monPath,xbins=48,xmin=-0.5,xmax=47.5,ybins=64,ymin=-0.5,ymax=63.5,opt='kAlwaysCreate')
607  myGroup.defineHistogram('candEtaPhi_PhiOverlapX_BA,candEtaPhi_PhiOverlapY_BA;candEtaPhi_PhiOverlap_BA',title='BA cand phi overlap;Eta;Phi', type='TH2F', path=monPath, xbins=barrelEtaLowBinEdges, ybins=barrelPhiLowBinEdges, opt='kAlwaysCreate')
608  myGroup.defineHistogram('candEtaPhi_Gt1CandRoiX_BA,candEtaPhi_Gt1CandRoiY_BA;candEtaPhi_Gt1CandRoi_BA',title='BA cand >1 in Roi;Eta;Phi', type='TH2F', path=monPath, xbins=barrelEtaLowBinEdges, ybins=barrelPhiLowBinEdges, opt='kAlwaysCreate')
609  myGroup.defineHistogram('candEtaPhi_SectorFlagGtNX_BA,candEtaPhi_SectorFlagGtNY_BA;candEtaPhi_SectorFlagGtN_BA',title=">2 cand in sector;Eta;Phi", type='TH2F',path=monPath, xbins=barrelEtaLowBinEdges, ybins=barrelPhiLowBinEdges, opt='kAlwaysCreate')
610  myGroup.defineHistogram('candEtaPhi_NSWMonFlagX_EC,candEtaPhi_NSWMonFlagY_EC;candEtaPhi_NSWMonFlag_EC',title='NSW monitoring flag EC;Eta;Phi',type='TH2F',path=monPath,xbins=endcapEtaLowBinEdges,ybins=endcapPhiLowBinEdges,opt='kAlwaysCreate')
611  myGroup.defineHistogram('candEtaPhi_NSWMonFlagX_FW,candEtaPhi_NSWMonFlagY_FW;candEtaPhi_NSWMonFlag_FW',title='NSW monitoring flag FW;Eta;Phi',type='TH2F',path=monPath,xbins=forwardEtaLowBinEdges,ybins=forwardPhiLowBinEdges,opt='kAlwaysCreate')
612  myGroup.defineHistogram('candEtaPhi_SectorFlagGtNX_EC,candEtaPhi_SectorFlagGtNY_EC;candEtaPhi_SectorFlagGtN_EC',title='>4 cand in EC sector;Eta;Phi',type='TH2F',path=monPath,xbins=endcapEtaLowBinEdges,ybins=endcapPhiLowBinEdges,opt='kAlwaysCreate')
613  myGroup.defineHistogram('candEtaPhi_SectorFlagGtNX_FW,candEtaPhi_SectorFlagGtNY_FW;candEtaPhi_SectorFlagGtN_FW',title='>4 cand in FW sector;Eta;Phi',type='TH2F',path=monPath,xbins=forwardEtaLowBinEdges,ybins=forwardPhiLowBinEdges,opt='kAlwaysCreate')
614 
615  candFlagsMUCTPIBinLabels_BA = [ #cxx indices
616  "> 1 cand. in the RoI" , #1
617  "phi overlap" , #2
618  ]
619  candFlagsMUCTPIBinLabels_ECFW = [ #cxx indices
620  "charge" , #1
621  "BW2/3" , #2
622  "InnerCoin" , #2
623  "GoodMF" , #2
624  ]
625  myGroup.defineHistogram('candCandFlagsVsSLBACentralSliceX,candCandFlagsVsSLBACentralSliceY;candCandFlagsVsSLBACentralSlice', title='BA cand CandFlags vs SL (central slice);BA sect. number', type='TH2F', path=monPath, xbins=64, xmin=-0.5,xmax=63.5, ybins=2, ymin=-0.5,ymax=1.5,ylabels=candFlagsMUCTPIBinLabels_BA,opt='kAlwaysCreate')
626  myGroup.defineHistogram('candCandFlagsVsSLECCentralSliceX,candCandFlagsVsSLECCentralSliceY;candCandFlagsVsSLECCentralSlice', title='EC cand CandFlags vs SL (central slice);EC sect. number', type='TH2F', path=monPath, xbins=96, xmin=-0.5,xmax=95.5, ybins=4, ymin=-0.5,ymax=3.5,ylabels=candFlagsMUCTPIBinLabels_ECFW,opt='kAlwaysCreate')
627  myGroup.defineHistogram('candCandFlagsVsSLFWCentralSliceX,candCandFlagsVsSLFWCentralSliceY;candCandFlagsVsSLFWCentralSlice', title='FW cand CandFlags vs SL (central slice);FW sect. number', type='TH2F', path=monPath, xbins=48,xmin=-0.5,xmax=47.5, ybins=4, ymin=-0.5,ymax=3.5,ylabels=candFlagsMUCTPIBinLabels_ECFW,opt='kAlwaysCreate')
628 
629  #sec err per LB (Central slice)
630  myGroup.defineHistogram('candErrorflagVsSLBACentralSlicePerLBX,candErrorflagVsSLBACentralSlicePerLBY;candErrorflagVsSLBACentralSlicePerLB', title='SL (BA) cand ErrorFlag vs LB (central slice)', type='TH2F', path=monPath,xbins=2000,xmin=0.5,xmax=2000.5,ybins=64,ymin=-0.5,ymax=63.5,opt='kAlwaysCreate')
631  myGroup.defineHistogram('candErrorflagVsSLECCentralSlicePerLBX,candErrorflagVsSLECentralSlicePerLBY;candErrorflagVsSLECCentralSlicePerLB', title='SL (EC) cand ErrorFlag vs LB (central slice)', type='TH2F', path=monPath,xbins=2000,xmin=0.5,xmax=2000.5,ybins=96,ymin=-0.5,ymax=95.5,opt='kAlwaysCreate')
632  myGroup.defineHistogram('candErrorflagVsSLFWCentralSlicePerLBX,candErrorflagVsSLFWCentralSlicePerLBY;candErrorflagVsSLFWCentralSlicePerLB', title='SL (FW) cand ErrorFlag vs LB (central slice)', type='TH2F', path=monPath,xbins=2000,xmin=0.5,xmax=2000.5,ybins=48,ymin=-0.5,ymax=47.5,opt='kAlwaysCreate')
633  #sec err per LB (Other slice)
634  myGroup.defineHistogram('candErrorflagVsSLBAOtherSlicePerLBX,candErrorflagVsSLBAOtherSlicePerLBY;candErrorflagVsSLBAOtherSlicePerLB', title='SL (BA) cand ErrorFlag vs LB (other slice)', type='TH2F', path=monPath,xbins=2000,xmin=0.5,xmax=2000.5,ybins=64,ymin=-0.5,ymax=63.5,opt='kAlwaysCreate')
635  myGroup.defineHistogram('candErrorflagVsSLECOtherSlicePerLBX,candErrorflagVsSLECOtherSlicePerLBY;candErrorflagVsSLECOtherSlicePerLB', title='SL (EC) cand ErrorFlag vs LB (other slice)', type='TH2F', path=monPath,xbins=2000,xmin=0.5,xmax=2000.5,ybins=96,ymin=-0.5,ymax=95.5,opt='kAlwaysCreate')
636  myGroup.defineHistogram('candErrorflagVsSLFWOtherSlicePerLBX,candErrorflagVsSLFWOtherSlicePerLBY;candErrorflagVsSLFWOtherSlicePerLB', title='SL (FW) cand ErrorFlag vs LB (other slice)', type='TH2F', path=monPath,xbins=2000,xmin=0.5,xmax=2000.5,ybins=48,ymin=-0.5,ymax=47.5,opt='kAlwaysCreate')
637 
638  monPath="/MUCTPI/TOB/Expert"
639  etaBins=50
640  etaMin=0
641  etaMax=80
642  phiBins=50
643  phiMin=0
644  phiMax=80
645 
646  myGroup.defineHistogram('tobEtaPhiAX,tobEtaPhiAY;tobEtaPhiA',title='TOB hitmap (eta,phi);Eta;Phi', type='TH2F', path=monPath, xbins=phiBins, xmin=phiMin, xmax=phiMax, ybins=etaBins, ymin=etaMin, ymax=etaMax, opt='kAlwaysCreate')
647  myGroup.defineHistogram('tobEtaPhiA_GoodMFX,tobEtaPhiA_GoodMFY;tobEtaPhiA_GoodMF',title='TOB GoodMF flag hitmap (eta,phi);Eta;Phi', type='TH2F', path=monPath, xbins=phiBins, xmin=phiMin, xmax=phiMax, ybins=etaBins, ymin=etaMin, ymax=etaMax, opt='kAlwaysCreate')
648  myGroup.defineHistogram('tobEtaPhiA_InnerCoinX,tobEtaPhiA_InnerCoinY;tobEtaPhiA_InnerCoin',title='TOB InnerCoin flag hitmap (eta,phi);Eta;Phi', type='TH2F', path=monPath, xbins=phiBins, xmin=phiMin, xmax=phiMax, ybins=etaBins, ymin=etaMin, ymax=etaMax, opt='kAlwaysCreate')
649  myGroup.defineHistogram('tobEtaPhiA_BW23X,tobEtaPhiA_BW23Y;tobEtaPhiA_BW23',title='TOB BW23 flag hitmap (eta,phi);Eta;Phi', type='TH2F', path=monPath, xbins=phiBins, xmin=phiMin, xmax=phiMax, ybins=etaBins, ymin=etaMin, ymax=etaMax, opt='kAlwaysCreate')
650  myGroup.defineHistogram('tobEtaPhiA_ChargeX,tobEtaPhiA_ChargeY;tobEtaPhiA_Charge',title='TOB Charge flag hitmap (eta,phi);Eta;Phi', type='TH2F', path=monPath, xbins=phiBins, xmin=phiMin, xmax=phiMax, ybins=etaBins, ymin=etaMin, ymax=etaMax, opt='kAlwaysCreate')
651  myGroup.defineHistogram('tobEtaPhiCX,tobEtaPhiCY;tobEtaPhiC',title='TOB hitmap (eta,phi);Eta;Phi', type='TH2F', path=monPath, xbins=phiBins, xmin=phiMin, xmax=phiMax, ybins=etaBins, ymin=etaMin, ymax=etaMax, opt='kAlwaysCreate')
652  myGroup.defineHistogram('tobEtaPhiC_GoodMFX,tobEtaPhiC_GoodMFY;tobEtaPhiC_GoodMF',title='TOB GoodMF flag hitmap (eta,phi);Eta;Phi', type='TH2F', path=monPath, xbins=phiBins, xmin=phiMin, xmax=phiMax, ybins=etaBins, ymin=etaMin, ymax=etaMax, opt='kAlwaysCreate')
653  myGroup.defineHistogram('tobEtaPhiC_InnerCoinX,tobEtaPhiC_InnerCoinY;tobEtaPhiC_InnerCoin',title='TOB InnerCoin flag hitmap (eta,phi);Eta;Phi', type='TH2F', path=monPath, xbins=phiBins, xmin=phiMin, xmax=phiMax, ybins=etaBins, ymin=etaMin, ymax=etaMax, opt='kAlwaysCreate')
654  myGroup.defineHistogram('tobEtaPhiC_BW23X,tobEtaPhiC_BW23Y;tobEtaPhiC_BW23',title='TOB BW23 flag hitmap (eta,phi);Eta;Phi', type='TH2F', path=monPath, xbins=phiBins, xmin=phiMin, xmax=phiMax, ybins=etaBins, ymin=etaMin, ymax=etaMax, opt='kAlwaysCreate')
655  myGroup.defineHistogram('tobEtaPhiC_ChargeX,tobEtaPhiC_ChargeY;tobEtaPhiC_Charge',title='TOB Charge flag hitmap (eta,phi);Eta;Phi', type='TH2F', path=monPath, xbins=phiBins, xmin=phiMin, xmax=phiMax, ybins=etaBins, ymin=etaMin, ymax=etaMax, opt='kAlwaysCreate')
656  #pt vs eta/phi
657  myGroup.defineHistogram('tobPtVsEtaAX,tobPtVsEtaAY;tobPtVsEtaA',title='TOB pT VS eta (A);Eta;pT index', type='TH2F', path=monPath, xbins=etaBins, xmin=etaMin, xmax=etaMax, ybins=15, ymin=0.5, ymax=15.5, opt='kAlwaysCreate')
658  myGroup.defineHistogram('tobPtVsPhiAX,tobPtVsPhiAY;tobPtVsPhiA',title='TOB pT VS phi (A);Phi;pT index', type='TH2F', path=monPath, xbins=phiBins, xmin=phiMin, xmax=phiMax, ybins=15, ymin=0.5, ymax=15.5, opt='kAlwaysCreate')
659  myGroup.defineHistogram('tobPtVsEtaCX,tobPtVsEtaCY;tobPtVsEtaC',title='TOB pT VS eta (C);Eta;pT index', type='TH2F', path=monPath, xbins=etaBins, xmin=etaMin, xmax=etaMax, ybins=15, ymin=0.5, ymax=15.5, opt='kAlwaysCreate')
660  myGroup.defineHistogram('tobPtVsPhiCX,tobPtVsPhiCY;tobPtVsPhiC',title='TOB pT VS phi (C);Phi;pT index', type='TH2F', path=monPath, xbins=phiBins, xmin=phiMin, xmax=phiMax, ybins=15, ymin=0.5, ymax=15.5, opt='kAlwaysCreate')
661 
662  # Retrieve histogram binning for eta/phi
663 
664  monPath="/MUCTPI/TOB"
665  myGroup.defineHistogram('tobEtaPhiXdecoded_BA,tobEtaPhiYdecoded_BA;tobEtaPhi_BA',title='TOB hitmap BA (eta,phi);Eta;Phi', type='TH2F', path=monPath, xbins=barrelEtaLowBinEdges, ybins=barrelPhiLowBinEdges, opt='kAlwaysCreate')
666  myGroup.defineHistogram('tobEtaPhiXdecoded_EC,tobEtaPhiYdecoded_EC;tobEtaPhi_EC',title='TOB hitmap EC (eta,phi);Eta;Phi', type='TH2F', path=monPath, xbins=endcapEtaLowBinEdges, ybins=endcapPhiLowBinEdges, opt='kAlwaysCreate')
667  myGroup.defineHistogram('tobEtaPhiXdecoded_FW,tobEtaPhiYdecoded_FW;tobEtaPhi_FW',title='TOB hitmap FW (eta,phi);Eta;Phi', type='TH2F', path=monPath, xbins=forwardEtaLowBinEdges, ybins=forwardPhiLowBinEdges, opt='kAlwaysCreate')
668 
669  myGroup.defineHistogram('tobEtaPhi_GoodMFXdecoded_EC,tobEtaPhi_GoodMFYdecoded_EC;tobEtaPhi_GoodMF_EC',title='TOB GoodMF flag hitmap EC (eta,phi);Eta;Phi', type='TH2F', path=monPath, xbins=endcapEtaLowBinEdges, ybins=endcapPhiLowBinEdges, opt='kAlwaysCreate')
670  myGroup.defineHistogram('tobEtaPhi_GoodMFXdecoded_FW,tobEtaPhi_GoodMFYdecoded_FW;tobEtaPhi_GoodMF_FW',title='TOB GoodMF flag hitmap FW (eta,phi);Eta;Phi', type='TH2F', path=monPath, xbins=forwardEtaLowBinEdges, ybins=forwardPhiLowBinEdges, opt='kAlwaysCreate')
671 
672  myGroup.defineHistogram('tobEtaPhi_InnerCoinXdecoded_EC,tobEtaPhi_InnerCoinYdecoded_EC;tobEtaPhi_InnerCoin_EC',title='TOB InnerCoin flag hitmap EC (eta,phi);Eta;Phi', type='TH2F', path=monPath,xbins=endcapEtaLowBinEdges, ybins=endcapPhiLowBinEdges, opt='kAlwaysCreate')
673  myGroup.defineHistogram('tobEtaPhi_InnerCoinXdecoded_FW,tobEtaPhi_InnerCoinYdecoded_FW;tobEtaPhi_InnerCoin_FW',title='TOB InnerCoin flag hitmap FW (eta,phi);Eta;Phi', type='TH2F', path=monPath,xbins=forwardEtaLowBinEdges, ybins=forwardPhiLowBinEdges, opt='kAlwaysCreate')
674 
675  myGroup.defineHistogram('tobEtaPhi_BW23Xdecoded_EC,tobEtaPhi_BW23Ydecoded_EC;tobEtaPhi_BW23_EC',title='TOB BW23 flag hitmap EC (eta,phi);Eta;Phi', type='TH2F', path=monPath, xbins=endcapEtaLowBinEdges, ybins=endcapPhiLowBinEdges, opt='kAlwaysCreate')
676  myGroup.defineHistogram('tobEtaPhi_BW23Xdecoded_FW,tobEtaPhi_BW23Ydecoded_FW;tobEtaPhi_BW23_FW',title='TOB BW23 flag hitmap FW (eta,phi);Eta;Phi', type='TH2F', path=monPath, xbins=forwardEtaLowBinEdges, ybins=forwardPhiLowBinEdges, opt='kAlwaysCreate')
677 
678  myGroup.defineHistogram('tobEtaPhi_ChargeXdecoded_EC,tobEtaPhi_ChargeYdecoded_EC;tobEtaPhi_Charge_EC',title='TOB Charge flag hitmap EC (eta,phi);Eta;Phi', type='TH2F', path=monPath, xbins=endcapEtaLowBinEdges, ybins=endcapPhiLowBinEdges, opt='kAlwaysCreate')
679  myGroup.defineHistogram('tobEtaPhi_ChargeXdecoded_FW,tobEtaPhi_ChargeYdecoded_FW;tobEtaPhi_Charge_FW',title='TOB Charge flag hitmap FW (eta,phi);Eta;Phi', type='TH2F', path=monPath, xbins=forwardEtaLowBinEdges, ybins=forwardPhiLowBinEdges, opt='kAlwaysCreate')
680 
681  #pt vs eta/phi
682  myGroup.defineHistogram('tobPtVsEtaXdecoded_BA,tobPtVsEtaYdecoded_BA;tobPtVsEta_BA',title='TOB pT VS eta BA;Eta;pT index', type='TH2F', path=monPath, xbins=barrelEtaLowBinEdges, ybins=15, ymin=0.5, ymax=15.5, opt='kAlwaysCreate')
683  myGroup.defineHistogram('tobPtVsEtaXdecoded_EC,tobPtVsEtaYdecoded_EC;tobPtVsEta_EC',title='TOB pT VS eta EC;Eta;pT index', type='TH2F', path=monPath, xbins=endcapEtaLowBinEdges, ybins=15, ymin=0.5, ymax=15.5, opt='kAlwaysCreate')
684  myGroup.defineHistogram('tobPtVsEtaXdecoded_FW,tobPtVsEtaYdecoded_FW;tobPtVsEta_FW',title='TOB pT VS eta FW;Eta;pT index', type='TH2F', path=monPath, xbins=forwardEtaLowBinEdges, ybins=15, ymin=0.5, ymax=15.5, opt='kAlwaysCreate')
685 
686  myGroup.defineHistogram('tobPtVsPhiXdecoded_BA,tobPtVsPhiYdecoded_BA;tobPtVsPhi_BA',title='TOB pT VS phi BA;Phi;pT index', type='TH2F', path=monPath, xbins=barrelPhiLowBinEdges, ybins=15, ymin=0.5, ymax=15.5, opt='kAlwaysCreate')
687  myGroup.defineHistogram('tobPtVsPhiXdecoded_EC,tobPtVsPhiYdecoded_EC;tobPtVsPhi_EC',title='TOB pT VS phi EC;Phi;pT index', type='TH2F', path=monPath, xbins=endcapPhiLowBinEdges, ybins=15, ymin=0.5, ymax=15.5, opt='kAlwaysCreate')
688  myGroup.defineHistogram('tobPtVsPhiXdecoded_FW,tobPtVsPhiYdecoded_FW;tobPtVsPhi_FW',title='TOB pT VS phi FW;Phi;pT index', type='TH2F', path=monPath, xbins=forwardPhiLowBinEdges, ybins=15, ymin=0.5, ymax=15.5, opt='kAlwaysCreate')
689  # tob count
690  myGroup.defineHistogram('tobCount',title='TOBs distrib. per event (central slice);TOBs',type='TH1I',xbins=tobWordsPerTimeslice,path=monPath,opt='kAlwaysCreate')
691 
692  monPath="/MUCTPI/Timing"
693  candSliceVsSLMUCTPIBinLabels = [ #cxx indices
694  "-3 Slice" , #1
695  "-2 Slice" , #2
696  "-1 Slice" , #3
697  "Central Slice" , #4
698  "+1 Slice" , #5
699  "+2 Slice" , #6
700  "+3 Slice" , #7
701  ]
702  myGroup.defineHistogram('candSliceVsSLBAX,candSliceVsSLBAY;candSliceVsSLBA',title='SL (BA) slice vs SL', type='TH2F', path=monPath, xbins=64, xmin=-0.5, xmax=63.5, ybins=len(candSliceVsSLMUCTPIBinLabels), ymin=0., ymax=7., ylabels=candSliceVsSLMUCTPIBinLabels, opt='kAlwaysCreate')
703  myGroup.defineHistogram('candSliceVsSLECX,candSliceVsSLECY;candSliceVsSLEC',title='SL (EC) slice vs SL', type='TH2F', path=monPath, xbins=96, xmin=-0.5, xmax=95.5, ybins=len(candSliceVsSLMUCTPIBinLabels), ymin=0., ymax=7., ylabels=candSliceVsSLMUCTPIBinLabels, opt='kAlwaysCreate')
704  myGroup.defineHistogram('candSliceVsSLFWX,candSliceVsSLFWY;candSliceVsSLFW',title='SL (FW) slice vs SL', type='TH2F', path=monPath, xbins=48, xmin=-0.5, xmax=47.5, ybins=len(candSliceVsSLMUCTPIBinLabels), ymin=0., ymax=7., ylabels=candSliceVsSLMUCTPIBinLabels, opt='kAlwaysCreate')
705  #same histos, but aiming to fill only for specific BG (FirstInTrain) for better profiles
706  myGroup.defineHistogram('candSliceVsSLBAFirstInTrainX,candSliceVsSLBAFirstInTrainY;candSliceVsSLBAFirstInTrain',title='SL (BA) slice vs SL (BG=FirstInTrain)', type='TH2F', path=monPath, xbins=64, xmin=-0.5, xmax=63.5, ybins=len(candSliceVsSLMUCTPIBinLabels), ymin=0., ymax=7., ylabels=candSliceVsSLMUCTPIBinLabels, opt='kAlwaysCreate')
707  myGroup.defineHistogram('candSliceVsSLECFirstInTrainX,candSliceVsSLECFirstInTrainY;candSliceVsSLECFirstInTrain',title='SL (EC) slice vs SL (BG=FirstInTrain)', type='TH2F', path=monPath, xbins=96, xmin=-0.5, xmax=95.5, ybins=len(candSliceVsSLMUCTPIBinLabels), ymin=0., ymax=7., ylabels=candSliceVsSLMUCTPIBinLabels, opt='kAlwaysCreate')
708  myGroup.defineHistogram('candSliceVsSLFWFirstInTrainX,candSliceVsSLFWFirstInTrainY;candSliceVsSLFWFirstInTrain',title='SL (FW) slice vs SL (BG=FirstInTrain)', type='TH2F', path=monPath, xbins=48, xmin=-0.5, xmax=47.5, ybins=len(candSliceVsSLMUCTPIBinLabels), ymin=0., ymax=7., ylabels=candSliceVsSLMUCTPIBinLabels, opt='kAlwaysCreate')
709 
710 
711 
712 
713  acc = helper.result()
714  result.merge(acc)
715  return result
716 
717 

Variable Documentation

◆ BSMonitorCfg

BSMonitoringAlgorithm.BSMonitorCfg

Definition at line 736 of file BSMonitoringAlgorithm.py.

◆ cfg

BSMonitoringAlgorithm.cfg

Definition at line 733 of file BSMonitoringAlgorithm.py.

◆ False

BSMonitoringAlgorithm.False

Definition at line 741 of file BSMonitoringAlgorithm.py.

◆ Files

BSMonitoringAlgorithm.Files

Definition at line 726 of file BSMonitoringAlgorithm.py.

◆ flags

BSMonitoringAlgorithm.flags

Definition at line 725 of file BSMonitoringAlgorithm.py.

◆ HISTFileName

BSMonitoringAlgorithm.HISTFileName

Definition at line 727 of file BSMonitoringAlgorithm.py.

◆ inputs

BSMonitoringAlgorithm.inputs

Definition at line 723 of file BSMonitoringAlgorithm.py.

◆ nevents

BSMonitoringAlgorithm.nevents

Definition at line 743 of file BSMonitoringAlgorithm.py.

◆ OutputLevel

BSMonitoringAlgorithm.OutputLevel

Definition at line 739 of file BSMonitoringAlgorithm.py.

◆ summariseProps

BSMonitoringAlgorithm.summariseProps

Definition at line 741 of file BSMonitoringAlgorithm.py.

◆ withDetails

BSMonitoringAlgorithm.withDetails

Definition at line 741 of file BSMonitoringAlgorithm.py.

python.AutoConfigFlags.GetFileMD
def GetFileMD(filenames, allowEmpty=True, maxLevel='peeker')
Definition: AutoConfigFlags.py:65
python.JetAnalysisCommon.ComponentAccumulator
ComponentAccumulator
Definition: JetAnalysisCommon.py:302
BSMonitoringAlgorithm.BSMonitoringConfig
def BSMonitoringConfig(inputFlags)
Definition: BSMonitoringAlgorithm.py:5
TrigT1ResultByteStreamConfig.MuCTPIPhase1ByteStreamAlgoCfg
def MuCTPIPhase1ByteStreamAlgoCfg(flags)
Definition: TrigT1ResultByteStreamConfig.py:319
print
void print(char *figname, TCanvas *c1)
Definition: TRTCalib_StrawStatusPlots.cxx:26
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:567
python.ParticleTypeUtil.info
def info
Definition: ParticleTypeUtil.py:87
Generated on Thu Oct 30 2025 21:51:52 for ATLAS Offline Software by   doxygen 1.8.18