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.