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 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 JetTileD3PD(file,
level=4,
tuplename='MyTuple',
seq=topSequence,
D3PDSvc='D3PD::RootD3PDSvc',
streamNameRoot=None,
**kw):
alg = D3PDMakerCoreComps.MakerAlg(tuplename,
seq,
file=file,
D3PDSvc=D3PDSvc,
streamNameRoot=streamNameRoot)
JetIncludes = ['AssocTrackCont']
alg += EventInfoD3PDObject(**_args(level, 'EventInfo', kw))
alg += JetTileD3PDObject(**_args(
level, inputSGkey, kw, sgkey=inputSGkey, prefix='AntiKt4Topo_'))
from TriggerD3PDMaker.BGCodeD3PDObject import BGCodeD3PDObject
from TriggerD3PDMaker.BunchStructureMetadata import addBunchStructureMetadata
alg += BGCodeD3PDObject(**_args(2, 'BGCode', kw))
addBunchStructureMetadata(alg)
from TriggerD3PDMaker.TrigDecisionD3PDObject import TrigDecisionD3PDObject
from TriggerD3PDMaker.TrigConfMetadata import addTrigConfMetadata
alg += TrigDecisionD3PDObject(**_args(10, 'TrigDecision', kw))
addTrigConfMetadata(alg)
if D3PDMakerFlags.DoTrigger():
alg += jetMETTriggerBitsD3PDObject(level)
from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags
TrackD3PDFlags.storeVertexTrackIndexAssociation.set_Value_and_Lock(False)
TrackD3PDFlags.storeVertexTrackAssociation.set_Value_and_Lock(False)
TrackD3PDFlags.storeVertexFitQuality.set_Value_and_Lock(False)
from TrackD3PDMaker.xAODVertexD3PDObject import PrimaryxAODVertexD3PDObject
alg += PrimaryxAODVertexD3PDObject(
**_args(0,
'PrimaryVertex',
kw,
allowMissing=True,
sgkey=D3PDMakerFlags.VertexSGKey(),
prefix='vxp_'))
if rec.doTruth():
alg += GenEventD3PDObject(**_args(1, 'GenEvent', kw))
alg += TruthParticleD3PDObject(**_args(1, 'TruthParticle', kw))
alg += JetTileD3PDObject(**_args(1,
'AntiKt4TruthJets',
kw,
sgkey='AntiKt4TruthJets',
prefix='AntiKt4Truth_'))
alg.MetadataTools += [LBMetadataConfig()]
return alg
def JetD3PD(file,
level=4,
tuplename='jet',
seq=topSequence,
D3PDSvc='D3PD::RootD3PDSvc',
streamNameRoot=None,
**kw):
alg = D3PDMakerCoreComps.MakerAlg(tuplename,
seq,
file=file,
D3PDSvc=D3PDSvc,
streamNameRoot=streamNameRoot)
JetIncludes = ['AssocTrackCont']
alg += EventInfoD3PDObject(**_args(level, 'EventInfo', kw))
alg += ElectronD3PDObject(**_args(level, 'Electron', kw))
alg += PhotonD3PDObject(**_args(level, 'Photon', kw))
alg += MuonD3PDObject(**_args(level, 'Muon', kw))
#alg += MissingETD3PDObject (**_args (level, 'MissingET', kw))
#at the moment only the first one holds also b tagging information
alg += JetD3PDObject(**_args(level,
'AntiKt4H1TopoJets',
kw,
sgkey='AntiKt4H1TopoJets',
prefix='AntiKt4H1Topo_'))
alg += JetD3PDObject(**_args(level,
'AntiKt6H1TopoJets',
kw,
sgkey='AntiKt6H1TopoJets',
prefix='AntiKt6H1Topo_'))
if D3PDMakerFlags.DoTrigger():
alg += jetMETTriggerBitsD3PDObject(level)
alg += PrimaryVertexD3PDObject(**_args(1,
'PrimaryVertex',
kw,
allowMissing=True,
sgkey=D3PDMakerFlags.VertexSGKey(),
prefix='vxp_'))
if rec.doTruth():
alg += GenEventD3PDObject(**_args(1, 'GenEvent', kw))
alg += TruthParticleD3PDObject(**_args(1, 'TruthParticle', kw))
alg += JetD3PDObject(**_args(1,
'AntiKt4TruthJets',
kw,
sgkey='AntiKt4TruthJets',
prefix='AntiKt4Truth_'))
#alg += JetD3PDObject (level, sgkey='AntiKt6TruthJets', prefix='AntiKt6Truth_' )
alg.MetadataTools += [LBMetadataConfig()]
return alg
def egammaTimeCorrConfig \
(seq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()),
prefix = '',
sgkey = D3PDMakerFlags.ElectronSGKey(),
typeName = 'DataVector<xAOD::Electron_v1>',
allowMissing = False):
"""Configure egammaTimeCorrAlg for D3PD making.
SEQ is the Gaudi sequence to which the algorithm should be added.
Default is that given by PreD3PDAlgSeqName.
PREFIX is a prefix to add to the name of the algorithm scheduled.
SGKEY/TYPENAME is the StoreGate key of the input electron container
and the name of its type.
If ALLOWMISSING is true, don't fail if the SG key doesn't exist.
"""
if (not D3PDMakerFlags.MakeEgammaUserData() or
D3PDMakerFlags.HaveEgammaUserData()):
return
DVGetter = D3PDMakerCoreComps.SGDataVectorGetterTool
resolved_sgkey = resolveSGKey (typeName, sgkey)
auxprefix = (D3PDMakerFlags.EgammaUserDataPrefix() + '_' +
resolved_sgkey + '_')
algName = 'egammaTimeCorrAlg' + resolved_sgkey
if not hasattr (seq, algName):
from IOVDbSvc.CondDB import conddb
conddb.addFolder("LAR_OFL","/LAR/TimeCorrectionOfl/NonRunCon <tag>LARTimeCorrectionOflNonRunCon-00</tag>",force=True)
conddb.addFolder("LAR_OFL","/LAR/TimeCorrectionOfl/RunCon <tag>LARTimeCorrectionOflRunCon-00</tag>",force=True)
from CaloClusterCorrection.CaloClusterTimeTool import GetCaloClusterTimeTool
myCaloClusterTimeTool=GetCaloClusterTimeTool("caloClusterTimeTool", "/LAR/TimeCorrectionOfl/NonRunCon","/LAR/TimeCorrectionOfl/RunCon")
seq += egammaD3PDAnalysis.egammaTimeCorrAlg \
(algName,
Getter = DVGetter
(prefix + 'egammaTimeCorrGetter',
TypeName = typeName,
SGKey = sgkey),
AllowMissing = allowMissing,
AuxPrefix = auxprefix,
CaloClusterTimeTool = myCaloClusterTimeTool,
)
return
def TileGapConfig \
(seq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()),
prefix = '',
sgkey = 'egClusterCollection',
typeName = 'DataVector<xAOD::CaloCluster_v1>',
allowMissing = False):
"""Configure egammaMaxECellAlg for D3PD making.
SEQ is the Gaudi sequence to which the algorithm should be added.
Default is that given by PreD3PDAlgSeqName.
PREFIX is a prefix to add to the name of the algorithm scheduled.
SGKEY/TYPENAME is the StoreGate key of the input electron container
and the name of its type.
If ALLOWMISSING is true, don't fail if the SG key doesn't exist.
"""
if (not D3PDMakerFlags.MakeEgammaUserData() or
D3PDMakerFlags.HaveEgammaUserData()):
return
DVGetter = D3PDMakerCoreComps.SGDataVectorGetterTool
resolved_sgkey = resolveSGKey (typeName, sgkey)
auxprefix = (D3PDMakerFlags.EgammaUserDataPrefix() + '_' +
resolved_sgkey + '_')
algName = 'TileGapSumAlg' + resolved_sgkey
if not hasattr (seq, algName):
gapsel = TileGapSelectionGetter (seq)
myAlg = egammaD3PDAnalysis.TileGapSumAlg \
(algName,
ClusterGetter = DVGetter
(prefix + 'TileGapAlgGetter',
TypeName = typeName,
SGKey = sgkey),
CellGetter = SGDataVectorGetterTool
(prefix + 'TileGapAlgCellGetter',
SGKey = gapsel.outputKey(),
TypeName = gapsel.outputType()),
AllowMissing = allowMissing,
AuxPrefix = auxprefix,)
seq += myAlg
return
def PhotonTruthConfig \
(seq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()),
prefix = '',
sgkey = D3PDMakerFlags.ElectronSGKey(),
typeName = 'ElectronContainer',
allowMissing = False):
"""Configure PhotonTruthAlg for D3PD making.
SEQ is the Gaudi sequence to which the algorithm should be added.
Default is that given by PreD3PDAlgSeqName.
PREFIX is a prefix to add to the name of the algorithm scheduled.
SGKEY/TYPENAME is the StoreGate key of the input electron container
and the name of its type.
If ALLOWMISSING is true, don't fail if the SG key doesn't exist.
"""
if not rec.doTruth():
return
if (not D3PDMakerFlags.MakeEgammaUserData() or
D3PDMakerFlags.HaveEgammaUserData()):
return
DVGetter = D3PDMakerCoreComps.SGDataVectorGetterTool
resolved_sgkey = resolveSGKey (typeName, sgkey)
auxprefix = (D3PDMakerFlags.EgammaUserDataPrefix() + '_' +
resolved_sgkey + '_')
from TruthD3PDMaker.MCTruthClassifierConfig \
import D3PDMCTruthClassifier
ptaname = 'PhotonTruthAlg_' + resolved_sgkey
if not hasattr (seq, ptaname):
seq += egammaD3PDAnalysis.PhotonTruthAlg \
(ptaname,
PhotonGetter = DVGetter
(prefix + 'PhotonTruthAlgGetter',
TypeName = typeName,
SGKey = sgkey),
AllowMissing = allowMissing,
AuxPrefix = auxprefix,
TruthTool = egammaD3PDAnalysis.PhotonTruthTool
('D3PD__PhotonTruthTool',
Classifier = D3PDMCTruthClassifier))
return
def makeD3PDObject(name,
prefix,
object_name,
getter=None,
sgkey=None,
label=None):
if sgkey == None: sgkey = "LArHits"
if label == None: label = prefix
if prefix == "hitemb_":
sgkey = "LArHitEMB"
elif prefix == "hitemec_":
sgkey = "LArHitEMEC"
elif prefix == "hithec_":
sgkey = "LArHitHEC"
elif prefix == "hitfcal_":
sgkey = "LArHitFCAL"
if not getter:
getter = CaloSysD3PDMaker.LArHitContainerGetterTool \
(name + '_Getter',
TypeName = 'LArHitContainer',
SGKey = sgkey,
Label = label)
return D3PDMakerCoreComps.VectorFillerTool (name,
Prefix = prefix,
Getter = getter,
ObjectName = object_name,
SaveMetadata = \
D3PDMakerFlags.SaveObjectMetadata())
def makeCellD3PDObject(name,
prefix,
object_name,
getter=None,
sgkey=None,
label=None):
if sgkey == None: sgkey = 'AllCalo'
if label == None: label = prefix
if prefix in prefix_to_det.keys():
sgkey = prefix
#print " makeCellD3PDObject: sgkey = ", sgkey
if not getter:
getter = D3PDMakerCoreComps.SGDataVectorGetterTool \
(name + '_Getter',
TypeName = 'CaloCellContainer',
SGKey = sgkey,
Label = label)
# create the selected cells
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
return D3PDMakerCoreComps.VectorFillerTool (name,
Prefix = prefix,
Getter = getter,
ObjectName = object_name,
SaveMetadata = \
D3PDMakerFlags.SaveObjectMetadata())
def BuildVertexD3PDObject(_prefix='vx_',
_label='vx',
_sgkey=D3PDMakerFlags.VertexSGKey(),
_object_name='PrimaryVertexD3PDObject',
trackTarget='trk',
trackPrefix='trk_',
trackType='Rec::TrackParticleContainer'):
object = make_SGDataVector_D3PDObject (
'VxContainer',
_sgkey,
_prefix,
_object_name,
default_allowMissing = True,
allow_args = ['storeVertexTrackAssociation',
'storeVertexTrackIndexAssociation',
'storeDiagonalCovarianceAsErrors',
'storeVertexType',
'storeVertexFitQuality',
'storeVertexKinematics',
'storeVertexPurity',
'vertexPositionLevelOfDetails',
'doTruth'])
DefineVertexD3PDObject(object,
trackTarget,
trackPrefix,
trackType)
return object
def make_obj (name, prefix, object_name):
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
return D3PDMakerCoreComps.VoidObjFillerTool (name,
Prefix = prefix,
ObjectName = object_name,
SaveMetadata = \
D3PDMakerFlags.SaveObjectMetadata())
def _larCollTimeAlgHook(c,
seq=AlgSequence(
D3PDMakerFlags.PreD3PDAlgSeqName()),
*args,
**kw):
LArCollisionTimeGetter(seq)
return
def make_JetTagJet_D3PDObject(name,
prefix,
object_name,
sgkey,
label,
allowMissing=False,
**kw):
getter = D3PDMakerCoreComps.SGDataVectorGetterTool(
name + '_Getter', SGKey=sgkey, TypeName='JetCollection', Label=label)
defs = kw
# select valid argument for VectorFillerTool
# needed to remove argument for the hook function
for k in defs.keys():
if not hasattr(D3PDMakerCoreComps.VectorFillerTool, k):
del defs[k]
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
return D3PDMakerCoreComps.VectorFillerTool (name,
Prefix = prefix,
Getter = getter,
ObjectName = object_name,
AllowMissing=allowMissing,
SaveMetadata = \
D3PDMakerFlags.SaveObjectMetadata(),
**defs)
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 makeTruthTrackD3PDObject (name, prefix, object_name, getter = None,
sgkey = "TruthEvent,GEN_AOD",
typename = 'McEventCollection',
label = 'mc'):
if not getter:
from InDetD3PDMaker import TruthTrackGetterTool
getter = TruthTrackGetterTool (name + '_Getter',
SGKey = sgkey,
TypeName = typename,
Label = label,
KeepOnlyPrimaryParticles = False,
KeepOnlyChargedParticles = False,
KeepV0 = True,
TrueTrackPtCut = 0,
TrueTrackEtaCut = 99999.,
MaxRAll = 2000000,
MaxZAll = 2000000,
MaxRPrimary = 25,
MaxZPrimary = 200)
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
return D3PDMakerCoreComps.VectorFillerTool (name, Prefix = prefix,
Getter = getter,
ObjectName = object_name,
SaveMetadata = \
D3PDMakerFlags.SaveObjectMetadata())
def makeV0D3PDObject(name,
prefix,
object_name,
getter=None,
sgkey=_sgkey,
label=_label):
if sgkey == None:
sgkey = 'SimpleV0Candidates'
if label == None:
label = prefix
if not getter:
from InDetD3PDMaker import V0ContainerGetterTool
getter = V0ContainerGetterTool\
(name + '_Getter',
TypeName = 'V0Container',
SGKey = sgkey,
Label = label)
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
return D3PDMakerCoreComps.VectorFillerTool (name,
Prefix = prefix,
Getter = getter,
ObjectName = object_name,
AllowMissing = True,
SaveMetadata = \
D3PDMakerFlags.SaveObjectMetadata())
def __vertexReco(c, **kw):
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from AthenaCommon.AlgSequence import AlgSequence
from HSG2VertexCreation.HSG2VertexReconstruction import HSG2VertexReconstruction
HSG2VertexReconstruction("HSG2VertexReconstruction",
AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()))
return
def makeTowerD3PDObject(name,
prefix,
object_name='TowerD3PDObject',
getter=None,
sgkey=None,
label=None):
if sgkey == None: sgkey = 'CombinedTower'
if label == None: label = prefix
ContainerType = 'CaloTowerContainer'
if sgkey == 'TopoTower': ContainerType = 'CaloTopoTowerContainer'
print " makeTowerD3PDObject: name = ", name
print " makeTowerD3PDObject: prefix = ", prefix
print " makeTowerD3PDObject: object_name = ", object_name
print " makeTowerD3PDObject: sgkey = ", sgkey
if not getter:
getter = D3PDMakerCoreComps.SGDataVectorGetterTool \
(name + '_Getter',
TypeName = ContainerType,
SGKey = sgkey,
Label = label)
# create the selected cells
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
return D3PDMakerCoreComps.VectorFillerTool (name,
Prefix = prefix,
Getter = getter,
ObjectName = object_name,
SaveMetadata = \
D3PDMakerFlags.SaveObjectMetadata())
def make_obj(name,
prefix,
object_name,
getter=None,
sgkey=None,
filter=default_filter,
label=default_label,
**kw):
if sgkey == None: sgkey = default_sgkey
if label == None: label = TruthD3PDKeys.GenEventGetterLabel()
if getter == None:
getter = TruthD3PDMaker.GenEventGetterTool(name + '_Getter',
Label=label,
Selector=filter,
SGKey=sgkey)
defs = other_defaults.copy()
defs.update(kw)
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
return D3PDMakerCoreComps.VectorFillerTool( name,
Prefix = prefix,
Getter = getter,
ObjectName = object_name,
SaveMetadata = \
D3PDMakerFlags.SaveObjectMetadata(),
**defs )
def _electronAlgHook(c,
prefix,
sgkey,
typeName,
seq=AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()),
*args,
**kw):
ElectronUserDataConfig(seq=seq,
prefix=prefix,
sgkey=sgkey,
typeName=typeName)
from PhotonAnalysisUtils.PhotonAnalysisUtilsFlags import jobproperties
# set some options here.
jobproperties.PhotonAnalysisUtilsFlags.DumpNtuple = False
jobproperties.PhotonAnalysisUtilsFlags.DumpHistograms = False
if hasattr(jobproperties.PhotonAnalysisUtilsFlags, 'DumpTimeDifference'):
jobproperties.PhotonAnalysisUtilsFlags.DumpTimeDifference = False
jobproperties.PhotonAnalysisUtilsFlags.AlgSequence = seq.getName()
jobproperties.PhotonAnalysisUtilsFlags.DoReRunJetFinding = True
# probably a few more need to be set
rlist = release_version()
if rlist == None:
# Assume an old version if no version string was stored.
jobproperties.PhotonAnalysisUtilsFlags.ProductionRelease = 15.0
elif rlist:
jobproperties.PhotonAnalysisUtilsFlags.ProductionRelease = \
rlist[0] + float(rlist[1])/10
#commented out PUU
#from PhotonAnalysisUtils.PhotonAnalysisUtilsGetter import PhotonAnalysisUtilsGetter
#pau = PhotonAnalysisUtilsGetter()
return
def makeTileD3PDObject(name,
prefix,
object_name='TileDetailsD3PDObject',
getter=None,
sgkey=None,
label=None):
global BaseSGKey
BaseSGKey = sgkey
sgkey = prefix
if label == None: label = prefix
print " makeTileD3PDObject: name = ", name
print " makeTileD3PDObject: prefix = ", prefix
print " makeTileD3PDObject: object_name = ", object_name
print " makeTileD3PDObject: sgkey = ", sgkey
if not getter:
getter = D3PDMakerCoreComps.SGDataVectorGetterTool \
(name + '_Getter',
TypeName = 'CaloCellContainer',
SGKey = sgkey,
Label = label)
# create the selected cells
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
return D3PDMakerCoreComps.VectorFillerTool (name,
Prefix = prefix,
Getter = getter,
ObjectName = object_name,
SaveMetadata = \
D3PDMakerFlags.SaveObjectMetadata())
def makeTileCosmicMuonD3PDObject (name, prefix, object_name='TileCosmicMuonD3PDObject', getter = None,
sgkey = None,
label = None):
if sgkey == None: sgkey = 'TileCosmicMuonHT'
if label == None: label = prefix
print " makeTileCosmicMuonD3PDObject: name = ", name
print " makeTileCosmicMuonD3PDObject: prefix = ", prefix
print " makeTileCosmicMuonD3PDObject: object_name = ", object_name
print " makeTileCosmicMuonD3PDObject: sgkey = ", sgkey
if not getter:
getter = D3PDMakerCoreComps.SGDataVectorGetterTool \
(name + '_Getter',
TypeName = 'TileCosmicMuonContainer',
SGKey = sgkey,
Label = label)
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
return D3PDMakerCoreComps.VectorFillerTool (name,
Prefix = prefix,
Getter = getter,
ObjectName = object_name,
SaveMetadata = \
D3PDMakerFlags.SaveObjectMetadata())
def make_TwoTrackVertex_D3PDObject(
name,
prefix,
object_name,
sgkey,
label=JetTagD3PDKeys.JFTwoTrackVertexGetterLabel(),
allowMissing=False,
**kw):
getter = D3PDMakerCoreComps.SGDataVectorGetterTool(
name + '_Getter',
SGKey=sgkey,
TypeName='JetTagTwoTrackVertexDataHolder',
Label=label)
defs = kw
for k in defs.keys():
if not hasattr(D3PDMakerCoreComps.VectorFillerTool, k):
del defs[k]
if not defs.has_key("SaveMetadata"):
defs["SaveMetadata"] = D3PDMakerFlags.SaveObjectMetadata()
return D3PDMakerCoreComps.VectorFillerTool(name,
Prefix=prefix,
Getter=getter,
ObjectName=object_name,
AllowMissing=allowMissing,
**defs)
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 egammaDeltaEmax2Config \
(seq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()),
prefix = '',
sgkey = D3PDMakerFlags.ElectronSGKey(),
typeName = 'DataVector<xAOD::Electron_v1>',
allowMissing = False):
"""Configure egammaDeltaEmax2Alg for D3PD making.
SEQ is the Gaudi sequence to which the algorithm should be added.
Default is that given by PreD3PDAlgSeqName.
PREFIX is a prefix to add to the name of the algorithm scheduled.
SGKEY/TYPENAME is the StoreGate key of the input electron container
and the name of its type.
If ALLOWMISSING is true, don't fail if the SG key doesn't exist.
"""
if (not D3PDMakerFlags.MakeEgammaUserData() or
D3PDMakerFlags.HaveEgammaUserData()):
return
DVGetter = D3PDMakerCoreComps.SGDataVectorGetterTool
resolved_sgkey = resolveSGKey (typeName, sgkey)
auxprefix = (D3PDMakerFlags.EgammaUserDataPrefix() + '_' +
resolved_sgkey + '_')
emax2name = 'DeltaEmax2Alg_' + resolved_sgkey
if not hasattr (seq, emax2name):
highlum = False
if typeName == 'ElectronContainer':
from AthenaCommon.BeamFlags import jobproperties
if jobproperties.Beam.numberOfCollisions() >= 20 :
highlum = True
seq += egammaD3PDAnalysis.egammaDeltaEmax2Alg \
(emax2name,
Getter = DVGetter
(prefix + 'DeltaEmax2Getter',
TypeName = typeName,
SGKey = sgkey),
AllowMissing = allowMissing,
HighLum = highlum,
AuxPrefix = auxprefix)
return
def _electronRawClusterAssocHook(c, prefix, sgkey, typeName, *args, **kw):
assoc = getattr(c,
c.name() + '_D3PD__egammaRawClusterAssociationTool', None)
if assoc:
assoc.Associator.AssocGetter.SGKey = \
(resolveSGKey(typeName, sgkey) +
D3PDMakerFlags.RawClustersAssocSGKeySuffix())
return
def _egammaTruthAlgHook(c,
prefix,
sgkey,
seq=AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()),
*args,
**kw):
egammaTruthParticleConfig(seq=seq, prefix=prefix, sgkey=sgkey)
return
def _fixJetTiming(c, **kw):
# Check version number of the input data.
# If no version is found, assume old.
rlist = release_version()
if rlist:
if rlist[0] >= 16: return
if rlist[0] == 15 and rlist[1] >= 7: return
if rlist[0] == 15 and rlist[1] == 6 and rlist[2] >= 8: return
sgkey_in = c.Getter.SGKey
sgkey_in = resolveSGKey('JetCollection', sgkey_in)
sgkey_out = sgkey_in + '_timing'
seq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName())
if not hasattr(seq, sgkey_out):
tools = []
caloqual_kw = {
'doCellBasedVariables': True,
'doConstituentBasedVariables': True,
'doSamplingBasedVariables': True,
'cutOnTile': 254,
'cutOnLAr': 4000,
'doTileQuality': True,
'doLArQuality': True
}
if hasattr(JetRecToolsConf, 'JetTimeQualityTool'):
# rel 15 setup
tool1 = JetRecToolsConf.JetTimeQualityTool(sgkey_out + 'TimeTool',
DoTime=False,
DoQuality=False,
UseCells=False)
if rec.readESD() or rec.readRDO():
tool1.DoTime = True
tool1.DoQuality = True
tool1.UseCells = True
if rec.readAOD() and (sgkey_in.find('H1Topo') >= 0
or sgkey_in.find('LCTopo') >= 0):
tool1.DoTime = True
tools.append(tool1)
else:
# rel 16
caloqual_kw['doTiming'] = True
tool2 = JetCaloQualityTool(sgkey_out + 'QualTool', **caloqual_kw)
tools.append(tool2)
alg = JetD3PDMaker.JetFixupAlg(sgkey_out,
InputKey=sgkey_in,
OutputKey=sgkey_out,
Tools=tools)
for t in tools:
alg += t
seq += alg
c.Getter.SGKey = sgkey_out
return
def tileMuonFiller(name, prefix, object_name):
tileMuonGetter = SGDataVectorGetterTool('Muon_getter',
TypeName = 'xAOD::MuonContainer',
SGKey = 'SelectedMuons')
return VectorFillerTool(name,
Prefix = prefix,
Getter = tileMuonGetter,
ObjectName = 'muons',
SaveMetadata = D3PDMakerFlags.SaveObjectMetadata())
def tileCellFiller(name, prefix, object_name):
tilecell_getter = SGDataVectorGetterTool('cell_getter',
TypeName = 'CaloCellContainer',
SGKey = 'SelectedCells')
return VectorFillerTool(name,
Prefix = prefix,
Getter = tilecell_getter,
ObjectName = 'calocells',
SaveMetadata = D3PDMakerFlags.SaveObjectMetadata())
