Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
RunTileCalibRec.py
Go to the documentation of this file.
1 #!/usr/bin/env python
2 #
3 # Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
4 #
5 '''@file RunTileCalibRec.py
6 @brief Script to run Tile Reconstrcution/Monitoring for calibration runs
7 '''
8 
9 from TileRecEx import TileInputFiles
10 from AthenaConfiguration.Enums import Format
11 from TileConfiguration.TileConfigFlags import TileRunType
12 from AthenaCommon.SystemOfUnits import MeV
13 
14 epiLog = """
15 Examples:
16 
17  RunTileCalibRec.py --run RUNNUMBER --evtMax 1 --pedestals --loglevel WARNING IOVDb.GlobalTag='CONDBR2-BLKPA-2018-13'
18  RunTileCalibRec.py --filesInput=FILE1,FILE2 Tile.RunType=TileRunType.LAS Tile.correctTime=True Exec.SkipEvents=100
19  RunTileCalibRec.py --run RUNNUMBER --cis --postExec='useTagFor("RUN2-HLT-UPD1-00", "/TILE/OFL02/TIME/CHANNELOFFSET/CIS");'
20  RunTileCalibRec.py --run RUNNUMBER --laser --postExec='useSqliteFor("tileSqlite.db", "/TILE");'
21 
22  RunTileCalibRec.py --run RUNNUMBER @options.txt
23 
24  where "options.txt" is text file which can contain all arguments and Athen configuration flags (one per line), e.g.:
25  --run2
26  --upd4
27  --laser
28  --loglevel=INFO
29  --postExec=useSqliteAndTagFor("tileSqlite.db", "RUN2-HLT-UPD1-00", "/TILE/OFL02/TIME/CHANNELOFFSET/LAS");
30  Tile.correctTime=True
31  Exec.SkipEvents=100
32 
33 At least one should provide the following arguments or Athena configuration flags (flags have higher priority):
34  Input file(s), e.g.: --run RUNNUMBER | --filesInput=FILE1,FILE2 | Input.Files="['FILE1','FILE2']"
35  Tile Run Type, e.g.: --cis | --laser | --pedestals | --physics | Tile.RunType=TileRunType.PHY
36 """
37 
38 
39 def getArgumentParser(flags):
40  """ Function to return command line arguments parser for reconstuction of Tile calibration runs """
41 
42  parserParents = [flags.getArgumentParser(), TileInputFiles.getArgumentParser(add_help=False)]
43 
44  import argparse
45  parser= argparse.ArgumentParser(parents=parserParents, add_help=False, fromfile_prefix_chars='@', epilog=epiLog, formatter_class=argparse.RawTextHelpFormatter)
46 
47  parser.add_argument('--preExec', help='Code to execute before locking configs')
48  parser.add_argument('--postExec', help='Code to execute after setup')
49  parser.add_argument('--printDetailedConfig', action='store_true', help='Print detailed Athena configuration')
50  parser.add_argument('--dumpArguments', action='store_true', help='Print arguments and exit')
51  parser.add_argument('--outputDirectory', default='.', help='Output directory for produced files')
52 
53  parser.add_argument('--outputVersion', type=str, default='0', help='Version to be used in output files for ntuple and monitoring')
54 
55  parser.add_argument('--calib', default=False, help='Calculate calibration constants and store them in ROOT file', action=argparse.BooleanOptionalAction)
56  parser.add_argument('--tmdb', default=None, help='Enable TMDB', action=argparse.BooleanOptionalAction)
57  parser.add_argument('--cells', help='Reconstruct Tile cells (default depends on if they are needed)', action=argparse.BooleanOptionalAction)
58  parser.add_argument('--clusters', default=False, help='Reconstruct Tile clusters', action=argparse.BooleanOptionalAction)
59  parser.add_argument('--towers', default=False, help='Reconstruct Tile towers', action=argparse.BooleanOptionalAction)
60  parser.add_argument('--muonfit', default=False, help='Reconstruct Tile MuonFit', action=argparse.BooleanOptionalAction)
61  parser.add_argument('--muid', default=False, help='Reconstruct Tile MuID', action=argparse.BooleanOptionalAction)
62  parser.add_argument('--pool', default=False, help='Create output POOL file', action=argparse.BooleanOptionalAction)
63  parser.add_argument('--jivexml', default=False, help='Create output Jive XML files for Atlantis', action=argparse.BooleanOptionalAction)
64  parser.add_argument('--d3pd', default=False, help='Create output D3PD file', action=argparse.BooleanOptionalAction)
65  parser.add_argument('--special-demo-shape', dest='special_demo_shape', type=int, default=None, help='Use special pulse shape for the Demonstrator')
66 
67  # Set up Tile h2000 ntuple
68  ntuple = parser.add_argument_group('Tile h2000 ntuple')
69  ntuple.add_argument('--ntuple', default=True, help='Create Tile h2000 ntuple', action=argparse.BooleanOptionalAction)
70  ntuple.add_argument('--reduced-ntuple', dest='reduced_ntuple', action='store_true', help='No Tile raw cahnnel container (including DSP) in h2000 ntuple')
71  ntuple.add_argument('--use-dsp-units', dest='use_dsp_units', action='store_true', help='Use DSP units in h2000 ntuple')
72  ntuple.add_argument('--calibrate', default=None, help='Calibrate energy in h2000 ntuple', action=argparse.BooleanOptionalAction)
73  ntuple.add_argument('--offline-units', dest='offline_units', type=int, default=None, help='Units in h2000 ntuple (see TileRawChannelUnit)')
74 
75  # Set up Tile monitoring
76  mon = parser.add_argument_group('Tile monitoring')
77  mon.add_argument('--mon', default=False, help='Run Tile monitoring', action=argparse.BooleanOptionalAction)
78  mon.add_argument('--postprocessing', default=True, help='Run Tile monitoring postprocessing', action=argparse.BooleanOptionalAction)
79  mon.add_argument('--digits-mon', dest='digits_mon', default=True, help='Run Tile digits monitoring', action=argparse.BooleanOptionalAction)
80  mon.add_argument('--channel-mon', dest='channel_mon', default=True, help='Run Tile raw channles monitoring', action=argparse.BooleanOptionalAction)
81  mon.add_argument('--channel-time-mon', dest='channel_time_mon', default=None, help='Run Tile raw channles time monitoring', action=argparse.BooleanOptionalAction)
82  mon.add_argument('--tmdb-mon', dest='tmdb_mon', default=True, help='Run TMDB monitoring', action=argparse.BooleanOptionalAction)
83  mon.add_argument('--tmdb-digits-mon', dest='tmdb_digits_mon', default=True, help='Run TMDB digits monitoring', action=argparse.BooleanOptionalAction)
84  mon.add_argument('--tmdb-channel-mon', dest='tmdb_channel_mon', default=True, help='Run TMDB raw channels monitoring', action=argparse.BooleanOptionalAction)
85  mon.add_argument('--digi-noise-mon', dest='digi_noise_mon', help='Run Tile digi noise monitoring (default: True for pedestals run)', action=argparse.BooleanOptionalAction)
86  mon.add_argument('--cell-mon', dest='cell_mon', help='Run Tile Cell monitoring (default: True for physics run)', action=argparse.BooleanOptionalAction)
87  mon.add_argument('--dq-mon', dest='dq_mon', default=True, help='Run Tile DQ monitoring for physics run', action=argparse.BooleanOptionalAction)
88 
89  # Set up Tile run type
90  run_type_group = parser.add_argument_group('Tile Run Type')
91  run_type = run_type_group.add_mutually_exclusive_group()
92  run_type.add_argument('--cis', action='store_true', help='Tile CIS run type')
93  run_type.add_argument('--mono-cis', action='store_true', dest='mono_cis', help='Tile mono CIS run type')
94  run_type.add_argument('--gap-cis', action='store_true', dest='gap_cis', help='Tile gap CIS run type')
95  run_type.add_argument('--l1calo', action='store_true', help='Tile LVL1 Calo (CIS) run type')
96  run_type.add_argument('--laser', action='store_true', help='Tile laser run type')
97  run_type.add_argument('--gap-laser', action='store_true', dest='gap_laser', help='Tile gap laser run type')
98  run_type.add_argument('--pedestals', action='store_true', help='Tile pedestals run type')
99  run_type.add_argument('--physics', action='store_true', help='Tile physics run type')
100 
101  # Set up Tile reconstuction method
102  method = parser.add_argument_group('Tile reconstuction method')
103  method.add_argument('--opt2', default=True, help='Use Tile Opt2 reconstuction method', action=argparse.BooleanOptionalAction)
104  method.add_argument('--opt-atlas', dest='opt_atlas', default=True, help='Use Tile OptATLAS reconstuction method', action=argparse.BooleanOptionalAction)
105  method.add_argument('--fit', default=True, help='Use Tile Fit reconstuction method', action=argparse.BooleanOptionalAction)
106  method.add_argument('--of1', default=False, help='Use Tile OF1 reconstuction method', action=argparse.BooleanOptionalAction)
107  method.add_argument('--mf', default=False, help='Use Tile MF reconstuction method', action=argparse.BooleanOptionalAction)
108 
109  run_period_group = parser.add_argument_group('LHC Run period')
110  run_period = run_period_group.add_mutually_exclusive_group()
111  run_period.add_argument('--run2', action='store_true', help='LHC Run2 period')
112  run_period.add_argument('--run3', action='store_true', help='LHC Run3 period')
113 
114  parser.add_argument('--upd4', action='store_true', help='Use UPD4 conditions')
115 
116  return parser
117 
118 
119 def useTagFor(tag, folder):
120  ''' Function to override tag for DB folder (it should be used in --postExec) '''
121  fullTag = f'{folder.title().replace("/","")}-{tag}' if folder.startswith('/TILE') and not tag.startswith('Tile') else tag
122  from AthenaCommon.Logging import log
123  log.info(f'Use tag {fullTag} for folder: {folder}')
124  cfg.getService('IOVDbSvc').overrideTags += [f'<prefix>{folder}</prefix> <tag>{fullTag}</tag>']
125 
126 def useSqliteFor(sqliteFile, folder):
127  ''' Function to use Sqlite file for DB folder (it should be used in --postExec) '''
128  iovDbSvc = cfg.getService('IOVDbSvc')
129  from AthenaCommon.Logging import log
130  log.info(f'Use Sqlite file {sqliteFile} for folder: {folder}')
131  iovDbSvc.overrideTags += [f'<prefix>{folder}</prefix> <db>sqlite://;schema={sqliteFile};dbname={iovDbSvc.DBInstance}</db>']
132 
133 def useSqliteAndTagFor(sqliteFile, tag, folder):
134  ''' Function to use tag from Sqlite file for DB folder (it should be used in --postExec) '''
135  useSqliteFor(sqliteFile, folder)
136  useTagFor(tag, folder)
137 
138 if __name__=='__main__':
139  import sys,os
140 
141  from AthenaConfiguration.AllConfigFlags import initConfigFlags
142  flags = initConfigFlags()
143 
144  # Setup logs
145  from AthenaCommon.Logging import log
146  from AthenaCommon import Constants
147  log.setLevel(Constants.INFO)
148 
149  parser = getArgumentParser(flags)
150  args, _ = parser.parse_known_args()
151 
152  # Initially the following flags are not set up (they must be provided)
153  flags.Input.Files = []
154  flags.Tile.RunType = TileRunType.UNDEFINED
155 
156  # Initial configuration flags from command line arguments (to be used to set up defaults)
157  flags.fillFromArgs(parser=parser)
158 
159  # =======>>> Set up the Athena configuration flags to defaults (can be overriden via comand line)
160 
161  # Set up the Tile input files
162  if not flags.Input.Files and args.run:
163  flags.Input.Files = TileInputFiles.findFilesFromAgruments(args)
164  if not flags.Input.Files:
165  log.error('Input files must be provided! For example: --filesInput=file1,file2,... or --run RUNNUMBER')
166  sys.exit(-1)
167 
168  # Set up the Tile run type using arguments if it was not set up via configuration flags
169  if flags.Tile.RunType is TileRunType.UNDEFINED:
170  if args.cis:
171  flags.Tile.RunType = TileRunType.CIS
172  elif args.mono_cis:
173  flags.Tile.RunType = TileRunType.MONOCIS
174  elif args.gap_cis:
175  flags.Tile.RunType = TileRunType.GAPCIS
176  elif args.l1calo:
177  flags.Tile.RunType = TileRunType.L1CALO
178  elif args.laser:
179  flags.Tile.RunType = TileRunType.LAS
180  elif args.gap_laser:
181  flags.Tile.RunType = TileRunType.GAPLAS
182  elif args.pedestals:
183  flags.Tile.RunType = TileRunType.PED
184  elif args.physics:
185  flags.Tile.RunType = TileRunType.PHY
186  else:
187  log.error('The Tile Run Type must be provided! For example: --laser or --cis, ..., or Tile.RunType=TileRunType.PED')
188  sys.exit(-1)
189 
190  if flags.Tile.RunType in [TileRunType.PED, TileRunType.LAS, TileRunType.BILAS, TileRunType.MONOCIS]:
191  flags.Exec.SkipEvents = 1
192  elif flags.Tile.RunType is TileRunType.CIS:
193  flags.Exec.SkipEvents = 192 # skip all events when just one channel is fired (4*48)
194  elif flags.Tile.RunType is TileRunType.L1CALO:
195  flags.Exec.SkipEvents = 3
196 
197  # Set up Tile reconstuction method
198  flags.Tile.doOpt2 = args.opt2
199  flags.Tile.doOptATLAS = args.opt_atlas
200  flags.Tile.doFit = args.fit
201  flags.Tile.doOF1 = args.of1
202  flags.Tile.doMF = args.mf
203 
204  flags.Tile.BestPhaseFromCOOL = True
205  flags.Tile.NoiseFilter = 0 # disable noise filter by default
206  flags.Tile.doOverflowFit = False
207  flags.Tile.correctAmplitude = False
208  flags.Tile.correctTime = flags.Tile.RunType in [TileRunType.PHY, TileRunType.GAPLAS, TileRunType.GAPCIS]
209  flags.Tile.OfcFromCOOL = flags.Tile.RunType in [TileRunType.PHY, TileRunType.PED]
210 
211  runNumber = flags.Input.RunNumbers[0]
212 
213  # Set up LHC Run period
214  if not any([args.run2, args.run3]):
215  if not flags.Input.isMC:
216  if runNumber >= 411938:
217  args.run3 = True
218  elif any([args.year and args.year > 2014, runNumber > 232000, flags.Input.ProjectName.startswith("data15_")]):
219  args.run2 = True
220 
221  # Set up the DB global conditions tag
222  if flags.Input.Format is Format.BS:
223  if args.run3:
224  condDbTag = 'CONDBR2-BLKPA-2024-04' if args.upd4 else 'CONDBR2-ES1PA-2024-05'
225  detDescrVersion = 'ATLAS-R3S-2021-03-01-00'
226  elif args.run2:
227  condDbTag = 'CONDBR2-BLKPA-2018-16' if args.upd4 else 'CONDBR2-ES1PA-2018-05'
228  detDescrVersion = 'ATLAS-R2-2016-01-00-01'
229  else:
230  condDbTag = 'COMCOND-BLKPA-RUN1-06' if (args.upd4 and runNumber > 141066) else 'COMCOND-ES1PA-006-05'
231  detDescrVersion = 'ATLAS-R1-2012-03-02-00'
232 
233  flags.IOVDb.GlobalTag = condDbTag
234  flags.GeoModel.AtlasVersion = detDescrVersion
235 
236  if args.mon:
237  flags.DQ.useTrigger = False
238  flags.DQ.enableLumiAccess = False
239  if not flags.Output.HISTFileName:
240  flags.Output.HISTFileName = f'{args.outputDirectory}/tilemon_{runNumber}_{args.outputVersion}.root'
241 
242  if args.tmdb is None:
243  args.tmdb = not flags.Input.isMC
244 
245  if args.channel_time_mon is None:
246  args.channel_time_mon = flags.Tile.RunType in [TileRunType.GAPLAS, TileRunType.GAPCIS] and (args.run2 or args.run3) and flags.Tile.doFit
247 
248  if args.pool:
249  flags.Output.ESDFileName = f'tile_{runNumber}_{args.outputVersion}.pool.root'
250 
251  if args.jivexml:
252  flags.Output.doJiveXML = True
253 
254  # Override default configuration flags from command line arguments
255  flags.fillFromArgs(parser=parser)
256 
257  if args.dumpArguments:
258  log.info('=====>>> FINAL ARGUMENTS FOLLOW:')
259  print('{:40} : {}'.format('Argument Name', 'Value'))
260  for a,v in (vars(args)).items():
261  print(f'{a:40} : {v}')
262  sys.exit(0)
263 
264  flags.needFlagsCategory('Tile')
265 
266  if args.preExec:
267  log.info('Executing preExec: %s', args.preExec)
268  exec(args.preExec)
269 
270  flags.lock()
271 
272  log.info('=====>>> FINAL CONFIG FLAGS SETTINGS FOLLOW:')
273  flags.dump(pattern='Tile.*|Input.*|Exec.*|IOVDb.[D|G].*', evaluate=True)
274 
275  biGainRun = flags.Tile.RunType.isBiGain()
276 
277  # =======>>> Set up default arguments
278  cellsAvailable = (flags.Input.Format is Format.POOL and 'AllCalo' in flags.Input.Collections)
279  if args.cells is None:
280  args.cells = not cellsAvailable and (args.towers or args.clusters or args.muid or args.muonfit
281  or args.jivexml or args.d3pd or args.pool
282  or flags.Tile.RunType is TileRunType.PHY)
283  cellsAvailable = cellsAvailable or args.cells
284 
285  if args.cell_mon is None:
286  args.cell_mon = cellsAvailable and flags.Tile.RunType is TileRunType.PHY
287 
288  if args.digi_noise_mon is None:
289  args.digi_noise_mon = flags.Tile.RunType is TileRunType.PED
290 
291  # Initialize configuration object, add accumulator, merge, and run.
292  from AthenaConfiguration.MainServicesConfig import MainServicesCfg
293  cfg = MainServicesCfg(flags)
294 
295  # =======>>> Set up the File (BS | POOL) reading
296  if flags.Input.Format is Format.BS:
297  # Configure reading the Tile BS files
298  from TileByteStream.TileByteStreamConfig import TileRawDataReadingCfg
299  cfg.merge( TileRawDataReadingCfg(flags, readMuRcv=args.ntuple,
300  readMuRcvDigits=any([args.tmdb_digits_mon, args.tmdb_mon, args.ntuple]),
301  readMuRcvRawCh=any([args.tmdb_channel_mon, args.tmdb_mon, args.ntuple])) )
302 
303  else:
304  # Configure reading POOL files
305  from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
306  cfg.merge(PoolReadCfg(flags))
307 
308  # =======>>> Set up the Tile raw channel maker only if readDigits is set
309  if flags.Tile.readDigits:
310  from TileRecUtils.TileRawChannelMakerConfig import TileRawChannelMakerCfg
311  cfg.merge( TileRawChannelMakerCfg(flags) )
312  rawChMaker = cfg.getEventAlgo('TileRChMaker')
313  if args.threads and (args.threads > 1):
314  rawChMaker.Cardinality = args.threads
315  for builderTool in rawChMaker.TileRawChannelBuilder:
316  builderTool.UseDSPCorrection = not biGainRun
317 
318  # =======>>> Set up the Tile cell maker
319  if args.cells:
320  rawChannelContainer = flags.Tile.RawChannelContainer
321  if flags.Tile.doOptATLAS and any([flags.Tile.doFit, flags.Tile.doOpt2]):
322  rawChannelContainer = 'TileRawChannelOpt2' if flags.Tile.doOpt2 else 'TileRawChannelFit'
323  from TileRecUtils.TileCellMakerConfig import TileCellMakerCfg
324  if biGainRun:
325  cfg.merge( TileCellMakerCfg(flags, SkipGain=0, mergeChannels=False) )
326  cfg.merge( TileCellMakerCfg(flags, SkipGain=1, mergeChannels=False) )
327  cfg.getEventAlgo("TileCellMakerHG").CaloCellMakerToolNames["TileCellBuilder"].TileRawChannelContainer = rawChannelContainer
328  cfg.getEventAlgo("TileCellMakerLG").CaloCellMakerToolNames["TileCellBuilder"].TileRawChannelContainer = rawChannelContainer
329  else:
330  cfg.merge( TileCellMakerCfg(flags, mergeChannels=False) )
331  cfg.getEventAlgo("TileCellMaker").CaloCellMakerToolNames["TileCellBuilder"].TileRawChannelContainer = rawChannelContainer
332 
333  # =======>>> Set up the Tile clusters maker
334  if args.clusters:
335  from TileMonitoring.TileTopoClusterConfig import TileTopoClusterCfg
336  cfg.merge( TileTopoClusterCfg(flags) )
337 
338  # =======>>> Set up the Tile muon fitter
339  if args.muonfit:
340  from TileCosmicAlgs.TileMuonFitterConfig import TileMuonFitterCfg
341  cfg.merge( TileMuonFitterCfg(flags) )
342 
343  # =======>>> Set up the Tile muon ID reconstuction
344  if args.muid:
345  from TileMuId.TileMuIdConfig import TileLookForMuAlgCfg
346  cfg.merge( TileLookForMuAlgCfg(flags) )
347 
348  # =======>>> Set up the Tile raw channel to hit algorithm
349  if flags.Output.doWriteESD:
350  from TileRecAlgs.TileRawChannelToHitConfig import TileRawChannelToHitCfg
351  cfg.merge( TileRawChannelToHitCfg(flags) )
352 
353  # =======>>> Set up the Tile Ntuple
354  if args.ntuple:
355  ntupleFile = f'{args.outputDirectory}/tile_{runNumber}_{args.outputVersion}.aan.root'
356  from TileRec.TileAANtupleConfig import TileAANtupleCfg
357  cfg.merge( TileAANtupleCfg(flags, outputFile=ntupleFile, UseDspUnits=args.use_dsp_units) )
358  tileNtuple = cfg.getEventAlgo('TileNtuple')
359  # CompressionSettings: algorithm * 100 + level
360  tileNtuple.CompressionSettings = 204
361  tileNtuple.SkipEvents = 4 if flags.Tile.RunType is TileRunType.LAS else 0
362  tileNtuple.TileRawChannelContainerOpt = "TileRawChannelOpt2" if flags.Tile.doOpt2 else ""
363  tileNtuple.TileRawChannelContainerDsp = "" if biGainRun else "TileRawChannelCnt"
364  if args.reduced_ntuple:
365  tileNtuple.Reduced = True
366  tileNtuple.TileRawChannelContainer = ""
367  if args.offline_units:
368  tileNtuple.OfflineUnits = args.offline_units
369  tileNtuple.CalibrateEnergy = True
370  elif args.calibrate is not None:
371  tileNtuple.CalibrateEnergy = args.calibrate
372  if flags.Tile.RunType in [TileRunType.GAPLAS, TileRunType.GAPCIS]:
373  tileNtuple.TileDigitsContainerFlt = "TileDigitsCnt"
374  tileNtuple.TileDigitsContainer = "" # do not save various error bits
375 
376  # =======>>> Set up the Tile monitoring
377  if args.mon:
378 
380  for tool in alg.GMTools:
381  tool.Histograms = [h.replace('OFFLINE','ONLINE') for h in tool.Histograms]
382 
383  if args.digits_mon:
384  from TileMonitoring.TileDigitsMonitorAlgorithm import TileDigitsMonitoringConfig
385  cfg.merge(TileDigitsMonitoringConfig(flags))
386  setOnlineEnvironment(cfg.getEventAlgo('TileDigitsMonAlg'))
387 
388  if args.channel_mon:
389  from TileMonitoring.TileRawChannelMonitorAlgorithm import TileRawChannelMonitoringConfig
390  cfg.merge(TileRawChannelMonitoringConfig(flags))
391  setOnlineEnvironment(cfg.getEventAlgo('TileRawChannelMonAlg'))
392 
393  if args.channel_time_mon:
394  from TileMonitoring.TileRawChannelTimeMonitorAlgorithm import TileRawChannelTimeMonitoringConfig
395  cfg.merge(TileRawChannelTimeMonitoringConfig(flags))
396  setOnlineEnvironment(cfg.getEventAlgo('TileRawChanTimeMonAlg'))
397 
398  if args.tmdb_digits_mon:
399  from TileMonitoring.TileTMDBDigitsMonitorAlgorithm import TileTMDBDigitsMonitoringConfig
400  cfg.merge(TileTMDBDigitsMonitoringConfig(flags))
401  setOnlineEnvironment(cfg.getEventAlgo('TileTMDBDigitsMonAlg'))
402 
403  if args.tmdb_channel_mon:
404  from TileMonitoring.TileTMDBRawChannelMonitorAlgorithm import TileTMDBRawChannelMonitoringConfig
405  cfg.merge(TileTMDBRawChannelMonitoringConfig(flags))
406  setOnlineEnvironment(cfg.getEventAlgo('TileTMDBRawChanDspMonAlg'))
407 
408  if args.tmdb_mon:
409  from TileMonitoring.TileTMDBMonitorAlgorithm import TileTMDBMonitoringConfig
410  cfg.merge(TileTMDBMonitoringConfig(flags))
411  setOnlineEnvironment(cfg.getEventAlgo('TileTMDBMonAlg'))
412 
413  if args.dq_mon and flags.Tile.RunType is TileRunType.PHY and flags.Tile.readDigits:
414  from TileMonitoring.TileDQFragMonitorAlgorithm import TileDQFragMonitoringConfig
415  cfg.merge(TileDQFragMonitoringConfig(flags))
416  setOnlineEnvironment(cfg.getEventAlgo('TileDQMonAlg'))
417 
418  if args.cell_mon:
419  from TileMonitoring.TileCellMonitorAlgorithm import TileCellMonitoringConfig
420  if biGainRun:
421  cfg.merge(TileCellMonitoringConfig(flags, CaloCellContainer='AllCaloHG'))
422  else:
423  cfg.merge(TileCellMonitoringConfig(flags, fillTimeHistograms=True,
424  EnergyThresholdForTime=150.0*MeV))
425  setOnlineEnvironment(cfg.getEventAlgo('TileCellMonAlg'))
426 
427  if args.digi_noise_mon:
428  from TileMonitoring.TileDigiNoiseMonitorAlgorithm import TileDigiNoiseMonitoringConfig
429  triggerTypes = [0x82] if flags.Tile.RunType is TileRunType.PHY else []
430  cfg.merge(TileDigiNoiseMonitoringConfig(flags, TriggerTypes=triggerTypes))
431  setOnlineEnvironment(cfg.getEventAlgo('TileDigiNoiseMonAlg'))
432 
433  if any([args.tmdb_digits_mon, args.tmdb_mon, args.channel_mon, args.digits_mon]) and args.postprocessing:
434  from AthenaCommon.Utils.unixtools import find_datafile
435  configurations = []
436  dataPath = find_datafile('TileMonitoring')
437  if any([args.tmdb_digits_mon, args.tmdb_mon]):
438  configurations += [os.path.join(dataPath, 'TileTMDBPostProc.yaml')]
439  if args.digits_mon:
440  configurations += [os.path.join(dataPath, 'TileDigitsPostProc.yaml')]
441  if args.channel_mon:
442  if flags.Tile.RunType in [TileRunType.CIS]:
443  configurations += [os.path.join(dataPath, 'TileRawChanCisPostProc.yaml')]
444  else:
445  configurations += [os.path.join(dataPath, 'TileRawChanPostProc.yaml')]
446  if flags.Tile.RunType is TileRunType.LAS:
447  configurations += [os.path.join(dataPath, 'TileRawChanLasPostProc.yaml')]
448  if not biGainRun:
449  configurations += [os.path.join(dataPath, 'TileRawChanDspPostProc.yaml')]
450 
451  from DataQualityUtils.DQPostProcessingAlg import DQPostProcessingAlg
452  class TileMonPostProcessingAlg(DQPostProcessingAlg):
453  def initialize(self):
454  if hasattr(self, 'OutputLevel'):
455  self.msg.setLevel(self.OutputLevel)
456  return super(TileMonPostProcessingAlg, self).initialize()
457 
458  ppa = TileMonPostProcessingAlg("TileMonPostProcessingAlg")
459  ppa.OutputLevel = flags.Exec.OutputLevel
460  ppa.ExtraInputs = {( 'xAOD::EventInfo' , 'StoreGateSvc+EventInfo' )}
461  ppa.Interval = 1000000 # Big number (>evtMax) to do postprocessing during finalization
462  ppa.ConfigFiles = configurations
463  ppa._ctr = 1 # Start postprocessing only after specified number of events (not during the first one)
464  ppa.FileKey = f'/{flags.DQ.FileKey}/'
465 
466  cfg.addEventAlgo(ppa, sequenceName='AthEndSeq')
467 
468 
469  # =======>>> Set up the Tile calibration
470  if args.calib:
471  if flags.Tile.RunType is TileRunType.LAS:
472  laserCalibFile = f'tileCalibLAS_{runNumber}_{args.outputVersion}.root'
473  from TileCalibAlgs.TileLaserCalibAlgConfig import TileLaserCalibAlgCfg
474  cfg.merge( TileLaserCalibAlgCfg(flags, FileName=laserCalibFile) )
475 
476  elif flags.Tile.RunType is TileRunType.L1CALO:
477  from TrigT1CaloByteStream.LVL1CaloRun2ByteStreamConfig import LVL1CaloRun2ReadBSCfg
478  cfg.merge( LVL1CaloRun2ReadBSCfg(flags))
479 
480  l1caloCalibFile = f'tileCalibL1Calo_{runNumber}_{args.outputVersion}.root'
481  from TileCalibAlgs.TileTriggerCalibAlgConfig import TileTriggerCalibAlgCfg
482  cfg.merge( TileTriggerCalibAlgCfg(flags, FileName=l1caloCalibFile) )
483 
484  elif flags.Tile.RunType is TileRunType.CIS:
485  cisCalibFile = f'tileCalibCIS_{runNumber}_{args.outputVersion}.root'
486  from TileCalibAlgs.TileCisCalibAlgConfig import TileCisCalibAlgCfg
487  cfg.merge( TileCisCalibAlgCfg(flags, FileName=cisCalibFile) )
488 
489  elif flags.Tile.RunType in [TileRunType.PHY, TileRunType.PED]:
490  defaultVersions = ['0', 'Ped.0', 'Ped']
491 
492  fileVersion = f'_{flags.Tile.NoiseFilter}' if flags.Tile.NoiseFilter > 0 else ""
493  if args.outputVersion not in defaultVersions:
494  fileVersion = f'_{args.outputVersion}_tnf{flags.Tile.NoiseFilter}'
495 
496  from TileCalibAlgs.TileRawChNoiseCalibAlgConfig import TileRawChNoiseCalibAlgCfg
497  cfg.merge( TileRawChNoiseCalibAlgCfg(flags) )
498  rawChanNoiseCalibAlg = cfg.getEventAlgo('TileRawChNoiseCalibAlg')
499  rawChanNoiseCalibAlg.FileNamePrefix = f'{args.outputDirectory}/RawCh_NoiseCalib{fileVersion}'
500  if flags.Input.isMC:
501  rawChanNoiseCalibAlg.doFit = False
502  rawChanNoiseCalibAlg.doFixed = False
503  rawChanNoiseCalibAlg.doOpt = False
504  rawChanNoiseCalibAlg.doDsp = True
505  rawChanNoiseCalibAlg.UseforCells = 3 # i.e. from TileRawChannelCnt (like DSP)
506  else:
507  rawChanNoiseCalibAlg.doDsp = (flags.Tile.RunType is TileRunType.PHY)
508  rawChanNoiseCalibAlg.UseforCells = 1 # 1= Fixed , 2= Opt2
509 
510  # Produce digi noise ntuple only for default version
511  if args.outputVersion in defaultVersions:
512  from TileCalibAlgs.TileDigiNoiseCalibAlgConfig import TileDigiNoiseCalibAlgCfg
513  cfg.merge( TileDigiNoiseCalibAlgCfg(flags) )
514  digiNoiseCalibAlg = cfg.getEventAlgo('TileDigiNoiseCalibAlg')
515  digiNoiseCalibAlg.DoAvgCorr = False # False=> Full AutoCorr matrix calculation
516  digiNoiseCalibAlg.FileNamePrefix = f'{args.outputDirectory}/Digi_NoiseCalib{fileVersion}'
517 
518 
519  # =======>>> Set up the Tile output Jive XML files
520  if flags.Output.doJiveXML:
521  from TileMonitoring.TileJiveXMLConfig import TileAlgoJiveXMLCfg
522  cfg.merge(TileAlgoJiveXMLCfg(flags))
523 
524 
525  # =======>>> Set up the Tile output D3PD file
526  if args.d3pd:
527  d3pdFile = f'{args.outputDirectory}/tile_{runNumber}_{args.outputVersion}.aan.root'
528  from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
529  D3PDMakerFlags.DoTruth = flags.Input.isMC
530  from TileRecEx.TileD3PDConfig import TileD3PDCfg
531  cfg.merge( TileD3PDCfg(flags,
532  outputFile=d3pdFile,
533  saveCells=cellsAvailable,
534  saveMBTS=cellsAvailable,
535  saveE4pr=args.run2,
536  saveMuId=args.muid,
537  saveMuonFitter=args.muonfit,
538  saveClusters=args.clusters,
539  saveEventInfo=(flags.Tile.RunType is TileRunType.PHY)) )
540 
541  # =======>>> Set up the Tile output POOL file
542  if flags.Output.doWriteESD:
543  outputItemList = ["TileHitVector#*"]
544  outputItemList += ["TileDigitsContainer#*"]
545  outputItemList += ["TileBeamElemContainer#*"]
546  outputItemList += ["TileRawChannelContainer#*"]
547  outputItemList += ["TileCellContainer#*"]
548  outputItemList += ["CaloCellContainer#*"]
549  outputItemList += [ "TileMuContainer#*" ]
550  outputItemList += [ "TileL2Container#*" ]
551  outputItemList += [ "TileCosmicMuonContainer#*" ]
552 
553  from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
554  cfg.merge( OutputStreamCfg(flags, streamName='ESD', ItemList=outputItemList) )
555 
556  if args.run3:
557  if args.special_demo_shape and args.special_demo_shape > 0 and args.special_demo_shape <= 10:
558  tileInfoLoader = cfg.getService('TileInfoLoader')
559  if flags.RunType.getCommonType() is TileRunType.LAS:
560  # Disable special treatment for demo in laser runs for the moment
561  args.special_demo_shape = -1
562  elif flags.RunType.getCommonType() is TileRunType.CIS:
563  # Put CIS pulse shape for Demo in laser and physics structures
564  args.special_demo_shape = 3
565  tileInfoLoader.filename_lo_las = "pulselo_cis_demo_100.dat"
566  tileInfoLoader.filename_hi_las = "pulsehi_cis_demo_100.dat"
567  tileInfoLoader.filename_lo_las_der = "dpulselo_cis_demo_100.dat"
568  tileInfoLoader.filename_hi_las_der = "dpulsehi_cis_demo_100.dat"
569  tileInfoLoader.filename_lo_phys = "pulselo_cis_demo_5p2.dat"
570  tileInfoLoader.filename_hi_phys = "pulsehi_cis_demo_5p2.dat"
571  tileInfoLoader.filename_lo_phys_der = "dpulselo_cis_demo_5p2.dat"
572  tileInfoLoader.filename_hi_phys_der = "dpulsehi_cis_demo_5p2.dat"
573  else:
574  # Put physics pulse shape for Demo in laser structures
575  args.special_demo_shape = 2
576  tileInfoLoader.filename_lo_las = "pulselo_phys_demo.dat"
577  tileInfoLoader.filename_hi_las = "pulsehi_phys_demo.dat"
578  tileInfoLoader.filename_lo_las_der = "dpulselo_phys_demo.dat"
579  tileInfoLoader.filename_hi_las_der = "dpulsehi_phys_demo.dat"
580  else:
581  # Disable only leakage pulse in CIS/MonoCIS, but use the same pulse shape
582  if not args.special_demo_shape:
583  args.special_demo_shape = 9
584 
585  if args.special_demo_shape:
586  if flags.Tile.doFit:
587  fitFilter = cfg.getEventAlgo('TileRChMaker').TileRawChannelBuilder['TileRawChannelBuilderFitFilter']
588  fitFilter.SpecialDemoShape = args.special_demo_shape
589 
590  if flags.Input.Format is Format.BS:
591  cfg.getCondAlgo("TileHid2RESrcIDCondAlg").RODStatusProxy = None
592 
593  # =======>>> Any last things to do?
594  if args.postExec:
595  log.info('Executing postExec: %s', args.postExec)
596  exec(args.postExec)
597 
598  cfg.printConfig(withDetails=args.printDetailedConfig,
599  summariseProps=args.printDetailedConfig,
600  printDefaults=args.printDetailedConfig)
601 
602  if args.config_only:
603  cfg.store(open('RunTileCalibRec.pkl', 'wb'))
604  else:
605  sc = cfg.run()
606  # Success should be 0
607  sys.exit(0 if sc.isSuccess() else 1)
TileInputFiles.getArgumentParser
def getArgumentParser(**kwargs)
Definition: TileInputFiles.py:144
TileTriggerCalibAlgConfig.TileTriggerCalibAlgCfg
def TileTriggerCalibAlgCfg(flags, **kwargs)
Definition: TileTriggerCalibAlgConfig.py:53
TileRawChannelToHitConfig.TileRawChannelToHitCfg
def TileRawChannelToHitCfg(flags, **kwargs)
Definition: TileRawChannelToHitConfig.py:9
RunTileCalibRec.getArgumentParser
def getArgumentParser(flags)
Definition: RunTileCalibRec.py:39
SystemOfUnits
TileTMDBRawChannelMonitorAlgorithm.TileTMDBRawChannelMonitoringConfig
def TileTMDBRawChannelMonitoringConfig(flags, MuRcvRawChCnt="MuRcvRawChCnt", FillRawChannelHistograms=True, FillEfficiencyHistograms=False, **kwargs)
Definition: TileTMDBRawChannelMonitorAlgorithm.py:48
vtune_athena.format
format
Definition: vtune_athena.py:14
TileAANtupleConfig.TileAANtupleCfg
def TileAANtupleCfg(flags, outputFile='', saveTMDB=True, **kwargs)
Definition: TileAANtupleConfig.py:15
TileJiveXMLConfig.TileAlgoJiveXMLCfg
def TileAlgoJiveXMLCfg(flags, TileDigitsContainer=None, TileRawChannelContainer=None, CaloClusterContainer='TileTopoCluster', **kwargs)
Definition: TileJiveXMLConfig.py:57
TileRawChNoiseCalibAlgConfig.TileRawChNoiseCalibAlgCfg
def TileRawChNoiseCalibAlgCfg(flags, **kwargs)
Definition: TileRawChNoiseCalibAlgConfig.py:8
RunTileCalibRec.setOnlineEnvironment
def setOnlineEnvironment(alg)
Definition: RunTileCalibRec.py:379
TileLaserCalibAlgConfig.TileLaserCalibAlgCfg
def TileLaserCalibAlgCfg(flags, **kwargs)
Definition: TileLaserCalibAlgConfig.py:55
TileTMDBMonitorAlgorithm.TileTMDBMonitoringConfig
def TileTMDBMonitoringConfig(flags, **kwargs)
Definition: TileTMDBMonitorAlgorithm.py:12
python.OutputStreamConfig.OutputStreamCfg
def OutputStreamCfg(flags, streamName, ItemList=[], MetadataItemList=[], disableEventTag=False, trigNavThinningSvc=None, takeItemsFromInput=False, extendProvenanceRecord=True, keepProvenanceTagsRegEx=None, AcceptAlgs=[], HelperTools=[])
Definition: OutputStreamConfig.py:16
TileDigitsMonitorAlgorithm.TileDigitsMonitoringConfig
def TileDigitsMonitoringConfig(flags, **kwargs)
Definition: TileDigitsMonitorAlgorithm.py:11
TileCellMakerConfig.TileCellMakerCfg
def TileCellMakerCfg(flags, mergeChannels=True, **kwargs)
Definition: TileCellMakerConfig.py:32
RunTileCalibRec.TileMonPostProcessingAlg
Definition: RunTileCalibRec.py:452
LVL1CaloRun2ByteStreamConfig.LVL1CaloRun2ReadBSCfg
def LVL1CaloRun2ReadBSCfg(flags, forRoIBResultToxAOD=False)
Definition: LVL1CaloRun2ByteStreamConfig.py:121
TileRawChannelMonitorAlgorithm.TileRawChannelMonitoringConfig
def TileRawChannelMonitoringConfig(flags, overlapHistograms=None, **kwargs)
Definition: TileRawChannelMonitorAlgorithm.py:11
pool::DbPrintLvl::setLevel
void setLevel(MsgLevel l)
Definition: DbPrint.h:32
RunTileCalibRec.useTagFor
def useTagFor(tag, folder)
Definition: RunTileCalibRec.py:119
TileInputFiles.findFilesFromAgruments
def findFilesFromAgruments(args)
Definition: TileInputFiles.py:133
RunTileCalibRec.TileMonPostProcessingAlg.initialize
def initialize(self)
Definition: RunTileCalibRec.py:453
LArG4FSStartPointFilter.exec
exec
Definition: LArG4FSStartPointFilter.py:103
python.MainServicesConfig.MainServicesCfg
def MainServicesCfg(flags, LoopMgr='AthenaEventLoopMgr')
Definition: MainServicesConfig.py:260
TileCellMonitorAlgorithm.TileCellMonitoringConfig
def TileCellMonitoringConfig(flags, **kwargs)
Definition: TileCellMonitorAlgorithm.py:8
TileCisCalibAlgConfig.TileCisCalibAlgCfg
def TileCisCalibAlgCfg(flags, **kwargs)
Definition: TileCisCalibAlgConfig.py:43
TileTopoClusterConfig.TileTopoClusterCfg
def TileTopoClusterCfg(flags, **kwargs)
Definition: TileTopoClusterConfig.py:11
print
void print(char *figname, TCanvas *c1)
Definition: TRTCalib_StrawStatusPlots.cxx:25
TileDigiNoiseCalibAlgConfig.TileDigiNoiseCalibAlgCfg
def TileDigiNoiseCalibAlgCfg(flags, **kwargs)
Definition: TileDigiNoiseCalibAlgConfig.py:8
TrigJetMonitorAlgorithm.items
items
Definition: TrigJetMonitorAlgorithm.py:71
TileD3PDConfig.TileD3PDCfg
def TileD3PDCfg(flags, outputFile=None, saveCells=True, saveMBTS=True, saveE4pr=False, saveClusters=False, saveMuId=False, saveMuonFit=False, savePosition=True, saveEventInfo=False, **kwargs)
Definition: TileD3PDConfig.py:24
Trk::open
@ open
Definition: BinningType.h:40
RunTileCalibRec.useSqliteFor
def useSqliteFor(sqliteFile, folder)
Definition: RunTileCalibRec.py:126
TileDigiNoiseMonitorAlgorithm.TileDigiNoiseMonitoringConfig
def TileDigiNoiseMonitoringConfig(flags, **kwargs)
Definition: TileDigiNoiseMonitorAlgorithm.py:8
TileTMDBDigitsMonitorAlgorithm.TileTMDBDigitsMonitoringConfig
def TileTMDBDigitsMonitoringConfig(flags)
Definition: TileTMDBDigitsMonitorAlgorithm.py:10
python.AllConfigFlags.initConfigFlags
def initConfigFlags()
Definition: AllConfigFlags.py:19
TileDQFragMonitorAlgorithm.TileDQFragMonitoringConfig
def TileDQFragMonitoringConfig(flags, **kwargs)
Definition: TileDQFragMonitorAlgorithm.py:10
TileByteStreamConfig.TileRawDataReadingCfg
def TileRawDataReadingCfg(flags, readDigits=True, readRawChannel=True, readMuRcv=None, readMuRcvDigits=False, readMuRcvRawCh=False, readBeamElem=None, readLaserObj=None, readDigitsFlx=False, readL2=False, stateless=False, **kwargs)
Definition: TileByteStreamConfig.py:87
RunTileCalibRec.useSqliteAndTagFor
def useSqliteAndTagFor(sqliteFile, tag, folder)
Definition: RunTileCalibRec.py:133
TileRawChannelMakerConfig.TileRawChannelMakerCfg
def TileRawChannelMakerCfg(flags, **kwargs)
Definition: TileRawChannelMakerConfig.py:10
TileMuIdConfig.TileLookForMuAlgCfg
def TileLookForMuAlgCfg(flags, **kwargs)
Definition: TileMuIdConfig.py:12
TileMuonFitterConfig.TileMuonFitterCfg
def TileMuonFitterCfg(flags, **kwargs)
Definition: TileMuonFitterConfig.py:12
python.PoolReadConfig.PoolReadCfg
def PoolReadCfg(flags)
Definition: PoolReadConfig.py:69
python.Utils.unixtools.find_datafile
def find_datafile(fname, pathlist=None, access=os.R_OK)
pathresolver-like helper function --------------------------------------—
Definition: unixtools.py:67
TileRawChannelTimeMonitorAlgorithm.TileRawChannelTimeMonitoringConfig
def TileRawChannelTimeMonitoringConfig(flags, amplitudeFragIDs=None, **kwargs)
Definition: TileRawChannelTimeMonitorAlgorithm.py:11