def setupMuonCalib():
global topSequence, ToolSvc
if not rec.doMuon() or not DetFlags.Muon_on():
logMuon.warning(
"Not setting up requested Muon Calibration because Muons are off")
return
logMuon.info("Setting up Muon Calibration")
try:
from MuonCnvExample.MuonCalibFlags import muonCalibFlags
muonCalibFlags.setDefaults()
configs = getCalibConfigs()
#
# MuonSegmentToCalibSegment
#
calibConfig = muonRec.allConfigs()[0].getCalibConfig(
) #muonRec.getConfig(muonCalibFlags.EventTag()).getCalibConfig()
MuonSegmentToCalibSegment = getMuonSegmentToCalibSegment()
#
# MuonCalibAlg
#
MuonCalibAlg = getMuonCalibAlg(muonCalibFlags.EventTag())
from MdtCalibTools.MdtCalibToolsConf import MuonCalib__MdtCalibTool
MuonCalibTool = MuonCalib__MdtCalibTool()
calibMode = muonCalibFlags.Mode()
if calibMode == 'regionNtuple':
from MdtCalibTools.MdtCalibToolsConf import MuonCalib__MdtCalibNtupleMakerTool
MdtCalibTool = MuonCalib__MdtCalibNtupleMakerTool()
else:
raise RuntimeError("Unknown Muon Calibration Mode: %r" % calibMode)
ToolSvc += MdtCalibTool
MuonCalibTool.MdtCalibTool = MdtCalibTool
ToolSvc += MuonCalibTool
MuonCalibAlg.MuonCalibTool = MuonCalibTool
except:
from AthenaCommon.Resilience import treatException
treatException(
"Problem in MuonCalib - Muon Calibration configuration probably incomplete"
)
def setupMuonCalibNtuple():
global topSequence, muonRecFlags, beamFlags, ToolSvc, rec, DetFlags
if not rec.doMuon() or not DetFlags.Muon_on():
logMuon.warning(
"Not setting up requested Muon Calibration Ntuple because Muons are off"
)
return
logMuon.info("Setting up Muon Calibration Ntuple")
try:
configs = getCalibConfigs()
# MuonSegmentToCalibSegment is only needed if we want segments
if muonRecFlags.calibNtupleSegments and muonRecFlags.calibMuonStandalone:
MuonSegmentToCalibSegment = getMuonSegmentToCalibSegment()
# MuonCalibAlg is always needed
eventTag = "UNKNOWN"
if (muonRecFlags.calibNtupleSegments or muonRecFlags.calibNtupleTracks
) and muonRecFlags.calibMuonStandalone:
if len(configs) >= 1:
eventTag = configs[0]["eventTag"]
elif muonRecFlags.calibNtupleTrigger:
eventTag = "TRIG"
else:
eventTag = "HITS"
MuonCalibAlg = getMuonCalibAlg(eventTag)
# configure for writing ntuple
from MuonCalibTools.MuonCalibToolsConf import MuonCalib__PatternNtupleMaker
MuonCalibTool = MuonCalib__PatternNtupleMaker(
"MuonCalibPatternNtupleMaker")
MuonCalibTool.FillTruth = rec.doTruth()
MuonCalibTool.DoRawTGC = (muonRecFlags.doTGCs()
and muonRecFlags.calibNtupleRawTGC())
ToolSvc += MuonCalibTool
MuonCalibAlg.MuonCalibTool = MuonCalibTool
# MuonCalibExtraTree only if we want to write tracks
if muonRecFlags.calibNtupleTracks:
MuonCalibTool.DelayFinish = True
from MuonCalibExtraTreeAlg.MuonCalibExtraTreeAlgConf import MuonCalib__MuonCalibExtraTreeAlg
MuonCalibExtraTreeAlg = MuonCalib__MuonCalibExtraTreeAlg(
"MuonCalibExtraTreeAlg",
NtupleName="PatternNtupleMaker",
)
segmentOnTrackSelector = None
if hasattr(topSequence, "MuonSegmentToCalibSegment"):
from MuonCalibExtraTreeAlg.MuonCalibExtraTreeAlgConf import MuonCalib__SegmentOnTrackSelector
segmentOnTrackSelector = MuonCalib__SegmentOnTrackSelector()
segmentOnTrackSelector.PattternLocation = "PatternsForCalibration"
ToolSvc += segmentOnTrackSelector
MuonCalibExtraTreeAlg.SegmentOnTrackSelector = segmentOnTrackSelector
if not rec.doMuonCombined():
tool_nr = 0
from MuonCalibExtraTreeAlg.MuonCalibExtraTreeAlgConf import MuonCalib__ExtraTreeTrackFillerTool
resPullCalc = getPublicTool("ResidualPullCalculator")
for config in configs:
trackDumpTool = MuonCalib__ExtraTreeTrackFillerTool(
"ExtraTreeTrackFillerTool" + str(tool_nr))
trackDumpTool.TrackCollectionKey = config['tracksKey']
trackDumpTool.SegmentAuthors = [config['segmentAuthor']]
trackDumpTool.TrackAuthor = config['trackAuthor']
trackDumpTool.PullCalculator = resPullCalc
ToolSvc += trackDumpTool
MuonCalibExtraTreeAlg.TrackFillerTools.append(
trackDumpTool)
tool_nr += 1
# configure needed tools
# add to topSequence
topSequence += MuonCalibExtraTreeAlg
# MuonCalibExtraTreeTriggerAlg only if trigger is available
if muonRecFlags.calibNtupleTrigger: # and DetFlags.detdescr.LVL1_on() and DetFlags.haveRDO.LVL1_on():
# protect against running without AtlasTrigger project
doMuCTPI = True
if doMuCTPI:
try:
from TrigT1RPCRecRoiSvc import TrigT1RPCRecRoiConfig
from TrigT1TGCRecRoiSvc import TrigT1TGCRecRoiConfig
except ImportError:
logMuon.warning(
"MuonCalibExtraTreeTriggerAlg.doMuCTPI = False because AtlasTrigger is not available"
)
doMuCTPI = False
# delay writing of MuonCalibAlg
MuonCalibTool.DelayFinish = True
# also delay MuonCalibExtraTreeAlg if it is running
try:
topSequence.MuonCalibExtraTreeAlg.DelayFinish = True
except AttributeError:
pass
from MuonCalibExtraTreeAlg.MuonCalibExtraTreeAlgConf import MuonCalib__MuonCalibExtraTreeTriggerAlg
topSequence += MuonCalib__MuonCalibExtraTreeTriggerAlg(
'MuonCalibExtraTreeTriggerAlg',
doMuCTPI=doMuCTPI,
doLVL1Calo=rec.doTile() or rec.doLArg()
or DetFlags.haveRDO.Calo_on(),
doMBTS=rec.doTile() or DetFlags.haveRDO.Tile_on())
except:
from AthenaCommon.Resilience import treatException
treatException(
"Problem in MuonCalib - Muon Calibration Ntuple configuration probably incomplete"
)
from AthenaCommon.BeamFlags import jobproperties
if jobproperties.Beam.beamType == 'cosmics':
jetFlags.useVertices = False
# Skip pflow if we are not using tracks.
print myname + "Initial usePFlow: " + sflagstat(jetFlags.usePFlow)
if not jetFlags.usePFlow.statusOn:
jetFlags.usePFlow = jetFlags.useTracks()
print myname + "Final usePFlow: " + sflagstat(jetFlags.usePFlow)
# Skip use of muon segments if not built.
# No action if someone has already set the flag.
print myname + "Initial use muon segments: " + sflagstat(
jetFlags.useMuonSegments)
if not jetFlags.useMuonSegments.statusOn:
jetFlags.useMuonSegments = rec.doMuon() and rec.doMuonCombined()
print myname + " Final use muon segments: " + sflagstat(
jetFlags.useMuonSegments)
# Use rec flag to control BTagging.
# No. Disable this unit we get support from Btagging to do this.
# No action if someone has already set the flag.
print myname + "Initial use Btagging: " + str(jetFlags.useBTagging)
print myname + " rec do BTagging: " + str(rec.doBTagging())
if not jetFlags.useBTagging.statusOn:
#jetFlags.useBTagging = rec.doBTagging()
jetFlags.useBTagging = False
print myname + " Final use Btagging: " + str(jetFlags.useBTagging)
# The following can be used to exclude tools from reconstruction.
if 0:
from RecExConfig.RecFlags import rec
from RecExConfig.RecAlgsFlags import recAlgs
#AOD list, also added to the ESD
IsoAODESList = []
if rec.doWriteAOD() or rec.doWriteESD():
if rec.doMuon() or rec.doEgamma():
IsoAODESList += ["xAOD::EventShape#TopoClusterIsoCentralEventShape"]
IsoAODESList += [
"xAOD::EventShapeAuxInfo#TopoClusterIsoCentralEventShapeAux."
]
IsoAODESList += ["xAOD::EventShape#TopoClusterIsoForwardEventShape"]
IsoAODESList += [
"xAOD::EventShapeAuxInfo#TopoClusterIsoForwardEventShapeAux."
]
IsoAODESList += [
"xAOD::EventShape#TopoClusterIsoVeryForwardEventShape"
]
IsoAODESList += [
"xAOD::EventShapeAuxInfo#TopoClusterIsoVeryForwardEventShapeAux."
]
if recAlgs.doEFlow():
IsoAODESList += [
"xAOD::EventShape#ParticleFlowIsoCentralEventShape"
]
IsoAODESList += [
"xAOD::EventShapeAuxInfo#ParticleFlowIsoCentralEventShapeAux."
]
IsoAODESList += [
"xAOD::EventShape#ParticleFlowIsoForwardEventShape"
IsolationBuilder,
name="IsolationBuilder",
CaloCellIsolationTool=CaloIsolationTool,
CaloTopoIsolationTool=CaloIsolationTool,
PFlowIsolationTool=CaloIsolationTool,
TrackIsolationTool=TrackIsolationTool,
FeIsoTypes=[] if not rec.doEgamma() else IsoTypesFe,
FeCorTypes=IsoCorFe,
FeCorTypesExtra=IsoCorFeExtra,
ElIsoTypes=[] if not rec.doEgamma() else IsoTypes,
ElCorTypes=IsoCorEg,
ElCorTypesExtra=IsoCorEgExtra,
PhIsoTypes=[] if not rec.doEgamma() else IsoTypes,
PhCorTypes=IsoCorEg,
PhCorTypesExtra=IsoCorEgExtra,
MuIsoTypes=IsoTypes if rec.doMuon() and muonRecFlags.doMuonIso() else [],
MuCorTypes=IsoCorMu,
MuCorTypesExtra=IsoCorMuExtra)
from RecExConfig.Configured import Configured
class isoGetter(Configured):
def configure(self):
mlog = logging.getLogger('isoGetter.py::configure:')
mlog.info('entering')
# configure iso here:
try:
self._isoBuilderHandle = isoBuilder()
except Exception:
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
DQMonFlags.doMuonCombinedMon = False
if (not rec.doMuonCombined()) or (rec.readRDO() and
not jobproperties.MuonCombinedRec.Enabled()):
DQMonFlags.doMuonCombinedMon = False
if (not rec.doEgamma()) or (rec.readRDO()
and not jobproperties.egammaRecFlags.Enabled()):
if not hasattr(ServiceMgr, 'THistSvc'):
from GaudiSvc.GaudiSvcConf import THistSvc
ServiceMgr += THistSvc()
for filename in tf.NtupleProductionFlags.FileNames():
ServiceMgr.THistSvc.Output += [
filename + " DATAFILE=\'" + filename + "\' OPT=\'RECREATE\'"
]
# MinBias
if tf.NtupleProductionFlags.SliceTuples.doSlice("MinBias"):
include("TrigMinBiasNtuple/TrigMinBiasNtuple_jo.py")
pass
# Muon
if tf.NtupleProductionFlags.SliceTuples.doSlice("Muon") and rec.doMuon():
include("TrigMuonNtuple/TrigMuonNtuple_jo.py")
pass
# Tau
if tf.NtupleProductionFlags.SliceTuples.doSlice("Tau") and rec.doTau():
include("TrigTauPerformAthena/TrigTauNtuple_jo.py")
pass
# Egamma
if tf.NtupleProductionFlags.SliceTuples.doSlice("EGamma") and rec.doEgamma():
include("TrigEgammaNtuple/TrigEgammaNtuple_jo.py")
pass
#L1Calo
if tf.NtupleProductionFlags.SliceTuples.doSlice("L1Calo"):
[isoPar.neflowisol20, isoPar.neflowisol30, isoPar.neflowisol40])
IsoCorEg.append([isoPar.coreCone, isoPar.pileupCorrection])
IsoCorMu.append([isoPar.coreCone, isoPar.pileupCorrection])
from IsolationAlgs.IsolationAlgsConf import IsolationBuilder
isoBuilder = AlgFactory(IsolationBuilder,
name="IsolationBuilder",
CaloCellIsolationTool=CaloIsolationTool,
CaloTopoIsolationTool=CaloIsolationTool,
PFlowIsolationTool=CaloIsolationTool,
TrackIsolationTool=TrackIsolationTool,
FeIsoTypes=[[]] if not rec.doEgamma() else IsoTypesFe,
FeCorTypes=IsoCorFe,
EgIsoTypes=[[]] if not rec.doEgamma() else IsoTypes,
EgCorTypes=IsoCorEg,
MuIsoTypes=[[]] if not rec.doMuon() else IsoTypes,
MuCorTypes=IsoCorMu,
LeakageTool=None,
OutputLevel=3)
from RecExConfig.Configured import Configured
class isoGetter(Configured):
def configure(self):
mlog = logging.getLogger('isoGetter.py::configure:')
mlog.info('entering')
# configure iso here:
try:
self._isoBuilderHandle = isoBuilder()
def sync_DetFlags(self,technologies="MDT,RPC,CSC,TGC,sTGC,Micromegas"):
self.setDefaults()
global rec
from AthenaCommon.DetFlags import DetFlags
# if Muons off, then do nothing
if not DetFlags.Muon_on() or not rec.doMuon(): return
flagsOn = []
flagsOff = [ 'readRIOBS' ] # we don't store RIO (=PRD) on bytestream ???
# Reading RDO
if rec.readRDO():
if muonRecFlags.makePRDs():
flagsOn.append( 'makeRIO' )
else:
flagsOff.append( 'makeRIO' )
if globalflags.InputFormat == 'pool' :
flagsOn.append( 'readRDOPool' )
flagsOff.append( 'readRDOBS' )
elif globalflags.InputFormat == 'bytestream':
flagsOn.append( 'readRDOBS' )
flagsOff.append( 'readRDOPool' )
else: # not reading RDO
flagsOff.append( 'makeRIO' )
# Reading ESD
if rec.readESD():
flagsOn.append( 'readRIOPool' )
else:
flagsOff.append( 'readRIOPool' )
# Writing RDO Pool
if rec.doWriteRDO():
flagsOn.append( 'writeRDOPool' )
else:
flagsOff.append( 'writeRDOPool' )
# Writing RDO bystream
if rec.doWriteBS() :
flagsOn.append( 'writeBS' )
else:
flagsOff.append( 'writeBS' )
# Writing ESD
if rec.doWriteESD():
flagsOn.append( 'writeRIOPool' )
else:
flagsOff.append( 'writeRIOPool' )
# Digitization on-the-fly
if self.doDigitization():
flagsOn.append( 'digitize' )
try:
flagsOn.remove( 'readRDOPool' )
except ValueError: # not in list
pass
try:
flagsOn.remove( 'readRDOBS' )
except ValueError: # not in list
pass
flagsOff.append( 'readRDOPool' )
flagsOff.append( 'readRDOBS' )
# very special case for normal Rome production (inspired by RecExCommon_DetFlags.py)
if 'readRIOPool' not in flagsOn:
flagsOn.append( 'readRIOPool' )
try:
flagsOff.remove( 'readRIOPool' )
except ValueError: # not in list
pass
if not rec.doWriteRDO() and 'makeRIO' not in flagsOn:
flagsOn.append( 'makeRIO' )
try:
flagsOff.remove( 'makeRIO' )
except ValueError: #not in list
pass
else:
flagsOff.append( 'digitize')
# do sync per technology for selected flags
MDT_on = self.doMDTs()
RPC_on = self.doRPCs()
CSC_on = self.doCSCs()
TGC_on = self.doTGCs()
sTGC_on = self.dosTGCs()
Micromegas_on = self.doMicromegas()
techList = technologies.split(',')
for f in flagsOn:
for tech in techList:
setOn = eval(tech+'_on')
isOn = eval("DetFlags.%s.%s_on()" % (f,tech))
if setOn:
if not isOn:
cmd = "DetFlags.%s.%s_setOn()" % (f,tech)
logMuon.info(cmd)
exec(cmd)
else: # set off
if isOn:
cmd = "DetFlags.%s.%s_setOff()" % (f,tech)
logMuon.info(cmd)
exec(cmd)
# Turn off Muon flags (row in DetFlags printout)
for f in flagsOff:
isOn = eval("DetFlags.%s.Muon_on()" % f)
if isOn:
cmd = "DetFlags.%s.Muon_setOff()" % f
logMuon.info(cmd)
exec(cmd)
def DCMathT0FitSegmentMaker(name='DCMathT0FitSegmentMaker',extraFlags=None,**kwargs):
if extraFlags is None: extraFlags = ExtraFlags()
extraFlags.setFlagDefault('doSegmentT0Fit',True)
return DCMathSegmentMaker(name,extraFlags,**kwargs)
# end of factory function DCMathSegmentMaker
def MuonLayerHoughTool(name='MuonLayerHoughTool',extraFlags=None,**kwargs):
kwargs.setdefault("DoTruth", rec.doTruth() )
return CfgMgr.Muon__MuonLayerHoughTool(name,**kwargs)
if DetFlags.detdescr.Muon_on() and rec.doMuon():
# until all clients explicitly get their tools and services, load some explicitly
getPublicTool("ResidualPullCalculator")
getPublicTool("MuonHoughPatternTool")
getPublicTool("MuonCombinePatternTool")
getPublicTool("MuonPhiHitSelector")
getPublicTool("MuonEDMPrinterTool")
getPublicTool("MuonSegmentMomentum")
getPublicTool("MuonClusterOnTrackCreator")
getPublicTool("CscClusterOnTrackCreator")
getPublicTool("CscBroadClusterOnTrackCreator")
getPublicTool("MdtDriftCircleOnTrackCreator")
getPublicTool("MdtTubeHitOnTrackCreator")
#getService("SomeService")
def setDefaults(self):
global globalflags
from MuonRecExample.MuonRecUtils import setJobPropertyDefault as setDefault
# as long as rec.Commissioning is alive, sync the default to it
# in case of BS->RDO, RDO->RDO, RDO->BS, BS->BS: don't run RIO (i.e RDO->PRD)
setDefault(self.makePRDs, rec.readRDO() and not rec.doWriteRDO() and not rec.doWriteBS())
setDefault(self.doStandalone,True)
setDefault(self.doDigitization,False)
setDefault(self.doCalib,False)
setDefault(self.applyResilience,athenaCommonFlags.AllowIgnoreConfigError())
setDefault(self.doSegmentsOnly,False)
setDefault(self.doMDTs,True)
setDefault(self.doRPCs,True)
setDefault(self.doTGCs,True)
setDefault(self.doCSCs,True)
setDefault(self.dosTGCs,True)
setDefault(self.doMicromegas,True)
setDefault(self.doMSVertex,True)
setDefault(self.useWireSagCorrections,False)
setDefault(self.enableErrorTuning,True)
setDefault(self.useLooseErrorTuning,False)
setDefault(self.useAlignmentCorrections,DetFlags.detdescr.Muon_on() and rec.doMuon())
setDefault(self.writeSDOs, rec.doWriteESD() and globalflags.DataSource != 'data')
setDefault(self.useTGCPriorNextBC,True)
setDefault(self.doMuonIso,True)
if beamFlags.beamType == 'cosmics' or beamFlags.beamType == 'singlebeam':
setDefault(self.doSegmentT0Fit,True)
else:
setDefault(self.doSegmentT0Fit,False)
setDefault(self.doPrdSelect,False)
# Default for MuonCalibration ntuple
setDefault(self.calibMuonStandalone, muonRecFlags.doStandalone() or rec.readESD() )
try:
from MuonCnvExample.MuonCalibFlags import muonCalibFlags
except ImportError:
from AthenaCommon.Resilience import treatException
treatException("Could not load MuonCalibFlags. Switching off calibration ntuple")
self.doCalib = False
self.doCalibNtuple = False
else:
doTracks = self.calibMuonStandalone()
# chose a default
if not muonCalibFlags.Mode.statusOn:
if doTracks:
muonCalibFlags.Mode = 'trackNtuple'
else:
muonCalibFlags.Mode = 'ntuple'
if muonCalibFlags.Mode == 'trackNtuple' and doTracks:
setDefault(self.doCalibNtuple,self.doCalib())
setDefault(self.calibNtupleSegments,True)
setDefault(self.calibNtupleTracks,True)
if rec.doTrigger: setDefault(self.calibNtupleTrigger,True)
else: setDefault(self.calibNtupleTrigger,False)
elif muonCalibFlags.Mode == 'ntuple' or (muonCalibFlags.Mode == 'trackNtuple' and not doTracks):
setDefault(self.doCalibNtuple,self.doCalib())
setDefault(self.calibNtupleSegments,True)
setDefault(self.calibNtupleTracks,False)
if rec.doTrigger: setDefault(self.calibNtupleTrigger,True)
else: setDefault(self.calibNtupleTrigger,False)
else:
setDefault(self.doCalibNtuple,False)
setDefault(self.calibNtupleSegments,False)
setDefault(self.calibNtupleTracks,False)
setDefault(self.calibNtupleTrigger,False)
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 DQMonFlags.doMuonCombinedMon=False if (not rec.doMuonCombined()) or (rec.readRDO() and not jobproperties.MuonCombinedRec.Enabled()): DQMonFlags.doMuonCombinedMon=False if (not rec.doEgamma()) or (rec.readRDO() and not jobproperties.egammaRecFlags.Enabled()): DQMonFlags.doEgammaMon=False #if (not rec.doJetRec()) or (rec.readRDO() and not jobproperties.JetRecFlags.Enabled()):
#ToolSvc += DQTGlobalWFinderTool;
#ManagedAthenaGlobalMon.AthenaMonTools += [ DQTGlobalWFinderTool ];
# Import BackgroundMon tool
if DQMonFlags.useTrigger():
from DataQualityTools.DataQualityToolsConf import DQTBackgroundMon
DQTBackgroundMon = DQTBackgroundMon(
name='DQTBackgroundMon',
histoPathBase="/GLOBAL/DQTBackgroundMon",
doOfflineHists=isOffline,
doOnlineHists=isOnline,
doRunCosmics=isCosmics,
doRunBeam=isBeam,
doMuons=rec.doMuon(),
doTrigger=rec.doTrigger())
ToolSvc += DQTBackgroundMon
ManagedAthenaGlobalMon.AthenaMonTools += [DQTBackgroundMon]
# Default values
MinSCTHits = 5
MinPtCut = 4000
#For now, to increase statistics in cosmics data taking
if athenaCommonFlags.isOnline == True:
MinSCTHits = 0
MinPtCut = 500
# Import MuonID tool
CBNTAA_VxPrimary.useTrkTrack = False
CBNTAA_VxPrimary.McEventCollectionName = "GEN_AOD"
except Exception:
logCBNT_config.warning("CBNTAA_VxPrimary undefined")
protectedInclude("CBNT_Particle/CBNT_Particle_jobOptions.py")
#if rec.doLArg() or rec.doTile():
# protectedInclude ("CaloRec/CaloRec_CBNT_jobOptions.py")
# #FIXME
# #try:
# # CBNT_LArCell.Enable=False
# #except Exception:
# # pass
if rec.doMuon():
protectedInclude("MuonRecExample/MuonCBNT_jobOptions.py")
if ((DetFlags.haveRIO.Muon_on() and
(JetRecFlagsOK and jobproperties.JetRecFlags.Enabled())
and recAlgs.doMuonSpShower()) or rec.readESD()):
protectedInclude("MuonSpShowerBuilderAlgs/CBNTAA_MuonSpShower.py")
#
# Jet
#
if rec.readAOD() or rec.readESD() or (JetRecFlagsOK
and jobproperties.JetRecFlags.Enabled()):
try:
from JetRec.CBNTJets import schedule_standard_CBNTJets
if rec.readESD():
rec.doHist = False
if athenaCommonFlags.isOnline():
rec.doWriteTAG = False
rec.doWriteTAGCOM = False
rec.doWriteESD = False
rec.doDetStatus = False
rec.doHist = False
#--------------------------------------------------------------
# Internal flags for each subsystem
#--------------------------------------------------------------
# MuDet
if rec.doMuon() and rec.doESD():
from MuonRecExample.MuonRecFlags import muonRecFlags
from MuonCnvExample.MuonCalibFlags import muonCalibFlags
from AthenaMonitoring.DQMonFlags import DQMonFlags
if rec.doESD() and DQMonFlags.doCTPMon() and rec.doTrigger():
include("TrigT1CTMonitoring/CTPFlags.py")
# FIXME obsolete flags (should be removed)!!!
# ------------------------------------
# import GlobalFlags from RecExCommon
# ------------------------------------
# new flag
rec.Commissioning = True
rec.ScopingLevel = 4
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
# Disable usage of vertices in pflow jets, if we are using cosmic data. from AthenaCommon.BeamFlags import jobproperties if jobproperties.Beam.beamType == 'cosmics': jetFlags.useVertices = False # Skip pflow if we are not using tracks. print myname + "Initial usePFlow: " + sflagstat(jetFlags.usePFlow) if not jetFlags.usePFlow.statusOn: jetFlags.usePFlow = jetFlags.useTracks() print myname + "Final usePFlow: " + sflagstat(jetFlags.usePFlow) # Skip use of muon segments if not built. # No action if someone has already set the flag. print myname + "Initial use muon segments: " + sflagstat(jetFlags.useMuonSegments) if not jetFlags.useMuonSegments.statusOn: jetFlags.useMuonSegments = rec.doMuon() and rec.doMuonCombined() print myname + " Final use muon segments: " + sflagstat(jetFlags.useMuonSegments) # Use rec flag to control BTagging. # No. Disable this unit we get support from Btagging to do this. # No action if someone has already set the flag. print myname + "Initial use Btagging: " + str(jetFlags.useBTagging) print myname + " rec do BTagging: " + str(rec.doBTagging()) if not jetFlags.useBTagging.statusOn: #jetFlags.useBTagging = rec.doBTagging() jetFlags.useBTagging = False print myname + " Final use Btagging: " + str(jetFlags.useBTagging) # The following can be used to exclude tools from reconstruction. if 0: jetFlags.skipTools = ["comshapes"]
# --- 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 #
#----------------------#
MuonRawMon=False
MuonESDMon=False
if DQMonFlags.monManEnvironment() == 'online':
MuonRawMon=True
MuonESDMon=True
elif DQMonFlags.monManEnvironment() == 'tier0Raw':
#Customisation
CustomCuts = [[3.0, 400, 'TightPrimary'], [3.0, 500, 'TightPrimary'],
[3.0, 800, 'TightPrimary'], [3.0, 1200, 'TightPrimary'],
[3.0, 1000, 'Loose'], [1.5, 1000, 'TightPrimary'],
[5.0, 1000, 'TightPrimary']]
for icut in CustomCuts:
CustomType = icut[2] + 'z0' + str(int(10 * icut[0])) + 'Pt' + str(
icut[1]) + 'MeV'
print 'Building track isolation tool for type ', CustomType
TrackIsolationCustom = xAOD__TrackIsolationTool(name='TrackIsolationTool' +
CustomType)
TrackIsolationCustom.TrackSelectionTool.maxZ0SinTheta = float(icut[0])
TrackIsolationCustom.TrackSelectionTool.minPt = float(icut[1])
TrackIsolationCustom.TrackSelectionTool.CutLevel = icut[2]
ToolSvc += TrackIsolationCustom
isoBuilderCustom = IsolationBuilder(
name="IsolationBuilder" + CustomType,
CaloCellIsolationTool=None,
CaloTopoIsolationTool=None,
PFlowIsolationTool=None,
TrackIsolationTool=TrackIsolationCustom,
EgIsoTypes=[[]] if not rec.doEgamma() else ptconeList,
MuIsoTypes=[[]] if not rec.doMuon() else ptconeList,
CustomConfgurationName=CustomType,
OutputLevel=3)
topSequence.insert(index, isoBuilderCustom)
## --postInclude 'RecJobTransforms/UseFrontier.py' RAWtoESD:'IsolationAlgs/CustomTrackIsoGetter.py'
