def getMuonCalibAlg(eventTag): global topSequence, beamFlags try: return topSequence.MuonCalibAlg except AttributeError: from MuonCalibAlgs.MuonCalibAlgsConf import MuonCalib__MuonCalibAlg MuonCalibAlg = MuonCalib__MuonCalibAlg( "MuonCalibAlg", doMDTs=muonRecFlags.doMDTs(), doCSCs=muonRecFlags.doCSCs(), doRPCs=muonRecFlags.doRPCs(), doTGCs=(muonRecFlags.doTGCs() and muonRecFlags.calibNtupleRawTGC()), doTGCCoinData=(muonRecFlags.doTGCs() and muonRecFlags.calibNtupleRawTGC()), doTruth=rec.doTruth(), DoPrdSelect=muonRecFlags.doPrdSelect( ), # optional cutting away of PRD hits to simulate dead channels NtupleName=muonRecFlags.calibNtupleOutput( ), # set the name of the output calibration ntuple EventTag=eventTag) if beamFlags.beamType == 'singlebeam' or beamFlags.beamType == 'cosmics': MuonCalibAlg.addTriggerTag = False else: MuonCalibAlg.addTriggerTag = rec.doTrigger() MuonCalibAlg.doTruth = rec.doTruth() topSequence += MuonCalibAlg return topSequence.MuonCalibAlg
def BunchCrossingConfProvider(type=""): # Get ourselves a logger: from AthenaCommon.Logging import logging __logger = logging.getLogger("BunchCrossingConfProvider") # If the user requested some instance directly: if type != "": if type == "TrigConf": __logger.info("Forcing the usage of TrigConfBunchCrossingTool") from TrigBunchCrossingTool.BunchCrossingTool import TrigConfBunchCrossingTool return TrigConfBunchCrossingTool() elif type == "LHC": __logger.info("Forcing the usage of LHCBunchCrossingTool") from TrigBunchCrossingTool.BunchCrossingTool import LHCBunchCrossingTool return LHCBunchCrossingTool() elif type == "MC": from TrigBunchCrossingTool.BunchCrossingTool import MCBunchCrossingTool __logger.info("Forcing the usage of MCBunchCrossingTool") return MCBunchCrossingTool() else: __logger.warning("Type = " + type + " not recognized") __logger.warning("Will select tool type based on global flags") # Decide which tool to use based on the global flags: from AthenaCommon.GlobalFlags import globalflags if globalflags.isOverlay(): __logger.info("Selecting LHCBunchCrossingTool for overlay job") from TrigBunchCrossingTool.BunchCrossingTool import LHCBunchCrossingTool return LHCBunchCrossingTool() if globalflags.DataSource() == "data": from RecExConfig.RecFlags import rec from RecExConfig.RecAlgsFlags import recAlgs from TriggerJobOpts.TriggerFlags import TriggerFlags if rec.doTrigger() or TriggerFlags.doTriggerConfigOnly( ) or recAlgs.doTrigger(): from TrigBunchCrossingTool.BunchCrossingTool import TrigConfBunchCrossingTool __logger.info("Selecting TrigConfBunchCrossingTool for this job") return TrigConfBunchCrossingTool() else: __logger.info( "Trigger turned off, selecting LHCBunchCrossingTool for this job" ) from TrigBunchCrossingTool.BunchCrossingTool import LHCBunchCrossingTool return LHCBunchCrossingTool() else: __logger.info("Selecting MCBunchCrossingTool for this job") from TrigBunchCrossingTool.BunchCrossingTool import MCBunchCrossingTool return MCBunchCrossingTool()
def BunchCrossingConfProvider( type = "" ): # Get ourselves a logger: from AthenaCommon.Logging import logging __logger = logging.getLogger( "BunchCrossingConfProvider" ) # If the user requested some instance directly: if type != "": if type == "TrigConf": __logger.info( "Forcing the usage of TrigConfBunchCrossingTool" ) from TrigBunchCrossingTool.BunchCrossingTool import TrigConfBunchCrossingTool return TrigConfBunchCrossingTool() elif type == "LHC": __logger.info( "Forcing the usage of LHCBunchCrossingTool" ) from TrigBunchCrossingTool.BunchCrossingTool import LHCBunchCrossingTool return LHCBunchCrossingTool() elif type == "MC": from TrigBunchCrossingTool.BunchCrossingTool import MCBunchCrossingTool __logger.info( "Forcing the usage of MCBunchCrossingTool" ) return MCBunchCrossingTool() else: __logger.warning( "Type = " + type + " not recognized" ) __logger.warning( "Will select tool type based on global flags" ) # Decide which tool to use based on the global flags: from AthenaCommon.GlobalFlags import globalflags if globalflags.isOverlay(): __logger.info( "Selecting LHCBunchCrossingTool for overlay job" ) from TrigBunchCrossingTool.BunchCrossingTool import LHCBunchCrossingTool return LHCBunchCrossingTool() if globalflags.DataSource() == "data": from RecExConfig.RecFlags import rec from RecExConfig.RecAlgsFlags import recAlgs from TriggerJobOpts.TriggerFlags import TriggerFlags if rec.doTrigger() or TriggerFlags.doTriggerConfigOnly() or recAlgs.doTrigger(): from TrigBunchCrossingTool.BunchCrossingTool import TrigConfBunchCrossingTool __logger.info( "Selecting TrigConfBunchCrossingTool for this job" ) return TrigConfBunchCrossingTool() else: __logger.info( "Trigger turned off, selecting LHCBunchCrossingTool for this job" ) from TrigBunchCrossingTool.BunchCrossingTool import LHCBunchCrossingTool return LHCBunchCrossingTool() else: __logger.info( "Selecting MCBunchCrossingTool for this job" ) from TrigBunchCrossingTool.BunchCrossingTool import MCBunchCrossingTool return MCBunchCrossingTool()
# Offline AthenaMonitoring configuration # set DQMonFlags; defaults are in DataQualityTools/python/DQMonFlags.py ######################################################################## local_logger = logging.getLogger('DQMonFlagsConfig_jobOptions') if not 'DQMonFlags' in dir(): local_logger.debug("DQMonFlags not yet imported - I import them now") from AthenaMonitoring.DQMonFlags import DQMonFlags if not 'rec' in dir(): from RecExConfig.RecFlags import rec from RecExConfig.RecAlgsFlags import recAlgs if rec.doTrigger() == False: DQMonFlags.useTrigger = False # steers trigger-awareness DQMonFlags.doLVL1CaloMon = False DQMonFlags.doCTPMon = False DQMonFlags.doHLTMon = False # Set the data type based on beamType/HI flag if globalflags.DataSource.get_Value() == 'geant4': DQMonFlags.monManDataType = 'monteCarlo' elif rec.doHeavyIon(): DQMonFlags.monManDataType = 'heavyioncollisions' DQMonFlags.doHIMon = True elif jobproperties.Beam.beamType() == 'cosmics': DQMonFlags.monManDataType = 'cosmics' elif jobproperties.Beam.beamType() == 'collisions': DQMonFlags.monManDataType = 'collisions'
def configure(self): from AthenaCommon.Logging import logging mlog = logging.getLogger('CaloCellGetter::configure:') mlog.info('entering') doStandardCellReconstruction = True from CaloRec.CaloCellFlags import jobproperties if not jobproperties.CaloCellFlags.doFastCaloSim.statusOn: doFastCaloSim = False mlog.info("doFastCaloSim not set, so not using it") else: doFastCaloSim = jobproperties.CaloCellFlags.doFastCaloSim() if doFastCaloSim: mlog.info("doFastCaloSim requested") doStandardCellReconstruction = False if jobproperties.CaloCellFlags.doFastCaloSimAddCells(): doStandardCellReconstruction = True mlog.info( "doFastCaloSimAddCells requested: FastCaloSim is added to fullsim calorimeter" ) else: mlog.info( "doFastCaloSimAddCells not requested: Stand alone FastCaloSim is running" ) else: mlog.info("doFastCaloSim explicitly not requested") # get handle to upstream object # handle tile if doStandardCellReconstruction: # handle LAr import traceback try: from LArROD.LArRODFlags import larRODFlags from AthenaCommon.GlobalFlags import globalflags if larRODFlags.readDigits() and globalflags.DataSource( ) == 'data': from AthenaCommon.KeyStore import CfgItemList CfgItemList("KeyStore_inputFile").removeItem( "LArRawChannelContainer#LArRawChannels") if (not larRODFlags.readDigits() ) and globalflags.InputFormat() == 'bytestream': from AthenaCommon.AppMgr import ServiceMgr as svcMgr try: if not "LArRawChannelContainer/LArRawChannels" in svcMgr.ByteStreamAddressProviderSvc.TypeNames: svcMgr.ByteStreamAddressProviderSvc.TypeNames += [ "LArRawChannelContainer/LArRawChannels" ] except: mlog.warning( "Cannot remove LArRawChannelContainer/LArRawChannels from bytestream list" ) from LArROD.LArRawChannelGetter import LArRawChannelGetter theLArRawChannelGetter = LArRawChannelGetter() except: mlog.error("could not get handle to LArRawChannel Quit") print traceback.format_exc() return False if not theLArRawChannelGetter.usable(): if not self.ignoreConfigError(): mlog.error("LArRawChannelGetter unusable. Quit.") return False else: mlog.error( "LArRawChannelGetter unusable. Continue nevertheless") # writing of thinned digits if jobproperties.CaloCellFlags.doLArThinnedDigits.statusOn and jobproperties.CaloCellFlags.doLArThinnedDigits( ): from AthenaCommon.GlobalFlags import globalflags if globalflags.DataSource() == 'data': try: from LArROD.LArDigits import DefaultLArDigitThinner LArDigitThinner = DefaultLArDigitThinner( 'LArDigitThinner' ) # automatically added to topSequence LArDigitThinner.InputContainerName = "FREE" LArDigitThinner.OutputContainerName = "LArDigitContainer_Thinned" except Exception: treatException("Problem with LArDigitThinner ") # now configure the algorithm, part of this could be done in a separate class # cannot have same name try: from CaloRec.CaloRecConf import CaloCellMaker except: mlog.error("could not import CaloRec.CaloCellMaker") print traceback.format_exc() return False theCaloCellMaker = CaloCellMaker() self._CaloCellMakerHandle = theCaloCellMaker from AthenaCommon.AppMgr import ToolSvc if doStandardCellReconstruction: # configure CaloCellMaker here # check LArCellMakerTool_jobOptions.py for full configurability # FIXME from RecExConfig.RecFlags import rec if rec.doLArg(): try: from LArCellRec.LArCellRecConf import LArCellBuilderFromLArRawChannelTool theLArCellBuilder = LArCellBuilderFromLArRawChannelTool() except: mlog.error( "could not get handle to LArCellBuilderFromLArRawChannel Quit" ) print traceback.format_exc() return False if jobproperties.CaloCellFlags.doLArCreateMissingCells(): # bad channel tools try: from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool theLArBadChannelTool = LArBadChanTool() except: mlog.error("could not access bad channel tool Quit") print traceback.format_exc() return False ToolSvc += theLArBadChannelTool theLArCellBuilder.addDeadOTX = True theLArCellBuilder.badChannelTool = theLArBadChannelTool # add the tool to list of tool ( should use ToolHandle eventually) ToolSvc += theLArCellBuilder theCaloCellMaker.CaloCellMakerToolNames += [theLArCellBuilder] if rec.doTile(): from AthenaCommon.GlobalFlags import globalflags if globalflags.DataSource( ) == 'data' and globalflags.InputFormat() == 'bytestream': from AthenaCommon.AppMgr import ServiceMgr as svcMgr try: svcMgr.ByteStreamCnvSvc.ROD2ROBmap = ["-1"] if not "TileDigitsContainer/TileDigitsCnt" in svcMgr.ByteStreamAddressProviderSvc.TypeNames: svcMgr.ByteStreamAddressProviderSvc.TypeNames += [ "TileBeamElemContainer/TileBeamElemCnt", "TileDigitsContainer/TileDigitsCnt", "TileL2Container/TileL2Cnt", "TileLaserObject/TileLaserObj", "TileMuonReceiverContainer/TileMuRcvCnt" ] except: mlog.warning( "Cannot add TileDigitsContainer/TileDigitsCnt et al. to bytestream list" ) # set options for TileRawChannelMaker from TileRecUtils.TileRecFlags import jobproperties jobproperties.TileRecFlags.TileRunType = 1 # physics run type # reading of digits can be disabled before calling CaloCellGetter # if this is not done, but digits are not available in BS file # reading of digits is automatically disabled at start of run if jobproperties.TileRecFlags.readDigits() \ and not (jobproperties.TileRecFlags.doTileFlat \ or jobproperties.TileRecFlags.doTileFit \ or jobproperties.TileRecFlags.doTileFitCool \ or jobproperties.TileRecFlags.doTileOpt \ or jobproperties.TileRecFlags.doTileOF1 \ or jobproperties.TileRecFlags.doTileOpt2 \ or jobproperties.TileRecFlags.doTileOptATLAS \ or jobproperties.TileRecFlags.doTileMF): from AthenaCommon.BeamFlags import jobproperties # run Opt filter with iterations by default, both for cosmics and collisions before 2011 # run Opt filter without iterations for collisions in 2011 and later if not 'doTileOpt2' in dir(): from RecExConfig.AutoConfiguration import GetRunNumber rn = GetRunNumber() if rn > 0 and rn < 171194: doTileOpt2 = True elif jobproperties.Beam.beamType() == 'collisions': doTileOpt2 = False # use OF without iterations for collisions else: doTileOpt2 = True # always run OF with iterations for cosmics # jobproperties.TileRecFlags.calibrateEnergy=True; # use pCb for RawChannels # please, note that time correction and best phase are used only for collisions if doTileOpt2: jobproperties.TileRecFlags.doTileOpt2 = True # run optimal filter with iterations jobproperties.TileRecFlags.doTileOptATLAS = False # disable optimal filter without iterations jobproperties.TileRecFlags.correctAmplitude = False # don't do parabolic correction if jobproperties.Beam.beamType() == 'collisions': jobproperties.TileRecFlags.correctTime = True # apply time correction in physics runs jobproperties.TileRecFlags.BestPhaseFromCOOL = False # best phase is not needed for iterations else: jobproperties.TileRecFlags.doTileOpt2 = False # disable optimal filter with iterations jobproperties.TileRecFlags.doTileOptATLAS = True # run optimal filter without iterations jobproperties.TileRecFlags.correctAmplitude = True # apply parabolic correction if jobproperties.Beam.beamType() == 'collisions': jobproperties.TileRecFlags.correctTime = False # don't need time correction if best phase is used jobproperties.TileRecFlags.BestPhaseFromCOOL = True # use best phase stored in DB try: from TileRecUtils.TileRawChannelGetter import TileRawChannelGetter theTileRawChannelGetter = TileRawChannelGetter() except: mlog.error("could not load TileRawChannelGetter Quit") print traceback.format_exc() return False try: from TileRecAlgs.TileRecAlgsConf import TileDigitsFilter from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence += TileDigitsFilter() except: mlog.error("Could not configure TileDigitsFilter") try: from TileRecUtils.TileRecUtilsConf import TileCellBuilder theTileCellBuilder = TileCellBuilder() from TileRecUtils.TileRecFlags import jobproperties theTileCellBuilder.TileRawChannelContainer = jobproperties.TileRecFlags.TileRawChannelContainer( ) if not hasattr(ToolSvc, "TileBeamInfoProvider"): from TileRecUtils.TileRecUtilsConf import TileBeamInfoProvider ToolSvc += TileBeamInfoProvider() if globalflags.DataSource( ) == 'data' and globalflags.InputFormat() == 'bytestream': if jobproperties.TileRecFlags.readDigits(): # everything is already corrected at RawChannel level theTileCellBuilder.correctTime = False theTileCellBuilder.correctAmplitude = False else: ToolSvc.TileBeamInfoProvider.TileRawChannelContainer = "TileRawChannelCnt" # by default parameters are tuned for opt.filter without iterations theTileCellBuilder.correctTime = jobproperties.TileRecFlags.correctTime( ) theTileCellBuilder.correctAmplitude = jobproperties.TileRecFlags.correctAmplitude( ) theTileCellBuilder.AmpMinForAmpCorrection = jobproperties.TileRecFlags.AmpMinForAmpCorrection( ) if jobproperties.TileRecFlags.TimeMaxForAmpCorrection( ) <= jobproperties.TileRecFlags.TimeMinForAmpCorrection( ): from AthenaCommon.BeamFlags import jobproperties mlog.info( "adjusting min/max time of parabolic correction for %s" % jobproperties.Beam.bunchSpacing) halfBS = jobproperties.Beam.bunchSpacing.get_Value( ) / 2. jobproperties.TileRecFlags.TimeMinForAmpCorrection = -halfBS jobproperties.TileRecFlags.TimeMaxForAmpCorrection = halfBS if jobproperties.TileRecFlags.TimeMaxForAmpCorrection( ) > jobproperties.TileRecFlags.TimeMinForAmpCorrection( ): theTileCellBuilder.TimeMinForAmpCorrection = jobproperties.TileRecFlags.TimeMinForAmpCorrection( ) theTileCellBuilder.TimeMaxForAmpCorrection = jobproperties.TileRecFlags.TimeMaxForAmpCorrection( ) ToolSvc += theTileCellBuilder theCaloCellMaker.CaloCellMakerToolNames += [ theTileCellBuilder ] except: mlog.error("could not get handle to TileCellBuilder Quit") print traceback.format_exc() return False if doFastCaloSim: mlog.info('configuring FastCaloSim here') try: from FastCaloSim.FastCaloSimConf import EmptyCellBuilderTool theEmptyCellBuilderTool = EmptyCellBuilderTool() ToolSvc += theEmptyCellBuilderTool theCaloCellMaker.CaloCellMakerToolNames += [ theEmptyCellBuilderTool ] print theEmptyCellBuilderTool mlog.info("configure EmptyCellBuilderTool worked") except: mlog.error("could not get handle to EmptyCellBuilderTool Quit") print traceback.format_exc() return False try: from FastCaloSim.FastCaloSimFactory import FastCaloSimFactory theFastShowerCellBuilderTool = FastCaloSimFactory() ToolSvc += theFastShowerCellBuilderTool theCaloCellMaker.CaloCellMakerToolNames += [ theFastShowerCellBuilderTool ] mlog.info("configure FastShowerCellBuilderTool worked") except: mlog.error( "could not get handle to FastShowerCellBuilderTool Quit") print traceback.format_exc() return False doFastCaloSimNoise = jobproperties.CaloCellFlags.doFastCaloSimNoise( ) if doFastCaloSimNoise: try: from FastCaloSim.FastCaloSimConf import AddNoiseCellBuilderTool theAddNoiseCellBuilderTool = AddNoiseCellBuilderTool() from CaloTools.CaloNoiseToolDefault import CaloNoiseToolDefault theCaloNoiseTool = CaloNoiseToolDefault() from AthenaCommon.AppMgr import ToolSvc ToolSvc += theCaloNoiseTool theAddNoiseCellBuilderTool.CaloNoiseTool = theCaloNoiseTool.getFullName( ) print theAddNoiseCellBuilderTool ToolSvc += theAddNoiseCellBuilderTool theCaloCellMaker.CaloCellMakerToolNames += [ theAddNoiseCellBuilderTool ] mlog.info("configure AddNoiseCellBuilderTool worked") except: mlog.error( "could not get handle to AddNoiseCellBuilderTool Quit") print traceback.format_exc() return False # # CaloCellContainerFinalizerTool : closing container and setting up iterators # from CaloRec.CaloRecConf import CaloCellContainerFinalizerTool theCaloCellContainerFinalizerTool = CaloCellContainerFinalizerTool() ToolSvc += theCaloCellContainerFinalizerTool theCaloCellMaker.CaloCellMakerToolNames += [ theCaloCellContainerFinalizerTool ] # # Mergeing of calo cellcontainer with sparse raw channel container with improved energies # doLArMerge = False if globalflags.DataSource( ) == 'data' and jobproperties.CaloCellFlags.doLArRawChannelMerge.statusOn and jobproperties.CaloCellFlags.doLArRawChannelMerge( ): from LArROD.LArRODFlags import larRODFlags if larRODFlags.readDigits() and larRODFlags.keepDSPRaw(): doLArMerge = True if doLArMerge: try: from LArCellRec.LArCellRecConf import LArCellMerger theLArCellMerger = LArCellMerger() except: mlog.error("could not get handle to LArCellMerge Quit") print traceback.format_exc() return False theLArCellMerger.RawChannelsName = larRODFlags.RawChannelFromDigitsContainerName( ) ToolSvc += theLArCellMerger theCaloCellMaker.CaloCellMakerToolNames += [theLArCellMerger] # # masking of noisy and sporadic noisy cells in LAr # doNoiseMask = False if jobproperties.CaloCellFlags.doLArNoiseMasking.statusOn and jobproperties.CaloCellFlags.doLArNoiseMasking( ): doNoiseMask = True doSporadicMask = False if jobproperties.CaloCellFlags.doLArSporadicMasking.statusOn and jobproperties.CaloCellFlags.doLArSporadicMasking( ): doSporadicMask = True if doNoiseMask or doSporadicMask: try: from LArCellRec.LArCellRecConf import LArCellNoiseMaskingTool theLArCellNoiseMaskingTool = LArCellNoiseMaskingTool() except: mlog.error( "could not get handle to LArCellNoiseMaskingTool Quit") print traceback.format_exc() return False # bad channel tools try: from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool theLArBadChannelTool = LArBadChanTool() except: mlog.error("could not access bad channel tool Quit") print traceback.format_exc() return False ToolSvc += theLArBadChannelTool if doSporadicMask: try: from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker theLArSporadicNoiseMasker = LArBadChannelMasker( "LArSporadicNoiseMasker") except: mlog.error("could not access bad channel tool Quit") print traceback.format_exc() return False theLArSporadicNoiseMasker.TheLArBadChanTool = theLArBadChannelTool theLArSporadicNoiseMasker.DoMasking = True theLArSporadicNoiseMasker.ProblemsToMask = [ "sporadicBurstNoise" ] ToolSvc += theLArSporadicNoiseMasker theLArCellNoiseMaskingTool.MaskingSporadicTool = theLArSporadicNoiseMasker if doNoiseMask: try: from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker theLArNoiseMasker = LArBadChannelMasker("LArNoiseMasker") except: mlog.error("could not access bad channel tool Quit") print traceback.format_exc() return False theLArNoiseMasker.TheLArBadChanTool = theLArBadChannelTool theLArNoiseMasker.DoMasking = True theLArNoiseMasker.ProblemsToMask = [ "highNoiseHG", "highNoiseMG", "highNoiseLG", "deadReadout", "deadPhys" ] ToolSvc += theLArNoiseMasker theLArCellNoiseMaskingTool.MaskingTool = theLArNoiseMasker theLArCellNoiseMaskingTool.maskNoise = doNoiseMask theLArCellNoiseMaskingTool.maskSporadic = doSporadicMask # quality cut for sporadic noise masking theLArCellNoiseMaskingTool.qualityCut = 4000 ToolSvc += theLArCellNoiseMaskingTool theCaloCellMaker.CaloCellMakerToolNames += [ theLArCellNoiseMaskingTool ] # # masking of Feb problems # doBadFebMasking = False if jobproperties.CaloCellFlags.doLArBadFebMasking.statusOn and jobproperties.CaloCellFlags.doLArBadFebMasking( ): from AthenaCommon.GlobalFlags import globalflags if globalflags.DataSource() == 'data': doBadFebMasking = True if doBadFebMasking: try: from LArCellRec.LArCellRecConf import LArBadFebMaskingTool theLArBadFebMaskingTool = LArBadFebMaskingTool() if ( rec.doExpressProcessing() or athenaCommonFlags.isOnline() ): # In online or express processing, EventInfo::LArError is triggered if >=4 FEB with data corrupted theLArBadFebMaskingTool.minFebInError = 4 except: mlog.error("could not get handle to LArBadFebMaskingTool Quit") print traceback.format_exc() return False ToolSvc += theLArBadFebMaskingTool # bad channel tools try: from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool theLArBadChannelTool = LArBadChanTool() except: mlog.error("could not access bad channel tool Quit") print traceback.format_exc() return False ToolSvc += theLArBadChannelTool theLArBadFebMaskingTool.badChannelTool = theLArBadChannelTool theCaloCellMaker.CaloCellMakerToolNames += [ theLArBadFebMaskingTool ] # # emulate gain pathologies on MC # doGainPathology = False if jobproperties.CaloCellFlags.doLArCellGainPathology.statusOn and jobproperties.CaloCellFlags.doLArCellGainPathology( ): from AthenaCommon.GlobalFlags import globalflags if globalflags.DataSource() == 'geant4': doGainPathology = True if doGainPathology: try: from LArCellRec.LArCellRecConf import LArCellGainPathology theLArCellGainPathology = LArCellGainPathology() except: mlog.error("could not get handle to LArCellGainPatholog< Quit") print traceback.format_exc() return False ToolSvc += theLArCellGainPathology theCaloCellMaker.CaloCellMakerToolNames += [ theLArCellGainPathology ] # lar miscalibration if MC only (should be done after finalisation) if not jobproperties.CaloCellFlags.doLArCellEmMisCalib.statusOn: # the flag has not been set, so decide a reasonable default # this is the old global flags should use the new one as # soon as monitoring does from AthenaCommon.GlobalFlags import globalflags if globalflags.DataSource() == 'data': doLArCellEmMisCalib = False mlog.info( "jobproperties.CaloCellFlags.doLArMisCalib not set and real data: do not apply LArCellEmMisCalibTool" ) else: doLArCellEmMisCalib = True mlog.info( "jobproperties.CaloCellFlags.doLArMisCalib not set and Monte Carlo: apply LArCellEmMisCalibTool" ) else: doLArCellEmMisCalib = jobproperties.CaloCellFlags.doLArCellEmMisCalib( ) if doLArCellEmMisCalib: mlog.info("LArCellEmMisCalibTool requested") else: mlog.info("LArCellEmMisCalibTool explicitly not requested") if doLArCellEmMisCalib: try: from LArCellRec.LArCellRecConf import LArCellEmMiscalib theLArCellEmMiscalib = LArCellEmMiscalib("LArCellEmMiscalib") except: mlog.error("could not get handle to LArCellEmMisCalib Quit") print traceback.format_exc() return False # examples on how to change miscalibration. Default values are 0.005 and 0.007 # theLArCellEmMiscalib.SigmaPerRegion = 0.005; # theLArCellEmMiscalib.SigmaPerCell = 0.005; ToolSvc += theLArCellEmMiscalib try: from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool from CaloIdentifier import SUBCALO theMisCalibTool = CaloCellContainerCorrectorTool( "MisCalibTool", CaloNums=[SUBCALO.LAREM], CellCorrectionToolNames=[theLArCellEmMiscalib]) except: mlog.error("could not get handle to MisCalibTool Quit") print traceback.format_exc() return False ToolSvc += theMisCalibTool theCaloCellMaker.CaloCellMakerToolNames += [theMisCalibTool] # # Pedestal shift correction # doPedestalCorr = False if jobproperties.CaloCellFlags.doPedestalCorr.statusOn: from AthenaCommon.GlobalFlags import globalflags if jobproperties.CaloCellFlags.doPedestalCorr() and ( globalflags.DataSource() == 'data' or jobproperties.CaloCellFlags.doPileupOffsetBCIDCorr): doPedestalCorr = True mlog.info("Apply cell level pedestal shift correction") import os if doPedestalCorr: try: from CaloCellCorrection.CaloCellPedestalCorrDefault import CaloCellPedestalCorrDefault theCaloCellPedestalCorr = CaloCellPedestalCorrDefault() ToolSvc += theCaloCellPedestalCorr theCaloCellMaker.CaloCellMakerToolNames += [ theCaloCellPedestalCorr ] except: mlog.error("could not get handle to CaloCellPedestalCorr") print traceback.format_exc() # # HV correction for offline reprocessing, reading HV from Cool-DCS database # doHVCorr = False from AthenaCommon.DetFlags import DetFlags if DetFlags.dcs.LAr_on(): if jobproperties.CaloCellFlags.doLArHVCorr.statusOn: from AthenaCommon.GlobalFlags import globalflags if jobproperties.CaloCellFlags.doLArHVCorr( ) and globalflags.DataSource() == 'data': doHVCorr = True mlog.info( "Redoing HV correction at cell level from COOL/DCS database" ) if doHVCorr: from LArCellRec.LArCellHVCorrDefault import LArCellHVCorrDefault theLArCellHVCorr = LArCellHVCorrDefault() try: from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool from CaloIdentifier import SUBCALO theHVCorrTool = CaloCellContainerCorrectorTool( "HVCorrTool", CaloNums=[SUBCALO.LAREM, SUBCALO.LARHEC, SUBCALO.LARFCAL], CellCorrectionToolNames=[theLArCellHVCorr]) except: mlog.error("could not get handle to HVCorrTool Quit") print traceback.format_exc() return False ToolSvc += theHVCorrTool theCaloCellMaker.CaloCellMakerToolNames += [theHVCorrTool] # # correction to undo online calibration and apply new LAr electronics calibration for ADC->MeV conversion # doLArRecalibration = False if jobproperties.CaloCellFlags.doLArRecalibration.statusOn: from AthenaCommon.GlobalFlags import globalflags from LArConditionsCommon.LArCondFlags import larCondFlags if jobproperties.CaloCellFlags.doLArRecalibration( ) and globalflags.DataSource() == 'data' and ( not larCondFlags.SingleVersion()): doLArRecalibration = True mlog.info("Redoing LAr electronics calibration for ADC->MeV") if doLArRecalibration: # get tool for cell recalibration try: from LArCellRec.LArCellRecConf import LArCellRecalibration theLArCellRecalibration = LArCellRecalibration( "LArCellRecalibration") except: mlog.error("could not get handle to LArCellRecalibration Quit") print traceback.format_exc() return False ToolSvc += theLArCellRecalibration # get new ADC2MeVTool try: from LArRecUtils.LArADC2MeVToolDefault import LArADC2MeVToolDefault theLArADC2MeVToolDefault = LArADC2MeVToolDefault() except: mlog.error( "Could not get handle to LArADC2MeVToolDefault Quit") print traceback.format_exc() return False ToolSvc += theLArADC2MeVToolDefault # get old ADC2MeVTool try: from LArRecUtils.LArADC2MeVToolOnline import LArADC2MeVToolOnline theLArADC2MeVToolOnline = LArADC2MeVToolOnline() except: mlog.error("Could not get handle to LArADC2MeVToolOnline Quit") print traceback.format_exc() return False ToolSvc += theLArADC2MeVToolOnline theLArCellRecalibration.adc2MeVTool = theLArADC2MeVToolDefault theLArCellRecalibration.adc2MeVToolOnline = theLArADC2MeVToolOnline try: from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool from CaloIdentifier import SUBCALO theLArRecalibrationTool = CaloCellContainerCorrectorTool( "LArRecalibrationTool", CaloNums=[SUBCALO.LAREM, SUBCALO.LARHEC, SUBCALO.LARFCAL], CellCorrectionToolNames=[theLArCellRecalibration]) except: mlog.error("could not get handle to HVCorrTool Quit") print traceback.format_exc() return False ToolSvc += theLArRecalibrationTool theCaloCellMaker.CaloCellMakerToolNames += [ theLArRecalibrationTool ] # # Correction for MinBias energy shift for MC pileup reco # doMinBiasAverage = False if jobproperties.CaloCellFlags.doMinBiasAverage.statusOn: from AthenaCommon.GlobalFlags import globalflags from AthenaCommon.BeamFlags import jobproperties if jobproperties.CaloCellFlags.doMinBiasAverage( ) and globalflags.DataSource() == 'geant4' and ( not jobproperties.Beam.zeroLuminosity()): doMinBiasAverage = True if doMinBiasAverage: try: from CaloTools.CaloMBAverageToolDefault import CaloMBAverageToolDefault theCaloMBAverageTool = CaloMBAverageToolDefault() except: mlog.error("could not get handle to CaloMBAverageTool Quit") print traceback.format_exc() return False ToolSvc += theCaloMBAverageTool try: from CaloCellCorrection.CaloCellCorrectionConf import CaloCellMBAverageCorr theCaloCellMBAverageCorr = CaloCellMBAverageCorr( "CaloCellMBAverageCorr") theCaloCellMBAverageCorr.CaloMBAverageTool = theCaloMBAverageTool except: mlog.error( "could not get handle to CaloCellMBAverageCorr Quit") print traceback.format_exc() return False ToolSvc += theCaloCellMBAverageCorr try: from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool from CaloIdentifier import SUBCALO theMBAverageTool = CaloCellContainerCorrectorTool( "MBAverageTool", CaloNums=[SUBCALO.NSUBCALO], CellCorrectionToolNames=[theCaloCellMBAverageCorr]) except: mlog.error( "could not get handle to CaloCellContainerCorrectorTool/MBAverageTool Quit" ) print traceback.format_exc() return False ToolSvc += theMBAverageTool theCaloCellMaker.CaloCellMakerToolNames += [theMBAverageTool] # # Correction for dead cells, where we average the energy density of neighbor cells # doNeighborsAverage = False if jobproperties.CaloCellFlags.doDeadCellCorr.statusOn: if jobproperties.CaloCellFlags.doDeadCellCorr(): doNeighborsAverage = True if doNeighborsAverage: try: from CaloCellCorrection.CaloCellCorrectionConf import CaloCellNeighborsAverageCorr theCaloCellNeighborsAverageCorr = CaloCellNeighborsAverageCorr( "CaloCellNeighborsAverageCorr") theCaloCellNeighborsAverageCorr.testMode = False except: mlog.error( "could not get handle to CaloCellNeighborsAverageCorr Quit" ) print traceback.format_exc() return False ToolSvc += theCaloCellNeighborsAverageCorr theCaloCellMaker.CaloCellMakerToolNames += [ theCaloCellNeighborsAverageCorr ] # # correction for missing Febs based on L1 readout doLArDeadOTXCorr = False if jobproperties.CaloCellFlags.doLArDeadOTXCorr.statusOn and jobproperties.CaloCellFlags.doLArCreateMissingCells.statusOn: if jobproperties.CaloCellFlags.doLArDeadOTXCorr( ) and jobproperties.CaloCellFlags.doLArCreateMissingCells( ) and doStandardCellReconstruction: if rec.doTrigger(): doLArDeadOTXCorr = True else: mlog.warning( "Trigger is switched off. Can't run deadOTX correction." ) if doLArDeadOTXCorr: try: from LArCellRec.LArCellDeadOTXCorrToolDefault import LArCellDeadOTXCorrToolDefault theLArCellDeadOTXCorr = LArCellDeadOTXCorrToolDefault() except: mlog.error("could not get handle to LArCellDeadOTXCorr Quit") print traceback.format_exc() ToolSvc += theLArCellDeadOTXCorr theCaloCellMaker.CaloCellMakerToolNames += [theLArCellDeadOTXCorr] doCaloEnergyRescaler = False if jobproperties.CaloCellFlags.doCaloCellEnergyCorr( ) and globalflags.DataSource( ) == 'data' and not athenaCommonFlags.isOnline(): try: from CaloCellCorrection.CaloCellCorrectionConf import CaloCellEnergyRescaler theCCERescalerTool = CaloCellEnergyRescaler() theCCERescalerTool.Folder = "/LAR/CellCorrOfl/EnergyCorr" ToolSvc += theCCERescalerTool from IOVDbSvc.CondDB import conddb # conddb.addFolder("","/LAR/CellCorrOfl/EnergyCorr<tag>EnergyScale-00</tag><db>sqlite://;schema=escale.db;dbname=COMP200</db>") conddb.addFolder("LAR_OFL", "/LAR/CellCorrOfl/EnergyCorr") ToolSvc += theCCERescalerTool theCaloCellMaker.CaloCellMakerToolNames += [theCCERescalerTool] except: mlog.error( "could not get handle to CaloCellEnergyRescaler Quit") print traceback.format_exc() return False pass if jobproperties.CaloCellFlags.doCaloCellTimeCorr( ) and globalflags.DataSource( ) == 'data' and not athenaCommonFlags.isOnline(): try: from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool from CaloCellCorrection.CaloCellCorrectionConf import CaloCellTimeCorrTool theLArTimeCorr = CaloCellTimeCorrTool() theLArTimeCorr.Folder = "/LAR/TimeCorrectionOfl/CellTimeOffset" ToolSvc += theLArTimeCorr from IOVDbSvc.CondDB import conddb # conddb.addFolder("","/LAR/TimeCorrectionOfl/CellTimeOffset<tag>LARTimeCorrectionOflCellTimeOffset-empty</tag><db>sqlite://;schema=timecorr.db;dbname=COMP200</db>") conddb.addFolder("LAR_OFL", "/LAR/TimeCorrectionOfl/CellTimeOffset") theCaloTimeCorrTool = CaloCellContainerCorrectorTool( "LArTimeCorrTool", CellCorrectionToolNames=[theLArTimeCorr]) ToolSvc += theCaloTimeCorrTool theCaloCellMaker.CaloCellMakerToolNames += [ theCaloTimeCorrTool ] except: mlog.error("could not get handle to CaloCellTimeCorrTool Quit") print traceback.format_exc() return False pass # make lots of checks (should not be necessary eventually) # to print the check add: from CaloRec.CaloRecConf import CaloCellContainerCheckerTool theCaloCellContainerCheckerTool = CaloCellContainerCheckerTool() # FIXME # theCaloCellContainerCheckerTool.OutputLevel=DEBUG ToolSvc += theCaloCellContainerCheckerTool theCaloCellMaker.CaloCellMakerToolNames += [ theCaloCellContainerCheckerTool ] # # sets output key theCaloCellMaker.CaloCellsOutputName = self.outputKey() # register output in objKeyStore from RecExConfig.ObjKeyStore import objKeyStore objKeyStore.addStreamESD(self.outputType(), self.outputKey()) # now add algorithm to topSequence # this should always come at the end mlog.info(" now adding CaloCellMaker to topSequence") from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence += theCaloCellMaker return True
raise RuntimeError, " one and only one of readRDO (%s) readESD (%s) readAOD (%s) should be on !!!" % ( rec.readRDO(), rec.readESD(), rec.readAOD()) #now read input file to set up some flags accordingly if possible # load an OKS with the input data file from AthenaCommon.Include import excludeTracePattern excludeTracePattern.append("*/PyUtils/*") # if autoconfig not used, switched of doTruth for data if globalflags.DataSource == 'data' and not 'DoTruth' in rec.AutoConfiguration( ): rec.doTruth = False try: if rec.doTrigger(): from TriggerJobOpts.TriggerFlags import TriggerFlags, sync_Trigger2Reco except Exception: logRecExCommon_flags.info( "Could not load TriggerFlags. OK only if AtlasReconstruction. Switching of rec.doTrigger" ) rec.doTrigger = False #load commissioning flags here (major cleanup needed) if rec.Commissioning(): #-------------------------------------------------------------- # Common flags with RecExCommon #-------------------------------------------------------------- #if rec.readRDO: # include( "RecExCommission/RecExCommissionCommonFlags_jobOptions.py" )
#now read input file to set up some flags accordingly if possible # load an OKS with the input data file from AthenaCommon.Include import excludeTracePattern excludeTracePattern.append("*/PyUtils/*") # if autoconfig not used, switched of doTruth for data if globalflags.DataSource=='data' and not 'DoTruth' in rec.AutoConfiguration(): rec.doTruth=False try: if rec.doTrigger(): from TriggerJobOpts.TriggerFlags import TriggerFlags, sync_Trigger2Reco except Exception: logRecExCommon_flags.info("Could not load TriggerFlags. OK only if AtlasReconstruction. Switching of rec.doTrigger") rec.doTrigger=False #load commissioning flags here (major cleanup needed) if rec.Commissioning(): #-------------------------------------------------------------- # Common flags with RecExCommon #-------------------------------------------------------------- #if rec.readRDO: # include( "RecExCommission/RecExCommissionCommonFlags_jobOptions.py" )
def backgroundD3PD(alg=None, level=10, file='background.root', tuplename='background', flags=BackgroundD3PDMakerFlags, **kw): preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()) if (not hasattr(topSequence, 'BeamBackgroundFiller') and not hasattr(preseq, 'BeamBackgroundFiller')): if cfgKeyStore.isInInput("Trk::SegmentCollection", "ConvertedMBoySegments"): from RecBackgroundAlgs import RecBackgroundAlgsConf preseq += RecBackgroundAlgsConf.BeamBackgroundFiller() if (not hasattr(topSequence, 'BeamBackgroundFillerMoore') and not hasattr(preseq, 'BeamBackgroundFillerMoore')): if cfgKeyStore.isInInput("Trk::SegmentCollection", "MooreSegments"): from RecBackgroundAlgs.RecBackgroundAlgsConf import BeamBackgroundFiller BeamBackgroundFillerMoore = BeamBackgroundFiller( 'BeamBackgroundFillerMoore', muonSegmentContainerKey='MooreSegments', BeamBackgroundKey='BeamBackgroundDataMoore') preseq += BeamBackgroundFillerMoore # The core algorithm if not alg: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr alg = MSMgr.NewRootStream(tuplename, file) #Event level info alg += EventInfoD3PDObject(**_args(1, 'EventInfo', kw)) if globalflags.DataSource == "data": alg += LBLengthD3PDObject(**_args(0, 'LBLength', kw)) if rec.doTruth(): from TruthD3PDMaker.GenEventD3PDObject import GenEventD3PDObject alg += GenEventD3PDObject(**_args(0, 'GenEvent', kw)) if rec.doTrigger(): alg += TrigDecisionD3PDObject(**_args(2, 'TrigDecision', kw)) addTrigConfMetadata(alg) bcToolType = "" if globalflags.DataSource == "data": bcToolType = "LHC" addBunchStructureMetadata(alg, bcToolType) alg += BGCodeD3PDObject(**_args(2, 'BGCode', kw)) if flags.AddTriggerBits(): alg += getBkgdTriggerBitsD3PDObject([]) alg += BackgroundWordD3PDObject(**_args(0, 'BkgWord', kw)) if flags.doLUCID(): alg += Lucid_RawDataD3PDObject(**_args(0, 'Lucid', kw)) alg += RawInfoSummaryForTagD3PDObject(**_args(0, 'SumForTag', kw)) alg += MBTSD3PDObject(**_args(0, 'MBTS', kw)) alg += LArCollisionTimeD3PDObject(**_args(0, 'LArTimeDiff', kw)) if flags.doMet(): alg += MissingETD3PDObject(**_args(1, 'MET_RefFinal', kw, sgkey='MET_RefFinal', prefix='MET_RefFinal', allowMissing=True)) alg += MuonD3PDObject( **_args(0, 'Muon', kw, sgkey='MuonCollection', prefix='mu_', include=[ "Isolation", "Quality", "MuonTimingFillerTool", "MuonTileTimeTool", "ChamberT0" ], allowMissing=True)) alg += MuonD3PDObject( **_args(0, 'MuidMuon', kw, sgkey='MuidMuonCollection', prefix='mu_muid_', include=[ "Isolation", "Quality", "MuonTimingFillerTool", "MuonTileTimeTool", "ChamberT0" ], allowMissing=True)) alg += MuonD3PDObject( **_args(0, 'StacoMuon', kw, sgkey='StacoMuonCollection', prefix='mu_staco_', include=[ "Isolation", "Quality", "MuonTimingFillerTool", "MuonTileTimeTool", "ChamberT0" ], allowMissing=True)) if flags.doCaloMuon(): alg += MuonD3PDObject( **_args(0, 'CaloMuon', kw, sgkey='CaloMuonCollection', prefix='mu_calo_', include=[ "Isolation", "Quality", "MuonTimingFillerTool", "MuonTileTimeTool", "ChamberT0" ], allowMissing=True)) alg += MuonSegmentD3PDObject(**_args( 1, 'MuonSeg', kw, sgkey='MuonSegments', prefix='museg_', # MooreSegmentT0 takes the default time # MuonboySegmentT0 recalculates time (see MuonSegmentD3PDObject.py and MuonSegmentT0FillerTool.cxx) include=['MooreSegmentT0'], exclude=['MuonboySegmentT0'], allowMissing=True)) alg += MuonSegmentD3PDObject(**_args(1, 'MooreSeg', kw, sgkey='MooreSegments', prefix='mooreseg_', include=['MooreSegmentT0'], exclude=['MuonboySegmentT0'], allowMissing=True)) alg += MuonSegmentD3PDObject(**_args(1, 'MboySeg', kw, sgkey='ConvertedMBoySegments', prefix='mboyseg_', include=['MuonboySegmentT0'], exclude=['MooreSegmentT0'], allowMissing=True)) if flags.doMuGirlSeg(): alg += MuonSegmentD3PDObject(**_args(1, 'MuGirlSeg', kw, sgkey='MuGirlSegments', prefix='mgseg_', include=['MooreSegmentT0'], exclude=['MuonboySegmentT0'], allowMissing=True)) if flags.doTrk(): alg += xAODTrackParticleD3PDObject( **_args(0, 'TrackParticle', kw, prefix='trk_')) if flags.doMuonHits(): alg += MdtPrepDataD3PDObject(0) alg += RpcPrepDataD3PDObject(0) alg += CscPrepDataD3PDObject(0) alg += TgcPrepDataD3PDObject(0) alg += TgcPrepDataD3PDObject(**_args(0, 'TGC_MeasurementsPriorBC', kw, sgkey='TGC_MeasurementsPriorBC', prefix='tgcPriorBC_', label='TgcPrepDataPriorBC')) alg += TgcPrepDataD3PDObject(**_args(0, 'TGC_MeasurementsNextBC', kw, sgkey='TGC_MeasurementsNextBC', prefix='tgcNextBC_', label='TgcPrepDataNextBC')) if flags.doCaloJet(): #alg += JetD3PDObject (**_args(4,'AntiKt4TopoEMJets', kw, sgkey='AntiKt4TopoEMJets', prefix='AntiKt4TopoEM_', include='BeamBackground' )) if cfgKeyStore.isInInput("Trk::SegmentCollection", "ConvertedMBoySegments"): alg += JetD3PDObject( **_args(4, 'AntiKt4TopoEMJets', kw, sgkey='AntiKt4TopoEMJets', prefix='AntiKt4TopoEM_', include=['BeamBackground'], exclude=[ 'JetVertexFraction', 'JVtx', 'ActiveArea', 'TruthMF', 'TracksMoments' ], BeamBackground_BeamBackgroundKey='BeamBackgroundData')) else: alg += JetD3PDObject( **_args(4, 'AntiKt4TopoEMJets', kw, sgkey='AntiKt4TopoEMJets', prefix='AntiKt4TopoEM_', exclude=[ 'JetVertexFraction', 'JVtx', 'ActiveArea', 'TruthMF', 'TracksMoments' ])) else: alg += JetD3PDObject( **_args(4, 'AntiKt4TrackJets', kw, sgkey='AntiKt4TrackJets', prefix='AntiKt4Track_', exclude=[ 'JetVertexFraction', 'JVtx', 'ActiveArea', 'TruthMF', 'TracksMoments' ])) alg += PrimaryxAODVertexD3PDObject(0) if flags.doBeamBkgd(): #alg += BeamBackgroundD3PDObject(1) if cfgKeyStore.isInInput("Trk::SegmentCollection", "ConvertedMBoySegments"): alg += BeamBackgroundD3PDObject( **_args(1, 'BeamBackgroundData', kw, sgkey='BeamBackgroundData', prefix='bb_', bbJetIndex_Target='AntiKt4TopoEM_', bbClusterIndex_Target='cl_')) if cfgKeyStore.isInInput("Trk::SegmentCollection", "MooreSegments"): alg += BeamBackgroundD3PDObject( **_args(1, 'BeamBackgroundData', kw, sgkey='BeamBackgroundDataMoore', prefix='bbMoore_', bbJetIndex_Target='AntiKt4TopoEM_', bbClusterIndex_Target='cl_')) if flags.doBCM(): alg += BcmRdoFlatD3PDObject(**_args(0, 'BCMRdo', kw)) if flags.doZDC(): if globalflags.DataSource == "data": alg += ZdcD3PDObject(10) if flags.doPixelClus(): from InDetD3PDMaker.PixelClusterD3PDObject import PixelClusterD3PDObject alg += PixelClusterD3PDObject(0) if flags.doCaloClus(): from CaloSysD3PDMaker.ClusterD3PDObject import ClusterD3PDObject alg += ClusterD3PDObject(1) return alg
cleaning.CutLevel = "LooseBad" cleaning.DoUgly = False ToolSvc += cleaning ToolSvc.TileJetMonTool.do_jet_cleaning = True ToolSvc.TileJetMonTool.useJVTTool = jvt ToolSvc.TileJetMonTool.useJetCleaning = cleaning if DQMonFlags.monManDataType == 'heavyioncollisions': if not rec.doHIP(): ToolSvc.TileJetMonTool.jetCollectionName = 'AntiKt4HIJets' ToolSvc.TileJetMonTool.do_event_cleaning = False ToolSvc.TileJetMonTool.do_jet_cleaning = False ManagedAthenaTileMon.AthenaMonTools += [ ToolSvc.TileJetMonTool ] if (not 'doTileTMDBRawChannelMon' in dir() or doTileTMDBRawChannelMon) and (DQMonFlags.useTrigger() and rec.doTrigger()): from TileConditions.TileCondToolConf import getTileCondToolTMDB tileCondToolTMDB = getTileCondToolTMDB('COOL') if tileCondToolTMDB: ToolSvc += tileCondToolTMDB ToolSvc += CfgMgr.TileTMDBRawChannelMonTool(name = 'TileTMDBRawChannelDspMon' , OutputLevel = INFO , NotDSP = False , Efficiency = True , TileRawChannelContainer = "MuRcvRawChCnt" , TileCondToolTMDB = tileCondToolTMDB , histoPathBase = "/Tile/TMDBRawChannel/Dsp") ManagedAthenaTileMon.AthenaMonTools += [ ToolSvc.TileTMDBRawChannelDspMon ];
include.block ("EventTagUtils/RegistrationStreamTrig_jobOptions.py") from EventTagUtils.EventTagUtilsConf import RegistrationStreamTrig as ConfiguredRegistrationStreamTrig from RecExConfig.RecFlags import rec topSequence += ConfiguredRegistrationStreamTrig(GetTriggerConf = rec.doTrigger()) if not rec.doTrigger() : print "RegistrationStreamTrig_jobOptions.py::WARNING: No Trigger keys in metadata if rec.doTrigger()=false" print topSequence
def configure(config): """Configure the calibration input and output. If both segmentsKey and segmentCombisKey are defined, segmentsKey has priority.""" global topSequence, ToolSvc, MdtCalibTool, MuonSegmentToCalibSegment, MuonCalibAlg, MuonCalibTool, MuonCalibExtraTreeAlg, muonRecFlags log.info("Configuring with %s", config) calibMode = muonCalibFlags.Mode() # # Configure MuonSegmentToCalibSegment # try: MuonSegmentToCalibSegment = topSequence.MuonSegmentToCalibSegment except AttributeError: from MuonCalibPatRec.MuonCalibPatRecConf import MuonCalib__MuonSegmentToCalibSegment MuonSegmentToCalibSegment = MuonCalib__MuonSegmentToCalibSegment( "MuonSegmentToCalibSegment") topSequence += MuonSegmentToCalibSegment MuonSegmentToCalibSegment.UseCscSegments = muonRecFlags.doCSCs() # segmentsKey try: segmentsKey = config.segmentsKey except AttributeError: MuonSegmentToCalibSegment.ReadSegments = False else: MuonSegmentToCalibSegment.SegmentLocation = segmentsKey MuonSegmentToCalibSegment.ReadSegments = True # segmentCombisKey try: segmentCombisKey = config.segmentCombisKey except AttributeError: pass else: MuonSegmentToCalibSegment.SegmentCombiLocation = segmentCombisKey # # MuonCalibAlg # try: MuonCalibAlg = topSequence.MuonCalibAlg except AttributeError: from MuonCalibAlgs.MuonCalibAlgsConf import MuonCalib__MuonCalibAlg MuonCalibAlg = MuonCalib__MuonCalibAlg("MuonCalibAlg") topSequence += MuonCalibAlg if beamFlags.beamType() == 'singlebeam' or beamFlags.beamType( ) == 'cosmics': MuonCalibAlg.addTriggerTag = False else: MuonCalibAlg.addTriggerTag = recFlags.doTrigger() MuonCalibAlg.doMDTs = muonRecFlags.doMDTs() MuonCalibAlg.doCSCs = muonRecFlags.doCSCs() MuonCalibAlg.doRPCs = muonRecFlags.doRPCs() MuonCalibAlg.doTGCs = muonRecFlags.doTGCs() try: eventTag = config.eventTag except AttributeError: pass else: MuonCalibAlg.EventTag = eventTag MuonCalibAlg.doTruth = recFlags.doTruth() if calibMode == 'ntuple' or calibMode == 'trackNtuple': from MuonCalibTools.MuonCalibToolsConf import MuonCalib__PatternNtupleMaker MuonCalibTool = MuonCalib__PatternNtupleMaker() if calibMode == 'trackNtuple': if muonRecFlags.doSegmentsOnly(): log.warning( "Making ntuple instead of trackNtuple because making segments only" ) muonCalibFlags.Mode = 'ntuple' else: MuonCalibTool.DelayFinish = True try: MuonCalibExtraTreeAlg = topSequence.MuonCalibExtraTreeAlg except AttributeError: from MuonCalibExtraTreeAlg.MuonCalibExtraTreeAlgConf import MuonCalib__MuonCalibExtraTreeAlg MuonCalibExtraTreeAlg = MuonCalib__MuonCalibExtraTreeAlg( "MuonCalibExtraTreeAlg") MuonCalibExtraTreeAlg.NtupleName = "PatternNtupleMaker" topSequence += MuonCalibExtraTreeAlg # doPhi try: doPhi = config.doPhi except AttributeError: doPhi = False MuonCalibExtraTreeAlg.doPhi = doPhi # doTracks try: doTracks = config.doTracks except AttributeError: doTracks = False MuonCalibExtraTreeAlg.doTracks = doTracks # patternsKey try: patternsKey = config.patternsKey except AttributeError: pass else: MuonCalibExtraTreeAlg.PatternLocation = patternsKey # tracksKey try: tracksKey = config.tracksKey except AttributeError: pass else: MuonCalibExtraTreeAlg.TrackLocation = tracksKey else: # other calib modes from MdtCalibTools.MdtCalibToolsConf import MuonCalib__MdtCalibTool MuonCalibTool = MuonCalib__MdtCalibTool() if calibMode == 'regionNtuple': from MdtCalibTools.MdtCalibToolsConf import MuonCalib__MdtCalibNtupleMakerTool MdtCalibTool = MuonCalib__MdtCalibNtupleMakerTool() else: raise RuntimeError("Unknown Muon Calibration Mode: %r" % calibMode) ToolSvc += MdtCalibTool MuonCalibTool.MdtCalibTool = MdtCalibTool ToolSvc += MuonCalibTool MuonCalibAlg.MuonCalibTool = MuonCalibTool
######################################################################## # Conditions access # These lines were previously in SCT_Monitoring_ConditionsAccess.py ######################################################################## from SCT_Monitoring.SCT_MonitoringConf import SCTHitsNoiseMonTool InDetSCTHitsTool = SCTHitsNoiseMonTool ( name = "InDetSCTHitsNoiseMonTool", OutputLevel = 4, doHitmapHistos = False, CheckRate = 1000, doPositiveEndcap = True, doNegativeEndcap = True, doTrigger = globalflags.DataSource == "data") from RecExConfig.RecFlags import rec if not rec.doTrigger(): InDetSCTHitsTool.doTrigger=False InDetSCTHitsTool.tracksName = InDetKeys.SCTTracks() if InDetFlags.doTrackSegmentsSCT() else InDetKeys.UnslimmedTracks() ToolSvc += InDetSCTHitsTool if (InDetFlags.doPrintConfigurables()): print InDetSCTHitsTool from SCT_Monitoring.SCT_MonitoringConf import SCTTracksMonTool InDetSCTTracksMonTool = SCTTracksMonTool ( name = "InDetSCTTracksMonTool", OutputLevel = 4, CheckRate = 1000, doPositiveEndcap = True, doNegativeEndcap = True, doUnbiasedCalc = True,
ecTool.PtCut = jetPtMin ecTool.EtaCut = jet_tracking_eta_limit ecTool.JvtDecorator = "passJvt" ecTool.OrDecorator = "passOR" ecTool.CleaningLevel = cleaning.CutLevel ToolSvc += ecTool TileJetMonTool.useJVTTool = jvt TileJetMonTool.useJetCleaning = cleaning TileJetMonTool.useEventCleaning = ecTool TileJetMonTool.jet_tracking_eta_limit = jet_tracking_eta_limit ManagedAthenaTileMon.AthenaMonTools += [TileJetMonTool] if (not 'doTileTMDBRawChannelMon' in dir() or doTileTMDBRawChannelMon) and (DQMonFlags.useTrigger() and rec.doTrigger()): from TileConditions.TileCondToolConf import getTileCondToolTMDB tileCondToolTMDB = getTileCondToolTMDB('COOL') if tileCondToolTMDB: ToolSvc += tileCondToolTMDB TileTMDBRawChannelDspMon = CfgMgr.TileTMDBRawChannelMonTool( name='TileTMDBRawChannelDspMon', OutputLevel=INFO, NotDSP=False, Efficiency=True, TileRawChannelContainer="MuRcvRawChCnt", TileCondToolTMDB=tileCondToolTMDB, histoPathBase="/Tile/TMDBRawChannel/Dsp") ManagedAthenaTileMon.AthenaMonTools += [TileTMDBRawChannelDspMon] if tileRawMon:
globalflags.InputFormat = 'pool' globalflags.Luminosity = 'zero' #-------------------------------------------------------------- # --- switch on only Muon Detector #-------------------------------------------------------------- DetFlags.ID_setOff() DetFlags.detdescr.ID_setOn() DetFlags.Calo_setOff() DetFlags.detdescr.Calo_setOn() DetFlags.Muon_setOn() # no digitization DetFlags.digitize.all_setOff() if not recFlags.doTrigger(): DetFlags.LVL1_setOff() #-------------------------------------------------------------- # switch on writing of Full Calibration ntuple by default #-------------------------------------------------------------- muonRecFlags.doCalibNtuple = False muonRecFlags.calibNtupleSegments = False muonRecFlags.calibNtupleTracks = False muonRecFlags.calibNtupleTrigger = False #-------------------------------------------------------------- # select Standalone reconstruction #-------------------------------------------------------------- muonRecFlags.doStandalone = True
# Offline AthenaMonitoring configuration # set DQMonFlags; defaults are in DataQualityTools/python/DQMonFlags.py ######################################################################## local_logger = logging.getLogger('DQMonFlagsConfig_jobOptions') if not 'DQMonFlags' in dir(): local_logger.debug("DQMonFlags not yet imported - I import them now") from AthenaMonitoring.DQMonFlags import DQMonFlags if not 'rec' in dir(): from RecExConfig.RecFlags import rec from RecExConfig.RecAlgsFlags import recAlgs if rec.doTrigger() == False: DQMonFlags.useTrigger=False # steers trigger-awareness DQMonFlags.doLVL1CaloMon=False DQMonFlags.doCTPMon=False DQMonFlags.doHLTMon=False # Set the data type based on beamType/HI flag if globalflags.DataSource.get_Value() == 'geant4': DQMonFlags.monManDataType = 'monteCarlo' elif rec.doHeavyIon(): DQMonFlags.monManDataType = 'heavyioncollisions' DQMonFlags.doHIMon = True elif jobproperties.Beam.beamType() == 'cosmics': DQMonFlags.monManDataType = 'cosmics' elif jobproperties.Beam.beamType() == 'collisions': DQMonFlags.monManDataType = 'collisions'
#ManagedAthenaGlobalMon.AthenaMonTools += [ DQTGlobalWFinderTool ]; # Import BackgroundMon tool if DQMonFlags.useTrigger(): from DataQualityTools.DataQualityToolsConf import DQTBackgroundMon DQTBackgroundMon = DQTBackgroundMon( name='DQTBackgroundMon', histoPathBase="/GLOBAL/DQTBackgroundMon", doOfflineHists=isOffline, doOnlineHists=isOnline, doRunCosmics=isCosmics, doRunBeam=isBeam, doMuons=rec.doMuon(), doTrigger=rec.doTrigger()) ToolSvc += DQTBackgroundMon ManagedAthenaGlobalMon.AthenaMonTools += [DQTBackgroundMon] # Default values MinSCTHits = 5 MinPtCut = 4000 #For now, to increase statistics in cosmics data taking if athenaCommonFlags.isOnline == True: MinSCTHits = 0 MinPtCut = 500 # Import MuonID tool #from DataQualityTools.DataQualityToolsConf import DQTMuonIDTrackTool
## svcMgr.ByteStreamAddressProviderSvc.TypeNames += ["LArRawChannelContainer/LArRawChannels"] if DetFlags.readRDOBS.Tile_on(): svcMgr.ByteStreamAddressProviderSvc.TypeNames += [ "TileRawChannelContainer/TileRawChannelCnt", "TileL2Container/TileL2Cnt" ] if DetFlags.readRDOBS.LVL1_on(): svcMgr.ByteStreamAddressProviderSvc.TypeNames += [ "ROIB::RoIBResult/RoIBResult", "MuCTPI_RDO/MUCTPI_RDO", "CTP_RDO/CTP_RDO", "L1TopoRDOCollection/L1TopoRDOCollection" ] #if ATLASCosmicFlags.doLVL1Calo: if rec.doTrigger(): include("TrigT1CaloByteStream/ReadLVL1CaloBS_jobOptions.py") if rec.doTrigger(): if DetFlags.readRIOBS.Tile_on(): svcMgr.ByteStreamAddressProviderSvc.TypeNames += [ "TileCellIDC/TileCellIDC", ] if DetFlags.readRIOBS.pixel_on(): svcMgr.ByteStreamAddressProviderSvc.TypeNames += [ "Trk::PixelClusterContainer/PixelOnlineClusters", ] if DetFlags.readRIOBS.SCT_on(): svcMgr.ByteStreamAddressProviderSvc.TypeNames += [
if DetFlags.readRIOBS.RPC_on(): svcMgr.ByteStreamAddressProviderSvc.TypeNames += [ "RpcDigitContainer/RPC_DIGITS", "Muon::RpcPrepDataContainer/RPC_Measurements", ] if DetFlags.readRIOBS.TGC_on(): svcMgr.ByteStreamAddressProviderSvc.TypeNames += [ "TgcDigitContainer/TGC_DIGITS", "Muon::TgcPrepDataContainer/TGC_Measurements", ] if DetFlags.readRIOBS.CSC_on(): svcMgr.ByteStreamAddressProviderSvc.TypeNames += [ "CscDigitContainer/CSC_DIGITS", "Muon::CscPrepDataContainer/CSC_Clusters", ] if DetFlags.readRIOBS.LVL1_on(): svcMgr.ByteStreamAddressProviderSvc.TypeNames += [ "ROIB::RecRoIBResult/RecRoIBResult", "MuCTPI_RIO/MUCTPI_RIO", "CTP_RIO/CTP_RIO" ] from RecExConfig.RecFlags import rec if rec.doTrigger(): svcMgr.ByteStreamAddressProviderSvc.TypeNames += [ "HLT::HLTResult/HLTResult_L2", "HLT::HLTResult/HLTResult_EF" ]
def configure(self): if self._done: log.info("configuration already done, who is calling it again?") return True self._done = True # start with print some information what this will do log.info( "Basic configuration flags RecAlgsFlag.doTrigger: %d RecFlags.doTrigger: %d TriggerFlags.doTriggerConfigOnly %d", recAlgs.doTrigger(), rec.doTrigger(), TF.doTriggerConfigOnly()) log.info( "TriggerFlags: doL1Topo: %s, doLVL1: %s, doLVL2: %s, doEF: %s, doHLT: %s, doMT: %s", TF.doL1Topo(), TF.doLVL1(), TF.doLVL2(), TF.doEF(), TF.doHLT(), TF.doMT()) # RDOtoRDOTrigger MT temporarily coded in the transform skeleton, so skip here if TF.doMT() and rec.readRDO() and rec.doWriteRDO(): log.info("Nothing happens in TriggerGetter for RDOtoRDOTrigger MT") return True else: #GenerateMenu imports slice flags, which are Menu/MenuMT dependent from TriggerMenu.menu.GenerateMenu import GenerateMenu willGenerateMenu = recAlgs.doTrigger() and ( TF.doLVL1() or TF.doLVL2() or TF.doEF() or TF.doHLT()) and not TF.doTriggerConfigOnly() willRunTriggerConfigGetter = recAlgs.doTrigger() or rec.doTrigger( ) or TF.doTriggerConfigOnly() willRunLVL1SimulationGetter = recAlgs.doTrigger( ) and not TF.doTriggerConfigOnly() willRunHLTSimulationGetter = willRunLVL1SimulationGetter and ( TF.doLVL2() or TF.doEF() or TF.doHLT()) log.info( "Will run: %s%s%s%s", "GenerateMenu " if willGenerateMenu else "", "TriggerConfigGetter " if willRunTriggerConfigGetter else "", "LVL1SimulationGetter " if willRunLVL1SimulationGetter else "", "HLTSimulationGetter " if willRunHLTSimulationGetter else "") log.info( "Will not run: %s%s%s%s", "GenerateMenu " if not willGenerateMenu else "", "TriggerConfigGetter " if not willRunTriggerConfigGetter else "", "LVL1SimulationGetter " if not willRunLVL1SimulationGetter else "", "HLTSimulationGetter " if not willRunHLTSimulationGetter else "") if recAlgs.doTrigger(): if ((TF.doLVL1() or TF.doLVL2() or TF.doEF() or TF.doHLT()) and not TF.doTriggerConfigOnly()): log.info("generating menu") # trigger menu files generation g = GenerateMenu() g.generate() # after the menu xml file has been created or the TriggerDB access is configured, # the COOL/SQlite db can be written # TB this needs to be optimized -- we do not need ti always but only when AOD or ESD are created if recAlgs.doTrigger() or rec.doTrigger() or TF.doTriggerConfigOnly(): # setup configuration services from TriggerJobOpts.TriggerConfigGetter import TriggerConfigGetter cfg = TriggerConfigGetter() # noqa: F841 from TrigConfigSvc.TrigConf2COOL import theConfCOOLWriter theConfCOOLWriter.writeConf2COOL() # preconfigure TrigDecisionTool from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool from AthenaCommon.AppMgr import ToolSvc ToolSvc += Trig__TrigDecisionTool("TrigDecisionTool") from PyUtils.MetaReaderPeekerFull import metadata if "metadata_items" in metadata and any( ('TriggerMenu' in key) for key in metadata["metadata_items"].keys()): # Use xAOD configuration. from AthenaCommon.AppMgr import ServiceMgr as svcMgr if not hasattr(svcMgr, 'xAODConfigSvc'): from TrigConfxAOD.TrigConfxAODConf import TrigConf__xAODConfigSvc svcMgr += TrigConf__xAODConfigSvc('xAODConfigSvc') ToolSvc += Trig__TrigDecisionTool("TrigDecisionTool") ToolSvc.TrigDecisionTool.TrigConfigSvc = svcMgr.xAODConfigSvc else: # Use TrigConfigSvc ToolSvc.TrigDecisionTool.TrigConfigSvc = "TrigConf::TrigConfigSvc/TrigConfigSvc" from TrigEDMConfig.TriggerEDM import EDMLibraries ToolSvc.TrigDecisionTool.Navigation.Dlls = [ e for e in EDMLibraries if 'TPCnv' not in e ] # actuall trigger simulation running if recAlgs.doTrigger() and not TF.doTriggerConfigOnly(): # setup Lvl1 # initialize LVL1ConfigSvc log.info("configuring lvl1") from TriggerJobOpts.Lvl1TriggerGetter import Lvl1SimulationGetter lvl1 = Lvl1SimulationGetter() # noqa: F841 if TF.doTransientByteStream() or ( jobproperties.Global.InputFormat() != 'bytestream' and (TF.doLVL2() or TF.doEF() or TF.doHLT())): # Transient BS construction and intialization from ByteStreamCnvSvc import WriteByteStream StreamBS = WriteByteStream.getStream("Transient", "StreamBS") StreamBS.ItemList += [ "DataVector<LVL1::TriggerTower>#TriggerTowers" ] StreamBS.ItemList += ["TRT_RDO_Container#TRT_RDOs"] StreamBS.ItemList += ["SCT_RDO_Container#SCT_RDOs"] StreamBS.ItemList += ["PixelRDO_Container#PixelRDOs"] # StreamBS.ItemList +=["LArRawChannelContainer#*"] StreamBS.ItemList += ["2721#*"] # StreamBS.ItemList +=["TileRawChannelContainer#*"] StreamBS.ItemList += ["2927#*"] StreamBS.ItemList += [ "2934#*" ] # added on request from: Arantxa Ruiz Martinez for TileRODMu # don't need Muons in transient BS # StreamBS.ItemList +=["MdtCsmContainer#*"] # StreamBS.ItemList +=["RpcPadContainer#*"] # StreamBS.ItemList +=["TgcRdoContainer#*"] # StreamBS.ItemList +=["CscRawDataContainer#*"] from AthenaCommon.Include import include # setup trans BS for the ID include("InDetRecExample/InDetRecCabling.py") # setup HLT # initialize HLT config svc log.info("TriggerFlags: doLVL2 %r", TF.doLVL2()) log.info("TriggerFlags: doEF %r", TF.doEF()) log.info("TriggerFlags: doHLT %r", TF.doHLT()) if TF.doLVL2() or TF.doEF() or TF.doHLT(): log.info("configuring hlt") from TriggerJobOpts.HLTTriggerGetter import HLTSimulationGetter hlt = HLTSimulationGetter(g) # noqa: F841 else: from RegionSelector.RegSelSvcDefault import RegSelSvcDefault from AthenaCommon.AppMgr import ServiceMgr ServiceMgr += RegSelSvcDefault() ServiceMgr.RegSelSvc.enablePixel = False ServiceMgr.RegSelSvc.enableSCT = False # prepare result making of L1 from TriggerJobOpts.Lvl1ResultBuilderGetter import Lvl1ResultBuilderGetter hltouput = Lvl1ResultBuilderGetter() # prepare result making of HLT if TF.doLVL2() or TF.doEF() or TF.doHLT() or (recAlgs.doTrigger() and TF.readBS()): from TriggerJobOpts.HLTTriggerResultGetter import HLTTriggerResultGetter hltouput = HLTTriggerResultGetter() # noqa: F841 return True
def configure(self): from AthenaCommon.Logging import logging mlog = logging.getLogger('CaloCellGetter_DigiHSTruth::configure:') mlog.info('entering') doStandardCellReconstruction = True from CaloRec.CaloCellFlags import jobproperties # get handle to upstream object # handle tile if doStandardCellReconstruction: from LArROD.LArRODFlags import larRODFlags # now configure the algorithm, part of this could be done in a separate class # cannot have same name try: from CaloRec.CaloRecConf import CaloCellMaker except Exception: mlog.error("could not import CaloRec.CaloCellMaker") print(traceback.format_exc()) return False theCaloCellMaker = CaloCellMaker("CaloCellMaker_DigiHSTruth") self._CaloCellMakerHandle = theCaloCellMaker from AthenaCommon.AppMgr import ToolSvc if doStandardCellReconstruction: # configure CaloCellMaker here # check LArCellMakerTool_jobOptions.py for full configurability # FIXME if rec.doLArg(): from LArCabling.LArCablingAccess import LArOnOffIdMapping LArOnOffIdMapping() try: from LArCellRec.LArCellRecConf import LArCellBuilderFromLArRawChannelTool theLArCellBuilder = LArCellBuilderFromLArRawChannelTool( "LArCellBuilder_DigiHSTruth") theLArCellBuilder.RawChannelsName = "LArRawChannels_DigiHSTruth" except Exception: mlog.error( "could not get handle to LArCellBuilderFromLArRawChannel Quit" ) print(traceback.format_exc()) return False if jobproperties.CaloCellFlags.doLArCreateMissingCells(): theLArCellBuilder.addDeadOTX = True # add the tool to list of tool ( should use ToolHandle eventually) theCaloCellMaker += theLArCellBuilder theCaloCellMaker.CaloCellMakerToolNames += [theLArCellBuilder] if rec.doTile(): try: from TileRecUtils.TileRecUtilsConf import TileCellBuilder theTileCellBuilder = TileCellBuilder( "TileCellBuilder_DigiHSTruth") theTileCellBuilder.TileRawChannelContainer = "TileRawChannelCnt_DigiHSTruth" theTileCellBuilder.E4prContainer = "E4prContainer2_DigiHSTruth" theTileCellBuilder.MBTSContainer = "MBTSContainer2_DigiHSTruth" theTileCellBuilder.TileDSPRawChannelContainer = "TileRawChannelCnt_DigiHSTruth" theCaloCellMaker += theTileCellBuilder theCaloCellMaker.CaloCellMakerToolNames += [ theTileCellBuilder ] except Exception: mlog.error("could not get handle to TileCellBuilder Quit") print(traceback.format_exc()) return False # # CaloCellContainerFinalizerTool : closing container and setting up iterators # from CaloRec.CaloRecConf import CaloCellContainerFinalizerTool theCaloCellContainerFinalizerTool = CaloCellContainerFinalizerTool( "CaloCellContainerFinalizerTool_DigiHSTruth") theCaloCellMaker += theCaloCellContainerFinalizerTool theCaloCellMaker.CaloCellMakerToolNames += [ theCaloCellContainerFinalizerTool ] # # Mergeing of calo cellcontainer with sparse raw channel container with improved energies # doLArMerge = False if doLArMerge: try: from LArCellRec.LArCellRecConf import LArCellMerger theLArCellMerger = LArCellMerger() except Exception: mlog.error("could not get handle to LArCellMerge Quit") print(traceback.format_exc()) return False theLArCellMerger.RawChannelsName = larRODFlags.RawChannelFromDigitsContainerName( ) theCaloCellMaker += theLArCellMerger theCaloCellMaker.CaloCellMakerToolNames += [theLArCellMerger] # # masking of noisy and sporadic noisy cells in LAr # doNoiseMask = False if jobproperties.CaloCellFlags.doLArNoiseMasking.statusOn and jobproperties.CaloCellFlags.doLArNoiseMasking( ): doNoiseMask = True doSporadicMask = False if jobproperties.CaloCellFlags.doLArSporadicMasking.statusOn and jobproperties.CaloCellFlags.doLArSporadicMasking( ): doSporadicMask = True if doNoiseMask or doSporadicMask: try: from LArCellRec.LArCellRecConf import LArCellNoiseMaskingTool theLArCellNoiseMaskingTool = LArCellNoiseMaskingTool() except Exception: mlog.error( "could not get handle to LArCellNoiseMaskingTool Quit") print(traceback.format_exc()) return False if doSporadicMask: try: from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker theLArSporadicNoiseMasker = LArBadChannelMasker( "LArSporadicNoiseMasker") except Exception: mlog.error("could not access bad channel tool Quit") print(traceback.format_exc()) return False theLArSporadicNoiseMasker.DoMasking = True theLArSporadicNoiseMasker.ProblemsToMask = [ "sporadicBurstNoise" ] ToolSvc += theLArSporadicNoiseMasker theLArCellNoiseMaskingTool.MaskingSporadicTool = theLArSporadicNoiseMasker if doNoiseMask: try: from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker theLArNoiseMasker = LArBadChannelMasker("LArNoiseMasker") except Exception: mlog.error("could not access bad channel tool Quit") print(traceback.format_exc()) return False theLArNoiseMasker.DoMasking = True theLArNoiseMasker.ProblemsToMask = [ "highNoiseHG", "highNoiseMG", "highNoiseLG", "deadReadout", "deadPhys" ] ToolSvc += theLArNoiseMasker theLArCellNoiseMaskingTool.MaskingTool = theLArNoiseMasker theLArCellNoiseMaskingTool.maskNoise = doNoiseMask theLArCellNoiseMaskingTool.maskSporadic = doSporadicMask # quality cut for sporadic noise masking theLArCellNoiseMaskingTool.qualityCut = 4000 theCaloCellMaker += theLArCellNoiseMaskingTool theCaloCellMaker.CaloCellMakerToolNames += [ theLArCellNoiseMaskingTool ] # # masking of Feb problems # doBadFebMasking = False if doBadFebMasking: try: from LArCellRec.LArCellRecConf import LArBadFebMaskingTool theLArBadFebMaskingTool = LArBadFebMaskingTool() if ( rec.doExpressProcessing() or athenaCommonFlags.isOnline() ): # In online or express processing, EventInfo::LArError is triggered if >=4 FEB with data corrupted theLArBadFebMaskingTool.minFebInError = 4 except Exception: mlog.error("could not get handle to LArBadFebMaskingTool Quit") print(traceback.format_exc()) return False theCaloCellMaker += theLArBadFebMaskingTool theCaloCellMaker.CaloCellMakerToolNames += [ theLArBadFebMaskingTool ] # # emulate gain pathologies on MC # doGainPathology = False if jobproperties.CaloCellFlags.doLArCellGainPathology.statusOn and jobproperties.CaloCellFlags.doLArCellGainPathology( ): if globalflags.DataSource() == 'geant4': doGainPathology = True if doGainPathology: try: from LArCellRec.LArCellRecConf import LArCellGainPathology theLArCellGainPathology = LArCellGainPathology() except Exception: mlog.error("could not get handle to LArCellGainPatholog< Quit") print(traceback.format_exc()) return False theCaloCellMaker += theLArCellGainPathology theCaloCellMaker.CaloCellMakerToolNames += [ theLArCellGainPathology ] # lar miscalibration if MC only (should be done after finalisation) if not jobproperties.CaloCellFlags.doLArCellEmMisCalib.statusOn: # the flag has not been set, so decide a reasonable default # this is the old global flags should use the new one as # soon as monitoring does doLArCellEmMisCalib = True mlog.info( "jobproperties.CaloCellFlags.doLArMisCalib not set and Monte Carlo: apply LArCellEmMisCalibTool" ) else: doLArCellEmMisCalib = jobproperties.CaloCellFlags.doLArCellEmMisCalib( ) if doLArCellEmMisCalib: mlog.info("LArCellEmMisCalibTool requested") else: mlog.info("LArCellEmMisCalibTool explicitly not requested") if doLArCellEmMisCalib: try: from LArCellRec.LArCellRecConf import LArCellEmMiscalib theLArCellEmMiscalib = LArCellEmMiscalib("LArCellEmMiscalib") except Exception: mlog.error("could not get handle to LArCellEmMisCalib Quit") print(traceback.format_exc()) return False # examples on how to change miscalibration. Default values are 0.005 and 0.007 # theLArCellEmMiscalib.SigmaPerRegion = 0.005 # theLArCellEmMiscalib.SigmaPerCell = 0.005 ToolSvc += theLArCellEmMiscalib try: from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool from CaloIdentifier import SUBCALO theMisCalibTool = CaloCellContainerCorrectorTool( "MisCalibTool", CaloNums=[SUBCALO.LAREM], CellCorrectionToolNames=[theLArCellEmMiscalib]) except Exception: mlog.error("could not get handle to MisCalibTool Quit") print(traceback.format_exc()) return False theCaloCellMaker += theMisCalibTool theCaloCellMaker.CaloCellMakerToolNames += [theMisCalibTool] # # Pedestal shift correction # doPedestalCorr = False if jobproperties.CaloCellFlags.doPedestalCorr.statusOn: if jobproperties.CaloCellFlags.doPedestalCorr() and ( jobproperties.CaloCellFlags.doPileupOffsetBCIDCorr): doPedestalCorr = True mlog.info("Apply cell level pedestal shift correction") if doPedestalCorr: try: from CaloCellCorrection.CaloCellPedestalCorrDefault import CaloCellPedestalCorrDefault theCaloCellPedestalCorr = CaloCellPedestalCorrDefault() theCaloCellMaker += theCaloCellPedestalCorr theCaloCellMaker.CaloCellMakerToolNames += [ theCaloCellPedestalCorr ] except Exception: mlog.error("could not get handle to CaloCellPedestalCorr") print(traceback.format_exc()) # # Correction for MinBias energy shift for MC pileup reco # doMinBiasAverage = False if jobproperties.CaloCellFlags.doMinBiasAverage.statusOn: from AthenaCommon.BeamFlags import jobproperties if jobproperties.CaloCellFlags.doMinBiasAverage( ) and globalflags.DataSource() == 'geant4' and ( not jobproperties.Beam.zeroLuminosity()): doMinBiasAverage = True if doMinBiasAverage: try: from CaloTools.CaloMBAverageToolDefault import CaloMBAverageToolDefault theCaloMBAverageTool = CaloMBAverageToolDefault() except Exception: mlog.error("could not get handle to CaloMBAverageTool Quit") print(traceback.format_exc()) return False ToolSvc += theCaloMBAverageTool try: from CaloCellCorrection.CaloCellCorrectionConf import CaloCellMBAverageCorr theCaloCellMBAverageCorr = CaloCellMBAverageCorr( "CaloCellMBAverageCorr") theCaloCellMBAverageCorr.CaloMBAverageTool = theCaloMBAverageTool except Exception: mlog.error( "could not get handle to CaloCellMBAverageCorr Quit") print(traceback.format_exc()) return False ToolSvc += theCaloCellMBAverageCorr try: from CaloRec.CaloRecConf import CaloCellContainerCorrectorTool from CaloIdentifier import SUBCALO theMBAverageTool = CaloCellContainerCorrectorTool( "MBAverageTool", CaloNums=[SUBCALO.NSUBCALO], CellCorrectionToolNames=[theCaloCellMBAverageCorr]) except Exception: mlog.error( "could not get handle to CaloCellContainerCorrectorTool/MBAverageTool Quit" ) print(traceback.format_exc()) return False theCaloCellMaker += theMBAverageTool theCaloCellMaker.CaloCellMakerToolNames += [theMBAverageTool] # # Correction for dead cells, where we average the energy density of neighbor cells # doNeighborsAverage = False if jobproperties.CaloCellFlags.doDeadCellCorr.statusOn: if jobproperties.CaloCellFlags.doDeadCellCorr(): doNeighborsAverage = True if doNeighborsAverage: try: from CaloCellCorrection.CaloCellCorrectionConf import CaloCellNeighborsAverageCorr theCaloCellNeighborsAverageCorr = CaloCellNeighborsAverageCorr( "CaloCellNeighborsAverageCorr") theCaloCellNeighborsAverageCorr.testMode = False except Exception: mlog.error( "could not get handle to CaloCellNeighborsAverageCorr Quit" ) print(traceback.format_exc()) return False theCaloCellMaker += theCaloCellNeighborsAverageCorr theCaloCellMaker.CaloCellMakerToolNames += [ theCaloCellNeighborsAverageCorr ] # # correction for missing Febs based on L1 readout doLArDeadOTXCorr = False if jobproperties.CaloCellFlags.doLArDeadOTXCorr.statusOn and jobproperties.CaloCellFlags.doLArCreateMissingCells.statusOn: if jobproperties.CaloCellFlags.doLArDeadOTXCorr( ) and jobproperties.CaloCellFlags.doLArCreateMissingCells( ) and doStandardCellReconstruction: if rec.doTrigger(): doLArDeadOTXCorr = True else: mlog.warning( "Trigger is switched off. Can't run deadOTX correction." ) if doLArDeadOTXCorr: try: from LArCellRec.LArCellDeadOTXCorrToolDefault import LArCellDeadOTXCorrToolDefault theLArCellDeadOTXCorr = LArCellDeadOTXCorrToolDefault() except Exception: mlog.error("could not get handle to LArCellDeadOTXCorr Quit") print(traceback.format_exc()) theCaloCellMaker += theLArCellDeadOTXCorr theCaloCellMaker.CaloCellMakerToolNames += [theLArCellDeadOTXCorr] # make lots of checks (should not be necessary eventually) # to print the check add: from CaloRec.CaloRecConf import CaloCellContainerCheckerTool theCaloCellContainerCheckerTool = CaloCellContainerCheckerTool() # FIXME # theCaloCellContainerCheckerTool.OutputLevel=DEBUG theCaloCellMaker += theCaloCellContainerCheckerTool theCaloCellMaker.CaloCellMakerToolNames += [ theCaloCellContainerCheckerTool ] # sets output key theCaloCellMaker.CaloCellsOutputName = self.outputKey() # register output in objKeyStore from RecExConfig.ObjKeyStore import objKeyStore objKeyStore.addStreamESD(self.outputType(), self.outputKey()) # Also note that we produce it as a transient output. objKeyStore.addTransient(self.outputType(), self.outputKey()) from TileRecUtils.TileDQstatusAlgDefault import TileDQstatusAlgDefault TileDQstatusAlgDefault() # now add algorithm to topSequence # this should always come at the end mlog.info(" now adding CaloCellMaker to topSequence") from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence += theCaloCellMaker return True
def configure(self): if self._done: log.info("configuration already done, who is calling it again?") return True self._done = True # start with print some information what this will do log.info( "Basic configuration flags RecAlgsFlag.doTrigger: %d RecFlags.doTrigger: %d TriggerFlags.doTriggerConfigOnly %d" % (recAlgs.doTrigger(), rec.doTrigger(), TF.doTriggerConfigOnly())) log.info( "TriggerFlags: doL1Topo: %s, doLVL1: %s, doLVL2: %s, doEF: %s, doHLT: %s" % (TF.doL1Topo(), TF.doLVL1(), TF.doLVL2(), TF.doEF(), TF.doHLT())) willGenerateMenu = recAlgs.doTrigger() and ( TF.doLVL1() or TF.doLVL2() or TF.doEF() or TF.doHLT()) and not TF.doTriggerConfigOnly() willRunTriggerConfigGetter = recAlgs.doTrigger() or rec.doTrigger( ) or TF.doTriggerConfigOnly() willRunLVL1SimulationGetter = recAlgs.doTrigger( ) and not TF.doTriggerConfigOnly() willRunHLTSimulationGetter = willRunLVL1SimulationGetter and ( TF.doLVL2() or TF.doEF() or TF.doHLT()) log.info("Will run: %s%s%s%s" % ( "GenerateMenu " if willGenerateMenu else "", "TriggerConfigGetter " if willRunTriggerConfigGetter else "", "LVL1SimulationGetter " if willRunLVL1SimulationGetter else "", "HLTSimulationGetter " if willRunHLTSimulationGetter else "", )) log.info("Will not run: %s%s%s%s" % ( "GenerateMenu " if not willGenerateMenu else "", "TriggerConfigGetter " if not willRunTriggerConfigGetter else "", "LVL1SimulationGetter " if not willRunLVL1SimulationGetter else "", "HLTSimulationGetter " if not willRunHLTSimulationGetter else "", )) if recAlgs.doTrigger(): # setup the trigger from the DB if TF.readConfigFromTriggerDb(): return self.configureTriggerFromDB() if ((TF.doLVL1() == True or TF.doLVL2() == True or TF.doEF() == True or TF.doHLT() == True) and TF.doTriggerConfigOnly() == False): log.info("generating menu") # trigger menu files generation g = GenerateMenu() g.generate() # after the menu xml file has been created or the TriggerDB access is configured, # the COOL/SQlite db can be written # TB this needs to be optimized -- we do not need ti always but only when AOD or ESD are created if recAlgs.doTrigger() or rec.doTrigger() or TF.doTriggerConfigOnly(): # setup configuration services from TriggerJobOpts.TriggerConfigGetter import TriggerConfigGetter cfg = TriggerConfigGetter() from TrigConfigSvc.TrigConf2COOL import theConfCOOLWriter theConfCOOLWriter.writeConf2COOL() # preconfigure TrigDecisionTool from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool from AthenaCommon.AppMgr import ToolSvc ToolSvc += Trig__TrigDecisionTool("TrigDecisionTool") # tell tdt to use TrigConfigSvc (Since TrigDecisionTool-00-03-40, defaults to not use it) ToolSvc.TrigDecisionTool.TrigConfigSvc = "Trig::TrigConfigSvc/TrigConfigSvc" from TrigEDMConfig.TriggerEDM import EDMLibraries ToolSvc.TrigDecisionTool.Navigation.Dlls = [ e for e in EDMLibraries if 'TPCnv' not in e ] # actuall trigger simulation running if recAlgs.doTrigger() and not TF.doTriggerConfigOnly(): # setup Lvl1 # initialize LVL1ConfigSvc log.info("configuring lvl1") from TriggerJobOpts.Lvl1TriggerGetter import Lvl1SimulationGetter lvl1 = Lvl1SimulationGetter() if jobproperties.Global.InputFormat() != 'bytestream' and ( TF.doLVL2 == True or TF.doEF == True or TF.doHLT == True): # Transient BS construction and intialization from ByteStreamCnvSvc import WriteByteStream StreamBS = WriteByteStream.getStream("Transient", "StreamBS") StreamBS.ForceRead = True StreamBS.ItemList += [ "DataVector<LVL1::TriggerTower>#TriggerTowers" ] StreamBS.ItemList += ["TRT_RDO_Container#TRT_RDOs"] StreamBS.ItemList += ["SCT_RDO_Container#SCT_RDOs"] StreamBS.ItemList += ["PixelRDO_Container#PixelRDOs"] # StreamBS.ItemList +=["LArRawChannelContainer#*"] StreamBS.ItemList += ["2721#*"] # StreamBS.ItemList +=["TileRawChannelContainer#*"] StreamBS.ItemList += ["2927#*"] StreamBS.ItemList += [ "2934#*" ] # added on request from: Arantxa Ruiz Martinez for TileRODMu # don't need Muons in transient BS # StreamBS.ItemList +=["MdtCsmContainer#*"] # StreamBS.ItemList +=["RpcPadContainer#*"] # StreamBS.ItemList +=["TgcRdoContainer#*"] # StreamBS.ItemList +=["CscRawDataContainer#*"] from AthenaCommon.Include import include # setup trans BS for the ID include("InDetRecExample/InDetRecCabling.py") # setup HLT # initialize HLT config svc log.info("TriggerFlags: doLVL2 %r" % TF.doLVL2()) log.info("TriggerFlags: doEF %r" % TF.doEF()) log.info("TriggerFlags: doHLT %r" % TF.doHLT()) if TF.doLVL2() == True or TF.doEF() == True or TF.doHLT() == True: log.info("configuring hlt") from TriggerJobOpts.HLTTriggerGetter import HLTSimulationGetter hlt = HLTSimulationGetter(g) else: from RegionSelector.RegSelSvcDefault import RegSelSvcDefault from AthenaCommon.AppMgr import ServiceMgr ServiceMgr += RegSelSvcDefault() ServiceMgr.RegSelSvc.enablePixel = False ServiceMgr.RegSelSvc.enableSCT = False # prepare result making of L1 from TriggerJobOpts.Lvl1ResultBuilderGetter import Lvl1ResultBuilderGetter hltouput = Lvl1ResultBuilderGetter() # prepare result making of HLT if TF.doLVL2() == True or TF.doEF() == True or TF.doHLT() or ( recAlgs.doTrigger() and TF.readBS()): from TriggerJobOpts.HLTTriggerResultGetter import HLTTriggerResultGetter hltouput = HLTTriggerResultGetter() return True
if jobproperties.CaloRecFlags.doCaloTopoTower() and DetFlags.haveRIO.Calo_on(): try: include("CaloRec/CaloTopoTower_jobOptions.py") except Exception: treatException("Problem with CaloTopoTower. Switched off.") jobproperties.CaloRecFlags.doCaloTopoTower = False else: jobproperties.CaloRecFlags.doCaloTopoTower = False # # functionality : muon candidates in Tile # if DetFlags.haveRDO.Tile_on() and DetFlags.detdescr.Tile_on(): # this part is needed if we are reading Geant4 RDO created before 14.5.0 # but it's also safe to include this jobOptions even for new Geant4 RDO if globalflags.DataSource() == 'geant4' and rec.doTrigger(): try: include("TileL2Algs/TileL2Algs_jobOptions.py") except Exception: treatException("Could not set up TileMuId at ROD") if jobproperties.CaloRecFlags.doTileMuId(): if DetFlags.haveRIO.Tile_on(): from AthenaCommon.BeamFlags import jobproperties try: # will merge these 2 jobOptions eventually if jobproperties.Beam.beamType( ) == 'cosmics' or jobproperties.Beam.beamType() == 'singlebeam': include("TileMuId/TileMuId_cosmics_jobOptions.py") else:
TriggerD3PDStream_msg = logging.getLogger('TriggerD3PD_prodJobOFragment') # Check if the configuration makes sense: if prodFlags.WriteTriggerD3PD.isVirtual: TriggerD3PDStream_msg.error("The Trigger D3PD stream can't be virtual! " + "It's a configuration error!") raise NameError("Trigger D3PD set to be a virtual stream") # Construct the stream and file names for the Trigger D3PD: streamName = prodFlags.WriteTriggerD3PD.StreamName fileName = buildFileName(prodFlags.WriteTriggerD3PD) TriggerD3PDStream_msg.info( "Configuring Trigger D3PD with streamName '%s' and " \ "fileName '%s'" % ( streamName, fileName ) ) # Check if we will get trigger information: triggerAvailable = (rec.doTrigger() and (not rec.noESDTrigger())) # Print a warning if the trigger is not used: if not triggerAvailable: TriggerD3PDStream_msg.warning( "Running without trigger information on the input. " "Most information will not be available/saved.") pass # Set global D3PDMaker flags: from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags D3PDMakerFlags.DoPAU = False D3PDMakerFlags.DoTrigger = True #FPP: patch to run D3PD with the merged L2EF (must add new flags in D3PDMakerConfig/python/D3PDMakerFlags.py) D3PDMakerFlags.ElectronEFTrigPattern = "EF_[0-9]?e[0-9]+.*|HLT_[0-9]?e[0-9]+.*" D3PDMakerFlags.ElectronL2TrigPattern = "L2_[0-9]?e[0-9]+.*"
def configure(self): log = logging.getLogger( "TriggerConfigGetter.py" ) from PyUtils.MetaReaderPeekerFull import metadata # first check the input if "HIT2RDO" in self._environment: TriggerFlags.doLVL2 = False TriggerFlags.doEF = False log.info("For simulation jobs the following flags are set:") log.info("globalflags.InputFormat : %s", globalflags.InputFormat()) log.info("globalflags.DataSource : %s", globalflags.DataSource()) log.info("TriggerFlags.configForStartup : %s", TriggerFlags.configForStartup()) log.info("TriggerFlags.dataTakingConditions : %s", TriggerFlags.dataTakingConditions()) log.info("TriggerFlags.doLVL2 : %s", TriggerFlags.doLVL2()) log.info("TriggerFlags.doEF : %s", TriggerFlags.doEF()) else: if not self.checkInput(): log.error("Could not determine job input. Can't setup trigger configuration and will return!") return # self.checkInput() may call TriggerConfigCheckMetadata, this can in turn set "rec.doTrigger.set_Value_and_Lock(False)" # but TriggerConfigGetter might have only been called in the first place due to this flag having been true, # so re-check that we're still OK to be executing here if not (recAlgs.doTrigger() or rec.doTrigger() or TriggerFlags.doTriggerConfigOnly()): log.info("Aborting TriggerConfigGetter as the trigger flags were switched to false in checkInput()") return True self.readPool = globalflags.InputFormat() == 'pool' self.readRDO = rec.readRDO() self.writeESDAOD = rec.doWriteESD() or rec.doWriteAOD() or rec.doWriteDPD() self.writeAOD = rec.doWriteAOD() or rec.doWriteDPD() self.ConfigSrcList = TriggerFlags.configurationSourceList() self.readMC = globalflags.DataSource()=='geant3' or globalflags.DataSource()=='geant4' self.readTriggerDB = TriggerFlags.readMenuFromTriggerDb() and self.readRDO self.isCommisioning = globalflags.DataSource()=='data' and globalflags.DetGeo()=='commis' self.l1Folders = TriggerFlags.dataTakingConditions()=='FullTrigger' or TriggerFlags.dataTakingConditions()=='Lvl1Only' self.hltFolders = TriggerFlags.dataTakingConditions()=='FullTrigger' or TriggerFlags.dataTakingConditions()=='HltOnly' self.isRun1Data = False self.hasxAODMeta = ("metadata_items" in metadata and any(('TriggerMenu' in key) for key in metadata["metadata_items"].keys())) if globalflags.DataSource()=='data': from RecExConfig.AutoConfiguration import GetRunNumber runNumber = GetRunNumber() if runNumber is not None and runNumber > 0 and runNumber < 230000 : self.isRun1Data = True self.isTriggerReprocessing = False # the TriggerFlags.readMenuFromTriggerDb() tells us that we read the trigger menu from the database # the connection itself is defined in TriggerFlags.triggerDbConnection() # reading from the TriggerDB can mean different things: # a) TriggerFlags doLVL2() and doEF() are both False: # - create a tmp sqlite file with the conditions (menu) # - use DSConfigSvc # b) TriggerFlags doLVL2() or doEF() is True: # - use HLTConfigSvc if self.readTriggerDB and (TriggerFlags.doLVL2() or TriggerFlags.doEF() or TriggerFlags.doHLT()): self.ConfigSrcList = ['xml'] # to use L1/HLTConfigSvc and not DSConfigSvc, but only if we are running the HLT if self._environment: # I don't think anyone calls TriggerConfigGetter with an argument self.readPool = False self.writeESDAOD = False self.readHits = False if "ReadPoolRDO" in self._environment: self.readPool = True self.readRDO = True elif "ReadPool" in self._environment: self.readPool = True self.readRDO = False if "WritePool" in self._environment: self.writeESDAOD = True if "HIT2RDO" in self._environment: self.readRDO = False self.readHits = True # define ConfigSvc if not self.ConfigSrcList: if (self.readPool and not self.readRDO) or (self.readRDO and not self.readPool): # (ESD, AOD, DPD) or (RDO-BS) self.ConfigSrcList = ['ds'] elif (self.readRDO and self.readPool) or rec.readTAG() or self.readHits: # (RDO-MC) or TAG self.ConfigSrcList = ['xml'] else: # should not get here: should be found by checkInput log.fatal('no reading of BS, RDO, AOD, ESD, or TAG specified') # we need the temporary COOL database, if we read the configuration from XML and write ESD/AOD (or have 'ds' set for some reason) self.makeTempCool = self.readRDO and \ ( self.writeESDAOD or 'ds' in self.ConfigSrcList ) and \ ( self.readMC \ or (self.isCommisioning and (TriggerFlags.readLVL1configFromXML() and TriggerFlags.readHLTconfigFromXML())) \ or TriggerFlags.readMenuFromTriggerDb() ) log.info("Need to create temporary cool file? : %r", self.makeTempCool) log.info('Creating the Trigger Configuration Services') from AthenaCommon.AppMgr import ServiceMgr as svcMgr ######################################################################## # START OF TEMPORARY SOLUTION FOR RUN-3 TRIGGER DEVELOPMENT ######################################################################## from TriggerJobOpts.HLTTriggerResultGetter import EDMDecodingVersion EDMDecodingVersion() # In most use cases this needs to be called much earlier than in HLTTriggerResultGetter if TriggerFlags.EDMDecodingVersion() >= 3: if self.hasxAODMeta: if not hasattr(svcMgr, 'xAODConfigSvc'): from TrigConfxAOD.TrigConfxAODConf import TrigConf__xAODConfigSvc svcMgr += TrigConf__xAODConfigSvc('xAODConfigSvc') else: # Does not have xAODMeta # Run-3 Trigger Configuration Services from TrigConfigSvc.TrigConfigSvcCfg import getL1ConfigSvc, getHLTConfigSvc from AthenaConfiguration.AllConfigFlags import ConfigFlags svcMgr += getL1ConfigSvc(ConfigFlags) svcMgr += getHLTConfigSvc(ConfigFlags) # Needed for TrigConf::xAODMenuWriterMT from TrigConfigSvc.TrigConfigSvcConfig import TrigConfigSvc svcMgr += TrigConfigSvc("TrigConfigSvc") svcMgr.TrigConfigSvc.PriorityList = ["none", "ds", "xml"] else: # non-MT (Run-2) Trigger Configuration self.svc = SetupTrigConfigSvc() if 'xml' in self.ConfigSrcList or self.makeTempCool: # sets them if plain XML reading is to be used self.svc.l1topoXmlFile = TriggerFlags.outputL1TopoConfigFile() # generated in python self.svc.l1XmlFile = TriggerFlags.outputLVL1configFile() # generated in python self.svc.hltXmlFile = TriggerFlags.outputHLTconfigFile() # generated in python if TriggerFlags.readL1TopoConfigFromXML(): self.svc.l1topoXmlFile = TriggerFlags.inputL1TopoConfigFile() # given XML if TriggerFlags.readLVL1configFromXML(): self.svc.l1XmlFile = TriggerFlags.inputLVL1configFile() # given XML if TriggerFlags.readHLTconfigFromXML(): self.svc.hltXmlFile = TriggerFlags.inputHLTconfigFile() # given XML try: self.svc.SetStates( self.ConfigSrcList ) except Exception: log.error( 'Failed to set state of TrigConfigSvc to %r', self.ConfigSrcList ) else: log.info('The following configuration services will be tried: %r', self.ConfigSrcList ) try: self.svc.InitialiseSvc() except Exception as ex: log.error( 'Failed to activate TrigConfigSvc: %r', ex ) ######################################################################## # END OF TEMPORARY SOLUTION FOR RUN-3 TRIGGER DEVELOPMENT ######################################################################## if self.readTriggerDB: log.info( "Using TriggerDB connection '%s'", TriggerFlags.triggerDbConnection() ) self.trigDbConnectionParameters = interpretConnection(TriggerFlags.triggerDbConnection(), resolveAlias=False) self.setConfigSvcConnParams(self.trigDbConnectionParameters) log.info("TriggerFlags.triggerCoolDbConnection is '%s' [default: '']", TriggerFlags.triggerCoolDbConnection()) TrigCoolDbConnection = TriggerFlags.triggerCoolDbConnection() if self.makeTempCool: TrigCoolDbConnection = self.setupTempCOOLWriting(TrigCoolDbConnection) if ('ds' in self.ConfigSrcList) and not self.hasxAODMeta: self.setupCOOLReading(TrigCoolDbConnection) if hasattr(svcMgr, 'DSConfigSvc'): db = 'TRIGGERDB' if self.isRun1Data: db = 'TRIGGERDB_RUN1' elif self.readMC: db = 'TRIGGERDBMC' elif self.isTriggerReprocessing: db = 'TRIGGERDBREPR' svcMgr.DSConfigSvc.ConfigSource = 'dblookup' svcMgr.DSConfigSvc.DBServer = db log.info("DSConfigSvc trigger database is '%s'", db) if not self.hasxAODMeta: self.setupxAODWriting() # all went fine we are configured return True