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
import MuonD3PDMaker
import D3PDMakerCoreComps
import EventCommonD3PDMaker
from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from MuonD3PDMaker.MuonD3PDMakerFlags import MuonD3PDFlags
from RecExConfig.RecFlags import rec
#from MuonD3PDMaker.MuonD3PDMakerConf import MuonWZTruthTool
#TruthTool = MuonWZTruthTool()
#ToolSvc += TruthTool
MuonSegmentD3PDObject = \
make_SGDataVector_D3PDObject ('Trk::SegmentCollection',
D3PDMakerFlags.MuonSegmentSGKey(),
'mu_seg_', 'MuonSegmentD3PDObject')
MuonSegmentD3PDObject.defineBlock (1, 'Location',
MuonD3PDMaker.MuonSegmentLocationFillerTool)
MuonSegmentD3PDObject.defineBlock (1, 'Author',
MuonD3PDMaker.MuonSegmentAuthorFillerTool)
MuonSegmentD3PDObject.defineBlock (1, 'FitQuality',
MuonD3PDMaker.MuonSegmentFitQualityFillerTool)
# Include the chamber t0 for the relevant MuonSegment collection, leave out the other
MuonSegmentD3PDObject.defineBlock (1, 'MuonboySegmentT0',
MuonD3PDMaker.MuonSegmentT0FillerTool,doMuonBoyCSCTiming=True)
MuonSegmentD3PDObject.defineBlock (1, 'MooreSegmentT0',
MuonD3PDMaker.MuonSegmentT0FillerTool,doMuonBoyCSCTiming=False)
from TriggerD3PDMaker.defineTriggerBits import defineTriggerBits
from AthenaCommon.AlgSequence import AlgSequence
from RecExConfig.RecFlags import rec
import egammaD3PDMaker
import EventCommonD3PDMaker
import TrackD3PDMaker
import CaloD3PDMaker
import D3PDMakerCoreComps
from ROOT import egammaParameters
from ROOT import egammaPID
ElectronD3PDObject = \
make_SGDataVector_D3PDObject ('ElectronContainer',
D3PDMakerFlags.ElectronSGKey(),
'el_', 'QcdElectronD3PDObject')
def _electronAlgHook(c,
prefix,
sgkey,
typeName,
seq=AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()),
*args,
**kw):
ElectronUserDataConfig(seq=seq,
prefix=prefix,
sgkey=sgkey,
typeName=typeName)
#### TauRec block ####
import TrackD3PDMaker
from D3PDMakerCoreComps.ContainedVectorMultiAssociation import ContainedVectorMultiAssociation
from D3PDMakerCoreComps.SimpleAssociation import SimpleAssociation
#Test A
from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from TauD3PDMaker.TauD3PDMakerConf import D3PD__TauPIDFillerTool
from TauD3PDMaker.TauD3PDMakerConf import D3PD__TauJetFillerTool
from TauD3PDMaker.TauD3PDMakerConf import D3PD__TauTrackAssociationTool
from TauD3PDMaker.TauD3PDMakerConf import D3PD__TauTrackToOriginFillerTool
import EventCommonD3PDMaker
TauD3PDObject = make_SGDataVector_D3PDObject("Analysis::TauJetContainer",
D3PDMakerFlags.TauSGKey(), "tau_",
"TauD3PDObject")
TauD3PDObject.defineBlock(0,
'Kinematics',
EventCommonD3PDMaker.FourMomFillerTool,
WriteEt=True,
WritePt=True)
TauD3PDObject.defineBlock(0, 'Charge', EventCommonD3PDMaker.ChargeFillerTool)
TauD3PDObject.defineBlock(0, 'PID', D3PD__TauPIDFillerTool)
TauD3PDObject.defineBlock(0, 'TauJet', D3PD__TauJetFillerTool)
TauD3PDObject.defineBlock(0, 'TracksToOrigin',
D3PD__TauTrackToOriginFillerTool)
# Associate tau with its tracks
TauTrackAssoc = ContainedVectorMultiAssociation \
(TauD3PDObject,
D3PD__TauTrackAssociationTool,prefix='track_')
from CaloD3PDMaker.CaloCellD3PDObject import SelCaloCellD3PDObject
scell_alg = MakerAlg ('scells', file = 'scells.root')
scell_alg += EventInfoD3PDObject (0)
scell_alg += AllCaloCellD3PDObject (2, sgkey = 'SCells', prefix = 'sc_',
include = ['RawPosition'])
d3pd_tests += [('scells.root', 'scells.ref')]
# Test LeadingPtAssociationTool.
from D3PDMakerCoreComps.SimpleAssociation import SimpleAssociation
from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject
import EventCommonD3PDMaker
TestJetD3PDObject = make_SGDataVector_D3PDObject ('JetCollection',
'AntiKt4TopoEMJets,' +
'AntiKt4TopoJets,' +
'AntiKt4H1TopoJets',
'testjet_', 'testjet')
TestJetD3PDObject.defineBlock (0, 'Kin', EventCommonD3PDMaker.FourMomFillerTool)
LeadingConstitAssoc = SimpleAssociation \
(TestJetD3PDObject,
EventCommonD3PDMaker.LeadingPtAssociationTool,
level = 0,
prefix = 'lconstit_',
blockname = 'LeadingConstitAssoc',
MultiAssocTool = EventCommonD3PDMaker.NavigableConstituentAssociationTool
('LeadingConstitMAssoc', TypeName = 'CaloCluster'))
LeadingConstitAssoc.defineBlock (0, 'LeadKin',
EventCommonD3PDMaker.FourMomFillerTool)
from D3PDMakerCoreComps.ContainedVectorMultiAssociation import ContainedVectorMultiAssociation
#import TrigMuonD3PDMaker
import TruthD3PDMaker
from RecExConfig.RecFlags import rec
from RecExConfig.ObjKeyStore import cfgKeyStore
from AthenaCommon.AppMgr import ToolSvc
from AthenaCommon.Include import include
from MuonD3PDMaker.MuonD3PDMakerFlags import MuonD3PDFlags
MuonD3PDObject = \
make_SGDataVector_D3PDObject ('DataVector<xAOD::Muon_v1>',
D3PDMakerFlags.MuonSGKey(),
'mu_', 'MuonD3PDObject')
MuonD3PDObject.defineBlock(0,
'Kinematics',
EventCommonD3PDMaker.FourMomFillerTool,
WriteRect=True,
WriteE=True,
WriteM=True)
MuonD3PDObject.defineBlock(0,
'AllAuthor',
D3PDMakerCoreComps.AuxDataFillerTool,
Vars=['allauthor = allAuthors'])
MuonD3PDObject.defineBlock(1,
'Authors',
def getJetD3PDObject(objectname='JetD3PDObject',
prefix='jet_',
btagleveloffset=7):
object = make_SGDataVector_D3PDObject('DataVector<xAOD::Jet_v1>',
D3PDMakerFlags.JetSGKey(), prefix,
objectname)
# object.defineHook (_fixJetTiming)
# object.defineHook (_jetVertexAlgHook)
# object.defineHook (_jetMomentsHook)
# object.defineHook (_jetClusterMomentsHook)
object.defineBlock(0,
'Kinematics',
EventCommonD3PDMaker.FourMomFillerTool,
WriteE=True)
# object.defineBlock(1, 'OriginCorrection',
# JetD3PDMaker.JetMomentFillerTool,
# Moments=['EtaOrigin' , 'PhiOrigin' , 'MOrigin'
# ])
# object.defineBlock(1, 'WIDTH',
# JetD3PDMaker.JetMomentFillerTool,
# Moments=['WIDTH'
# ])
object.defineBlock(1,
'DQMoments',
D3PDMakerCoreComps.AuxDataFillerTool,
Vars=[
'n90 = N90Cells < int: 0',
'Timing < float: 0',
'LArQuality < float: 0',
'OriginIndex < float: 0',
'HECQuality < float: 0',
'NegativeE < float: 0',
'AverageLArQF < float: 0',
'BCH_CORR_CELL = BchCorrCell < float:0',
'BCH_CORR_DOTX = BchCorrDotx < int:0',
'BCH_CORR_JET = BchCorrJet < int:0',
'BCH_CORR_JET_FORCELL = BchCorrJetForCell < int:0',
'NumTowers < float: 0',
'ootFracCells5 < float: 0',
'ootFracCells10 < float: 0',
'ootFracClusters5 < float: 0',
'ootFracClusters10 < float: 0',
])
# object.defineBlock(1, 'JetSamplingsFrac',
# JetD3PDMaker.JetSamplingsFracFillerTool)
# object.defineBlock(1, 'JetQual',
# JetD3PDMaker.JetCaloUtilsFillerTool)
object.defineBlock(1,
'JetQual',
D3PDMakerCoreComps.AuxDataFillerTool,
Vars=[
'isBadLoose < int: 0',
'isBadMedium < int: 0',
'isBadTight < int: 0',
'isUgly < int: 0',
'hecf = HECFrac < float: 0',
])
# object.defineBlock(1, 'EMFraction',
# JetD3PDMaker.JetEMFractionFillerTool)
# object.defineBlock(1, 'JES',
# JetD3PDMaker.JetMomentFillerTool,
# Moments=[ 'Offset', 'EMJES', 'EMJES_EtaCorr','EMJESnooffset' ])
# object.defineBlock(1, 'JESMoments',
# JetD3PDMaker.JetMomentFillerTool,
# Moments=['LCJES', 'LCJES_EtaCorr' ])
# object.defineBlock(1, 'EMScale',
# JetD3PDMaker.JetSignalStateFillerTool,
# WriteE = True,
# SignalStateNumber = 0,
# SignalStatePrefix = 'emscale')
# object.defineBlock(1, 'ActiveArea',
# JetD3PDMaker.JetMomentFillerTool,
# Moments=['ActiveArea', 'ActiveAreaPx', 'ActiveAreaPy', 'ActiveAreaPz', 'ActiveAreaE'])
# # Including JetVertexFraction should also include JVtx and TruthMF,
# # unless explicitly excluded.
# def _jvfLOD (reqlev, args, hookargs):
# if reqlev < 3: return False
# if not 'JVtx' in hookargs['exclude']:
# hookargs['include'].append ('JVtx')
# if not 'TruthMF' in hookargs['exclude']:
# hookargs['include'].append ('TruthMF')
# return True
# try:
# # tracksAvailableForJets not defined in every release. Temporarily put it in
# # a try / except block
# from JetRec.TrackSelectionForJets import tracksAvailableForJets
# dotrackVars = tracksAvailableForJets()
# except:
# dotrackVars = True
# if dotrackVars:
# object.defineBlock(_jvfLOD, 'JetVertexFraction',
# JetD3PDMaker.JetVertexFractionFillerTool,
# UDPrefix=D3PDMakerFlags.JetUserDataPrefix(),
# )
# object.defineBlock(3, 'JVtx',
# JetD3PDMaker.JetVtxFillerTool)
# object.defineBlock(3, 'TruthMF',
# JetD3PDMaker.JetMomentFillerTool,
# Moments=['TruthMFindex','TruthMF'])
# object.defineBlock(3, 'Layer',
# JetD3PDMaker.JetMomentFillerTool,
# Moments=['GSCFactorF','WidthFraction'])
# object.defineBlock(4, 'Samplings',
# JetD3PDMaker.JetSamplingsFillerTool)
# object.defineBlock(4, 'JetShape',
# JetD3PDMaker.JetShapeFillerTool)
# object.defineBlock(4, 'Constituents',
# JetD3PDMaker.JetConstituentFillerTool,
# SignalStateNumber = -1,
# SignalStatePrefix = 'default')
# object.defineBlock(4, 'ConstituentScale',
# JetD3PDMaker.JetSignalStateFillerTool,
# WriteE = True,
# SignalStateNumber = 2,
# SignalStatePrefix = 'constscale')
# object.defineBlock(5, 'JetLArHVMoment',
# JetD3PDMaker.JetMomentFillerTool,
# Moments=['LArBadHVEnergy','LArBadHVRatio'])
# object.defineBlock(9, 'JetClusterMoment',
# JetD3PDMaker.JetMomentFillerTool,
# Moments=['CENTER_LAMBDA','SECOND_R','SECOND_LAMBDA',
# 'CLUSTER_PT'])
# addBTagInfoToJetObject(object,btagleveloffset)
# # Track association cannot be done unless there are tracks.
# # As often this is not the case track association will be done only
# # if this is explicitly asked for. by defining it in the include list.
# #
# # You can also enable it by passing an argument to JetD3PDObject
# # like:
# # AssocTrackCont_target='mytarget_'
# def _jetAssocLevel (reqlev, args):
# return args.has_key ('target') or (reqlev >= 999)
# IndexMultiAssociation (object,
# JetD3PDMaker.FlavorAssociationTool,
# 'trk',
# prefix = 'flavor_assoctrk_',
# level = _jetAssocLevel,
# blockname = 'AssocTrackCont')
# object.defineBlock(10, 'JetRoIword',
# JetD3PDMaker.JetROIWordFillerTool
# )
# #JetElAssoc = DRAssociation(object,"ElectronContainer",D3PDMakerFlags.ElectronSGKey(),0.2,prefix='el_',matched="matched",blockname="El02Match")
# #JetMuAssoc = DRAssociation(object,"Analysis::MuonContainer",D3PDMakerFlags.MuonSGKey(),0.2,prefix='mu_',matched="matched",blockname="Mu02Match")
# #JetTrkAssoc = DRAssociation(object,"Rec::TrackParticleContainer",D3PDMakerFlags.TrackSGKey(),0.4,prefix='trk_',matched="matched",blockname="Trk04Match")
# #---------------- Trigger Object ----------------------------
# #if D3PDMakerFlags.DoTrigger():
# if False:
# JetL1Assoc = SimpleAssociation(object,
# JetD3PDMaker.JetL1TriggerObjectAssociationTool,
# matched = 'matched',
# blockname = 'L1Info',
# prefix = 'L1_',
# MaxDR = 0.6,
# ChainPattern = 'L1_J.*')
# JetL1Assoc.defineBlock (99, 'L1Kinematics',
# EventCommonD3PDMaker.FourMomFillerTool,
# WriteE = True,
# WriteEt = False,
# WriteM = False)
# JetL2Assoc = SimpleAssociation(object,
# JetD3PDMaker.JetL2TriggerObjectAssociationTool,
# matched = 'matched',
# blockname = 'L2Info',
# prefix = 'L2_',
# MaxDR = 0.25,
# ChainPattern = 'L2_j.*')
# JetL2Assoc.defineBlock (99, 'L2Kinematics',
# EventCommonD3PDMaker.FourMomFillerTool,
# WriteE = True,
# WriteEt = False,
# WriteM = False)
# JetEFAssoc = SimpleAssociation(object,
# JetD3PDMaker.JetEFTriggerObjectAssociationTool,
# matched = 'matched',
# blockname = 'EFInfo',
# prefix = 'EF_',
# MaxDR = 0.25,
# ChainPattern = 'EF_j.*')
# JetEFAssoc.defineBlock (99, 'EFKinematics',
# EventCommonD3PDMaker.FourMomFillerTool,
# WriteE = True,
# WriteEt = False,
# WriteM = False)
# pass
# ConstitAssoc = ContainedVectorMultiAssociation \
# (object,
# #JetD3PDMaker.JetConstituentAssociationTool,
# EventCommonD3PDMaker.NavigableConstituentAssociationTool,
# 'constit_',
# TypeName = 'CaloCluster',
# nrowName = '',
# level = 1)
# ConstitAssoc.defineBlock (_constitAssocLevel, 'ConstitIndex',
# D3PDMakerCoreComps.IndexFillerTool,
# Target = '')
# # Beam Background Identification Method
# object.defineBlock( 999, 'BeamBackground',
# BackgroundD3PDMaker.BeamBackgroundJetFillerTool)
# #---------------- special jet moments ----------------------------
# object.defineBlock(999, 'TrackMF',
# JetD3PDMaker.JetMomentFillerTool,
# Moments=['TrackMFindex','TrackMF'])
# object.defineBlock(999, 'TracksMoments',
# JetD3PDMaker.JetMomentFillerTool,
# Moments=['nTrk_pv0_1GeV', 'sumPtTrk_pv0_1GeV', 'nTrk_allpv_1GeV', 'sumPtTrk_allpv_1GeV',
# 'nTrk_pv0_500MeV', 'sumPtTrk_pv0_500MeV',
# 'trackWIDTH_pv0_1GeV','trackWIDTH_allpv_1GeV'
# ])
# object.defineBlock(999, 'JetLabel',
# JetD3PDMaker.JetMomentFillerTool,
# Moments=['JetLabel'])
# object.defineBlock(999, 'Special',
# JetD3PDMaker.JetMomentFillerTool,
# Moments=['LikeLihood_0',
# 'LowEtConstituentsFrac','KtDr',
# ])
# object.defineBlock(999, 'VoronoiArea',
# JetD3PDMaker.JetMomentFillerTool,
# Moments=['VoronoiArea', 'VoronoiAreaPx', 'VoronoiAreaPy', 'VoronoiAreaPz', 'VoronoiAreaE',
# ])
# object.defineBlock(999, 'Isolation',
# JetD3PDMaker.JetMomentFillerTool,
# Moments=['IsoKR20Perp', 'IsoKR20Par', 'IsoKR20SumPt', 'IsoDelta2Perp', 'IsoDelta2Par',
# 'IsoDelta2SumPt', 'IsoFixedCone8Perp', 'IsoFixedCone8Par', 'IsoFixedCone8SumPt',
# 'IsoFixedArea13Perp', 'IsoFixedArea13Par', 'IsoFixedArea13SumPt',
# 'Iso6To88Perp', 'Iso6To88Par', 'Iso6To88SumPt',
# ])
# object.defineBlock(999, 'SplitInfo',
# JetD3PDMaker.JetMomentFillerTool,
# Moments=['SPLIT12', 'SPLIT23', 'SPLIT34'])
# object.defineBlock(999, 'Uncertainties',
# JetD3PDMaker.JetMomentFillerTool,
# Moments=['SmearingFactor'])
return object
# from AthenaCommon.AlgSequence import AlgSequence
from RecExConfig.RecFlags import rec
import egammaD3PDMaker
# import egammaD3PDAnalysis
import EventCommonD3PDMaker
# import CaloD3PDMaker
import D3PDMakerCoreComps
import TruthD3PDMaker
import TrackD3PDMaker
PhotonD3PDObject = \
make_SGDataVector_D3PDObject ('xAOD::PhotonContainer',
D3PDMakerFlags.PhotonSGKey(),
'ph_', 'PhotonD3PDObject')
# AuxPrefix args need to be deferred in order to add in the sgkey.
auxprefix = DeferArg(
'D3PDMakerFlags.EgammaUserDataPrefix() + "_" +'
'resolveSGKey (typeName, sgkey) + "_"', globals())
PhotonD3PDObject.defineBlock(0,
'Kinematics',
EventCommonD3PDMaker.FourMomFillerTool,
WriteE=True,
WriteEt=True,
WriteRect=True)
PhotonD3PDObject.defineBlock(0,
'Author',
def commonD3PD(
alg=None,
file='physics.root',
tuplename='physics',
streamname='d3pdstream',
doThirdMuonChain=True,
stdElectronContainer=D3PDMakerFlags.ElectronSGKey(),
gsfElectronContainer=D3PDMakerFlags.GSFElectronSGKey(),
muonContainer='None', # can be 'Muons' for third muon chain
stacoMuonContainer='StacoMuonCollection',
muidMuonContainer='MuidMuonCollection',
caloMuonContainer='CaloMuonCollection',
photonContainer=D3PDMakerFlags.PhotonSGKey(),
tauContainer=D3PDMakerFlags.TauSGKey(),
jetEM4Container='AntiKt4TopoEMJets',
jetEM6Container='AntiKt6TopoEMJets',
jetLC4Container='AntiKt4LCTopoJets',
jetLC6Container='AntiKt6LCTopoJets',
**kw):
flags = CommonD3PDMakerFlags
# define track and cluster filters
preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName())
if not hasattr(preseq, "GoodTracks"):
filter1 = makeTrackFilterAlg(TracksName=D3PDMakerFlags.TrackSGKey(),
OutputTracksName='GoodTracks',
ptCut=0.)
preseq += filter1
if not hasattr(preseq, "HighPtTracks"):
filter2 = makeTrackFilterAlg(TracksName=D3PDMakerFlags.TrackSGKey(),
OutputTracksName='HighPtTracks',
ptCut=4000.,
nSCTPix=4)
preseq += filter2
if not hasattr(preseq, "HighPtClusters"):
filter3 = makeClusterFilter(InputName=D3PDMakerFlags.ClusterSGKey(),
OutputName='HighPtClusters',
ptCut=10000.)
preseq += filter3
if not hasattr(preseq, "HighPtEMClusters"):
filter4 = makeClusterFilter(
InputName=D3PDMakerFlags.EMTopoClusterSGKey(),
OutputName='HighPtEMClusters',
ptCut=10000.)
preseq += filter4
if not hasattr(preseq, "SUSYTrackCandidate"):
filter5 = makeTrackFilterAlg(TracksName=D3PDMakerFlags.TrackSGKey(),
OutputTracksName='SUSYTrackCandidate',
ptCut=10000.)
preseq += filter5
# perform recoil calculation
from HadronicRecoil.Configurables import add_hadronic_recoil_filters
preseq = add_hadronic_recoil_filters(preseq)
# beam background stuff
from RecBackgroundAlgs.RecBackgroundAlgsConf import BeamBackgroundFiller
if not hasattr(preseq, "BeamBackgroundFiller"):
BeamBackgroundFiller = BeamBackgroundFiller()
preseq += BeamBackgroundFiller
# now configure the D3PD
if not alg:
alg = MSMgr.NewRootStream(StreamName=streamname,
FileName=file,
TreeName=tuplename)
alg += EventInfoD3PDObject(**_args(10, 'EventInfo', kw))
alg += LArCollisionTimeD3PDObject(**_args(10, 'LArCollisionTime', kw))
addBunchStructureMetadata(alg)
if flags.doEventShape():
alg += EventShapeD3PDObject(**_args(10, 'rho', kw))
if flags.doMuonSpShower2():
alg += MuonSpShowerD3PDObject(**_args(10, 'MuonSpShower', kw))
alg += BackgroundWordD3PDObject(**_args(0, 'BkgWord', kw))
alg += BeamBackgroundD3PDObject(1)
alg += DefaultV0D3PDObject(**_args(1, 'V0Objects', kw))
from D3PDMakerConfig.addTauD3PDInfo import addTauD3PDInfo
addTauD3PDInfo(alg, file, tuplename, kw)
# Eta rings of energy
if not rec.readAOD:
from CaloD3PDMaker.RapgapD3PDObject import EtaRingsNonTileD3PDObject
from CaloD3PDMaker.RapgapD3PDObject import EtaRingsD3PDObject
alg += EtaRingsNonTileD3PDObject(**_args(0, 'EtaRings', kw))
alg += EtaRingsD3PDObject(**_args(0, 'EtaRings', kw))
# Electron/Photon blocks
if (stdElectronContainer != 'None'):
alg += ElectronD3PDObject(**_args(10,
'Electron',
kw,
sgkey=stdElectronContainer,
include=flags.electronInclude()))
if (gsfElectronContainer != 'None') and testSGKey('ElectronContainer',
gsfElectronContainer):
alg += GSFElectronD3PDObject(**_args(10,
'GSFElectron',
kw,
sgkey=gsfElectronContainer,
prefix='el_gsf_',
include=flags.electronInclude()))
# define associations
if not PhotonD3PDObject.allBlocknames().has_key('RecoveryMatch'):
from PhotonD3PDMaker.PhotonRecoveryAssociation import PhotonRecoveryAssociation
if (stdElectronContainer != 'None'):
PhotonRecoveryAssoc = PhotonRecoveryAssociation(
PhotonD3PDObject,
'ElectronContainer',
stdElectronContainer,
prefix='el_',
include=['TrkFitQuality', 'Vertex'],
blockname='RecoveryMatch',
target='ph_ElectronRecovered_')
if (photonContainer != 'None'):
alg += PhotonD3PDObject(
**_args(10,
'Photon',
kw,
sgkey=photonContainer,
include=flags.photonInclude(),
ConversionVertexTrackIndex_target="GSF_trk"))
# Muon blocks
### Third muon chain variables!
if doThirdMuonChain and muonContainer == 'None':
muonContainer = 'Muons'
if (muonContainer != 'None'):
alg += myMuonD3PDObject(**_args(10,
'Muon',
kw,
sgkey=muonContainer,
prefix='mu_',
include=flags.muonInclude() + [
"EFCBInfoIndex", "EFMGInfoIndex",
"EFMEInfoIndex", "L2CBInfoIndex"
],
allowMissing=True))
if (muidMuonContainer != 'None'):
alg += myMuonD3PDObject(**_args(10,
'MuidMuon',
kw,
sgkey=muidMuonContainer,
prefix='mu_muid_',
include=flags.muonInclude() + [
"EFCBInfoIndex", "EFMGInfoIndex",
"EFMEInfoIndex", "L2CBInfoIndex"
],
allowMissing=True))
if (stacoMuonContainer != 'None'):
alg += myMuonD3PDObject(**_args(10,
'StacoMuon',
kw,
sgkey=stacoMuonContainer,
prefix='mu_staco_',
include=flags.muonInclude() + [
"EFCBInfoIndex", "EFMGInfoIndex",
"EFMEInfoIndex", "L2CBInfoIndex"
],
allowMissing=True))
if (caloMuonContainer != 'None'):
alg += myMuonD3PDObject(**_args(
10,
'CaloMuon',
kw,
sgkey=caloMuonContainer,
prefix='mu_calo_',
include=flags.muonInclude() + [
"MuonHitSummary", "Authors", "Likelihood", "CaloEnergyLoss",
"Quality"
],
#exclude = "Isolation"))
allowMissing=True))
# add missingEt info
from D3PDMakerConfig.addMissingEtInfo import addMissingEtInfo
addMissingEtInfo(alg, file, tuplename, kw)
# add Jets info
from D3PDMakerConfig.addJetsInfo import addJetsInfo
addJetsInfo(alg, file, tuplename, kw)
from HiggsD3PDMaker.HSG2VertexReconstruction import addHSG2VertexReconstruction
addHSG2VertexReconstruction(alg, muon_target="mu_")
alg += HforD3PDObject(**_args(0, 'HforInfo', kw))
# HadronicRecoil blocks
alg += ElectronD3PDObject(0, sgkey="HR_selectedElectrons", prefix="hr_el_")
alg += MuonD3PDObject(0, sgkey="HR_selectedMuons", prefix="hr_mu_")
# track and cluster blocks
#alg += ClusterD3PDObject (**_args ( 0, 'Clusters1', kw,
# include=['CenterMagMoments']))
#exclude=['SamplingBasics']))
# ... higher LOD for pt>10 GeV
#alg += ClusterD3PDObject (**_args ( 2, 'Clusters2', kw,
# sgkey = 'HighPtClusters',
# prefix = 'clpt10_'))
#alg += ClusterD3PDObject (**_args ( 3, 'Clusters3', kw,
# sgkey = 'HighPtEMClusters',
# prefix = 'emclpt10_'))
if flags.doClusterHad():
alg += ClusterD3PDObject(**_args(0,
'CaloCalTopoCluster',
kw,
prefix='cl_lc_',
exclude='SamplingBasics',
Kinematics_WriteE=False))
alg += ClusterD3PDObject(
**_args(2,
'CaloCalTopoCluster',
kw,
prefix='cl_',
exclude=['Kinematics', 'SamplingBasics'],
Kinematics_WriteE=False))
if flags.doClusterEM():
alg += ClusterD3PDObject(**_args(0,
'CaloCalTopoCluster',
kw,
prefix='cl_em_',
exclude='SamplingBasics',
Kinematics_WriteE=False,
Kinematics_SignalState=0))
# turn on detailed track info if writing SoftQCD version of D3PD
if flags.doSoftQCD():
alg += TrackParticleD3PDObject(
**_args(3,
'Tracks1',
kw,
sgkey='GoodTracks',
label='trk',
prefix='trk_',
doTruth=True,
TruthParticleTarget='mc_',
storeDiagonalCovarianceAsErrors=True,
storeHitTruthMatching=True,
storePixelHitsOnTrack=False,
storePixelHolesOnTrack=False,
storePixelOutliersOnTrack=False,
storeSCTHitsOnTrack=False,
storeTrackFitQuality=True,
storeTrackMomentum=True,
storeTrackSummary=True,
trackParametersAtBeamSpotLevelOfDetails=0,
trackParametersAtGlobalPerigeeLevelOfDetails=1,
trackParametersAtPrimaryVertexLevelOfDetails=2))
else:
alg += TrackParticleD3PDObject(**_args(
10,
'Tracks3',
kw,
sgkey='SUSYTrackCandidate',
label='trk10',
prefix='trk10_',
include=[
"Isolation", "Isolation_40_1GeV", "Isolation_40_2GeV",
"Isolation_40_3GeV", "Isolation_40_3GeV_hitschi",
"Isolation_40_4GeV", "Isolation_50_5GeV"
],
TruthParticleTarget='mc_',
trackParametersAtBeamSpotLevelOfDetails=2,
trackParametersAtPrimaryVertexLevelOfDetails=2,
#trackParametersAtBeamLineLevelOfDetails=2, # does not work??
trk_TrackSummary_FullInfo=False,
doTruth=True))
alg += TrackParticleD3PDObject(
**_args(10,
'Tracks1',
kw,
sgkey='GoodTracks',
label='trk',
prefix='trk_',
exclude=['trk_IPEstimate'],
TruthParticleTarget='mc_',
trackParametersAtBeamSpotLevelOfDetails=1,
trackParametersAtGlobalPerigeeLevelOfDetails=1,
trackParametersAtPrimaryVertexLevelOfDetails=2,
storeTrackParametersAtCalo=True,
storeTrackParametersAtCalo2ndLayer=True,
storeDiagonalCovarianceAsErrors=False,
storeTrackInfo=True,
storeHitTruthMatching=True,
doTruth=True))
alg += TrackParticleD3PDObject(
**_args(3,
'Tracks2',
kw,
sgkey='HighPtTracks',
label='trk4',
prefix='trkpt4_',
exclude=['trk_IPEstimate'],
doTruth=True,
TruthParticleTarget='mc_',
storeDiagonalCovarianceAsErrors=True,
storeHitTruthMatching=True,
storePixelHitsOnTrack=False,
storePixelHolesOnTrack=False,
storePixelOutliersOnTrack=False,
storeSCTHitsOnTrack=False,
storeSCTHolesOnTrack=False,
storeSCTOutliersOnTrack=False,
storeTRTHitsOnTrack=False,
storeTRTHolesOnTrack=False,
storeTRTOutliersOnTrack=False,
storeTrackFitQuality=True,
storeTrackMomentum=True,
storeTrackSummary=True,
trk_TrackSummary_IDOutliers=True,
trk_TrackSummary_PixelInfoPlus=True,
trk_TrackSummary_SCTInfoPlus=True,
trk_TrackSummary_TRTInfoPlus=True,
trk_TrackSummary_InfoPlus=True,
trk_TrackSummary_MuonHits=True,
trackParametersAtBeamSpotLevelOfDetails=0,
trackParametersAtGlobalPerigeeLevelOfDetails=2,
trackParametersAtPrimaryVertexLevelOfDetails=2,
storeTrackParametersAtCalo=False))
# Primary vertex block - May be missing in single-beam data.
alg += PrimaryVertexD3PDObject(**_args(3,
'PrimaryVertex',
kw,
allowMissing=True,
sgkey=D3PDMakerFlags.VertexSGKey(),
prefix='vxp_',
include=['Error']))
# MBTS
alg += MBTSD3PDObject(**_args(10, 'MBTS', kw))
alg += MBTSTimeD3PDObject(**_args(10, 'MBTSTime', kw))
alg += MBTSTriggerBitsD3PDObject(**_args(10, 'MBTSTriggerBits', kw))
alg += CollisionDecisionD3PDObject(**_args(10, 'CollisionDecision', kw))
# Truth
if rec.doTruth():
alg += TruthParticleD3PDObject(
10, sgkey=D3PDMakerFlags.TruthParticlesSGKey())
alg += TruthVertexD3PDObject(
**_args(1, 'TruthVertex', kw, sgkey=D3PDMakerFlags.TruthSGKey()))
alg += TruthMuonD3PDObject(**_args(2, 'TruthMuon', kw))
alg += GenEventD3PDObject(**_args(
1, 'GenEvent', kw)) #, filter = CoreTruthFilterTool() ))
# ... heavy flavor truth information
#from TruthD3PDMaker.TruthD3PDMakerKeys import TruthD3PDKeys
#TruthD3PDKeys.TruthTrackGetterLabel.set_Value("D3PDTruth_TruthTrack")
alg += GenVertexD3PDObject(**_args(0,
"hfgenvertex",
kw,
prefix='mchfvtx_',
filter=smwzhfGenVtxFilterTool))
alg += GenTruthTrackD3PDObject(**_args(0, "TruthTracks", kw))
alg += GenParticleD3PDObject(
**_args(10,
"hfgenparticle",
kw,
prefix='mchfpart_',
filter=smwzhfGenPartFilterTool,
GenParticle_WriteMotherType=False,
GenParticle_WriteMotherBarcode=False))
# ... leptonic W/Z truth information
alg += GenParticleD3PDObject(**_args(
10,
"lepwzgenparticle",
kw,
prefix='mclepwzpart_',
filter=smwzlepwzGenPartFilterTool,
label="LepWZTruthD3PDObject",
exclude=["GenPartProdVertexAssoc", "GenPartDecayVertexAssoc"],
GenParticle_WriteMotherType=False,
GenParticle_WriteMotherBarcode=False,
GenPartMotherAssoc_target="LepWZTruthD3PDObject",
GenPartChildAssoc_target="LepWZTruthD3PDObject"))
alg += egammaTruthD3PDObject(0)
if (SUSYD3PDFlags.includeSUSYHardProcess()):
alg += SUSYHardProcessD3PDObject(**_args(0, 'HardProcess', kw))
# A dictionary of store gate keys and ntuple variable prefix
truthParticleContainers = {
'TruthTopVertexContainer': 'mc_t_vx_',
'TruthWVertexContainer': 'mc_W_vx_',
'TruthZVertexContainer': 'mc_Z_vx_',
'TruthTopDecayContainer': 'mc_t_vx_end_',
'TruthWDecayContainer': 'mc_W_vx_end_',
'TruthZDecayContainer': 'mc_Z_vx_end_',
'TruthWTauContainer': 'mc_W_tau_',
'TruthZTauContainer': 'mc_Z_tau_'
}
#import D3PDMakerCoreComps
from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject
from TruthD3PDMaker import TruthParticleGenParticleAssociationTool
for contKey, prefix in truthParticleContainers.iteritems():
truthPartObj = make_SGDataVector_D3PDObject(
'TruthParticleContainer', contKey, prefix, "truthPartObj")
genPart = SimpleAssociation(
truthPartObj, TruthParticleGenParticleAssociationTool)
trupart2 = IndexAssociation(
genPart,
TruthD3PDMaker.GenParticleTruthParticleAssociationTool,
target='mc_',
Target='mc_')
alg += truthPartObj(0, prefix)
#if not rec.doTruth():
# alg += BeamSpotD3PDObject(10)
# Trigger
if D3PDMakerFlags.DoTrigger():
from PhysicsD3PDMaker.SMWZTriggerBitsD3PDObject import SMWZTriggerBitsD3PDObject
alg += SMWZTriggerBitsD3PDObject(**_args(10, 'SMWZTriggerBits', kw))
alg += GenericTriggerBitsD3PDObject(
**_args(10, 'GenericTriggerBits', kw))
alg += InitTrigD3PDObject(10)
# Trigger Decision + metadata
alg += TrigDecisionD3PDObject(**_args(10, 'TrigDecision', kw))
#addTrigConfMetadata(alg)
####### begin from TRIGBJET ########
from TriggerD3PDMaker.JetETROID3PDObject import JetETROID3PDObject
from JetD3PDMaker.jetMETD3PDTrigger import jetMETTriggerBitsD3PDObject
alg += jetMETTriggerBitsD3PDObject(10)
alg += JetETROID3PDObject(10)
# The L2 JE information:
from TrigMissingETD3PDMaker.TrigMETD3PDObject import TrigMETD3PDObject
alg += TrigMETD3PDObject(level=10,
prefix="trig_L2_je_",
sgkey="HLT_L2JetEtSum",
allowMissing=True)
###### end from TRIGBJET ########
# Bunch group info
alg += BGCodeD3PDObject(**_args(2, 'BGCode', kw))
# Egamma and Mu
TrigEgammaD3PDObjects(alg, 10)
TrigMuonD3PDObjects(alg, 10, addNaviInfo=True, addConfigInfo=True)
alg += egammaTriggerBitsD3PDObject(**_args(0, 'egammaTriggerBits', kw))
alg += MuonTriggerBitsD3PDObject(**_args(2, 'MuonTriggerBits', kw))
alg += JetROID3PDObject(
**_args(10, 'JetROI', kw, prefix="trig_L1_jet_"))
alg += TrigJetD3PDObject(**_args(2,
'TrigJet',
kw,
sgkey='HLT_TrigT2CaloJet',
prefix='trig_L2_jet_',
allowMissing=True))
alg += EFJetD3PDObject(**_args(2,
'EFJet',
kw,
sgkey='HLT_TrigJetRec',
prefix='trig_EF_jet_',
allowMissing=True,
include=['Triggers']))
# MET
TrigMETD3PDObjects(alg)
alg += METD3PDTriggerBitsObject(0)
# The BJet information:
TrigBJetD3PDObjects(alg,
level=10,
doAddL2ID=True,
doAddEFID=True,
addNaviInfo=True,
addConfigInfo=True,
addL1Jet=True) #, addOffTrack = True)
alg += QcdTriggerBitsD3PDObject(**_args(10, 'TriggerBits', kw))
from TrigTauD3PDMaker.TrigTauD3PD import TrigTauD3PDObjects
TrigTauD3PDObjects(alg, 2)
# Event metadata
alg.MetadataTools += [LBMetadataConfig()]
alg.MetadataTools += [CutFlowMetadataConfig(alg)]
# begin for add CutflowSvc
#EventBookkeepers
#from AthenaCommon.AppMgr import ServiceMgr as svcMgr
#from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
#if not hasattr(svcMgr,"CutFlowSvc"):
# from EventBookkeeperTools.EventBookkeeperToolsConf import CutFlowSvc
# svcMgr+=CutFlowSvc()
# pass
#if rec.readAOD() or rec.readESD():
#force CutFlowSvc execution (necessary for file merging)
# theApp.CreateSvc+=['CutFlowSvc']
# pass
# Determine current skimming cycle and input stream name
#from RecExConfig.InputFilePeeker import inputFileSummary
#from RecExConfig.RecoFunctions import GetSkimCycle
#inputCycle=GetSkimCycle(inputFileSummary)
#if inputCycle<0:
# currentCycle=1
#else:
# currentCycle=inputCycle+1
# pass
#svcMgr.CutFlowSvc.SkimmingCycle=currentCycle
#svcMgr.CutFlowSvc.InputStream=rec.mergingStreamName()
#Exception for DPD pass-through mode
#if rec.doDPD.passThroughMode:
# svcMgr.CutFlowSvc.SkimmingCycle=0
# svcMgr.CutFlowSvc.InputStream="Virtual"
# pass
#if rec.DPDMakerScripts()!=[] and not rec.doDPD.passThroughMode :
# #Create a separate EventBookkeeper list to persistify skimming cycle info
# from EventBookkeeperTools.BookkeepingInfoWriter import EventBookkeepersWriter
# SkimmingCycleDefiner=EventBookkeepersWriter("SkimmingCycleDefiner")
# SkimmingCycleDefiner.OutputCollectionName="cycle"+str(currentCycle)
# SkimmingCycleDefiner.ParentStreamName=rec.mergingStreamName()
# topSequence = AlgSequence()
# topSequence+=SkimmingCycleDefiner #
#Explicitely add file metadata from input and from transient store
# MSMgr.AddMetaDataItemToAllStreams(inputFileSummary['metadata_itemsList'])
# MSMgr.AddMetaDataItemToAllStreams( "LumiBlockCollection#*" )
# MSMgr.AddMetaDataItemToAllStreams( "EventBookkeeperCollection#*" )
# MSMgr.AddMetaDataItemToAllStreams( "IOVMetaDataContainer#*" )
# pass
# end for add CutflowSvc
if D3PDMakerFlags.FilterCollCand():
from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg
alg.filterSeq += CollisionFilterAlg(tuplename + '_CollCandFilter')
# Add BeamSpot information
from TrackD3PDMaker.BeamSpotD3PDObject import BeamSpotD3PDObject
alg += BeamSpotD3PDObject(10)
#-------------------------------------------------------------------------------------
# Diphoton information... in order to run this, need to have setup the diphoton
# analysis algorithm. See CommonD3PD_prodJobOFragment.py.
#
from PhotonD3PDMaker.DiPhotonD3PDObject import DiPhotonD3PDObject
alg += DiPhotonD3PDObject(**_args(10, 'DiPhoton', kw))
#-------------------------------------------------------------------------------------
#from D3PDMakerCoreComps.resolveSGKey import testSGKey
GSFTrackParticlesInSample = testSGKey('Rec::TrackParticleContainer',
"GSFTrackParticleCandidate")
if GSFTrackParticlesInSample:
GSFTrackParticleD3PDObject = TrackD3PDObject(
_label='trk',
_prefix='trk_',
_sgkey=D3PDMakerFlags.TrackSGKey(),
_object_name='GSFTrackParticleD3PDObject',
typeName='Rec::TrackParticleContainer',
vertexTarget='PV_',
vertexPrefix='PV_',
vertexSGKey='VxPrimaryCandidate',
truthTarget='mc',
truthPrefix='mc_',
detailedTruthPrefix='detailed_mc_',
truthMapKey='GSFTrackParticleTruthCollection',
SGKeyForTruth="GSFTrackParticleCandidate",
detailedTruthMapKey='DetailedTrackTruth',
SGKeyForDetailedTruth='Tracks',
flags=TrackD3PDFlags)
# add a flag for conversion tracks
from TrackD3PDMaker import TrackParticleVertexAssociationTool
from PhotonD3PDMaker import GSFOriginalTrackParticleAssociationTool
convTrackAssociation = SimpleAssociation \
(GSFTrackParticleD3PDObject,
TrackParticleVertexAssociationTool,
prefix = 'GSF_conv_',
blockname='ConversionTrackParticle',
VxSGKey='AllPhotonsVxCandidates')
origTrackAssociation = IndexAssociation \
(GSFTrackParticleD3PDObject,
#PhotonD3PDMaker.GSFOriginalTrackParticleAssociationTool,
GSFOriginalTrackParticleAssociationTool,
target="trk",
prefix="trk_",
level=0,
blockname="GSFOriginalTPAssoc",
allowMissing=False,
AssocGetter = D3PDMakerCoreComps.SGObjGetterTool
('GSFAssocGetter',
SGKey = D3PDMakerFlags.GSFTrackAssocSGKey(),
TypeName = 'TrackParticleAssocs'))
alg += GSFTrackParticleD3PDObject(0,
sgkey="GSFTrackParticleCandidate",
label="GSF_trk",
prefix="GSF_trk_")
from PhotonD3PDMaker.PhotonPVD3PDObject import PVD3PDObject
alg += PVD3PDObject(**_args(0,
'PrimaryVertex',
kw,
allowMissing=True,
sgkey=D3PDMakerFlags.VertexSGKey(),
prefix='PhotonPV_'))
return alg
def xAODTrackD3PDObject(_label='trkTrack',
_prefix='trkTrack_',
_sgkey='TrackParticleCandidate',
_object_name='TrackD3PDObject',
vertexTarget='vx',
vertexPrefix='vx_',
vertexSGKey='VxPrimaryCandidate',
flags=TrackD3PDFlags):
object = make_SGDataVector_D3PDObject (
'xAOD::TrackParticleContainer',
_sgkey,
_prefix,
_object_name,
default_allowMissing = True,
default_label = _label,
allow_args = ['storeTrackMomentum',
'trackParametersAtGlobalPerigeeLevelOfDetails',
'trackParametersAtPrimaryVertexLevelOfDetails',
'trackParametersAtBeamSpotLevelOfDetails',
'storeDiagonalCovarianceAsErrors',
'storeTrackFitQuality',
'storeTrackPredictionAtBLayer',
'storeTrackInfo',
'storeVertexAssociation',
'storeTrackSummary',
])
## default perigee (at (0,0,0))
PerigeeAssoc = PerigeeAssociation\
(object,
TrackD3PDMaker.TrackParticlePerigeeAtOOAssociationTool,
"GlobalPerigee",
fillMomName = 'storeTrackMomentum',
levelName = 'trackParametersAtGlobalPerigeeLevelOfDetails')
from AthenaCommon.AppMgr import ToolSvc
if hasattr(ToolSvc, 'InDetRecTestBLayerTool'):
PerigeeAssoc.defineBlock (flagTestLOD('storeTrackPredictionAtBLayer', flags),
_prefix+'BLayerInfo',
TrackD3PDMaker.PerigeeBLPredictionFillerTool,
InDetTestBLayerTool = ToolSvc.InDetRecTestBLayerTool)
# perigee at Primary Vertex
PerigeeAtPVAssoc = PerigeeAssociation\
(object,
TrackD3PDMaker.TrackParticlePerigeeAtPVAssociationTool,
"PerigeeAtPV",
suffix='_wrtPV',
levelName = 'trackParametersAtPrimaryVertexLevelOfDetails')
# perigee at Beam Spot
PerigeeAtBSAssoc = PerigeeAssociation\
(object,
TrackD3PDMaker.TrackParticlePerigeeAtBSAssociationTool,
"PerigeeAtBS",
suffix='_wrtBS',
levelName = 'trackParametersAtBeamSpotLevelOfDetails')
object.defineBlock(flagTestLOD('storeTrackFitQuality', flags),
_prefix+'FitQuality',
D3PDMakerCoreComps.AuxDataFillerTool,
Vars = ['chiSquared',
'numberDoF'])
# Track Summary
class SumVars:
HitSum = 1 << 0
HoleSum = 1 << 1
IDHits = 1 << 2
IDHoles = 1 << 3
IDSharedHits = 1 << 4
IDOutliers = 1 << 5
PixelInfoPlus = 1 << 6
SCTInfoPlus = 1 << 7
TRTInfoPlus = 1 << 8
InfoPlus = 1 << 9
ExpectBLayer = 1 << 10
MuonHits = 1 << 11
DBMHits = 1 << 12
varsTable = [
# ID hits
[IDHits, 'nBLHits', 'numberOfInnermostPixelLayerHits'],
[IDHits + HitSum, 'nPixHits', 'numberOfPixelHits' ],
[IDHits + HitSum, 'nSCTHits', 'numberOfSCTHits' ],
[IDHits + HitSum, 'nTRTHits', 'numberOfTRTHits' ],
[IDHits, 'nTRTHighTHits', 'numberOfTRTHighThresholdHits'],
[IDHits, 'nTRTXenonHits', 'numberOfTRTXenonHits'],
# ID holes + dead sensors - needed for appropriate cutting
[IDHoles + HoleSum, 'nPixHoles', 'numberOfPixelHoles' ],
[IDHoles + HoleSum, 'nSCTHoles', 'numberOfSCTHoles' ],
[IDHoles + HoleSum, 'nTRTHoles', 'numberOfTRTHoles' ],
[IDHoles, 'nPixelDeadSensors', 'numberOfPixelDeadSensors' ],
[IDHoles, 'nSCTDeadSensors', 'numberOfSCTDeadSensors' ],
# ID shared & Split hits
[IDSharedHits, 'nBLSharedHits', 'numberOfInnermostPixelLayerSharedHits'],
[IDSharedHits, 'nPixSharedHits', 'numberOfPixelSharedHits'],
[IDSharedHits, 'nSCTSharedHits', 'numberOfSCTSharedHits'],
[IDSharedHits, 'nBLayerSplitHits', 'numberOfInnermostPixelLayerSplitHits'],
[IDSharedHits, 'nPixSplitHits', 'numberOfPixelSplitHits'],
# ID outliers
[IDOutliers, 'nBLayerOutliers', 'numberOfInnermostPixelLayerOutliers' ],
[IDOutliers, 'nPixelOutliers', 'numberOfPixelOutliers' ],
[IDOutliers, 'nSCTOutliers', 'numberOfSCTOutliers' ],
[IDOutliers, 'nTRTOutliers', 'numberOfTRTOutliers'],
[IDOutliers, 'nTRTHighTOutliers', 'numberOfTRTHighThresholdOutliers'],
# Pixel info plus
[PixelInfoPlus, 'nContribPixelLayers', 'numberOfContribPixelLayers' ],
[PixelInfoPlus, 'nGangedPixels', 'numberOfGangedPixels' ],
[PixelInfoPlus, 'nGangedFlaggedFakes', 'numberOfGangedFlaggedFakes' ],
[PixelInfoPlus, 'nPixelSpoiltHits', 'numberOfPixelSpoiltHits' ],
# SCT info plus
[SCTInfoPlus, 'nSCTDoubleHoles', 'numberOfSCTDoubleHoles' ],
[SCTInfoPlus, 'nSCTSpoiltHits', 'numberOfSCTSpoiltHits' ],
# TRT info plus
[TRTInfoPlus, 'nTRTDeadStraws', 'numberOfTRTDeadStraws' ],
[TRTInfoPlus, 'nTRTTubeHits', 'numberOfTRTTubeHits' ],
[TRTInfoPlus, 'nTRTSharedHits', 'numberOfTRTSharedHits' ],
[TRTInfoPlus, 'nTRTHTHitsTotal', 'numberOfTRTHighThresholdHitsTotal' ],
# Info plus
[InfoPlus, 'nOutliersOnTrack', 'numberOfOutliersOnTrack'],
[InfoPlus, 'standardDeviationOfChi2OS',],
# Expect BLayer hit
[ExpectBLayer, 'expectInnermostPixelLayerHit'],
# Muon hits
[MuonHits + HitSum, 'numberOfPrecisionLayers'],
[MuonHits + HitSum, 'numberOfPrecisionHoleLayers'],
[MuonHits + HitSum, 'numberOfPhiLayers'],
[MuonHits + HitSum, 'numberOfPhiHoleLayers'],
[MuonHits + HitSum, 'numberOfTriggerEtaLayers'],
[MuonHits + HitSum, 'numberOfTriggerEtaHoleLayers'],
]
@classmethod
def varlist (cls,
FullInfo,
IDHits,
IDHoles,
IDSharedHits,
IDOutliers,
PixelInfoPlus,
SCTInfoPlus,
TRTInfoPlus,
InfoPlus,
ExpectBLayer,
MuonHits,
DBMHits,
HitSum,
HoleSum,
ElectronPID,
PixeldEdx):
ret = []
mask = 0
if FullInfo: mask = ~0
if IDHits: mask |= cls.IDHits
if IDHoles: mask |= cls.IDHoles
if IDSharedHits: mask |= cls.IDSharedHits
if IDOutliers: mask |= cls.IDOutliers
if PixelInfoPlus: mask |= cls.PixelInfoPlus
if SCTInfoPlus: mask |= cls.SCTInfoPlus
if TRTInfoPlus: mask |= cls.TRTInfoPlus
if InfoPlus: mask |= cls.InfoPlus
if ExpectBLayer: mask |= cls.ExpectBLayer
if MuonHits: mask |= cls.MuonHits
if DBMHits: mask |= cls.DBMHits
if HitSum: mask |= cls.HitSum
if HoleSum: mask |= cls.HoleSum
for v in cls.varsTable:
if (v[0] & mask) != 0:
var = v[1]
enum = v[2] if len(v) >= 3 else var
ret.append (var + ' = ' + enum)
if ElectronPID or FullInfo:
ret.append ('eProbabilityComb')
ret.append ('eProbabilityHT')
if PixeldEdx or FullInfo:
ret.append ('pixeldEdx')
ret.append ('numberOfUsedHitsdEdx')
ret.append ('numberOfIBLOverflowsdEdx')
return ret
sumvarlist = SumVars.varlist (
FullInfo = flags.storeTrackSummary.FullInfo,
IDHits = flags.storeTrackSummary.IDHits,
IDHoles = flags.storeTrackSummary.IDHoles,
IDSharedHits = flags.storeTrackSummary.IDSharedHits,
IDOutliers = flags.storeTrackSummary.IDOutliers,
PixelInfoPlus = flags.storeTrackSummary.PixelInfoPlus,
SCTInfoPlus = flags.storeTrackSummary.SCTInfoPlus,
TRTInfoPlus = flags.storeTrackSummary.TRTInfoPlus,
InfoPlus = flags.storeTrackSummary.InfoPlus,
ExpectBLayer = flags.storeTrackSummary.ExpectBLayer,
MuonHits = flags.storeTrackSummary.MuonHits,
DBMHits = flags.storeTrackSummary.DBMHits,
HitSum = flags.storeTrackSummary.HitSum,
HoleSum = flags.storeTrackSummary.HoleSum,
ElectronPID = flags.storeTrackSummary.ElectronPID,
PixeldEdx = flags.storeTrackSummary.PixeldEdx,
)
object.defineBlock (flagTestLOD('storeTrackSummary', flags),
_prefix + 'TrackSummary',
D3PDMakerCoreComps.AuxDataFillerTool,
Vars = sumvarlist)
# Track Info
object.defineBlock (flagTestLOD('storeTrackInfo', flags),
_prefix + 'TrackInfo',
D3PDMakerCoreComps.AuxDataFillerTool,
Vars = ['trackFitter',
'particleHypothesis',
'trackProperties',
'patternRecoInfo'])
# Vertex association
VertexAssoc = IndexAssociation (
object,
TrackD3PDMaker.TrackParticleVertexAssociationTool,
vertexTarget,
prefix = vertexPrefix,
VxSGKey = vertexSGKey,
level = flagTestLOD('storeVertexAssociation', flags))
return object
def getJetTileD3PDObject(objectname='JetTileD3PDObject',
prefix='jet_',
btagleveloffset=7):
object = make_SGDataVector_D3PDObject('JetCollection',
D3PDMakerFlags.JetSGKey(), prefix,
objectname)
object.defineHook(_fixJetTiming)
object.defineBlock(0,
'Kinematics',
EventCommonD3PDMaker.FourMomFillerTool,
WriteE=True)
object.defineBlock(1,
'OriginCorrection',
JetD3PDMaker.JetMomentFillerTool,
Moments=['EtaOrigin', 'PhiOrigin', 'MOrigin'])
object.defineBlock(
1,
'DQMoments',
JetD3PDMaker.JetMomentFillerTool,
Moments=[
'WIDTH', 'n90', 'Timing', 'LArQuality', 'nTrk', 'sumPtTrk',
'OriginIndex', 'HECQuality', 'NegativeE', 'AverageLArQF',
'BCH_CORR_CELL', 'BCH_CORR_DOTX', 'BCH_CORR_JET',
'BCH_CORR_JET_FORCELL', 'ENG_BAD_CELLS', 'N_BAD_CELLS',
'N_BAD_CELLS_CORR', 'BAD_CELLS_CORR_E', 'NumTowers',
'ootFracCells5', 'ootFracCells10', 'ootFracClusters5',
'ootFracClusters10'
])
object.defineBlock(1, 'JetSamplingsFrac',
JetD3PDMaker.JetSamplingsFracFillerTool)
object.defineBlock(1, 'JetQual', JetD3PDMaker.JetCaloUtilsFillerTool)
object.defineBlock(1, 'EMFraction', JetD3PDMaker.JetEMFractionFillerTool)
object.defineBlock(
1,
'JES',
JetD3PDMaker.JetMomentFillerTool,
Moments=['Offset', 'EMJES', 'EMJES_EtaCorr', 'EMJESnooffset'])
object.defineBlock(1,
'EMScale',
JetD3PDMaker.JetSignalStateFillerTool,
WriteE=True,
SignalStateNumber=0,
SignalStatePrefix='emscale')
object.defineBlock(2, 'JetTileFiller', JetD3PDMaker.JetTileCellFillerTool)
# object.defineBlock(3, 'JVtx',
# JetD3PDMaker.JetVtxFillerTool,
# JetVertexAssociationTool=_getJvfTool())
object.defineBlock(3,
'Layer',
JetD3PDMaker.JetMomentFillerTool,
Moments=['GSCFactorF', 'WidthFraction'])
object.defineBlock(4, 'Samplings', JetD3PDMaker.JetSamplingsFillerTool)
object.defineBlock(5,
'JESMoments',
JetD3PDMaker.JetMomentFillerTool,
Moments=['LCJES'])
# Moments=['GCWJES', 'GCWJES_EtaCorr','CB'])
object.defineBlock(5, 'JetShape', JetD3PDMaker.JetShapeFillerTool)
object.defineBlock(5,
'Constituents',
JetD3PDMaker.JetConstituentFillerTool,
SignalStateNumber=0,
SignalStatePrefix='emscale')
object.defineBlock(5,
'ConstituentScale',
JetD3PDMaker.JetSignalStateFillerTool,
WriteE=True,
SignalStateNumber=2,
SignalStatePrefix='constscale')
object.defineBlock(6,
'JetLArHVMoment',
JetD3PDMaker.JetMomentFillerTool,
Moments=['LArBadHVEnergy', 'LArBadHVRatio'])
addBTagInfoToJetObject(object, btagleveloffset)
# Track association cannot be done unless there are tracks.
# As often this is not the case track association will be done only
# if this is explicitly asked for. by defining it in the include list.
#
# You can also enable it by passing an argument to JetD3PDObject
# like:
# AssocTrackCont_target='mytarget_'
def _jetAssocLevel(reqlev, args):
return args.has_key('target') or (reqlev >= 999)
IndexMultiAssociation(object,
JetD3PDMaker.FlavorAssociationTool,
'trk',
prefix='flavor_assoctrk_',
level=_jetAssocLevel,
blockname='AssocTrackCont')
object.defineBlock(10, 'JetRoIword', JetD3PDMaker.JetROIWordFillerTool)
JetElAssoc = DRAssociation(object,
"ElectronContainer",
D3PDMakerFlags.ElectronSGKey(),
0.2,
prefix='el_',
matched="matched",
blockname="El02Match")
JetMuAssoc = DRAssociation(object,
"Analysis::MuonContainer",
D3PDMakerFlags.MuonSGKey(),
0.2,
prefix='mu_',
matched="matched",
blockname="Mu02Match")
#JetTrkAssoc = DRAssociation(object,"Rec::TrackParticleContainer",D3PDMakerFlags.TrackSGKey(),0.4,prefix='trk_',matched="matched",blockname="Trk04Match")
#---------------- Trigger Object ----------------------------
JetL1Assoc = SimpleAssociation(
object,
JetD3PDMaker.JetL1TriggerObjectAssociationTool,
matched='matched',
blockname='L1Info',
prefix='L1_',
MaxDR=0.6,
ChainPattern='L1_J.*')
JetL1Assoc.defineBlock(99,
'L1Kinematics',
EventCommonD3PDMaker.FourMomFillerTool,
WriteE=True,
WriteEt=False,
WriteM=False)
JetL2Assoc = SimpleAssociation(
object,
JetD3PDMaker.JetL2TriggerObjectAssociationTool,
matched='matched',
blockname='L2Info',
prefix='L2_',
MaxDR=0.25,
ChainPattern='L2_j.*')
JetL2Assoc.defineBlock(99,
'L2Kinematics',
EventCommonD3PDMaker.FourMomFillerTool,
WriteE=True,
WriteEt=False,
WriteM=False)
JetEFAssoc = SimpleAssociation(
object,
JetD3PDMaker.JetEFTriggerObjectAssociationTool,
matched='matched',
blockname='EFInfo',
prefix='EF_',
MaxDR=0.25,
ChainPattern='EF_j.*')
JetEFAssoc.defineBlock(99,
'EFKinematics',
EventCommonD3PDMaker.FourMomFillerTool,
WriteE=True,
WriteEt=False,
WriteM=False)
ConstitAssoc = ContainedVectorMultiAssociation \
(object,
#JetD3PDMaker.JetConstituentAssociationTool,
EventCommonD3PDMaker.NavigableConstituentAssociationTool,
'constit_',
TypeName = 'CaloCluster',
nrowName = '',
level = 1)
ConstitAssoc.defineBlock(_constitAssocLevel,
'ConstitIndex',
D3PDMakerCoreComps.IndexFillerTool,
Target='')
return object
def JSD3PD(jetsToWrite,
alg=None,
scheduleOnly=False,
level=10,
file='js.root',
tuplename='js'):
if not alg:
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
alg = MSMgr.NewRootStream(tuplename, file, asAlg=True)
commonExcludeList = [
'El02Match', 'Mu02Match', 'L1Info', 'L2Info', 'EFInfo'
]
commonIncludeList = []
import re
JetAlgPattern = re.compile(
r'^(\D+)(\d{1,2})(\D+)Jets') #assuming standard notation
ars = JetAlgPattern.match(jetsToWrite[0]).groups()
parentJets = ''.join(ars) #remove the 'Jets' at the end
groomedJetsList = jetsToWrite[1]
parentJetsWithoutJS = parentJets
if parentJets[-2:] == 'JS': parentJetsWithoutJS = parentJets[:-2]
parentJetsWithoutJSForGrooming = parentJetsWithoutJS
if scheduleOnly: parentJetsWithoutJS += "Jets"
filteredSequence = AlgSequence('TopWGFilter')
theZeroLevel = 0
if not scheduleOnly:
MyJetD3PDObject = getJetD3PDObject(objectname='MyJetD3PDObject')
MyJetD3PDObject._hookArgs['seq'] = filteredSequence
else:
from TopInputsD3PDMaker.topInputsD3PD import JetD3PDObject
MyJetD3PDObject = JetD3PDObject
mylod = myLOD('jet_' + parentJetsWithoutJS + '_')
theZeroLevel = mylod._prefixLOD
MyGroomedJetD3PDObject = getJetD3PDObject(
objectname='MyGroomedJetD3PDObject')
MyGroomedJetD3PDObject._hookArgs['seq'] = filteredSequence
## Electron LC cluster overlap map
if ('LCTopo' in parentJets) and (not hasattr(
alg, 'ElecTopoClusterAssoc_Filler')):
MyJetAssocD3PDObject = make_SGDataVector_D3PDObject(
'DataVector<INavigable4Momentum>',
'ElectronAODCollection_CaloCalTopoCluster_jetsubstructure_electrons',
'ElecTopoClusterAssoc_', 'myJetAssocD3PDObject')
AddAssocConstitIndex(MyJetAssocD3PDObject)
AddAssocConstitIndex(MyJetAssocD3PDObject, 'CaloCluster', 'cl_')
alg += MyJetAssocD3PDObject(0)
if 'Track' in parentJets:
AddConstitIndex(MyGroomedJetD3PDObject,
typename='Rec::TrackParticle',
target='trk')
AddConstitIndex(MyJetD3PDObject,
typename='Rec::TrackParticle',
target='trk',
level=theZeroLevel)
AddLeptonicInfo(MyJetD3PDObject, level=theZeroLevel)
AddLeptonicInfo(MyGroomedJetD3PDObject, 99)
elif 'Topo' in parentJets:
AddConstitIndex(MyGroomedJetD3PDObject)
AddConstitIndex(MyJetD3PDObject, level=theZeroLevel)
AddLeptonicInfo(MyJetD3PDObject, level=theZeroLevel)
AddLeptonicInfo(MyGroomedJetD3PDObject, 99)
elif 'Truth' in parentJets:
if ars[1] == '4':
from JetD3PDMaker.JetD3PDMakerConf import D3PD__JetShapeFillerTool
from JetD3PDMaker.JetD3PDMakerConf import D3PD__JetTrueTagFillerTool
MyJetD3PDObject.defineBlock(theZeroLevel, 'myJetShape',
D3PD__JetShapeFillerTool)
MyJetD3PDObject.defineBlock(theZeroLevel, 'TrueFlavorComponents',
D3PD__JetTrueTagFillerTool)
AddConstitTruthIndex(MyJetD3PDObject, level=theZeroLevel)
AddTruthLeptonicInfo(MyJetD3PDObject, level=theZeroLevel)
AddTruthLeptonicInfo(MyGroomedJetD3PDObject, level=99)
AddConstitTruthIndex(MyGroomedJetD3PDObject)
if 'Track' not in parentJets and 'Truth' not in parentJets:
AddAssocJetsIndex(MyJetD3PDObject,
'TrackJets',
'jet_' + ars[0] + ars[1] + 'TrackZ_',
level=theZeroLevel)
if rec.doTruth():
AddAssocJetsIndex(MyJetD3PDObject,
'TruthJets',
'jet_' + ars[0] + ars[1] + 'Truth_',
level=theZeroLevel)
JetQualInclude = []
if 'Topo' in parentJets:
commonIncludeList += ['ConstituentScale', 'EMScale']
if not scheduleOnly:
AddHadronicInfo(MyJetD3PDObject, [
'OriginIndex', 'nTrk', 'sumPtTrk', 'EtaOrigin', 'PhiOrigin',
'MOrigin'
],
theblockname='OriginIndexBlock')
AddHadronicInfo(MyGroomedJetD3PDObject,
['EtaOrigin', 'PhiOrigin', 'MOrigin'],
theblockname='OriginIndexBlock',
level=99)
if (parentJetsWithoutJS == 'AntiKt10LCTopo') or (parentJetsWithoutJS
== 'CamKt12LCTopo'):
AddHadronicInfo(MyJetD3PDObject,
['LCJES', 'LCJES_EtaCorr', 'LCJES_MassCorr'],
theblockname='LCJESBlock',
level=theZeroLevel)
AddHadronicInfo(MyGroomedJetD3PDObject,
['LCJES', 'LCJES_EtaCorr', 'LCJES_MassCorr'],
theblockname='LCJESBlock')
if ars[1] == '4' or ars[1] == '6':
if not scheduleOnly:
AddHadronicInfo(MyJetD3PDObject, ['EMJES', 'EMJES_EtaCorr'],
theblockname='EMJESBlock',
level=99)
AddHadronicInfo(MyJetD3PDObject, ['LCJES', 'LCJES_EtaCorr'],
theblockname='LCJESBlock',
level=99)
AddHadronicInfo(MyJetD3PDObject, [
'Timing', 'LArQuality', 'HECQuality', 'NegativeE',
'AverageLArQF'
],
theblockname='QMomentsBlock')
if 'TopoEM' in ars[2]:
JetQualInclude += ['EMJESBlock', 'JetQual']
elif 'LCTopo' in ars[2]:
JetQualInclude += ['LCJESBlock', 'JetQual']
VtxInclude = []
if 'Topo' in parentJets:
VtxInclude += ['JVtx', 'JetVertexFraction']
elif 'Track' in parentJets:
VtxInclude += ['JVtx']
AddAssocJetsIndex(MyGroomedJetD3PDObject, 'Parent',
'jet_' + parentJetsWithoutJS + '_')
for gr in groomedJetsList:
AddAssocJetsIndex(MyJetD3PDObject,
gr,
'jet_' + parentJetsWithoutJSForGrooming + gr + '_',
level=theZeroLevel)
MyGroomedJetCollectionD3PDObject = getJetCollectionD3PDObject(
objectname="MyGroomedJetCollectionD3PDObject")
AddUniqueMoments(MyGroomedJetCollectionD3PDObject, ['SmallR', 'PtFrac'],
theblockname='TrimConfigMoments',
level=99)
#AddUniqueMoments(MyGroomedJetCollectionD3PDObject, ['NSubjets','ktycut2','massFraction','minRfilt','minSplitR'], theblockname = 'FiltConfigMoments', level = 99)
#AddUniqueMoments(MyGroomedJetCollectionD3PDObject, ['RcutFactor', 'Zcut'], theblockname = 'PrunConfigMoments', level = 99)
AddHadronicInfo(MyGroomedJetD3PDObject, ['CORE_RBB', 'CORE_RFILT'],
theblockname='FiltMoments',
level=99)
listOfMoments = [
'Tau1', 'Tau2', 'Tau3', 'SPLIT12', 'SPLIT23', 'SPLIT34', 'ZCUT12',
'ZCUT23', 'ZCUT34', 'QW', 'PullMag', 'PullPhi', 'Pull_C00', 'Pull_C01',
'Pull_C10', 'Pull_C11', 'WIDTH'
]
if not scheduleOnly: listOfMoments_ = listOfMoments
else: listOfMoments_ = listOfMoments[:-1] # without WIDTH
AddHadronicInfo(MyGroomedJetD3PDObject,
listOfMoments,
theblockname='jsObsblock',
level=99)
AddHadronicInfo(MyJetD3PDObject,
listOfMoments_,
theblockname='jsObsblock',
level=theZeroLevel)
if not scheduleOnly:
alg += MyJetD3PDObject(0,
prefix='jet_' + parentJetsWithoutJS + '_',
sgkey=parentJets + 'Jets',
exclude=commonExcludeList,
include=commonIncludeList + VtxInclude +
JetQualInclude)
for gr in groomedJetsList:
includelist = []
includelist_unique = []
if 'Trim' in gr:
includelist_unique += ['TrimConfigMoments']
includelist += ['jsObsblock']
if 'Topo' in parentJets:
includelist += [
'OriginIndexBlock', 'EMScale', 'ConstituentScale',
'elecblockindex', 'muonblockindex'
]
elif 'Truth' in parentJets:
includelist += ['TruthParticleLeptonblockindex']
elif 'Track' in parentJets:
includelist += ['elecblockindex', 'muonblockindex']
alg += MyGroomedJetCollectionD3PDObject(
0,
prefix='jet_' + parentJetsWithoutJSForGrooming + gr +
'_config_',
sgkey=parentJets + gr + 'Jets',
include=includelist_unique)
elif 'Filt' in gr:
includelist += ['FiltMoments', 'jsObsblock']
#includelist_unique += ['FiltConfigMoments']
elif 'Prun' in gr:
#includelist_unique += ['PrunConfigMoments']
includelist += ['jsObsblock']
alg += MyGroomedJetD3PDObject(
0,
prefix='jet_' + parentJetsWithoutJSForGrooming + gr + '_',
sgkey=parentJets + gr + 'Jets',
include=includelist,
exclude=commonExcludeList)
return alg
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id: ZdcD3PDObject.py 470583 2011-11-25 10:33:45Z krasznaa $
from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject
import ForwardDetectorsD3PDMaker
ZdcD3PDObject = make_SGDataVector_D3PDObject("ZdcRawChannelCollection",
"ZdcRawChannelCollection", "Zdc_",
"ZdcD3PDObject")
ZdcD3PDObject.defineBlock(0, 'ZdcRawChannel',
ForwardDetectorsD3PDMaker.ZdcFillerTool)
# $Id$
#
# @file MuonD3PDMaker/python/MuonSpShowerD3PDObject.py
# @author Michiru Kaneda <*****@*****.**>
# @date Jan., 2011
# @brief MuonSpShower filler tool
#
import D3PDMakerCoreComps
from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject
from MuonD3PDMaker.MuonD3PDMakerConf import D3PD__MuonSpShowerFillerTool as MuonSpShowerFillerTool
MuonSpShowerD3PDObject = \
make_SGDataVector_D3PDObject ('Rec::MuonSpShowerContainer',
'MuonSpShowers',
'musp_', 'MuonSpShowerD3PDObject')
MuonSpShowerD3PDObject.defineBlock(0,
'Position',
MuonSpShowerFillerTool,
WritePosition=True,
WriteHits=False,
WriteSegments=False)
MuonSpShowerD3PDObject.defineBlock(1,
'Hits',
MuonSpShowerFillerTool,
WritePosition=False,
WriteHits=True,
WriteSegments=False)
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id: MuonROID3PDObject.py 620244 2014-10-06 19:02:48Z ssnyder $
#
# D3PD object saving the LVL1 muon RoI information into the D3PD
#
from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject
import TriggerD3PDMaker
import EventCommonD3PDMaker
import D3PDMakerCoreComps
MuonROID3PDObject = \
make_SGDataVector_D3PDObject( "xAOD::MuonRoIContainer_v1",
"LVL1MuonRoIs",
"trig_L1_mu_", "MuonROID3PDObject")
MuonROID3PDObject.defineBlock (
0, 'Kinematics',
D3PDMakerCoreComps.AuxDataFillerTool,
Vars = ['eta', 'phi'])
MuonROID3PDObject.defineBlock (
0, 'ThrInfo',
D3PDMakerCoreComps.AuxDataFillerTool,
Vars = ['thrName', 'thrValue'])
MuonROID3PDObject.defineBlock (
2, 'RoIWord',
D3PDMakerCoreComps.AuxDataFillerTool,
Vars = ['RoIWord = roiWord'])
MuonROID3PDObject.defineBlock( 1, "DecodedInfo",
alg = D3PDMakerCoreComps.MakerAlg('test1', topSequence, 'test1.root')
from D3PDMakerCoreComps.D3PDObject import \
make_SGDataVector_D3PDObject, make_SG_D3PDObject, make_Void_D3PDObject
from D3PDMakerCoreComps.SimpleAssociation import SimpleAssociation
from D3PDMakerCoreComps.ContainedVectorMultiAssociation \
import ContainedVectorMultiAssociation
from D3PDMakerCoreComps.ContainedMultiAssociation \
import ContainedMultiAssociation
###########################################################################
Obj1D3PDObject = \
make_SGDataVector_D3PDObject ('D3PDTest::Obj1Container',
'obj1container',
'o1_')
Obj1D3PDObject.defineBlock(0, 'Obj1', D3PDMakerTest.Obj1FillerTool)
Obj1D3PDObject.defineBlock(0, 'Obj1a', D3PDMakerTest.Obj12FillerTool)
Obj1D3PDObject.defineBlock(0, 'Def2', D3PDMakerTest.DefaultFillerTool2)
#####################
Obj2aAssoc = SimpleAssociation(Obj1D3PDObject,
D3PDMakerTest.Obj1Obj2AssociationTool,
prefix='o2a_')
Obj2aAssoc.defineBlock(0, 'Obj2Assoc', D3PDMakerTest.Obj2FillerTool)
Obj2bAssoc = ContainedVectorMultiAssociation \
(Obj1D3PDObject,
D3PDMakerTest.Obj1Obj2MultiAssociationTool,
# Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
import CaloD3PDMaker
import CaloSysD3PDMaker
import D3PDMakerCoreComps
import EventCommonD3PDMaker
from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
EMClusterD3PDObject = \
make_SGDataVector_D3PDObject ('CaloClusterContainer',
D3PDMakerFlags.EMTopoClusterSGKey(),
'emcl_', 'EMClusterD3PDObject')
EMClusterD3PDObject.defineBlock(0,
'Kinematics',
EventCommonD3PDMaker.FourMomFillerTool,
WriteE=True)
EMClusterD3PDObject.defineBlock(0, 'SamplingBasics',
CaloD3PDMaker.ClusterSamplingFillerTool)
from CaloSysD3PDMaker import ClusterMomentFillerTool as CMFT
EMClusterD3PDObject.defineBlock(
1,
'Moments',
CMFT,
Moments=[
CMFT.FIRST_ENG_DENS, 'firstEdens', CMFT.ENG_FRAC_MAX, 'cellmaxfrac',
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id$
import CaloD3PDMaker
from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject
""" level of details:
0: digits
1: digit+SCA index
2: OF Iteration results
Note: 1 and 2 are not available in ESD. They are available when running recon on raw data.
"""
LArDigitD3PDObject = make_SGDataVector_D3PDObject("LArDigitContainer",
"LArDigitContainer_Thinned",
"lardigit_",
"LArDigitD3PDObject")
LArDigitD3PDObject.defineBlock(0,
'Digits',
CaloD3PDMaker.LArDigitFillerTool,
SaveDigit=True,
SaveId=True,
SaveSCAAddress=False,
DumpIterResults=False)
LArDigitD3PDObject.defineBlock(1,
'SCA',
CaloD3PDMaker.LArDigitFillerTool,
SaveDigit=False,
SaveId=False,
def TrackD3PDObject(_label='trkTrack',
_prefix='trkTrack_',
_sgkey='Tracks',
_object_name='TrackD3PDObject',
typeName='TrackCollection',
vertexTarget='vx',
vertexPrefix='vx_',
vertexSGKey='VxPrimaryCandidate',
truthTarget='mc',
truthPrefix='mc_',
detailedTruthPrefix='detailed_mc_',
truthMapKey='TrackTruthCollection',
SGKeyForTruth='Tracks',
detailedTruthMapKey='DetailedTrackTruth',
SGKeyForDetailedTruth='Tracks',
flags=TrackD3PDFlags):
object = make_SGDataVector_D3PDObject (
typeName,
_sgkey,
_prefix,
_object_name,
default_allowMissing = True,
default_label = _label,
allow_args = ['GenParticleTarget',
'TruthParticleTarget',
'storeTruthInfo',
'storeTrackMomentum',
'trackParametersAtGlobalPerigeeLevelOfDetails',
'trackParametersAtPrimaryVertexLevelOfDetails',
'trackParametersAtBeamSpotLevelOfDetails',
'trackParameterAtBeamLineLevelOfDetails',
'storeDiagonalCovarianceAsErrors',
'storeTrackParametersAtCalo',
'storeTrackParametersAtCalo2ndLayer',
'storeTrackFitQuality',
'storeTrackPredictionAtBLayer',
'storeTrackInfo',
'storeVertexAssociation',
'storeDetailedTruth',
'storeBLayerHitsOnTrack',
'storePixelHitsOnTrack',
'storeSCTHitsOnTrack',
'storeTRTHitsOnTrack',
'storeMDTHitsOnTrack',
'storeCSCHitsOnTrack',
'storeRPCHitsOnTrack',
'storeTGCHitsOnTrack',
'storeBLayerOutliersOnTrack',
'storePixelOutliersOnTrack',
'storeSCTOutliersOnTrack',
'storeTRTOutliersOnTrack',
'storeMDTOutliersOnTrack',
'storeCSCOutliersOnTrack',
'storeRPCOutliersOnTrack',
'storeTGCOutliersOnTrack',
'storeBLayerHolesOnTrack',
'storePixelHolesOnTrack',
'storeSCTHolesOnTrack',
'storeTRTHolesOnTrack',
'storeMDTHolesOnTrack',
'storeCSCHolesOnTrack',
'storeRPCHolesOnTrack',
'storeTGCHolesOnTrack',
'storePullsAndResiduals',
'storeTrackUnbiasedIPAtPV',
'storeHitTruthMatching',
'storeTrackSummary',
'doTruth',
])
if typeName=='TrackCollection':
PerigeeAssociationTool = TrackD3PDMaker.TrkTrackPerigeeAssociationTool
PerigeeAtPVAssociationTool = TrackD3PDMaker.TrkTrackPerigeeAtPVAssociationTool
PerigeeAtBSAssociationTool = TrackD3PDMaker.TrkTrackPerigeeAtBSAssociationTool
FitQualityAssociationTool = TrackD3PDMaker.TrkTrackFitQualityAssociationTool
TrackSummaryAssociationTool = TrackD3PDMaker.TrkTrackTrackSummaryAssociationTool
TrackInfoAssociationTool = TrackD3PDMaker.TrkTrackInfoAssociationTool
HitAssociationTool = TrackD3PDMaker.TrkTrackTSOAssociationTool
VertexAssociationTool = TrackD3PDMaker.TrkTrackVertexAssociationTool
TruthAssociationTool = TrackD3PDMaker.TrkTrackTruthAssociationTool
DetailedTruthAssociationTool = TrackD3PDMaker.TrkTrackDetailedTruthAssociationTool
ParametersAtBLFillerTool = TrackD3PDMaker.TrkTrackParametersAtBLFillerTool
if typeName=='Rec::TrackParticleContainer':
PerigeeAssociationTool = TrackD3PDMaker.TrackParticlePerigeeAtOOAssociationTool
PerigeeAtPVAssociationTool = TrackD3PDMaker.TrackParticlePerigeeAtPVAssociationTool
PerigeeAtBSAssociationTool = TrackD3PDMaker.TrackParticlePerigeeAtBSAssociationTool
FitQualityAssociationTool = TrackD3PDMaker.TrackParticleFitQualityAssociationTool
TrackSummaryAssociationTool = TrackD3PDMaker.TrackParticleTrackSummaryAssociationTool
TrackInfoAssociationTool = TrackD3PDMaker.TrackParticleInfoAssociationTool
HitAssociationTool = TrackD3PDMaker.TrackParticleTSOAssociationTool
VertexAssociationTool = TrackD3PDMaker.TrackParticleVertexAssociationTool
TruthAssociationTool = TrackD3PDMaker.TrackParticleTruthAssociationTool
DetailedTruthAssociationTool = TrackD3PDMaker.TrackParticleDetailedTruthAssociationTool
ParametersAtBLFillerTool = TrackD3PDMaker.TrackParticleParametersAtBLFillerTool
# This generates ERROR messages. Disabled for now.
#object.defineBlock(1, "Isolation", TrackD3PDMaker.TrackIsolationFillerTool)
## default perigee (at (0,0,0))
PerigeeAssoc = PerigeeAssociation\
(object,
PerigeeAssociationTool, "GlobalPerigee",
fillMomName = 'storeTrackMomentum',
levelName = 'trackParametersAtGlobalPerigeeLevelOfDetails')
# Unbiased impact parameters at PV
PerigeeAssoc.defineBlock (flagTestLOD('storeTrackUnbiasedIPAtPV',
flags, _get_estimator),
_prefix+"IPEstimate",
TrackD3PDMaker.PerigeeUnbiasedIPAtPVFillerTool,
# Filled in by LOD function.
TrackToVertexIPEstimator=None,
Prefix = 'IPEstimate_',
Suffix = '_wrtPV')
# perigee at Primary Vertex
PerigeeAtPVAssoc = PerigeeAssociation\
(object,
PerigeeAtPVAssociationTool, "PerigeeAtPV",
suffix='_wrtPV',
levelName = 'trackParametersAtPrimaryVertexLevelOfDetails')
# perigee at Beam Spot
PerigeeAtBSAssoc = PerigeeAssociation\
(object,
PerigeeAtBSAssociationTool, "PerigeeAtBS",
suffix='_wrtBS',
levelName = 'trackParametersAtBeamSpotLevelOfDetails')
# perigee at Beam Line
from TrackD3PDMaker.PerigeeAssociation import perigeeLOD
# Not implemented in TrackToVertex.
#object.defineBlock(perigeeLOD ('trackParametersAtBeamLineLevelOfDetails>0',
# flags),
# _prefix+"ParametersAtBL",
# ParametersAtBLFillerTool,
# levelOfDetails = deferFlag ('trackParametersAtBeamLineLevelOfDetails', flags))
# parameters at Calo
object.defineBlock(flagTestLOD('storeTrackParametersAtCalo', flags),
_prefix+"ParametersAtCalo",
ParametersAtCaloFillerTool)
# parameters at Calo 2nd layer
object.defineBlock(flagTestLOD('storeTrackParametersAtCalo2ndLayer', flags),
_prefix+"ParametersAtCalo2ndLayer",
ParametersAtCaloFillerTool,
Sampling = 1,
Suffix = '2ndLayer')
# Fit Quality
FitQualityAssoc = SimpleAssociation\
(object,
FitQualityAssociationTool,
level = flagTestLOD('storeTrackFitQuality', flags))
FitQualityAssoc.defineBlock(flagTestLOD('storeTrackFitQuality', flags),
_prefix+'FitQuality',
TrackD3PDMaker.TrackFitQualityFillerTool)
# Track Summary
TrackSummaryAssoc = SimpleAssociation\
(object,
TrackSummaryAssociationTool,
level = flagTestLOD('storeTrackSummary', flags))
TrackSummaryAssoc.defineBlock(flagTestLOD('storeTrackSummary', flags),
_prefix+'TrackSummary',
TrackD3PDMaker.TrackTrackSummaryFillerTool,
FullInfo = flags.storeTrackSummary.FullInfo,
IDHits = flags.storeTrackSummary.IDHits,
IDHoles = flags.storeTrackSummary.IDHoles,
IDSharedHits = flags.storeTrackSummary.IDSharedHits,
IDOutliers = flags.storeTrackSummary.IDOutliers,
PixelInfoPlus = flags.storeTrackSummary.PixelInfoPlus,
SCTInfoPlus = flags.storeTrackSummary.SCTInfoPlus,
TRTInfoPlus = flags.storeTrackSummary.TRTInfoPlus,
InfoPlus = flags.storeTrackSummary.InfoPlus,
MuonHits = flags.storeTrackSummary.MuonHits,
MuonHoles = flags.storeTrackSummary.MuonHoles,
ExpectBLayer = flags.storeTrackSummary.ExpectBLayer,
HitSum = flags.storeTrackSummary.HitSum,
HoleSum = flags.storeTrackSummary.HoleSum,
HitPattern = flags.storeTrackSummary.HitPattern,
SiHits = flags.storeTrackSummary.SiHits,
TRTRatio = flags.storeTrackSummary.TRTRatio,
PixeldEdx = flags.storeTrackSummary.PixeldEdx,
ElectronPID = flags.storeTrackSummary.ElectronPID)
# Track Info
TrackInfoAssoc = SimpleAssociation\
(object,
TrackInfoAssociationTool,
level = flagTestLOD('storeTrackInfo', flags))
TrackInfoAssoc.defineBlock(flagTestLOD('storeTrackInfo', flags),
_prefix+'TrackInfo',
TrackD3PDMaker.TrackInfoFillerTool)
## B-Layer predictions
from AthenaCommon.AppMgr import ToolSvc
if hasattr(ToolSvc, 'InDetRecTestBLayerTool'):
BLayerPredictionAssoc = SimpleAssociation\
(object,
PerigeeAssociationTool,
prefix = 'blayerPrediction_',
blockname = _prefix+'BLayerInfoAssoc',
level = flagTestLOD('storeTrackPredictionAtBLayer', flags))
BLayerPredictionAssoc.defineBlock (flagTestLOD('storeTrackPredictionAtBLayer', flags),
_prefix+'BLayerInfo',
TrackD3PDMaker.PerigeeBLPredictionFillerTool,
InDetTestBLayerTool = ToolSvc.InDetRecTestBLayerTool)
tsos_table = [
('storeBLayerHitsOnTrack', 'BLayer_hit_', 'getBLayerMeasurements'),
('storePixelHitsOnTrack', 'Pixel_hit_', 'getPixelMeasurements'),
('storeSCTHitsOnTrack', 'SCT_hit_', 'getSCTMeasurements'),
('storeTRTHitsOnTrack', 'TRT_hit_', 'getTRTMeasurements'),
('storeMDTHitsOnTrack', 'MDT_hit_', 'getMDTMeasurements'),
('storeCSCHitsOnTrack', 'CSC_hit_', 'getCSCMeasurements'),
('storeRPCHitsOnTrack', 'RPC_hit_', 'getRPCMeasurements'),
('storeTGCHitsOnTrack', 'TGC_hit_', 'getTGCMeasurements'),
('storeBLayerOutliersOnTrack', 'BLayer_outlier_', 'getBLayerOutliers'),
('storePixelOutliersOnTrack', 'Pixel_outlier_', 'getPixelOutliers'),
('storeSCTOutliersOnTrack', 'SCT_outlier_', 'getSCTOutliers'),
('storeTRTOutliersOnTrack', 'TRT_outlier_', 'getTRTOutliers'),
('storeMDTOutliersOnTrack', 'MDT_outlier_', 'getMDTOutliers'),
('storeCSCOutliersOnTrack', 'CSC_outlier_', 'getCSCOutliers'),
('storeRPCOutliersOnTrack', 'RPC_outlier_', 'getRPCOutliers'),
('storeTGCOutliersOnTrack', 'TGC_outlier_', 'getTGCOutliers'),
('storeBLayerHolesOnTrack', 'BLayer_hole_', 'getBLayerHoles'),
('storePixelHolesOnTrack', 'Pixel_hole_', 'getPixelHoles'),
('storeSCTHolesOnTrack', 'SCT_hole_', 'getSCTHoles'),
('storeTRTHolesOnTrack', 'TRT_hole_', 'getTRTHoles'),
('storeMDTHolesOnTrack', 'MDT_hole_', 'getMDTHoles'),
('storeCSCHolesOnTrack', 'CSC_hole_', 'getCSCHoles'),
('storeRPCHolesOnTrack', 'RPC_hole_', 'getRPCHoles'),
('storeTGCHolesOnTrack', 'TGC_hole_', 'getTGCHoles'),
]
for flag, pref, opt in tsos_table:
TrackStateOnSurfaceAssociation (object,
HitAssociationTool,
pref, _prefix + pref,
flagTestLOD(flag, flags),
fillPullsName = 'storePullsAndResiduals' if flag.find('Holes')<0 else 'False',
**{opt : True})
# Vertex association
VertexAssoc = IndexAssociation (
object,
VertexAssociationTool, vertexTarget,
prefix = vertexPrefix,
VxSGKey = vertexSGKey,
level = flagTestLOD('storeVertexAssociation', flags))
# Truth matching
if rec.doTruth():
# Simple truth matching
# Allow associating to either GenParticles or TruthParticles.
def _levelAssocToGP (reqlev, args, hookargs):
if reqlev < 1: return False
if hookargs.get ('TruthParticleTarget'): return False
if hookargs.get ('GenParticleTarget'):
args['Target'] = hookargs.get ('GenParticleTarget')
return True
def _levelAssocToTP (reqlev, args, hookargs):
if reqlev < 1: return False
tpt = hookargs.get ('TruthParticleTarget')
if not tpt: return False
args['Target'] = tpt
return True
TruthAssoc = SimpleAssociation\
(object,
TruthAssociationTool,
prefix = truthPrefix,
SGKey = SGKeyForTruth,
MapKey = truthMapKey,
level = flagTestLOD('doTruth and storeHitTruthMatching', flags))
TruthAssoc.defineBlock (_levelAssocToGP,
'TruthAssocIndex',
D3PDMakerCoreComps.IndexFillerTool,
Target = truthTarget)
# TruthAssocTP = SimpleAssociation\
# (TruthAssoc,
# TruthD3PDMaker.GenParticleTruthParticleAssociationTool,
# level = _levelAssocToTP)
# TruthAssocTP.defineBlock (_levelAssocToTP,
# 'TruthAssocIndexTP',
# D3PDMakerCoreComps.IndexFillerTool,
# Target = truthTarget)
# _levelTruthInfo = flagTestLOD ('doTruth and storeHitTruthMatching and reqlev>=2 and storeTruthInfo', flags)
# TruthAssoc.defineBlock (_levelTruthInfo,
# 'TruthPerigee',
# TruthD3PDMaker.GenParticlePerigeeFillerTool)
#
# if typeName == 'Rec::TrackParticleContainer':
# from TruthD3PDMaker.MCTruthClassifierConfig import \
# D3PDMCTruthClassifier
# object.defineBlock \
# (_levelTruthInfo,
# 'MCClassification',
# TrackD3PDMaker.TrackParticleMCClassifierFillerTool,
# prefix = 'mc_',
# Classifier = D3PDMCTruthClassifier)
# Detailed truth matching
DetailedTruthAssoc = IndexMultiAssociation (
object,
DetailedTruthAssociationTool, truthTarget,
prefix = detailedTruthPrefix,
level = flagTestLOD('doTruth and storeDetailedTruth and reqlev>=1', flags),
SGKey = SGKeyForDetailedTruth,
MapKey = detailedTruthMapKey)
# if typeName == 'Rec::TrackParticleContainer':
# from TrackD3PDMaker.trackIsolationTool import \
# trackIsolationTool_500MeV, \
# trackIsolationTool_1GeV, \
# trackIsolationTool_2GeV, \
# trackIsolationTool_3GeV, \
# trackIsolationTool_4GeV, \
# trackIsolationTool_5GeV, \
# trackIsolationTool_3GeV_hitschi
# from TrackD3PDMaker.addTrackIsolationCones import addTrackIsolationCones
# addTrackIsolationCones (
# object, 'Isolation', level=999,
# sizes = [0.2, 0.3, 0.4],
# caloIsoVar = 'cone%%_caloIso',
# trackIsoVar = 'cone%%_trackIso',
# nTrackIsoVar = 'cone%%_nTrackIso',
# isolationTool = DeferArg('tool()',
# tool=trackIsolationTool_500MeV))
# iso4blocks = [[trackIsolationTool_1GeV, '1GeV', 'ptmin1gev_'],
# [trackIsolationTool_2GeV, '2GeV', 'ptmin2gev_'],
# [trackIsolationTool_3GeV, '3GeV', 'ptmin3gev_'],
# [trackIsolationTool_3GeV_hitschi, '3GeV_hitschi', 'ptmin3gev_hitschi_'],
# [trackIsolationTool_4GeV, '4GeV', 'ptmin4gev_'],
# [trackIsolationTool_5GeV, '5GeV', 'ptmin5gev_'],
# ]
# for (tool, blksuff, varsuff) in iso4blocks:
# object.defineBlock (999, 'Isolation_40_' + blksuff,
# TrackD3PDMaker.TrackIsolationFillerTool,
# ConeSize = 0.4,
# prefix = 'cone40_' + varsuff,
# TrackIsolationTool = DeferArg('tool()',
# tool=tool))
return object
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id$
#
# @file CaloD3PDMaker/python/MBTSD3PDObject.py
# @author scott snyder <*****@*****.**>
# @date Nov, 2009
# @brief D3PD object for MBTS.
#
# We require TileID.
# If identifiers have not yet been configured, request a minimal
# setup (that doesn't use GeoModelSvc).
from AthenaCommon.AppMgr import ServiceMgr
if not hasattr (ServiceMgr, 'DetDescrCnvSvc'):
import DetDescrCnvSvc.DetStoreConfig
ServiceMgr.DetDescrCnvSvc.DoInitNeighbours = False
import CaloD3PDMaker
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject
MBTSD3PDObject = \
make_SGDataVector_D3PDObject ('TileContainer<TileCell>',
D3PDMakerFlags.MBTSSGKey(),
'mb_', 'MBTSD3PDObject')
MBTSD3PDObject.defineBlock (0, 'MBTS', CaloD3PDMaker.MBTSFillerTool)
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id: ZdcDigitsD3PDObject.py 470583 2011-11-25 10:33:45Z krasznaa $
from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject
import ForwardDetectorsD3PDMaker
ZdcDigitsD3PDObject = make_SGDataVector_D3PDObject("ZdcDigitsCollection",
"ZdcDigitsCollection",
"ZdcDigits_",
"ZdcDigitsD3PDObject")
ZdcDigitsD3PDObject.defineBlock(0, 'ZdcDigits',
ForwardDetectorsD3PDMaker.ZdcDigitsFillerTool)
#alg += CaloInfoD3PDObject (10)
#alg += ClusterD3PDObject (10)
#alg += LArDigitD3PDObject (2)
alg += AllCaloCellD3PDObject(1, sgkey='SCellContainer', prefix='scells_')
alg.scells_Filler.scells_Filler_Detail1.SaveId = True
import CaloD3PDMaker
from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject
if doRawData:
LArDigitD3PDObject = make_SGDataVector_D3PDObject("LArDigitContainer",
"LArDigitContainer_MC",
"lardigit_",
"LArDigitD3PDObject")
LArDigitD3PDObject.defineBlock(0,
'Digits',
CaloD3PDMaker.LArDigitFillerTool,
SaveDigit=True,
SaveId=True,
SaveSCAAddress=False,
DumpIterResults=False)
alg += LArDigitD3PDObject(0)
TileDigitD3PDObject = D3PDObject(makeTileDigitD3PDObject, 'tiledigit_',
'TileDigitD3PDObject')
TileDigitD3PDObject.defineBlock(
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
import MuonD3PDMaker
import D3PDMakerCoreComps
import EventCommonD3PDMaker
from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject
from D3PDMakerCoreComps.SimpleAssociation import SimpleAssociation
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from RecExConfig.RecFlags import rec
MuonSegmentTruthD3PDObject = \
make_SGDataVector_D3PDObject ('Trk::SegmentCollection',
'MuonSegments',
'mu_segmentTruth_', 'MuonSegmentTruthD3PDObject')
MuonSegmentTruthD3PDObject.defineBlock(
1, 'PatternTruthCombination', MuonD3PDMaker.MuonSegmentTruthFillerTool)
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id: EmTauROID3PDObject.py 633616 2014-12-04 10:10:12Z ssnyder $
#
# D3PD object saving the LVL1 Em/Tau RoI information into the D3PD
#
from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject
import TriggerD3PDMaker
import EventCommonD3PDMaker
import D3PDMakerCoreComps
EmTauROID3PDObject = \
make_SGDataVector_D3PDObject( 'xAOD::EmTauRoIContainer',
"HLT_xAOD__EmTauRoIContainer_L1TopoEM,LVL1EmTauRoIs",
"trig_L1_emtau_", "EmTauROID3PDObject")
EmTauROID3PDObject.defineBlock(0,
'Kinematics',
D3PDMakerCoreComps.AuxDataFillerTool,
Vars=['eta', 'phi'])
EmTauROID3PDObject.defineBlock(0,
'ThrInfo',
D3PDMakerCoreComps.AuxDataFillerTool,
Vars=['thrNames', 'thrValues'])
EmTauROID3PDObject.defineBlock(1,
'DecodedInfo',
D3PDMakerCoreComps.AuxDataFillerTool,
def __init__(self, jetsToWrite):
self.commonExcludeList = [
] #'El02Match','Mu02Match','L1Info','L2Info','EFInfo']
self.commonIncludeList = [
'El02Match', 'Mu02Match', 'L1Info', 'L2Info', 'EFInfo',
'SubjetMomentsHadronic'
]
MyJetD3PDObject = getJetD3PDObject(objectname='MyJetD3PDObject')
MyGroomedJetD3PDObject = getJetD3PDObject(
objectname='MyGroomedJetD3PDObject')
import re
JetAlgPattern = re.compile(
r'^(\D+)(\d{1,2})(\D+)Jets') #assuming standard notation
ars = JetAlgPattern.match(jetsToWrite[0]).groups()
self.parentJets = ''.join(ars) #remove the 'Jets' at the end
#global self.parentJets
self.groomedJetsList = jetsToWrite[1]
## Electron LC cluster overlap map
if ('LCTopo' in self.parentJets):
MyJetAssocD3PDObject = make_SGDataVector_D3PDObject(
'DataVector<INavigable4Momentum>',
'ElectronAODCollection_CaloCalTopoCluster_jetsubstructure_electrons',
'ElecTopoClusterAssoc_', 'myJetAssocD3PDObject')
AddAssocConstitIndex(MyJetAssocD3PDObject)
AddAssocConstitIndex(MyJetAssocD3PDObject, 'CaloCluster', 'cl_lc_')
#alg += MyJetAssocD3PDObject(0)
if 'Track' in self.parentJets:
AddConstitIndex(MyGroomedJetD3PDObject,
typename='Rec::TrackParticle',
target='trk')
AddConstitIndex(MyJetD3PDObject,
typename='Rec::TrackParticle',
target='trk')
#AddLeptonicInfo(MyJetD3PDObject,level=0)
#AddLeptonicInfo(MyGroomedJetD3PDObject,99)
elif 'Topo' in self.parentJets:
AddConstitIndex(MyGroomedJetD3PDObject)
AddConstitIndex(MyJetD3PDObject)
AddLeptonicInfo(MyJetD3PDObject, level=0)
AddLeptonicInfo(MyGroomedJetD3PDObject, 99)
AddAssocJetsIndex(MyJetD3PDObject, 'TrackAssoc', 'trk')
AddAssocJetsIndex(MyGroomedJetD3PDObject, 'TrackAssoc', 'trk')
elif 'Truth' in self.parentJets:
AddConstitTruthIndex(MyJetD3PDObject)
AddConstitTruthIndex(MyGroomedJetD3PDObject)
AddTruthLeptonicInfo(MyJetD3PDObject, level=0)
AddTruthLeptonicInfo(MyGroomedJetD3PDObject, level=0)
if 'Track' not in self.parentJets and 'Truth' not in self.parentJets:
AddAssocJetsIndex(MyJetD3PDObject, 'TrackJets',
'jet_' + ars[0] + ars[1] + 'TrackZ_')
if rec.doTruth():
if self.parentJets == "AntiKt10LCTopo" or self.parentJets == "CamKt12LCTopo":
AddAssocJetsIndex(MyJetD3PDObject, 'TruthJets',
'jet_' + ars[0] + ars[1] + 'Truth_')
else:
AddAssocJetsIndex(MyJetD3PDObject, 'TruthJets',
'jet_' + ars[0] + ars[1] + 'Truth_')
#AddAssocJetsIndex(MyJetD3PDObject, 'TruthJets', 'jet_' + ars[0] + ars[1] + 'Truth_')
self.JetQualInclude = []
if 'Topo' in self.parentJets or 'LCTopo' in self.parentJets:
self.commonIncludeList += [
'ConstituentScale', 'EMScale', 'EMFraction', 'JetSamplingsFrac'
] #, 'El02Match', 'Mu02Match', 'L1Info', 'L2Info', 'EFInfo']
AddHadronicInfo(MyJetD3PDObject, [
'OriginIndex', 'nTrk', 'sumPtTrk', 'EtaOrigin', 'PhiOrigin',
'MOrigin'
],
theblockname='OriginIndexBlock')
AddHadronicInfo(MyGroomedJetD3PDObject,
['EtaOrigin', 'PhiOrigin', 'MOrigin'],
theblockname='OriginIndexBlock')
if (self.parentJets == 'AntiKt10LCTopo') or (self.parentJets
== 'CamKt12LCTopo'):
AddHadronicInfo(MyJetD3PDObject,
['LCJES', 'LCJES_EtaCorr', 'LCJES_MassCorr'],
theblockname='LCJESBlock')
AddHadronicInfo(MyGroomedJetD3PDObject,
['LCJES', 'LCJES_EtaCorr', 'LCJES_MassCorr'],
theblockname='LCJESBlock')
self.VtxInclude = []
#if 'Topo' in self.parentJets:
# self.VtxInclude += ['JVtx','JetVertexFraction']
self.VtxInclude += ['JVtx', 'JetVertexFraction']
tmpParentJets = self.parentJets.replace("JS", "")
AddAssocJetsIndex(MyGroomedJetD3PDObject, 'Parent',
'jet_' + tmpParentJets + '_')
for gr in self.groomedJetsList:
AddAssocJetsIndex(MyJetD3PDObject, gr,
'jet_' + tmpParentJets + gr + '_')
MyGroomedJetCollectionD3PDObject = getJetCollectionD3PDObject(
objectname="MyGroomedJetCollectionD3PDObject")
AddUniqueMoments(MyGroomedJetCollectionD3PDObject,
['SmallR', 'PtFrac', 'NSub'],
theblockname='TrimConfigMoments',
level=99)
AddUniqueMoments(
MyGroomedJetCollectionD3PDObject,
['NSubjets', 'ktycut2', 'massFraction', 'minRfilt', 'minSplitR'],
theblockname='FiltConfigMoments',
level=0)
AddHadronicInfo(MyGroomedJetD3PDObject, ['CORE_RBB', 'CORE_RFILT'],
theblockname='FiltMoments',
level=99)
AddHadronicInfo(MyGroomedJetD3PDObject, [
'Tau1', 'Tau2', 'Tau3', 'WIDTH', 'SPLIT12', 'SPLIT23', 'SPLIT34',
'ZCUT12', 'ZCUT23', 'ZCUT34', 'Dip12', 'Dip13', 'Dip23',
'DipExcl12', 'PlanarFlow', 'Angularity', 'ActiveArea',
'ActiveArea_px', 'ActiveArea_py', 'ActiveArea_pz', 'ActiveArea_e',
'VoronoiArea', 'QW', 'PullMag', 'PullPhi', 'Pull_C00', 'Pull_C01',
'Pull_C10', 'Pull_C11'
],
theblockname='jsObsblock')
AddHadronicInfo(MyJetD3PDObject, [
'Tau1', 'Tau2', 'Tau3', 'WIDTH', 'SPLIT12', 'SPLIT23', 'SPLIT34',
'ZCUT12', 'ZCUT23', 'ZCUT34', 'Dip12', 'Dip13', 'Dip23',
'DipExcl12', 'PlanarFlow', 'Angularity', 'ActiveArea',
'ActiveArea_px', 'ActiveArea_py', 'ActiveArea_pz', 'ActiveArea_e',
'VoronoiArea', 'QW', 'PullMag', 'PullPhi', 'Pull_C00', 'Pull_C01',
'Pull_C10', 'Pull_C11'
],
theblockname='jsObsblock')
#add area corrected kinematics for the groomed jets
from D3PDMakerConfig.CommonGroomedJetsConfig import getGroomedJetsConfig
dictsConfig = getGroomedJetsConfig()
from D3PDMakerConfig.CommonJSjets import buildName
self.AreaCorr = []
for dC in dictsConfig:
for l in dC[1]:
if 'AreaCorr' in l['args']:
if l['args']['AreaCorr']:
self.AreaCorr.append(buildName(l))
if (self.AreaCorr) and ((self.parentJets == 'AntiKt10LCTopo') or
(self.parentJets == 'CamKt12LCTopo')):
AddHadronicInfo(MyGroomedJetD3PDObject, [
'm_areacorrected', 'pt_areacorrected', 'phi_areacorrected',
'eta_areacorrected', 'm_voronoiareacorrected',
'pt_voronoiareacorrected', 'phi_voronoiareacorrected',
'eta_voronoiareacorrected', 'm_voronoighostareacorrected',
'pt_voronoighostareacorrected',
'phi_voronoighostareacorrected',
'eta_voronoighostareacorrected'
],
theblockname='AreaCorrectedMoments',
level=99)
## in groomedJetsList, subjets name should follow the name of the 'full/composite' jet.
for idx, gr in enumerate(self.groomedJetsList):
## names are unique
if 'KtSubjets' in gr:
#AddBTaggingInfoFromSubjets(MyGroomedJetD3PDObject, sj_assoc_name = gr, sj_prefix = gr, level = 99)
AddAssocJetsIndex(MyGroomedJetD3PDObject,
gr,
'jet_' + tmpParentJets + gr + '_',
intermediate_names=['Parent'],
level=99)
elif 'Subjets' in gr and idx != 0 and 'Subjets' not in self.groomedJetsList[
idx - 1]:
#AddBTaggingInfoFromSubjets(MyGroomedJetD3PDObject, sj_assoc_name = gr, sj_prefix = gr, level = 99)
AddAssocJetsIndex(MyGroomedJetD3PDObject,
gr,
'jet_' + tmpParentJets + gr + '_',
intermediate_names=['Parent'],
level=99)
if 'LCTopo' in self.parentJets:
AddBTaggingInfoFromSubjets(MyGroomedJetD3PDObject,
sj_assoc_name=gr,
sj_prefix=gr,
level=99)
elif 'Subjets' in gr:
raise ValueError("Subjets without full composite jet ?"
) ## not suppose to happen
self.MyJetD3PDObject = MyJetD3PDObject
self.MyGroomedJetD3PDObject = MyGroomedJetD3PDObject
self.MyGroomedJetCollectionD3PDObject = MyGroomedJetCollectionD3PDObject
if ('LCTopo' in self.parentJets):
self.MyJetAssocD3PDObject = MyJetAssocD3PDObject
from D3PDMakerCoreComps.D3PDObject import DeferArg
from D3PDMakerCoreComps.resolveSGKey import resolveSGKey
from AthenaCommon.AlgSequence import AlgSequence
import EventCommonD3PDMaker
import D3PDMakerCoreComps
import egammaD3PDMaker
import CaloD3PDMaker
auxprefix = DeferArg(
'D3PDMakerFlags.EgammaUserDataPrefix() + "_" +'
'resolveSGKey (typeName, sgkey) + "_"', globals())
CorrectionClusterD3PDObject = \
make_SGDataVector_D3PDObject ('DataVector<xAOD::CaloCluster_v1>',
'egClusterCollection',
'cl_',
'CorrectionClusterD3PDObject')
CorrectionClusterD3PDObject.defineBlock(0,
'Kinematics',
EventCommonD3PDMaker.FourMomFillerTool,
WriteE=True)
CorrectionClusterD3PDObject.defineBlock(
0,
'Samplings',
CaloD3PDMaker.ClusterSamplingFillerTool,
SamplingEnergies=True,
SamplingEtaPhi=True,
SamplingEtaPhiRaw=True,
#SamplingEtamax = True,
Samplings=[0, 1, 2, 3, 4, 5, 6, 7])
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
import D3PDMakerCoreComps
import EventCommonD3PDMaker
import JetD3PDMaker
from D3PDMakerCoreComps.D3PDObject import D3PDObject
from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from RecExConfig.RecFlags import rec
TruthJetD3PDObject = make_SGDataVector_D3PDObject('JetCollection',
D3PDMakerFlags.JetSGKey(),
'truthjet_',
'TruthJetD3PDObject')
TruthJetD3PDObject.defineBlock(0,
'Kinematics',
EventCommonD3PDMaker.FourMomFillerTool,
WriteE=True)
TruthJetD3PDObject.defineBlock(2, 'JetShape', JetD3PDMaker.JetShapeFillerTool)
if rec.doTruth:
TruthJetD3PDObject.defineBlock(2, 'TrueFlavorComponents',
JetD3PDMaker.JetTrueTagFillerTool)
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
# $Id$
#
# @file QcdD3PDMaker/python/QcdMuonSpShowerD3PDObject.py
# @author Michiru Kaneda <*****@*****.**>
# @date Jan., 2011
# @brief MuonSpShower filler tool
#
from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject
from QcdD3PDMaker.QcdD3PDMakerConf import QcdD3PD__MuonSpShowerFillerTool as MuonSpShowerFillerTool
MuonSpShowerD3PDObject = make_SGDataVector_D3PDObject(
"Rec::MuonSpShowerContainer", "MuonSpShowers", "musp_",
"QcdMuonSpShowerD3PDObject")
MuonSpShowerD3PDObject.defineBlock(0,
'Position',
MuonSpShowerFillerTool,
WritePosition=True,
WriteHits=False,
WriteSegments=False)
MuonSpShowerD3PDObject.defineBlock(1,
'Hits',
MuonSpShowerFillerTool,
WritePosition=False,
WriteHits=True,
WriteSegments=False)
# Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
import CaloD3PDMaker
import CaloSysD3PDMaker
import D3PDMakerCoreComps
import EventCommonD3PDMaker
from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from D3PDMakerCoreComps.ContainedVectorMultiAssociation import ContainedVectorMultiAssociation
ClusterD3PDObject = \
make_SGDataVector_D3PDObject ('CaloClusterContainer',
D3PDMakerFlags.ClusterSGKey(),
'cl_', 'ClusterD3PDObject')
ClusterD3PDObject.defineBlock(0,
'Kinematics',
EventCommonD3PDMaker.FourMomFillerTool,
WriteE=False,
WriteM=False)
ClusterD3PDObject.defineBlock(0, 'SamplingBasics',
CaloD3PDMaker.ClusterSamplingFillerTool)
from CaloSysD3PDMaker import ClusterMomentFillerTool as CMFT
ClusterD3PDObject.defineBlock(
1,
'Moments',
CMFT,
# @file MuonD3PDMaker/python/TruthMuonD3PDObject.py
# $author Srivas Prasad <*****@*****.**>
# @date March 2010
# @brief dump true muons - modeled on Tau code
import MuonD3PDMaker
import EventCommonD3PDMaker
from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject
from D3PDMakerCoreComps.resolveSGKey import testSGKey
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from AthenaCommon.AlgSequence import AlgSequence
from RecExConfig.ObjKeyStore import cfgKeyStore
import TruthD3PDMaker
TruthMuonD3PDObject = make_SGDataVector_D3PDObject(
'DataVector<xAOD::TruthParticle_v1>', 'TruthMuons', 'muonTruth_',
'TruthMuonD3PDObject')
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
