##Implementing x277 requirements PF 26/10/2014
#rec.doJetMissingETTag=False -> Not needed for this Jo since it properly set the Calo off
rec.doTau = False
from TrigHLTMonitoring.HLTMonFlags import HLTMonFlags
HLTMonFlags.doBphys = False
from AthenaMonitoring import DQMonFlags
DQMonFlags.doJetMon = False
DQMonFlags.doMissingEtMon = False
DQMonFlags.enableLumiAccess = False
DQMonFlags.doStreamAwareMon = False
from JetRec.JetRecFlags import jetFlags
jetFlags.useTracks = False
from InDetRecExample.InDetJobProperties import InDetFlags
InDetFlags.doTruth = (globalflags.DataSource == 'geant4'
and globalflags.InputFormat() == 'pool')
#InDetFlags.doTruth = False
if globalflags.InputFormat(
) == 'pool' and not globalflags.DataSource == 'geant4':
# ---- run over ESD files
# InDetFlags.preProcessing=True
#This is not originally defined in the Cosmics jobOption, but i add it here
InDetFlags.doPRDFormation = False
else:
InDetFlags.doPRDFormation = True
# --- uncomment to change the default of one of the following options:
#InDetFlags.doNewTracking = False
#InDetFlags.doLowPt = True
#InDetFlags.doBeamGas = True
#InDetFlags.doBeamHalo = True
if tileRawMon:
if 'doTileMonOld' in dir() and doTileMonOld:
TileMBTSMon = CfgMgr.TileMBTSMonTool(
name='TileMBTSMon',
OutputLevel=INFO,
histoPathBase="/Tile/MBTS_OLD",
LVL1ConfigSvc="TrigConf::TrigConfigSvc/TrigConfigSvc",
doOnline=athenaCommonFlags.isOnline(),
readTrigger=False,
UseTrigger=False,
FillHistogramsPerMBTS=False)
# , readTrigger = DQMonFlags.useTrigger());
from AthenaCommon.GlobalFlags import globalflags
if globalflags.InputFormat() == 'pool':
TileMBTSMon.TileDigitsContainerName = 'TileDigitsFlt'
ManagedAthenaTileMon.AthenaMonTools += [TileMBTSMon]
from TileMonitoring.TileMBTSMonitorAlgorithm import TileMBTSMonitoringConfigOld
topSequence += TileMBTSMonitoringConfigOld(DQMonFlags)
from TileRecUtils.TileRecFlags import jobproperties
if jobproperties.TileRecFlags.readDigits():
if 'doTileRODMon' in dir() and doTileRODMon:
TileRODMon = CfgMgr.TileRODMonTool(
name='TileRODMon',
OutputLevel=INFO,
histoPathBase="/Tile/ROD",
FillHistogramsForL1Triggers=[],
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
try:
from CaloRec.CaloClusterSWCmbGetter import CaloClusterSWCmbGetter
CaloClusterSWCmbGetter()
except Exception:
treatException("Problem with CaloSWCmbCluster. Switched off.")
jobproperties.CaloRecFlags.doCaloCluster = False
#EM clusters
if jobproperties.CaloRecFlags.doEmCluster():
try:
include("LArClusterRec/LArCluster_jobOptions.py")
except Exception:
treatException("Problem with LArCluster. Switched off.")
jobproperties.CaloRecFlags.doEmCluster = False
# write digits of EM clusters
if jobproperties.CaloRecFlags.doEMDigits() and globalflags.DataSource(
) == 'data' and globalflags.InputFormat() == 'bytestream':
try:
include("LArClusterRec/LArDigits_fromEMCluster_jobptions.py")
except Exception:
treatException(
"Problem with LArDigitsFromEMClust. Switched off.")
jobproperties.CaloRecFlags.doEMDigits = False
#Topoclusters
if jobproperties.CaloRecFlags.doCaloTopoCluster():
try:
include("CaloRec/CaloTopoCluster_jobOptions.py")
except Exception:
treatException("Problem with CaloTopoCluster. Switched off.")
jobproperties.CaloRecFlags.doCaloTopoCluster = False
TrackD3PDSCTFlags.inputFiles = runArgs.inputBSFile
globalflags.InputFormat='bytestream'
athenaCommonFlags.BSRDOInput=TrackD3PDSCTFlags.inputFiles()
if hasattr(runArgs,"inputRDOFile"):
TrackD3PDSCTFlags.inputFiles = runArgs.inputRDOFile
globalflags.InputFormat='pool'
athenaCommonFlags.PoolRDOInput=TrackD3PDSCTFlags.inputFiles()
athenaCommonFlags.FilesInput=athenaCommonFlags.PoolRDOInput()
# run the reconstruction
include('TrackD3PDMaker/RecoSetupForSctNtuple.py')
#Condition tag 04.03
if globalflags.InputFormat() == 'bytestream':
if len(globalflags.ConditionsTag())!=0:
from IOVDbSvc.CondDB import conddb
conddb.setGlobalTag(globalflags.ConditionsTag())
# compose the tree
from TrackD3PDMaker.TrackD3PDMakerSCTFlags import TrackD3PDSCTFlags
# uncomment the necessary one
TrackD3PDSCTFlags.doSCTNtuple = True # default
#TrackD3PDSCTFlags.doSCTNtupleLight = True
#TrackD3PDSCTFlags.doSCTNtupleExtended = True
#if not hasattr(runArgs,"inputRDOFile") and not hasattr(runArgs,"inputBSFile"):
# include('TrackD3PDMaker/SCTNtuple.py')
DetFlags.ID_setOn() # --- and switch off all the rest DetFlags.Calo_setOff() DetFlags.Muon_setOff() # --- printout DetFlags.Print() #DetFlags.writeRDOPool.pixel_setOn() #-------------------------------------------------------------- # Load InDet configuration #-------------------------------------------------------------- # --- setup InDetJobProperties from InDetRecExample.InDetJobProperties import InDetFlags InDetFlags.doTruth = (globalflags.InputFormat() == 'pool') InDetFlags.doLowBetaFinder = False # --- uncomment to change the default of one of the following options: #OutputLevel = DEBUG # --- possibility to change the trackfitter #InDetFlags.trackFitterType = 'KalmanFitter' #if (hasattr(InDetFlags,"doPixelClusterSplitting")) : # InDetFlags.doPixelClusterSplitting=False #---slhc #InDetFlags.doTrackSegmentsPixel = False #InDetFlags.doTrackSegmentsSCT = False #InDetFlags.doTrackSegmentsTRT = False
#DetFlags.pixel_setOff() #DetFlags.detdescr.pixel_setOn() #DetFlags.SCT_setOff() #DetFlags.detdescr.SCT_setOn() DetFlags.TRT_setOff() DetFlags.detdescr.TRT_setOn() # --- printout DetFlags.Print() #-------------------------------------------------------------- # Load InDet configuration #-------------------------------------------------------------- # --- setup InDetJobProperties from InDetRecExample.InDetJobProperties import InDetFlags InDetFlags.doTruth = (globalflags.DataSource == 'geant4' and globalflags.InputFormat() == 'pool') # --- uncomment to change the default of one of the following options: #InDetFlags.doHeavyIon = True #InDetFlags.doNewTracking = False##################################### #InDetFlags.doLowPt = True #InDetFlags.doBeamGas = True #InDetFlags.doBeamHalo = True #InDetFlags.doxKalman = True #InDetFlags.doiPatRec = False #InDetFlags.doBackTracking = False #InDetFlags.doTRTStandalone = False #InDetFlags.doSingleSpBackTracking = True #InDetFlags.doV0Finder = False #InDetFlags.doConversions = False #InDetFlags.doStatistics = False
print "globalflags configuration:" print globalflags print "detflags configuration:" DetFlags.Print() print "rec configuration:" print rec #-------------------------------------------------------------- # Load InDet configuration #-------------------------------------------------------------- # --- setup InDetJobProperties (default) from InDetRecExample.InDetJobProperties import InDetFlags InDetFlags.doTruth.set_Value_and_Lock (globalflags.DataSource == 'geant4' and globalflags.InputFormat() == 'pool') # --- enable brem recovery InDetFlags.doBremRecovery.set_Value_and_Lock (doBremRecovery) # --- calo seeding does not work standalone InDetFlags.doCaloSeededBrem.set_Value_and_Lock (doCaloSeededBrem) # --- cut level #InDetFlags.cutLevel.set_Value_and_Lock (8) #InDetFlags.priVtxCutLevel.set_Value_and_Lock (2) # --- enable forward tracks InDetFlags.doForwardTracks.set_Value_and_Lock (False) # --- activate monitorings InDetFlags.doMonitoringGlobal.set_Value_and_Lock (False)
def configure(self):
mlog = logging.getLogger('Py:LArRawChannelGetter::configure %s:' %
self.__class__)
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
from AthenaCommon.AppMgr import ToolSvc
# get LArDigitGetter in MC case
from AthenaCommon.DetFlags import DetFlags
if DetFlags.digitize.LAr_on():
try:
from LArDigitization.LArDigitGetter import LArDigitGetter
theLArDigitGetter = LArDigitGetter()
except Exception as configException:
print configException
mlog.error("could not get handle to LArDigitGetter Quit")
return False
if not theLArDigitGetter.usable():
mlog.error("LArDigitGetter unusable. Quite")
return False
from LArROD.LArRODFlags import larRODFlags
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource() == 'data' or larRODFlags.forceIter():
# ADC2MeV tool
from LArRecUtils.LArADC2MeVToolDefault import LArADC2MeVToolDefault
theADC2MeVTool = LArADC2MeVToolDefault()
ToolSvc += theADC2MeVTool
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
# Data case
if larRODFlags.readDigits():
from AthenaCommon.GlobalFlags import globalflags
if globalflags.InputFormat() == 'bytestream':
if not "LArDigitContainer/FREE" in svcMgr.ByteStreamAddressProviderSvc.TypeNames:
svcMgr.ByteStreamAddressProviderSvc.TypeNames += [
"LArDigitContainer/FREE"
]
if not larRODFlags.keepDSPRaw():
if "LArRawChannelContainer/LArRawChannels" in svcMgr.ByteStreamAddressProviderSvc.TypeNames:
svcMgr.ByteStreamAddressProviderSvc.TypeNames.remove(
"LArRawChannelContainer/LArRawChannels")
else:
if not "LArRawChannelContainer/LArRawChannels" in svcMgr.ByteStreamAddressProviderSvc.TypeNames:
svcMgr.ByteStreamAddressProviderSvc.TypeNames += [
"LArRawChannelContainer/LArRawChannels"
]
if globalflags.DetGeo() == 'ctbh6' or globalflags.DetGeo(
) == 'ctbh8':
from LArROD.LArRODConf import LArRawChannelBuilder
theLArRawChannelBuilder = LArRawChannelBuilder()
topSequence += theLArRawChannelBuilder
return True
from LArROD.LArRODConf import LArRawChannelBuilderDriver
theLArRawChannelBuilder = LArRawChannelBuilderDriver(
"LArRawChannelBuilder")
topSequence += theLArRawChannelBuilder
if larRODFlags.keepDSPRaw():
theLArRawChannelBuilder.LArRawChannelContainerName = larRODFlags.RawChannelFromDigitsContainerName(
)
# bad channel masking if required
if not larRODFlags.doBuildBadChannel():
# The first tool filters out bad channels
from LArROD.LArRODConf import LArRawChannelBuilderToolBadChannelTool
theLArRawChannelBuilderToolBadChannel = LArRawChannelBuilderToolBadChannelTool(
)
from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker
theLArRCBMasker = LArBadChannelMasker("LArRCBMasker")
theLArRCBMasker.DoMasking = True
theLArRCBMasker.ProblemsToMask = [
"deadReadout", "deadPhys", "almostDead", "short",
"lowNoiseHG", "highNoiseHG", "unstableNoiseHG",
"lowNoiseMG", "highNoiseMG", "unstableNoiseMG",
"lowNoiseLG", "highNoiseLG", "unstableNoiseLG"
]
#ToolSvc+=theLArRCBMasker
from LArBadChannelTool.LArBadChannelToolConf import LArBadChanTool
ToolSvc += LArBadChanTool()
theLArRawChannelBuilderToolBadChannel.BadChannelMask = theLArRCBMasker
theLArRawChannelBuilder.BuilderTools += [
theLArRawChannelBuilderToolBadChannel
]
ToolSvc += theLArRawChannelBuilderToolBadChannel
# Pulse reconstruction
# main method: OFC iteration
from LArROD.LArRODConf import LArRawChannelBuilderToolOFCIter
theLArRawChannelBuilderToolOFCIter = LArRawChannelBuilderToolOFCIter(
)
theLArRawChannelBuilderToolOFCIter.minSample = 2
theLArRawChannelBuilderToolOFCIter.maxSample = 12
theLArRawChannelBuilderToolOFCIter.minADCforIterInSigma = 4 # ADCmax at least 4 sigma above noise for iteration
theLArRawChannelBuilderToolOFCIter.minADCforIter = 15 # min adc for iteration (only if no pedestalRMS found)
theLArRawChannelBuilderToolOFCIter.defaultPhase = 0 # starting delay, also the fixed delay for ADC below min.
theLArRawChannelBuilderToolOFCIter.ECut = 250. # Energy to save quality
theLArRawChannelBuilder.BuilderTools += [
theLArRawChannelBuilderToolOFCIter
]
theLArRawChannelBuilder += theLArRawChannelBuilderToolOFCIter
# no fallback when emulating exactly DSP computation
if not larRODFlags.doDSP():
# fallback(1): cubic method
from LArROD.LArRODConf import LArRawChannelBuilderToolCubic
theLArRawChannelBuilderToolCubic = LArRawChannelBuilderToolCubic(
)
theLArRawChannelBuilderToolCubic.minADCforCubic = 30
theLArRawChannelBuilder.BuilderTools += [
theLArRawChannelBuilderToolCubic
]
theLArRawChannelBuilder += theLArRawChannelBuilderToolCubic
# fallback(2) averageing
from LArROD.LArRODConf import LArRawChannelBuilderToolAverage
theLArRawChannelBuilderToolAverage = LArRawChannelBuilderToolAverage(
)
theLArRawChannelBuilderToolAverage.NScan = 0
theLArRawChannelBuilder.BuilderTools += [
theLArRawChannelBuilderToolAverage
]
theLArRawChannelBuilder += theLArRawChannelBuilderToolAverage
# Pedestal
# main method from database
from LArROD.LArRODConf import LArRawChannelBuilderPedestalDataBase
theLArRawChannelBuilderPedestalDataBase = LArRawChannelBuilderPedestalDataBase(
)
theLArRawChannelBuilderPedestalDataBase.LArPedestalKey = "Pedestal"
theLArRawChannelBuilder.PedestalTools = [
theLArRawChannelBuilderPedestalDataBase
]
theLArRawChannelBuilder += theLArRawChannelBuilderPedestalDataBase
# no fallback when emulating exactly DSP computation
if not larRODFlags.doDSP():
# fallback. sample 0
from LArROD.LArRODConf import LArRawChannelBuilderPedestalSampleZero
theLArRawChannelBuilderPedestalSampleZero = LArRawChannelBuilderPedestalSampleZero(
)
theLArRawChannelBuilder.PedestalTools += [
theLArRawChannelBuilderPedestalSampleZero
]
theLArRawChannelBuilder += theLArRawChannelBuilderPedestalSampleZero
# ADC to energy
# main method from database
from LArROD.LArRODConf import LArRawChannelBuilderADC2EDataBase
theLArRawChannelBuilderADC2EDataBase = LArRawChannelBuilderADC2EDataBase(
)
theLArRawChannelBuilder.ADCtoEnergyTools = [
theLArRawChannelBuilderADC2EDataBase
]
theLArRawChannelBuilderADC2EDataBase.ADC2MeVTool = theADC2MeVTool
theLArRawChannelBuilder += theLArRawChannelBuilderADC2EDataBase
# no fallback when emulating exactly DSP computation
if not larRODFlags.doDSP():
# fallback, constant conversion factors
from LArROD.LArRODConf import LArRawChannelBuilderADC2EConstants
theLArRawChannelBuilderADC2EConstants = LArRawChannelBuilderADC2EConstants(
)
theLArRawChannelBuilder.ADCtoEnergyTools += [
theLArRawChannelBuilderADC2EConstants
]
theLArRawChannelBuilder += theLArRawChannelBuilderADC2EConstants
#more tools to be configured
from LArRecUtils.LArRecUtilsConf import LArOFPeakRecoTool
theLArOFPeakRecoTool = LArOFPeakRecoTool()
from LArConditionsCommon.LArCondFlags import larCondFlags
theLArOFPeakRecoTool.UseShape = larCondFlags.useShape()
if larCondFlags.LArCoolChannelSelection.statusOn:
if len(larCondFlags.LArCoolChannelSelection()) > 0:
theLArOFPeakRecoTool.forceHighGain = larCondFlags.useOFCOnlyCoolChannelSelection(
)
ToolSvc += theLArOFPeakRecoTool
#
# adjust default timing to match first sample information written in cool from Lar online configuration
#
nominalPeakSample = 2
if globalflags.DataSource() == 'data':
from LArConditionsCommon.LArCool import larcool
if (larcool is not None):
nominalPeakSample = larcool.firstSample()
# don't use ramp intercept in calibration if gain type is not auto
if larcool.gainType() > 0:
mlog.info(
" Gain Type: %d don't use intercept in ADC to Energy ramp calibration",
larcool.gainType())
theLArRawChannelBuilderADC2EDataBase.UseHighGainRampIntercept = False
theLArRawChannelBuilderADC2EDataBase.UseMedGainRampIntercept = False
theLArRawChannelBuilderADC2EDataBase.UseLowGainRampIntercept = False
else:
mlog.info(
" Gain Type: %d use intercept in ADC to energy ramp calibraion ",
larcool.gainType())
if (nominalPeakSample > 1):
theLArRawChannelBuilder.DefaultShiftTimeSample = nominalPeakSample - 2
else:
theLArRawChannelBuilder.DefaultShiftTimeSample = 0
theLArRawChannelBuilder.DataLocation = "FREE"
else:
from AthenaCommon.GlobalFlags import globalflags
if globalflags.InputFormat() == 'bytestream':
if not "LArRawChannelContainer/LArRawChannels" in svcMgr.ByteStreamAddressProviderSvc.TypeNames:
svcMgr.ByteStreamAddressProviderSvc.TypeNames += [
"LArRawChannelContainer/LArRawChannels"
]
# In the case of DSP monitoring and reading rawchannels, need to give a different name to the LArRawChannels container
# read from the bytestream ...
# This name has to be coherent with the name in LArMonTools/LArRODMonTool_jobOptions.py
if larRODFlags.doDSP() and larRODFlags.readRawChannels(
): #Reading LArRawChannel
print "Reading RawChannels in DSP physics mode"
# !!! The name of the LArRawChannels container read from the Bytestream is LArRawChannels_fB !!!
if not "LArRawChannelContainer/LArRawChannels_fB" in svcMgr.ByteStreamAddressProviderSvc.TypeNames:
svcMgr.ByteStreamAddressProviderSvc.TypeNames += [
"LArRawChannelContainer/LArRawChannels_fB"
]
print svcMgr.ByteStreamAddressProviderSvc.TypeNames
else:
# MC Case
try:
from AthenaCommon import CfgGetter
topSequence += CfgGetter.getAlgorithm(
"LArRawChannelBuilder", tryDefaultConfigurable=True)
except Exception as cfgException:
print cfgException
mlog.error("Failed to retrieve LArRawChannelBuilder. Quit")
return False
return True
if globalflags.DataSource() == 'data':
if rec.projectName() == "data09_calophys":
# for data09_calophys project, force to use DSP output for the cell energy, perform reco like DSP, no dead cell correction
if rec.doLArg():
from LArROD.LArRODFlags import larRODFlags
larRODFlags.readDigits = False
if rec.doTile():
from TileRecUtils.TileRecFlags import jobproperties
jobproperties.TileRecFlags.readDigits = False
from CaloRec.CaloCellFlags import jobproperties
jobproperties.CaloCellFlags.doDeadCellCorr = False
jobproperties.CaloCellFlags.doLArCreateMissingCells = False
jobproperties.CaloCellFlags.doLArDeadOTXCorr = False
else:
if rec.doLArg() and globalflags.InputFormat(
) == 'bytestream' and jobproperties.CaloRecFlags.doLArAutoConfiguration(
):
# for bytestream reco of real data, autoconfigure based on the run format information
# use digits only when digits available for all cells (transparent or rawdataresult)
# use DSP energy + digits when available in case only sparse digits available (results)
# (when collisions with timing settled we could use only DSP energy in this case)
from LArROD.LArRODFlags import larRODFlags
larRODFlags.readDigits = True
from LArConditionsCommon.LArCool import larcool
if (larcool is not None):
# check format1 & results mode
if (larcool.format() == 1 and larcool.runType() == 2):
larRODFlags.keepDSPRaw = True
if (larcool.format() == 0):
larRODFlags.keepDSPRaw = False # raw data transparent mode, no DSP energy
CaloCellMakerFlags.doCompactCellInstead = doCompactCellInstead
CaloCellMakerFlags.doCompactCellInAddition = doCompactCellInAddition
# set sensible defaults according to global tags
CaloCellMakerFlags.makeCellFromRawChannel = False
CaloCellMakerFlags.makeCellFromDigit = False
CaloCellMakerFlags.doLArHitToCellDirect = False
CaloCellMakerFlags.doTileHitToRawChannelDirect = False
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource() == 'data':
if globalflags.DetGeo() == 'ctb':
CaloCellMakerFlags.makeCellFromDigit = True
if globalflags.DataSource() == 'geant3' and globalflags.InputFormat(
) == 'zebra':
# for geant3 digitisation of all calo is needed
DetFlags.digitize.Calo_setOn()
# usually use fast digitisation for lar
CaloCellMakerFlags.doLArHitToCellDirect = True
# usually use slow digitisation for tile
CaloCellMakerFlags.doTileHitToRawChannelDirect = False
CaloCellMakerFlags.makeCellFromDigit = True
elif globalflags.DataSource() == 'geant3' or globalflags.DataSource(
) == 'geant4':
# on geant4 usually run on raw channel file
CaloCellMakerFlags.makeCellFromRawChannel = True
if not DetFlags.digitize.LAr_on():
CaloCellMakerFlags.doLArHitToCellDirect = False
if not DetFlags.digitize.Tile_on():
def configure(self):
log = logging.getLogger("TriggerConfigGetter.py")
# 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.readPool = globalflags.InputFormat() == 'pool'
self.readRDO = rec.readRDO()
self.writeESDAOD = rec.doWriteESD() or 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
if globalflags.DataSource() == 'data':
from RecExConfig.AutoConfiguration import GetRunNumber
runNumber = GetRunNumber()
if 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')
self.svc = SetupTrigConfigSvc()
#set the merged system
#self.svc.doMergedHLT = TriggerFlags.doHLT()
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
### preparations are done!
try:
self.svc.SetStates(self.ConfigSrcList)
except:
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, ex:
log.error('Failed to activate TrigConfigSvc: %r' % ex)
import pickle
from AthenaCommon.GlobalFlags import globalflags
from AthenaCommon.AthenaCommonFlags import jobproperties,athenaCommonFlags
onlinegoodies = {}
onlinegoodies['DataSource'] = globalflags.DataSource()
onlinegoodies['InputFormat'] = globalflags.InputFormat()
onlinegoodies['ConditionsTag'] = globalflags.ConditionsTag()
onlinegoodies['beamType'] = jobproperties.Beam.beamType()
onlinegoodies['DetDescrVersion'] = globalflags.DetDescrVersion()
file = open("globalflags.pickle",'wb')
pickle.dump(onlinegoodies,file)
file.close()
def ConfigureInputType():
from PyUtils.MetaReaderPeeker import metadata
from AthenaCommon.GlobalFlags import globalflags
streamsName = []
if metadata['file_type'] == 'BS':
#byte stream
logAutoConfiguration.info("Input BS detected")
globalflags.InputFormat = 'bytestream'
rec.readRDO = True
rec.readESD = False
rec.readAOD = False
rec.doAOD = False
rec.doESD = True
rec.doWriteAOD = False
logAutoConfiguration.info(
"BS format: setting globalflags.InputFormat=%s " %
globalflags.InputFormat())
logAutoConfiguration.info("BS format: setting rec.readRDO=%s " %
rec.readRDO())
logAutoConfiguration.info("BS format: setting rec.doAOD=%s " %
rec.doAOD())
logAutoConfiguration.info("BS format: setting rec.doESD=%s " %
rec.doESD())
logAutoConfiguration.info("BS format: setting rec.doWriteAOD=%s " %
rec.doWriteAOD())
else:
globalflags.InputFormat = 'pool'
#Get streamsName
streamsName = []
if 'processingTags' in metadata:
streamsName = metadata['processingTags']
if streamsName == None:
streamsName = []
logAutoConfiguration.info("Extracted streams %s from input file " %
streamsName)
if len(streamsName) == 0:
logAutoConfiguration.warning(
"ConfigureInputType: no stream in input file.")
elif len(streamsName) > 1:
logAutoConfiguration.warning(
"ConfigureInputType: more than one stream: %s in input file. Default action. Consider the highest one."
)
else:
rec.mergingStreamName = streamsName[0]
from RecExConfig.RecoFunctions import OverlapLists
try:
from PrimaryDPDMaker.PrimaryDPDFlags import listRAWtoDPD, listESDtoDPD, listAODtoDPD
except:
logAutoConfiguration.warning(
"Unable to import PrimaryDPDFlags. OK for ATN tests below AtlasAnalysis, otherwise suspicious."
)
listRAWtoDPD = []
listESDtoDPD = []
listAODtoDPD = []
## these lines have been added to guarantee the backward compatibility for the old DPD naming convention cosmics
try:
from PrimaryDPDMaker.PrimaryDPDFlags import listBackwardCompatibleAODtoDPD, listBackwardCompatibleESDtoDPD
listESDtoDPD.extend(listBackwardCompatibleESDtoDPD)
listAODtoDPD.extend(listBackwardCompatibleAODtoDPD)
except:
logAutoConfiguration.warning(
"Primary DPDMake does not support the old naming convention!!")
if 'TagStreamsRef' in metadata and metadata['TagStreamsRef'] != None:
logAutoConfiguration.info("Input TAG detected")
rec.readTAG = True
logAutoConfiguration.info("Auto configured rec.readTAG=%s " %
rec.readTAG())
from RecExConfig.RecoFunctions import ItemInListStartsWith
if ItemInListStartsWith("StreamAOD", streamsName) or ItemInListStartsWith(
'StreamDAOD', streamsName) or ItemInListStartsWith(
'StreamD2AOD', streamsName) or OverlapLists(
streamsName, listAODtoDPD) or ItemInListStartsWith(
'DAOD', streamsName) or ItemInListStartsWith(
'D2AOD', streamsName):
logAutoConfiguration.info("Input AOD detected")
rec.readRDO = False
rec.readESD = False
rec.readAOD = True
rec.doAOD = False
rec.doESD = False
logAutoConfiguration.info("setting rec.readAOD=%s " % rec.readAOD())
elif ItemInListStartsWith(
"StreamESD", streamsName) or ItemInListStartsWith(
'StreamDESD', streamsName) or ItemInListStartsWith(
'StreamD2ESD', streamsName) or OverlapLists(
streamsName, listESDtoDPD) or ItemInListStartsWith(
'DESD', streamsName) or ItemInListStartsWith(
'D2ESD', streamsName):
logAutoConfiguration.info("Input ESD detected")
rec.readRDO = False
rec.readESD = True
rec.readAOD = False
rec.doAOD = True
rec.doESD = False
logAutoConfiguration.info("setting rec.readESD=%s " % rec.readESD())
logAutoConfiguration.info("setting rec.doAOD=%s " % rec.doAOD())
elif ItemInListStartsWith("Stream1", streamsName) or ItemInListStartsWith(
"StreamRDO", streamsName) or ItemInListStartsWith(
"OutputStreamRDO", streamsName) or OverlapLists(
streamsName, listRAWtoDPD):
logAutoConfiguration.info("Input RDO detected")
rec.readRDO = True
rec.readESD = False
rec.readAOD = False
rec.doAOD = False
rec.doESD = True
logAutoConfiguration.info("setting rec.readRDO=%s " % rec.readRDO())
logAutoConfiguration.info("setting rec.doESD=%s " % rec.doESD())
elif ItemInListStartsWith("StreamEVGEN", streamsName):
logAutoConfiguration.info("Input EVGEN detected")
rec.readRDO = False
rec.readESD = False
rec.readAOD = False
rec.doAOD = False
rec.doESD = False
logAutoConfiguration.info(
"setting all unlocked rec.readXXX and rec.doXXX to False")
elif ItemInListStartsWith("StreamHITS", streamsName):
logAutoConfiguration.info("Input StreamEVGEN detected")
elif metadata['file_type'] != 'BS':
raise RuntimeError("ConfigureInputType cannot handle streamsName==%s" %
streamsName)
return
if rec.oldFlagCompatibility:
print "RecExCommon_flags.py flags values:"
try:
for o in RecExCommonFlags.keys():
exec 'print "%s =",%s ' % (o,o)
except Exception:
print "WARNING RecExCommonFlags not available, cannot delete"
else:
print "Old flags have been deleted"
# end flag settings section
##########################################################################
# set up job
if globalflags.InputFormat()=='pool':
# to read Pool data
import AthenaPoolCnvSvc.ReadAthenaPool
# if file not in catalog put it there
svcMgr.PoolSvc.AttemptCatalogPatch=True
svcMgr.EventSelector.InputCollections = athenaCommonFlags.FilesInput()
# backward compatibility (needed for RTT overwriting InputCollections)
EventSelector=ServiceMgr.EventSelector
########################################################################
# Number of events to be processed
def createSvc(self):
#
# Load necessary conditions folders
#
# Calibration constants
from IOVDbSvc.CondDB import conddb
if not self._isMC:
#only needed for data
if not (conddb.folderRequested('/TRT/Onl/ROD/Compress')):
conddb.addFolder("TRT_ONL", "/TRT/Onl/ROD/Compress")
if not (conddb.folderRequested('/TRT/Calib/RT')
or conddb.folderRequested('/TRT/Onl/Calib/RT')):
conddb.addFolderSplitOnline('TRT', '/TRT/Onl/Calib/RT',
'/TRT/Calib/RT')
if not (conddb.folderRequested('/TRT/Calib/T0')
or conddb.folderRequested('/TRT/Onl/Calib/T0')):
conddb.addFolderSplitOnline('TRT', '/TRT/Onl/Calib/T0',
'/TRT/Calib/T0')
if not (conddb.folderRequested('/TRT/Calib/errors')
or conddb.folderRequested('/TRT/Onl/Calib/errors')):
conddb.addFolderSplitOnline("TRT", "/TRT/Onl/Calib/errors",
"/TRT/Calib/errors")
# not needed anymore conddb.addOverride('/TRT/Onl/Calib/errors','TrtCalibErrorsOnl-ErrorVal-00-00')
if not (conddb.folderRequested('/TRT/Calib/ToTCalib')
or conddb.folderRequested('/TRT/Onl/Calib/ToTCalib')):
conddb.addFolderSplitOnline("TRT", "/TRT/Onl/Calib/ToTCalib",
"/TRT/Calib/ToTCalib")
if not (conddb.folderRequested('/TRT/Calib/HTCalib')
or conddb.folderRequested('/TRT/Onl/Calib/HTCalib')):
conddb.addFolderSplitOnline("TRT", "/TRT/Onl/Calib/HTCalib",
"/TRT/Calib/HTCalib")
# Calibration DB Service
from AthenaCommon.AppMgr import ServiceMgr
from TRT_ConditionsServices.TRT_ConditionsServicesConf import TRT_CalDbSvc
#InDetTRTCalDbSvc = TRT_CalDbSvc(self.instanceName('TRT_CalDbSvc')) #
InDetTRTCalDbSvc = TRT_CalDbSvc('TRT_CalDbSvc')
ServiceMgr += InDetTRTCalDbSvc
if self._print:
print InDetTRTCalDbSvc
# Dead/Noisy Straw Lists
if not (conddb.folderRequested('/TRT/Cond/Status')
or conddb.folderRequested('/TRT/Onl/Cond/Status')):
conddb.addFolderSplitOnline("TRT", "/TRT/Onl/Cond/Status",
"/TRT/Cond/Status")
#there used to be an additional tag here!
#conddb.addFolder("TRT","/TRT/Cond/StatusPermanent<tag>TrtStrawStatusPermanent-01</tag>")
if not (conddb.folderRequested('/TRT/Cond/StatusPermanent')
or conddb.folderRequested('/TRT/Onl/Cond/StatusPermanent')):
conddb.addFolderSplitOnline("TRT", "/TRT/Onl/Cond/StatusPermanent",
"/TRT/Cond/StatusPermanent")
#high threshold capabilities
if not (conddb.folderRequested('/TRT/Cond/StatusHT')
or conddb.folderRequested('/TRT/Onl/Cond/StatusHT')):
conddb.addFolderSplitOnline("TRT", "/TRT/Onl/Cond/StatusHT",
"/TRT/Cond/StatusHT")
# DCS Data Folders
from AthenaCommon.GlobalFlags import globalflags
if (globalflags.InputFormat() == 'bytestream'
and globalflags.DataSource() == 'data'):
if self.useDCS and not self.onlineMode:
if not conddb.folderRequested(
'/TRT/DCS/HV/BARREL <cache>600</cache>'):
conddb.addFolder('DCS_OFL',
"/TRT/DCS/HV/BARREL <cache>600</cache>")
if not conddb.folderRequested(
'/TRT/DCS/HV/ENDCAPA <cache>600</cache>'):
conddb.addFolder('DCS_OFL',
"/TRT/DCS/HV/ENDCAPA <cache>600</cache>")
if not conddb.folderRequested(
'/TRT/DCS/HV/ENDCAPC <cache>600</cache>'):
conddb.addFolder('DCS_OFL',
"/TRT/DCS/HV/ENDCAPC <cache>600</cache>")
# TRT PID tools
if not (conddb.folderRequested('/TRT/Calib/PID')
or conddb.folderRequested('/TRT/Onl/Calib/PID')):
conddb.addFolderSplitOnline("TRT", "/TRT/Onl/Calib/PID",
"/TRT/Calib/PID")
if not (conddb.folderRequested('/TRT/Calib/PIDver_New')
or conddb.folderRequested('/TRT/Onl/Calib/PIDver_New')):
conddb.addFolderSplitOnline("TRT", "/TRT/Onl/Calib/PIDver_New",
"/TRT/Calib/PIDver_New")
if not (conddb.folderRequested('/TRT/Calib/PID_RToTver_New')
or conddb.folderRequested('/TRT/Onl/Calib/PID_RToTver_New')):
conddb.addFolderSplitOnline("TRT",
"/TRT/Onl/Calib/PID_RToTver_New",
"/TRT/Calib/PID_RToTver_New")
#
# Load and Configure TRT Conditions Services
#
InDetTRTConditionsServices = []
# Dead/Noisy Straw Service
from TRT_ConditionsServices.TRT_ConditionsServicesConf import TRT_StrawStatusSummarySvc
InDetTRTStrawStatusSummarySvc = \
TRT_StrawStatusSummarySvc(name=self.instanceName("InDetTRTStrawStatusSummarySvc"))
ServiceMgr += InDetTRTStrawStatusSummarySvc
InDetTRTConditionsServices.append(InDetTRTStrawStatusSummarySvc)
if self._print:
print InDetTRTStrawStatusSummarySvc
# Services which only run on raw data
if (globalflags.InputFormat() == 'bytestream'
and globalflags.DataSource() == 'data'):
# Hardware Mapping Service
from TRT_ConditionsServices.TRT_ConditionsServicesConf import TRT_HWMappingSvc
InDetTRT_HWMappingSvc = TRT_HWMappingSvc(
name=self.instanceName("InDetTRT_HWMappingSvc"))
ServiceMgr += InDetTRT_HWMappingSvc
if self._print:
print InDetTRT_HWMappingSvc
# DCS Conditions Service
if self.useDCS and not self.onlineMode:
from TRT_ConditionsServices.TRT_ConditionsServicesConf import TRT_DCS_ConditionsSvc
InDetTRT_DCS_ConditionsSvc = TRT_DCS_ConditionsSvc(
name=self.instanceName("InDetTRT_DCS_ConditionsSvc"),
HWMapSvc=InDetTRT_HWMappingSvc,
#OutputLevel = VERBOSE,
EventInfoKey="ByteStreamEventInfo",
DoIOVChecking=True,
IOVmaxLength=7 * 24 * 60 * 60,
#FallBackOnCOOLChanName = False,
)
ServiceMgr += InDetTRT_DCS_ConditionsSvc
if self._print:
print InDetTRT_DCS_ConditionsSvc
InDetTRTConditionsServices.append(InDetTRT_DCS_ConditionsSvc)
# TRT Conditions Summary Service
from TRT_ConditionsServices.TRT_ConditionsServicesConf import TRT_ConditionsSummarySvc
InDetTRTConditionsSummaryService = TRT_ConditionsSummarySvc(
name=self.instanceName("InDetTRTConditionsSummaryService"),
ServiceList=InDetTRTConditionsServices,
)
ServiceMgr += InDetTRTConditionsSummaryService
if self._print:
print InDetTRTConditionsSummaryService
from TRT_RecoConditionsServices.TRT_RecoConditionsServicesConf import TRT_ActiveFractionSvc
InDetTRT_ActiveFractionSvc = TRT_ActiveFractionSvc(
name=self.instanceName("InDetTRTActiveFractionSvc"),
#missing link to TRTSummarySvc
)
ServiceMgr += InDetTRT_ActiveFractionSvc
def createOutputStream(streamName,
fileName="",
asAlg=False,
noTag=False,
eventInfoKey="EventInfo",
decisionFilter="",
trigNavThinningSvc=None):
if trigNavThinningSvc is None:
trigNavThinningSvc = _trigNavThinningSvcs.get(streamName, None)
# define athena output stream
writingTool = AthenaOutputStreamTool(streamName + "Tool")
outputStream = AthenaOutputStream(streamName,
WritingTool=writingTool,
ItemList=["EventInfo#*"])
#outputStream.ItemList += [ "xAOD::EventInfo#*" ]
outputStream.MetadataStore = svcMgr.MetaDataStore
outputStream.MetadataItemList = [
"EventStreamInfo#" + streamName, "IOVMetaDataContainer#*"
]
## get a handle on the default top-level algorithm sequence
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
from AthenaCommon.AlgSequence import AthSequencer
outSequence = AthSequencer("AthOutSeq")
doTag = not noTag
if doTag:
if ('EventInfoTagBuilder/EventInfoTagBuilder'
not in topSequence.getProperties()['Members']):
key = "SimpleTag"
# Tell tool to pick it up
outputStream.WritingTool.AttributeListKey = key
# build eventinfo attribute list
from .OutputStreamAthenaPoolConf import EventInfoAttListTool, EventInfoTagBuilder
EventInfoTagBuilder = EventInfoTagBuilder(
AttributeList=key,
EventInfoKey=eventInfoKey,
FilterString=decisionFilter)
from AthenaCommon.GlobalFlags import globalflags
if globalflags.InputFormat() == 'bytestream':
#No event-tag input in bytestream
EventInfoTagBuilder.PropagateInput = False
topSequence += EventInfoTagBuilder
# decide where to put outputstream in sequencing
if asAlg:
outSequence += outputStream
else:
outSequence += outputStream
if fileName != "":
outputStream.OutputFile = fileName
from .OutputStreamAthenaPoolConf import MakeEventStreamInfo
streamInfoTool = MakeEventStreamInfo(streamName +
"_MakeEventStreamInfo")
streamInfoTool.Key = streamName
streamInfoTool.EventInfoKey = eventInfoKey
outputStream.HelperTools = [streamInfoTool]
# Support for MT thinning.
from AthenaServices.AthenaServicesConf import Athena__ThinningCacheTool
tct = Athena__ThinningCacheTool('ThinningCacheTool_' + streamName,
StreamName=streamName)
if trigNavThinningSvc is not None:
tct.TrigNavigationThinningSvc = trigNavThinningSvc
outputStream.HelperTools += [tct]
# Set the list of transient items based on what we know is in the transient
# store. The output algorithm will then declare input dependencies
# for objects which are both listed here and in the ItemList.
# (We do it like this because ItemList is typically configured to include
# everything which might possibly be output. If this gets cleaned up,
# then we can remove this.)
# Some builds don't include RecExConfig, so don't crash in that case.
# FIXME: Rather than using ObjKeyStore, we could scan all algorithms
# and look for write handles.
try:
tlist = []
from RecExConfig.ObjKeyStore import objKeyStore
for typ, klist in objKeyStore['transient'].getProperties().items():
for k in klist:
tlist.append(typ + '#' + k)
outputStream.TransientItems += tlist
except ImportError:
pass
return outputStream
globalflags.DataSource = 'data'
#--------------------------------------------------------------
# Detector Set Up
#-------------------------------------------------------------
from RecExConfig.RecFlags import rec
rec.Commissioning = False
rec.doESD.set_Value_and_Lock(True)
rec.doInDet.set_Value_and_Lock(True)
rec.doEgamma.set_Value_and_Lock(False)
rec.doWriteESD.set_Value_and_Lock(False) ## write out ESDs
rec.doJiveXML.set_Value_and_Lock(False) ## for ATLANTIS
readESD = True
readRDO = False
if globalflags.InputFormat() == 'bytestream':
readESD = False
elif globalflags.InputFormat() == 'pool' and globalflags.DataSource(
) == 'geant4':
redESD = False
redRDO = True
rec.readESD = readESD
rec.readRDO = readRDO
from AthenaCommon.DetFlags import DetFlags
# --- switch on Detector bits
DetFlags.ID_setOn()
#DetFlags.makeRIO.pixel_setOff()
#DetFlags.makeRIO.SCT_setOff()
#DetFlags.makeRIO.TRT_setOff()
def configure(self):
from AthenaCommon.Logging import logging
mlog = logging.getLogger('CaloCellGetter::configure:')
mlog.info('entering')
doStandardCellReconstruction = True
from CaloRec.CaloCellFlags import jobproperties
from AthenaCommon.AppMgr import ToolSvc
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:
from LArROD.LArRODFlags import larRODFlags
from AthenaCommon.GlobalFlags import globalflags
if larRODFlags.readDigits() and globalflags.DataSource() == 'data':
from LArROD.LArRawChannelBuilderDefault import LArRawChannelBuilderDefault
LArRawChannelBuilderDefault()
# 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 Exception:
mlog.error("could not import CaloRec.CaloCellMaker")
print(traceback.format_exc())
return False
theCaloCellMaker = CaloCellMaker()
self._CaloCellMakerHandle = theCaloCellMaker
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()
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():
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource(
) == 'data' and globalflags.InputFormat() == 'bytestream':
try:
svcMgr.ByteStreamCnvSvc.ROD2ROBmap = ["-1"]
if "TileDigitsContainer/TileDigitsCnt" not in svcMgr.ByteStreamAddressProviderSvc.TypeNames:
svcMgr.ByteStreamAddressProviderSvc.TypeNames += [
"TileBeamElemContainer/TileBeamElemCnt",
"TileDigitsContainer/TileDigitsCnt",
"TileL2Container/TileL2Cnt",
"TileLaserObject/TileLaserObj",
"TileMuonReceiverContainer/TileMuRcvCnt"
]
except Exception:
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.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 'doTileOpt2' not in dir():
from RecExConfig.AutoConfiguration import GetRunNumber
rn = GetRunNumber()
if not athenaCommonFlags.isOnline(
) and 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(
) # noqa: F841
except Exception:
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 Exception:
mlog.error("Could not configure TileDigitsFilter")
from AthenaCommon.AlgSequence import AthSequencer
condSequence = AthSequencer("AthCondSeq")
checkDCS = hasattr(condSequence, 'TileDCSCondAlg')
try:
from TileRecUtils.TileRecUtilsConf import TileCellBuilder
theTileCellBuilder = TileCellBuilder(CheckDCS=checkDCS)
from TileRecUtils.TileRecFlags import jobproperties
theTileCellBuilder.TileRawChannelContainer = jobproperties.TileRecFlags.TileRawChannelContainer(
)
if (jobproperties.TileRecFlags.noiseFilter() == 1
and jobproperties.TileRecFlags.readDigits()
and globalflags.DataSource() == 'data'
and not globalflags.isOverlay()):
theTileCellBuilder.TileDSPRawChannelContainer = 'TileRawChannelCntCorrected'
rawChannelContainer = ''
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:
rawChannelContainer = '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(
)
theCaloCellMaker += theTileCellBuilder
theCaloCellMaker.CaloCellMakerToolNames += [
theTileCellBuilder
]
except Exception:
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()
theCaloCellMaker += theEmptyCellBuilderTool
theCaloCellMaker.CaloCellMakerToolNames += [
theEmptyCellBuilderTool
]
print(theEmptyCellBuilderTool)
mlog.info("configure EmptyCellBuilderTool worked")
except Exception:
mlog.error("could not get handle to EmptyCellBuilderTool Quit")
print(traceback.format_exc())
return False
try:
from FastCaloSim.FastCaloSimFactory import FastCaloSimFactory
theFastShowerCellBuilderTool = FastCaloSimFactory()
theCaloCellMaker += theFastShowerCellBuilderTool
theCaloCellMaker.CaloCellMakerToolNames += [
theFastShowerCellBuilderTool
]
mlog.info("configure FastShowerCellBuilderTool worked")
except Exception:
mlog.error(
"could not get handle to FastShowerCellBuilderTool Quit")
print(traceback.format_exc())
return False
doFastCaloSimNoise = jobproperties.CaloCellFlags.doFastCaloSimNoise(
)
if doFastCaloSimNoise:
try:
from FastCaloSim.AddNoiseCellBuilderToolDefault import AddNoiseCellBuilderToolDefault
theAddNoiseCellBuilderTool = AddNoiseCellBuilderToolDefault(
)
print(theAddNoiseCellBuilderTool)
theCaloCellMaker += theAddNoiseCellBuilderTool
theCaloCellMaker.CaloCellMakerToolNames += [
theAddNoiseCellBuilderTool
]
mlog.info("configure AddNoiseCellBuilderTool worked")
except Exception:
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()
theCaloCellMaker += 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 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 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 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(
):
from AthenaCommon.GlobalFlags import globalflags
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
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 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
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:
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")
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())
#
# 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.LArCellRecConf import LArCellContHVCorrTool
theLArCellHVCorrTool = LArCellContHVCorrTool()
#theCaloCellMaker += theHVCorrTool
theCaloCellMaker.CaloCellMakerToolNames += [theLArCellHVCorrTool]
#
# 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 Exception:
mlog.error("could not get handle to LArCellRecalibration Quit")
print(traceback.format_exc())
return False
# get new ADC2MeVTool
try:
from LArRecUtils.LArADC2MeVToolDefault import LArADC2MeVToolDefault
theLArADC2MeVToolDefault = LArADC2MeVToolDefault()
except Exception:
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 Exception:
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 Exception:
mlog.error("could not get handle to HVCorrTool Quit")
print(traceback.format_exc())
return False
theCaloCellMaker += 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 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
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:
if globalflags.DataSource.get_Value(
) != 'geant4': #warning only if not MC
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]
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"
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",
className="AthenaAttributeList")
theCaloCellMaker += theCCERescalerTool
theCaloCellMaker.CaloCellMakerToolNames += [theCCERescalerTool]
except Exception:
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 CaloCellCorrection.CaloCellCorrectionConf import CaloCellTimeCorrTool
theLArTimeCorr = CaloCellTimeCorrTool()
theLArTimeCorr.Folder = "/LAR/TimeCorrectionOfl/CellTimeOffset"
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",
className="AthenaAttributeList")
theCaloCellMaker.CaloCellMakerToolNames += [theLArTimeCorr]
except Exception:
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
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(TileRawChannelContainer=rawChannelContainer)
# 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
# --- printout
DetFlags.Print()
# --- output level
OutputLevel = DEBUG
#--------------------------------------------------------------
# Load InDet configuration
#--------------------------------------------------------------
# --- setup InDetJobProperties
from AthenaCommon.GlobalFlags import globalflags
from InDetRecExample.InDetJobProperties import InDetFlags
InDetFlags.doTruth = (globalflags.DataSource == 'geant4'
and globalflags.InputFormat() == 'pool')
#InDetFlags.doTruth = False
#if globalflags.InputFormat() == 'pool' and not globalflags.DataSource == 'geant4':
# ---- run over ESD files
InDetFlags.preProcessing = True
InDetFlags.doPRDFormation = True
#else:
# InDetFlags.doPRDFormation = True
# --- uncomment to change the default of one of the following options:
InDetFlags.doNewTracking = True
#InDetFlags.doLowPt = True
#InDetFlags.doBeamGas = True
#InDetFlags.doBeamHalo = True
#if not Cosmics:
InDetFlags.doxKalman = False
topSequence = AlgSequence()
topSequence += AthenaMonManager("L1MonManager0A")
L1Man0A = topSequence.L1MonManager0A
topSequence += AthenaMonManager("L1MonManager0B")
L1Man0B = topSequence.L1MonManager0B
topSequence += AthenaMonManager("L1MonManager0C")
L1Man0C = topSequence.L1MonManager0C
topSequence += AthenaMonManager("L1MonManager1")
L1Man1 = topSequence.L1MonManager1
topSequence += AthenaMonManager("L1MonManager2")
L1Man2 = topSequence.L1MonManager2
## get a handle on the ToolSvc
#from AthenaCommon.AppMgr import ToolSvc
if globalflags.InputFormat() == "bytestream":
include("TrigT1CaloByteStream/ReadLVL1CaloBS_jobOptions.py")
if not hasattr(svcMgr, "ByteStreamAddressProviderSvc"):
from ByteStreamCnvSvcBase.ByteStreamCnvSvcBaseConf import ByteStreamAddressProviderSvc
svcMgr += ByteStreamAddressProviderSvc()
svcMgr.ByteStreamAddressProviderSvc.TypeNames += ["CTP_RDO/CTP_RDO"]
if isData and isCalo and (Online or rec.triggerStream() == "express"
or rec.triggerStream() == "JetTauEtmiss"):
####################### Calorimeter -> L1Calo ################################
include("CaloConditions/CaloConditions_jobOptions.py")
include("LArDetDescr/LArDetDescr_joboptions.py")
# CaloCells
from TrigT1Monitoring.TrigT1MonitoringConf import LVL1__CalorimeterL1CaloMon
CalorimeterL1CaloMonTool = LVL1__CalorimeterL1CaloMon(
def createSvc(self):
#
# Load necessary conditions folders
#
# Calibration constants
from IOVDbSvc.CondDB import conddb
if not self._isMC:
#only needed for data
if not (conddb.folderRequested('/TRT/Onl/ROD/Compress')):
conddb.addFolder("TRT_ONL",
"/TRT/Onl/ROD/Compress",
className='CondAttrListCollection')
if not (conddb.folderRequested('/TRT/Calib/RT')
or conddb.folderRequested('/TRT/Onl/Calib/RT')):
conddb.addFolderSplitOnline(
'TRT',
'/TRT/Onl/Calib/RT',
'/TRT/Calib/RT',
className='TRTCond::RtRelationMultChanContainer')
if not (conddb.folderRequested('/TRT/Calib/T0')
or conddb.folderRequested('/TRT/Onl/Calib/T0')):
conddb.addFolderSplitOnline(
'TRT',
'/TRT/Onl/Calib/T0',
'/TRT/Calib/T0',
className='TRTCond::StrawT0MultChanContainer')
if not (conddb.folderRequested('/TRT/Calib/errors')
or conddb.folderRequested('/TRT/Onl/Calib/errors')):
conddb.addFolderSplitOnline(
"TRT",
"/TRT/Onl/Calib/errors",
"/TRT/Calib/errors",
className='TRTCond::RtRelationMultChanContainer')
if not (conddb.folderRequested('/TRT/Calib/errors2d')
or conddb.folderRequested('/TRT/Onl/Calib/errors2d')):
conddb.addFolderSplitOnline(
"TRT",
"/TRT/Onl/Calib/errors2d",
"/TRT/Calib/errors2d",
className='TRTCond::RtRelationMultChanContainer')
if not (conddb.folderRequested('/TRT/Calib/slopes')
or conddb.folderRequested('/TRT/Onl/Calib/slopes')):
conddb.addFolderSplitOnline(
"TRT",
"/TRT/Onl/Calib/slopes",
"/TRT/Calib/slopes",
className='TRTCond::RtRelationMultChanContainer')
# Calibration DB Service
from AthenaCommon.AppMgr import ServiceMgr
# Dead/Noisy Straw Lists
if not conddb.folderRequested('/TRT/Cond/Status'):
conddb.addFolderSplitOnline(
"TRT",
"/TRT/Onl/Cond/Status",
"/TRT/Cond/Status",
className='TRTCond::StrawStatusMultChanContainer')
if not conddb.folderRequested('/TRT/Cond/StatusPermanent'):
conddb.addFolderSplitOnline(
"TRT",
"/TRT/Onl/Cond/StatusPermanent",
"/TRT/Cond/StatusPermanent",
className='TRTCond::StrawStatusMultChanContainer')
# Argon straw list
if not conddb.folderRequested('/TRT/Cond/StatusHT'):
conddb.addFolderSplitOnline(
"TRT",
"/TRT/Onl/Cond/StatusHT",
"/TRT/Cond/StatusHT",
className='TRTCond::StrawStatusMultChanContainer')
#these conditions were instantiated together with specific tools using them in InDetTrigRecLoadTools
#now required for the condAlg
if not (conddb.folderRequested("/TRT/Calib/PID_vector") or \
conddb.folderRequested("/TRT/Onl/Calib/PID_vector")):
conddb.addFolderSplitOnline("TRT",
"/TRT/Onl/Calib/PID_vector",
"/TRT/Calib/PID_vector",
className='CondAttrListVec')
if not (conddb.folderRequested("/TRT/Calib/ToT/ToTVectors") or \
conddb.folderRequested("/TRT/Onl/Calib/ToT/ToTVectors")):
conddb.addFolderSplitOnline("TRT",
"/TRT/Onl/Calib/ToT/ToTVectors",
"/TRT/Calib/ToT/ToTVectors",
className='CondAttrListVec')
if not (conddb.folderRequested("/TRT/Calib/ToT/ToTValue") or \
conddb.folderRequested("/TRT/Onl/Calib/ToT/ToTValue")):
conddb.addFolderSplitOnline("TRT",
"/TRT/Onl/Calib/ToT/ToTValue",
"/TRT/Calib/ToT/ToTValue",
className='CondAttrListCollection')
# Straw status tool (now private, cannot be passed by name)
from InDetTrigRecExample.InDetTrigCommonTools import InDetTrigTRTStrawStatusSummaryTool
# Alive straws algorithm
from TRT_ConditionsAlgs.TRT_ConditionsAlgsConf import TRTStrawCondAlg
TRTStrawCondAlg = TRTStrawCondAlg(
name="TRTStrawCondAlg",
TRTStrawStatusSummaryTool=InDetTrigTRTStrawStatusSummaryTool,
isGEANT4=self._isMC)
# Active Fraction algorithm
from TRT_ConditionsAlgs.TRT_ConditionsAlgsConf import TRTActiveCondAlg
TRTActiveCondAlg = TRTActiveCondAlg(
name="TRTActiveCondAlg",
TRTStrawStatusSummaryTool=InDetTrigTRTStrawStatusSummaryTool)
# HT probability algorithm
from TRT_ConditionsAlgs.TRT_ConditionsAlgsConf import TRTHTCondAlg
TRTHTCondAlg = TRTHTCondAlg(name="TRTHTCondAlg")
from TRT_ConditionsAlgs.TRT_ConditionsAlgsConf import TRTToTCondAlg
TRTToTCondAlg = TRTToTCondAlg(name="TRTToTCondAlg")
from AthenaCommon.AlgSequence import AthSequencer
condSeq = AthSequencer("AthCondSeq")
# Condition algorithms for straw conditions
if not hasattr(condSeq, "TRTStrawCondAlg"):
condSeq += TRTStrawCondAlg
if not hasattr(condSeq, "TRTActiveCondAlg"):
condSeq += TRTActiveCondAlg
# Condition algorithms for Pid
if not hasattr(condSeq, "TRTHTCondAlg"):
condSeq += TRTHTCondAlg
if not hasattr(condSeq, "TRTToTCondAlg"):
condSeq += TRTToTCondAlg
from AthenaCommon.GlobalFlags import globalflags
#
# Load and Configure TRT Conditions Services
#
InDetTRTConditionsServices = []
# Services which only run on raw data
if (globalflags.InputFormat() == 'bytestream'
and globalflags.DataSource() == 'data'):
# Hardware Mapping Service
from TRT_ConditionsServices.TRT_ConditionsServicesConf import TRT_HWMappingSvc
InDetTRT_HWMappingSvc = TRT_HWMappingSvc(
name=self.instanceName("InDetTRT_HWMappingSvc"))
ServiceMgr += InDetTRT_HWMappingSvc
if self._print:
print(InDetTRT_HWMappingSvc)
# DCS Conditions Service
if self.useDCS and not self.onlineMode:
from TRT_ConditionsServices.TRT_ConditionsServicesConf import TRT_DCS_ConditionsSvc
InDetTRT_DCS_ConditionsSvc = TRT_DCS_ConditionsSvc(
name=self.instanceName("InDetTRT_DCS_ConditionsSvc"),
HWMapSvc=InDetTRT_HWMappingSvc,
#OutputLevel = VERBOSE,
EventInfoKey="ByteStreamEventInfo",
DoIOVChecking=True,
IOVmaxLength=7 * 24 * 60 * 60,
#FallBackOnCOOLChanName = False,
)
ServiceMgr += InDetTRT_DCS_ConditionsSvc
if self._print:
print(InDetTRT_DCS_ConditionsSvc)
InDetTRTConditionsServices.append(InDetTRT_DCS_ConditionsSvc)
# TRT Conditions Summary Service
from TRT_ConditionsServices.TRT_ConditionsServicesConf import TRT_ConditionsSummarySvc
InDetTRTConditionsSummaryService = TRT_ConditionsSummarySvc(
name=self.instanceName("InDetTRTConditionsSummaryService"),
ServiceList=InDetTRTConditionsServices,
)
ServiceMgr += InDetTRTConditionsSummaryService
if self._print:
print(InDetTRTConditionsSummaryService)
#-- set that if using some ModuleOverlay maks
#
#conddb.iovdbsvc.Folders += [ "<dbConnection>impl=cool;techno=sqlite;schema=module_overlay.db;X:CONDBR2</dbConnection> /PIXEL/PixMapOverlay <tag>PixMapOverlay-Test-00</tag>" ]
#ServiceMgr.SpecialPixelMapSvc.ModuleOverlayFolder = "/PIXEL/PixMapOverlay"
#ServiceMgr.SpecialPixelMapSvc.ModuleOverlayKey = "PixMapOverlay"
from PixelConditionsServices.PixelConditionsServicesConf import PixelConditionsSummarySvc
ServiceMgr += PixelConditionsSummarySvc()
ServiceMgr.PixelConditionsSummarySvc.UseSpecialPixelMap = False
ServiceMgr.PixelConditionsSummarySvc.UseDCS = False
ServiceMgr.PixelConditionsSummarySvc.UseByteStream = True
## Input files
if globalflags.InputFormat() == 'pool':
import AthenaPoolCnvSvc.ReadAthenaPool
ServiceMgr.EventSelector.InputCollections = collection
include("PixelByteStreamErrorsSvc_jobOptions.py")
elif globalflags.InputFormat() == 'bytestream':
include("ByteStreamCnvSvc/BSEventStorageEventSelector_jobOptions.py")
include("InDetRecExample/InDetReadBS_jobOptions.py")
ServiceMgr.EventSelector.Input = collection
topSequence += NoiseMapBuilder
#
# include clusterization
#
if doClusterization:
