def configure(self):
# objKeyStore stuff needed?
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
# ---------------------------------------------------------------
# DiTauRec Tools
# ---------------------------------------------------------------
import DiTauRec.DiTauAlgorithmsHolder as DiTauAlgs
from DiTauRec.DiTauRecFlags import diTauFlags
from DiTauRec.DiTauRecConf import DiTauBuilder
tools = []
tools.append(DiTauAlgs.getSeedJetBuilder(_jet_container))
tools.append(DiTauAlgs.getElMuFinder())
tools.append(DiTauAlgs.getSubjetBuilder())
from InDetRecExample.InDetJobProperties import InDetFlags
from JetRec.JetRecFlags import jetFlags
if (InDetFlags.doVertexFinding()
and jetFlags.useTracks()) or diTauFlags.doVtxFinding:
tools.append(DiTauAlgs.getVertexFinder())
pass
tools.append(DiTauAlgs.getDiTauTrackFinder())
if diTauFlags.doCellFinding:
tools.append(
DiTauAlgs.getCellFinder(self.write_jet_cells,
self.write_subjet_cells))
pass
if not diTauFlags.doCellFinding:
self.use_cells = False
tools.append(DiTauAlgs.getIDVarCalculator(self.use_cells))
# ---------------------------------------------------------------
# add DiTauBuilder to Algorithm Sequence
# ---------------------------------------------------------------
DiTauBuilder = DiTauBuilder(name=self.name,
DiTauContainer=_outputKey,
DiTauAuxContainer=_outputAuxKey,
Tools=tools,
SeedJetName=_jet_container,
minPt=diTauFlags.diTauRecJetSeedPt(),
maxEta=2.5,
OutputLevel=3,
Rjet=self.R_jet,
Rsubjet=self.R_subjet,
Rcore=self.R_core)
topSequence += DiTauBuilder
#print topSequence
return True
def AddPtAssociationTools(R, doTracks=True):
tlist = []
if doTracks and jetFlags.useTracks():
cname = HIJetFlags.TrackJetContainerName()
tname = 'hitrackassoc_04'
if tname not in jtm.tools:
JetPtAssociationTool = CompFactory.JetPtAssociationTool
jtm.add(
JetPtAssociationTool(tname,
InputContainer=cname,
AssociationName="GhostTrack"))
tlist += [jtm.tools[tname]]
if jetFlags.useTruth():
cname = 'AntiKt%dTruthJets' % int(10 * R)
tname = 'truthassoc_0%d' % int(10 * R)
if tname not in jtm.tools:
JetPtAssociationTool = CompFactory.JetPtAssociationTool
jtm.add(
JetPtAssociationTool(tname,
InputContainer=cname,
AssociationName="GhostTruth"))
tlist += [jtm.tools[tname]]
return tlist
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. 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:
"Truth collection %s already exists, no need to rebuild it"
% tname)
collExists = True
break
if collExists: continue
f = jtm.addJetFinder(tname,
"AntiKt",
R,
"truth",
ptmin=HIJetFlags.TruthJetPtMin())
print("Adding %s" % tname)
AddToOutputList(tname)
#jtm.HIJetRecs+=[f]
#track jets
if jetFlags.useTracks():
tname = "AntiKt4HITrackJets"
hi_trk_modifiers = jtm.modifiersMap["HITrack"]
hi_trk_modifiers += AddPtAssociationTools(0.4, False)
f = jtm.addJetFinder(tname,
"AntiKt",
0.4,
"HITrack",
hi_trk_modifiers,
ptmin=HIJetFlags.TrackJetPtMin())
HIJetFlags.TrackJetContainerName = tname
AddToOutputList(tname)
jtm.HIJetRecs += [f]
#initial unsubtracted jets
for R in HIJetFlags.AntiKtRValues():
def addJetRecoToAlgSequence(job=None,
useTruth=None,
eventShapeTools=None,
separateJetAlgs=None,
debug=None):
myname = "JetAlgorithm: "
# We need this to modify the global variable.
global jetalg
# Import message level flags.
from GaudiKernel.Constants import DEBUG
# Import the jet reconstruction control flags.
from JetRec.JetRecFlags import jetFlags
# Import the standard jet tool manager.
from JetRec.JetRecStandardToolManager import jtm
# Set sequence and flags as needed.
if job == None:
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
if useTruth == None:
useTruth = jetFlags.useTruth()
if eventShapeTools == None:
eventShapeTools = jetFlags.eventShapeTools()
if eventShapeTools == None:
eventShapeTools = []
if separateJetAlgs == None:
separateJetAlgs = jetFlags.separateJetAlgs()
# Event shape tools.
evstools = []
evsDict = {
"emtopo": ("EMTopoEventShape", jtm.emget),
"lctopo": ("LCTopoEventShape", jtm.lcget),
"empflow": ("EMPFlowEventShape", jtm.empflowget),
"emcpflow": ("EMCPFlowEventShape", jtm.emcpflowget),
"lcpflow": ("LCPFlowEventShape", jtm.lcpflowget),
}
if jetFlags.useTracks():
evsDict["emtopo"] = ("EMTopoOriginEventShape", jtm.emoriginget)
evsDict["lctopo"] = ("LCTopoOriginEventShape", jtm.lcoriginget)
jetlog.info(myname + "Event shape tools: " + str(eventShapeTools))
from RecExConfig.AutoConfiguration import IsInInputFile
for evskey in eventShapeTools:
from EventShapeTools.EventDensityConfig import configEventDensityTool
if evskey in evsDict:
(toolname, getter) = evsDict[evskey]
if toolname in jtm.tools:
jetlog.info(myname + "Skipping duplicate event shape: " +
toolname)
else:
jetlog.info(myname + "Adding event shape " + evskey)
if not IsInInputFile("xAOD::EventShape", "Kt4" + toolname):
jtm += configEventDensityTool(toolname, getter, 0.4)
evstools += [jtm.tools[toolname]]
else:
jetlog.info(myname + "Invalid event shape key: " + evskey)
raise Exception
# Add the tool runner. It runs the jetrec tools.
rtools = []
# Add the truth tools.
if useTruth:
from JetRec.JetFlavorAlgs import scheduleCopyTruthParticles
rtools += scheduleCopyTruthParticles()
# build truth jet input :
rtools += [jtm.truthpartcopy, jtm.truthpartcopywz]
## if jetFlags.useCells():
## rtools += [jtm.missingcells] commented out : incompatible with trigger : ATR-9696
if jetFlags.useTracks:
rtools += [
jtm.tracksel,
jtm.tvassoc,
jtm.trackselloose_trackjets,
]
# Add the algorithm. It runs the jetrec tools.
from JetRec.JetRecConf import JetAlgorithm
ctools = []
if jetFlags.useTracks:
if not IsInInputFile("xAOD::CaloClusterContainer",
"LCOriginTopoClusters"):
ctools += [jtm.JetConstitSeq_LCOrigin]
if not IsInInputFile("xAOD::CaloClusterContainer",
"EMOriginTopoClusters"):
ctools += [jtm.JetConstitSeq_EMOrigin]
from JetRec.JetRecConf import JetToolRunner
runners = []
if len(ctools) > 0:
jtm += JetToolRunner("jetconstit",
EventShapeTools=[],
Tools=ctools,
Timer=jetFlags.timeJetToolRunner())
jtm.jetconstit
runners = [jtm.jetconstit]
if jetFlags.separateJetAlgs():
jtm += JetToolRunner("jetrun",
EventShapeTools=evstools,
Tools=rtools,
Timer=jetFlags.timeJetToolRunner())
runners += [jetrun]
job += JetAlgorithm("jetalg")
jetalg = job.jetalg
jetalg.Tools = runners
for t in jtm.jetrecs:
jalg = JetAlgorithm("jetalg" + t.name())
jalg.Tools = [t]
job += jalg
else:
from JetRec.JetRecConf import JetToolRunner
jtm += JetToolRunner("jetrun",
EventShapeTools=evstools,
Tools=rtools + jtm.jetrecs,
Timer=jetFlags.timeJetToolRunner())
runners += [jtm.jetrun]
job += JetAlgorithm("jetalg")
jetalg = job.jetalg
jetalg.Tools = runners
if jetFlags.debug > 0:
jtm.setOutputLevel(jtm.jetrun, DEBUG)
jetalg.OutputLevel = DEBUG
if jetFlags.debug > 1:
for tool in jtm.jetrecs:
jtm.setOutputLevel(tool, DEBUG)
if jetFlags.debug > 2:
for tool in jtm.finders:
jtm.setOutputLevel(tool, DEBUG)
if jetFlags.debug > 3:
jtm.setOutputLevel(jtm.jetBuilderWithArea, DEBUG)
jtm.setOutputLevel(jtm.jetBuilderWithoutArea, DEBUG)
def configure(self):
mlog = logging.getLogger('TauCoreBuilder.py::configure:')
mlog.info('entering')
from RecExConfig.RecFlags import rec
from RecExConfig.ObjKeyStore import objKeyStore
objKeyStore.addManyTypesStreamESD(self._output)
objKeyStore.addManyTypesStreamAOD(self._output)
objKeyStore.addManyTypesTransient(self._output)
import tauRec.TauAlgorithmsHolder as taualgs
from tauRec.tauRecFlags import tauFlags
#switch off TJVA if jet reco don't use tracks.
from JetRec.JetRecFlags import jetFlags
if not tauFlags.isStandalone() and not jetFlags.useTracks():
self.do_TJVA = False # switch off TJVA
tools = []
try:
tools.append(taualgs.getJetSeedBuilder())
# run vertex finder only in case vertexing is available. This check can also be done in TauAlgorithmsHolder instead doing it here.
from InDetRecExample.InDetJobProperties import InDetFlags
from tauRec.tauRecFlags import jobproperties
doMVATrackClassification = jobproperties.tauRecFlags.tauRecMVATrackClassification(
)
doRNNTrackClassification = jobproperties.tauRecFlags.tauRecRNNTrackClassification(
)
if tauFlags.isStandalone() or InDetFlags.doVertexFinding():
tools.append(
taualgs.getTauVertexFinder(doUseTJVA=self.do_TJVA))
tools.append(taualgs.getTauAxis())
tools.append(
taualgs.getTauTrackFinder(
removeDuplicateTracks=(not doMVATrackClassification)))
if doMVATrackClassification:
tools.append(taualgs.getTauTrackClassifier())
if not doMVATrackClassification and doRNNTrackClassification:
tools.append(taualgs.getTauTrackRNNClassifier())
if jobproperties.Beam.beamType() != "cosmics":
tools.append(
taualgs.getEnergyCalibrationLC(correctEnergy=True,
correctAxis=False,
postfix='_onlyEnergy'))
tools.append(taualgs.getCellVariables())
tools.append(taualgs.getElectronVetoVars())
tools.append(taualgs.getTauShotFinder())
if self.doPi0Clus:
tools.append(taualgs.getPi0ClusterFinder())
from tauRec.tauRecFlags import tauFlags
tools += tauFlags.tauRecToolsDevToolList()
except Exception:
mlog.error("could not append tools to TauBuilder")
traceback.print_exc()
return False
# run first part of Tau Builder
TauRecConfigured.WrapTauRecToolExecHandle(self, tool=tools)
return True
OutputName="JetInputTruthParticlesNoWZ",
MCTruthClassifier=truthClassifier,
IncludePromptLeptons=False,
IncludeMuons=True,
IncludeNeutrinos=True)
#--------------------------------------------------------------
# Jet reco infrastructure.
#--------------------------------------------------------------
# Jet pseudojet retriever.
jtm += JetPseudojetRetriever("jpjretriever")
# Jet constituent retriever.
labs = []
if jetFlags.useTracks():
labs += ["Track"]
labs += ["AntiKt2TrackJet", "AntiKt2TrackJet"]
if jetFlags.useMuonSegments():
labs += [
"MuonSegment",
]
if jetFlags.useTruth():
labs += ["Truth"]
for lab in jetFlags.truthFlavorTags():
labs += [lab]
jtm += JetConstituentsRetriever("jconretriever",
UsePseudojet=True,
UseJetConstituents=True,
PseudojetRetriever=jtm.jpjretriever,
GhostLabels=labs,
from JetRec.JetRecFlags import jetFlags
from RecExConfig.ObjKeyStore import cfgKeyStore
from AthenaCommon import Logging
jetlog = Logging.logging.getLogger('JetRec_jobOptions')
# Skip truth if rec says it is absent.
if not rec.doTruth():
jetFlags.useTruth = False
jetlog.info( " Truth enabled ? jetFlags.useTruth == %s", jetFlags.useTruth() )
#skip track if not built or not present in the job
if not rec.doInDet() \
and ( not cfgKeyStore.isInTransient("xAOD::VertexContainer_v1","PrimaryVertices") \
or not cfgKeyStore.isInTransient('xAOD::TrackParticleContainer_v1','InDetTrackParticles') ):
jetFlags.useTracks = False
jetlog.info( " Tracks enabled ? jetFlags.useTracks == %s", jetFlags.useTracks() )
#skip muon segment if not built
if not rec.doMuon() or not rec.doMuonCombined() :
jetFlags.useMuonSegments = False
print rec.doMuon() , rec.doMuonCombined()
jetlog.info( " MuonSegments enabled ? jetFlags.useMuonSegments == %s", jetFlags.useMuonSegments() )
#skip cluster if not built
if not rec.doCalo():
jetFlags.useTopo = False
jetlog.info( " TopCluster enabled ? jetFlags.useTopo == %s", jetFlags.useTopo() )
# The following can be used to exclude tools from reconstruction.
if jetFlags.detailLevel()==JetContentDetail.Reduced:
if jetFlags.useTopo():
jtm.addJetFinder("AntiKt4EMTopoJets", "AntiKt", 0.4, "emtopo_reduced", "emtopo_ungroomed", ghostArea=0.01, ptmin= 5000, ptminFilter= 15000, calibOpt=calibopt)
jtm.addJetFinder("AntiKt4LCTopoJets", "AntiKt", 0.4, "lctopo_reduced", "lctopo_ungroomed", ghostArea=0.01, ptmin= 5000, ptminFilter= 15000, calibOpt=calibopt)
jtm.addJetFinder("AntiKt10LCTopoJets", "AntiKt", 1.0, "lctopo_reduced", "lctopo_ungroomed", ghostArea=0.01, ptmin= 40000, ptminFilter=50000, calibOpt="none")
if jetFlags.usePFlow():
jtm.addJetFinder("AntiKt4EMPFlowJets", "AntiKt", 0.4, "empflow_reduced", "pflow_ungroomed", ghostArea=0.01, ptmin= 5000, ptminFilter= 10000, calibOpt=calibopt+":pflow")
# if jetFlags.useTruth():
# jtm.addJetFinder("AntiKt4TruthJets", "AntiKt", 0.4, "truth", ptmin= 5000)
elif jetFlags.detailLevel()>=JetContentDetail.Full:
if jetFlags.useTruth():
jtm.addJetFinder("AntiKt4TruthJets", "AntiKt", 0.4, "truth", ptmin= 5000)
jtm.addJetFinder("AntiKt4TruthWZJets", "AntiKt", 0.4, "truthwz", ptmin= 5000)
jtm.addJetFinder("AntiKt10TruthJets", "AntiKt", 1.0, "truth", ptmin=40000)
jtm.addJetFinder("AntiKt10TruthWZJets", "AntiKt", 1.0, "truthwz", ptmin=40000)
if jetFlags.useTracks():
jtm.addJetFinder("AntiKt2PV0TrackJets", "AntiKt", 0.2, "pv0track", ptmin= 2000)
jtm.addJetFinder("AntiKt4PV0TrackJets", "AntiKt", 0.4, "pv0track", ptmin= 2000)
if jetFlags.useTopo():
jtm.addJetFinder("AntiKt4EMTopoJets", "AntiKt", 0.4, "emtopo", "emtopo_ungroomed", ghostArea=0.01, ptmin= 5000, ptminFilter= 15000, calibOpt=calibopt)
jtm.addJetFinder("AntiKt4LCTopoJets", "AntiKt", 0.4, "lctopo", "lctopo_ungroomed", ghostArea=0.01, ptmin= 5000, ptminFilter= 15000, calibOpt=calibopt)
jtm.addJetFinder("AntiKt10LCTopoJets", "AntiKt", 1.0, "lctopo", "lctopo_ungroomed", ghostArea=0.01, ptmin= 40000, ptminFilter=50000, calibOpt="none")
if jetFlags.usePFlow():
jtm.addJetFinder("AntiKt4EMPFlowJets", "AntiKt", 0.4, "empflow", "pflow_ungroomed", ghostArea=0.01, ptmin= 5000, ptminFilter= 10000, calibOpt=calibopt+":pflow")
if jetFlags.detailLevel()==JetContentDetail.Validation:
jtm.addJetTrimmer( "AntiKt10LCTopoTrimmedPtFrac5SmallR20Jets",
rclus=0.2, ptfrac=0.05, input="AntiKt10LCTopoJets", modifiersin="lctopo_groomed" )
#--------------------------------------------------------------
# Build output container list.
#--------------------------------------------------------------
# Lock all the flags used here so that later attempts to change
# the value will fail with an error message.
jetFlags.useTruth.lock()
jetFlags.useTopo.lock()
jetFlags.useTracks.lock()
jetFlags.useMuonSegments.lock()
jetFlags.useBTagging.lock()
jetFlags.useCaloQualityTool.lock()
jetFlags.additionalTopoGetters.lock()
jetFlags.truthFlavorTags.lock()
jetFlags.skipTools.lock()
# Display all flags used here.
jetlog.info(myname + "jetFlags.useTruth: " + str(jetFlags.useTruth()))
jetlog.info(myname + "jetFlags.useTopo: " + str(jetFlags.useTopo()))
jetlog.info(myname + "jetFlags.useTracks: " + str(jetFlags.useTracks()))
jetlog.info(myname + "jetFlags.useMuonSegments: " +
str(jetFlags.useMuonSegments()))
jetlog.info(myname + "jetFlags.useBTagging: " + str(jetFlags.useBTagging()))
jetlog.info(myname + "jetFlags.useCaloQualityTool: " +
str(jetFlags.useCaloQualityTool()))
jetlog.info(myname + "jetFlags.additionalTopoGetters: " +
str(jetFlags.additionalTopoGetters()))
jetlog.info(myname + "jetFlags.truthFlavorTags: " +
str(jetFlags.truthFlavorTags()))
jetlog.info(myname + "jetFlags.skipTools: " + str(jetFlags.skipTools()))
#########################################################
# Create standard tool manager.
#########################################################
histoPathBase="/Tile/Muid")
ManagedAthenaTileMon.AthenaMonTools += [TileMuIdMon]
TileL2MuMon = CfgMgr.TileL2MonTool(name='TileL2MuMon',
OutputLevel=INFO,
FillHistogramsForL1Triggers=[],
histoPathBase="/Tile/L2Muon")
ManagedAthenaTileMon.AthenaMonTools += [TileL2MuMon]
if (jobproperties.Beam.beamType() == 'collisions'):
from JetRec.JetRecFlags import jetFlags
jetPtMin = 20000.
jetContainer = 'AntiKt4EMTopoJets'
doJetCleaning = jetFlags.useTracks()
doEventCleaning = True
if DQMonFlags.monManDataType == 'heavyioncollisions':
if not rec.doHIP():
jetContainer = 'AntiKt4HIJets'
doEventCleaning = False
doJetCleaning = False
TileJetMonTool = CfgMgr.TileJetMonTool(
name='TileJetMonTool',
OutputLevel=INFO,
jetPtMin=jetPtMin,
jetEtaMax=1.6,
jetCollectionName=jetContainer,
do_1dim_histos=False,
def buildGenericGroomAlg(jetalg,
rsize,
inputtype,
groomedName,
jetToolBuilder,
includePreTools=False,
algseq=None,
outputGroup="CustomJets",
writeUngroomed=False,
variableRMassScale=-1.0,
variableRMinRadius=-1.0,
constmods=[]):
algname = "jetalg" + groomedName[:-4]
from RecExConfig.AutoConfiguration import IsInInputFile
if algseq is None:
dfjetlog.info("No algsequence passed! Will not schedule " + algname)
return
elif IsInInputFile("xAOD::JetContainer", groomedName):
dfjetlog.info("Collection " + groomedName +
" is already in input AOD!")
return
from JetRec.JetRecUtils import buildJetContName
constmodstr = "".join(constmods)
inputname = inputtype + constmodstr
label = inputtype + constmodstr
ungroomedName = buildJetContName(jetalg, rsize, inputname,
variableRMassScale, variableRMinRadius)
ungroomedalgname = "jetalg" + ungroomedName[:-4] # Remove "Jets" from name
# add these groomed jets to the output (use setdefault() to constuct the list if not existing yet)
OutputJets.setdefault(outputGroup, []).append(groomedName)
if writeUngroomed:
OutputJets.setdefault(outputGroup, []).append(ungroomedName)
dfjetlog.info("Write " + ungroomedName)
from JetRec.JetRecConf import JetAlgorithm
# return if the alg is already scheduled here :
if hasattr(algseq, ungroomedalgname):
finderalg = getattr(algseq, ungroomedalgname)
dfjetlog.warning("Algsequence " + algseq.name() +
" already has an instance of " + ungroomedalgname)
elif ungroomedalgname in DFJetAlgs:
dfjetlog.info("Added jet finder " + ungroomedalgname + " to sequence" +
algseq.name())
finderalg = DFJetAlgs[ungroomedalgname]
algseq += DFJetAlgs[ungroomedalgname]
else:
# 1. make sure we have pseudo-jet in our original container
# this returns a list of the needed tools to do so.
jetalgTools = reCreatePseudoJets(jetalg,
rsize,
inputtype,
variableRMassScale,
variableRMinRadius,
algseq,
constmods=constmods)
if includePreTools and jetFlags.useTracks(
) and not "Truth" in inputtype:
# enable track ghost association and JVF
jetalgTools = [jtm.tracksel, jtm.tvassoc] + jetalgTools
finderalg = JetAlgorithm(ungroomedalgname, Tools=jetalgTools)
DFJetAlgs[ungroomedalgname] = finderalg
dfjetlog.info("Added jet finder " + ungroomedalgname +
" to sequence " + algseq.name())
algseq += finderalg
# 2nd step run the trimming alg. We can re-use the original largeR jet since we reassociated the PseudoJet already.
fatjet_groom = jetToolBuilder(groomedName, ungroomedName)
print(finderalg.Tools)
print(ungroomedName)
fatjet_rectool = [
t for t in finderalg.Tools if t.name().endswith(ungroomedName)
][0]
fatjet_groom.InputPseudoJets = fatjet_rectool.InputPseudoJets # recopy the InputPseudoJets so tools know how to map fastjet constituents with xAOD constituents
dfjetlog.info("Added jet groomer " + algname + " to sequence " +
algseq.name())
groomeralg = JetAlgorithm(algname, Tools=[fatjet_groom])
DFJetAlgs[algname] = groomeralg
algseq += groomeralg
return groomeralg
def addJetRecoToAlgSequence(job=None,
useTruth=None,
eventShapeTools=None,
separateJetAlgs=None,
debug=None):
myname = "JetAlgorithm: "
# We need this to modify the global variable.
global jetalg
# Import message level flags.
from GaudiKernel.Constants import DEBUG
# Import the jet reconstruction control flags.
from JetRec.JetRecFlags import jetFlags
# Import the standard jet tool manager.
from JetRec.JetRecStandard import jtm
# Set sequence and flags as needed.
if job == None:
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
if useTruth == None:
useTruth = jetFlags.useTruth()
if eventShapeTools == None:
eventShapeTools = jetFlags.eventShapeTools()
if eventShapeTools == None:
eventShapeTools = []
if separateJetAlgs == None:
separateJetAlgs = jetFlags.separateJetAlgs()
# Event shape tools.
evsDict = {
"emtopo": ("EMTopoEventShape", jtm.emget),
"lctopo": ("LCTopoEventShape", jtm.lcget),
"empflow": ("EMPFlowEventShape", jtm.empflowget),
}
if jetFlags.useTracks():
if jetFlags.useVertices():
evsDict["emtopo"] = ("EMTopoOriginEventShape", jtm.emoriginget)
evsDict["lctopo"] = ("LCTopoOriginEventShape", jtm.lcoriginget)
else:
evsDict["emtopo"] = ("EMTopoOriginEventShape", jtm.emget)
evsDict["lctopo"] = ("LCTopoOriginEventShape", jtm.lcget)
jetlog.info(myname + "Event shape tools: " + str(eventShapeTools))
from RecExConfig.AutoConfiguration import IsInInputFile
for evskey in eventShapeTools:
from EventShapeTools.EventDensityConfig import configEventDensityTool
if evskey in evsDict:
(toolname, getter) = evsDict[evskey]
if toolname in jtm.tools:
jetlog.info(myname + "Skipping duplicate event shape: " +
toolname)
else:
jetlog.info(myname + "Adding event shape " + evskey)
if not IsInInputFile("xAOD::EventShape", toolname):
jtm += configEventDensityTool(toolname, getter.Label, 0.4)
jtm.allEDTools += [jtm.tools[toolname]]
else:
jetlog.info(myname + "Invalid event shape key: " + evskey)
raise Exception
# Add the tool runner. It runs the jetrec tools.
ctools = []
# Add the truth tools.
if useTruth:
from JetRec.JetFlavorAlgs import scheduleCopyTruthParticles
ctools += scheduleCopyTruthParticles()
# build truth jet input :
ctools += [jtm.truthpartcopy, jtm.truthpartcopywz]
## if jetFlags.useCells():
## ctools += [jtm.missingcells] commented out : incompatible with trigger : ATR-9696
if jetFlags.useTracks:
ctools += [jtm.tracksel, jtm.trackselloose_trackjets]
if jetFlags.useVertices:
ctools += [jtm.tvassoc]
# LCOriginTopoClusters and EMOriginTopoClusters are shallow copies
# of CaloCalTopoClusters. This means that if CaloCalTopoClusters gets
# thinned on output, the the two derived containers need to be thinned
# in the same way, else they'll be corrupted in the output.
# FIXME: this should be automatic somehow.
postalgs = []
thinneg = False
from RecExConfig.RecFlags import rec
if rec.doWriteAOD() and not rec.readAOD():
from ParticleBuilderOptions.AODFlags import AODFlags
if AODFlags.ThinNegativeEnergyCaloClusters:
thinneg = True
if jetFlags.useTracks and jetFlags.useVertices:
if not IsInInputFile("xAOD::CaloClusterContainer",
"LCOriginTopoClusters"):
ctools += [jtm.JetConstitSeq_LCOrigin]
if thinneg:
from ThinningUtils.ThinningUtilsConf import ThinNegativeEnergyCaloClustersAlg
postalgs.append(
ThinNegativeEnergyCaloClustersAlg(
'ThinNegLCOriginTopoClusters',
ThinNegativeEnergyCaloClusters=True,
CaloClustersKey='LCOriginTopoClusters',
StreamName='StreamAOD'))
if not IsInInputFile("xAOD::CaloClusterContainer",
"EMOriginTopoClusters"):
ctools += [jtm.JetConstitSeq_EMOrigin]
if thinneg:
from ThinningUtils.ThinningUtilsConf import ThinNegativeEnergyCaloClustersAlg
postalgs.append(
ThinNegativeEnergyCaloClustersAlg(
'ThinNegEMOriginTopoClusters',
ThinNegativeEnergyCaloClusters=True,
CaloClustersKey='EMOriginTopoClusters',
StreamName='StreamAOD'))
if not IsInInputFile("xAOD::PFOContainer", "CHSParticleFlowObjects"):
if not hasattr(job, "jetalgCHSPFlow"):
ctools += [jtm.JetConstitSeq_PFlowCHS]
if thinneg:
from ThinningUtils.ThinningUtilsConf import ThinNegativeEnergyNeutralPFOsAlg
CHSnPFOsThinAlg = ThinNegativeEnergyNeutralPFOsAlg(
"ThinNegativeEnergyCHSNeutralPFOsAlg",
NeutralPFOsKey="CHSNeutralParticleFlowObjects",
ThinNegativeEnergyNeutralPFOs=True,
StreamName='StreamAOD')
postalgs.append(CHSnPFOsThinAlg)
from JetRec.JetRecConf import JetToolRunner
from JetRec.JetRecConf import JetAlgorithm
runners = []
if len(ctools) > 0:
jtm += JetToolRunner("jetconstit",
EventShapeTools=[],
Tools=ctools,
Timer=jetFlags.timeJetToolRunner())
job += JetAlgorithm("jetalgConstituents", Tools=[jtm.jetconstit])
# Add all the PseudoJetAlgorithms now
# To avoid massive refactoring and to preserve familiarity,
# kept calling things "getters", but these are already
# PseudoJetAlgorithms as we eliminated the wrappers
for getter in jtm.allGetters:
job += getter
# Then, add all event shape tools in separate algs
for evstool in jtm.allEDTools:
from EventShapeTools.EventShapeToolsConf import EventDensityAthAlg
job += EventDensityAthAlg("edalg_" + evstool.OutputContainer,
EventDensityTool=evstool)
if separateJetAlgs:
for t in jtm.jetrecs:
jalg = JetAlgorithm("jetalg" + t.name(), Tools=[t])
job += jalg
else:
from JetRec.JetRecConf import JetToolRunner
jtm += JetToolRunner("jetrun",
EventShapeTools=[],
Tools=rtools + jtm.jetrecs,
Timer=jetFlags.timeJetToolRunner())
runners += [jtm.jetrun]
job += JetAlgorithm("jetalg")
jetalg = job.jetalg
jetalg.Tools = runners
if jetFlags.debug > 0:
# jtm.setOutputLevel(jtm.jetrun, DEBUG)
jetalg.OutputLevel = DEBUG
if jetFlags.debug > 1:
for tool in jtm.jetrecs:
jtm.setOutputLevel(tool, DEBUG)
if jetFlags.debug > 2:
for tool in jtm.finders:
jtm.setOutputLevel(tool, DEBUG)
if jetFlags.debug > 3:
jtm.setOutputLevel(jtm.jetBuilderWithArea, DEBUG)
jtm.setOutputLevel(jtm.jetBuilderWithoutArea, DEBUG)
for postalg in postalgs:
job += postalg
theCalibTool.CalibSequence='EtaJES'
theCalibTool.lock()
#use existing R=0.2 jets from previous reco, only making use of discriminant
seed_prefix='AntiKt%dHIJets' % int(10*HIJetFlags.SeedRValue())
seeds0=jtm.addJetCopier("%s_%s0" % (seed_prefix, HIJetFlags.SeedSuffix()),seed_prefix,[jtm.discrim],shallow=False)
jtm.HIJetRecs+=[seeds0]
iter0=AddIteration(seed_container=seeds0.OutputContainer,shape_name=EventShapeKey,suffix="iter0")
modulator0=iter0.Modulator
subtr1=MakeSubtractionTool(iter0.OutputEventShapeKey,modulator=modulator0)
#now iterate
seeds1=jtm.addJetCopier("%s_%s1" % (seed_prefix,HIJetFlags.SeedSuffix()),seed_prefix,[subtr1,jtm.HICalibMap[seed_prefix],jtm.jetfilHISeeds],shallow=False)
jtm.HIJetRecs+=[seeds1]
iteration_dict=dict(suffix="iter1")
if jetFlags.useTracks() and HIJetFlags.TrackJetSeeds() : iteration_dict['track_jet_seeds']=HIJetFlags.TrackJetContainerName()
iter1=AddIteration(seed_container=seeds1.OutputContainer,shape_name=EventShapeKey,**iteration_dict)
HIJetFlags.IteratedEventShapeKey=iter1.OutputEventShapeKey
modulator1=iter1.Modulator
jtm.modulator=modulator1
from HIJetRec.HIJetRecConf import HIClusterSubtraction
cluster_update=HIClusterSubtraction('HIClusterUpdate')
cluster_update.ClusterKey="HIClusters"
cluster_update.EventShapeKey=HIJetFlags.IteratedEventShapeKey()
cluster_update.Subtractor=jtm.HIJetClusterSubtractor
cluster_update.Modulator=modulator1
cluster_update.UpdateOnly=True
jtm.add(cluster_update)
jtm.jetrecs += [cluster_update]
inpdmp = ToolSvc.inpdmp
inpdmp.ContainerName = clname
inpdmp.Detail = 1
inpdmp.MaxObject = 20
inpdmp.OutputLevel = INFO
jetalg.Tools += [inpdmp]
# Dump pseudojets after reco.
names = []
if dumpPseudojets:
if jetFlags.useTruth():
names += ["PseudoJetTruth"]
names += ["PseudoJetTruthWZ"]
names += ["PseudoJetEMTopo"]
names += ["PseudoJetLCTopo"]
if jetFlags.useTracks():
names += ["PseudoJetTracks"]
if jetFlags.useTruth():
names += ["PseudoJetGhostTruth"]
for ptype in jetFlags.truthFlavorTags():
names += ["PseudoJetGhost" + ptype]
if jetFlags.useMuonSegments():
names += ["PseudoJetGhostMuonSegment"]
icount = 0
for name in names:
tname = "psjdmp" + str(icount)
icount += 1
from JetRec.JetRecConf import JetDumper
psjdmp = JetDumper(tname)
ToolSvc += psjdmp
psjdmp.ContainerName = name
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.
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)
# Lock all the flags used here so that later attempts to change # the value will fail with an error message. jetFlags.useTruth.lock() jetFlags.useTopo.lock() jetFlags.useTracks.lock() jetFlags.useMuonSegments.lock() jetFlags.useBTagging.lock() jetFlags.useCaloQualityTool.lock() jetFlags.additionalTopoGetters.lock() jetFlags.truthFlavorTags.lock() jetFlags.skipTools.lock() # Display all flags used here. print myname + "jetFlags.useTruth: " + str(jetFlags.useTruth()) print myname + "jetFlags.useTopo: " + str(jetFlags.useTopo()) print myname + "jetFlags.useTracks: " + str(jetFlags.useTracks()) print myname + "jetFlags.useMuonSegments: " + str(jetFlags.useMuonSegments()) print myname + "jetFlags.useBTagging: " + str(jetFlags.useBTagging()) print myname + "jetFlags.useCaloQualityTool: " + str(jetFlags.useCaloQualityTool()) print myname + "jetFlags.additionalTopoGetters: " + str(jetFlags.additionalTopoGetters()) print myname + "jetFlags.truthFlavorTags: " + str(jetFlags.truthFlavorTags()) print myname + "jetFlags.skipTools: " + str(jetFlags.skipTools()) ######################################################### # Create standard tool manager. ######################################################### # Import the jet tool manager. from JetRec.JetToolSupport import JetToolManager # Global jet tool manager with standard definitions
if jetFlags.useTruth:
jtm += CopyTruthJetParticles("truthpartcopy", OutputName="JetInputTruthParticles" )
jtm += CopyTruthJetParticles("truthpartcopywz", OutputName="JetInputTruthParticlesNoWZ" ,IncludeWZLeptons=False, IncludeTauLeptons=False)
#--------------------------------------------------------------
# Jet reco infrastructure.
#--------------------------------------------------------------
# Jet pseudojet retriever.
jtm += JetPseudojetRetriever("jpjretriever")
# Jet constituent retriever.
labs = []
if jetFlags.useTracks():
labs += ["Track"]
labs += ["AntiKt3TrackJet", "AntiKt3TrackJet"]
if jetFlags.useMuonSegments():
labs += ["MuonSegment",]
if jetFlags.useTruth():
labs += ["Truth"]
for lab in jetFlags.truthFlavorTags():
labs += [lab]
jtm += JetConstituentsRetriever(
"jconretriever",
UsePseudojet = True,
UseJetConstituents = True,
PseudojetRetriever = jtm.jpjretriever,
GhostLabels = labs,
GhostScale = 1.e-20
# Lock all the flags used here so that later attempts to change
# the value will fail with an error message.
jetFlags.useTruth.lock()
jetFlags.useTopo.lock()
jetFlags.useTracks.lock()
jetFlags.useMuonSegments.lock()
jetFlags.useBTagging.lock()
jetFlags.useCaloQualityTool.lock()
jetFlags.additionalTopoGetters.lock()
jetFlags.truthFlavorTags.lock()
jetFlags.skipTools.lock()
# Display all flags used here.
print myname + "jetFlags.useTruth: " + str(jetFlags.useTruth())
print myname + "jetFlags.useTopo: " + str(jetFlags.useTopo())
print myname + "jetFlags.useTracks: " + str(jetFlags.useTracks())
print myname + "jetFlags.useMuonSegments: " + str(jetFlags.useMuonSegments())
print myname + "jetFlags.useBTagging: " + str(jetFlags.useBTagging())
print myname + "jetFlags.useCaloQualityTool: " + str(
jetFlags.useCaloQualityTool())
print myname + "jetFlags.additionalTopoGetters: " + str(
jetFlags.additionalTopoGetters())
print myname + "jetFlags.truthFlavorTags: " + str(jetFlags.truthFlavorTags())
print myname + "jetFlags.skipTools: " + str(jetFlags.skipTools())
#########################################################
# Create standard tool manager.
#########################################################
# Import the jet tool manager.
from JetRec.JetToolSupport import JetToolManager
SkipNegativeEnergy = False,
TreatNegativeEnergyAsGhost=True,
GhostScale = 1.e-20
)
jtm += PseudoJetGetter("gakt4trackget_HI",
InputContainer = HIJetFlags.TrackJetContainerName(),
Label = "Ghost" + HIJetFlags.TrackJetContainerName(),
SkipNegativeEnergy = True,
OutputContainer = "PseudoJetGhost" + HIJetFlags.TrackJetContainerName(),
GhostScale = 1.e-20)
HIgetters_ghost_track = []
HIgetters_common=[]
if jetFlags.useMuonSegments(): HIgetters_common += [jtm.gmusegget]
if jetFlags.useTracks():
HIgetters_ghost_track += [jtm.gakt4trackget_HI]
if HIJetFlags.UseHITracks() : HIgetters_ghost_track += [jtm.gtrackget_HI]
else: HIgetters_ghost_track += [jtm.gtrackget]
if jetFlags.useTruth():
#HIgetters_common += [jtm.gtruthget]
flavorgetters=[]
for ptype in jetFlags.truthFlavorTags():
flavorgetters += [getattr(jtm, "gtruthget_" + ptype)]
HIgetters_common += flavorgetters
jtm.gettersMap['HI'] = [jtm.get_HI]
jtm.gettersMap['HI'] += HIgetters_common
jtm.gettersMap['HI'] += HIgetters_ghost_track
from METReconstruction.METRecoFlags import metFlags
from METReconstruction.METRecoConfig import BuildConfig, RefConfig, METConfig, clusterSigStates
from RecExConfig.RecFlags import rec
doInDet = rec.doInDet()
from JetRec.JetRecFlags import jetFlags
jetsUseTracks = jetFlags.useTracks()
############################################################################
# MET_RefFinal
rf_builders = [
BuildConfig('Ele'),
BuildConfig('Gamma'),
BuildConfig('Tau'),
BuildConfig('Jet'),
BuildConfig('SoftClus'),
BuildConfig('SoftTrk')
]
rf_refiners = [RefConfig('TrackFilter', 'PVSoftTrk')]
cfg_mrf = METConfig('RefFinal',
rf_builders,
rf_refiners,
doSum=True,
doTracks=(doInDet and jetsUseTracks),
doRegions=True)
# Configure the tools explicitly with defaults
# These are mostly already set in the constructor declareProperty calls
cfg_mrf.builders['Ele'].MinPt = 10e3
cfg_mrf.builders['Ele'].MaxEta = 2.47
