def egammaTruthParticleConfig \
(seq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()),
sgkey = 'egammaTruth',
prefix = '',
doPileup = D3PDMakerFlags.TruthDoPileup(),
**kwargs):
if not rec.doTruth():
return
# Is the container already in SG?
if cfgKeyStore.isInInput ('DataVector<xAOD::TruthParticle_v1>', sgkey):
return
algname = prefix + sgkey + 'Builder'
if not hasattr (seq, algname):
import AthenaCommon.CfgMgr as CfgMgr
from egammaRec.Factories import ToolFactory
exten = ToolFactory (CfgMgr.Trk__ParticleCaloExtensionTool,
name="GSFParticleCaloExtensionTool",
StartFromPerigee = True)()
seq += egammaD3PDAnalysis.egammaTruthAlg (
algname,
InputKey = D3PDMakerFlags.TruthSGKey(),
OutputKey = sgkey,
ParticleCaloExtensionTool = exten,
AuxPrefix = D3PDMakerFlags.EgammaUserDataPrefix())
cfgKeyStore.addTransient ('DataVector<xAOD::TruthParticle_v1>', sgkey)
return
def _jetTwoTrackVertexTagAlgHook(
c,
prefix,
sgkey,
jetCollections,
InfoName=JetTagD3PDFlags.JetFitterVertexFinderObjects(),
**kw):
preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName())
# Is the container already in SG?
if cfgKeyStore.isInInput('JetTagTwoTrackVertexDataHolder', sgkey):
return
# Is the algorithm already in the sequence?
algname = sgkey + JetTagD3PDKeys.JFTwoTrackVertexMakerAlgPostfix()
if hasattr(preseq, algname):
return
filterargs = kw
for k in filterargs.keys():
if not hasattr(JetTagD3PDMaker.JetTagJetFitterDataToSGAlg, k):
del filterargs[k]
del filterargs['name']
preseq += JetTagD3PDMaker.JetTagJetFitterDataToSGAlg(
algname,
TwoTrackVertexName=sgkey,
FillTwoTrackVertex=True,
JetCollections=jetCollections,
InfoName=InfoName,
**filterargs)
return
def convert_trackparticles(seq,
xaod_key,
key,
truth_key,
trackmap_key=None,
base_xaod_key=None,
base_key=None):
from xAODTrackingCnv.xAODTrackingCnvConf import xAODMaker__TrackParticleCnvAlg
have_truth = cfgKeyStore.isInInput('TrackParticleTruthCollection',
truth_key)
alg = xAODMaker__TrackParticleCnvAlg \
(xaod_key + 'Cnv',
AODContainerName = key,
xAODContainerName = xaod_key,
AODTruthContainerName = truth_key,
AddTruthLink = have_truth)
seq += alg
if trackmap_key != None:
from xAODEgammaCnv.xAODEgammaCnvConf import xAODMaker__GSFTrackParticleMapCnvAlg
alg = xAODMaker__GSFTrackParticleMapCnvAlg\
(xaod_key + 'ParticleMapCnv',
AODContainerName = base_key,
AODContainerNameGSF = key,
xAODContainerName = base_xaod_key,
xAODContainerNameGSF = xaod_key,
TrackMapName = trackmap_key)
seq += alg
return
def _jetFilterAlgHook(c, prefix, sgkey, JetContainer, **kw):
preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName())
# Is the container already in SG?
if cfgKeyStore.isInInput('JetContainer', sgkey):
return
# Is the algorithm already in the sequence?
algname = sgkey + JetTagD3PDKeys.FilteredJetMakerAlgPostfix()
if hasattr(preseq, algname):
return
# select valid argument for JetTagJetFilterAlg
filterargs = kw
for k in filterargs.keys():
if not hasattr(JetTagD3PDMaker.JetTagJetFilterAlg, k):
del filterargs[k]
del filterargs['name']
### if some argument do not exist set them to the flag values
if not 'PtMinCut' in filterargs:
filterargs['PtMinCut'] = JetTagD3PDFlags.JetFilterPtMinCut()
if not 'EtaCut' in filterargs:
filterargs['EtaCut'] = JetTagD3PDFlags.JetFilterEtaCut()
if not 'UseEMScale' in filterargs:
filterargs['UseEMScale'] = JetTagD3PDFlags.JetFilterUseEMScale()
preseq += JetTagD3PDMaker.JetTagJetFilterAlg(algname,
FilteredJetContainer=sgkey,
JetContainer=JetContainer,
**filterargs)
return
def resolveSGKey(type, keystr):
"""Pick proper SG key out of a list from ObjKeyStore.
KEYSTR is a comma-separated list of StoreGate keys.
Return the first one from that list that exists in ObjKeyStore for TYPE.
Raise an exception if none of them exist.
"""
_initKeyStore()
log = logging.getLogger('D3PD')
kl = keystr.split(',')
for k in kl:
if cfgKeyStore.isInInput(type, k):
log.verbose("Using SG key %s for type %s." % (k, type))
return k
if len(kl) == 1:
# Just one, hope for the best.
return k
from RecExConfig.InputFilePeeker import inputFileSummary
if inputFileSummary['nentries'] == 0:
# No input events, can't autoconfig. Just return the first key...
log.warning("No input events, can't autoconfigure. "
"Using SG key %s for type %s." % (kl[0], type))
return kl[0]
raise Exception("No keys among `%s' for type `%s' in ObjKeyStore." %
(keystr, type))
def simpleParticleConfig(seq=AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()),
sgkey='SimpleTruthCollection',
prefix='',
pdg_id=11,
min_pt=-1. * GeV):
# Is the container already in SG?
if cfgKeyStore.isInInput('TruthParticleContainer', sgkey): return
# Is the algorithm already registered?
algname = prefix + sgkey + 'Builder'
if hasattr(seq, algname): return
filtname = prefix + sgkey + 'Filter'
seq += createMcAodBuilder\
(algname,
inMcEvtCollection = D3PDMakerFlags.TruthSGKey(),
outMcEvtCollection = sgkey + '_GEN_D3PD',
outTruthParticles = sgkey,
filterTool = TruthD3PDAnalysis.SimpleTruthParticleFilterTool
(filtname,
PDG_ID = pdg_id,
MinPt = min_pt),
cnvTool = CfgMgr.TruthParticleCnvTool('D3PDTruthParticleCnvTool'),
)
cfgKeyStore.addTransient('TruthParticleContainer', sgkey)
return
def convert_tracks(seq, xaod_key, key, truth_key):
from xAODTrackingCnv.xAODTrackingCnvConf import xAODMaker__TrackParticleCnvAlg
have_truth = cfgKeyStore.isInInput('TrackTruthCollection', truth_key)
alg = xAODMaker__TrackParticleCnvAlg \
(xaod_key + 'Cnv',
AddTruthLink = have_truth,
TrackContainerName = key,
xAODTrackParticlesFromTracksContainerName = xaod_key,
ConvertTracks = True,
ConvertTrackParticles = False)
seq += alg
return
def testSGKey(type, keystr):
"""Test to see if SG keys are in ObjKeyStore.
KEYSTR is a comma-separated list of StoreGate keys.
Return true if any key from that list exists in ObjKeyStore for TYPE.
"""
_initKeyStore()
kl = keystr.split(',')
for k in kl:
if cfgKeyStore.isInInput(type, k):
return True
return False
def addPFlowJets(inputtype="EM", rsize=0.4, algseq=None, outputGroup="PFlow"):
from JetRec.JetRecStandard import jtm
jtm.modifiersMap["mods"] = ["jetfilter", jtm.nsubjettiness, jtm.pull]
pflowName = "AntiKt" + str(int(
rsize * 10)) + inputtype + "Pflow" # input : EM, EMC, LC
algname = "jetalg" + pflowName
OutputJets.setdefault(outputGroup, []).append(pflowName)
# return if the alg is already scheduled here :
if algseq is None:
print "No algsequence passed! Will not schedule", algname
return
elif cfgKeyStore.isInInput("xAOD::JetContainer", pflowName):
print "Collection ", algname, "is already in input AOD!"
return
elif algname in DFJetAlgs:
if hasattr(algseq, algname):
print " Algsequence", algseq, "already has an instance of", algname
else:
print " Added", algname, "to sequence", algseq
algseq += DFJetAlgs[algname]
return DFJetAlgs[algname]
if inputtype == "EM":
inputName = "empflow"
elif inputtype == "EMC":
inputName = "emcpflow"
elif inputtype == "LC":
inputName = "lcpflow"
if pflowName in jtm.tools:
pflowjet = jtm.tools[pflowName]
else:
pflowjet = jtm.addJetFinder(pflowName + "Jets",
"AntiKt",
rsize,
inputName,
"mods",
ghostArea=0.01,
ptmin=2000,
ptminFilter=7000)
from JetRec.JetRecConf import JetAlgorithm
print "Adding PFlow jets : ", pflowName
alg = JetAlgorithm(algname, Tools=[pflowjet])
print " Added", algname, "to sequence", algseq
algseq += alg
DFJetAlgs[algname] = alg
return alg
def buildGenericGroomAlg(jetalg,
rsize,
inputtype,
groomedName,
jetToolBuilder,
includePreTools=False,
algseq=None,
outputGroup="CustomJets"):
algname = "jetalg" + groomedName
# add these groomed jets to the output (use setdefault() to constuct the list if not existing yet)
OutputJets.setdefault(outputGroup, []).append(groomedName + "Jets")
# return if the alg is already scheduled here :
if algseq is None:
print "No algsequence passed! Will not schedule", algname
return
elif cfgKeyStore.isInInput("xAOD::JetContainer", groomedName):
print "Collection ", algname, "is already in input AOD!"
return
elif algname in DFJetAlgs:
if hasattr(algseq, algname):
print " Algsequence", algseq, "already has an instance of", algname
else:
print " Added", algname, "to sequence", algseq
algseq += DFJetAlgs[algname]
return DFJetAlgs[algname]
from JetRec.JetRecUtils import buildJetContName
ungroomedname = buildJetContName(jetalg, rsize, inputtype)
# 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)
# 2nd step run the trimming alg. We can re-use the original largeR jet since we reassociated the PseudoJet already.
fatjet_trim = jetToolBuilder(groomedName + "Jets", ungroomedname)
from JetRec.JetRecConf import JetAlgorithm
if includePreTools:
# enable track ghost association and JVF
jetalgTools = [jtm.tracksel, jtm.tvassoc] + jetalgTools
alg = JetAlgorithm(algname, Tools=jetalgTools + [fatjet_trim])
DFJetAlgs[algname] = alg
print " Added", algname, "to sequence", algseq
algseq += alg
return alg
def buildGenericGroomAlg(
jetalg, rsize, inputtype, groomedName, jetToolBuilder, includePreTools=False, algseq=None, outputGroup="CustomJets"
):
algname = "jetalg" + groomedName
# add these groomed jets to the output (use setdefault() to constuct the list if not existing yet)
OutputJets.setdefault(outputGroup, []).append(groomedName + "Jets")
# return if the alg is already scheduled here :
if algseq is None:
print "No algsequence passed! Will not schedule", algname
return
elif cfgKeyStore.isInInput("xAOD::JetContainer", groomedName):
print "Collection ", algname, "is already in input AOD!"
return
elif algname in DFJetAlgs:
if hasattr(algseq, algname):
print " Algsequence", algseq, "already has an instance of", algname
else:
print " Added", algname, "to sequence", algseq
algseq += DFJetAlgs[algname]
return DFJetAlgs[algname]
from JetRec.JetRecUtils import buildJetContName
ungroomedname = buildJetContName(jetalg, rsize, inputtype)
# 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)
# 2nd step run the trimming alg. We can re-use the original largeR jet since we reassociated the PseudoJet already.
fatjet_trim = jetToolBuilder(groomedName + "Jets", ungroomedname)
from JetRec.JetRecConf import JetAlgorithm
if includePreTools:
# enable track ghost association and JVF
jetalgTools = [jtm.tracksel, jtm.tvassoc] + jetalgTools
alg = JetAlgorithm(algname, Tools=jetalgTools + [fatjet_trim])
DFJetAlgs[algname] = alg
print " Added", algname, "to sequence", algseq
algseq += alg
return alg
def addPFlowJets(inputtype="EM", rsize=0.4, algseq=None, outputGroup="PFlow"):
from JetRec.JetRecStandard import jtm
jtm.modifiersMap["mods"] = ["jetfilter", jtm.nsubjettiness, jtm.pull]
pflowName = "AntiKt" + str(int(rsize * 10)) + inputtype + "Pflow" # input : EM, EMC, LC
algname = "jetalg" + pflowName
OutputJets.setdefault(outputGroup, []).append(pflowName)
# return if the alg is already scheduled here :
if algseq is None:
print "No algsequence passed! Will not schedule", algname
return
elif cfgKeyStore.isInInput("xAOD::JetContainer", pflowName):
print "Collection ", algname, "is already in input AOD!"
return
elif algname in DFJetAlgs:
if hasattr(algseq, algname):
print " Algsequence", algseq, "already has an instance of", algname
else:
print " Added", algname, "to sequence", algseq
algseq += DFJetAlgs[algname]
return DFJetAlgs[algname]
if inputtype == "EM":
inputName = "empflow"
elif inputtype == "EMC":
inputName = "emcpflow"
elif inputtype == "LC":
inputName = "lcpflow"
if pflowName in jtm.tools:
pflowjet = jtm.tools[pflowName]
else:
pflowjet = jtm.addJetFinder(
pflowName + "Jets", "AntiKt", rsize, inputName, "mods", ghostArea=0.01, ptmin=2000, ptminFilter=7000
)
from JetRec.JetRecConf import JetAlgorithm
print "Adding PFlow jets : ", pflowName
alg = JetAlgorithm(algname, Tools=[pflowjet])
print " Added", algname, "to sequence", algseq
algseq += alg
DFJetAlgs[algname] = alg
return alg
def TruthJetFilterConfig(seq,
sgkey='Filtered' +
D3PDMakerFlags.TruthParticlesSGKey(),
prefix='',
excludeWZdecays=True,
photonCone=-1.,
doPileup=D3PDMakerFlags.TruthDoPileup(),
writePartons=D3PDMakerFlags.TruthWritePartons(),
writeHadrons=D3PDMakerFlags.TruthWriteHadrons(),
writeGeant=D3PDMakerFlags.TruthWriteGeant(),
excludeLeptonsFromTau=False):
if not rec.doTruth():
return
# Is the container already in SG?
if cfgKeyStore.isInInput('TruthParticleContainer', sgkey):
return
algname = prefix + sgkey + 'Builder'
if hasattr(seq, algname):
return
filtname = prefix + sgkey + 'Filter'
seq += createMcAodBuilder\
(algname,
inMcEvtCollection = D3PDMakerFlags.TruthSGKey(),
outMcEvtCollection = sgkey + '_GEN_D3PD',
outTruthParticles = sgkey,
filterTool = D3PD__TruthJetFilterTool
(filtname,
DoPileup = doPileup,
WritePartons = writePartons,
WriteHadrons = writeHadrons,
WriteGeant = writeGeant,
ExcludeWZdecays = excludeWZdecays,
PhotonCone = photonCone,
ExcludeLeptonsFromTau = excludeLeptonsFromTau,
),
cnvTool = CfgMgr.TruthParticleCnvTool('D3PDTruthJetCnvTool'),
)
cfgKeyStore.addTransient('TruthParticleContainer', sgkey)
return
def PartonJetConfig (finder = 'AntiKt',
size = 0.4,
doPythia = False,
doHerwig = False,
minJetPt = 7.*GeV,
absEtaMax = 10.,
suffix = '',
inputCollections = None):
if not rec.doTruth():
return
# Is the container already in SG?
import JetRec.JetAlgConfiguration
nameBuilder = JetRec.JetAlgConfiguration.nameBuilder
editParm = JetRec.JetAlgConfiguration.editParm
sgkey = nameBuilder(finder,editParm(size),'','Truth','Parton'+suffix,'',)+'Jets'
if cfgKeyStore.isInInput ('JetCollection', sgkey):
return
# Configure parton selector tool
from AthenaCommon.AppMgr import ToolSvc
jetPartonSelectorTool = JetPartonSelectorTool("JetPartonSelectorTool")
jetPartonSelectorTool.DoPythia = doPythia
jetPartonSelectorTool.DoHerwig = doHerwig
jetPartonSelectorTool.max_absEta = absEtaMax
#jetPartonSelectorTool.OutputLevel = INFO
ToolSvc += jetPartonSelectorTool
# Configure jets builder
if inputCollections != None:
partonJetAlg = make_StandardJetGetter(finder,size,'Truth',inputSuff='Parton'+suffix,
inputCollectionNames=inputCollections,
inputTools=[jetPartonSelectorTool]).jetAlgorithmHandle()
partonJetAlg.AlgTools['JetPartonSelectorTool'].InputCollectionKeys = []
partonJetAlg.AlgTools['JetPartonSelectorTool'].InputCollectionKeys.append(inputCollections[0])
else:
partonJetAlg = make_StandardJetGetter(finder,size,'Truth',inputSuff='Parton'+suffix).jetAlgorithmHandle()
partonJetAlg.AlgTools['JetFinalPtCut'].MinimumSignal = minJetPt
#partonJetAlg.AlgTools['InputToJet'].InputSelector = jetPartonSelectorTool
#partonJetAlg.OutputLevel = INFO
return
def _truthMuonAlgHook(c, prefix, sgkey, TruthContainer='TruthParticles', **kw):
preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName())
# Is the container already in SG?
if cfgKeyStore.isInInput('DataVector<xAOD::TruthParticle_v1>', sgkey):
return
# Is the algorithm already in the sequence?
algname = prefix + 'TruthMuonsToSG'
if hasattr(preseq, algname):
return
from TruthD3PDMaker.MCTruthClassifierConfig \
import D3PDMCTruthClassifier
preseq += MuonD3PDMaker.TruthMuonsToSG \
(algname,
TruthMuonContainer = sgkey,
TruthContainer = TruthContainer,
Classifier = D3PDMCTruthClassifier)
return
def configure(self):
mlog = logging.getLogger(
'ThinNegativeEnergyNeutralPFOs.py::configure:')
mlog.info('entering')
try:
from ThinningUtils.ThinningUtilsConf import ThinNegativeEnergyNeutralPFOsAlg
theNegativeEnergyNeutralPFOsThinner = ThinNegativeEnergyNeutralPFOsAlg(
"ThinNegativeEnergyNeutralPFOsAlg",
ThinNegativeEnergyNeutralPFOs=True,
StreamName='StreamAOD')
print(theNegativeEnergyNeutralPFOsThinner)
CHSnPFOsThinAlg = None
from RecExConfig.ObjKeyStore import cfgKeyStore
from JetRec.JetRecFlags import jetFlags
if (jetFlags.useTracks or cfgKeyStore.isInInput(
'xAOD::PFOContainer', 'CHSNeutralParticleFlowObjects')):
CHSnPFOsThinAlg = ThinNegativeEnergyNeutralPFOsAlg(
"ThinNegativeEnergyCHSNeutralPFOsAlg",
NeutralPFOsKey="CHSNeutralParticleFlowObjects",
ThinNegativeEnergyNeutralPFOs=True,
StreamName='StreamAOD')
print(CHSnPFOsThinAlg)
except Exception:
mlog.error(
"could not get handle to ThinNegativeEnergyNeutralPFOsAlg")
import traceback
traceback.print_exc()
return False
mlog.info("now adding to topSequence")
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
topSequence += theNegativeEnergyNeutralPFOsThinner
if CHSnPFOsThinAlg:
topSequence += CHSnPFOsThinAlg
return True
def configure(self):
mlog = logging.getLogger('TrkTrackPostExecStream.py::configure:')
mlog.info('entering')
try:
from RecExConfig.ObjKeyStore import cfgKeyStore
from ThinningUtils.ThinningUtilsConf import ThinTrkTrackAlg
theTrkTrackThinner = ThinTrkTrackAlg(
"ThinTrkTrackAlg",
doElectrons=True,
doPhotons=True,
doMuons=cfgKeyStore.isInInput('TrackCollection',
'CombinedMuonTracks'),
MuonsKey="Muons",
ElectronsKey="Electrons",
PhotonsKey="Photons",
CombinedMuonsTrackKey="CombinedMuonTracks",
GSFTrackKey="GSFTracks",
StreamName='StreamAOD')
from AthenaCommon.Constants import VERBOSE, DEBUG, INFO, ERROR
#theTrkTrackThinner.OutputLevel=DEBUG
print(theTrkTrackThinner)
except Exception:
import traceback
mlog.error("could not get handle to ThinTrkTrackAlg")
traceback.print_exc()
return False
mlog.info("now adding to topSequence")
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
topSequence += theTrkTrackThinner
mlog.info("Done adding to topSequence")
return True
def hideInput(typ, key):
sgkey = key
dpos = sgkey.find('.')
if dpos >= 0 and dpos < len(sgkey) - 1:
sgkey = sgkey[:dpos]
if cfgKeyStore.isInInput(typ, sgkey):
if key.endswith('.'):
newkey = key[:-1] + '_old.'
else:
newkey = key + '_old'
addInputRename(typ, key, newkey)
# Check for an xAOD type.
if typ.startswith('xAOD::') and key.find('.') < 0:
if typ.endswith('Container'):
auxtyp = typ[:-9] + 'AuxContainer'
else:
auxtyp = typ + 'AuxInfo'
auxkey = key + 'Aux.'
auxnewkey = key + 'Aux_old.'
addInputRename(auxtyp, auxkey, auxnewkey)
return
def buildTOPQCA15jets(algseq):
if not cfgKeyStore.isInInput("xAOD::JetContainer", "CamKt15LCTopoJets"):
from JetRec.JetRecConf import JetAlgorithm
jtm.modifiersMap["lctopoCA15"] = list(jtm.modifiersMap["lctopo"])
if globalflags.DataSource() == 'geant4':
jtm.modifiersMap["lctopoCA15"].remove('truthassoc')
if hasattr(jtm, "CamKt15LCTopoJets"):
TOPQCA15LC = getattr(jtm, "CamKt15LCTopoJets")
else:
TOPQCA15LC = jtm.addJetFinder("CamKt15LCTopoJets",
"CamKt",
1.5,
"lctopo",
"lctopoCA15",
ghostArea=0.01,
ptmin=2000,
ptminFilter=100000,
calibOpt="aro")
if not hasattr(algseq, "jetalgCamKt15LCTopo"):
TOPQCA15LCalg = JetAlgorithm("jetalgCamKt15LCTopo",
Tools=[TOPQCA15LC])
algseq += TOPQCA15LCalg
print("Running jet finding algorithm for CamKt15LCTopoJets")
def makexAOD(seq, xaod_type, xaod_key, key=None, **kw):
testfn = cfgKeyStore.isInInput
if xaod_type in ['xAOD::TrigDecision']:
testfn = cfgKeyStore.isInInputFile
if testfn(xaod_type, xaod_key):
return
if key == None:
key = xaod_key
tinfo_list = types[xaod_type]
if type(tinfo_list) != type([]):
tinfo_list = [tinfo_list]
for tinfo in tinfo_list:
if cfgKeyStore.isInInput(tinfo[0], key):
if seq == None:
seq = AlgSequence()
tinfo[1](seq, xaod_key, key, **kw)
cfgKeyStore.addTransient(xaod_type, xaod_key)
break
return
def createxAOD(seq):
from D3PDMakerConfig.makexAOD import makexAOD, setVxLinks
makexAOD(seq,
'xAOD::TruthParticleContainer',
'TruthParticles',
'GEN_AOD',
xaod_truth_event_key='TruthEvents',
xaod_truth_vertex_key='TruthVertices',
xaod_truth_links_key='xAODTruthLinks')
makexAOD(seq, 'xAOD::CaloClusterContainer', 'CaloCalTopoCluster')
makexAOD(seq, 'xAOD::CaloClusterContainer', 'egClusterCollection')
makexAOD(seq, 'xAOD::CaloClusterContainer', 'LArClusterEMFrwd')
makexAOD(seq, 'xAOD::CaloClusterContainer', 'LArClusterEMSofte')
makexAOD(seq, 'xAOD::CaloClusterContainer', 'EMTopoSW35')
makexAOD(seq, 'xAOD::CaloClusterContainer', 'HLT')
makexAOD(seq, 'xAOD::CaloClusterContainer', 'HLT_TrigCaloClusterMaker')
makexAOD(seq, 'xAOD::CaloClusterContainer', 'HLT_TrigCaloClusterMaker_slw')
makexAOD(seq, 'xAOD::CaloClusterContainer', 'MuonClusterCollection')
makexAOD(seq, 'xAOD::CaloClusterContainer', 'Tau1P3PCellCluster')
makexAOD(seq, 'xAOD::CaloClusterContainer', 'Tau1P3PEM012ClusterContainer')
makexAOD(seq, 'xAOD::CaloClusterContainer', 'Tai1P3PPi0ClusterContainer')
makexAOD(seq, 'xAOD::JetContainer', 'AntiKt4TopoEMJets')
makexAOD(seq, 'xAOD::JetContainer', 'AntiKt4TruthJets')
#makexAOD (seq, 'xAOD::TrackParticleContainer',
# 'InDetTrackParticles', 'Tracks',
# truth_key = 'TrackTruthCollection')
makexAOD(seq,
'xAOD::TrackParticleContainer',
'GSFInDetTrackParticles',
'GSFTracks',
truth_key='GSFTrackTruthCollection')
makexAOD(seq,
'xAOD::TrackParticleContainer',
'InDetTrackParticles',
'TrackParticleCandidate',
truth_key='TrackParticleTruthCollection')
makexAOD(seq,
'xAOD::TrackParticleContainer',
'GSFTrackParticles',
'GSFTrackParticleCandidate',
truth_key='GSFTrackParticleTruthCollection',
trackmap_key='GSFTrackAssociation',
base_xaod_key='InDetTrackParticles',
base_key='TrackParticleCandidate')
makexAOD(seq,
'xAOD::TrackParticleContainer',
'MuonboyTrackParticles',
truth_key='TrackParticleTruthCollection')
makexAOD(seq,
'xAOD::TrackParticleContainer',
'StacoTrackParticles',
truth_key='TrackParticleTruthCollection')
makexAOD(seq,
'xAOD::TrackParticleContainer',
'MuidExtrTrackParticles',
truth_key='TrackParticleTruthCollection')
makexAOD(seq,
'xAOD::TrackParticleContainer',
'MuidCombTrackParticles',
truth_key='TrackParticleTruthCollection')
makexAOD(seq,
'xAOD::TrackParticleContainer',
'ExtrapolatedMuonSpectrometerParticles',
truth_key='TrackParticleTruthCollection')
makexAOD(seq,
'xAOD::TrackParticleContainer',
'CombinedfitMuonparticles',
truth_key='TrackParticleTruthCollection')
makexAOD(seq,
'xAOD::TrackParticleContainer',
'HLT_InDetTrigParticleCreation_Electron_EFID',
truth_key='')
makexAOD(seq,
'xAOD::TrackParticleContainer',
'HLT_InDetTrigParticleCreationTRTOnly_Electron_EFID',
truth_key='')
makexAOD(seq,
'xAOD::TrackParticleContainer',
'HLT_InDetTrigParticleCreation_Muon_EFID',
truth_key='')
makexAOD(seq,
'xAOD::TrackParticleContainer',
'HLT_InDetTrigParticleCreation_FullScan_EFID',
truth_key='')
makexAOD(seq,
'xAOD::TrackParticleContainer',
'HLT_InDetTrigParticleCreation_Bphysics_EFID',
truth_key='')
makexAOD(seq,
'xAOD::TrackParticleContainer',
'HLT_InDetTrigParticleCreationTRTOnly_Muon_EFID',
truth_key='')
makexAOD(seq,
'xAOD::TrackParticleContainer',
'HLT_InDetTrigParticleCreationTRTOnly_FullScan_EFID',
truth_key='')
makexAOD(seq,
'xAOD::VertexContainer',
'AllPhotonsVxCandidates',
TPContainerName='GSFTrackParticles')
makexAOD(seq,
'xAOD::VertexContainer',
'VxPrimaryCandidate',
key='PrimaryVertices',
TPContainerName='InDetTrackParticles')
makexAOD(seq,
'xAOD::ElectronContainer',
'Electrons',
'ElectronAODCollection',
xAODContainerFrwdName='ForwardElectrons')
makexAOD(seq,
'xAOD::ElectronContainer',
'HLT_egamma_Electrons',
'HLT_egamma_Electrons',
xAODContainerFrwdName='HLT_egamma_Electrons_fwd',
forTrigger=True)
makexAOD(seq,
'xAOD::PhotonContainer',
'Photons',
'PhotonAODCollection',
topo_cluster_xaod_key='EMTopoSW35',
vertex_xaod_key='AllPhotonsVxCandidates')
makexAOD(seq,
'xAOD::PhotonContainer',
'HLT_egamma_Photons',
'HLT_egamma_Photons',
topo_cluster_xaod_key='',
vertex_xaod_key='',
forTrigger=True)
makexAOD(seq,
'xAOD::MuonContainer',
'StacoMuonCollection',
xaod_tp_key='InDetTrackParticles',
xaod_sa_key='MuonboyTrackParticles',
xaod_cb_key='StacoTrackParticles')
makexAOD(seq,
'xAOD::MuonContainer',
'MuidMuonCollection',
xaod_tp_key='InDetTrackParticles',
xaod_sa_key='MuidExtrTrackParticles',
xaod_cb_key='MuidCombTrackParticles')
makexAOD(seq,
'xAOD::MuonContainer',
'CaloMuonCollection',
xaod_tp_key='InDetTrackParticles',
xaod_sa_key='',
xaod_cb_key='')
makexAOD(seq, 'xAOD::MuonContainer', 'HLT_MuonEFInfo')
#makexAOD (seq, 'xAOD::MuonContainer',
# 'HLT_eMuonEFInfo')
#makexAOD (seq, 'xAOD::MuonContainer',
# 'Muons',
# xaod_tp_key = 'InDetTrackParticles',
# xaod_sa_key = 'ExtrapolatedMuonSpectrometerParticles',
# xaod_cb_key = 'CombinedfitMuonparticles')
makexAOD(seq, 'xAOD::TrigEMClusterContainer', 'HLT_TrigT2CaloEgamma')
#setVxLinks (seq, 'InDetTrackParticles', 'VxPrimaryCandidate')
#setVxLinks (seq, 'GSFTrackParticles', 'VxPrimaryCandidate')
makexAOD(seq, 'xAOD::MissingETContainer', 'MET_Core_AntiKt4EMTopo',
'MET_RefFinal')
makexAOD(seq, 'xAOD::TrigDecision', 'xTrigDecision', 'TrigDecision')
from xAODTriggerCnv.xAODRoICreator import xAODRoICreator
if cfgKeyStore.isInInput('LVL1_ROI', 'LVL1_ROI'):
xAODRoICreator(seq)
return
def backgroundD3PD(alg=None,
level=10,
file='background.root',
tuplename='background',
flags=BackgroundD3PDMakerFlags,
**kw):
preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName())
if (not hasattr(topSequence, 'BeamBackgroundFiller')
and not hasattr(preseq, 'BeamBackgroundFiller')):
if cfgKeyStore.isInInput("Trk::SegmentCollection",
"ConvertedMBoySegments"):
from RecBackgroundAlgs import RecBackgroundAlgsConf
preseq += RecBackgroundAlgsConf.BeamBackgroundFiller()
if (not hasattr(topSequence, 'BeamBackgroundFillerMoore')
and not hasattr(preseq, 'BeamBackgroundFillerMoore')):
if cfgKeyStore.isInInput("Trk::SegmentCollection", "MooreSegments"):
from RecBackgroundAlgs.RecBackgroundAlgsConf import BeamBackgroundFiller
BeamBackgroundFillerMoore = BeamBackgroundFiller(
'BeamBackgroundFillerMoore',
muonSegmentContainerKey='MooreSegments',
BeamBackgroundKey='BeamBackgroundDataMoore')
preseq += BeamBackgroundFillerMoore
# The core algorithm
if not alg:
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
alg = MSMgr.NewRootStream(tuplename, file)
#Event level info
alg += EventInfoD3PDObject(**_args(1, 'EventInfo', kw))
if globalflags.DataSource == "data":
alg += LBLengthD3PDObject(**_args(0, 'LBLength', kw))
if rec.doTruth():
from TruthD3PDMaker.GenEventD3PDObject import GenEventD3PDObject
alg += GenEventD3PDObject(**_args(0, 'GenEvent', kw))
if rec.doTrigger():
alg += TrigDecisionD3PDObject(**_args(2, 'TrigDecision', kw))
addTrigConfMetadata(alg)
bcToolType = ""
if globalflags.DataSource == "data":
bcToolType = "LHC"
addBunchStructureMetadata(alg, bcToolType)
alg += BGCodeD3PDObject(**_args(2, 'BGCode', kw))
if flags.AddTriggerBits():
alg += getBkgdTriggerBitsD3PDObject([])
alg += BackgroundWordD3PDObject(**_args(0, 'BkgWord', kw))
if flags.doLUCID():
alg += Lucid_RawDataD3PDObject(**_args(0, 'Lucid', kw))
alg += RawInfoSummaryForTagD3PDObject(**_args(0, 'SumForTag', kw))
alg += MBTSD3PDObject(**_args(0, 'MBTS', kw))
alg += LArCollisionTimeD3PDObject(**_args(0, 'LArTimeDiff', kw))
if flags.doMet():
alg += MissingETD3PDObject(**_args(1,
'MET_RefFinal',
kw,
sgkey='MET_RefFinal',
prefix='MET_RefFinal',
allowMissing=True))
alg += MuonD3PDObject(
**_args(0,
'Muon',
kw,
sgkey='MuonCollection',
prefix='mu_',
include=[
"Isolation", "Quality", "MuonTimingFillerTool",
"MuonTileTimeTool", "ChamberT0"
],
allowMissing=True))
alg += MuonD3PDObject(
**_args(0,
'MuidMuon',
kw,
sgkey='MuidMuonCollection',
prefix='mu_muid_',
include=[
"Isolation", "Quality", "MuonTimingFillerTool",
"MuonTileTimeTool", "ChamberT0"
],
allowMissing=True))
alg += MuonD3PDObject(
**_args(0,
'StacoMuon',
kw,
sgkey='StacoMuonCollection',
prefix='mu_staco_',
include=[
"Isolation", "Quality", "MuonTimingFillerTool",
"MuonTileTimeTool", "ChamberT0"
],
allowMissing=True))
if flags.doCaloMuon():
alg += MuonD3PDObject(
**_args(0,
'CaloMuon',
kw,
sgkey='CaloMuonCollection',
prefix='mu_calo_',
include=[
"Isolation", "Quality", "MuonTimingFillerTool",
"MuonTileTimeTool", "ChamberT0"
],
allowMissing=True))
alg += MuonSegmentD3PDObject(**_args(
1,
'MuonSeg',
kw,
sgkey='MuonSegments',
prefix='museg_',
# MooreSegmentT0 takes the default time
# MuonboySegmentT0 recalculates time (see MuonSegmentD3PDObject.py and MuonSegmentT0FillerTool.cxx)
include=['MooreSegmentT0'],
exclude=['MuonboySegmentT0'],
allowMissing=True))
alg += MuonSegmentD3PDObject(**_args(1,
'MooreSeg',
kw,
sgkey='MooreSegments',
prefix='mooreseg_',
include=['MooreSegmentT0'],
exclude=['MuonboySegmentT0'],
allowMissing=True))
alg += MuonSegmentD3PDObject(**_args(1,
'MboySeg',
kw,
sgkey='ConvertedMBoySegments',
prefix='mboyseg_',
include=['MuonboySegmentT0'],
exclude=['MooreSegmentT0'],
allowMissing=True))
if flags.doMuGirlSeg():
alg += MuonSegmentD3PDObject(**_args(1,
'MuGirlSeg',
kw,
sgkey='MuGirlSegments',
prefix='mgseg_',
include=['MooreSegmentT0'],
exclude=['MuonboySegmentT0'],
allowMissing=True))
if flags.doTrk():
alg += xAODTrackParticleD3PDObject(
**_args(0, 'TrackParticle', kw, prefix='trk_'))
if flags.doMuonHits():
alg += MdtPrepDataD3PDObject(0)
alg += RpcPrepDataD3PDObject(0)
alg += CscPrepDataD3PDObject(0)
alg += TgcPrepDataD3PDObject(0)
alg += TgcPrepDataD3PDObject(**_args(0,
'TGC_MeasurementsPriorBC',
kw,
sgkey='TGC_MeasurementsPriorBC',
prefix='tgcPriorBC_',
label='TgcPrepDataPriorBC'))
alg += TgcPrepDataD3PDObject(**_args(0,
'TGC_MeasurementsNextBC',
kw,
sgkey='TGC_MeasurementsNextBC',
prefix='tgcNextBC_',
label='TgcPrepDataNextBC'))
if flags.doCaloJet():
#alg += JetD3PDObject (**_args(4,'AntiKt4TopoEMJets', kw, sgkey='AntiKt4TopoEMJets', prefix='AntiKt4TopoEM_', include='BeamBackground' ))
if cfgKeyStore.isInInput("Trk::SegmentCollection",
"ConvertedMBoySegments"):
alg += JetD3PDObject(
**_args(4,
'AntiKt4TopoEMJets',
kw,
sgkey='AntiKt4TopoEMJets',
prefix='AntiKt4TopoEM_',
include=['BeamBackground'],
exclude=[
'JetVertexFraction', 'JVtx', 'ActiveArea',
'TruthMF', 'TracksMoments'
],
BeamBackground_BeamBackgroundKey='BeamBackgroundData'))
else:
alg += JetD3PDObject(
**_args(4,
'AntiKt4TopoEMJets',
kw,
sgkey='AntiKt4TopoEMJets',
prefix='AntiKt4TopoEM_',
exclude=[
'JetVertexFraction', 'JVtx', 'ActiveArea',
'TruthMF', 'TracksMoments'
]))
else:
alg += JetD3PDObject(
**_args(4,
'AntiKt4TrackJets',
kw,
sgkey='AntiKt4TrackJets',
prefix='AntiKt4Track_',
exclude=[
'JetVertexFraction', 'JVtx', 'ActiveArea', 'TruthMF',
'TracksMoments'
]))
alg += PrimaryxAODVertexD3PDObject(0)
if flags.doBeamBkgd():
#alg += BeamBackgroundD3PDObject(1)
if cfgKeyStore.isInInput("Trk::SegmentCollection",
"ConvertedMBoySegments"):
alg += BeamBackgroundD3PDObject(
**_args(1,
'BeamBackgroundData',
kw,
sgkey='BeamBackgroundData',
prefix='bb_',
bbJetIndex_Target='AntiKt4TopoEM_',
bbClusterIndex_Target='cl_'))
if cfgKeyStore.isInInput("Trk::SegmentCollection", "MooreSegments"):
alg += BeamBackgroundD3PDObject(
**_args(1,
'BeamBackgroundData',
kw,
sgkey='BeamBackgroundDataMoore',
prefix='bbMoore_',
bbJetIndex_Target='AntiKt4TopoEM_',
bbClusterIndex_Target='cl_'))
if flags.doBCM():
alg += BcmRdoFlatD3PDObject(**_args(0, 'BCMRdo', kw))
if flags.doZDC():
if globalflags.DataSource == "data": alg += ZdcD3PDObject(10)
if flags.doPixelClus():
from InDetD3PDMaker.PixelClusterD3PDObject import PixelClusterD3PDObject
alg += PixelClusterD3PDObject(0)
if flags.doCaloClus():
from CaloSysD3PDMaker.ClusterD3PDObject import ClusterD3PDObject
alg += ClusterD3PDObject(1)
return alg
def configure(self,keys=None):
super(MuonStandalone,self).configure(keys)
if not self.isEnabled(): return
from AthenaCommon.BeamFlags import jobproperties
beamFlags = jobproperties.Beam
SegmentLocation = "MuonSegments"
if muonStandaloneFlags.segmentOrigin == 'TruthTracking':
SegmentLocation = "ThirdChainSegments"
# do the following in case of (at least one) NSW
if (MuonGeometryFlags.hasSTGC() and MuonGeometryFlags.hasMM()):
getPublicTool("MuonLayerHoughTool")
self.addAlg( CfgMgr.MuonLayerHoughAlg( "MuonLayerHoughAlg",
PrintSummary = muonStandaloneFlags.printSummary(),
CscPrepDataContainer = ("CSC_Clusters" if MuonGeometryFlags.hasCSC() else ""),
sTgcPrepDataContainer = ("STGC_Measurements" if MuonGeometryFlags.hasSTGC() else ""),
MMPrepDataContainer = ("MM_Measurements" if MuonGeometryFlags.hasMM() else "") ) )
if not muonStandaloneFlags.patternsOnly():
SegmentFinder = getPublicTool("MuonClusterSegmentFinderTool")
Cleaner = getPublicToolClone("MuonTrackCleaner_seg","MuonTrackCleaner")
Cleaner.Extrapolator = getPublicTool("MuonStraightLineExtrapolator")
Cleaner.Fitter = getPublicTool("MCTBSLFitterMaterialFromTrack")
Cleaner.PullCut = 3
Cleaner.PullCutPhi = 3
Cleaner.UseSLFit = True
SegmentFinder.TrackCleaner = Cleaner
# for test purposes allow parallel running of truth segment finding and new segment finder
MuonSegmentFinderAlg = CfgMgr.MuonSegmentFinderAlg( "MuonSegmentMaker",SegmentCollectionName=SegmentLocation,
MuonPatternCalibration = getPublicTool("MuonPatternCalibration"),
MuonPatternSegmentMaker = getPublicTool("MuonPatternSegmentMaker"),
MuonTruthSummaryTool = None,
PrintSummary = muonStandaloneFlags.printSummary() )
# we check whether the layout contains any CSC chamber and if yes, we check that the user also wants to use the CSCs in reconstruction
if MuonGeometryFlags.hasCSC() and muonRecFlags.doCSCs():
getPublicTool("CscSegmentUtilTool")
getPublicTool("Csc2dSegmentMaker")
getPublicTool("Csc4dSegmentMaker")
else:
MuonSegmentFinderAlg.Csc2dSegmentMaker = ""
MuonSegmentFinderAlg.Csc4dSegmentMaker = ""
self.addAlg( MuonSegmentFinderAlg )
else:
getPublicTool("MuonLayerHoughTool")
self.addAlg(MooSegmentFinderAlg("MuonSegmentMaker"))
self.addAlg(MooSegmentFinderNCBAlg("MuonSegmentMaker_NCB"))
if (not cfgKeyStore.isInInput ('xAOD::MuonSegmentContainer', 'MuonSegments_NCB')):
self.addAlg( CfgMgr.xAODMaker__MuonSegmentCnvAlg("MuonSegmentCnvAlg_NCB",SegmentContainerName="NCB_MuonSegments",xAODContainerName="NCB_MuonSegments") )
if (not cfgKeyStore.isInInput ('xAOD::MuonSegmentContainer', 'MuonSegments')):
self.addAlg( CfgMgr.xAODMaker__MuonSegmentCnvAlg("MuonSegmentCnvAlg") )
if muonStandaloneFlags.doSegmentsOnly():
return
# Tracks builder
#
# add the algorithm (which uses the MuonTrackSteering)
#
TrackBuilder = CfgMgr.MuPatTrackBuilder("MuPatTrackBuilder", TrackSteering = getPublicTool("MuonTrackSteering") )
self.addAlg( TrackBuilder )
self.registerOutputKey("MuonSpectrometerTracks", self.MuPatTrackBuilder, "SpectrometerTrackOutputLocation")
self.registerInputKey ("MuonSegments", self.MuPatTrackBuilder, "MuonSegmentCollection" )
if muonStandaloneFlags.createTrackParticles():
xAODTrackParticleCnvAlg = MuonStandaloneTrackParticleCnvAlg("MuonStandaloneTrackParticleCnvAlg")
self.addAlg( xAODTrackParticleCnvAlg )
def addStandardJets(
jetalg,
rsize,
inputtype,
ptmin=2000,
ptminFilter=5000,
mods="calib",
calibOpt="none",
ghostArea=0.01,
algseq=None,
outputGroup="CustomJets",
exclusiveSubjetBuilderList=[],
**extraOptions
):
###############################################
# supported options in extraOptions:
# jetnamebase
# variableRMinRadius
# variableRMassScale
###############################################
# "jetnamebase" can be configured through extraOptions
if "jetnamebase" not in extraOptions.keys():
jetnamebase = "{0}{1}{2}".format(jetalg, int(rsize * 10), inputtype)
else:
jetnamebase = extraOptions["jetnamebase"]
jetname = jetnamebase + "Jets"
algname = "jetalg" + jetnamebase
OutputJets.setdefault(outputGroup, []).append(jetname)
# exclusive kt subjet builder list
if type(mods) is str:
mods = jtm.modifiersMap[mods]
for exclusiveSubjetBuilder in exclusiveSubjetBuilderList:
(subjetfinder, SubjetContainerName) = exclusiveSubjetBuilder(jetname)
mods += [subjetfinder]
# add subjet container to the output
OutputJets.setdefault(outputGroup, []).append(SubjetContainerName)
# return if the alg is already scheduled here :
if algseq is None:
print "No algsequence passed! Will not schedule", algname
return
elif cfgKeyStore.isInInput("xAOD::JetContainer", jetname):
print "Collection ", algname, "is already in input AOD!"
return
elif algname in DFJetAlgs:
if hasattr(algseq, algname):
print " Algsequence", algseq, "already has an instance of", algname
else:
print " Added", algname, "to sequence", algseq
algseq += DFJetAlgs[algname]
return DFJetAlgs[algname]
if not jetname in jtm.tools:
# Set default for the arguments to be passd to addJetFinder
finderArgs = dict(modifiersin=[], consumers=[])
finderArgs["ptmin"] = ptmin
finderArgs["ptminFilter"] = ptminFilter
finderArgs["ghostArea"] = ghostArea
# configs for variable-R
if ("variableRMinRadius" in extraOptions.keys()) and ("variableRMassScale" in extraOptions.keys()):
print "INFO: You are running varaible-R jets!"
finderArgs["variableRMinRadius"] = extraOptions["variableRMinRadius"]
finderArgs["variableRMassScale"] = extraOptions["variableRMassScale"]
# no container exist. simply build a new one.
if inputtype == "LCTopo":
finderArgs["modifiersin"] = mods
finderArgs["calibOpt"] = "none"
else:
# be careful here -- when inputtype is not "LCTopo", many modifers in "calib" will not work
# therefore, it is highly recommended to set mods=[], or something that you know that will work with non-calo type jet
print "Warning! Make sure you know what you are doing!"
print "Running addStandardJets for", jetname
print "Here is a list of modifiers:", mods
finderArgs["modifiersin"] = mods
# finderArgs.pop('modifiersin') # leave the default modifiers.
# map the input to the jtm code for PseudoJetGetter
getterMap = dict(LCTopo="lctopo", Truth="truth", TruthWZ="truthwz", PV0Track="pv0track")
# create the finder for the temporary collection.
finderTool = jtm.addJetFinder(
jetname, jetalg, rsize, getterMap[inputtype], **finderArgs # pass the prepared arguments
)
from JetRec.JetRecConf import JetAlgorithm
alg = JetAlgorithm(algname, Tools=[finderTool])
print " Added", algname, "to sequence", algseq
algseq += alg
DFJetAlgs[algname] = alg
def addStandardJets(jetalg,
rsize,
inputtype,
ptmin=2000,
ptminFilter=5000,
mods="calib",
calibOpt="none",
ghostArea=0.01,
algseq=None,
outputGroup="CustomJets",
exclusiveSubjetBuilderList=[],
**extraOptions):
###############################################
# supported options in extraOptions:
# jetnamebase
# variableRMinRadius
# variableRMassScale
###############################################
# "jetnamebase" can be configured through extraOptions
if 'jetnamebase' not in extraOptions.keys():
jetnamebase = "{0}{1}{2}".format(jetalg, int(rsize * 10), inputtype)
else:
jetnamebase = extraOptions['jetnamebase']
jetname = jetnamebase + "Jets"
algname = "jetalg" + jetnamebase
OutputJets.setdefault(outputGroup, []).append(jetname)
# exclusive kt subjet builder list
if type(mods) is str:
mods = jtm.modifiersMap[mods]
for exclusiveSubjetBuilder in exclusiveSubjetBuilderList:
(subjetfinder, SubjetContainerName) = exclusiveSubjetBuilder(jetname)
mods += [subjetfinder]
# add subjet container to the output
OutputJets.setdefault(outputGroup, []).append(SubjetContainerName)
# return if the alg is already scheduled here :
if algseq is None:
print "No algsequence passed! Will not schedule", algname
return
elif cfgKeyStore.isInInput("xAOD::JetContainer", jetname):
print "Collection ", algname, "is already in input AOD!"
return
elif algname in DFJetAlgs:
if hasattr(algseq, algname):
print " Algsequence", algseq, "already has an instance of", algname
else:
print " Added", algname, "to sequence", algseq
algseq += DFJetAlgs[algname]
return DFJetAlgs[algname]
if not jetname in jtm.tools:
# Set default for the arguments to be passd to addJetFinder
finderArgs = dict(modifiersin=[], consumers=[])
finderArgs['ptmin'] = ptmin
finderArgs['ptminFilter'] = ptminFilter
finderArgs['ghostArea'] = ghostArea
# configs for variable-R
if ("variableRMinRadius"
in extraOptions.keys()) and ("variableRMassScale"
in extraOptions.keys()):
print 'INFO: You are running varaible-R jets!'
finderArgs['variableRMinRadius'] = extraOptions[
'variableRMinRadius']
finderArgs['variableRMassScale'] = extraOptions[
'variableRMassScale']
# no container exist. simply build a new one.
if inputtype == "LCTopo":
finderArgs['modifiersin'] = mods
finderArgs['calibOpt'] = "none"
else:
# be careful here -- when inputtype is not "LCTopo", many modifers in "calib" will not work
# therefore, it is highly recommended to set mods=[], or something that you know that will work with non-calo type jet
print 'Warning! Make sure you know what you are doing!'
print 'Running addStandardJets for', jetname
print 'Here is a list of modifiers:', mods
finderArgs['modifiersin'] = mods
#finderArgs.pop('modifiersin') # leave the default modifiers.
# map the input to the jtm code for PseudoJetGetter
getterMap = dict(LCTopo='lctopo',
Truth='truth',
TruthWZ='truthwz',
PV0Track='pv0track')
# create the finder for the temporary collection.
finderTool = jtm.addJetFinder(
jetname,
jetalg,
rsize,
getterMap[inputtype],
**finderArgs # pass the prepared arguments
)
from JetRec.JetRecConf import JetAlgorithm
alg = JetAlgorithm(algname, Tools=[finderTool])
print " Added", algname, "to sequence", algseq
algseq += alg
DFJetAlgs[algname] = alg
# Schedules all tools needed for jet/MET analyses and writes the
# results into SG. These may then be accessed along the train
#********************************************************************
from DerivationFrameworkCore.DerivationFrameworkMaster import *
from JetRec.JetRecFlags import jetFlags
from AthenaCommon.GlobalFlags import globalflags
##################################################################
# Schedule common content for all jet-using derivations
##################################################################
jetFlags.eventShapeTools = []
from JetRec.JetRecStandard import jtm
from RecExConfig.ObjKeyStore import cfgKeyStore
if not cfgKeyStore.isInInput("xAOD::JetContainer", "AntiKt2PV0TrackJets"):
jtm.addJetFinder("AntiKt2PV0TrackJets",
"AntiKt",
0.2,
"pv0track",
ptmin=2000)
from JetRec.JetAlgorithm import addJetRecoToAlgSequence
addJetRecoToAlgSequence(DerivationFrameworkJob, eventShapeTools=None)
DFJetAlgs = {}
##################################################################
# Definitions of helper functions
##################################################################
# $Id: Lucid_RawDataD3PDObject.py 352093 2011-03-16 13:03:57Z mtibbett $
#
# @file BackgroundD3PDMaker/python/Lucid_RawDataD3PDObject.py
# @author Mark Tibbets <*****@*****.**>
# @date Feb, 2011
# @brief D3PD object for LUCID_RawData.
#
import D3PDMakerCoreComps
import BackgroundD3PDMaker
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
from RecExConfig.ObjKeyStore import cfgKeyStore
if cfgKeyStore.isInInput( "LUCID_RawDataContainer", "Lucid_RawData" ):
_haveLucid = True
else:
_haveLucid = False
from AthenaCommon.Logging import logging
_mlog = logging.getLogger( "Lucid_RawDataD3PDObject" )
_mlog.warning( "No LUCID_RawDataContainer object in input; skipping." )
Lucid_RawDataD3PDObject = \
make_SG_D3PDObject ('LUCID_RawDataContainer',
'Lucid_RawData',
'lucid_', 'Lucid_RawDataD3PDObject',
default_allowMissing = not _haveLucid )
if _haveLucid:
Lucid_RawDataD3PDObject.defineBlock (0, 'LucidPMTHits',
## because some of the following functions would add it with a lower
## detail level.
##
if triggerAvailable:
from TriggerD3PDMaker.TrigDecisionD3PDObject import TrigDecisionD3PDObject
d3pdalg += TrigDecisionD3PDObject(10)
pass
##
## Offline e/gamma information:
##
oflEgammaIncludes = ['ClusterKin']
from egammaD3PDMaker.ElectronD3PDObject import ElectronD3PDObject
added = False
for sgkey in D3PDMakerFlags.ElectronSGKey().split(","):
if cfgKeyStore.isInInput("ElectronContainer", sgkey):
d3pdalg += ElectronD3PDObject(1, include=oflEgammaIncludes)
added = True
break
pass
if not added:
TriggerD3PDStream_msg.warning("Offline electrons not found in input")
pass
from egammaD3PDMaker.PhotonD3PDObject import PhotonD3PDObject
added = False
for sgkey in D3PDMakerFlags.PhotonSGKey().split(","):
if cfgKeyStore.isInInput("PhotonContainer", sgkey):
d3pdalg += PhotonD3PDObject(1,
include=oflEgammaIncludes + ['Samplings'],
Samplings_Samplings=[2],
Samplings_WriteEnergy=False,
def egammaD3PD(alg=None,
trigalg=None,
level=10,
file='egamma.root',
tuplename='egamma',
**kw):
preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName())
createxAOD(preseq)
if not cfgKeyStore.isInInput('xAOD::ElectronContainer', 'AllElectrons'):
preseq += MergeElectrons()
# Core algorithm
# By default the user of this function should have created an algorithm already.
# But for backwards compatibility let the function create its own algorithm if
# needed...
if not alg:
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
alg = MSMgr.NewRootStream(tuplename, file)
alg += EventInfoD3PDObject(**_args(level, 'EventInfo', kw))
# Segregate trigger decision flags in a separate tree.
if not trigalg:
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
trigalg = MSMgr.NewRootStream(tuplename + ':' + tuplename + 'TrigDec',
FileName=file,
TreeName=tuplename + 'TrigDec')
trigalg += EventInfoD3PDObject(0)
alg.Stream.trigDecisionTree = trigalg
# Add bunch structure metadata.
from TriggerD3PDMaker.BunchStructureMetadata \
import addBunchStructureMetadata
addBunchStructureMetadata(alg)
alg += LArCollisionTimeD3PDObject(**_args(level, 'LArCollisionTime', kw))
alg += ElectronD3PDObject(**_args(
level, 'Electron', kw, EgammaJetSignedIPAndPTRel_target='jet_'))
alg += PhotonD3PDObject(**_args(level, 'Photon', kw))
# # Additional muon variables for Zg skims.
# if not MuonD3PDObject.allBlocknames().has_key("MuonScatteringAngleSignificance"):
# from AthenaCommon.AppMgr import ToolSvc
# muonScatteringSigTool=None
# if hasattr(ToolSvc, "MuonScatteringSigTool"):
# muonScatteringSigTool=ToolSvc.MuonScatteringSigTool
# from JetTagD3PDMaker import MuonScatteringAngleSignificanceFillerTool
# MuonD3PDObject.defineBlock (100, "MuonScatteringAngleSignificance",
# MuonScatteringAngleSignificanceFillerTool,
# ScatteringSigTool=muonScatteringSigTool)
alg += MuonD3PDObject(**_args(
10,
'Muons',
kw,
sgkey='StacoMuonCollection,Muons',
prefix='mu_',
include=[
"EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex",
"L1InfoIndex", "MuonScatteringAngleSignificance"
],
exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing=True))
alg += JetD3PDObject(
**_args(0, 'Jet', kw, include=['JetQual', 'DQMoments']))
alg += MBTSD3PDObject(**_args(level, 'MBTS', kw))
alg += MBTSTimeD3PDObject(**_args(level, 'MBTSTime', kw))
# alg += MBTSTriggerBitsD3PDObject (**_args (level, 'MBTSTriggerBits', kw))
# alg += ZDCTriggerBitsD3PDObject (**_args (level, 'ZDCTriggerBits', kw))
alg += CollisionDecisionD3PDObject(**_args(level, 'CollisionDecision', kw))
alg += MissingETD3PDObject(**_args(level,
'MissingET',
kw,
sgkey='MET_Core_AntiKt4EMTopo',
prefix='MET_RefFinal_'))
if D3PDMakerFlags.DoTrigger():
from TriggerD3PDMaker.TrigDecisionD3PDObject \
import TrigDecisionD3PDObject
alg += TrigDecisionD3PDObject(**_args(2, 'TrigDecision', kw))
#TrigEgammaD3PDObjects (alg, **_args (1, 'TrigEgamma', kw,
# TrigEMCluster_level = 2))
# from TriggerD3PDMaker.EnergySumROID3PDObject import EnergySumROID3PDObject
# from TrigMissingETD3PDMaker.TrigMETD3PDObject import TrigMETD3PDObject
# alg += EnergySumROID3PDObject(**_args (level, 'EnergySumROI', kw,
# prefix = "trig_L1_esum_",
# allowMissing = True))
# # The LVL2 information:
# alg += TrigMETD3PDObject(**_args( level, 'TrigMETL2', kw,
# prefix = "trig_L2_met_",
# sgkey = "HLT_T2MissingET" ))
# if cfgKeyStore.isInInputFile( "TrigMissingETContainer", "HLT_L2MissingET_FEB" ):
# alg += TrigMETD3PDObject(**_args( level, 'TrigMETL2_FEB', kw,
# prefix = "trig_L2_feb_met_",
# sgkey = "HLT_L2MissingET_FEB" ))
# # The EF information:
# alg += TrigMETD3PDObject(**_args ( level, 'TrigMETEF', kw,
# prefix = "trig_EF_met_",
# sgkey = "HLT_TrigEFMissingET" ))
# from TriggerD3PDMaker.BGCodeD3PDObject import BGCodeD3PDObject
# alg += BGCodeD3PDObject (**_args (2, 'BGCode', kw))
# May be missing in single-beam data.
alg += PrimaryxAODVertexD3PDObject(**_args(
1,
'PrimaryVertex',
kw,
#allowMissing = True,
sgkey=D3PDMakerFlags.VertexSGKey(),
prefix='vxp_',
storeVertexTrackIndexAssociation=False,
storeVertexTrackAssociation=True,
storeDiagonalCovarianceAsErrors=True))
if rec.doTruth():
from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject
alg += TruthMuonD3PDObject(**_args(level, 'TruthMuon', kw))
alg += TruthEventD3PDObject(**_args(1, 'TruthEvent', kw))
alg += TruthParticleD3PDObject(**_args(level, 'TruthParticle', kw))
# alg.MetadataTools += [LBMetadataConfig()]
# if D3PDMakerFlags.FilterCollCand():
# from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg
# alg.filterSeq += CollisionFilterAlg (tuplename + '_CollCandFilter')
return alg
UnassociatedHitsGetter = unassociatedHitsGetterTool,
ContainerName = "EventInfo",
DecorationPrefix = prefixName,
OutputLevel =INFO)
ToolSvc += unassociatedHitsDecorator
augmentationTools+=[unassociatedHitsDecorator]
if (printIdTrkDxAODConf):
print unassociatedHitsDecorator
print unassociatedHitsDecorator.properties()
# Add LArCollisionTime augmentation tool
if dumpLArCollisionTime:
from LArCellRec.LArCollisionTimeGetter import LArCollisionTimeGetter
from RecExConfig.ObjKeyStore import cfgKeyStore
# We can only do this if we have the cell container.
if cfgKeyStore.isInInput ('CaloCellContainer', 'AllCalo'):
LArCollisionTimeGetter (topSequence)
from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__LArCollisionTimeDecorator
lArCollisionTimeDecorator = DerivationFramework__LArCollisionTimeDecorator (name ='lArCollisionTimeDecorator',
ContainerName = "EventInfo",
DecorationPrefix = prefixName+"LArCollTime_",
OutputLevel =INFO)
ToolSvc += lArCollisionTimeDecorator
augmentationTools+=[lArCollisionTimeDecorator]
if (printIdTrkDxAODConf):
print lArCollisionTimeDecorator
print lArCollisionTimeDecorator.properties()
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id: TrigOperationalInfoD3PDObject.py 338058 2010-12-20 13:20:43Z krasznaa $
#
# D3PD object capable of saving the names of the chains which caused an event to
# end up in the express stream. Should only be useful for producing first trigger
# efficiency plots out of express stream data.
#
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
import TriggerD3PDMaker
# This object can only be used on express stream (D)ESD files. So let's check
# whether the source object is available, because most of the time it isn't.
from RecExConfig.ObjKeyStore import cfgKeyStore
if cfgKeyStore.isInInput( "TrigOperationalInfoCollection", "HLT_EXPRESS_OPI_EF" ):
_haveOpInfo = True
else:
_haveOpInfo = False
from AthenaCommon.Logging import logging
_mlog = logging.getLogger( "TrigOperationalInfoD3PDObject" )
_mlog.warning( "No TrigOperationalInfoCollection object in input; skipping." )
TrigOperationalInfoD3PDObject = make_SG_D3PDObject( "TrigOperationalInfoCollection",
"HLT_EXPRESS_OPI_EF",
"trig_express_",
"TrigOperationalInfoD3PDObject",
default_allowMissing = not _haveOpInfo )
if _haveOpInfo:
TrigOperationalInfoD3PDObject.defineBlock( 0, "ExpressChains",
UnassociatedHitsGetter=unassociatedHitsGetterTool,
ContainerName="EventInfo",
DecorationPrefix=prefixName,
OutputLevel=INFO)
ToolSvc += unassociatedHitsDecorator
augmentationTools += [unassociatedHitsDecorator]
if (printIdTrkDxAODConf):
print unassociatedHitsDecorator
print unassociatedHitsDecorator.properties()
# Add LArCollisionTime augmentation tool
if dumpLArCollisionTime:
from RecExConfig.ObjKeyStore import cfgKeyStore
# We can only do this if we have the cell container.
if cfgKeyStore.isInInput('CaloCellContainer', 'AllCalo'):
from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__LArCollisionTimeDecorator
lArCollisionTimeDecorator = DerivationFramework__LArCollisionTimeDecorator(
name='NCBlArCollisionTimeDecorator',
ContainerName="EventInfo",
DecorationPrefix=prefixName + "LArCollTime_",
OutputLevel=INFO)
ToolSvc += lArCollisionTimeDecorator
augmentationTools += [lArCollisionTimeDecorator]
if (printIdTrkDxAODConf):
print lArCollisionTimeDecorator
print lArCollisionTimeDecorator.properties()
#====================================================================
def JetVarToolConfig(seq=AlgSequence):
from RecExConfig.ObjKeyStore import cfgKeyStore
if (cfgKeyStore.isInInput('CaloCellContainer', 'AllCalo')
and cfgKeyStore.isInInput('CaloCellLinkContainer',
'CaloCalTopoCluster_Link')):
from JetRec.JetMomentGetter import make_JetMomentGetter
from JetRec.JetRecFlags import jetFlags
from CaloClusterCorrection.StandardCellWeightCalib import getCellWeightTool
cellcalibtool = getCellWeightTool('Kt',
0.4,
'Topo',
onlyCellWeight=True)
jetFlags.doJVF = False ##the following jet getter seems to fail if we don't deactivate the jet vertex finder.
#make_StandardJetGetter('AntiKt',0.4,'Topo',disable=False, doCalib=True, calibName='H1NumInv', outputCollectionName='AntiKt4TopoJets',seq=seq)
#make_StandardJetGetter('AntiKt',0.6,'Topo',disable=False, doCalib=True, calibName='H1NumInv', outputCollectionName='AntiKt6TopoJets',seq=seq)
# MB: April 19, 2011, Suggested fix from SS
make_StandardJetGetter('AntiKt',
0.4,
'Topo',
disable=False,
doCalib=True,
calibName='EM:H1NumInv',
outputCollectionName='AntiKt4TopoJets',
seq=seq)
make_StandardJetGetter('AntiKt',
0.6,
'Topo',
disable=False,
doCalib=True,
calibName='EM:H1NumInv',
outputCollectionName='AntiKt6TopoJets',
seq=seq)
# MB: April 7, 2011 : Suggested fix from SS
from JetMomentTools.JetMomentToolsConf import \
JetBadChanCorrTool, JetBadCellCorrTool, JetCaloQualityTool
atool4 = JetBadChanCorrTool("JetBadChanCorrTool_anti04",
ConeDr=0.4,
UseCalibScale=False)
atool4.CellCalibrator = cellcalibtool
atool6 = JetBadChanCorrTool("JetBadChanCorrTool_anti06",
ConeDr=0.6,
UseCalibScale=False)
atool6.CellCalibrator = cellcalibtool
#atool4 = JetBadChanCorrTool("JetBadChanCorrTool_anti04",UpdateEvery=False,ConeDr=0.4,UseCalibScale=False)
#atool4.CellCalibrator = cellcalibtool
#atool6 = JetBadChanCorrTool("JetBadChanCorrTool_anti06",UpdateEvery=False,ConeDr=0.6,UseCalibScale=False)
#atool6.CellCalibrator = cellcalibtool
cqual_tool = JetCaloQualityTool("CaloQualTool")
cqual_tool.doSamplingBasedVariables = True
cqual_tool.doCellBasedVariables = True
BadCellCorrT = JetBadCellCorrTool("JetBadCellCorrTool")
BadCellCorrT.CellCalibrator = cellcalibtool
##print BadCellCorrT
##toolist += [BadCellCorrT]
make_JetMomentGetter("AntiKt4TopoJets",
[atool4, cqual_tool, BadCellCorrT],
seq=seq)
make_JetMomentGetter("AntiKt6TopoJets",
[atool6, cqual_tool, BadCellCorrT],
seq=seq)
else:
from AthenaCommon.Logging import logging
log = logging.getLogger('MissingETGoodness')
log.warning('No cells; not rebuilding jets.')
###############################################
jet_collection_key = 'AntiKt4TopoJets'
if cfgKeyStore.isInInput('JetCollection', 'AntiKt4TopoEMJets'):
jet_collection_key = 'AntiKt4TopoEMJets'
truth_jet_collection_key = 'Cone4TruthJets'
if cfgKeyStore.isInInput('JetCollection', 'AntiKt4TruthJets'):
truth_jet_collection_key = 'AntiKt4TruthJets'
from MissingETGoodness.MissingETGoodnessConf import JetVarTool as ConfiguredJetVarTool
JetVarTool = ConfiguredJetVarTool(
JetCollectionKey=jet_collection_key,
JetTruthCollectionKey=truth_jet_collection_key,
TrackParticleContainerKey='TrackParticleCandidate',
)
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += JetVarTool
print JetVarTool
#
# D3PD object saving the CTP_RDO information into the D3PD
# Note that this can only be used on ESD files (or if back-navigation
# is active...)
#
import D3PDMakerCoreComps
from D3PDMakerCoreComps.D3PDObject import D3PDObject
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
import TriggerD3PDMaker
# This object can only be used on (D)ESD files, when the CTP_RDO object is
# available:
from RecExConfig.ObjKeyStore import cfgKeyStore
if cfgKeyStore.isInInput("CTP_RDO", "CTP_RDO"):
_haveRDO = True
else:
_haveRDO = False
from AthenaCommon.Logging import logging
_mlog = logging.getLogger("CTPD3PDObject")
_mlog.warning("No CTP_RDO object in input; skipping.")
CTPD3PDObject = make_SG_D3PDObject("CTP_RDO",
"CTP_RDO",
"ctp_",
"CTPD3PDObject",
default_allowMissing=not _haveRDO)
if _haveRDO:
CTPD3PDObject.defineBlock(0, "RDOInfo", TriggerD3PDMaker.CTP_RDOFillerTool)
# results into SG. These may then be accessed along the train
# ********************************************************************
from DerivationFrameworkCore.DerivationFrameworkMaster import *
from JetRec.JetRecFlags import jetFlags
from AthenaCommon.GlobalFlags import globalflags
##################################################################
# Schedule common content for all jet-using derivations
##################################################################
jetFlags.eventShapeTools = []
from JetRec.JetRecStandard import jtm
from RecExConfig.ObjKeyStore import cfgKeyStore
if not cfgKeyStore.isInInput("xAOD::JetContainer", "AntiKt2PV0TrackJets"):
jtm.addJetFinder("AntiKt2PV0TrackJets", "AntiKt", 0.2, "pv0track", ptmin=2000)
from JetRec.JetAlgorithm import addJetRecoToAlgSequence
addJetRecoToAlgSequence(DerivationFrameworkJob, eventShapeTools=None)
DFJetAlgs = {}
##################################################################
# Definitions of helper functions
##################################################################
def defineEDAlg(R=0.4, inputtype="LCTopo"):
from EventShapeTools.EventDensityConfig import configEventDensityTool, EventDensityAlg
from AthenaCommon.AppMgr import ToolSvc