ATLAS Offline Software
Public Member Functions | Public Attributes | List of all members
python.ScanNtupleHandler.ScanNtupleHandler Class Reference
Collaboration diagram for python.ScanNtupleHandler.ScanNtupleHandler:

Public Member Functions

def __init__ (self)
 
def open (self)
 
def init (self)
 
def fill (self, data)
 
def close (self)
 
def initScanData (self)
 
def fillScanData (self, obj)
 
def initBeamPosition (self)
 
def fillBeamPosition (self, timeobj, data)
 
def initFillParams (self)
 
def fillFillParams (self, timeobj, data)
 
def initLbdata (self)
 
def fillLbdata (self, timeobj, data)
 
def initBunchData (self)
 
def fillBunchData (self, timeobj, data)
 
def initBunchLumi (self)
 
def fillBunchLumi (self, timeobj, data)
 
def initLumiData (self)
 
def fillLumiData (self, timeobj, data)
 
def fillLive (self, liveDict, denchan, numchan, dest)
 
def initLiveData (self)
 

Public Attributes

 fileName
 
 treeName
 
 file
 
 tree
 
 bcidData
 
 algDict
 
 bbbAlgDict
 
 scanDataStruct
 
 beamPositionStruct
 
 fillParamsStruct
 
 lbdataStruct
 
 bunchDataStruct
 
 bunchLumiStruct
 
 fLuminousBCIDs
 
 fBunchRawInstLum
 
 lumiStruct
 
 liveDataStruct
 

Detailed Description

Definition at line 16 of file ScanNtupleHandler.py.

Constructor & Destructor Documentation

◆ __init__()

def python.ScanNtupleHandler.ScanNtupleHandler.__init__ (   self)

Definition at line 18 of file ScanNtupleHandler.py.

18  def __init__(self):
19 
20  self.fileName = 'scan.root'
21  self.treeName = 'vdMScanData'
22  self.file = None
23  self.tree = None
24 
25  self.bcidData = LumiBCIDData()
26 
27  # Master list of tags to give to algorithms
28  self.algDict = dict()
29  self.algDict[0] = 'pref'
30  self.algDict[101] = 'lucidEvtAND'
31  self.algDict[102] = 'lucidEvtOR'
32  self.algDict[103] = 'lucidHitOR'
33  self.algDict[104] = 'lucidHitAND'
34  self.algDict[105] = 'lucidEvtA'
35  self.algDict[106] = 'lucidEvtC'
36 
37  self.algDict[111] = 'lucBiEvtAND'
38  self.algDict[112] = 'lucBiEvtOR'
39  self.algDict[113] = 'lucBiHitOR'
40  self.algDict[115] = 'lucBiEvtA'
41  self.algDict[116] = 'lucBiEvtC'
42 
43  self.algDict[121] = 'lucModEvtAND'
44  self.algDict[122] = 'lucModEvtOR'
45  self.algDict[123] = 'lucModHitOR'
46  self.algDict[124] = 'lucModHitAND'
47  self.algDict[125] = 'lucModEvtA'
48  self.algDict[126] = 'lucModEvtC'
49 
50  self.algDict[131] = 'lucBiPMTA1'
51  self.algDict[132] = 'lucBiPMTA5'
52  self.algDict[133] = 'lucBiPMTA9'
53  self.algDict[134] = 'lucBiPMTA13'
54  self.algDict[135] = 'lucBiPMTC1'
55  self.algDict[136] = 'lucBiPMTC5'
56  self.algDict[137] = 'lucBiPMTC9'
57  self.algDict[138] = 'lucBiPMTC13'
58 
59  self.algDict[151] = 'lucChA'
60  self.algDict[152] = 'lucChC'
61  self.algDict[153] = 'lucBiChA'
62  self.algDict[154] = 'lucBiChC'
63  self.algDict[155] = 'lucFibChA'
64  self.algDict[156] = 'lucFibChC'
65 
66  self.algDict[201] = 'bcmHEvtOR'
67  self.algDict[202] = 'bcmHEvtAND'
68  self.algDict[205] = 'bcmHORA'
69  self.algDict[206] = 'bcmHORC'
70 
71  self.algDict[211] = 'bcmVEvtOR'
72  self.algDict[212] = 'bcmVEvtAND'
73  self.algDict[215] = 'bcmVORA'
74  self.algDict[216] = 'bcmVORC'
75 
76  self.algDict[221] = 'bcmTEvtOR'
77  self.algDict[222] = 'bcmTEvtAND'
78  #self.algDict[225] = 'bcmTORA'
79  #self.algDict[226] = 'bcmTORC'
80 
81  self.algDict[231] = 'bcmHEarlyOR'
82  self.algDict[235] = 'bcmHEarlyA'
83  self.algDict[236] = 'bcmHEarlyC'
84 
85  self.algDict[241] = 'bcmVEarlyOR'
86  self.algDict[245] = 'bcmVEarlyA'
87  self.algDict[246] = 'bcmVEarlyC'
88 
89  self.algDict[301] = 'mbtsEvtOR'
90  self.algDict[302] = 'mbtsEvtAND'
91  self.algDict[303] = 'mbtsEvt2'
92 
93  self.algDict[501] = 'fcalA'
94  self.algDict[502] = 'fcalC'
95 
96  # Algorithms with bunch-by-bunch information
97  self.bbbAlgDict = dict()
98  self.bbbAlgDict[101] = 'lucidEvtAND'
99  self.bbbAlgDict[102] = 'lucidEvtOR'
100  self.bbbAlgDict[103] = 'lucidHitOR'
101  self.bbbAlgDict[104] = 'lucidHitAND'
102  self.bbbAlgDict[105] = 'lucidEvtA'
103  self.bbbAlgDict[106] = 'lucidEvtC'
104 
105  self.bbbAlgDict[111] = 'lucBiEvtAND'
106  self.bbbAlgDict[112] = 'lucBiEvtOR'
107  self.bbbAlgDict[113] = 'lucBiHitOR'
108  self.bbbAlgDict[114] = 'lucBiHitAND'
109  self.bbbAlgDict[115] = 'lucBiEvtA'
110  self.bbbAlgDict[116] = 'lucBiEvtC'
111 
112  self.bbbAlgDict[121] = 'lucModEvtAND'
113  self.bbbAlgDict[122] = 'lucModEvtOR'
114  self.bbbAlgDict[123] = 'lucModHitOR'
115  self.bbbAlgDict[125] = 'lucModEvtA'
116  self.bbbAlgDict[126] = 'lucModEvtC'
117 
118  self.bbbAlgDict[131] = 'lucBiPMTA1'
119  self.bbbAlgDict[132] = 'lucBiPMTA5'
120  self.bbbAlgDict[133] = 'lucBiPMTA9'
121  self.bbbAlgDict[134] = 'lucBiPMTA13'
122  self.bbbAlgDict[135] = 'lucBiPMTC1'
123  self.bbbAlgDict[136] = 'lucBiPMTC5'
124  self.bbbAlgDict[137] = 'lucBiPMTC9'
125  self.bbbAlgDict[138] = 'lucBiPMTC13'
126 
127  self.bbbAlgDict[151] = 'lucChA'
128  self.bbbAlgDict[152] = 'lucChC'
129  self.bbbAlgDict[153] = 'lucBiChA'
130  self.bbbAlgDict[154] = 'lucBiChC'
131  self.bbbAlgDict[155] = 'lucFibChA'
132  self.bbbAlgDict[156] = 'lucFibChC'
133 
134  self.bbbAlgDict[201] = 'bcmHEvtOR'
135  self.bbbAlgDict[202] = 'bcmHEvtAND'
136  self.bbbAlgDict[205] = 'bcmHORA'
137  self.bbbAlgDict[206] = 'bcmHORC'
138 
139  self.bbbAlgDict[211] = 'bcmVEvtOR'
140  self.bbbAlgDict[212] = 'bcmVEvtAND'
141  self.bbbAlgDict[215] = 'bcmVORA'
142  self.bbbAlgDict[216] = 'bcmVORC'
143 
144  self.bbbAlgDict[221] = 'bcmTEvtOR'
145  self.bbbAlgDict[222] = 'bcmTEvtAND'
146  #self.bbbAlgDict[225] = 'bcmTORA'
147  #self.bbbAlgDict[226] = 'bcmTORC'
148 
149  self.bbbAlgDict[231] = 'bcmHEarlyOR'
150  self.bbbAlgDict[235] = 'bcmHEarlyA'
151  self.bbbAlgDict[236] = 'bcmHEarlyC'
152 
153  self.bbbAlgDict[241] = 'bcmVEarlyOR'
154  self.bbbAlgDict[245] = 'bcmVEarlyA'
155  self.bbbAlgDict[246] = 'bcmVEarlyC'
156 

Member Function Documentation

◆ close()

def python.ScanNtupleHandler.ScanNtupleHandler.close (   self)

Definition at line 224 of file ScanNtupleHandler.py.

224  def close(self):
225  print('ScanNtupleHandler.close() called')
226 
227  self.file.Write()
228  self.file.Close()
229 

◆ fill()

def python.ScanNtupleHandler.ScanNtupleHandler.fill (   self,
  data 
)

Definition at line 183 of file ScanNtupleHandler.py.

183  def fill(self, data):
184  print('ScanNtupleHandler.fill() called')
185 
186  nfilled = 0
187  # First we need to fill the scan data
188  for obj in data.scanData.data:
189 
190  # Make cuts here if desired?
191 
192  # Clear out the BCID object
193  self.bcidData.clear()
194 
195  # Fill the scan data
196  self.fillScanData(obj)
197 
198  # Now fill other data.
199  # Must match by IOV, so pass original scan data object, and the relevant data list
200 
201  # BEAMPOSITION
202  self.fillBeamPosition(obj, data.beamData.data)
203 
204  # FILLPARAMS
205  self.fillFillParams(obj, data.fillData.data)
206 
207  # LBDATA
208  self.fillLbdata(obj, data.lbdataData.data)
209 
210  # BUNCHDATA
211  self.fillBunchData(obj, data.bunchData.data)
212 
213  # BUNCHLUMI
214  self.fillBunchLumi(obj, data.bunchLumi.data)
215 
216  # LUMINOSITY
217  self.fillLumiData(obj, data.lumiData.data)
218 
219  self.tree.Fill()
220  nfilled += 1
221 
222  print('ScanNtupleHandler.fill() - filled', nfilled, 'entries')
223 

◆ fillBeamPosition()

def python.ScanNtupleHandler.ScanNtupleHandler.fillBeamPosition (   self,
  timeobj,
  data 
)

Definition at line 288 of file ScanNtupleHandler.py.

288  def fillBeamPosition(self, timeobj, data):
289 
290  # Must match by IOV
291  # These should match exactly, so just look for the same start time
292  found = False
293  for obj in data:
294  if timeobj.since() != obj.since(): continue
295 
296  found = True
297  self.beamPositionStruct.fB1PositionH = obj.payload()['B1_PositionAtIP_H']
298  self.beamPositionStruct.fB1PositionV = obj.payload()['B1_PositionAtIP_V']
299  self.beamPositionStruct.fB2PositionH = obj.payload()['B2_PositionAtIP_H']
300  self.beamPositionStruct.fB2PositionV = obj.payload()['B2_PositionAtIP_V']
301  self.beamPositionStruct.fB1AngleH = obj.payload()['B1_AngleAtIP_H']
302  self.beamPositionStruct.fB1AngleV = obj.payload()['B1_AngleAtIP_V']
303  self.beamPositionStruct.fB2AngleH = obj.payload()['B2_AngleAtIP_H']
304  self.beamPositionStruct.fB2AngleV = obj.payload()['B2_AngleAtIP_V']
305  break
306 
307  if not found:
308  print("scanNtupleHandler.fillBeamPosition - Didn't find beam position data to match scan data!")
309  self.beamPositionStruct.fB1PositionH = 0.
310  self.beamPositionStruct.fB1PositionV = 0.
311  self.beamPositionStruct.fB2PositionH = 0.
312  self.beamPositionStruct.fB2PositionV = 0.
313  self.beamPositionStruct.fB1AngleH = 0.
314  self.beamPositionStruct.fB1AngleV = 0.
315  self.beamPositionStruct.fB2AngleH = 0.
316  self.beamPositionStruct.fB2AngleV = 0.
317 
318 

◆ fillBunchData()

def python.ScanNtupleHandler.ScanNtupleHandler.fillBunchData (   self,
  timeobj,
  data 
)

Definition at line 531 of file ScanNtupleHandler.py.

531  def fillBunchData(self, timeobj, data):
532 
533  # Must match by IOV
534  # LBDATA is fast data, so just match directly
535  foundBPTX = False
536  foundBCT = False
537 
538  for obj in data:
539  if timeobj.since() != obj.since(): continue
540 
541  # Now need to unpack the BCID blob
542  self.bcidData.fillCurrents(obj.payload())
543 
544  if obj.channelId() == 0:
545  foundBPTX = True
546 
547  self.bunchDataStruct.fB1BunchAverageBPTX = obj.payload()['B1BunchAverage']
548  self.bunchDataStruct.fB2BunchAverageBPTX = obj.payload()['B2BunchAverage']
549  self.bunchDataStruct.fValidBPTX = obj.payload()['Valid']
550 
551  self.bunchDataStruct.fB1BunchesBPTX = len(self.bcidData.b1Curr)
552  # Following line causes problems?
553  # Try the brute force apprach again.
554  # self.bunchDataStruct.fB1BCIDsBPTX = array('i', self.bcidData.b1Curr.keys())
555  # self.bunchDataStruct.fB1BunchIntensitiesBPTX = array('f', self.bcidData.b1Curr.values())
556 
557  i = 0
558  for (bcid, val) in self.bcidData.b1Curr.iteritems():
559  self.bunchDataStruct.fB1BCIDsBPTX[i] = bcid
560  self.bunchDataStruct.fB1BunchIntensitiesBPTX[i] = val
561  i += 1
562 
563  self.bunchDataStruct.fB2BunchesBPTX = len(self.bcidData.b2Curr)
564  # self.bunchDataStruct.fB2BCIDsBPTX = array('i', self.bcidData.b2Curr.keys())
565  # self.bunchDataStruct.fB2BunchIntensitiesBPTX = array('f', self.bcidData.b2Curr.values())
566 
567  i = 0
568  for (bcid, val) in self.bcidData.b2Curr.iteritems():
569  self.bunchDataStruct.fB2BCIDsBPTX[i] = bcid
570  self.bunchDataStruct.fB2BunchIntensitiesBPTX[i] = val
571  i += 1
572 
573  elif obj.channelId() == 1:
574  foundBCT = True
575 
576  self.bunchDataStruct.fB1BunchAverageBCT = obj.payload()['B1BunchAverage']
577  self.bunchDataStruct.fB2BunchAverageBCT = obj.payload()['B2BunchAverage']
578  self.bunchDataStruct.fValidBCT = obj.payload()['Valid']
579 
580  self.bunchDataStruct.fB1BunchesBCT = len(self.bcidData.b1Curr)
581  #self.bunchDataStruct.fB1BCIDsBCT = array('i', self.bcidData.b1Curr.keys())
582  #self.bunchDataStruct.fB1BunchIntensitiesBCT = array('f', self.bcidData.b1Curr.values())
583 
584  i = 0
585  for (bcid, val) in self.bcidData.b1Curr.iteritems():
586  self.bunchDataStruct.fB1BCIDsBCT[i] = bcid
587  self.bunchDataStruct.fB1BunchIntensitiesBCT[i] = val
588  i += 1
589 
590  self.bunchDataStruct.fB2BunchesBCT = len(self.bcidData.b2Curr)
591  # self.bunchDataStruct.fB2BCIDsBCT = array('i', self.bcidData.b2Curr.keys())
592  # self.bunchDataStruct.fB2BunchIntensitiesBCT = array('f', self.bcidData.b2Curr.values())
593 
594  i = 0
595  for (bcid, val) in self.bcidData.b2Curr.iteritems():
596  self.bunchDataStruct.fB2BCIDsBCT[i] = bcid
597  self.bunchDataStruct.fB2BunchIntensitiesBCT[i] = val
598  i += 1
599 
600  else:
601  print('scanNtupleHandler.fillLbdata - Found unknown channel', obj.channelId(), '!')
602 
603  if foundBCT and foundBPTX: break
604 
605 
606  if (not foundBPTX) and (not foundBCT):
607  print("scanNtupleHandler.fillBunchData - Couldn't find BUNCHDATA!")
608  elif not foundBCT:
609  print("scanNtupleHandler.fillBunchData - Couldn't find BCT data in BUNCHDATA!")
610  elif not foundBPTX:
611  print("scanNtupleHandler.fillBunchData - Couldn't find BPTX data in BUNCHDATA!")
612 
613  if not foundBCT:
614  self.bunchDataStruct.fB1BunchAverageBCT = 0.
615  self.bunchDataStruct.fB2BunchAverageBCT = 0.
616  self.bunchDataStruct.fValidBCT = -1
617  self.bunchDataStruct.fB1BunchesBCT = 0
618  self.bunchDataStruct.fB2BunchesBCT = 0
619 
620  if not foundBPTX:
621  self.bunchDataStruct.fB1BunchAverageBPTX = 0.
622  self.bunchDataStruct.fB2BunchAverageBPTX = 0.
623  self.bunchDataStruct.fValidBPTX = -1
624  self.bunchDataStruct.fB1BunchesBPTX = 0
625  self.bunchDataStruct.fB2BunchesBPTX = 0
626 
627  # print 'BCT Avg:', self.bunchDataStruct.fB1BunchAverageBCT
628  # for i in range(self.bunchDataStruct.fB1BunchesBCT):
629  # print ' BCID:', self.bunchDataStruct.fB1BCIDsBCT[i], self.bunchDataStruct.fB2BunchIntensitiesBCT[i]
630 

◆ fillBunchLumi()

def python.ScanNtupleHandler.ScanNtupleHandler.fillBunchLumi (   self,
  timeobj,
  data 
)

Definition at line 667 of file ScanNtupleHandler.py.

667  def fillBunchLumi(self, timeobj, data):
668 
669  # Must match by IOV - exact match
670  # Keep track of every algorithm separately
671  foundAny = False
672 
673  found = dict()
674  for chId in self.bbbAlgDict.iterkeys():
675  found[chId] = False
676 
677  for obj in data:
678  if timeobj.since() != obj.since(): continue
679 
680  # Figure out which channel
681  chId = obj.channelId()
682  if chId not in self.bbbAlgDict:
683  print('scanNtupleHandler.fillBunchLumi - Unknown lumi channel', chId, '!')
684  continue
685 
686  foundAny = True
687 
688  # Unpack lumi blob
689  self.bcidData.fillRawLumi(obj.payload())
690 
691  found[chId] = True
692  self.bunchLumiStruct[chId].fChannel = obj.channelId()
693  self.bunchLumiStruct[chId].fValid = obj.payload()['Valid']
694  self.bunchLumiStruct[chId].fAverageRawInstLum = obj.payload()['AverageRawInstLum']
695 
696  self.bunchLumiStruct[chId].fLuminousBunches = len(self.bcidData.rawLumi)
697  #self.fLuminousBCIDs[chId] = array('i', self.bcidData.rawLumi.keys())
698  #self.fBunchRawInstLum[chId] = array('f', self.bcidData.rawLumi.values())
699  #if obj.channelId() == 102:
700  # print 'Channel: %d, Luminous bunches: %d' % (obj.channelId(), len(self.bcidData.rawLumi))
701 
702  i = 0
703  bcidList = self.bcidData.rawLumi.keys()
704  for bcid in sorted(bcidList):
705  val = self.bcidData.rawLumi[bcid]
706  self.fLuminousBCIDs[chId][i] = bcid
707  self.fBunchRawInstLum[chId][i] = val
708  i += 1
709 
710 # self.bunchLumiStruct[chId].fLuminousBCIDs[i] = bcid
711 # self.bunchLumiStruct[chId].fBunchRawInstLum[i] = val
712 
713  if not foundAny:
714  print('scanNtupleHandler.fillBunchLumi - Found no BUNCHLUMIS data to match IOV!')
715 
716  else:
717  for (chId, algstr) in self.bbbAlgDict.iteritems():
718  if not found[chId]:
719  print('scanNtupleHandler.fillBunchLumi - Found no BUNCHLUMIS data for', algstr, '!')
720 
721  for chId in self.bbbAlgDict.iterkeys():
722  if not found[chId]:
723  self.bunchLumiStruct[chId].fChannel = chId
724  self.bunchLumiStruct[chId].fValid = 0xFFFFFFFF
725  self.bunchLumiStruct[chId].fAverageRawInstLum = 0.
726  self.bunchLumiStruct[chId].fLuminousBunches = 0
727 

◆ fillFillParams()

def python.ScanNtupleHandler.ScanNtupleHandler.fillFillParams (   self,
  timeobj,
  data 
)

Definition at line 349 of file ScanNtupleHandler.py.

349  def fillFillParams(self, timeobj, data):
350 
351  # Must match by IOV
352  # FILLPARAMS is slow LHC data, so look for range that encloses start of timeobj IOV
353  found = False
354  for obj in data:
355  # Check that start of scan step is enclosed in object IOV
356  if timeobj.since() < obj.since(): continue
357  if timeobj.since() >= obj.until(): continue
358 
359  found = True
360  self.fillParamsStruct.fB1Bunches = obj.payload()['Beam1Bunches']
361  self.fillParamsStruct.fB2Bunches = obj.payload()['Beam2Bunches']
362  self.fillParamsStruct.fLuminousBunches = obj.payload()['LuminousBunches']
363 
364  # Now need to unpack the BCID blob
365  self.bcidData.fillMask(obj.payload())
366 
367  # Get the BCID lists and enter into ntuple arrays
368 
369  # self.fillParamsStruct.fB1BCIDs = array('i', list(self.bcidData.b1BCID))
370  i = 0
371  for bcid in self.bcidData.b1BCID:
372  self.fillParamsStruct.fB1BCIDs[i] = bcid
373  i += 1
374 
375  # self.fillParamsStruct.fB2BCIDs = array('i', list(self.bcidData.b2BCID))
376  i = 0
377  for bcid in self.bcidData.b2BCID:
378  self.fillParamsStruct.fB2BCIDs[i] = bcid
379  i += 1
380 
381  # self.fillParamsStruct.fLuminousBCIDs = array('i', list(self.bcidData.colBCID))
382  i = 0
383  for bcid in self.bcidData.colBCID:
384  self.fillParamsStruct.fLuminousBCIDs[i] = bcid
385  i += 1
386 
387  if not found:
388  print("scanNtupleHandler.fillFillParams - Didn't find FILLPARAMS data to match scan data!")
389  self.fillParamsStruct.fB1Bunches = 0
390  self.fillParamsStruct.fB2Bunches = 0
391  self.fillParamsStruct.fLuminousBunches = 0
392 
393  for i in range(3564):
394  self.fillParamsStruct.fB1BCIDs[i] = 0
395  self.fillParamsStruct.fB2BCIDs[i] = 0
396  self.fillParamsStruct.fLuminousBCIDs[i] = 0
397 

◆ fillLbdata()

def python.ScanNtupleHandler.ScanNtupleHandler.fillLbdata (   self,
  timeobj,
  data 
)

Definition at line 421 of file ScanNtupleHandler.py.

421  def fillLbdata(self, timeobj, data):
422 
423  # Must match by IOV
424  # LBDATA is fast data, so just match directly
425  foundBPTX = False
426  foundBCT = False
427  foundDCCT = False
428 
429  for obj in data:
430  if timeobj.since() != obj.since(): continue
431 
432  if obj.channelId() == 0:
433  foundBPTX = True
434 
435  self.lbdataStruct.fB1IntensityBPTX = obj.payload()['Beam1Intensity']
436  self.lbdataStruct.fB2IntensityBPTX = obj.payload()['Beam2Intensity']
437  self.lbdataStruct.fB1IntensityAllBPTX = obj.payload()['Beam1IntensityAll']
438  self.lbdataStruct.fB2IntensityAllBPTX = obj.payload()['Beam2IntensityAll']
439 
440  elif obj.channelId() == 1:
441  foundBCT = True
442 
443  self.lbdataStruct.fB1IntensityBCT = obj.payload()['Beam1Intensity']
444  self.lbdataStruct.fB2IntensityBCT = obj.payload()['Beam2Intensity']
445  self.lbdataStruct.fB1IntensityAllBCT = obj.payload()['Beam1IntensityAll']
446  self.lbdataStruct.fB2IntensityAllBCT = obj.payload()['Beam2IntensityAll']
447 
448  elif obj.channelId() == 2:
449  foundDCCT = True
450 
451  self.lbdataStruct.fB1IntensityAllDCCT = obj.payload()['Beam1IntensityAll']
452  self.lbdataStruct.fB2IntensityAllDCCT = obj.payload()['Beam2IntensityAll']
453 
454  else:
455  print('scanNtupleHandler.fillLbdata - Found unknown channel', obj.channelId(), '!')
456 
457  if foundBCT and foundBPTX and foundDCCT : break
458 
459 
460  if (not foundBPTX) and (not foundBCT) and (not foundDCCT):
461  print("scanNtupleHandler.fillLBdata - Couldn't find LBDATA!")
462  elif not foundBCT:
463  print("scanNtupleHandler.fillLBdata - Couldn't find BCT data in LBDATA!")
464  elif not foundBPTX:
465  print("scanNtupleHandler.fillLBdata - Couldn't find BPTX data in LBDATA!")
466  elif not foundDCCT:
467  print("scanNtupleHandler.fillLBdata - Couldn't find DCCT data in LBDATA!")
468 
469  if not foundBCT:
470  self.lbdataStruct.fB1IntensityBCT = 0.
471  self.lbdataStruct.fB2IntensityBCT = 0.
472  self.lbdataStruct.fB1IntensityAllBCT = 0.
473  self.lbdataStruct.fB2IntensityAllBCT = 0.
474 
475  if not foundBPTX:
476  self.lbdataStruct.fB1IntensityBPTX = 0.
477  self.lbdataStruct.fB2IntensityBPTX = 0.
478  self.lbdataStruct.fB1IntensityAllBPTX = 0.
479  self.lbdataStruct.fB2IntensityAllBPTX = 0.
480 
481  if not foundDCCT:
482  self.lbdataStruct.fB1IntensityAllDCCT = 0.
483  self.lbdataStruct.fB2IntensityAllDCCT = 0.
484 

◆ fillLive()

def python.ScanNtupleHandler.ScanNtupleHandler.fillLive (   self,
  liveDict,
  denchan,
  numchan,
  dest 
)

Definition at line 853 of file ScanNtupleHandler.py.

853  def fillLive(self, liveDict, denchan, numchan, dest):
854  num = liveDict.get(numchan, 0.)
855  den = liveDict.get(denchan, 0.)
856  if den > 0.:
857  dest = num/den
858  else:
859  dest = 0. # noqa: F841
860 
861  self.liveDataStruct.fRD0_Filled = 0.
862 
863 

◆ fillLumiData()

def python.ScanNtupleHandler.ScanNtupleHandler.fillLumiData (   self,
  timeobj,
  data 
)

Definition at line 761 of file ScanNtupleHandler.py.

761  def fillLumiData(self, timeobj, data):
762 
763  # Must match by IOV - exact match
764  # Keep track of every algorithm separately
765  foundAny = False
766 
767  found = dict()
768  liveDict = dict()
769 
770  for chId in self.algDict.iterkeys():
771  found[chId] = False
772 
773  for obj in data:
774  if timeobj.since() != obj.since(): continue
775 
776  # Figure out which channel
777  chId = obj.channelId()
778  if chId == 5:
779  continue # Ignore CMS luminosity
780 
781  elif chId >= 50 and chId <=70:
782  liveDict[chId] = obj.payload()['LBAvOLCInstLum']
783  continue
784 
785  elif chId not in self.algDict:
786  print('scanNtupleHandler.fillLumiData - Unknown lumi channel', chId, '!')
787  continue
788 
789  foundAny = True
790 
791  # Fill the data for this algorithm
792  found[chId] = True
793  self.lumiStruct[chId].fChannel = obj.channelId()
794  self.lumiStruct[chId].fLBAvInstLumPhys = obj.payload()['LBAvInstLumPhys']
795  self.lumiStruct[chId].fLBAvEvtsPerBXPhys = obj.payload()['LBAvEvtsPerBXPhys']
796  self.lumiStruct[chId].fLBAvRawInstLumPhys = obj.payload()['LBAvRawInstLumPhys']
797  self.lumiStruct[chId].fLBAvInstLumAll = obj.payload()['LBAvInstLumAll']
798  self.lumiStruct[chId].fLBAvEvtsPerBXAll = obj.payload()['LBAvEvtsPerBXAll']
799  self.lumiStruct[chId].fLBAvRawInstLumAll = obj.payload()['LBAvRawInstLumAll']
800  self.lumiStruct[chId].fLBAvOLCInstLum = obj.payload()['LBAvOLCInstLum']
801  self.lumiStruct[chId].fLBAvOLCEvtsPerBX = obj.payload()['LBAvOLCEvtsPerBX']
802  self.lumiStruct[chId].fLBAvOLCRawInstLum = obj.payload()['LBAvOLCRawInstLum']
803  self.lumiStruct[chId].fDetectorState = obj.payload()['DetectorState']
804  try:
805  self.lumiStruct[chId].fNOrbPhys = obj.payload()['NOrbPhys']
806  self.lumiStruct[chId].fNOrbAll = obj.payload()['NOrbAll']
807  self.lumiStruct[chId].fNOrbOLC = obj.payload()['NOrbOLC']
808  except Exception as e:
809  print(e)
810  self.lumiStruct[chId].fNOrbPhys = 0
811  self.lumiStruct[chId].fNOrbAll = 0
812  self.lumiStruct[chId].fNOrbOLC = 0
813 
814  self.lumiStruct[chId].fValid = obj.payload()['Valid']
815 
816  if not foundAny:
817  print('scanNtupleHandler.fillLumiData - Found no LUMINOSITY data to match IOV!')
818 
819  else:
820  for (chId, algstr) in self.algDict.iteritems():
821  if not found[chId]:
822  print('scanNtupleHandler.fillLumiData - Found no LUMINOSITY data for', algstr, '!')
823 
824  for chId in self.algDict.iterkeys():
825  if not found[chId]:
826  self.lumiStruct[chId].fChannel = chId
827  self.lumiStruct[chId].fLBAvInstLumPhys = 0.
828  self.lumiStruct[chId].fLBAvEvtsPerBXPhys = 0.
829  self.lumiStruct[chId].fLBAvRawInstLumPhys = 0.
830  self.lumiStruct[chId].fLBAvInstLumAll = 0.
831  self.lumiStruct[chId].fLBAvEvtsPerBXAll = 0.
832  self.lumiStruct[chId].fLBAvRawInstLumAll = 0.
833  self.lumiStruct[chId].fLBAvOLCInstLum = 0.
834  self.lumiStruct[chId].fLBAvOLCEvtsPerBX = 0.
835  self.lumiStruct[chId].fLBAvOLCRawInstLum = 0.
836  self.lumiStruct[chId].fNOrbPhys = 0
837  self.lumiStruct[chId].fNOrbAll = 0
838  self.lumiStruct[chId].fNOrbOLC = 0
839  self.lumiStruct[chId].fDetectorState = 0
840  self.lumiStruct[chId].fValid = 0xFFFFFFFF
841 
842  # Fill the livefraction data (if present)
843  self.fillLive(liveDict, 50, 51, self.liveDataStruct.fRD0_Filled)
844  self.fillLive(liveDict, 54, 55, self.liveDataStruct.fMBTS_1_1)
845  self.fillLive(liveDict, 56, 57, self.liveDataStruct.fMBTS_2)
846  self.fillLive(liveDict, 58, 59, self.liveDataStruct.fEM12)
847  self.fillLive(liveDict, 60, 61, self.liveDataStruct.fRD0_BGRP9)
848  self.fillLive(liveDict, 62, 63, self.liveDataStruct.fMBTS_1_BGRP9)
849  self.fillLive(liveDict, 66, 67, self.liveDataStruct.fMBTS_2_BGRP9)
850 
851  print(self.liveDataStruct.fEM12)
852 

◆ fillScanData()

def python.ScanNtupleHandler.ScanNtupleHandler.fillScanData (   self,
  obj 
)

Definition at line 257 of file ScanNtupleHandler.py.

257  def fillScanData(self, obj):
258  self.scanDataStruct.fStartTime = obj.since() # Time in ns
259  self.scanDataStruct.fEndTime = obj.until() # Time in ns
260  self.scanDataStruct.fScanRun = obj.payload()['RunLB'] >> 32
261  self.scanDataStruct.fScanLB = obj.payload()['RunLB']&0xFFFFFFFF
262  self.scanDataStruct.fStepProgress = obj.payload()['StepProgress']
263  self.scanDataStruct.fScanningIP = obj.payload()['ScanningIP']
264  self.scanDataStruct.fAcquisitionFlag = obj.payload()['AcquisitionFlag']
265  self.scanDataStruct.fMovingBeam = obj.payload()['MovingBeam']
266  self.scanDataStruct.fNominalSeparation = obj.payload()['NominalSeparation']
267  self.scanDataStruct.fScanInPlane = obj.payload()['ScanInPlane']
268 

◆ init()

def python.ScanNtupleHandler.ScanNtupleHandler.init (   self)

Definition at line 163 of file ScanNtupleHandler.py.

163  def init(self):
164  print('ScanNtupleHandler.init() called')
165 
166  self.initScanData()
167  self.initBeamPosition()
168  self.initFillParams()
169  self.initLbdata()
170  self.initBunchData()
171  self.initBunchLumi()
172  self.initLumiData()
173  self.initLiveData()
174 

◆ initBeamPosition()

def python.ScanNtupleHandler.ScanNtupleHandler.initBeamPosition (   self)

Definition at line 269 of file ScanNtupleHandler.py.

269  def initBeamPosition(self):
270 
271  #
272  # Define BEAMPOSITION tree
273  gROOT.ProcessLine("struct BeamPositionStruct {\
274  Float_t fB1PositionH;\
275  Float_t fB1PositionV;\
276  Float_t fB2PositionH;\
277  Float_t fB2PositionV;\
278  Float_t fB1AngleH;\
279  Float_t fB1AngleV;\
280  Float_t fB2AngleH;\
281  Float_t fB2AngleV;\
282  };")
283  from ROOT import BeamPositionStruct
284  self.beamPositionStruct = BeamPositionStruct()
285 
286  self.tree.Branch('BEAMPOSITION', self.beamPositionStruct, 'B1PositionH/F:B1PositionV/F:B2PositionH/F:B2PositionV/F:B1AngleH/F:B1AngleV/F:B2AngleH/F:B2AngleV/F')
287 

◆ initBunchData()

def python.ScanNtupleHandler.ScanNtupleHandler.initBunchData (   self)

Definition at line 485 of file ScanNtupleHandler.py.

485  def initBunchData(self):
486 
487  #
488  # Define BUNCHDATA tree
489  gROOT.ProcessLine("struct BunchDataStruct {\
490  UInt_t fValidBPTX;\
491  Float_t fB1BunchAverageBPTX;\
492  Float_t fB2BunchAverageBPTX;\
493  Int_t fB1BunchesBPTX;\
494  Int_t fB2BunchesBPTX;\
495  Float_t fB1BunchIntensitiesBPTX[3564];\
496  Int_t fB1BCIDsBPTX[3564];\
497  Float_t fB2BunchIntensitiesBPTX[3564];\
498  Int_t fB2BCIDsBPTX[3564];\
499  UInt_t fValidBCT;\
500  Float_t fB1BunchAverageBCT;\
501  Float_t fB2BunchAverageBCT;\
502  Int_t fB1BunchesBCT;\
503  Int_t fB2BunchesBCT;\
504  Int_t fB1BCIDsBCT[3564];\
505  Float_t fB1BunchIntensitiesBCT[3564];\
506  Int_t fB2BCIDsBCT[3564];\
507  Float_t fB2BunchIntensitiesBCT[3564];\
508  };")
509  from ROOT import BunchDataStruct
510  self.bunchDataStruct = BunchDataStruct()
511 
512  # Not sure why this is necessary
513  self.bunchDataStruct.fB1BunchesBPTX = 0
514  self.bunchDataStruct.fB2BunchesBPTX = 0
515  self.bunchDataStruct.fB1BunchesBCT = 0
516  self.bunchDataStruct.fB2BunchesBCT = 0
517 
518  self.tree.Branch('BCT_BUNCHDATA', AddressOf(self.bunchDataStruct, 'fValidBCT'), 'BCT_Valid/i:BCT_B1BunchAverage/F:BCT_B2BunchAverage/F:BCT_B1Bunches/I:BCT_B2Bunches/I')
519  self.tree.Branch('BCT_B1BCID', AddressOf(self.bunchDataStruct, 'fB1BCIDsBCT'), 'BCT_B1BCID[BCT_B1Bunches]/I')
520  self.tree.Branch('BCT_B2BCID', AddressOf(self.bunchDataStruct, 'fB2BCIDsBCT'), 'BCT_B2BCID[BCT_B2Bunches]/I')
521  self.tree.Branch('BCT_B1BunchIntensity', AddressOf(self.bunchDataStruct, 'fB1BunchIntensitiesBCT'), 'BCT_B1BunchIntensity[BCT_B1Bunches]/F')
522  self.tree.Branch('BCT_B2BunchIntensity', AddressOf(self.bunchDataStruct, 'fB2BunchIntensitiesBCT'), 'BCT_B2BunchIntensity[BCT_B2Bunches]/F')
523 
524  self.tree.Branch('BPTX_BUNCHDATA', AddressOf(self.bunchDataStruct, 'fValidBPTX'), 'BPTX_Valid/i:BPTX_B1BunchAverage/F:BPTX_B2BunchAverage/F:BPTX_B1Bunches/I:BPTX_B2Bunches/I')
525  self.tree.Branch('BPTX_B1BCID', AddressOf(self.bunchDataStruct, 'fB1BCIDsBPTX'), 'BPTX_B1BCID[BPTX_B1Bunches]/I')
526  self.tree.Branch('BPTX_B2BCID', AddressOf(self.bunchDataStruct, 'fB2BCIDsBPTX'), 'BPTX_B2BCID[BPTX_B2Bunches]/I')
527  self.tree.Branch('BPTX_B1BunchIntensity', AddressOf(self.bunchDataStruct, 'fB1BunchIntensitiesBPTX'), 'BPTX_B1BunchIntensity[BPTX_B1Bunches]/F')
528  self.tree.Branch('BPTX_B2BunchIntensity', AddressOf(self.bunchDataStruct, 'fB2BunchIntensitiesBPTX'), 'BPTX_B2BunchIntensity[BPTX_B2Bunches]/F')
529 
530 

◆ initBunchLumi()

def python.ScanNtupleHandler.ScanNtupleHandler.initBunchLumi (   self)

Definition at line 631 of file ScanNtupleHandler.py.

631  def initBunchLumi(self):
632 
633  #
634  # Define BUNCHDATA tree
635  gROOT.ProcessLine("struct BunchLumiStruct {\
636  UInt_t fChannel;\
637  UInt_t fValid;\
638  Float_t fAverageRawInstLum;\
639  Int_t fLuminousBunches;\
640  Int_t fLuminousBCIDs[3564];\
641  Float_t fBunchRawInstLum[3564];\
642  };")
643  from ROOT import BunchLumiStruct
644 
645  self.bunchLumiStruct = dict()
646  self.fLuminousBCIDs = dict()
647  self.fBunchRawInstLum = dict()
648 
649  for (chId, algstr) in self.bbbAlgDict.iteritems():
650  print('scanNtupleHandler.initLumiData - initializing', algstr, 'as channel', chId)
651  self.bunchLumiStruct[chId] = BunchLumiStruct()
652  self.bunchLumiStruct[chId].fLuminousBunches = 0
653 
654  self.fLuminousBCIDs[chId] = array('i', 3564*[0])
655  self.fBunchRawInstLum[chId] = array('f', 3564*[0.])
656 
657  branchString1 = 'ALG_Channel/i:ALG_Valid/i:ALG_AverageRawInstLum/F:ALG_LuminousBunches/I'
658  branchString2 = 'ALG_LuminousBCIDs[ALG_LuminousBunches]/I'
659  branchString3 = 'ALG_BunchRawInstLum[ALG_LuminousBunches]/F'
660 
661  self.tree.Branch(algstr+'_BUNCHDATA', self.bunchLumiStruct[chId], branchString1.replace('ALG', algstr))
662  #self.tree.Branch(algstr+'_BCID', AddressOf(self.bunchLumiStruct[chId], 'fLuminousBCIDs'), branchString2.replace('ALG', algstr))
663  #self.tree.Branch(algstr+'_BunchRawInstLum', AddressOf(self.bunchLumiStruct[chId], 'fBunchRawInstLum'), branchString3.replace('ALG', algstr))
664  self.tree.Branch(algstr+'_BCID', self.fLuminousBCIDs[chId], branchString2.replace('ALG', algstr))
665  self.tree.Branch(algstr+'_BunchRawInstLum', self.fBunchRawInstLum[chId], branchString3.replace('ALG', algstr))
666 

◆ initFillParams()

def python.ScanNtupleHandler.ScanNtupleHandler.initFillParams (   self)

Definition at line 319 of file ScanNtupleHandler.py.

319  def initFillParams(self):
320 
321  #
322  # Define FILLPARAMS tree
323  gROOT.ProcessLine("struct FillParamsStruct {\
324  Int_t fB1Bunches;\
325  Int_t fB1BCIDs[3564];\
326  Int_t fB2Bunches;\
327  Int_t fB2BCIDs[3564];\
328  Int_t fLuminousBunches;\
329  Int_t fLuminousBCIDs[3564];\
330  };")
331  from ROOT import FillParamsStruct
332  self.fillParamsStruct = FillParamsStruct()
333 
334  self.fillParamsStruct.fB1Bunches = 0
335  self.fillParamsStruct.fB2Bunches = 0
336  self.fillParamsStruct.fLuminousBunches = 0
337  # self.fB1BCIDs = array('i', 3564*[0])
338  # self.fB2BCIDs = array('i', 3564*[0])
339  # self.fLuminousBCIDs = array('i', 3564*[0])
340 
341  self.tree.Branch('FILLPARAMSB1', AddressOf(self.fillParamsStruct, 'fB1Bunches'), 'B1Bunches/I:B1BCIDs[B1Bunches]/I')
342  self.tree.Branch('FILLPARAMSB2', AddressOf(self.fillParamsStruct, 'fB2Bunches'), 'B2Bunches/I:B2BCIDs[B2Bunches]/I')
343  self.tree.Branch('FILLPARAMS', AddressOf(self.fillParamsStruct, 'fLuminousBunches'), 'LuminousBunches/I:LuminousBCIDs[LuminousBunches]/I')
344 
345  print('Defined FillParams data type')
346  #print 'type(fB1Bunches):', type(self.fillParamsStruct.fB1Bunches)
347  #print 'type(fB1BCIDs):', type(self.fillParamsStruct.fB1BCIDs)
348 

◆ initLbdata()

def python.ScanNtupleHandler.ScanNtupleHandler.initLbdata (   self)

Definition at line 398 of file ScanNtupleHandler.py.

398  def initLbdata(self):
399 
400  #
401  # Define LBDATA tree
402  gROOT.ProcessLine("struct LbdataStruct {\
403  Float_t fB1IntensityBPTX;\
404  Float_t fB2IntensityBPTX;\
405  Float_t fB1IntensityAllBPTX;\
406  Float_t fB2IntensityAllBPTX;\
407  Float_t fB1IntensityBCT;\
408  Float_t fB2IntensityBCT;\
409  Float_t fB1IntensityAllBCT;\
410  Float_t fB2IntensityAllBCT;\
411  Float_t fB1IntensityAllDCCT;\
412  Float_t fB2IntensityAllDCCT;\
413  };")
414  from ROOT import LbdataStruct
415  self.lbdataStruct = LbdataStruct()
416 
417  self.tree.Branch('BPTX_LBDATA', AddressOf(self.lbdataStruct, 'fB1IntensityBPTX'), 'BPTX_B1Intensity/F:BPTX_B2Intensity/F:BPTX_B1IntensityAll/F:BPTX_B2IntensityAll/F')
418  self.tree.Branch('BCT_LBDATA', AddressOf(self.lbdataStruct, 'fB1IntensityBCT'), 'BCT_B1Intensity/F:BCT_B2Intensity/F:BCT_B1IntensityAll/F:BCT_B2IntensityAll/F')
419  self.tree.Branch('DCCT_LBDATA', AddressOf(self.lbdataStruct, 'fB1IntensityAllDCCT'), 'DCCT_B1IntensityAll/F:DCCT_B2IntensityAll/F')
420 

◆ initLiveData()

def python.ScanNtupleHandler.ScanNtupleHandler.initLiveData (   self)

Definition at line 864 of file ScanNtupleHandler.py.

864  def initLiveData(self):
865 
866  #
867  # Define LIVEDATA tree
868  gROOT.ProcessLine("struct LiveDataStruct {\
869  Float_t fRD0_Filled;\
870  Float_t fMBTS_1_1;\
871  Float_t fMBTS_2;\
872  Float_t fEM12;\
873  Float_t fRD0_BGRP9;\
874  Float_t fMBTS_1_BGRP9;\
875  Float_t fMBTS_2_BGRP9;\
876  };")
877  from ROOT import LiveDataStruct
878  self.liveDataStruct = LiveDataStruct()
879 
880  self.tree.Branch('LiveFractions', AddressOf(self.liveDataStruct, 'fRD0_Filled'), 'RD0_Filled/f,MBTS_1_1/f,MBTS_2/f,EM12/f,RD0_BGRP9/f,MBTS_1_BGRP9/f,MBTS_2_BGRP9/f')
881 
882 

◆ initLumiData()

def python.ScanNtupleHandler.ScanNtupleHandler.initLumiData (   self)

Definition at line 728 of file ScanNtupleHandler.py.

728  def initLumiData(self):
729  print('scanNtupleHandler.initLumiData() called')
730 
731  #
732  # Define LUMINOSITY tree
733  # Try to abstract this for different lumi algorithms
734  gROOT.ProcessLine("struct LumiDataStruct {\
735  UInt_t fChannel;\
736  Float_t fLBAvInstLumPhys;\
737  Float_t fLBAvEvtsPerBXPhys;\
738  Float_t fLBAvRawInstLumPhys;\
739  Float_t fLBAvInstLumAll;\
740  Float_t fLBAvRawInstLumAll;\
741  Float_t fLBAvEvtsPerBXAll;\
742  Float_t fLBAvOLCInstLum;\
743  Float_t fLBAvOLCRawInstLum;\
744  Float_t fLBAvOLCEvtsPerBX;\
745  UInt_t fNOrbPhys;\
746  UInt_t fNOrbAll;\
747  UInt_t fNOrbOLC;\
748  UInt_t fDetectorState;\
749  UInt_t fValid;\
750  };")
751  from ROOT import LumiDataStruct
752 
753  self.lumiStruct = dict()
754  for (chId, algstr) in self.algDict.iteritems():
755  print('scanNtupleHandler.initLumiData - initializing', algstr, 'as channel', chId)
756  self.lumiStruct[chId] = LumiDataStruct()
757  branchString = 'ALG_LumiChannel/i:ALG_LBAvInstLumPhys/F:ALG_LBAvEvtsPerBXPhys/F:ALG_LBAvRawInstLumPhys/F:ALG_LBAvInstLumAll/F:ALG_LBAvRawInstLumAll/F:ALG_LBAvEvtsPerBXAll/F:ALG_LBAvOLCInstLum/F:ALG_LBAvOLCRawInstLum/F:ALG_LBAvOLCEvtsPerBX/F:ALG_NOrbPhys/i:ALG_NOrbAll/i:ALG_NOrbOLC/i:ALG_DetectorState/i:ALG_LumiValid/i'
758 
759  self.tree.Branch(algstr+'_LUMI', self.lumiStruct[chId], branchString.replace('ALG', algstr))
760 

◆ initScanData()

def python.ScanNtupleHandler.ScanNtupleHandler.initScanData (   self)

Definition at line 230 of file ScanNtupleHandler.py.

230  def initScanData(self):
231 
232  #
233  # Define SCANDATA tree
234  # Time is in ms
235  structStr = "struct ScanDataStruct {\
236  ULong64_t fStartTime;\
237  ULong64_t fEndTime;\
238  UInt_t fScanRun;\
239  UInt_t fScanLB;\
240  Float_t fStepProgress;\
241  Float_t fScanningIP;\
242  Float_t fAcquisitionFlag;\
243  Float_t fMovingBeam;\
244  Float_t fNominalSeparation;\
245  Float_t fScanInPlane;\
246  };"
247 
248  # Replace sizes if needed
249  gROOT.ProcessLine(structStr)
250  from ROOT import ScanDataStruct
251  self.scanDataStruct = ScanDataStruct()
252 
253  # l = 64 bit unsigned int, L = 64 bit signed int
254  self.tree.Branch('SCANDATA', self.scanDataStruct, 'StartTime/l:EndTime/l:ScanRun/i:ScanLB/i:StepProgress/F:ScanningIP/F:AcquisitionFlag/F:MovingBeam/F:NominalSeparation/F:ScanInPlane/F')
255 

◆ open()

def python.ScanNtupleHandler.ScanNtupleHandler.open (   self)

Definition at line 157 of file ScanNtupleHandler.py.

157  def open(self):
158  print('ScanNtupleHandler.open() called')
159 
160  self.file = TFile(self.fileName, 'recreate')
161  self.tree = TTree(self.treeName, self.treeName)
162 

Member Data Documentation

◆ algDict

python.ScanNtupleHandler.ScanNtupleHandler.algDict

Definition at line 28 of file ScanNtupleHandler.py.

◆ bbbAlgDict

python.ScanNtupleHandler.ScanNtupleHandler.bbbAlgDict

Definition at line 97 of file ScanNtupleHandler.py.

◆ bcidData

python.ScanNtupleHandler.ScanNtupleHandler.bcidData

Definition at line 25 of file ScanNtupleHandler.py.

◆ beamPositionStruct

python.ScanNtupleHandler.ScanNtupleHandler.beamPositionStruct

Definition at line 284 of file ScanNtupleHandler.py.

◆ bunchDataStruct

python.ScanNtupleHandler.ScanNtupleHandler.bunchDataStruct

Definition at line 510 of file ScanNtupleHandler.py.

◆ bunchLumiStruct

python.ScanNtupleHandler.ScanNtupleHandler.bunchLumiStruct

Definition at line 645 of file ScanNtupleHandler.py.

◆ fBunchRawInstLum

python.ScanNtupleHandler.ScanNtupleHandler.fBunchRawInstLum

Definition at line 647 of file ScanNtupleHandler.py.

◆ file

python.ScanNtupleHandler.ScanNtupleHandler.file

Definition at line 22 of file ScanNtupleHandler.py.

◆ fileName

python.ScanNtupleHandler.ScanNtupleHandler.fileName

Definition at line 20 of file ScanNtupleHandler.py.

◆ fillParamsStruct

python.ScanNtupleHandler.ScanNtupleHandler.fillParamsStruct

Definition at line 332 of file ScanNtupleHandler.py.

◆ fLuminousBCIDs

python.ScanNtupleHandler.ScanNtupleHandler.fLuminousBCIDs

Definition at line 646 of file ScanNtupleHandler.py.

◆ lbdataStruct

python.ScanNtupleHandler.ScanNtupleHandler.lbdataStruct

Definition at line 415 of file ScanNtupleHandler.py.

◆ liveDataStruct

python.ScanNtupleHandler.ScanNtupleHandler.liveDataStruct

Definition at line 878 of file ScanNtupleHandler.py.

◆ lumiStruct

python.ScanNtupleHandler.ScanNtupleHandler.lumiStruct

Definition at line 753 of file ScanNtupleHandler.py.

◆ scanDataStruct

python.ScanNtupleHandler.ScanNtupleHandler.scanDataStruct

Definition at line 251 of file ScanNtupleHandler.py.

◆ tree

python.ScanNtupleHandler.ScanNtupleHandler.tree

Definition at line 23 of file ScanNtupleHandler.py.

◆ treeName

python.ScanNtupleHandler.ScanNtupleHandler.treeName

Definition at line 21 of file ScanNtupleHandler.py.

The documentation for this class was generated from the following file:
python.Bindings.iteritems
iteritems
Definition: Control/AthenaPython/python/Bindings.py:812
python.Bindings.iterkeys
iterkeys
Definition: Control/AthenaPython/python/Bindings.py:802
plotBeamSpotVxVal.range
range
Definition: plotBeamSpotVxVal.py:195
DerivationFramework::TriggerMatchingUtils::sorted
std::vector< typename T::value_type > sorted(T begin, T end)
Helper function to create a sorted vector from an unsorted one.
array
python.PyKernel.init
def init(v_theApp, v_rootStream=None)
Definition: PyKernel.py:45
python.processes.powheg.ZZ.ZZ.__init__
def __init__(self, base_directory, **kwargs)
Constructor: all process options are set here.
Definition: ZZ.py:18
Trk::open
@ open
Definition: BinningType.h:40
VKalVrtAthena::varHolder_detail::clear
void clear(T &var)
Definition: NtupleVars.h:48
lumiFormat.fill
fill
Definition: lumiFormat.py:111
Muon::print
std::string print(const MuPatSegment &)
Definition: MuonTrackSteering.cxx:28
Generated on Fri Jul 5 2024 22:25:29 for ATLAS Offline Software by   doxygen 1.8.18