# 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"]
jetlog.info("Skipped tools: %s", jetFlags.skipTools())
from RecExConfig.RecAlgsFlags import recAlgs
if not recAlgs.doEFlow():
jetFlags.usePFlow = False
# Set the list of rho calculations.
# If caller has set jetFlags.eventShapeTools(), then we use those values.
if jetFlags.eventShapeTools() == None:
jetFlags.eventShapeTools = []
if jetFlags.useTopo():
jetFlags.eventShapeTools += ['emtopo', 'lctopo']
if jetFlags.usePFlow():
jetFlags.eventShapeTools += ['empflow']
# Import the jet tool manager.
from JetRec.JetRecStandardToolManager import jtm
print myname + "End."
# 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"]
jetlog.info( "Skipped tools: %s", jetFlags.skipTools())
from RecExConfig.RecAlgsFlags import recAlgs
if not recAlgs.doEFlow():
jetFlags.usePFlow = False
# Set the list of rho calculations.
# If caller has set jetFlags.eventShapeTools(), then we use those values.
if jetFlags.eventShapeTools() == None:
jetFlags.eventShapeTools = []
if jetFlags.useTopo():
jetFlags.eventShapeTools += ['emtopo', 'lctopo']
if jetFlags.usePFlow():
jetFlags.eventShapeTools += ['empflow']
# Import the jet tool manager.
from JetRec.JetRecStandardToolManager import jtm
print myname + "End."
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)
# Import the standard jet tool manager.
from JetRec.JetRecStandard import jtm
# Full job is a list of algorithms
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
# Add the truth tools.
if jetFlags.useTruth:
from JetRec.JetFlavorAlgs import scheduleCopyTruthParticles
scheduleCopyTruthParticles(job)
# Event shape tools.
evstools = []
for name in jetFlags.eventShapeTools():
from EventShapeTools.EventDensityConfig import configEventDensityTool
if name == "em":
jtm += configEventDensityTool("EMTopoEventShape", jtm.emget, 0.4)
evstools += [jtm.tools["EMTopoEventShape"]]
elif name == "lc":
jtm += configEventDensityTool("LCTopoEventShape", jtm.lcget, 0.4)
evstools += [jtm.tools["LCTopoEventShape"]]
else:
print myname + "Invalid event shape key: " + name
raise Exception
# Add the tool runner. It runs the jetrec tools.
rtools = []
if jetFlags.useCells():
rtools += [jtm.missingcells]
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),
}
print myname + "Event shape tools: " + str(eventShapeTools)
for evskey in eventShapeTools:
from EventShapeTools.EventDensityConfig import configEventDensityTool
if evskey in evsDict:
(toolname, getter) = evsDict[evskey]
if toolname in jtm.tools:
print myname + "Skipping duplicate event shape: " + toolname
else:
print myname + "Adding event shape " + evskey
jtm += configEventDensityTool(toolname, getter, 0.4)
evstools += [jtm.tools[toolname]]
else:
print 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,
jtm.JetConstitSeq_LCOrigin,
jtm.JetConstitSeq_EMOrigin,
]
# Add the algorithm. It runs the jetrec tools.
from JetRec.JetRecConf import JetAlgorithm
if jetFlags.separateJetAlgs():
from JetRec.JetRecConf import JetToolRunner
jtm += JetToolRunner("jetrun",
EventShapeTools=evstools,
Tools=rtools,
Timer=jetFlags.timeJetToolRunner()
)
jetrun = jtm.jetrun
job += JetAlgorithm("jetalg")
jetalg = job.jetalg
jetalg.Tools = [jtm.jetrun]
for t in jtm.jetrecs:
# from JetRec.JetRecConf import JetToolRunner
# jetrun_rec = JetToolRunner("jetrun"+t.name(),
# EventShapeTools=[],
# Tools=[t],
# Timer=jetFlags.timeJetToolRunner()
# )
# jtm += jetrun_rec
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()
)
jetrun = jtm.jetrun
job += JetAlgorithm("jetalg")
jetalg = job.jetalg
jetalg.Tools = [jtm.jetrun]
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 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