def BunchConfigIDD3PDObject(source=""):
object = make_Void_D3PDObject("bunch_",
"BunchConfigIDD3PDObject",
default_name="BunchConfigIDFiller")
object.defineBlock(0,
"ConfigID",
TriggerD3PDMaker.BunchConfigIDFillerTool,
BCConfProvider=BunchCrossingConfProvider(source))
return object
ObjectName = 'muons',
SaveMetadata = D3PDMakerFlags.SaveObjectMetadata())
TileMuonD3PDObject = D3PDObject(tileMuonFiller, 'muons_' , 'MuonsD3PDObject')
TileMuonD3PDObject.defineBlock(0, 'MuonsDump', TileMuonFillerTool)
# Index associations ###################################
from D3PDMakerCoreComps.D3PDObject import make_Void_D3PDObject
from TileD3PDMaker import TileAssocFillerTool
def MuonCellFiller(name):
return TileAssocFillerTool(name,
ContainerName = 'muonCells',
BranchName = '_index')
MuonCellD3PDObject = make_Void_D3PDObject( 'muons_muonCells', 'MuonCellD3PDObject' )
MuonCellD3PDObject.defineBlock(0, 'MuonCellDump', MuonCellFiller)
# Finally create an output stream and specify what is dumped
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
alg = MSMgr.NewRootStream( 'tileD3PD', outputFile )
alg += TileEventD3PDObject(10)
alg += TileTrackD3PDObject(10)
alg += TileCellD3PDObject(10)
alg += MuonCellD3PDObject(10)
alg += TileMuonD3PDObject(10)
print "==============> D3PD ATTRIBUTES SET <=============="
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id: TrigBJetD3PD.py 528259 2012-11-29 15:09:12Z ssnyder $
#
# This file holds a helper function to add all the b-jet trigger information to
# a D3PD.
#
# Make sure that the navigation flattening algorithm is called with the correct
# configuration befor the D3PDMaker code is executed:
#
from D3PDMakerCoreComps.D3PDObject import make_Void_D3PDObject
InitTrigD3PDObject = make_Void_D3PDObject(default_name='InitTrigBjet')
def _initTrigHook(c, **kw):
from TriggerJobOpts.TriggerConfigGetter import TriggerConfigGetter
cfg = TriggerConfigGetter()
from TriggerMenuAnalysis.TriggerMenuAnalysisConf import RoILinksCnvTool
from AthenaCommon.AppMgr import ToolSvc
if not hasattr(ToolSvc, 'RoILinksCnvTool'):
ToolSvc += RoILinksCnvTool('RoILinksCnvTool')
import TrigJetD3PDMaker.Setup_RoILinksCnvTool_IBv3
ToolSvc.RoILinksCnvTool.Chains_Jet += [
'L2_j.*', 'EF_j.*', 'L2_2j.*', 'EF_2j.*', 'L2_3j.*', 'EF_3j.*',
'L2_4j.*', 'EF_4j.*', 'L2_5j.*', 'EF_5j.*'
]
ToolSvc.RoILinksCnvTool.Chains_Bjet = [ # these first regexps should deal with most b-jet triggers
'L2_b.*',
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id$
#
#@file MissingETD3PDMaker/python/MissingETD3PDTriggerBitsObject.py
#@author Jet Goodson <*****@*****.**> (copied Haifeng Li's & Scott Snyder's tool in egamma)
#@date 12 Nov, 2009
#@brief Define trigger bit blocks for MissingET
#
from D3PDMakerCoreComps.D3PDObject import make_Void_D3PDObject
METD3PDTriggerBitsObject = \
make_Void_D3PDObject (default_name = 'MissingETTriggerBitsFiller')
#
# The MET trigger bits are now added in MissingETD3PDObject;
# this file is kept just for backwards compatibility.
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id: LBLengthD3PDObject.py 515218 2012-08-28 08:50:53Z krasznaa $
#
# D3PDObject filling the length of the luminosity blocks into a D3PD.
#
# D3PDMaker import(s):
from D3PDMakerCoreComps.D3PDObject import make_Void_D3PDObject
import EventCommonD3PDMaker
# Hook setting up the connection to the DB folder:
def __lblbFolderAccess( c, **kw ):
__folder = "/TRIGGER/LUMI/LBLB"
from IOVDbSvc.CondDB import conddb
if not conddb.folderRequested( __folder ):
conddb.addFolderWithTag( "TRIGGER", __folder, "HEAD" )
pass
return
# Create the object:
LBLengthD3PDObject = make_Void_D3PDObject( "", "LBLengthD3PDObject",
default_name = "LBLengthFiller" )
# Set up its hook:
LBLengthD3PDObject.defineHook( __lblbFolderAccess )
# Add the only tool to it:
LBLengthD3PDObject.defineBlock( 0, "LBLength",
EventCommonD3PDMaker.LumiBlockLengthFillerTool )
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
#
## @file BackgroundD3PDMaker/python/BkgdTriggerBitsD3PDObject.py
## @brief D3PD object for background stream trigger bits
## @author Mark Tibbetts
## @date May 2012
##
from TriggerD3PDMaker.defineTriggerBits import defineTriggerBits
from D3PDMakerCoreComps.D3PDObject import make_Void_D3PDObject
BkgdTriggerBitsD3PDObject = make_Void_D3PDObject(
"", "BkgdTriggerBitsD3PDObject", default_name='BkgdTriggerBitsFiller')
# defineTriggerBits will handle the duplicates correctly
defineTriggerBits(
BkgdTriggerBitsD3PDObject, 0,
["EF_Background.*", "EF_mbSpTrk_unpaired_iso", "EF_mbSpBg_unpaired_iso"])
defineTriggerBits(
BkgdTriggerBitsD3PDObject, 0,
["L2_Background.*", "L2_mbSpTrk_unpaired_iso", "L2_mbSpBg_unpaired_iso"])
defineTriggerBits(BkgdTriggerBitsD3PDObject, 0, [
"L1_RD0_UNPAIRED_ISO", "L1_RD0_EMPTY", "L1_BCM_AC_CA_BGRP0",
"L1_BCM_AC_CA_UNPAIRED_ISO", "L1_BCM_Wide_EMPTY",
"L1_BCM_Wide_UNPAIRED_ISO", "L1_BCM_Wide_UNPAIRED_NONISO",
"L1_EM3_UNPAIRED_ISO", "L1_FJ30_UNPAIRED_ISO", "L1_J10_UNPAIRED_ISO",
"L1_J10_UNPAIRED_NONISO", "L1_LUCID_A_C_EMPTY",
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id$
#
# @file CaloD3PDMaker/python/MBTSTimeD3PDObject.py
# @author scott snyder <*****@*****.**>
# @date Mar, 2010
# @brief MBTS time info object.
#
import CaloD3PDMaker
from D3PDMakerCoreComps.D3PDObject import make_Void_D3PDObject
MBTSTimeD3PDObject = \
make_Void_D3PDObject ('mbtime_', 'MBTSTimeD3PDObject')
MBTSTimeD3PDObject.defineBlock (0, 'MBTSTime',
CaloD3PDMaker.MBTSTimeFillerTool)
def VertexGroupD3PD(alg=None,
file=VertexD3PDAnalysisKeys.D3PDFileName(),
treeName=VertexD3PDAnalysisKeys.D3PDTreeName(),
**kw):
print '[TrackD3PDMaker.VertexGroupD3PD] Vertex group D3PD settings:'
print 'VertexD3PDAnalysisFlags'
print VertexD3PDAnalysisFlags
print 'VertexD3PDAnalysisKeys'
print VertexD3PDAnalysisKeys
if not alg:
## Create a new algorithm
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
alg = MSMgr.NewRootStream(treeName, file)
## General event information (custom options prefix: 'ei_')
if VertexD3PDAnalysisFlags.useEventInfo():
from EventCommonD3PDMaker.EventInfoD3PDObject import EventInfoD3PDObject
alg += EventInfoD3PDObject(**_args('ei_', kw, level=0, prefix='ei_'))
## Trigger information (custom options prefix: 'trig_')
if VertexD3PDAnalysisFlags.useTrigger():
from TriggerJobOpts.TriggerConfigGetter import TriggerConfigGetter
cfg = TriggerConfigGetter("ReadPool")
from TriggerD3PDMaker.defineTriggerBits import defineTriggerBits
from TriggerD3PDMaker.TrigConfMetadata import addTrigConfMetadata
from TriggerD3PDMaker.TrigDecisionD3PDObject import TrigDecisionD3PDObject
alg += TrigDecisionD3PDObject(**_args('trig_', kw, level=2))
addTrigConfMetadata(alg)
if VertexD3PDAnalysisFlags.useTriggerRaw():
from TriggerJobOpts.TriggerConfigGetter import TriggerConfigGetter
cfg = TriggerConfigGetter("ReadPool")
from TriggerD3PDMaker.defineTriggerBits import defineTriggerBits
from TriggerD3PDMaker.TrigConfMetadata import addTrigConfMetadata
#Setup custom D3PD object with raw trigger info only (e.g. calibration_vdM streams)
from D3PDMakerCoreComps.D3PDObject import make_Void_D3PDObject
import TriggerD3PDMaker
TrigDecisionD3PDObjectRaw = make_Void_D3PDObject(
"trigRaw_",
"TrigDecisionD3PDObjectRaw",
default_name="TrigDecisionFillerRaw")
if not VertexD3PDAnalysisFlags.useTrigger():
TrigDecisionD3PDObjectRaw.defineBlock(
0,
"TriggerRawInfo",
TriggerD3PDMaker.TrigDecisionFillerTool,
SaveLVL1Raw=True,
SaveHLTRaw=True,
SaveBGCode=True)
else:
TrigDecisionD3PDObjectRaw.defineBlock(
0,
"TriggerRawInfo",
TriggerD3PDMaker.TrigDecisionFillerTool,
SaveHLTRaw=True,
SaveBGCode=True)
#Finally add object to algorithms
alg += TrigDecisionD3PDObjectRaw(**_args('trig_', kw, level=0))
if not VertexD3PDAnalysisFlags.useTrigger():
#unless we've already added it, add meta-data as well
addTrigConfMetadata(alg)
## Beam background information (custom options prefix: 'bkg_')
if VertexD3PDAnalysisFlags.useBackgroundWord():
from BackgroundD3PDMaker.BackgroundWordD3PDObject import BackgroundWordD3PDObject
alg += BackgroundWordD3PDObject(**_args('bkg_', kw, level=0))
## Tracks and V0 information (custom options prefix: 'trk_', and 'v0_')
if VertexD3PDAnalysisFlags.useTracks():
labelDefaultVtx = VertexD3PDAnalysisKeys.LabelDefaultVtx()
prefixDefaultVtx = labelDefaultVtx + '_' #Add trailing '_'
import TrackD3PDMaker
from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags
from TrackD3PDMaker.TrackD3PDObject import TrackD3PDObject
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from TruthD3PDMaker.TruthD3PDMakerFlags import TruthD3PDFlags
from TruthD3PDMaker.TruthD3PDMakerKeys import TruthD3PDKeys
VtxD3PD_Track_Exclude = ['vx_weight']
TrackD3PDMaker.PerigeeUnbiasedIPAtPVFillerTool.DoBiased = False #Switch off biased perigee
TrackParticleD3PDObjectForVertex = TrackD3PDObject(
_label='trk',
_prefix='trk_',
_sgkey=D3PDMakerFlags.TrackSGKey(),
_object_name='TrackParticleD3PDObjectForVertex',
typeName='Rec::TrackParticleContainer',
vertexTarget=labelDefaultVtx,
vertexPrefix=prefixDefaultVtx,
vertexSGKey='VxPrimaryCandidate',
truthTarget=TruthD3PDFlags.GenParticleAssocLabel(),
truthPrefix=TruthD3PDKeys.GenParticlePrefix(),
detailedTruthPrefix='', # 'mc_detailed_'
SGKeyForTruth=D3PDMakerFlags.TrackSGKey(),
truthMapKey='TrackParticleTruthCollection',
detailedTruthMapKey='', #'DetailedTrackTruth'
flags=TrackD3PDFlags)
alg += TrackParticleD3PDObjectForVertex(
**_args('trk_', kw, level=8, exclude=VtxD3PD_Track_Exclude))
if VertexD3PDAnalysisFlags.useSecondaryVertex():
from TrackD3PDMaker.V0D3PDObject import V0D3PDObject
alg += V0D3PDObject(**_args('v0_', kw, level=10))
## Store beamspot information (custom option perfix: 'bs_')
if VertexD3PDAnalysisFlags.useBeamspot():
from TrackD3PDMaker.BeamSpotD3PDObject import BeamSpotD3PDObject
alg += BeamSpotD3PDObject(**_args('bs_', kw, level=0))
## Store vertex information (custom options prefix: 'vtx_' or 'vtx' for BuildVertexD3PDObject)
from TrackD3PDMaker.VertexD3PDObject import PrimaryVertexD3PDObject
from TrackD3PDMaker.VertexD3PDObject import BuildVertexD3PDObject
from InDetRecExample.InDetKeys import InDetKeys
from InDetRecExample.InDetJobProperties import InDetFlags
#First dump existing content
labelDefaultVtx = VertexD3PDAnalysisKeys.LabelDefaultVtx()
prefixDefaultVtx = labelDefaultVtx + '_' #Add trailing '_'
VtxDefaultD3PDObj = BuildVertexD3PDObject(
**_args('vtx',
kw,
_prefix=prefixDefaultVtx,
_label=labelDefaultVtx,
_sgkey=InDetKeys.PrimaryVertices(),
trackTarget='trk',
trackPrefix='trk_',
trackType='Rec::TrackParticleContainer'))
alg += VtxDefaultD3PDObj(**_args('vtx_', kw, level=10))
#Then also dump the other vertex collections
if VertexD3PDAnalysisFlags.useAllVertexCollections:
#Use non BC and split collections (sorry, no customization of parameters here)
if not InDetFlags.doSplitVertexFindingForMonitoring():
#raise NameError('Requesting split vertices but algorith has not run!')
#pass
print(
'[TrackD3PDMaker.VertexGroupD3PD] WARNING: Requested split vertices, but algorithm has not run! Skipped.'
)
else:
SplitPrimaryVertexD3PDObject = BuildVertexD3PDObject(
_prefix='vxsplit_',
_label='vxsplit',
_sgkey=InDetKeys.PrimaryVerticesSplitStream(),
trackTarget='trk',
trackPrefix='trk_',
trackType='Rec::TrackParticleContainer')
alg += SplitPrimaryVertexD3PDObject(8)
#Then store also non beamspot constrained ones
if not InDetFlags.doVertexFindingForMonitoring():
#raise NameError('Requesting NBC vertices but algorith has not run!')
#pass
print(
'[TrackD3PDMaker.VertexGroupD3PD] WARNING: Requested non beamspot constrained vertices, but algorithm has not run! Skipped.'
)
else:
NoBeamConstraintPrimaryVertexD3PDObject = BuildVertexD3PDObject(
_prefix='vxnbc_',
_label='vxnbc',
_sgkey=InDetKeys.PrimaryVerticesWithoutBeamConstraint(),
trackTarget='trk',
trackPrefix='trk_',
trackType='Rec::TrackParticleContainer')
alg += NoBeamConstraintPrimaryVertexD3PDObject(8)
## Store truth-level information (custom options prefix: 'tuthVtx_', 'truthEvt_', 'truthPart_')
if VertexD3PDAnalysisFlags.useTruth():
from TruthD3PDAnalysis.TruthD3PDAnalysisConf import D3PD__GenObjectsFilterTool
trackGenObjectsFilterTool = D3PD__GenObjectsFilterTool(
"trackGenObjectsFilterTool")
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += trackGenObjectsFilterTool
if (VertexD3PDAnalysisFlags.filterTightTruth()):
trackGenObjectsFilterTool.SelectTruthTracks = True
trackGenObjectsFilterTool.PtMin = VertexD3PDAnalysisKeys.TruthTrackCutPtMin(
)
trackGenObjectsFilterTool.EtaMax = VertexD3PDAnalysisKeys.TruthTrackCutEtaMax(
)
trackGenObjectsFilterTool.RemoveEmptyEvents = True
trackGenObjectsFilterTool.RemoveDummyEvents = True
trackGenObjectsFilterTool.RemoveInTimePileUp = False
trackGenObjectsFilterTool.Remove2BCPileUp = True
trackGenObjectsFilterTool.Remove800nsPileUp = True
trackGenObjectsFilterTool.RemoveCavernBkg = False
trackGenObjectsFilterTool.AddOnlyFirstVertex = VertexD3PDAnalysisKeys.TruthAddOnlyFirstVertex(
)
else:
#Use a more inclusive truth policy
trackGenObjectsFilterTool.SelectTruthTracks = False
trackGenObjectsFilterTool.PtMin = VertexD3PDAnalysisKeys.TruthTrackCutPtMin(
)
trackGenObjectsFilterTool.EtaMax = VertexD3PDAnalysisKeys.TruthTrackCutEtaMax(
)
trackGenObjectsFilterTool.RemoveEmptyEvents = True
trackGenObjectsFilterTool.RemoveDummyEvents = True
trackGenObjectsFilterTool.AddOnlyFirstVertex = VertexD3PDAnalysisKeys.TruthAddOnlyFirstVertex(
)
from TruthD3PDMaker.GenEventD3PDObject import GenEventD3PDObject
alg += GenEventD3PDObject(
**_args('truthEvt_',
kw,
level=10,
filter=trackGenObjectsFilterTool,
pileup_CollectionGetterRegistry=alg.name() +
'_CollectionGetterRegistry'))
from TruthD3PDMaker.GenVertexD3PDObject import GenVertexD3PDObject
alg += GenVertexD3PDObject(**_args(
'truthVtx_', kw, level=1, filter=trackGenObjectsFilterTool))
from TruthD3PDMaker.GenParticleD3PDObject import GenParticleD3PDObject
alg += GenParticleD3PDObject(**_args(
'truthPart_', kw, level=10, filter=trackGenObjectsFilterTool))
from TruthD3PDMaker.GenParticleD3PDObject import GenTruthTrackD3PDObject
alg += GenTruthTrackD3PDObject(**_args('truthTrack_', kw, level=0))
## Dump higher level objects
# Missing Energy (custom options prefix with VertexD3PDAnalysisKeys.MetCollections+'_')
if VertexD3PDAnalysisFlags.useMET():
for MET in VertexD3PDAnalysisKeys.MetCollections():
VtxD3PD_Met_Key = MET
VtxD3PD_Met_Prefix = MET.replace('_', '') + '_'
VtxD3PD_Met_Level = 0 #Only basic info
VtxD3PD_Met_Exclude = ['MET_Regions', 'L1_', 'L2_', 'EF_']
from MissingETD3PDMaker.MissingETD3PDObject import RefFinalMETD3PDObject
VtxD3PD_Met_Obj = RefFinalMETD3PDObject(
**_args(MET + '_',
kw,
level=VtxD3PD_Met_Level,
sgkey=VtxD3PD_Met_Key,
prefix=VtxD3PD_Met_Prefix,
exclude=VtxD3PD_Met_Exclude))
alg += VtxD3PD_Met_Obj
#Muons (custom options prefix VtxD3PD_Muon_Prefix -- see below [e.g. muid_, staco_, ...])
if VertexD3PDAnalysisFlags.useMuons():
from MuonD3PDMaker.MuonD3PDObject import MuonD3PDObject
for Muon in VertexD3PDAnalysisKeys.MuonCollections():
VtxD3PD_Muon_Key = Muon
VtxD3PD_Muon_Prefix = Muon + '_'
if VtxD3PD_Muon_Key == 'MuidMuonCollection':
VtxD3PD_Muon_Prefix = 'muid_'
elif VtxD3PD_Muon_Key == 'StacoMuonCollection':
VtxD3PD_Muon_Prefix = 'staco_'
VtxD3PD_Muon_Level = 0 #Only basic info
VtxD3PD_Muon_Exclude = [
'EFCBInfo', 'EFMGInfo', 'EFMEInfo', 'L2CBInfo', 'L1Info',
'L1_', 'L2_', 'EF_'
]
VtxD3PD_Muon_Obj = MuonD3PDObject(
**_args(VtxD3PD_Muon_Prefix,
kw,
level=VtxD3PD_Muon_Level,
sgkey=VtxD3PD_Muon_Key,
prefix=VtxD3PD_Muon_Prefix,
allowMissing=True,
exclude=VtxD3PD_Muon_Exclude))
alg += VtxD3PD_Muon_Obj
#Electrons (custom options prefix: 'el_')
if VertexD3PDAnalysisFlags.useElectrons():
from egammaD3PDMaker.ElectronD3PDObject import ElectronD3PDObject
alg += ElectronD3PDObject(**_args('el_', kw, prefix='el_', level=0))
#Photons (custom options prefix: 'ph_')
if VertexD3PDAnalysisFlags.usePhotons():
from egammaD3PDMaker.PhotonD3PDObject import PhotonD3PDObject
alg += PhotonD3PDObject(**_args('ph_', kw, prefix='ph_', level=0))
#Jets, JVF, b-jets (custom options prefix: 'jet_')
if VertexD3PDAnalysisFlags.useJets():
from JetD3PDMaker.JetD3PDObject import JetD3PDObject
from JetTagD3PDMaker.JetTagD3PDMakerKeys import JetTagD3PDKeys
from JetTagD3PDMaker.AddBTagD3PDInfo import addBTagInfoToJetObject
addBTagInfoToJetObject(JetD3PDObject, btagLevelOffset=0)
VtxD3PD_Jet_Include = [
'Kinematics', 'JetVertexFraction', 'JVtx', 'EMFraction',
'TrueFlavorComponents',
JetTagD3PDKeys.BTagWeightsBlockName()
]
for JET in VertexD3PDAnalysisKeys.JetCollections():
VtxD3PD_Jet_Prefix = JET.replace('_', '') + '_'
if len(VertexD3PDAnalysisKeys.JetCollections()) == 1:
#only 1 element, simplify prefix
VtxD3PD_Jet_Prefix = 'jet_'
alg += JetD3PDObject(**_args('jet_',
kw,
sgkey=JET,
prefix=VtxD3PD_Jet_Prefix,
level=0,
include=VtxD3PD_Jet_Include))
#Taus
if VertexD3PDAnalysisFlags.useTaus():
from TauD3PDMaker.TauD3PDObject import TauD3PDObject
VtxD3PD_Tau_Include = ['TauPriVtx']
alg += TauD3PDObject(**_args(
'tau_', kw, prefix='tau_', level=0, include=VtxD3PD_Tau_Include))
## Return algorithm
return alg
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id: BGCodeD3PDObject.py 338058 2010-12-20 13:20:43Z krasznaa $
#
# D3PD object saving the BunchGroup code from the TDT into the D3PD
#
from D3PDMakerCoreComps.D3PDObject import make_Void_D3PDObject
import TriggerD3PDMaker
BGCodeD3PDObject = make_Void_D3PDObject("trig_",
"BGCodeD3PDObject",
default_name="BGCodeFiller")
BGCodeD3PDObject.defineBlock(0,
"BGCode",
TriggerD3PDMaker.TrigDecisionFillerTool,
SaveBGCode=True)
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration # $Id$ # # @file egammaD3PDMaker/python/egammaTriggerBitsD3PDObject.py # @author Haifeng Li <*****@*****.**>, sss # @date Sep, 2009 # @brief Define trigger bit blocks for egamma. # import D3PDMakerCoreComps import TriggerD3PDMaker from D3PDMakerCoreComps.D3PDObject import make_Void_D3PDObject from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags # Create the object type. egammaTriggerBitsD3PDObject = \ make_Void_D3PDObject (default_name = 'egammaTriggerBitsFiller') # # The egamma trigger bits are now added in ElectronD3PDObject and # PhotonD3PDObject; this file is kept just for backwards compatibility. #
Getter = tilecell_getter,
ObjectName = 'calocells',
SaveMetadata = D3PDMakerFlags.SaveObjectMetadata())
TileCellD3PDObject = D3PDObject(tileCellFiller, 'cells_' , 'CellsD3PDObject')
TileCellD3PDObject.defineBlock(0, 'CaloCellDump', TileCellFillerTool)
# Index associations ###################################
from D3PDMakerCoreComps.D3PDObject import make_Void_D3PDObject
from TileD3PDMaker import TileAssocFillerTool
def trackClusterFiller(name):
return TileAssocFillerTool(name,
ContainerName = 'TrackClusters',
BranchName = '_index')
trackClusterD3PDObject = make_Void_D3PDObject( 'tracks_trackclusters', 'TrackClusterD3PDObject' )
trackClusterD3PDObject.defineBlock(0, 'TrackClusterDump', trackClusterFiller)
def trackCellFiller(name):
return TileAssocFillerTool(name,
ContainerName = 'TrackCells',
BranchName = '_index')
trackCellD3PDObject = make_Void_D3PDObject( 'tracks_trackcells', 'TrackCellD3PDObject' )
trackCellD3PDObject.defineBlock(0, 'TrackCellDump', trackCellFiller)
def clusterCellFiller(name):
return TileAssocFillerTool(name,
ContainerName = "ClusterCells",
BranchName = "_index")
clusterCellD3PDObject = make_Void_D3PDObject( 'clusters_clustercells', 'ClusterCellD3PDObject' )
clusterCellD3PDObject.defineBlock(0, 'ClusterCellDump', clusterCellFiller)
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id: TrigDBKeysD3PDObject.py 338058 2010-12-20 13:20:43Z krasznaa $
#
# D3PD object saving the trigger configuration DB keys that were used to record
# the event. To be used in conjunction with saving the trigger configuration metadata.
#
from D3PDMakerCoreComps.D3PDObject import make_Void_D3PDObject
import TriggerD3PDMaker
TrigDBKeysD3PDObject = make_Void_D3PDObject("trig_DB_",
"TrigDBKeysD3PDObject",
default_name="TrigDBKeysFiller")
TrigDBKeysD3PDObject.defineBlock(0, "DBKeys",
TriggerD3PDMaker.TrigDBKeysFillerTool)
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id: TrigDecisionD3PDObject.py 451855 2011-08-03 09:28:07Z krasznaa $
#
# D3PD object saving the raw trigger decision in the D3PD.
# Note, that you need to know the trigger configuration to make sense
# of this information. Your best bet is to save the configuration as
# meta-data using TrigConfMetadataTool.
#
from D3PDMakerCoreComps.D3PDObject import make_Void_D3PDObject
import TriggerD3PDMaker
TrigDecisionD3PDObject = make_Void_D3PDObject(
"trig_", "TrigDecisionD3PDObject", default_name="TrigDecisionFiller")
TrigDecisionD3PDObject.defineBlock(0,
"PhysicsBits",
TriggerD3PDMaker.TrigDecisionFillerTool,
SaveLVL1Physics=True,
SaveHLTPhysics=True)
TrigDecisionD3PDObject.defineBlock(1,
"RawBits",
TriggerD3PDMaker.TrigDecisionFillerTool,
SaveLVL1Raw=True,
SaveHLTRaw=True,
SaveTruncated=True)
TrigDecisionD3PDObject.defineBlock(2,
"HLTDetails",
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
from D3PDMakerCoreComps.D3PDObject import make_Void_D3PDObject
import TruthD3PDMaker
#import TopInputsD3PDMaker
HforD3PDObject = make_Void_D3PDObject("top_",
"HforD3PDObject",
default_name="HforFiller")
HforD3PDObject.defineBlock(0, "HforBits", TruthD3PDMaker.HforFillerTool)
# @file GenericD3PDMaker/python/GenericTriggerBitsD3PDObject.py
# shamelessly copied by Gustaaf Brooijmans from SUSY:
# @author Bjorn H. Samset <*****@*****.**>
# @date Jan, 2010
# @brief Define trigger bit blocks for Generic.
#
import D3PDMakerCoreComps
import TriggerD3PDMaker
from TriggerD3PDMaker.defineTriggerBits import defineTriggerBits
from D3PDMakerCoreComps.D3PDObject import make_Void_D3PDObject
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
#from SUSYD3PDMaker.SUSYD3PDFlags import SUSYD3PDFlags
# Create the object type.
GenericTriggerBitsD3PDObject = make_Void_D3PDObject(
"", "GenericTriggerBitsD3PDObject", "GenericTriggerBitsFiller")
######
# Define blocks.
if D3PDMakerFlags.DoTrigger():
#-- for R&D NTUP_Generic{SKIM}, put level of detail at 10
defineTriggerBits(GenericTriggerBitsD3PDObject, 10, ['EF_.*'])
##Tau bits
defineTriggerBits(GenericTriggerBitsD3PDObject, 10, [
'L1_Tau*',
'EF_Tau*',
'EF_mu4T*',
'EF_2mu4T*',
def suffix (radius, calibrated):
suff = 'Kt%d' % int(radius*10 + 0.5)
if calibrated:
suff = suff + 'LC'
else:
suff = suff + 'EM'
return suff
def areaDensity (radius, calibrated):
suff = suffix (radius, calibrated)
ss = 'CALIBRATED' if calibrated else 'UNCALIBRATED'
return configureJetAreaDensity ('ClusterRho' + suff,
Radius = radius,
SignalState = ss,
**commonDict)
def rhoBlock (obj, radius, calibrated):
suff = suffix (radius, calibrated)
obj.defineBlock (0, 'ClusterRho' + suff,
QcdD3PDMaker.EventEtDensityFillerTool,
VariableSuffix = suff,
EventEtDensityTool = areaDensity (radius, calibrated))
return
EventShapeD3PDObject = make_Void_D3PDObject( 'Eventshape_', "EventShapeD3PDObject" )
rhoBlock (EventShapeD3PDObject, 0.3, False)
rhoBlock (EventShapeD3PDObject, 0.4, False)
rhoBlock (EventShapeD3PDObject, 0.3, True)
rhoBlock (EventShapeD3PDObject, 0.4, True)
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
#
## @file JetTagD3PDMaker/python/JetTagTriggerBitsD3PDObject.py
## @brief D3PD object for trigger bits needed by btagging
## @author Georges Aad
## @date Juin, 2011
##
from TriggerD3PDMaker.defineTriggerBits import defineTriggerBits
from D3PDMakerCoreComps.D3PDObject import make_Void_D3PDObject
JetTagTriggerBitsD3PDObject = \
make_Void_D3PDObject( "", "JetTagTriggerBitsD3PDObject",
default_name = 'JetTagTriggerBitsFiller' )
### add btag triggers
# already added if btag trig info is included
# but defineTriggerBits will handle the duplicates correctly
defineTriggerBits(JetTagTriggerBitsD3PDObject, 0, ["EF_b.*", "EF_2b.*", "EF_3b.*",
"EF_mu4_j10_a4tc_EFFS", "EF_mu4_L1J10_matched",
"EF_mu4_L1J20_matched",
"EF_mu4_L1J30_matched", "EF_mu4_L1J50_matched",
"EF_mu4_L1J75_matched", "EF_4j30_a4tc_EFFS",
"EF_mu4_j100_a4tc_EFFS_L1matched",
"EF_mu4_j10_a4_EFFS",
"EF_mu4_j10_a4tc_EFFS_matched"
])
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration # @file MuonD3PDMaker/python/MuonTriggerBitsD3PDObject.py # @author Srivas Prasad <*****@*****.**> # @date Jan, 2010 # @brief Define muon trigger bit blocks from D3PDMakerCoreComps.D3PDObject import make_Void_D3PDObject MuonTriggerBitsD3PDObject = \ make_Void_D3PDObject (default_name = 'MuonTriggerBitsFiller') # # The muon trigger bits are now added in MuonD3PDObject; # this file is kept just for backwards compatibility. #
Vars=[
'anInt', 'aFloat',
's = aString #This is a string.', 'aFourvec',
'dummy < int:-999'
])
###########################################################################
alg += Obj1D3PDObject(99)
alg += Obj1D3PDObject2(99)
alg += Obj1D3PDObject(99, prefix='o1filt_', getterFilter='obj1sel')
alg += Obj3D3PDObject(99)
alg += Obj4D3PDObject(99)
alg += Obj5D3PDObject(99)
DefD3PDObject = make_Void_D3PDObject('def_')
DefD3PDObject.defineBlock(0, 'Def', D3PDMakerTest.DefaultFillerTool)
alg += DefD3PDObject(99)
# Testing SimHitsCollection.
from MuonD3PDMaker.MDTSimHitD3PDObject import MDTSimHitD3PDObject
alg += MDTSimHitD3PDObject(99, sgkey='MDTSimHits')
from MuonD3PDMaker.TrackRecordD3PDObject import TrackRecordD3PDObject
alg += TrackRecordD3PDObject(99, sgkey='TrackRecord', exclude=['TruthHits'])
from AnalysisTools.AthAnalysisToolsConf import AANTupleStream
AANTupleStream('D3PD').ExistDataHeader = False
def dumpit():
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id$
#
# @file CaloD3PDMaker/python/ZDCTriggerBitsD3PDObject.py
# @author scott snyder <*****@*****.**>
# @date Aug, 2010
# @brief ZDC trigger bits.
#
from TriggerD3PDMaker.defineTriggerBits import defineTriggerBits
from D3PDMakerCoreComps.D3PDObject import make_Void_D3PDObject
ZDCTriggerBitsD3PDObject = \
make_Void_D3PDObject (default_object_name = 'ZDCTriggerBitsD3PDObject', default_name = 'ZDCTriggerBits')
defineTriggerBits (ZDCTriggerBitsD3PDObject, 0, 'L1_ZDC')
# a single TriggerBitsFillerTool; duplicates will be removed within
# the tool so that's no longer an issue.
#
# Use it like this:
#
# defineTriggerBits (d3pdObj, 0, 'L1_EM.*')
#
import TriggerD3PDMaker
from D3PDMakerCoreComps.D3PDObject import make_Void_D3PDObject
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from AthenaCommon.AppMgr import theApp
triggerBitsD3PDObject = \
make_Void_D3PDObject ( "", "triggerBitsD3PDObject",
default_name = 'TriggerBitsFiller' )
triggerBitsD3PDObject.defineBlock \
(0, 'TriggerBits',
TriggerD3PDMaker.TriggerBitFillerTool ,
AllowExtend = D3PDMakerFlags.AllowTrigExtend(),
Triggers=[ ])
def defineTriggerBits(d3pdobj, level, pattern):
"""Define trigger bits to be added to the D3PD whenever D3PDObj is added.
LEVEL is the level-of-detail for the bits.
PATTERN is a regular expression giving the pattern of the desired bits.
It may also be a list of patterns.