cfg_truthassoc_akt4lc = METAssocConfig(
'Truth_AntiKt4LCTopo', [AssocConfig('Truth', 'AntiKt4LCTopoJets')],
doTruth=True)
metFlags.METAssocConfigs()[
cfg_truthassoc_akt4lc.suffix] = cfg_truthassoc_akt4lc
metFlags.METAssocOutputList().append(cfg_truthassoc_akt4lc.suffix)
############################################################################
# AntiKt4EMTopo
cfg_truthassoc_akt4em = METAssocConfig(
'Truth_AntiKt4EMTopo', [AssocConfig('Truth', 'AntiKt4EMTopoJets')],
doTruth=True)
metFlags.METAssocConfigs()[
cfg_truthassoc_akt4em.suffix] = cfg_truthassoc_akt4em
#metFlags.METAssocOutputList().append(cfg_truthassoc_akt4em.suffix)
############################################################################
# AntiKt4EMPFlow
from RecExConfig.RecFlags import rec
if rec.doInDet() and metFlags.DoPFlow():
cfg_truthassoc_akt4pf = METAssocConfig(
'Truth_AntiKt4EMPFlow', [AssocConfig('Truth', 'AntiKt4EMPFlowJets')],
doTruth=True)
metFlags.METAssocConfigs()[
cfg_truthassoc_akt4pf.suffix] = cfg_truthassoc_akt4pf
metFlags.METAssocOutputList().append(cfg_truthassoc_akt4pf.suffix)
MuonDQADetFlags.doCSCSegmMon = False
## --- Muon StandAlone Trk Monitoring and MuonCombined options
MuonDQADetFlags.doMuonTrackMon = True
## --- MuonTrk Trigger Aware Monitoring options
MuonDQADetFlags.MuonTrkMonDoTrigger = False
# --- Muon Alignment Monitoring
MuonDQADetFlags.doMuonTrkAlignMon = False
# --- MuonPhysics Monitoring options
MuonDQADetFlags.doMuonPhysMon = False
from RecExConfig.RecFlags import rec
MuonDQADetFlags.doMuTrkMon = rec.doInDet()
# --- HighLvl Muon Monitoring options
#MuonDQADetFlags.doMuonTrkPhysMon = rec.doMuon()
#MuonDQADetFlags.doMuonTrkPhysMon = True
#
if recFlags.doInDet() and recFlags.doMuon():
MuonDQADetFlags.doMuonTrkPhysMon = True
MuonDQADetFlags.doMuonCbTrkAlignMon = False
else:
MuonDQADetFlags.doMuonTrkPhysMon = False
MuonDQADetFlags.doMuonCbTrkAlignMon = False
#----------------------#
# Muon raw monitoring #
FixedCutTightTrackOnlyIsoTool.MuonWP = "FixedCutTightTrackOnly"
ToolSvc += FixedCutTightTrackOnlyIsoTool
FixedCutLooseIsoTool = CfgMgr.CP__IsolationSelectionTool( "MuonFixedCutLooseIsolationSelectionTool" )
FixedCutLooseIsoTool.MuonWP = "FixedCutLoose"
ToolSvc += FixedCutLooseIsoTool
from RecExConfig.RecFlags import rec
from MuonTagTools.MuonTagToolsConf import MuonTagTool as ConfiguredMuonTagTool
from MuonRecExample.MuonRecFlags import muonRecFlags
MuonTagTool = ConfiguredMuonTagTool(Container = theMuonCollection,
MuonMETContainerName = MuonMETContainerName,
PtCut = 6.0*GeV,
EtconeIsoCutValues = [3.0*GeV, 5.0*GeV],
PtconeIsoCutValues = [3.0*GeV, 5.0*GeV],
EtconeRelIsoCutValues = [0.15, 0.3],
PtconeRelIsoCutValues = [0.15, 0.3],
isCosmics = CosmicsCommissioning,
doInDet = rec.doInDet(),
MuonCalibrationTool = MuonCorrectionTool,
MuonSelectionTool = MuonSelectionTool,
LooseTrackOnlyIsolation= LooseTrackOnlyIsoTool,
LooseIsolation = LooseIsoTool ,
TightIsolation = TightIsoTool ,
GradientIsolation = GradientIsoTool ,
GradientLooseIsolation = GradientLooseIsoTool,
FixedCutTightTrackOnlyIsolation= FixedCutTightTrackOnlyIsoTool,
FixedCutLooseIsolation = FixedCutLooseIsoTool,
DoIsolation = muonRecFlags.doMuonIso()
)
ToolSvc += MuonTagTool
include.block('RecBackgroundAlgs/RecBackground_jobOptions.py')
from RecExConfig.RecFlags import rec
from AthenaCommon.DetFlags import DetFlags
if rec.doInDet() and rec.doMuon() and rec.doCalo() and \
DetFlags.detdescr.Muon_on() and DetFlags.detdescr.Calo_on() and DetFlags.detdescr.ID_on() :
from RecBackgroundAlgs.RecBackgroundAlgsConf import BeamBackgroundFiller
BeamBackgroundFiller = BeamBackgroundFiller()
topSequence += BeamBackgroundFiller
from BCM_BackgroundAlgs.BCM_BackgroundAlgsConf import BcmCollisionTimeAlg
BcmCollisionTimeAlg = BcmCollisionTimeAlg()
topSequence += BcmCollisionTimeAlg
from RecBackgroundAlgs.RecBackgroundAlgsConf import BackgroundWordFiller
BackgroundWordFiller = BackgroundWordFiller()
topSequence += BackgroundWordFiller
print myname + " Final useTruth: " + sflagstat(jetFlags.useTruth)
# Skip use of topoclusters if not built
# No action if someone has already set the flag.
print myname + "Initial use topoclusters: " + str(jetFlags.useTopo())
if not jetFlags.useTopo.statusOn:
jetFlags.useTopo = rec.doCalo()
print myname + " Final use topoclusters: " + str(jetFlags.useTopo())
# Skip tracks if tracks or vertices are not present in the job.
# No action if someone has already set the flag.
haveTracks = cfgKeyStore.isInTransient('xAOD::TrackParticleContainer',
'InDetTrackParticles')
haveVertices = cfgKeyStore.isInTransient("xAOD::VertexContainer",
"PrimaryVertices")
recTracks = rec.doInDet()
recVertices = bool(InDetFlags.doVertexFinding) and (recTracks or haveTracks)
print myname + "Initial useTracks: " + sflagstat(jetFlags.useTracks)
print myname + " rec doInDet: " + str(recTracks)
print myname + " doVertexFinding: " + str(recVertices)
print myname + " have tracks: " + str(haveTracks)
print myname + " have vertices: " + str(haveVertices)
if not jetFlags.useTracks.statusOn:
jetFlags.useTracks = (recTracks or haveTracks) and (recVertices
or haveVertices)
print myname + " Final useTracks: " + sflagstat(jetFlags.useTracks)
if not jetFlags.useVertices.statusOn:
jetFlags.useVertices = (recVertices or haveVertices)
print myname + " useVertices: " + sflagstat(jetFlags.useVertices)
svcMgr = theApp.serviceMgr()
if not hasattr(svcMgr, "ByteStreamAddressProviderSvc"):
logBSRead.error("Can't find ByteStreamAddressProviderSvc!")
if not athenaCommonFlags.isOnline() and not rec.readTAG():
try:
#svcMgr.ByteStreamInputSvc.ProcessBadEvent=True
svcMgr.EventSelector.ProcessBadEvent = True
except Exception:
treatException(
"could not set svcMgr.EventSelector.ProcessBadEvent=True")
from RecExConfig.RecFlags import rec
from AthenaCommon.DetFlags import DetFlags
if rec.doInDet():
include("InDetRecExample/InDetReadBS_jobOptions.py")
if rec.doMuon():
include("MuonCnvExample/MuonReadBS_jobOptions.py")
if DetFlags.readRDOBS.LAr_on():
if globalflags.DataSource() == 'data':
svcMgr.ByteStreamAddressProviderSvc.TypeNames += [
"LArFebHeaderContainer/LArFebHeader"
]
else: # Bytestream from MC
svcMgr.ByteStreamAddressProviderSvc.TypeNames += [
"LArRawChannelContainer/LArRawChannels"
]
from CaloRec.CaloRecFlags import jobproperties
from InDetRecExample.InDetJobProperties import InDetFlags
from MuonRecExample.MuonRecFlags import muonRecFlags
from MuonCombinedRecExample.MuonCombinedRecFlags import muonCombinedRecFlags
from egammaRec.egammaRecFlags import jobproperties
from tauRec.tauRecFlags import jobproperties
from JetRec.JetRecFlags import jobproperties
if (not rec.doCalo()) or (rec.readRDO()
and not jobproperties.CaloRecFlags.Enabled()):
DQMonFlags.doCaloMon = False
DQMonFlags.doTileMon = False
DQMonFlags.doLArMon = False
if (not rec.doInDet()) or (rec.readRDO()
and not jobproperties.InDetJobProperties.Enabled()):
DQMonFlags.doPixelMon = False
DQMonFlags.doSCTMon = False
DQMonFlags.doTRTMon = False
DQMonFlags.doTRTElectronMon = False
DQMonFlags.doInDetGlobalMon = False
DQMonFlags.doInDetAlignMon = False
DQMonFlags.doInDetPerfMon = False
if (not rec.doMuon()) or (rec.readRDO()
and not jobproperties.MuonRec.Enabled()):
DQMonFlags.doMuonRawMon = False
DQMonFlags.doMuonSegmentMon = False
DQMonFlags.doMuonTrackMon = False
DQMonFlags.doMuonAlignMon = False
if not jetFlags.useTruth.statusOn:
jetFlags.useTruth = rec.doTruth()
print myname + " Final useTruth: " + sflagstat(jetFlags.useTruth)
# Skip use of topoclusters if not built
# No action if someone has already set the flag.
print myname + "Initial use topoclusters: " + str(jetFlags.useTopo())
if not jetFlags.useTopo.statusOn:
jetFlags.useTopo = rec.doCalo()
print myname + " Final use topoclusters: " + str(jetFlags.useTopo())
# Skip tracks if tracks or vertices are not present in the job.
# No action if someone has already set the flag.
haveTracks = cfgKeyStore.isInTransient('xAOD::TrackParticleContainer','InDetTrackParticles')
haveVertices = cfgKeyStore.isInTransient("xAOD::VertexContainer","PrimaryVertices")
recTracks = rec.doInDet()
recVertices = bool(InDetFlags.doVertexFinding) and (recTracks or haveTracks)
print myname + "Initial useTracks: " + sflagstat(jetFlags.useTracks)
print myname + " rec doInDet: " + str(recTracks)
print myname + " doVertexFinding: " + str(recVertices)
print myname + " have tracks: " + str(haveTracks)
print myname + " have vertices: " + str(haveVertices)
if not jetFlags.useTracks.statusOn:
jetFlags.useTracks = (recTracks or haveTracks) and (recVertices or haveVertices)
print myname + " Final useTracks: " + sflagstat(jetFlags.useTracks)
if not jetFlags.useVertices.statusOn:
jetFlags.useVertices = (recVertices or haveVertices)
print myname + " useVertices: " + sflagstat(jetFlags.useVertices)
# Disable usage of vertices in pflow jets, if we are using cosmic data.
topSequence = AlgSequence()
############################################################################
# Set up muon and egamma topocluster links
muonTCLinkAlg = CfgMgr.ClusterMatching__CaloClusterMatchLinkAlg(
"MuonTCLinks", ClustersToDecorate="MuonClusterCollection")
topSequence += muonTCLinkAlg
############################################################################
# SHOULD BE MIGRATED TO MUON ALGORITHMS
from METReconstruction.METRecoFlags import metFlags
from AthenaCommon.BeamFlags import jobproperties
from RecExConfig.RecFlags import rec
if jobproperties.Beam.beamType == 'cosmics' or jobproperties.Beam.beamType == 'singlebeam' or not rec.doInDet(
):
metFlags.UseTracks.set_Value(False)
metFlags.DoPFlow.set_Value(False)
print "METReconstruction_jobOptions: detected cosmics/single-beam configuration -- switch off track-based MET reco"
import METReconstruction.METConfig_Calo
import METReconstruction.METConfig_Track
if rec.doTruth():
import METReconstruction.METConfig_Truth
from METReconstruction.METRecoConfig import getMETRecoAlg
metAlg = getMETRecoAlg('METReconstruction')
topSequence += metAlg
# Set up default configurations
if rec.readRDO(): from CaloRec.CaloRecFlags import jobproperties from InDetRecExample.InDetJobProperties import InDetFlags from MuonRecExample.MuonRecFlags import muonRecFlags from MuonCombinedRecExample.MuonCombinedRecFlags import muonCombinedRecFlags from egammaRec.egammaRecFlags import jobproperties from tauRec.tauRecFlags import jobproperties from JetRec.JetRecFlags import jobproperties if (not rec.doCalo()) or (rec.readRDO() and not jobproperties.CaloRecFlags.Enabled()): DQMonFlags.doCaloMon=False DQMonFlags.doTileMon=False DQMonFlags.doLArMon=False if (not rec.doInDet()) or (rec.readRDO() and not jobproperties.InDetJobProperties.Enabled()): DQMonFlags.doPixelMon=False DQMonFlags.doSCTMon=False DQMonFlags.doTRTMon=False DQMonFlags.doTRTElectronMon=False DQMonFlags.doInDetGlobalMon=False DQMonFlags.doInDetAlignMon=False DQMonFlags.doInDetPerfMon=False if (not rec.doMuon()) or (rec.readRDO() and not jobproperties.MuonRec.Enabled()): DQMonFlags.doMuonRawMon=False DQMonFlags.doMuonSegmentMon=False DQMonFlags.doMuonTrackMon=False DQMonFlags.doMuonAlignMon=False DQMonFlags.doMuonPhysicsMon=False DQMonFlags.doMuonTrkPhysMon=False
import os
if 'AtlasProject' in os.environ and 'AtlasVersion' in os.environ:
releaseString = '%s-%s' % (os.environ['AtlasProject'],
os.environ['AtlasVersion'])
else:
releaseString = 'Unknown'
DQTDataFlowMon = DQTDataFlowMonTool(name='DQTDataFlowMon',
histoPathBase='/GLOBAL/DQTDataFlow',
releaseString=releaseString)
ToolSvc += DQTDataFlowMon
ManagedAthenaGlobalMon.AthenaMonTools += [DQTDataFlowMon]
#print ManagedAthenaGlobalMon;
#if isBeam==True and (DQMonFlags.monManEnvironment == 'tier0ESD' or DQMonFlags.monManEnvironment == 'online' or DQMonFlags.monManEnvironment == 'tier0' or DQMonFlags.monManEnvironment == 'tier0Raw' ) and rec.doInDet():
if isBeam == True and (DQMonFlags.monManEnvironment != 'tier0Raw'
) and rec.doInDet() and DQMonFlags.useTrigger():
topSequence += AthenaMonManager("GlobalMonPhysicsManager")
ManagedAthenaGlobalPhysMon = topSequence.GlobalMonPhysicsManager
ManagedAthenaGlobalPhysMon.FileKey = DQMonFlags.monManFileKey()
ManagedAthenaGlobalPhysMon.ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup(
)
ManagedAthenaGlobalPhysMon.DataType = DQMonFlags.monManDataType()
ManagedAthenaGlobalPhysMon.Environment = DQMonFlags.monManEnvironment()
from MuonSelectorTools.MuonSelectorToolsConf import CP__MuonSelectionTool
ToolSvc += CP__MuonSelectionTool("DQTMuonSelectionTool",
MaxEta=2.4,
MuQuality=1)
ToolSvc += CfgMgr.CP__IsolationSelectionTool("DQTIsoGradientTool",
MuonWP="LooseTrackOnly",
