def JetTileD3PD(file,
level=4,
tuplename='MyTuple',
seq=topSequence,
D3PDSvc='D3PD::RootD3PDSvc',
streamNameRoot=None,
**kw):
alg = D3PDMakerCoreComps.MakerAlg(tuplename,
seq,
file=file,
D3PDSvc=D3PDSvc,
streamNameRoot=streamNameRoot)
JetIncludes = ['AssocTrackCont']
alg += EventInfoD3PDObject(**_args(level, 'EventInfo', kw))
alg += JetTileD3PDObject(**_args(
level, inputSGkey, kw, sgkey=inputSGkey, prefix='AntiKt4Topo_'))
from TriggerD3PDMaker.BGCodeD3PDObject import BGCodeD3PDObject
from TriggerD3PDMaker.BunchStructureMetadata import addBunchStructureMetadata
alg += BGCodeD3PDObject(**_args(2, 'BGCode', kw))
addBunchStructureMetadata(alg)
from TriggerD3PDMaker.TrigDecisionD3PDObject import TrigDecisionD3PDObject
from TriggerD3PDMaker.TrigConfMetadata import addTrigConfMetadata
alg += TrigDecisionD3PDObject(**_args(10, 'TrigDecision', kw))
addTrigConfMetadata(alg)
if D3PDMakerFlags.DoTrigger():
alg += jetMETTriggerBitsD3PDObject(level)
from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags
TrackD3PDFlags.storeVertexTrackIndexAssociation.set_Value_and_Lock(False)
TrackD3PDFlags.storeVertexTrackAssociation.set_Value_and_Lock(False)
TrackD3PDFlags.storeVertexFitQuality.set_Value_and_Lock(False)
from TrackD3PDMaker.xAODVertexD3PDObject import PrimaryxAODVertexD3PDObject
alg += PrimaryxAODVertexD3PDObject(
**_args(0,
'PrimaryVertex',
kw,
allowMissing=True,
sgkey=D3PDMakerFlags.VertexSGKey(),
prefix='vxp_'))
if rec.doTruth():
alg += GenEventD3PDObject(**_args(1, 'GenEvent', kw))
alg += TruthParticleD3PDObject(**_args(1, 'TruthParticle', kw))
alg += JetTileD3PDObject(**_args(1,
'AntiKt4TruthJets',
kw,
sgkey='AntiKt4TruthJets',
prefix='AntiKt4Truth_'))
alg.MetadataTools += [LBMetadataConfig()]
return alg
def JetD3PD(file,
level=4,
tuplename='jet',
seq=topSequence,
D3PDSvc='D3PD::RootD3PDSvc',
streamNameRoot=None,
**kw):
alg = D3PDMakerCoreComps.MakerAlg(tuplename,
seq,
file=file,
D3PDSvc=D3PDSvc,
streamNameRoot=streamNameRoot)
JetIncludes = ['AssocTrackCont']
alg += EventInfoD3PDObject(**_args(level, 'EventInfo', kw))
alg += ElectronD3PDObject(**_args(level, 'Electron', kw))
alg += PhotonD3PDObject(**_args(level, 'Photon', kw))
alg += MuonD3PDObject(**_args(level, 'Muon', kw))
#alg += MissingETD3PDObject (**_args (level, 'MissingET', kw))
#at the moment only the first one holds also b tagging information
alg += JetD3PDObject(**_args(level,
'AntiKt4H1TopoJets',
kw,
sgkey='AntiKt4H1TopoJets',
prefix='AntiKt4H1Topo_'))
alg += JetD3PDObject(**_args(level,
'AntiKt6H1TopoJets',
kw,
sgkey='AntiKt6H1TopoJets',
prefix='AntiKt6H1Topo_'))
if D3PDMakerFlags.DoTrigger():
alg += jetMETTriggerBitsD3PDObject(level)
alg += PrimaryVertexD3PDObject(**_args(1,
'PrimaryVertex',
kw,
allowMissing=True,
sgkey=D3PDMakerFlags.VertexSGKey(),
prefix='vxp_'))
if rec.doTruth():
alg += GenEventD3PDObject(**_args(1, 'GenEvent', kw))
alg += TruthParticleD3PDObject(**_args(1, 'TruthParticle', kw))
alg += JetD3PDObject(**_args(1,
'AntiKt4TruthJets',
kw,
sgkey='AntiKt4TruthJets',
prefix='AntiKt4Truth_'))
#alg += JetD3PDObject (level, sgkey='AntiKt6TruthJets', prefix='AntiKt6Truth_' )
alg.MetadataTools += [LBMetadataConfig()]
return alg
alg += myJetD3PDObject(
2,
'Jet_Truth10Trim',
prefix='jet_AntiKt10TruthTrimmedPtFrac5SmallR30_',
sgkey='AntiKt10TruthTrimmedPtFrac5SmallR30Jets',
include=['TrueFlavorComponents', 'JetLabel'],
exclude=[
'L1Kinematics', 'L2Kinematics', 'EFKinematics', 'El02Match',
'Mu02Match', 'L1Info', 'L2Info', 'EFInfo', 'OriginCorrection',
'DQMoments', 'JetSamplingsFrac', 'JetQual', 'EMFraction', 'JES',
'JESMoments', 'EMScale', 'Layer', 'Samplings', 'ConstituentScale',
'JetLArHVMoment', 'JetClusterMoment'
])
from TruthD3PDMaker.TruthParticleD3PDObject import TruthParticleD3PDObject
alg += TruthParticleD3PDObject(1, 'TruthParticle')
alg.TruthParticle.BlockFillers[
1].WriteE = True # Turn on the writing of the Energy branch
from TruthD3PDMaker.Atlfast1MissingETD3PDObject import TruthMETD3PDObject
alg += TruthMETD3PDObject(level=10)
# Add the necessary input containers for the objects
from TruthD3PDMaker.TruthParticleFakerObject import simpleParticleConfig
simpleParticleConfig(topSequence,
sgkey='SimpleElectronContainer',
pdg_id=11,
min_pt=1 * GeV)
simpleParticleConfig(topSequence,
sgkey='SimpleMuonContainer',
pdg_id=13,
def SMWZD3PD (alg = None,
file = 'smwz.root',
tuplename = 'physics',
streamname = 'd3pdstream',
doSoftQCD = False,
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', #Commented by Bertrand
jetEM6Container = 'AntiKt6TopoEMJets',
jetLC4Container = 'AntiKt4LCTopoJets',
jetLC6Container = 'AntiKt6LCTopoJets',
#jetEM4Container = 'AntiKt4TopoEMJetsReTagged',
#jetEM6Container = 'AntiKt6TopoEMJetsReTagged',
#jetLC4Container = 'AntiKt4LCTopoJetsReTagged',
#jetLC6Container = 'AntiKt6LCTopoJetsReTagged',
jetDetails = 3, # for the moment only level 2 and 3 are defined
METDetails = 3, # for the moment only level 2 and 3 are defined
**kw):
if doThirdMuonChain and muonContainer == 'None':
muonContainer = 'Muons'
# define associations
if not PhotonD3PDObject.allBlocknames().has_key('RecoveryMatch'):
from PhotonD3PDMaker.PhotonRecoveryAssociation import PhotonRecoveryAssociation
if (stdElectronContainer != 'None'):
PhotonRecoveryAssoc = PhotonRecoveryAssociation(PhotonD3PDObject,
'ElectronContainer',
stdElectronContainer,
prefix = 'el_',
blockname = 'RecoveryMatch',
target = 'ph_ElectronRecovered_')
# define track and cluster filters
preseq = AlgSequence (D3PDMakerFlags.PreD3PDAlgSeqName())
if not hasattr( preseq, "GoodTracks" ):
filter1 = makeTrackFilterAlg(TracksName = D3PDMakerFlags.TrackSGKey(),
OutputTracksName='GoodTracks',
ptCut=0.,nSCTPix=4)
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
# perform recoil calculation
import HadronicRecoil.Configurables as hrc
preseq = hrc.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))
from TriggerD3PDMaker.BunchStructureMetadata import addBunchStructureMetadata
addBunchStructureMetadata (alg)
from BackgroundD3PDMaker.BeamBackgroundD3PDObject import BeamBackgroundD3PDObject
from BackgroundD3PDMaker.BackgroundWordD3PDObject import BackgroundWordD3PDObject
alg += BackgroundWordD3PDObject (**_args(0, 'BkgWord', kw))
alg += BeamBackgroundD3PDObject(1)
# Electron/Photon blocks
if (stdElectronContainer != 'None'):
alg += ElectronD3PDObject (**_args (10, 'Electron', kw, sgkey = stdElectronContainer))
if (gsfElectronContainer != 'None') and testSGKey ('ElectronContainer', gsfElectronContainer):
alg += GSFElectronD3PDObject (**_args (10, 'GSFElectron', kw,
sgkey = gsfElectronContainer,
prefix = 'el_gsf_'))
if (photonContainer != 'None'):
alg += PhotonD3PDObject (**_args (10, 'Photon', kw, sgkey = photonContainer))
# Muon blocks
### Third muon chain variables!
if (muonContainer != 'None'):
alg += MuonD3PDObject (**_args (10, 'Muon', kw,
sgkey=muonContainer, prefix='mu_',
include = ["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex",
"L2CBInfoIndex", "L1InfoIndex"],
exclude = ["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing = True ))
### Third muon chain variables!
if (muidMuonContainer != 'None'):
alg += MuonD3PDObject (**_args (10, 'MuidMuon', kw,
sgkey=muidMuonContainer, prefix='mu_muid_',
include = ["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex",
"L2CBInfoIndex", "L1InfoIndex"],
exclude = ["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing = True ))
if (stacoMuonContainer != 'None'):
alg += MuonD3PDObject (**_args (10, 'StacoMuon', kw,
sgkey=stacoMuonContainer, prefix='mu_staco_',
include = ["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex",
"L2CBInfoIndex", "L1InfoIndex"],
exclude = ["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing = True ))
if (caloMuonContainer != 'None'):
alg += MuonD3PDObject (**_args (10, 'CaloMuon', kw,
sgkey=caloMuonContainer, prefix='mu_calo_',
include = ["MuonHitSummary", "Authors", "Likelihood",
"Isolation", "CaloEnergyLoss", "Quality"] ))
# Tau block
if (tauContainer != 'None'):
alg += TauD3PDObject (**_args ( 1, 'Tau', kw, sgkey = tauContainer))
# Jet blocks
from JetTagD3PDMaker.JetTagD3PDMakerFlags import JetTagD3PDFlags
from JetTagD3PDMaker.JetTagD3PDMakerKeys import JetTagD3PDKeys
## add MSV target to the jetd3pd object properties
if not kw.has_key ('AK4TopoEMJet_'+JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName()+'_target'):
kw['AK4TopoEMJet_'+JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName()+'_target']= JetTagD3PDKeys.MSVVtxInfoInJetGetterLabel()
if not kw.has_key ('AK6TopoEMJet_'+JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName()+'_target'):
kw['AK6TopoEMJet_'+JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName()+'_target']= JetTagD3PDKeys.MSVVtxInfoInJetGetterLabel()
## add track index for IPInfoPlus
if not kw.has_key ('AK4TopoEMJet_'+JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()+'_target'):
kw['AK4TopoEMJet_'+JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()+'_target']= "trk"
if not kw.has_key ('AK6TopoEMJet_'+JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()+'_target'):
kw['AK6TopoEMJet_'+JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()+'_target']= "trk"
## add track index for SVInfoPlus
if not kw.has_key ('AK4TopoEMJet_'+JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName()+'_target'):
kw['AK4TopoEMJet_'+JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName()+'_target']= "trk"
if not kw.has_key ('AK6TopoEMJet_'+JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName()+'_target'):
kw['AK6TopoEMJet_'+JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName()+'_target']= "trk"
## add track index for SV0InfoPlus
if not kw.has_key ('AK4TopoEMJet_'+JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName()+'_target'):
kw['AK4TopoEMJet_'+JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName()+'_target']= "trk"
if not kw.has_key ('AK6TopoEMJet_'+JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName()+'_target'):
kw['AK6TopoEMJet_'+JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName()+'_target']= "trk"
## add MSV target to the jetd3pd object properties
if not kw.has_key ('AK4LCTopoJet_'+JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName()+'_target'):
kw['AK4LCTopoJet_'+JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName()+'_target']= JetTagD3PDKeys.MSVVtxInfoInJetGetterLabel()
if not kw.has_key ('AK6LCTopoJet_'+JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName()+'_target'):
kw['AK6LCTopoJet_'+JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName()+'_target']= JetTagD3PDKeys.MSVVtxInfoInJetGetterLabel()
## add track index for IPInfoPlus
if not kw.has_key ('AK4LCTopoJet_'+JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()+'_target'):
kw['AK4LCTopoJet_'+JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()+'_target']= "trk"
if not kw.has_key ('AK6LCTopoJet_'+JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()+'_target'):
kw['AK6LCTopoJet_'+JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()+'_target']= "trk"
## add track index for SVInfoPlus
if not kw.has_key ('AK4LCTopoJet_'+JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName()+'_target'):
kw['AK4LCTopoJet_'+JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName()+'_target']= "trk"
if not kw.has_key ('AK6LCTopoJet_'+JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName()+'_target'):
kw['AK6LCTopoJet_'+JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName()+'_target']= "trk"
## add track index for SV0InfoPlus
if not kw.has_key ('AK4LCTopoJet_'+JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName()+'_target'):
kw['AK4LCTopoJet_'+JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName()+'_target']= "trk"
if not kw.has_key ('AK6LCTopoJet_'+JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName()+'_target'):
kw['AK6LCTopoJet_'+JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName()+'_target']= "trk"
if jetDetails == 3:
jetInclude = JetTagD3PDFlags.StdInfoInclude()+[JetTagD3PDKeys.MultiSVInfoPlusBlockName()]
jetInclude += [JetTagD3PDKeys.JetFitterCharmTagInfoBlockName(), JetTagD3PDKeys.JetFitterCharmInfoBaseBlockName()]
else:
jetInclude = [ JetTagD3PDKeys.BTagWeightsBlockName(), JetTagD3PDKeys.TruthInfoBlockName() ]
if (jetEM4Container != 'None'):
alg += JetD3PDObject (**_args ( 4, 'AK4TopoEMJet', kw,
sgkey=jetEM4Container, prefix='jet_AntiKt4TopoEM_',
include = jetInclude+['BeamBackground','ConstituentScale','TracksMoments'],
JetVertexFraction_FromUD=False,
JetVertexFraction_FillFullJVF=False,
allowMissing = True))
if (jetEM6Container != 'None'):
alg += JetD3PDObject (**_args ( 4, 'AK6TopoEMJet', kw,
sgkey=jetEM6Container, prefix='jet_AntiKt6TopoEM_',
include = jetInclude+['BeamBackground','ConstituentScale','TracksMoments'],
JetVertexFraction_FromUD=False,
JetVertexFraction_FillFullJVF=False,
allowMissing = True))
if (jetLC4Container != 'None'):
alg += JetD3PDObject (**_args ( 4, 'AK4LCTopoJet', kw,
sgkey=jetLC4Container, prefix='jet_AntiKt4LCTopo_',
include = jetInclude+['BeamBackground','ConstituentScale','TracksMoments'],
JetVertexFraction_FromUD=False,
JetVertexFraction_FillFullJVF=False,
allowMissing = True))
if (jetLC6Container != 'None'):
alg += JetD3PDObject (**_args ( 4, 'AK6LCTopoJet', kw,
sgkey=jetLC6Container, prefix='jet_AntiKt6LCTopo_',
include = jetInclude+['BeamBackground','ConstituentScale','TracksMoments'],
JetVertexFraction_FromUD=False,
JetVertexFraction_FillFullJVF=False,
allowMissing = True))
### add the MSV block
MSVJetCollections = []
if (jetEM4Container != 'None'):
MSVJetCollections += [jetEM4Container]
if (jetEM6Container != 'None'):
MSVJetCollections += [jetEM6Container]
if (jetLC4Container != 'None'):
MSVJetCollections += [jetLC4Container]
if (jetLC6Container != 'None'):
MSVJetCollections += [jetLC6Container]
### link multisv to tracks
if not kw.has_key ('msvvtxinfo_JetTag_JetMultiSVVtxAssoc_target'):
kw['msvvtxinfo_JetTag_JetMultiSVVtxAssoc_target']= "trk"
from JetTagD3PDMaker.JetTagMSVVtxInJetD3PDObject import getJetTagMSVVtxInfoInJetD3PDObject
alg += getJetTagMSVVtxInfoInJetD3PDObject(**_args(1,"msvvtxinfo", kw,
jetCollections=MSVJetCollections)
)
from TopInputsD3PDMaker.HforD3PDObject import HforD3PDObject
alg += HforD3PDObject(**_args (0, 'HforInfo', kw))
# MET blocks
# a whole mess to remove x,y components separately for all flavours
if METDetails >= 3:
alg += MissingETD3PDObject (**_args (10, 'MissingET', kw,
exclude=['MET_Base', 'MET_Base0', 'MET_Truth_Int',
'MET_RefFinal_Comps','MET_Calib_Comps','MET_CellOut_Comps',
'MET_CorrTopo_Comps','MET_Cryo_Comps','MET_CryoCone_Comps',
'MET_Final_Comps','MET_LocHadTopo_Comps',
'MET_LocHadTopoObj_Comps','MET_Muid_Comps',
'MET_Muid_Spectro_Comps','MET_Muid_Track_Comps',
'MET_MuonBoy_Comps','MET_MuonBoy_Spectro_Comps',
'MET_MuonBoy_Track_Comps','MET_MuonMuid_Comps',
'MET_Muon_Comps','MET_Muon_Isol_Muid_Comps',
'MET_Muon_Isol_Staco_Comps','MET_Muon_NonIsol_Muid_Comps',
'MET_Muon_NonIsol_Staco_Comps','MET_Muon_Total_Muid_Comps',
'MET_Muon_Total_Staco_Comps','MET_RefEle_Comps',
'MET_RefEle_em_Comps','MET_RefGamma_Comps',
'MET_RefGamma_em_Comps','MET_RefJet_Comps',
'MET_RefJet_em_Comps','MET_RefMuon_Comps',
'MET_RefMuon_Muid_Comps','MET_RefMuon_Staco_Comps',
'MET_RefMuon_Track_Muid_Comps','MET_RefMuon_Track_Staco_Comps',
'MET_RefMuon_Track_em_Comps','MET_RefMuon_Track_Comps',
'MET_RefMuon_em_Comps','MET_RefTau_Comps',
'MET_RefTau_em_Comps','MET_SoftJets_Comps',
'MET_SoftJets_em_Comps','MET_Topo_Comps',
'MET_TopoObj_Comps','MET_Track_Comps','MET_Comps',
'MET_Track_Weights','MET_Cluster_Weights'],
allowMissing=True))
elif METDetails > 0:
alg += MissingETD3PDObject (**_args (10, 'MissingET', kw,
exclude=['MET_Base','MET_Base0','MET_Truth',
'MET_CellOut_Comps','MET_CellOut_Regions',
'MET_CellOut_em_Comps','MET_CellOut_em_Regions',
'MET_CellOut_Eflow_Comps','MET_CellOut_Eflow_Regions',
'MET_Calib',
'MET_CorrTopo',
'MET_Cryo',
'MET_CryoCone',
'MET_Final',
'MET_LocHadTopo_Comps',
'MET_LocHadTopoObj',
'MET_Muid',
'MET_Muid_Spectro',
'MET_Muid_Track',
'MET_MuonBoy_Regions',
'MET_MuonBoy_Spectro',
'MET_MuonBoy_Track',
'MET_MuonMuid',
'MET_Muon',
'MET_Muon_Isol_Muid',
'MET_Muon_Isol_Staco',
'MET_Muon_NonIsol_Muid',
'MET_Muon_NonIsol_Staco',
'MET_Muon_Total_Muid',
'MET_Muon_Total_Staco',
'MET_RefEle_Comps','MET_RefEle_Regions',
'MET_RefEle_em_Comps','MET_RefEle_em_Regions',
'MET_RefGamma_Comps','MET_RefGamma_Regions',
'MET_RefGamma_em_Comps','MET_RefGamma_em_Regions',
'MET_RefJet_Comps','MET_RefJet_Regions',
'MET_RefJet_em_Comps','MET_RefJet_em_Regions',
'MET_RefMuon_Comps','MET_RefMuon_Regions',
'MET_RefMuon_Muid_Comps','MET_RefMuon_Muid_Regions',
'MET_RefMuon_Staco_Comps','MET_RefMuon_Staco_Regions',
'MET_RefMuon_Track_Muid_Comps','MET_RefMuon_Track_Muid_Regions',
'MET_RefMuon_Track_Staco_Comps','MET_RefMuon_Track_Staco_Regions',
'MET_RefMuon_Track_em_Comps','MET_RefMuon_Track_em_Regions',
'MET_RefMuon_Track_Comps','MET_RefMuon_Track_Regions',
'MET_RefMuon_em_Comps','MET_RefMuon_em_Regions',
'MET_RefTau_Comps','MET_RefTau_Regions',
'MET_RefTau_em_Comps','MET_RefTau_em_Regions',
'MET_SoftJets_Comps','MET_SoftJets_Regions',
'MET_SoftJets_em_Comps','MET_SoftJets_em_Regions',
'MET_Topo',
'MET_TopoObj_Comps','MET_TopoObj_Regions',
'MET_Track_Comps','MET_Track_Regions',
'MET_Track_Weights','MET_Cluster_Weights',
'MET_Comps'
],
allowMissing=True ))
if METDetails > 0:
add_met (alg)
# track and cluster blocks
# ... all clusters, very low LOD
alg += ClusterD3PDObject (**_args ( 0, 'Clusters1', kw,
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_'))
from TrackD3PDMaker.TrackD3PDObject import TrackD3PDObject
# ... good tracks only (nSCT>3; no pt cut)
# turn on detailed track info if writing SoftQCD version of D3PD
if doSoftQCD :
from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags as softQcdFlags
softQcdFlags.doTruth = True
softQcdFlags.storeDetailedTruth = False
softQcdFlags.storeDiagonalCovarianceAsErrors = True
softQcdFlags.storeHitTruthMatching = True
softQcdFlags.storePixelHitsOnTrack = False
softQcdFlags.storePixelHolesOnTrack = False
softQcdFlags.storePixelOutliersOnTrack = False
softQcdFlags.storeSCTHitsOnTrack = False
softQcdFlags.storeSCTHolesOnTrack = False
softQcdFlags.storeSCTOutliersOnTrack = False
softQcdFlags.storeTRTHitsOnTrack = False
softQcdFlags.storeTRTHolesOnTrack = False
softQcdFlags.storeTRTOutliersOnTrack = False
softQcdFlags.storeTrackFitQuality = True
softQcdFlags.storeTrackInfo = True
softQcdFlags.storeTrackMomentum = True
softQcdFlags.storeTrackPredictionAtBLayer = True
softQcdFlags.storeTrackSummary = True
softQcdFlags.trackParametersAtBeamSpotLevelOfDetails = 0
softQcdFlags.trackParametersAtGlobalPerigeeLevelOfDetails = 2
softQcdFlags.trackParametersAtPrimaryVertexLevelOfDetails = 2
SoftQCDTrackParticleD3PDObject = TrackD3PDObject(_label='trk',
_prefix='trk_',
_sgkey='GoodTracks',
typeName='Rec::TrackParticleContainer',
truthMapKey='TrackParticleTruthCollection',
SGKeyForTruth=D3PDMakerFlags.TrackSGKey(),
flags=softQcdFlags)
alg += SoftQCDTrackParticleD3PDObject(**_args ( 3, 'Tracks1', kw,
sgkey = 'GoodTracks',
label = 'trk',
prefix = 'trk_'))
else :
# ... use standard level of track info for 'GoodTracks'
alg += TrackParticleD3PDObject (**_args ( 3, 'Tracks1', kw,
sgkey = 'GoodTracks',
label = 'trk',
prefix = 'trk_'))
# ... high-pt tracks (nSCT>3; pt>5 GeV)
from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags as highPtFlags
highPtFlags.doTruth = True
highPtFlags.storeDiagonalCovarianceAsErrors = True
highPtFlags.storeHitTruthMatching = True
highPtFlags.storePixelHitsOnTrack = False
highPtFlags.storePixelHolesOnTrack = False
highPtFlags.storePixelOutliersOnTrack = False
highPtFlags.storeSCTHitsOnTrack = False
highPtFlags.storeSCTHolesOnTrack = False
highPtFlags.storeSCTOutliersOnTrack = False
highPtFlags.storeTRTHitsOnTrack = False
highPtFlags.storeTRTHolesOnTrack = False
highPtFlags.storeTRTOutliersOnTrack = False
highPtFlags.storeTrackFitQuality = True
highPtFlags.storeTrackMomentum = True
highPtFlags.storeTrackSummary = True
highPtFlags.storeTrackSummary.IDOutliers = True
highPtFlags.storeTrackSummary.PixelInfoPlus = True
highPtFlags.storeTrackSummary.SCTInfoPlus = True
highPtFlags.storeTrackSummary.TRTInfoPlus = True
highPtFlags.storeTrackSummary.InfoPlus = True
highPtFlags.trackParametersAtBeamSpotLevelOfDetails = 0
highPtFlags.trackParametersAtGlobalPerigeeLevelOfDetails = 2
highPtFlags.trackParametersAtPrimaryVertexLevelOfDetails = 3
HighPtTrackParticleD3PDObject = TrackD3PDObject(_label='trkpt4',
_prefix='trkpt4_',
_sgkey='HighPtTracks',
typeName='Rec::TrackParticleContainer',
truthMapKey='TrackParticleTruthCollection',
SGKeyForTruth=D3PDMakerFlags.TrackSGKey(),
flags=highPtFlags)
alg += HighPtTrackParticleD3PDObject(**_args ( 3, 'Tracks2', kw,
sgkey = 'HighPtTracks',
label = 'trkpt4',
prefix = 'trkpt4_'))
# Primary vertex block - May be missing in single-beam data.
alg += PrimaryVertexD3PDObject (**_args (1, 'PrimaryVertex', kw,
allowMissing = True,
sgkey = D3PDMakerFlags.VertexSGKey(),
prefix = 'vxp_'))
# 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))
### EventShape variables Bertrand
alg += EventShapeD3PDObject(**_args(0, 'rho', kw))
# Truth
if rec.doTruth():
from TruthD3PDMaker.TruthParticleD3PDObject import TruthParticleD3PDObject
alg += TruthParticleD3PDObject(**_args ( 1, 'TruthParticle', kw))
from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject
alg += TruthMuonD3PDObject (**_args ( 2, 'TruthMuon', kw))
from AthenaCommon.AppMgr import ToolSvc
from TruthD3PDAnalysis.TruthD3PDAnalysisConf import D3PD__GenObjectsFilterTool
# ... remove empty GenEvents
smwzGenEvtFilterTool = D3PD__GenObjectsFilterTool( "smwzGenEvtFilterTool" )
ToolSvc += smwzGenEvtFilterTool
smwzGenEvtFilterTool.RemoveDummyEvents = True
smwzGenEvtFilterTool.RemoveInTimePileUp = True
smwzGenEvtFilterTool.Remove2BCPileUp = True
smwzGenEvtFilterTool.Remove800nsPileUp = True
smwzGenEvtFilterTool.RemoveCavernBkg = True
smwzGenEvtFilterTool.RemoveEmptyEvents = True
from TruthD3PDMaker.GenEventD3PDObject import GenEventD3PDObject
alg += GenEventD3PDObject (**_args ( 0, 'GenEvent', kw, filter = smwzGenEvtFilterTool ))
# ... TruthJets
if not testSGKey ('JetCollection', 'AntiKt6TruthJets'):
make_StandardJetGetter('AntiKt', 0.6, 'Truth')
alg += JetD3PDObject (**_args ( 1, 'AK4TruthJet', kw,
sgkey='AntiKt4TruthJets',prefix='jet_AntiKt4Truth_',
allowMissing = True))
alg += JetD3PDObject (**_args ( 1, 'AK6TruthJet', kw,
sgkey='AntiKt6TruthJets', prefix='jet_AntiKt6Truth_',
allowMissing = True))
alg += JetD3PDObject (**_args ( 1, 'AK4TruthJetALL', kw,
sgkey='AntiKt4TruthJets_ALL', prefix='jet_AntiKt4TruthALL_',
allowMissing = True))
alg += JetD3PDObject (**_args ( 1, 'AK6TruthJetALL', kw,
sgkey='AntiKt6TruthJets_ALL', prefix='jet_AntiKt6TruthALL_',
allowMissing = True))
alg += JetD3PDObject (**_args ( 1, 'AK4TruthJetWZ', kw,
sgkey='AntiKt4TruthJets_WZ', prefix='jet_AntiKt4TruthWZ_',
allowMissing = True))
alg += JetD3PDObject (**_args ( 1, 'AK6TruthJetWZ', kw,
sgkey='AntiKt6TruthJets_WZ', prefix='jet_AntiKt6TruthWZ_',
allowMissing = True))
# ... heavy flavor truth information
from AthenaCommon.AppMgr import ToolSvc
from TruthD3PDAnalysis.TruthD3PDAnalysisConf import D3PD__GenObjectsFilterTool
smwzhfGenVtxFilterTool = D3PD__GenObjectsFilterTool( "SMWZHFGenVtxFilterTool" )
ToolSvc += smwzhfGenVtxFilterTool
smwzhfGenVtxFilterTool.RemoveInTimePileUp = False
smwzhfGenVtxFilterTool.Remove2BCPileUp = True
smwzhfGenVtxFilterTool.Remove800nsPileUp = True
smwzhfGenVtxFilterTool.RemoveCavernBkg = True
smwzhfGenVtxFilterTool.RemoveEmptyEvents = True
smwzhfGenVtxFilterTool.RemoveDummyEvents = True
smwzhfGenVtxFilterTool.RemoveUnrequestedParticles=True
smwzhfGenVtxFilterTool.KeepBCHadrons=True
from TruthD3PDMaker.GenVertexD3PDObject import GenVertexD3PDObject
alg += GenVertexD3PDObject( **_args(0, "hfgenvertex", kw, prefix='mchfvtx_',
filter = smwzhfGenVtxFilterTool )
)
smwzhfGenPartFilterTool = D3PD__GenObjectsFilterTool( "SMWZHFGenPartFilterTool" )
ToolSvc += smwzhfGenPartFilterTool
smwzhfGenPartFilterTool.RemoveInTimePileUp = False
smwzhfGenPartFilterTool.Remove2BCPileUp = True
smwzhfGenPartFilterTool.Remove800nsPileUp = True
smwzhfGenPartFilterTool.RemoveCavernBkg = True
smwzhfGenPartFilterTool.RemoveEmptyEvents = True
smwzhfGenPartFilterTool.RemoveDummyEvents = True
smwzhfGenPartFilterTool.RemoveUnrequestedParticles=True
smwzhfGenPartFilterTool.KeepBCQuarks=True
smwzhfGenPartFilterTool.KeepBCQuarkAncestors=True
smwzhfGenPartFilterTool.KeepBCHadrons=True
smwzhfGenPartFilterTool.KeepBCHadronDecayChain=True
smwzhfGenPartFilterTool.BCHadronsDescendantsPtCut=200
smwzhfGenPartFilterTool.BCHadronsDescendantsBarcodeCut=300000
smwzhfGenPartFilterTool.BCHadronsDescendantsEtaCut=5
from TruthD3PDMaker.GenParticleD3PDObject import GenParticleD3PDObject
alg += GenParticleD3PDObject( **_args(10, "hfgenparticle", kw, prefix='mchfpart_',
filter = smwzhfGenPartFilterTool,
GenParticle_WriteMotherType=False,
GenParticle_WriteMotherBarcode=False
)
)
# ... leptonic W/Z truth information
smwzlepwzGenPartFilterTool = D3PD__GenObjectsFilterTool( "SMWZLepWZGenPartFilterTool" )
ToolSvc += smwzlepwzGenPartFilterTool
smwzlepwzGenPartFilterTool.RemoveInTimePileUp = True
smwzlepwzGenPartFilterTool.Remove2BCPileUp = True
smwzlepwzGenPartFilterTool.Remove800nsPileUp = True
smwzlepwzGenPartFilterTool.RemoveCavernBkg = True
smwzlepwzGenPartFilterTool.RemoveEmptyEvents = True
smwzlepwzGenPartFilterTool.RemoveDummyEvents = True
smwzlepwzGenPartFilterTool.RemoveUnrequestedParticles=True
smwzlepwzGenPartFilterTool.KeepLeptonicWZBosons=True
smwzlepwzGenPartFilterTool.KeepLeptonicWZBosonDecayChains=True
smwzlepwzGenPartFilterTool.KeepLeptonicWZBosonsParents=True
from TruthD3PDMaker.GenParticleD3PDObject import GenParticleD3PDObject
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"
)
)
if not rec.doTruth():
alg += BeamSpotD3PDObject(10)
# Trigger
if D3PDMakerFlags.DoTrigger():
alg += SMWZTriggerBitsD3PDObject (**_args (10, 'SMWZTriggerBits', kw))
# Trigger Decision + metadata
alg += TrigDecisionD3PDObject (**_args(10, 'TrigDecision', kw))
addTrigConfMetadata(alg)
# Bunch group info
alg += BGCodeD3PDObject (**_args (2, 'BGCode', kw))
# Egamma and Mu
TrigEgammaD3PDObjects (alg, 1)
TrigMuonD3PDObjects( alg, 1)
# MET
TrigMETD3PDObjects (alg, 2)
# The BJet information:
TrigBJetD3PDObjects(alg,10, False, False, True, True, True)
# Event metadata
alg.MetadataTools += [LBMetadataConfig()]
if D3PDMakerFlags.FilterCollCand():
from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg
alg.filterSeq += CollisionFilterAlg (tuplename + '_CollCandFilter')
return alg
def ZPrimeEED3PD(alg=None,
file='smwz.root',
tuplename='physics',
streamname='d3pdstream',
doSoftQCD=False,
**kw):
# 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))
# Electron/Photon blocks
elInclude = [
'HadLeakage',
'Layer1Shape',
'Layer1ShapeExtra',
'Layer2Shape',
'Layer3Shape',
'Iso',
'IsoPtCorrected',
'ConvFlags',
'Conversion',
'TrkMatch',
'Retaphi',
'Rings',
'ElecDiscrim',
'Pointing',
'Samplings',
'ClusterKin',
'FwdEVars',
'D3PD__egammaRawClusterAssociationTool',
'RawSamplings',
'RawClusterKin',
'TrkInfo',
'Trk',
'TrkFitQuality',
'IDHits',
'TrackSummaryPID',
'Vertex',
'trackImpactbeam',
'trackImpactSigbeam',
'trackImpactpv',
'trackImpactSigpv',
'trackOldImpactpvunbiased',
'trackImpactpvunbiased',
'UDLayer1Shape',
'UDShowerDepth',
'IsIso',
'MVAIso',
'JetMatch',
'JetKinematics',
'PAU',
'PAUVariables',
'EFIndex',
'L2Index',
'L1Index',
]
elExclude = []
alg += ElectronD3PDObject(
**_args(0,
'Electron',
kw,
sgkey=kw.get('electronContainer', 'ElectronAODCollection'),
include=elInclude,
exclude=elExclude))
phInclude = [
'HadLeakage', 'Layer1Shape', 'Layer1ShapeExtra', 'Layer2Shape', 'Iso',
'IsoPtCorrected', 'Conversion', 'Retaphi', 'TopoClusterIsolationCones',
'Pointing', 'ClusterKin', 'Samplings', 'UDTopoCones', 'CorrIso',
'ConvIP', 'TopoMatch', 'TopoKinematics', 'TopoEMMatch',
'TopoEMKinematics'
]
phExclude = []
alg += PhotonD3PDObject(
**_args(0,
'Photon',
kw,
sgkey=kw.get('photonContainer', 'PhotonAODCollection'),
include=phInclude,
exclude=phExclude))
# Muon blocks
muInclude = ['AcceptMethods']
muExclude = [
'TrkInfo', 'EFCBInfoIndex', 'EFCBInfo', 'EFMGInfo', 'EFMEInfo',
'L2CBInfoIndex', 'L2CBInfo', 'L1InfoIndex', 'L1Info', 'AllAuthor',
'SelectionFlagging', 'CBTrackDetails', 'MGTrackDetails'
]
#Muid
if cfgKeyStore.isInInput("Analysis::MuonContainer", "MuidMuonCollection"):
alg += MuonD3PDObject(**_args(0,
'MuidMuon',
kw,
sgkey='MuidMuonCollection',
prefix='mu_muid_',
include=muInclude,
exclude=muExclude,
allowMissing=True))
#Staco
if cfgKeyStore.isInInput("Analysis::MuonContainer", "StacoMuonCollection"):
alg += MuonD3PDObject(**_args(0,
'StacoMuon',
kw,
sgkey='StacoMuonCollection',
prefix='mu_staco_',
include=muInclude,
exclude=muExclude,
allowMissing=True))
#Third chain
if cfgKeyStore.isInInput("Analysis::MuonContainer", "Muons"):
alg += MuonD3PDObject(**_args(0,
'Muons',
kw,
sgkey='Muons',
prefix='mu_',
include=muInclude,
exclude=muExclude,
allowMissing=True))
# Jet blocks
from JetTagD3PDMaker.JetTagD3PDMakerFlags import JetTagD3PDFlags
alg += JetD3PDObject(**_args(1,
'AK4TopoEMJet',
kw,
sgkey='AntiKt4TopoEMJets',
prefix='jet_AntiKt4TopoEM_',
include=[],
exclude=[
'JESMoments', 'JVtx', 'El02Match',
'Mu02Match', 'L1Info', 'L2Info', 'EFInfo'
],
allowMissing=True))
# EventShape variables
alg += EventShapeD3PDObject(**_args(0, 'rho', kw))
#MET
metKeys = [
'MET_LocHadTopo', 'MET_RefFinal', 'MET_RefEle', 'MET_RefMuon',
'MET_RefMuon_Staco', 'MET_RefMuon_Muid', 'MET_CorrTopo',
'MET_RefFinal_em', 'MET_Topo', 'MET_Calib', 'MET_CellOut_Eflow_Muons',
'MET_CellOut_Eflow', 'MET_CellOut_Eflow_Muid', 'MET_MuonBoy',
'MET_Muons', 'MET_Muid', 'MET_RefMuons', 'MET_RefFinal_STVF',
'MET_RefJet_JVF', 'MET_RefJet_JVFCut', 'MET_CellOut_Eflow_STVF',
'MET_CellOut_Eflow_JetArea'
]
for key in metKeys:
alg += MissingETD3PDObject(
**_args(-1,
key,
kw,
prefix=key,
sgkey=key,
include=['MET_Phi', 'MET_Et', 'MET_SumEt'],
exclude=[],
allowMissing=True))
#EMFrac for MET_LocHadTopo
alg += TopoMETD3PDObject(
**_args(-1,
'MET_LocHadTopo_SUMET_EMFrac',
kw,
prefix='MET_LocHadTopo_',
name_prefix='MET_LocHadTopo_SUMET_EMFrac_',
sgkey='MET_LocHadTopo',
include=['MET_Calo_EMFracSET'],
exclude=[],
allowMissing=True))
# Primary vertex block - May be missing in single-beam data.
alg += PrimaryVertexD3PDObject(**_args(1,
'PrimaryVertex',
kw,
allowMissing=True,
sgkey=D3PDMakerFlags.VertexSGKey(),
prefix='vxp_'))
# Truth
if rec.doTruth():
from TruthD3PDMaker.TruthParticleD3PDObject import TruthParticleD3PDObject
from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject
alg += TruthMuonD3PDObject(**_args(2, 'TruthMuon', kw))
alg += GenEventD3PDObject(**_args(1, 'GenEvent', kw))
alg += TruthParticleD3PDObject(**_args(1, 'TruthParticle', kw))
# TruthJets
alg += JetD3PDObject(**_args(1,
'AK4TruthJet',
kw,
sgkey='AntiKt4TruthJets',
prefix='jet_AntiKt4Truth_',
allowMissing=True))
if not rec.doTruth():
alg += BeamSpotD3PDObject(10)
# Trigger
if D3PDMakerFlags.DoTrigger():
alg += ZPrimeEETriggerBitsD3PDObject(
**_args(10, 'ZPrimeEETriggerBits', kw))
# Trigger Decision + metadata
alg += TrigDecisionD3PDObject(**_args(10, 'TrigDecision', kw))
addTrigConfMetadata(alg)
# Egamma
alg += InitTrigD3PDObject(1)
alg += EmTauROID3PDObject(1,
prefix="trig_L1_emtau_",
exclude=['ThrInfo'])
alg += TrigElectronD3PDObject(
1,
name='trig_L2_el_',
prefix='trig_L2_el_',
sgkey='HLT_L2ElectronFex,HLT_L2IDCaloFex',
allowMissing=True)
alg += TrigPhotonD3PDObject(1,
name='trig_L2_ph_',
prefix='trig_L2_ph_')
alg += EFElectronD3PDObject(1,
name='trig_EF_el_',
sgkey='HLT_egamma_Electrons,HLT_egamma',
prefix='trig_EF_el_',
allowMissing=True)
alg += EFPhotonD3PDObject(1,
name='trig_EF_ph_',
sgkey='HLT_egamma_Photons,HLT_egamma',
prefix='trig_EF_ph_',
allowMissing=True)
# Event metadata
alg.MetadataTools += [LBMetadataConfig()]
if D3PDMakerFlags.FilterCollCand():
from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg
alg.filterSeq += CollisionFilterAlg(tuplename + '_CollCandFilter')
return alg
def ZPrimeMMD3PD(alg=None,
file='smwz.root',
tuplename='physics',
streamname='d3pdstream',
doSoftQCD=False,
doThirdMuonChain=True,
**kw):
# define associations
if not PhotonD3PDObject.allBlocknames().has_key('RecoveryMatch'):
from PhotonD3PDMaker.PhotonRecoveryAssociation import PhotonRecoveryAssociation
PhotonRecoveryAssoc = PhotonRecoveryAssociation(
PhotonD3PDObject,
'ElectronContainer',
D3PDMakerFlags.ElectronSGKey(),
prefix='el_',
blockname='RecoveryMatch',
target='ph_ElectronRecovered_')
# define track and cluster filters
preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName())
if not hasattr(preseq, "GoodTracks"):
filter1 = makeTrackFilterAlg(TracksName=D3PDMakerFlags.TrackSGKey(),
OutputTracksName='GoodTracks',
ptCut=0.,
nSCTPix=4)
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
# perform recoil calculation
import HadronicRecoil.Configurables as hrc
preseq = hrc.add_hadronic_recoil_filters(preseq)
# 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))
from TriggerD3PDMaker.BunchStructureMetadata import addBunchStructureMetadata
addBunchStructureMetadata(alg)
# Electron/Photon blocks
alg += ElectronD3PDObject(**_args(10, 'Electron', kw))
if testSGKey('ElectronContainer', D3PDMakerFlags.GSFElectronSGKey()):
alg += GSFElectronD3PDObject(
**_args(10,
'GSFElectron',
kw,
sgkey=D3PDMakerFlags.GSFElectronSGKey(),
prefix='el_gsf_'))
alg += PhotonD3PDObject(**_args(10, 'Photon', kw))
# Muon blocks
### add the scattering significance filler - to be removed when added in the MuonD3PDMaker
if not MuonD3PDObject.allBlocknames().has_key(
"MuonScatteringAngleSignificance"):
from AthenaCommon.AppMgr import ToolSvc
muonScatteringSigTool = None
if hasattr(ToolSvc, "MuonScatteringSigTool"):
muonScatteringSigTool = ToolSvc.MuonScatteringSigTool
from JetTagD3PDMaker import MuonScatteringAngleSignificanceFillerTool
MuonD3PDObject.defineBlock(100,
"MuonScatteringAngleSignificance",
MuonScatteringAngleSignificanceFillerTool,
ScatteringSigTool=muonScatteringSigTool)
### Third muon chain variables!
if doThirdMuonChain:
if cfgKeyStore.isInInput("Analysis::MuonContainer", "Muons"):
alg += MuonD3PDObject(**_args(
10,
'Muon',
kw,
sgkey='Muons',
prefix='mu_',
include=[
"EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex",
"L2CBInfoIndex", "L1InfoIndex",
"MuonScatteringAngleSignificance"
],
exclude=[
"EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"
],
allowMissing=True))
### Third muon chain variables!
if cfgKeyStore.isInInput("Analysis::MuonContainer", "MuidMuonCollection"):
alg += MuonD3PDObject(**_args(
10,
'MuidMuon',
kw,
sgkey='MuidMuonCollection',
prefix='mu_muid_',
include=[
"EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex",
"L2CBInfoIndex", "L1InfoIndex",
"MuonScatteringAngleSignificance"
],
exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing=True))
if cfgKeyStore.isInInput("Analysis::MuonContainer", "StacoMuonCollection"):
alg += MuonD3PDObject(**_args(
10,
'StacoMuon',
kw,
sgkey='StacoMuonCollection',
prefix='mu_staco_',
include=[
"EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex",
"L2CBInfoIndex", "L1InfoIndex",
"MuonScatteringAngleSignificance"
],
exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing=True))
if cfgKeyStore.isInInput("Analysis::MuonContainer", "CaloMuonCollection"):
alg += MuonD3PDObject(
**_args(0,
'CaloMuon',
kw,
sgkey='CaloMuonCollection',
prefix='mu_calo_',
include=[
"MuonHitSummary", "Authors", "Likelihood", "Isolation",
"CaloEnergyLoss", "Quality"
]))
# Tau block
alg += TauD3PDObject(**_args(1, 'Tau', kw))
# Jet blocks
from JetTagD3PDMaker.JetTagD3PDMakerFlags import JetTagD3PDFlags
from JetTagD3PDMaker.JetTagD3PDMakerKeys import JetTagD3PDKeys
## add MSV target to the jetd3pd object properties
if not kw.has_key('AK4TopoEMJet_' +
JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName() +
'_target'):
kw['AK4TopoEMJet_' +
JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName() +
'_target'] = JetTagD3PDKeys.MSVVtxInfoInJetGetterLabel()
if not kw.has_key('AK6TopoEMJet_' +
JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName() +
'_target'):
kw['AK6TopoEMJet_' +
JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName() +
'_target'] = JetTagD3PDKeys.MSVVtxInfoInJetGetterLabel()
## add track index for IPInfoPlus
if not kw.has_key('AK4TopoEMJet_' +
JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName() +
'_target'):
kw['AK4TopoEMJet_' + JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName() +
'_target'] = "trk"
if not kw.has_key('AK6TopoEMJet_' +
JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName() +
'_target'):
kw['AK6TopoEMJet_' + JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName() +
'_target'] = "trk"
## add track index for SVInfoPlus
if not kw.has_key('AK4TopoEMJet_' +
JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName() +
'_target'):
kw['AK4TopoEMJet_' + JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName() +
'_target'] = "trk"
if not kw.has_key('AK6TopoEMJet_' +
JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName() +
'_target'):
kw['AK6TopoEMJet_' + JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName() +
'_target'] = "trk"
## add track index for SV0InfoPlus
if not kw.has_key('AK4TopoEMJet_' +
JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName() +
'_target'):
kw['AK4TopoEMJet_' + JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName() +
'_target'] = "trk"
if not kw.has_key('AK6TopoEMJet_' +
JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName() +
'_target'):
kw['AK6TopoEMJet_' + JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName() +
'_target'] = "trk"
alg += JetD3PDObject(**_args(3,
'AK4TopoEMJet',
kw,
sgkey='AntiKt4TopoEMJets',
prefix='jet_AntiKt4TopoEM_',
include=JetTagD3PDFlags.StdInfoInclude() +
[JetTagD3PDKeys.MultiSVInfoPlusBlockName()],
JetVertexFraction_FromUD=True,
JetVertexFraction_FillFullJVF=True,
allowMissing=True))
alg += JetD3PDObject(**_args(3,
'AK6TopoEMJet',
kw,
sgkey='AntiKt6TopoEMJets',
prefix='jet_AntiKt6TopoEM_',
include=JetTagD3PDFlags.StdInfoInclude() +
[JetTagD3PDKeys.MultiSVInfoPlusBlockName()],
JetVertexFraction_FromUD=True,
JetVertexFraction_FillFullJVF=True,
allowMissing=True))
alg += JetD3PDObject(**_args(3,
'AK4LCTopoJet',
kw,
sgkey='AntiKt4LCTopoJets',
prefix='jet_AntiKt4LCTopo_',
JetVertexFraction_FromUD=True,
JetVertexFraction_FillFullJVF=True,
allowMissing=True))
alg += JetD3PDObject(**_args(3,
'AK6LCTopoJet',
kw,
sgkey='AntiKt6LCTopoJets',
prefix='jet_AntiKt6LCTopo_',
JetVertexFraction_FromUD=True,
JetVertexFraction_FillFullJVF=True,
allowMissing=True))
### add the MSV block
MSVJetCollections = ['AntiKt4TopoEMJets', 'AntiKt6TopoEMJets']
### link multisv to tracks
if not kw.has_key('msvvtxinfo_JetTag_JetMultiSVVtxAssoc_target'):
kw['msvvtxinfo_JetTag_JetMultiSVVtxAssoc_target'] = "trk"
from JetTagD3PDMaker.JetTagMSVVtxInJetD3PDObject import getJetTagMSVVtxInfoInJetD3PDObject
alg += getJetTagMSVVtxInfoInJetD3PDObject(
**_args(1, "msvvtxinfo", kw, jetCollections=MSVJetCollections))
from TopInputsD3PDMaker.HforD3PDObject import HforD3PDObject
alg += HforD3PDObject(**_args(0, 'HforInfo', kw))
# EventShape variables
alg += EventShapeD3PDObject(**_args(0, 'rho', kw))
# MET blocks
# a whole mess to remove x,y components separately for all flavours
alg += MissingETD3PDObject(**_args(
10,
'MissingET',
kw,
exclude=[
'MET_Base', 'MET_Base0', 'MET_Truth_Int', 'MET_RefFinal_Comps',
'MET_Calib_Comps', 'MET_CellOut_Comps', 'MET_CorrTopo_Comps',
'MET_Cryo_Comps', 'MET_CryoCone_Comps', 'MET_Final_Comps',
'MET_LocHadTopo_Comps', 'MET_LocHadTopoObj_Comps',
'MET_Muid_Comps', 'MET_Muid_Spectro_Comps', 'MET_Muid_Track_Comps',
'MET_MuonBoy_Comps', 'MET_MuonBoy_Spectro_Comps',
'MET_MuonBoy_Track_Comps', 'MET_MuonMuid_Comps', 'MET_Muon_Comps',
'MET_Muon_Isol_Muid_Comps', 'MET_Muon_Isol_Staco_Comps',
'MET_Muon_NonIsol_Muid_Comps', 'MET_Muon_NonIsol_Staco_Comps',
'MET_Muon_Total_Muid_Comps', 'MET_Muon_Total_Staco_Comps',
'MET_RefEle_Comps', 'MET_RefEle_em_Comps', 'MET_RefGamma_Comps',
'MET_RefGamma_em_Comps', 'MET_RefJet_Comps', 'MET_RefJet_em_Comps',
'MET_RefMuon_Comps', 'MET_RefMuon_Muid_Comps',
'MET_RefMuon_Staco_Comps', 'MET_RefMuon_Track_Muid_Comps',
'MET_RefMuon_Track_Staco_Comps', 'MET_RefMuon_Track_em_Comps',
'MET_RefMuon_Track_Comps', 'MET_RefMuon_em_Comps',
'MET_RefTau_Comps', 'MET_RefTau_em_Comps', 'MET_SoftJets_Comps',
'MET_SoftJets_em_Comps', 'MET_Topo_Comps', 'MET_TopoObj_Comps',
'MET_Track_Comps', 'MET_Comps', 'MET_Track_Weights',
'MET_Cluster_Weights'
'MET_RefFinal_STVF', 'MET_RefJet_JVF', 'MET_RefJet_JVFCut',
'MET_CellOut_Eflow_STVF', 'MET_CellOut_Eflow_JetArea'
],
allowMissing=True))
# ... DR = 0.15
alg += MissingETD3PDObject(0,
sgkey="RoughRecoil_15",
prefix="hr_roughRecoil_15",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="ueCorrection_15",
prefix="hr_ueCorrection_15",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="RefinedRecoil_15",
prefix="hr_corrRecoil_15",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="MET_HR_15",
prefix="hr_MET_15",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="RoughRecoil_Eflow_15",
prefix="hr_roughRecoil_Eflow_15",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="ueCorrection_Eflow_15",
prefix="hr_ueCorrection_Eflow_15",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="RefinedRecoil_Eflow_15",
prefix="hr_corrRecoil_Eflow_15",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="MET_HR_Eflow_15",
prefix="hr_MET_Eflow_15",
exclude=['MET_Regions', 'MET_Comps'])
# ... DR = 0.20
alg += MissingETD3PDObject(0,
sgkey="RoughRecoil_20",
prefix="hr_roughRecoil_20",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="ueCorrection_20",
prefix="hr_ueCorrection_20",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="RefinedRecoil_20",
prefix="hr_corrRecoil_20",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="MET_HR_20",
prefix="hr_MET_20",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="RoughRecoil_track_20",
prefix="hr_roughRecoil_track_20",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="ueCorrection_track_20",
prefix="hr_ueCorrection_track_20",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="RefinedRecoil_track_20",
prefix="hr_corrRecoil_track_20",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="MET_HR_track_20",
prefix="hr_MET_track_20",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="RoughRecoil_clusNoTrack_20",
prefix="hr_roughRecoil_clusNoTrack_20",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="ueCorrection_clusNoTrack_20",
prefix="hr_ueCorrection_clusNoTrack_20",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="RefinedRecoil_clusNoTrack_20",
prefix="hr_corrRecoil_clusNoTrack_20",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="MET_HR_clusNoTrack_20",
prefix="hr_MET_clusNoTrack_20",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="RoughRecoil_Eflow_20",
prefix="hr_roughRecoil_Eflow_20",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="ueCorrection_Eflow_20",
prefix="hr_ueCorrection_Eflow_20",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="RefinedRecoil_Eflow_20",
prefix="hr_corrRecoil_Eflow_20",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="MET_HR_Eflow_20",
prefix="hr_MET_Eflow_20",
exclude=['MET_Regions', 'MET_Comps'])
# ... DR = 0.25
alg += MissingETD3PDObject(0,
sgkey="RoughRecoil_25",
prefix="hr_roughRecoil_25",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="ueCorrection_25",
prefix="hr_ueCorrection_25",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="RefinedRecoil_25",
prefix="hr_corrRecoil_25",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="MET_HR_25",
prefix="hr_MET_25",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="RoughRecoil_Eflow_25",
prefix="hr_roughRecoil_Eflow_25",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="ueCorrection_Eflow_25",
prefix="hr_ueCorrection_Eflow_25",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="RefinedRecoil_Eflow_25",
prefix="hr_corrRecoil_Eflow_25",
exclude=['MET_Regions', 'MET_Comps'])
alg += MissingETD3PDObject(0,
sgkey="MET_HR_Eflow_25",
prefix="hr_MET_Eflow_25",
exclude=['MET_Regions', 'MET_Comps'])
# track and cluster blocks
# ... all clusters, very low LOD
alg += ClusterD3PDObject(
**_args(0, 'Clusters1', kw, 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_'))
from TrackD3PDMaker.TrackD3PDObject import TrackD3PDObject
# ... good tracks only (nSCT>3; no pt cut)
# turn on detailed track info if writing SoftQCD version of D3PD
if doSoftQCD:
from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags as softQcdFlags
softQcdFlags.doTruth = True
softQcdFlags.storeDetailedTruth = False
softQcdFlags.storeDiagonalCovarianceAsErrors = True
softQcdFlags.storeHitTruthMatching = True
softQcdFlags.storePixelHitsOnTrack = False
softQcdFlags.storePixelHolesOnTrack = False
softQcdFlags.storePixelOutliersOnTrack = False
softQcdFlags.storeSCTHitsOnTrack = False
softQcdFlags.storeSCTHolesOnTrack = False
softQcdFlags.storeSCTOutliersOnTrack = False
softQcdFlags.storeTRTHitsOnTrack = False
softQcdFlags.storeTRTHolesOnTrack = False
softQcdFlags.storeTRTOutliersOnTrack = False
softQcdFlags.storeTrackFitQuality = True
softQcdFlags.storeTrackInfo = True
softQcdFlags.storeTrackMomentum = True
softQcdFlags.storeTrackPredictionAtBLayer = True
softQcdFlags.storeTrackSummary = True
softQcdFlags.trackParametersAtBeamSpotLevelOfDetails = 0
softQcdFlags.trackParametersAtGlobalPerigeeLevelOfDetails = 2
softQcdFlags.trackParametersAtPrimaryVertexLevelOfDetails = 2
SoftQCDTrackParticleD3PDObject = TrackD3PDObject(
_label='trk',
_prefix='trk_',
_sgkey='GoodTracks',
typeName='Rec::TrackParticleContainer',
flags=softQcdFlags)
alg += SoftQCDTrackParticleD3PDObject(**_args(
3, 'Tracks1', kw, sgkey='GoodTracks', label='trk', prefix='trk_'))
else:
# ... use standard level of track info for 'GoodTracks'
alg += TrackParticleD3PDObject(**_args(
3, 'Tracks1', kw, sgkey='GoodTracks', label='trk', prefix='trk_'))
# ... high-pt tracks (nSCT>3; pt>5 GeV)
from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags as highPtFlags
highPtFlags.doTruth = True
highPtFlags.storeDiagonalCovarianceAsErrors = True
highPtFlags.storeHitTruthMatching = True
highPtFlags.storePixelHitsOnTrack = False
highPtFlags.storePixelHolesOnTrack = False
highPtFlags.storePixelOutliersOnTrack = False
highPtFlags.storeSCTHitsOnTrack = False
highPtFlags.storeSCTHolesOnTrack = False
highPtFlags.storeSCTOutliersOnTrack = False
highPtFlags.storeTRTHitsOnTrack = False
highPtFlags.storeTRTHolesOnTrack = False
highPtFlags.storeTRTOutliersOnTrack = False
highPtFlags.storeTrackFitQuality = True
highPtFlags.storeTrackMomentum = True
highPtFlags.storeTrackSummary = True
highPtFlags.storeTrackSummary.IDOutliers = True
highPtFlags.storeTrackSummary.PixelInfoPlus = True
highPtFlags.storeTrackSummary.SCTInfoPlus = True
highPtFlags.storeTrackSummary.TRTInfoPlus = True
highPtFlags.storeTrackSummary.InfoPlus = True
highPtFlags.trackParametersAtBeamSpotLevelOfDetails = 0
highPtFlags.trackParametersAtGlobalPerigeeLevelOfDetails = 2
highPtFlags.trackParametersAtPrimaryVertexLevelOfDetails = 3
HighPtTrackParticleD3PDObject = TrackD3PDObject(
_label='trkpt4',
_prefix='trkpt4_',
_sgkey='HighPtTracks',
typeName='Rec::TrackParticleContainer',
flags=highPtFlags)
alg += HighPtTrackParticleD3PDObject(**_args(3,
'Tracks2',
kw,
sgkey='HighPtTracks',
label='trkpt4',
prefix='trkpt4_'))
# Primary vertex block - May be missing in single-beam data.
alg += PrimaryVertexD3PDObject(**_args(1,
'PrimaryVertex',
kw,
allowMissing=True,
sgkey=D3PDMakerFlags.VertexSGKey(),
prefix='vxp_'))
# 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():
from TruthD3PDMaker.TruthParticleD3PDObject import TruthParticleD3PDObject
from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject
alg += TruthMuonD3PDObject(**_args(2, 'TruthMuon', kw))
alg += GenEventD3PDObject(**_args(1, 'GenEvent', kw))
alg += TruthParticleD3PDObject(**_args(1, 'TruthParticle', kw))
# TruthJets
alg += JetD3PDObject(**_args(1,
'AK4TruthJet',
kw,
sgkey='AntiKt4TruthJets',
prefix='jet_AntiKt4Truth_',
allowMissing=True))
alg += JetD3PDObject(**_args(1,
'AK6TruthJet',
kw,
sgkey='AntiKt6TruthJets',
prefix='jet_AntiKt6Truth_',
allowMissing=True))
alg += JetD3PDObject(**_args(1,
'AK4TruthJetALL',
kw,
sgkey='AntiKt4TruthJets_ALL',
prefix='jet_AntiKt4TruthALL_',
allowMissing=True))
alg += JetD3PDObject(**_args(1,
'AK6TruthJetALL',
kw,
sgkey='AntiKt6TruthJets_ALL',
prefix='jet_AntiKt6TruthALL_',
allowMissing=True))
alg += JetD3PDObject(**_args(1,
'AK4TruthJetWZ',
kw,
sgkey='AntiKt4TruthJets_WZ',
prefix='jet_AntiKt4TruthWZ_',
allowMissing=True))
alg += JetD3PDObject(**_args(1,
'AK6TruthJetWZ',
kw,
sgkey='AntiKt6TruthJets_WZ',
prefix='jet_AntiKt6TruthWZ_',
allowMissing=True))
### heavy flavor truth information
from AthenaCommon.AppMgr import ToolSvc
from TruthD3PDAnalysis.TruthD3PDAnalysisConf import D3PD__GenObjectsFilterTool
smwzhfGenVtxFilterTool = D3PD__GenObjectsFilterTool(
"SMWZHFGenVtxFilterTool")
ToolSvc += smwzhfGenVtxFilterTool
smwzhfGenVtxFilterTool.RemoveInTimePileUp = False
smwzhfGenVtxFilterTool.Remove2BCPileUp = True
smwzhfGenVtxFilterTool.Remove800nsPileUp = True
smwzhfGenVtxFilterTool.RemoveCavernBkg = True
smwzhfGenVtxFilterTool.RemoveEmptyEvents = True
smwzhfGenVtxFilterTool.RemoveDummyEvents = True
smwzhfGenVtxFilterTool.RemoveUnrequestedParticles = True
smwzhfGenVtxFilterTool.KeepBCHadrons = True
from TruthD3PDMaker.GenVertexD3PDObject import GenVertexD3PDObject
alg += GenVertexD3PDObject(**_args(0,
"hfgenvertex",
kw,
prefix='mchfvtx_',
filter=smwzhfGenVtxFilterTool))
smwzhfGenPartFilterTool = D3PD__GenObjectsFilterTool(
"SMWZHFGenPartFilterTool")
ToolSvc += smwzhfGenPartFilterTool
smwzhfGenPartFilterTool.RemoveInTimePileUp = False
smwzhfGenPartFilterTool.Remove2BCPileUp = True
smwzhfGenPartFilterTool.Remove800nsPileUp = True
smwzhfGenPartFilterTool.RemoveCavernBkg = True
smwzhfGenPartFilterTool.RemoveEmptyEvents = True
smwzhfGenPartFilterTool.RemoveDummyEvents = True
smwzhfGenPartFilterTool.RemoveUnrequestedParticles = True
smwzhfGenPartFilterTool.KeepBCQuarks = True
smwzhfGenPartFilterTool.KeepBCQuarkAncestors = True
smwzhfGenPartFilterTool.KeepBCHadrons = True
smwzhfGenPartFilterTool.KeepBCHadronDecayChain = True
smwzhfGenPartFilterTool.BCHadronsDescendantsPtCut = 200
smwzhfGenPartFilterTool.BCHadronsDescendantsBarcodeCut = 300000
smwzhfGenPartFilterTool.BCHadronsDescendantsEtaCut = 5
from TruthD3PDMaker.GenParticleD3PDObject import GenParticleD3PDObject
alg += GenParticleD3PDObject(
**_args(10,
"hfgenparticle",
kw,
prefix='mchfpart_',
filter=smwzhfGenPartFilterTool,
GenParticle_WriteMotherType=False,
GenParticle_WriteMotherBarcode=False))
### leptonic W/Z truth information
smwzlepwzGenPartFilterTool = D3PD__GenObjectsFilterTool(
"SMWZLepWZGenPartFilterTool")
ToolSvc += smwzlepwzGenPartFilterTool
smwzlepwzGenPartFilterTool.RemoveInTimePileUp = True
smwzlepwzGenPartFilterTool.Remove2BCPileUp = True
smwzlepwzGenPartFilterTool.Remove800nsPileUp = True
smwzlepwzGenPartFilterTool.RemoveCavernBkg = True
smwzlepwzGenPartFilterTool.RemoveEmptyEvents = True
smwzlepwzGenPartFilterTool.RemoveDummyEvents = True
smwzlepwzGenPartFilterTool.RemoveUnrequestedParticles = True
smwzlepwzGenPartFilterTool.KeepLeptonicWZBosons = True
smwzlepwzGenPartFilterTool.KeepLeptonicWZBosonDecayChains = True
smwzlepwzGenPartFilterTool.KeepLeptonicWZBosonsParents = True
from TruthD3PDMaker.GenParticleD3PDObject import GenParticleD3PDObject
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"))
if not rec.doTruth():
alg += BeamSpotD3PDObject(10)
# Trigger
if D3PDMakerFlags.DoTrigger():
alg += ZPrimeMMTriggerBitsD3PDObject(
**_args(10, 'ZPrimeMMTriggerBits', kw))
# Trigger Decision + metadata
alg += TrigDecisionD3PDObject(**_args(10, 'TrigDecision', kw))
addTrigConfMetadata(alg)
# Bunch group info
alg += BGCodeD3PDObject(**_args(2, 'BGCode', kw))
# Egamma and Mu
TrigEgammaD3PDObjects(alg, 1)
TrigMuonD3PDObjects(alg, 1)
# Esum
alg += EnergySumROID3PDObject(
**_args(2, 'EnergySumROI', kw, prefix="trig_L1_esum_"))
# The LVL2 information:
alg += TrigMETD3PDObject(**_args(
2, 'TrigMETL2', kw, prefix="trig_L2_met_",
sgkey="HLT_T2MissingET"))
# The EF information:
alg += TrigMETD3PDObject(**_args(2,
'TrigMETEF',
kw,
prefix="trig_EF_met_",
sgkey="HLT_TrigEFMissingET"))
# The BJet information:
TrigBJetD3PDObjects(alg, 10, False, False, True, True, True)
# Event metadata
alg.MetadataTools += [LBMetadataConfig()]
if D3PDMakerFlags.FilterCollCand():
from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg
alg.filterSeq += CollisionFilterAlg(tuplename + '_CollCandFilter')
return alg
if rec.doTruth():
from TruthD3PDAnalysis.TruthD3PDAnalysisConf import D3PD__GenObjectsFilterTool
# ... remove empty GenEvents
LightGenEvtFilterTool = D3PD__GenObjectsFilterTool("LightGenEvtFilterTool")
ToolSvc += LightGenEvtFilterTool
LightGenEvtFilterTool.RemoveDummyEvents = True
LightGenEvtFilterTool.RemoveInTimePileUp = True
LightGenEvtFilterTool.Remove2BCPileUp = True
LightGenEvtFilterTool.Remove800nsPileUp = True
LightGenEvtFilterTool.RemoveCavernBkg = True
LightGenEvtFilterTool.RemoveEmptyEvents = True
from TruthD3PDMaker.GenEventD3PDObject import GenEventD3PDObject
MuonD3PDStream += GenEventD3PDObject(level=0, filter=LightGenEvtFilterTool)
from TruthD3PDMaker.TruthParticleD3PDObject import TruthParticleD3PDObject
MuonD3PDStream += TruthParticleD3PDObject(1)
# The actual MuonD3PD object
from MuonD3PDMaker.MuonD3PDObject import MuonD3PDObject
#from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject
from MuonD3PDMaker.MuonTriggerBitsD3PDObject import MuonTriggerBitsD3PDObject
muonIncludes = [
'Kinematics', 'Charge', 'AllAuthor', 'Authors', 'TrkMatchQuality',
'Isolation', 'CaloEnergyLoss', 'AcceptMethods', 'ParametersAtPV',
'ComponentTrkParameters', 'MuonHitSummary', 'MuonSpectrometerHitSummary',
'TrkParameters', 'TrkCovDiag', 'TrkCovOffDiag', 'Quality', 'EFCBInfoIndex',
'EFMGInfoIndex', 'EFMEInfoIndex', 'PrimaryTrackDiagonalCovarianceAtPV',
'StacoTrackAssocIndex'
]
def MCPphysicsD3PD(file,
tuplename='physics',
seq=topSequence,
D3PDSvc='D3PD::RootD3PDSvc',
streamNameRoot=None,
**kw):
# define track and cluster filters
filter1 = makeTrackFilterAlg(TracksName=D3PDMakerFlags.TrackSGKey(),
OutputTracksName='GoodTracks',
ptCut=0.,
nSCTPix=4)
filter2 = makeTrackFilterAlg(TracksName=D3PDMakerFlags.TrackSGKey(),
OutputTracksName='HighPtTracks',
ptCut=5000.,
nSCTPix=4)
filter3 = makeClusterFilter(InputName=D3PDMakerFlags.ClusterSGKey(),
OutputName='HighPtClusters',
ptCut=10000.)
# FIXME (Maarten) : I need to give the container name explicitly apparently
filter4 = makeClusterFilter(InputName='EMTopoCluster430',
OutputName='HighPtEMClusters',
ptCut=10000.)
preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName())
preseq += filter1
preseq += filter2
preseq += filter3
preseq += filter4
# now configure the D3PD
alg = MSMgr.NewRootStream(StreamName=streamNameRoot,
FileName=file,
TreeName=tuplename)
alg += EventInfoD3PDObject(**_args(10, 'EventInfo', kw))
alg += LArCollisionTimeD3PDObject(**_args(10, 'LArCollisionTime', kw))
# Eta rings of energy
# FIXME brian crashing aod running
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
# alg += ElectronD3PDObject (**_args (10, 'Electron', kw,
# exclude = ['EMTrackFitDetails','EgammaJetSignedIPAndPTRelKin']))
alg += PhotonD3PDObject(**_args(10, 'Photon', kw))
# Muon blocks
alg += MuonD3PDObject(**_args(
10,
'Muons',
kw,
sgkey='Muons',
prefix='mu_',
include=[
"EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex",
"L1InfoIndex"
],
exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing=True))
alg += MuonD3PDObject(**_args(
10,
'MuidMuon',
kw,
sgkey='MuidMuonCollection',
prefix='mu_muid_',
include=[
"EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex",
"L1InfoIndex"
],
exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing=True))
alg += MuonD3PDObject(**_args(
10,
'StacoMuon',
kw,
sgkey='StacoMuonCollection',
prefix='mu_staco_',
include=[
"EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex",
"L1InfoIndex"
],
exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing=True))
alg += MuonD3PDObject(**_args(
0, 'CaloMuon', kw, sgkey='CaloMuonCollection', prefix='mu_calo_'))
# Tau block
# alg += TauD3PDObject (**_args ( 1, 'Tau', kw))
# Jet blocks
alg += JetD3PDObject(
**_args(3,
'AK4TopoEMJet',
kw,
sgkey='AntiKt4TopoEMJets',
prefix='jet_akt4topoem_',
include=['BTag', 'TrueFlavorComponents', 'BTagComponents'],
allowMissing=True))
alg += JetD3PDObject(
**_args(3,
'AK6TopoEMJet',
kw,
sgkey='AntiKt6TopoEMJets',
prefix='jet_akt6topoem_',
include=['BTag', 'TrueFlavorComponents', 'BTagComponents'],
allowMissing=True))
from TopInputsD3PDMaker.HforD3PDObject import HforD3PDObject
alg += HforD3PDObject(**_args(0, 'HforInfo', kw))
# MET blocks
# a whole mess to remove x,y components separately for all flavours
alg += MissingETD3PDObject(**_args(
10,
'MissingET',
kw,
exclude=[
'MET_Base', 'MET_Base0', 'MET_Truth_Int', 'MET_RefFinal_Comps',
'MET_Calib_Comps', 'MET_CellOut_Comps', 'MET_CorrTopo_Comps',
'MET_Cryo_Comps', 'MET_CryoCone_Comps', 'MET_Final_Comps',
'MET_LocHadTopo_Comps', 'MET_LocHadTopoObj_Comps',
'MET_Muid_Comps', 'MET_Muid_Spectro_Comps', 'MET_Muid_Track_Comps',
'MET_MuonBoy_Comps', 'MET_MuonBoy_Spectro_Comps',
'MET_MuonBoy_Track_Comps', 'MET_MuonMuid_Comps', 'MET_Muon_Comps',
'MET_Muon_Isol_Muid_Comps', 'MET_Muon_Isol_Staco_Comps',
'MET_Muon_NonIsol_Muid_Comps', 'MET_Muon_NonIsol_Staco_Comps',
'MET_Muon_Total_Muid_Comps', 'MET_Muon_Total_Staco_Comps',
'MET_RefEle_Comps', 'MET_RefEle_em_Comps', 'MET_RefGamma_Comps',
'MET_RefGamma_em_Comps', 'MET_RefJet_Comps', 'MET_RefJet_em_Comps',
'MET_RefMuon_Comps', 'MET_RefMuon_Muid_Comps',
'MET_RefMuon_Staco_Comps', 'MET_RefMuon_Track_Muid_Comps',
'MET_RefMuon_Track_Staco_Comps', 'MET_RefMuon_Track_em_Comps',
'MET_RefMuon_Track_Comps', 'MET_RefMuon_em_Comps',
'MET_RefTau_Comps', 'MET_RefTau_em_Comps', 'MET_SoftJets_Comps',
'MET_SoftJets_em_Comps', 'MET_Topo_Comps', 'MET_TopoObj_Comps',
'MET_Track_Comps', 'MET_Composition'
],
allowMissing=True))
# HadronicRecoil blocks
# alg += ElectronD3PDObject(0, sgkey = "HR_selectedElectrons", prefix = "hr_el_")
# alg += MuonD3PDObject( 0, sgkey = "HR_selectedMuons", prefix = "hr_mu_" )
# alg += MissingETD3PDObject(0, sgkey = "RoughRecoil", prefix = "hr_roughRecoil")
# alg += MissingETD3PDObject(0, sgkey = "ueCorrection", prefix = "hr_ueCorrection")
# track and cluster blocks
# ... all clusters, very low LOD
alg += ClusterD3PDObject(
**_args(0, 'Clusters1', kw, 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_'))
# ... good tracks only (nSCT>3; no pt cut)
alg += TrackParticleD3PDObject(**_args(
3, 'Tracks1', kw, sgkey='GoodTracks', label='trk', prefix='trk_'))
# ... high-pt tracks (nSCT>3; pt>5 GeV)
from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags as highPtFlags
highPtFlags.doTruth = True
highPtFlags.storeDiagonalCovarianceAsErrors = True
highPtFlags.storeHitTruthMatching = True
highPtFlags.storePixelHitsOnTrack = False
highPtFlags.storePixelHolesOnTrack = False
highPtFlags.storePixelOutliersOnTrack = False
highPtFlags.storeSCTHitsOnTrack = False
highPtFlags.storeSCTHolesOnTrack = False
highPtFlags.storeSCTOutliersOnTrack = False
highPtFlags.storeTRTHitsOnTrack = False
highPtFlags.storeTRTHolesOnTrack = False
highPtFlags.storeTRTOutliersOnTrack = False
highPtFlags.storeTrackFitQuality = True
highPtFlags.storeTrackMomentum = True
highPtFlags.storeTrackSummary = True
highPtFlags.trackParametersAtBeamSpotLevelOfDetails = 0
highPtFlags.trackParametersAtGlobalPerigeeLevelOfDetails = 2
highPtFlags.trackParametersAtPrimaryVertexLevelOfDetails = 3
from TrackD3PDMaker.TrackD3PDObject import TrackD3PDObject
HighPtTrackParticleD3PDObject = TrackD3PDObject(
_label='trkpt5',
_prefix='trkpt5_',
_sgkey='HighPtTracks',
typeName='Rec::TrackParticleContainer',
flags=highPtFlags)
alg += HighPtTrackParticleD3PDObject(**_args(3,
'Tracks2',
kw,
sgkey='HighPtTracks',
label='trkpt5',
prefix='trkpt5_'))
# Primary vertex block - May be missing in single-beam data.
alg += PrimaryVertexD3PDObject(**_args(1,
'PrimaryVertex',
kw,
allowMissing=True,
sgkey=D3PDMakerFlags.VertexSGKey(),
prefix='vxp_'))
# 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():
from TruthD3PDMaker.TruthParticleD3PDObject import TruthParticleD3PDObject
from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject
alg += TruthMuonD3PDObject(**_args(2, 'TruthMuon', kw))
alg += GenEventD3PDObject(**_args(1, 'GenEvent', kw))
alg += TruthParticleD3PDObject(**_args(1, 'TruthParticle', kw))
# TruthJets
alg += JetD3PDObject(**_args(1,
'AK4TruthJet',
kw,
sgkey='AntiKt4TruthJets',
prefix='jet_antikt4truth_'))
alg += JetD3PDObject(**_args(1,
'AK6TruthJet',
kw,
sgkey='AntiKt6TruthJets',
prefix='jet_antikt6truth_'))
alg += JetD3PDObject(**_args(1,
'AK4TruthJetALL',
kw,
sgkey='AntiKt4TruthJets_ALL',
prefix='jet_antikt4truthALL_'))
alg += JetD3PDObject(**_args(1,
'AK6TruthJetALL',
kw,
sgkey='AntiKt6TruthJets_ALL',
prefix='jet_antikt6truthALL_'))
alg += JetD3PDObject(**_args(1,
'AK4TruthJetWZ',
kw,
sgkey='AntiKt4TruthJets_WZ',
prefix='jet_antikt4truthWZ_'))
alg += JetD3PDObject(**_args(1,
'AK6TruthJetWZ',
kw,
sgkey='AntiKt6TruthJets_WZ',
prefix='jet_antikt6truthWZ_'))
if not rec.doTruth():
alg += BeamSpotD3PDObject(10)
# Trigger
if D3PDMakerFlags.DoTrigger():
# Trigger Decision + metadata
alg += TrigDecisionD3PDObject(**_args(10, 'TrigDecision', kw))
addTrigConfMetadata(alg)
# Bunch group info
alg += BGCodeD3PDObject(**_args(2, 'BGCode', kw))
# Egamma and Mu
TrigEgammaD3PDObjects(alg, 0)
# TrigMuonD3PDObjects( alg, 0)
# Esum
alg += EnergySumROID3PDObject(
**_args(2, 'EnergySumROI', kw, prefix="trig_L1_esum_"))
# The LVL2 information:
alg += TrigMETD3PDObject(**_args(
2, 'TrigMETL2', kw, prefix="trig_L2_met_",
sgkey="HLT_T2MissingET"))
# The EF information:
alg += TrigMETD3PDObject(**_args(2,
'TrigMETEF',
kw,
prefix="trig_EF_met_",
sgkey="HLT_TrigEFMissingET"))
# Event metadata
alg.MetadataTools += [LBMetadataConfig()]
if D3PDMakerFlags.FilterCollCand():
from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg
alg.filterSeq += CollisionFilterAlg(tuplename + '_CollCandFilter')
return alg
def HSG2physicsD3PD(name, file, tuplename='physics', **kw):
from AthenaCommon.AlgSequence import AlgSequence # needed for attila's code
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags # needed for attila's code
# define track and cluster filters
filter1 = makeTrackFilterAlg(TracksName=D3PDMakerFlags.TrackSGKey(),
OutputTracksName='GoodTracks' + name,
ptCut=0.,
nSCTPix=4)
filter2 = makeTrackFilterAlg(TracksName=D3PDMakerFlags.TrackSGKey(),
OutputTracksName='HighPtTracks' + name,
ptCut=5000.,
nSCTPix=4)
preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName())
preseq += filter1
preseq += filter2
# now configure the D3PD
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
alg = MSMgr.NewRootStream(name, file, TreeName=tuplename)
#alg = D3PDMakerCoreComps.MakerAlg(tuplename, seq,
# file = file,
# D3PDSvc = D3PDSvc,
# streamNameRoot = streamNameRoot)
alg += EventInfoD3PDObject(**_args(10, 'EventInfo', kw))
alg += LArCollisionTimeD3PDObject(**_args(10, 'LArCollisionTime', kw))
from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject
import EventCommonD3PDMaker
# Electron/Photon block
alg += ElectronD3PDObject(
**_args(10,
'Electron',
kw,
exclude=[
'L1Index', 'L2Index', 'EMTrackFitDetails',
'EgammaJetSignedIPAndPTRelKin'
]))
# Photon block
alg += PhotonD3PDObject(**_args(10, 'Photon', kw))
# Muon blocks
alg += MuonD3PDObject(**_args(
10,
'MuidMuon',
kw,
sgkey='MuidMuonCollection',
prefix='mu_muid_',
include=["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex"],
exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing=True))
alg += MuonD3PDObject(**_args(
10,
'StacoMuon',
kw,
sgkey='StacoMuonCollection',
prefix='mu_staco_',
include=["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex"],
exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing=True))
alg += MuonD3PDObject(**_args(
10,
'CaloMuon',
kw,
sgkey='CaloMuonCollection',
prefix='mu_calo_',
include=["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex"],
exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing=True))
alg += MuonD3PDObject(**_args(
10,
'Muons',
kw,
sgkey='Muons',
prefix='mu_muon_',
include=["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex"],
exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing=True))
# Quadruplet vertex block
from AthenaCommon.AlgSequence import AlgSequence
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from HSG2VertexCreation.HSG2VertexReconstruction import HSG2VertexReconstruction
HSG2VertexReconstruction("HSG2VertexReconstruction",
AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()))
from HiggsD3PDMaker.HSG2VertexReconstruction import addHSG2VertexReconstruction
addHSG2VertexReconstruction(alg,
electron_target="el_",
muid_target="mu_muid_",
staco_target="mu_staco_",
calo_target="mu_calo_",
muon_target="mu_muon_")
# Tau block
alg += TauD3PDObject(**_args(1, 'Tau', kw))
# Jet blocks
alg += JetD3PDObject(**_args(
3,
'AK4TopoEMJet',
kw,
sgkey='AntiKt4TopoEMJets' + JetTagD3PD_CollectionPostfix,
prefix='jet_akt4topoem_',
#include = ['BTag','TrueFlavorComponents','BTagComponents'],
include=[
JetTagD3PDKeys.BTagWeightsBlockName(),
JetTagD3PDKeys.JetFitterCharmTagInfoBlockName(),
JetTagD3PDKeys.JetFitterCharmInfoBaseBlockName(),
JetTagD3PDKeys.TruthInfoBlockName(),
"Constituents",
'TracksMoments',
'Samplings', # For GSC corrections
],
allowMissing=True))
# For VBF and ZH(->inv) analyses
alg += JetD3PDObject(**_args(
3,
'AK4LCTopoJet',
kw,
sgkey='AntiKt4LCTopoJets' + JetTagD3PD_CollectionPostfix,
prefix='jet_AntiKt4LCTopo_',
include=[
JetTagD3PDKeys.BTagWeightsBlockName(),
JetTagD3PDKeys.JetFitterCharmTagInfoBlockName(),
JetTagD3PDKeys.JetFitterCharmInfoBaseBlockName(),
JetTagD3PDKeys.TruthInfoBlockName(),
"Constituents",
"ConstituentScale", # For ZH(->inv) analysis
'TracksMoments',
'Samplings', # For GSC corrections
],
allowMissing=True))
# MET blocks
# a whole mess to remove x,y components separately for all flavours
alg += MissingETD3PDObject(**_args(
10,
'MissingET',
kw,
exclude=[
'MET_Base', 'MET_Base0', 'MET_Truth_Int', 'MET_RefFinal_Comps',
'MET_Calib_Comps', 'MET_CellOut_Comps', 'MET_CorrTopo_Comps',
'MET_Cryo_Comps', 'MET_CryoCone_Comps', 'MET_Final_Comps',
'MET_LocHadTopo_Comps', 'MET_LocHadTopoObj_Comps',
'MET_Muid_Comps', 'MET_Muid_Spectro_Comps', 'MET_Muid_Track_Comps',
'MET_MuonBoy_Comps', 'MET_MuonBoy_Spectro_Comps',
'MET_MuonBoy_Track_Comps', 'MET_MuonMuid_Comps', 'MET_Muon_Comps',
'MET_Muon_Isol_Muid_Comps', 'MET_Muon_Isol_Staco_Comps',
'MET_Muon_NonIsol_Muid_Comps', 'MET_Muon_NonIsol_Staco_Comps',
'MET_Muon_Total_Muid_Comps', 'MET_Muon_Total_Staco_Comps',
'MET_RefEle_Comps', 'MET_RefEle_em_Comps', 'MET_RefGamma_Comps',
'MET_RefGamma_em_Comps', 'MET_RefJet_Comps', 'MET_RefJet_em_Comps',
'MET_RefMuon_Comps', 'MET_RefMuon_Muid_Comps',
'MET_RefMuon_Staco_Comps', 'MET_RefMuon_Track_Muid_Comps',
'MET_RefMuon_Track_Staco_Comps', 'MET_RefMuon_Track_em_Comps',
'MET_RefMuon_Track_Comps', 'MET_RefMuon_em_Comps',
'MET_RefTau_Comps', 'MET_RefTau_em_Comps', 'MET_SoftJets_Comps',
'MET_SoftJets_em_Comps', 'MET_Topo_Comps', 'MET_TopoObj_Comps',
'MET_Track_Comps'
],
allowMissing=True))
# Pileup-subtracted MET RefFinal for ZH(->inv) analysis
alg += MissingETCompositionD3PDObject(level=4,
sgkey='MET_RefComposition_STVF',
suffix='STVF_',
allowMissing=True,
jetSGKey='AntiKt4LCTopoJets',
jetPrefix='jet_AntiKt4LCTopo_MET_')
# ... good tracks only (nSCT>3; no pt cut)
alg += TrackParticleD3PDObject(**_args(3,
'Tracks1',
kw,
sgkey='GoodTracks' + name,
label='trk',
prefix='trk_'))
# ... high-pt tracks (nSCT>3; pt>5 GeV)
from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags as highPtFlags
highPtFlags.doTruth = True
highPtFlags.storeDiagonalCovarianceAsErrors = True
highPtFlags.storeHitTruthMatching = True
highPtFlags.storePixelHitsOnTrack = False
highPtFlags.storePixelHolesOnTrack = False
highPtFlags.storePixelOutliersOnTrack = False
highPtFlags.storeSCTHitsOnTrack = False
highPtFlags.storeSCTHolesOnTrack = False
highPtFlags.storeSCTOutliersOnTrack = False
highPtFlags.storeTRTHitsOnTrack = False
highPtFlags.storeTRTHolesOnTrack = False
highPtFlags.storeTRTOutliersOnTrack = False
highPtFlags.storeTrackFitQuality = True
highPtFlags.storeTrackMomentum = True
highPtFlags.storeTrackSummary = True
highPtFlags.trackParametersAtBeamSpotLevelOfDetails = 0
highPtFlags.trackParametersAtGlobalPerigeeLevelOfDetails = 2
highPtFlags.trackParametersAtPrimaryVertexLevelOfDetails = 3
alg += TrackParticleD3PDObject(**_args(3,
'Tracks2',
kw,
sgkey='HighPtTracks' + name,
label='trkpt5',
prefix='trkpt5_'))
# Primary vertex block - May be missing in single-beam data.
alg += PrimaryVertexD3PDObject(**_args(1,
'PrimaryVertex',
kw,
allowMissing=True,
sgkey=D3PDMakerFlags.VertexSGKey(),
prefix='vxp_'))
# Truth
if rec.doTruth():
from TruthD3PDMaker.GenEventD3PDObject import GenEventD3PDObject
from TruthD3PDMaker.TruthParticleD3PDObject import TruthParticleD3PDObject
from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject
alg += TruthMuonD3PDObject(**_args(2, 'TruthMuon', kw))
alg += GenEventD3PDObject(**_args(1, 'GenEvent', kw))
alg += TruthParticleD3PDObject(**_args(1, 'TruthParticle', kw))
# TruthJets
alg += JetD3PDObject(**_args(1,
'AK4TruthJet',
kw,
sgkey='AntiKt4TruthJets',
prefix='jet_antikt4truth_',
allowMissing=True))
# add Heavy flavour overlap
from TopInputsD3PDMaker.HforD3PDObject import HforD3PDObject
alg += HforD3PDObject(**_args(0, 'HforD3PD', kw))
# add mcVx information
from TrackD3PDMaker.TruthVertexD3PDObject import TruthVertexD3PDObject
alg += TruthVertexD3PDObject(**_args(0, 'TruthVertex', kw))
if not rec.doTruth():
alg += BeamSpotD3PDObject(10)
if D3PDMakerFlags.DoTrigger():
# Trigger Decision + metadata
alg += TrigDecisionD3PDObject(**_args(10, 'TrigDecision', kw))
addTrigConfMetadata(alg)
from TrigMissingETD3PDMaker.TrigMETD3PD import TrigMETD3PDObjects
TrigMETD3PDObjects(alg)
from TrigEgammaD3PDMaker.TrigEgammaD3PD import TrigEgammaD3PDObjects
TrigMuonD3PDObjects(alg, 1)
TrigEgammaD3PDObjects(alg, level=10)
# Event metadata
alg.MetadataTools += [LBMetadataConfig()]
from EventCommonD3PDMaker.CutFlowMetadataConfig import CutFlowMetadataConfig
alg.MetadataTools += [CutFlowMetadataConfig(alg)]
# Bunch train information
from TriggerD3PDMaker.BunchStructureMetadata import addBunchStructureMetadata
addBunchStructureMetadata(alg)
## Silence the trigger navigation warnings about missing containers:
from AthenaCommon.AppMgr import ToolSvc
if not hasattr(ToolSvc, "TrigDecisionTool"):
from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool
ToolSvc += Trig__TrigDecisionTool("TrigDecisionTool")
pass
ToolSvc.TrigDecisionTool.Navigation.OutputLevel = 5
# EventShape variables
# https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/D3PDVariablesForPileup#EventShape_variables
from QcdD3PDMaker.QcdEventShapeD3PDObject import EventShapeD3PDObject
alg += EventShapeD3PDObject(**_args(0, 'rho', kw))
return alg
