def SMWZLightD3PD (alg = None,
file = 'smlight.root',
tuplename = 'physics',
streamname = 'd3pdstream',
stdElectronContainer = 'None',
gsfElectronContainer = 'None',
stacoMuonContainer = 'None',
muidMuonContainer = 'None',
photonContainer = 'None',
jetContainer = 'None',
clusterContainer = 'None',
tauContainer = 'None',
trackContainer = 'None',
**kw):
preseq = AlgSequence (D3PDMakerFlags.PreD3PDAlgSeqName())
# perform recoil calculation
import HadronicRecoil.Configurables as hrc
preseq = hrc.add_hadronic_recoil_filters(preseq)
# 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
if stdElectronContainer != 'None':
alg += ElectronD3PDObject (**_args (10, 'Electron', kw,
sgkey = stdElectronContainer,
prefix = 'el_',
exclude = ['EMTrackFit','EMTrackFitDetailsBrem',
'EMTrackFitDetailsRefit',
'EMTrackFitDetailsRefitCov'],
allowMissing = True ))
if (gsfElectronContainer != 'None') and testSGKey ('ElectronContainer', gsfElectronContainer):
alg += GSFElectronD3PDObject (**_args (1, 'GSFElectron', kw,
sgkey = gsfElectronContainer,
prefix = 'el_gsf_',
exclude = ['EMTrackFit','EMTrackFitDetailsBrem',
'EMTrackFitDetailsRefit',
'EMTrackFitDetailsRefitCov'],
allowMissing = True ))
D3PDMakerFlags.DoPAU = False
if photonContainer != 'None':
alg += PhotonD3PDObject (**_args (10, 'Photon', kw,
sgkey = photonContainer,
prefix = 'ph_',
exclude = ['OQRecalc'],
allowMissing = True ))
# 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)
if stacoMuonContainer != 'None':
alg += MuonD3PDObject (**_args (10, 'StacoMuon', kw,
sgkey=stacoMuonContainer,
prefix='mu_staco_',
include = ['EFCBInfoIndex', 'EFMGInfoIndex', 'EFMEInfoIndex',
'MuonScatteringAngleSignificance'],
exclude = ['EFCBInfo', 'EFMGInfo', 'EFMEInfo',
'L2CBInfo', 'L1Info',
'MuonTimingFillerTool'],
allowMissing = True ))
if muidMuonContainer != 'None':
alg += MuonD3PDObject (**_args (10, 'MuidMuon', kw,
sgkey=muidMuonContainer,
prefix='mu_muid_',
include = ['EFCBInfoIndex', 'EFMGInfoIndex', 'EFMEInfoIndex',
'MuonScatteringAngleSignificance'],
exclude = ['EFCBInfo', 'EFMGInfo', 'EFMEInfo',
'L2CBInfo', 'L1Info',
'MuonTimingFillerTool'],
allowMissing = True ))
# Jet block
from JetTagD3PDMaker.JetTagD3PDMakerFlags import JetTagD3PDFlags
from JetTagD3PDMaker.JetTagD3PDMakerKeys import JetTagD3PDKeys
if jetContainer != 'None':
alg += JetD3PDObject (**_args ( 3, 'AK4TopoEMJet', kw,
sgkey=jetContainer,
allowMissing=True,
prefix='jet_AntiKt4TopoEM_',
JetVertexFraction_FromUD=True,
JetVertexFraction_FillFullJVF=True,
include = [ JetTagD3PDKeys.BTagWeightsBlockName(),
JetTagD3PDKeys.TruthInfoBlockName() ] ))
# Tau block
if tauContainer != 'None':
alg += TauD3PDObject (**_args ( 0, 'Tau', kw,
allowMissing=True,
sgkey=tauContainer ))
# HF overlap removal (ALPGEN)
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',
'MET_RefFinal_Comps','MET_RefFinal_Regions',
'MET_LocHadTopo_Comps','MET_LocHadTopo_Regions',
'MET_CellOut_Comps','MET_CellOut_Regions',
'MET_Calib',
'MET_CorrTopo',
'MET_Cryo',
'MET_CryoCone',
'MET_Final',
'MET_LocHadTopoObj',
'MET_Muid',
'MET_Muid_Spectro',
'MET_Muid_Track',
'MET_MuonBoy',
'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_Comps',
'MET_Track_Weights','MET_Cluster_Weights',
'MET_Regions','MET_Composition'],
allowMissing=True ))
# HadronicRecoil blocks
alg += ElectronD3PDObject(0, sgkey = 'HR_selectedElectrons', prefix = 'hr_el_',allowMissing=True )
alg += MuonD3PDObject( 0, sgkey = 'HR_selectedMuons', prefix = 'hr_mu_', allowMissing=True )
# ... DR = 0.15
alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_15', prefix = 'hr_roughRecoil_15',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_15', prefix = 'hr_ueCorrection_15',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_15', prefix = 'hr_corrRecoil_15',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_15', prefix = 'hr_MET_15',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_Eflow_15', prefix = 'hr_roughRecoil_Eflow_15',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_Eflow_15', prefix = 'hr_ueCorrection_Eflow_15',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_Eflow_15', prefix = 'hr_corrRecoil_Eflow_15',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_Eflow_15', prefix = 'hr_MET_Eflow_15',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_track_15", prefix = "hr_roughRecoil_track_15",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_track_15", prefix = "hr_ueCorrection_track_15",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_track_15", prefix = "hr_corrRecoil_track_15",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "MET_HR_track_15", prefix = "hr_MET_track_15",
exclude=['MET_Regions','MET_Comps'] )
# ... DR = 0.20
alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_20', prefix = 'hr_roughRecoil_20',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_20', prefix = 'hr_ueCorrection_20',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_20', prefix = 'hr_corrRecoil_20',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_20', prefix = 'hr_MET_20',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_track_20', prefix = 'hr_roughRecoil_track_20',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_track_20', prefix = 'hr_ueCorrection_track_20',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_track_20', prefix = 'hr_corrRecoil_track_20',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_track_20', prefix = 'hr_MET_track_20',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_clusNoTrack_20', prefix = 'hr_roughRecoil_clusNoTrack_20',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_clusNoTrack_20', prefix = 'hr_ueCorrection_clusNoTrack_20',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_clusNoTrack_20', prefix = 'hr_corrRecoil_clusNoTrack_20',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_clusNoTrack_20', prefix = 'hr_MET_clusNoTrack_20',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_Eflow_20', prefix = 'hr_roughRecoil_Eflow_20',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_Eflow_20', prefix = 'hr_ueCorrection_Eflow_20',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_Eflow_20', prefix = 'hr_corrRecoil_Eflow_20',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_Eflow_20', prefix = 'hr_MET_Eflow_20',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
# ... DR = 0.25
alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_25', prefix = 'hr_roughRecoil_25',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_25', prefix = 'hr_ueCorrection_25',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_25', prefix = 'hr_corrRecoil_25',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_25', prefix = 'hr_MET_25',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_Eflow_25', prefix = 'hr_roughRecoil_Eflow_25',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_Eflow_25', prefix = 'hr_ueCorrection_Eflow_25',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_Eflow_25', prefix = 'hr_corrRecoil_Eflow_25',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_Eflow_25', prefix = 'hr_MET_Eflow_25',
exclude=['MET_Regions','MET_Comps'],
allowMissing=True )
alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_track_25", prefix = "hr_roughRecoil_track_25",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_track_25", prefix = "hr_ueCorrection_track_25",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_track_25", prefix = "hr_corrRecoil_track_25",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "MET_HR_track_25", prefix = "hr_MET_track_25",
exclude=['MET_Regions','MET_Comps'] )
# HR using truth leptons
if rec.doTruth():
## ... DR = 0.15
alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_15",
prefix = "hr_roughRecoil_trLep_15",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_15",
prefix = "hr_ueCorrection_trLep_15",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_15",
prefix = "hr_corrRecoil_trLep_15",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_15",
prefix = "hr_MET_trLep_15",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_Eflow_15",
prefix = "hr_roughRecoil_trLep_Eflow_15",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_Eflow_15",
prefix = "hr_ueCorrection_trLep_Eflow_15",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_Eflow_15",
prefix = "hr_corrRecoil_trLep_Eflow_15",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_Eflow_15",
prefix = "hr_MET_trLep_Eflow_15",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_track_15",
prefix = "hr_roughRecoil_trLep_track_15",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_track_15",
prefix = "hr_ueCorrection_trLep_track_15",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_track_15",
prefix = "hr_corrRecoil_trLep_track_15",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_track_15",
prefix = "hr_MET_trLep_track_15",
exclude=['MET_Regions','MET_Comps'] )
## ... DR = 0.20
alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_20",
prefix = "hr_roughRecoil_trLep_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_20",
prefix = "hr_ueCorrection_trLep_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_20",
prefix = "hr_corrRecoil_trLep_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_20",
prefix = "hr_MET_trLep_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_Eflow_20",
prefix = "hr_roughRecoil_trLep_Eflow_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_Eflow_20",
prefix = "hr_ueCorrection_trLep_Eflow_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_Eflow_20",
prefix = "hr_corrRecoil_trLep_Eflow_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_Eflow_20",
prefix = "hr_MET_trLep_Eflow_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_track_20",
prefix = "hr_roughRecoil_trLep_track_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_track_20",
prefix = "hr_ueCorrection_trLep_track_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_track_20",
prefix = "hr_corrRecoil_trLep_track_20",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_track_20",
prefix = "hr_MET_trLep_track_20",
exclude=['MET_Regions','MET_Comps'] )
## ... DR = 0.25
alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_25",
prefix = "hr_roughRecoil_trLep_25",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_25",
prefix = "hr_ueCorrection_trLep_25",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_25",
prefix = "hr_corrRecoil_trLep_25",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_25",
prefix = "hr_MET_trLep_25",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_Eflow_25",
prefix = "hr_roughRecoil_trLep_Eflow_25",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_Eflow_25",
prefix = "hr_ueCorrection_trLep_Eflow_25",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_Eflow_25",
prefix = "hr_corrRecoil_trLep_Eflow_25",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_Eflow_25",
prefix = "hr_MET_trLep_Eflow_25",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_track_25",
prefix = "hr_roughRecoil_trLep_track_25",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_track_25",
prefix = "hr_ueCorrection_trLep_track_25",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_track_25",
prefix = "hr_corrRecoil_trLep_track_25",
exclude=['MET_Regions','MET_Comps'] )
alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_track_25",
prefix = "hr_MET_trLep_track_25",
exclude=['MET_Regions','MET_Comps'] )
# Cluster block
# ... all clusters, very low LOD
if clusterContainer != 'None':
alg += ClusterD3PDObject (**_args ( 0, 'Clusters', kw,
sgkey = clusterContainer,
exclude='SamplingBasics',
allowMissing=True ))
# Track block
# ... good tracks only (nSCT>=6; no pt cut)
if trackContainer != 'None':
alg += TrackParticleD3PDObject (**_args ( 3, 'Tracks', kw,
sgkey = trackContainer,
label = 'trk',
prefix = 'trk_',
allowMissing=True ))
# Primary vertex block - May be missing in single-beam data.
alg += PrimaryVertexD3PDObject (**_args (1, 'PrimaryVertex', kw,
sgkey = D3PDMakerFlags.VertexSGKey(),
prefix = 'vxp_',
allowMissing=True ))
# Truth
if rec.doTruth():
from TruthD3PDMaker.TruthParticleD3PDObject import TruthParticleD3PDObject
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
smlightGenEvtFilterTool = D3PD__GenObjectsFilterTool( "smlightGenEvtFilterTool" )
ToolSvc += smlightGenEvtFilterTool
smlightGenEvtFilterTool.RemoveDummyEvents = True
smlightGenEvtFilterTool.RemoveInTimePileUp = True
smlightGenEvtFilterTool.Remove2BCPileUp = True
smlightGenEvtFilterTool.Remove800nsPileUp = True
smlightGenEvtFilterTool.RemoveCavernBkg = True
smlightGenEvtFilterTool.RemoveEmptyEvents = True
from TruthD3PDMaker.GenEventD3PDObject import GenEventD3PDObject
alg += GenEventD3PDObject (**_args ( 0, 'GenEvent', kw, filter = smlightGenEvtFilterTool ))
# ... leptonic W/Z truth information
smlightLepWZFilterTool = D3PD__GenObjectsFilterTool( "smlightLepWZFilterTool" )
ToolSvc += smlightLepWZFilterTool
smlightLepWZFilterTool.RemoveInTimePileUp = True
smlightLepWZFilterTool.Remove2BCPileUp = True
smlightLepWZFilterTool.Remove800nsPileUp = True
smlightLepWZFilterTool.RemoveCavernBkg = True
smlightLepWZFilterTool.RemoveEmptyEvents = True
smlightLepWZFilterTool.RemoveDummyEvents = True
smlightLepWZFilterTool.RemoveUnrequestedParticles=True
smlightLepWZFilterTool.KeepLeptonicWZBosons=True
smlightLepWZFilterTool.KeepLeptonicWZBosonDecayChains=True
smlightLepWZFilterTool.KeepLeptonicWZBosonsParents=True
from TruthD3PDMaker.GenParticleD3PDObject import GenParticleD3PDObject
alg += GenParticleD3PDObject( **_args(10, "lepwzgenparticle", kw, prefix='mclepwzpart_',
filter = smlightLepWZFilterTool,
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():
# RedefineTriggerBits(alg, 'EF*')
# alg += SMWZLightTriggerBitsD3PDObject (**_args (10, 'SMWZLightTriggerBits', kw))
# metadata
addTrigConfMetadata(alg)
# Bunch group info
alg += BGCodeD3PDObject (**_args (2, 'BGCode', kw))
# Egamma EF information
alg += EFElectronD3PDObject(0, name='trig_EF_el_',
sgkey='HLT_egamma_Electrons,HLT_egamma',
prefix='trig_EF_el_',
exclude=['Author','IsEM','IsEMCuts'],
include=['Triggers'],
allowMissing = True)
# alg += EFPhotonD3PDObject(0, name='trig_EF_ph_',
# sgkey='HLT_egamma_Photons,HLT_egamma',
# prefix='trig_EF_ph_',
# exclude=['Author','Conversion0','IsEM','IsEMCuts'],
# include=['Triggers'],
# allowMissing = True)
# Muon EF information
alg += TrigMuonEFInfoD3PDObject(0,
include=['Decision'],
exclude=['TrackDetails','SpectrometerTrackBasics','ExtrapolatedTrackBasics'],
allowMissing = True)
alg += TrigMuonEFInfoD3PDObject(0,
name = "trig_EF_trigmugirl_",
sgkey = "HLT_eMuonEFInfo",
prefix = "trig_EF_trigmugirl_",
exclude=['TrackDetails','SpectrometerTrackBasics','ExtrapolatedTrackBasics'],
include=['Decision'],
allowMissing = True)
# MET EF information
# alg += TrigMETD3PDObject(**_args ( 0, '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 backgroundD3PD(alg=None,
level=10,
file='background.root',
tuplename='background',
flags=BackgroundD3PDMakerFlags,
**kw):
preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName())
if (not hasattr(topSequence, 'BeamBackgroundFiller')
and not hasattr(preseq, 'BeamBackgroundFiller')):
if cfgKeyStore.isInInput("Trk::SegmentCollection",
"ConvertedMBoySegments"):
from RecBackgroundAlgs import RecBackgroundAlgsConf
preseq += RecBackgroundAlgsConf.BeamBackgroundFiller()
if (not hasattr(topSequence, 'BeamBackgroundFillerMoore')
and not hasattr(preseq, 'BeamBackgroundFillerMoore')):
if cfgKeyStore.isInInput("Trk::SegmentCollection", "MooreSegments"):
from RecBackgroundAlgs.RecBackgroundAlgsConf import BeamBackgroundFiller
BeamBackgroundFillerMoore = BeamBackgroundFiller(
'BeamBackgroundFillerMoore',
muonSegmentContainerKey='MooreSegments',
BeamBackgroundKey='BeamBackgroundDataMoore')
preseq += BeamBackgroundFillerMoore
# The core algorithm
if not alg:
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
alg = MSMgr.NewRootStream(tuplename, file)
#Event level info
alg += EventInfoD3PDObject(**_args(1, 'EventInfo', kw))
if globalflags.DataSource == "data":
alg += LBLengthD3PDObject(**_args(0, 'LBLength', kw))
if rec.doTruth():
from TruthD3PDMaker.GenEventD3PDObject import GenEventD3PDObject
alg += GenEventD3PDObject(**_args(0, 'GenEvent', kw))
if rec.doTrigger():
alg += TrigDecisionD3PDObject(**_args(2, 'TrigDecision', kw))
addTrigConfMetadata(alg)
bcToolType = ""
if globalflags.DataSource == "data":
bcToolType = "LHC"
addBunchStructureMetadata(alg, bcToolType)
alg += BGCodeD3PDObject(**_args(2, 'BGCode', kw))
if flags.AddTriggerBits():
alg += getBkgdTriggerBitsD3PDObject([])
alg += BackgroundWordD3PDObject(**_args(0, 'BkgWord', kw))
if flags.doLUCID():
alg += Lucid_RawDataD3PDObject(**_args(0, 'Lucid', kw))
alg += RawInfoSummaryForTagD3PDObject(**_args(0, 'SumForTag', kw))
alg += MBTSD3PDObject(**_args(0, 'MBTS', kw))
alg += LArCollisionTimeD3PDObject(**_args(0, 'LArTimeDiff', kw))
if flags.doMet():
alg += MissingETD3PDObject(**_args(1,
'MET_RefFinal',
kw,
sgkey='MET_RefFinal',
prefix='MET_RefFinal',
allowMissing=True))
alg += MuonD3PDObject(
**_args(0,
'Muon',
kw,
sgkey='MuonCollection',
prefix='mu_',
include=[
"Isolation", "Quality", "MuonTimingFillerTool",
"MuonTileTimeTool", "ChamberT0"
],
allowMissing=True))
alg += MuonD3PDObject(
**_args(0,
'MuidMuon',
kw,
sgkey='MuidMuonCollection',
prefix='mu_muid_',
include=[
"Isolation", "Quality", "MuonTimingFillerTool",
"MuonTileTimeTool", "ChamberT0"
],
allowMissing=True))
alg += MuonD3PDObject(
**_args(0,
'StacoMuon',
kw,
sgkey='StacoMuonCollection',
prefix='mu_staco_',
include=[
"Isolation", "Quality", "MuonTimingFillerTool",
"MuonTileTimeTool", "ChamberT0"
],
allowMissing=True))
if flags.doCaloMuon():
alg += MuonD3PDObject(
**_args(0,
'CaloMuon',
kw,
sgkey='CaloMuonCollection',
prefix='mu_calo_',
include=[
"Isolation", "Quality", "MuonTimingFillerTool",
"MuonTileTimeTool", "ChamberT0"
],
allowMissing=True))
alg += MuonSegmentD3PDObject(**_args(
1,
'MuonSeg',
kw,
sgkey='MuonSegments',
prefix='museg_',
# MooreSegmentT0 takes the default time
# MuonboySegmentT0 recalculates time (see MuonSegmentD3PDObject.py and MuonSegmentT0FillerTool.cxx)
include=['MooreSegmentT0'],
exclude=['MuonboySegmentT0'],
allowMissing=True))
alg += MuonSegmentD3PDObject(**_args(1,
'MooreSeg',
kw,
sgkey='MooreSegments',
prefix='mooreseg_',
include=['MooreSegmentT0'],
exclude=['MuonboySegmentT0'],
allowMissing=True))
alg += MuonSegmentD3PDObject(**_args(1,
'MboySeg',
kw,
sgkey='ConvertedMBoySegments',
prefix='mboyseg_',
include=['MuonboySegmentT0'],
exclude=['MooreSegmentT0'],
allowMissing=True))
if flags.doMuGirlSeg():
alg += MuonSegmentD3PDObject(**_args(1,
'MuGirlSeg',
kw,
sgkey='MuGirlSegments',
prefix='mgseg_',
include=['MooreSegmentT0'],
exclude=['MuonboySegmentT0'],
allowMissing=True))
if flags.doTrk():
alg += xAODTrackParticleD3PDObject(
**_args(0, 'TrackParticle', kw, prefix='trk_'))
if flags.doMuonHits():
alg += MdtPrepDataD3PDObject(0)
alg += RpcPrepDataD3PDObject(0)
alg += CscPrepDataD3PDObject(0)
alg += TgcPrepDataD3PDObject(0)
alg += TgcPrepDataD3PDObject(**_args(0,
'TGC_MeasurementsPriorBC',
kw,
sgkey='TGC_MeasurementsPriorBC',
prefix='tgcPriorBC_',
label='TgcPrepDataPriorBC'))
alg += TgcPrepDataD3PDObject(**_args(0,
'TGC_MeasurementsNextBC',
kw,
sgkey='TGC_MeasurementsNextBC',
prefix='tgcNextBC_',
label='TgcPrepDataNextBC'))
if flags.doCaloJet():
#alg += JetD3PDObject (**_args(4,'AntiKt4TopoEMJets', kw, sgkey='AntiKt4TopoEMJets', prefix='AntiKt4TopoEM_', include='BeamBackground' ))
if cfgKeyStore.isInInput("Trk::SegmentCollection",
"ConvertedMBoySegments"):
alg += JetD3PDObject(
**_args(4,
'AntiKt4TopoEMJets',
kw,
sgkey='AntiKt4TopoEMJets',
prefix='AntiKt4TopoEM_',
include=['BeamBackground'],
exclude=[
'JetVertexFraction', 'JVtx', 'ActiveArea',
'TruthMF', 'TracksMoments'
],
BeamBackground_BeamBackgroundKey='BeamBackgroundData'))
else:
alg += JetD3PDObject(
**_args(4,
'AntiKt4TopoEMJets',
kw,
sgkey='AntiKt4TopoEMJets',
prefix='AntiKt4TopoEM_',
exclude=[
'JetVertexFraction', 'JVtx', 'ActiveArea',
'TruthMF', 'TracksMoments'
]))
else:
alg += JetD3PDObject(
**_args(4,
'AntiKt4TrackJets',
kw,
sgkey='AntiKt4TrackJets',
prefix='AntiKt4Track_',
exclude=[
'JetVertexFraction', 'JVtx', 'ActiveArea', 'TruthMF',
'TracksMoments'
]))
alg += PrimaryxAODVertexD3PDObject(0)
if flags.doBeamBkgd():
#alg += BeamBackgroundD3PDObject(1)
if cfgKeyStore.isInInput("Trk::SegmentCollection",
"ConvertedMBoySegments"):
alg += BeamBackgroundD3PDObject(
**_args(1,
'BeamBackgroundData',
kw,
sgkey='BeamBackgroundData',
prefix='bb_',
bbJetIndex_Target='AntiKt4TopoEM_',
bbClusterIndex_Target='cl_'))
if cfgKeyStore.isInInput("Trk::SegmentCollection", "MooreSegments"):
alg += BeamBackgroundD3PDObject(
**_args(1,
'BeamBackgroundData',
kw,
sgkey='BeamBackgroundDataMoore',
prefix='bbMoore_',
bbJetIndex_Target='AntiKt4TopoEM_',
bbClusterIndex_Target='cl_'))
if flags.doBCM():
alg += BcmRdoFlatD3PDObject(**_args(0, 'BCMRdo', kw))
if flags.doZDC():
if globalflags.DataSource == "data": alg += ZdcD3PDObject(10)
if flags.doPixelClus():
from InDetD3PDMaker.PixelClusterD3PDObject import PixelClusterD3PDObject
alg += PixelClusterD3PDObject(0)
if flags.doCaloClus():
from CaloSysD3PDMaker.ClusterD3PDObject import ClusterD3PDObject
alg += ClusterD3PDObject(1)
return alg
def HSG5D3PD (alg = None,
file = 'hsg5.root',
tuplename = 'physics',
streamname = 'd3pdstream',
flags=HSG5Flags,
**kw):
if flags.doTaus():
# tau
from TauD3PDMaker.TauD3PDObject import TauD3PDObject
# define associations
if flags.doPhotons() and 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 flags.doGoodTracks() and not hasattr( preseq, "GoodTracks" ):
filter1 = makeTrackFilterAlg(TracksName = D3PDMakerFlags.TrackSGKey(),
OutputTracksName='GoodTracks',
ptCut=0.,nSCTPix=4)
preseq += filter1
if flags.doHighPtTracks() and not hasattr( preseq, "HighPtTracks" ):
filter2 = makeTrackFilterAlg(TracksName = D3PDMakerFlags.TrackSGKey(),
OutputTracksName='HighPtTracks',
ptCut=5000.,nSCTPix=4)
preseq += filter2
if flags.doHighPtClusters() and not hasattr( preseq, "HighPtClusters" ):
filter3 = makeClusterFilter(InputName = D3PDMakerFlags.ClusterSGKey(),
OutputName = 'HighPtClusters',
ptCut=10000.)
preseq += filter3
if flags.doHighPtEMClusters() and not hasattr( preseq, "HighPtEMClusters" ):
filter4 = makeClusterFilter(InputName = D3PDMakerFlags.EMTopoClusterSGKey(),
OutputName = 'HighPtEMClusters',
ptCut=10000.)
preseq += filter4
# perform recoil calculation
if flags.doHadronicRecoil():
from HadronicRecoil.HadronicRecoilConf import HadronicRecoil__ElectronSelector
from HadronicRecoil.HadronicRecoilConf import HadronicRecoil__MuonSelector
from HadronicRecoil.HadronicRecoilConf import HadronicRecoil__EflowSelector
from HadronicRecoil.HadronicRecoilConf import HadronicRecoil__RecoilCalculation
from HadronicRecoil.HadronicRecoilConf import HadronicRecoil__EflowRecoil
if not hasattr( preseq, "HadronicRecoil::ElectronSelector" ):
preseq += HadronicRecoil__ElectronSelector()
if not hasattr( preseq, "HadronicRecoil::MuonSelector" ):
preseq += HadronicRecoil__MuonSelector()
if not hasattr( preseq, "HadronicRecoil::EflowSelector" ):
preseq += HadronicRecoil__EflowSelector()
if not hasattr( preseq, "HadronicRecoil::RecoilCalculation" ):
preseq += HadronicRecoil__RecoilCalculation( ConeSizes = [0.20] )
if not hasattr( preseq, "EflowRecoil_20" ):
preseq += HadronicRecoil__EflowRecoil("EflowRecoil_20",
TrackRough = "RoughRecoil_track_20",
TrackUE = "ueCorrection_track_20",
TrackRef = "RefinedRecoil_track_20",
ClusNoTrackRough = "RoughRecoil_clusNoTrack_20",
ClusNoTrackUE = "ueCorrection_clusNoTrack_20",
ClusNoTrackRef = "RefinedRecoil_clusNoTrack_20",
RoughRecoil_out = "RoughRecoil_Eflow_20",
ueCorrection_out = "ueCorrection_Eflow_20",
RefinedRecoil_out= "RefinedRecoil_Eflow_20",
MET_out = "MET_HR_Eflow_20" )
# 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)
# 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))
if testSGKey ('ElectronContainer', D3PDMakerFlags.GSFElectronSGKey()):
alg += GSFElectronD3PDObject (**_args (10, 'GSFElectron', kw,
sgkey = D3PDMakerFlags.GSFElectronSGKey(),
prefix = 'el_gsf_'))
if flags.doPhotons():
print "adding photons"
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)
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 ))
from AthenaCommon.KeyStore import CfgItemList
if CfgItemList("KeyStore_inputFile").has_item("Analysis::MuonContainer#Muons"):
alg += MuonD3PDObject (**_args (10, 'Muons', kw,
sgkey='Muons', prefix='mu_muons_',
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_',
include = ["MuonHitSummary", "Authors", "Likelihood",
"Isolation", "CaloEnergyLoss", "Quality"] ))
# Tau block
if flags.doTaus():
alg += TauD3PDObject (**_args ( 1, 'Tau', kw))
# track and cluster blocks
# ... all clusters, very low LOD
alg += ClusterD3PDObject (**_args ( 0, 'Clusters1', kw,
exclude='SamplingBasics'))
# ... higher LOD for pt>10 GeV
if flags.doHighPtClusters():
alg += ClusterD3PDObject (**_args ( 2, 'Clusters2', kw,
sgkey = 'HighPtClusters',
prefix = 'clpt10_'))
if flags.doHighPtEMClusters():
alg += ClusterD3PDObject (**_args ( 3, 'Clusters3', kw,
sgkey = 'HighPtEMClusters',
prefix = 'emclpt10_'))
from TrackD3PDMaker.TrackD3PDObject import TrackD3PDObject
# ... good tracks only (nSCT>3; no pt cut)
# use standard level of track info for 'GoodTracks'
if flags.doGoodTracks():
# 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)
if flags.doHighPtTracks():
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='trkpt5',
_prefix='trkpt5_',
_sgkey='HighPtTracks',
typeName='Rec::TrackParticleContainer',
flags=highPtFlags)
alg += HighPtTrackParticleD3PDObject(**_args ( 3, 'Tracks2', kw,
sgkey = 'HighPtTracks',
label = 'trkpt5',
prefix = 'trkpt5_'))
# Jet blocks
from JetTagD3PDMaker.JetTagD3PDMakerFlags import JetTagD3PDFlags
# include list modified for HSG5D3PD
includelist = JetTagD3PDFlags.StdInfoInclude()
from JetTagD3PDMaker.JetTagD3PDMakerKeys import JetTagD3PDKeys
includelist += [JetTagD3PDKeys.BTagWeightsBlockName()]
#includelist += [JetTagD3PDKeys.JetFitterInfoBaseBlockName()]
#includelist += [JetTagD3PDKeys.JetFitterTagInfoBlockName()]
#includelist += [JetTagD3PDKeys.IP3DInfoBaseBlockName()]
#includelist += [JetTagD3PDKeys.IP3DIPInfoBaseBlockName()]
#includelist += [JetTagD3PDKeys.JetFitterCombInfoBaseBlockName()]
includelist += [JetTagD3PDKeys.JetTrackAssocBlockName()]
includelist += [JetTagD3PDKeys.JetTrackBlockName()]
includelist += [JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()]
includelist += [JetTagD3PDKeys.IPInfoPlusTrackBlockName()]
includelist += ['ConstituentScale']
jetkw = kw
if not jetkw.has_key ( 'AK4TopoEMJet_'+JetTagD3PDKeys.JetTrackAssocBlockName()+'_target'):
jetkw['AK4TopoEMJet_'+JetTagD3PDKeys.JetTrackAssocBlockName()+'_target']= "trk"
if not jetkw.has_key ( 'AK4TopoEMJet_'+JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()+'_target'):
jetkw['AK4TopoEMJet_'+JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()+'_target']= "trk"
alg += JetD3PDObject (**_args ( 3, 'AK4TopoEMJet', jetkw,
sgkey='AntiKt4TopoEMJets', prefix='jet_AntiKt4TopoEM_',
include = includelist,
JetVertexFraction_FromUD=True,
JetVertexFraction_FillFullJVF=True,
allowMissing = True))
alg += JetD3PDObject (**_args ( 3, 'AK6TopoEMJet', kw,
sgkey='AntiKt6TopoEMJets', prefix='jet_AntiKt6TopoEM_',
include = [JetTagD3PDFlags.StdInfoInclude(),'ConstituentScale'],
JetVertexFraction_FromUD=True,
JetVertexFraction_FillFullJVF=True,
allowMissing = True))
alg += JetD3PDObject (**_args ( 3, 'AK4LCTopoJet', kw,
sgkey='AntiKt4LCTopoJets', prefix='jet_AntiKt4LCTopo_',
exclude=['Layer'],
include=['ConstituentScale'],
JetVertexFraction_FromUD=True,
JetVertexFraction_FillFullJVF=True,
allowMissing = True))
alg += JetD3PDObject (**_args ( 3, 'AK6LCTopoJet', kw,
sgkey='AntiKt6LCTopoJets', prefix='jet_AntiKt6LCTopo_',
exclude=['Layer'],
include=['ConstituentScale'],
JetVertexFraction_FromUD=True,
JetVertexFraction_FillFullJVF=True,
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
if flags.doAllMissingET() :
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_Muons_Comps','MET_Muons_Spectro_Comps','MET_Muons_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_RefMons_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_RefMuons_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))
else :
alg += MissingETD3PDObject(0, sgkey = "MET_RefFinal", prefix = "MET_RefFinal")
# MuonBoy terms used in RefFinal
alg += MissingETD3PDObject(0, sgkey = "MET_MuonBoy", prefix = "MET_MuonBoy")
alg += MissingETD3PDObject(0, sgkey = "MET_RefMuon", prefix = "MET_RefMuon")
alg += MissingETD3PDObject(0, sgkey = "MET_CellOut_Eflow", prefix = "MET_CellOut_Eflow")
# terms needed to calculate RefFinal with Muid instead of Staco
alg += MissingETD3PDObject(0, sgkey = "MET_RefMuon_Muid", prefix = "MET_RefMuon_Muid")
alg += MissingETD3PDObject(0, sgkey = "MET_MuonMuid", prefix = "MET_MuonMuid")
alg += MissingETD3PDObject(0, sgkey = "MET_Muid", prefix = "MET_Muid")
alg += MissingETD3PDObject(0, sgkey = "MET_CellOut_Eflow_Muid", prefix = "MET_CellOut_Eflow_Muid")
# terms needed to calculate RefFinal with third chain instead of Staco
from AthenaCommon.KeyStore import CfgItemList
keystore = CfgItemList("KeyStore_inputFile")
if keystore.has_item("MissingET#MET_Muons"):
alg += MissingETD3PDObject(0, sgkey = "MET_Muons", prefix = "MET_Muons")
if keystore.has_item("MissingET#MET_RefMuons"):
alg += MissingETD3PDObject(0, sgkey = "MET_RefMuons", prefix = "MET_RefMuons")
if keystore.has_item("MissingET#MET_CellOut_Eflow_Muons"):
alg += MissingETD3PDObject(0, sgkey = "MET_CellOut_Eflow_Muons", prefix = "MET_CellOut_Eflow_Muons")
# I have no idea what these are for
alg += MissingETD3PDObject(0, sgkey = "MET_SoftJets", prefix = "MET_SoftJets")
alg += MissingETD3PDObject(0, sgkey = "MET_RefFinal_em", prefix = "MET_RefFinal_em")
alg += MissingETD3PDObject(0, sgkey = "MET_CellOut_em", prefix = "MET_CellOut_em")
alg += MissingETD3PDObject(0, sgkey = "MET_SoftJets_em", prefix = "MET_SoftJets_em")
# HadronicRecoil blocks
if flags.doHadronicRecoil():
alg += ElectronD3PDObject(0, sgkey = "HR_selectedElectrons", prefix = "hr_el_")
alg += MuonD3PDObject( 0, sgkey = "HR_selectedMuons", prefix = "hr_mu_" )
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'] )
"""
# track and cluster blocks
# ... all clusters, very low LOD
alg += ClusterD3PDObject (**_args ( 0, 'Clusters1', kw,
exclude='SamplingBasics'))
# ... higher LOD for pt>10 GeV
if flags.doHighPtClusters():
alg += ClusterD3PDObject (**_args ( 2, 'Clusters2', kw,
sgkey = 'HighPtClusters',
prefix = 'clpt10_'))
if flags.doHighPtEMClusters():
alg += ClusterD3PDObject (**_args ( 3, 'Clusters3', kw,
sgkey = 'HighPtEMClusters',
prefix = 'emclpt10_'))
from TrackD3PDMaker.TrackD3PDObject import TrackD3PDObject
# ... good tracks only (nSCT>3; no pt cut)
# use standard level of track info for 'GoodTracks'
if flags.doGoodTracks():
# 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)
if flags.doHighPtTracks():
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='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_',
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))
if not rec.doTruth():
alg += BeamSpotD3PDObject(10)
from TrigMissingETD3PDMaker.TrigMETD3PD import TrigMETD3PDObjects
TrigMETD3PDObjects(alg,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)
# 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()]
# Invoke routine to write GSCFactor and WidthFraction jet moments
#addSTRUCTCalib('AntiKt4LCTopoJets', input='Topo', mainParam=0.4)
#addSTRUCTCalib('AntiKt6LCTopoJets', input='Topo', mainParam=0.6)
#addSTRUCTCalib('AntiKt4TopoEMJets', input='Topo', mainParam=0.4)
#addSTRUCTCalib('AntiKt6TopoEMJets', input='Topo', mainParam=0.6)
if D3PDMakerFlags.FilterCollCand():
from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg
alg.filterSeq += CollisionFilterAlg (tuplename + '_CollCandFilter')
return alg
def egammaD3PD(alg=None,
trigalg=None,
level=10,
file='egamma.root',
tuplename='egamma',
**kw):
preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName())
createxAOD(preseq)
if not cfgKeyStore.isInInput('xAOD::ElectronContainer', 'AllElectrons'):
preseq += MergeElectrons()
# Core algorithm
# By default the user of this function should have created an algorithm already.
# But for backwards compatibility let the function create its own algorithm if
# needed...
if not alg:
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
alg = MSMgr.NewRootStream(tuplename, file)
alg += EventInfoD3PDObject(**_args(level, 'EventInfo', kw))
# Segregate trigger decision flags in a separate tree.
if not trigalg:
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
trigalg = MSMgr.NewRootStream(tuplename + ':' + tuplename + 'TrigDec',
FileName=file,
TreeName=tuplename + 'TrigDec')
trigalg += EventInfoD3PDObject(0)
alg.Stream.trigDecisionTree = trigalg
# Add bunch structure metadata.
from TriggerD3PDMaker.BunchStructureMetadata \
import addBunchStructureMetadata
addBunchStructureMetadata(alg)
alg += LArCollisionTimeD3PDObject(**_args(level, 'LArCollisionTime', kw))
alg += ElectronD3PDObject(**_args(
level, 'Electron', kw, EgammaJetSignedIPAndPTRel_target='jet_'))
alg += PhotonD3PDObject(**_args(level, 'Photon', kw))
# # Additional muon variables for Zg skims.
# 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)
alg += MuonD3PDObject(**_args(
10,
'Muons',
kw,
sgkey='StacoMuonCollection,Muons',
prefix='mu_',
include=[
"EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex",
"L1InfoIndex", "MuonScatteringAngleSignificance"
],
exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing=True))
alg += JetD3PDObject(
**_args(0, 'Jet', kw, include=['JetQual', 'DQMoments']))
alg += MBTSD3PDObject(**_args(level, 'MBTS', kw))
alg += MBTSTimeD3PDObject(**_args(level, 'MBTSTime', kw))
# alg += MBTSTriggerBitsD3PDObject (**_args (level, 'MBTSTriggerBits', kw))
# alg += ZDCTriggerBitsD3PDObject (**_args (level, 'ZDCTriggerBits', kw))
alg += CollisionDecisionD3PDObject(**_args(level, 'CollisionDecision', kw))
alg += MissingETD3PDObject(**_args(level,
'MissingET',
kw,
sgkey='MET_Core_AntiKt4EMTopo',
prefix='MET_RefFinal_'))
if D3PDMakerFlags.DoTrigger():
from TriggerD3PDMaker.TrigDecisionD3PDObject \
import TrigDecisionD3PDObject
alg += TrigDecisionD3PDObject(**_args(2, 'TrigDecision', kw))
#TrigEgammaD3PDObjects (alg, **_args (1, 'TrigEgamma', kw,
# TrigEMCluster_level = 2))
# from TriggerD3PDMaker.EnergySumROID3PDObject import EnergySumROID3PDObject
# from TrigMissingETD3PDMaker.TrigMETD3PDObject import TrigMETD3PDObject
# alg += EnergySumROID3PDObject(**_args (level, 'EnergySumROI', kw,
# prefix = "trig_L1_esum_",
# allowMissing = True))
# # The LVL2 information:
# alg += TrigMETD3PDObject(**_args( level, 'TrigMETL2', kw,
# prefix = "trig_L2_met_",
# sgkey = "HLT_T2MissingET" ))
# if cfgKeyStore.isInInputFile( "TrigMissingETContainer", "HLT_L2MissingET_FEB" ):
# alg += TrigMETD3PDObject(**_args( level, 'TrigMETL2_FEB', kw,
# prefix = "trig_L2_feb_met_",
# sgkey = "HLT_L2MissingET_FEB" ))
# # The EF information:
# alg += TrigMETD3PDObject(**_args ( level, 'TrigMETEF', kw,
# prefix = "trig_EF_met_",
# sgkey = "HLT_TrigEFMissingET" ))
# from TriggerD3PDMaker.BGCodeD3PDObject import BGCodeD3PDObject
# alg += BGCodeD3PDObject (**_args (2, 'BGCode', kw))
# May be missing in single-beam data.
alg += PrimaryxAODVertexD3PDObject(**_args(
1,
'PrimaryVertex',
kw,
#allowMissing = True,
sgkey=D3PDMakerFlags.VertexSGKey(),
prefix='vxp_',
storeVertexTrackIndexAssociation=False,
storeVertexTrackAssociation=True,
storeDiagonalCovarianceAsErrors=True))
if rec.doTruth():
from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject
alg += TruthMuonD3PDObject(**_args(level, 'TruthMuon', kw))
alg += TruthEventD3PDObject(**_args(1, 'TruthEvent', kw))
alg += TruthParticleD3PDObject(**_args(level, 'TruthParticle', kw))
# alg.MetadataTools += [LBMetadataConfig()]
# if D3PDMakerFlags.FilterCollCand():
# from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg
# alg.filterSeq += CollisionFilterAlg (tuplename + '_CollCandFilter')
return alg
def physicsD3PD(alg=None,
trigalg=None,
file='physics.root',
tuplename='physics',
**kw):
# Core algorithm
# By default the user of this function should have created an algorithm already.
# But for backwards compatibility let the function create its own algorithm if
# needed...
if not alg:
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
alg = MSMgr.NewRootStream(tuplename, file)
alg += EventInfoD3PDObject(**_args(10, 'EventInfo', kw))
# Segregate trigger decision flags in a separate tree.
if not trigalg:
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
trigalg = MSMgr.NewRootStream(tuplename + ':' + tuplename + 'TrigDec',
FileName=file,
TreeName=tuplename + 'TrigDec')
trigalg += EventInfoD3PDObject(0)
alg.Stream.trigDecisionTree = trigalg
# Add bunch structure metadata.
from TriggerD3PDMaker.BunchStructureMetadata \
import addBunchStructureMetadata
addBunchStructureMetadata(alg)
# Make track jets, but we can only do this if we have vertices.
if testSGKey('VxContainer', 'VxPrimaryCandidate'):
from D3PDMakerConfig.createTrackJets import createTrackJets
createTrackJets(AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()))
alg += JetD3PDObject(**_args(
-1, 'TrackJet', kw, prefix='trackjet_', sgkey='AntiKtZ5TrackJets'))
k = 'Electron_EgammaTrackJetSignedIPAndPTRel_target'
if not kw.has_key(k):
kw[k] = 'trackjet_'
alg += LArCollisionTimeD3PDObject(**_args(10, 'LArCollisionTime', kw))
# Electron/Photon blocks
alg += ElectronD3PDObject(
**_args(10,
'Electron',
kw,
EgammaJetSignedIPAndPTRel_target='jet_antikt4h1topo_'))
alg += PhotonD3PDObject(
**_args(10, 'Photon', kw, ConversionVertexTrackIndex_target='trk'))
if testSGKey('ElectronContainer', D3PDMakerFlags.GSFElectronSGKey()):
alg += GSFElectronD3PDObject(
**_args(level,
'GSFElectron',
kw,
sgkey=D3PDMakerFlags.GSFElectronSGKey(),
prefix='el_gsf_'))
# Muon blocks
alg += MuonD3PDObject(**_args(10,
'MuidMuon',
kw,
sgkey='MuidMuonCollection',
prefix='mu_muid_',
allowMissing=True))
alg += MuonD3PDObject(**_args(10,
'StacoMuon',
kw,
sgkey='StacoMuonCollection',
prefix='mu_staco_',
allowMissing=True))
alg += MuonD3PDObject(**_args(
10, 'Muons', kw, sgkey='Muons', prefix='mu_', allowMissing=True))
# Tau block
alg += TauD3PDObject(**_args(1, 'Tau', kw))
# Jet blocks
alg += JetD3PDObject(**_args(9,
'AK4TopoJet',
kw,
sgkey='AntiKt4TopoEMJets,' +
'AntiKt4TopoJets,' + 'AntiKt4H1TopoJets',
prefix='jet_antikt4h1topo_',
ConstitIndex_Target='cl_',
exclude=['Constituents'],
allowMissing=True))
alg += JetD3PDObject(**_args(6,
'AK4TowerJet',
kw,
sgkey='AntiKt4TowerAODJets,' +
'AntiKt4TowerJets,' + 'AntiKt4H1TowerJets',
prefix='jet_antikt4h1tower_',
exclude=['Constituents'],
allowMissing=True))
alg += JetD3PDObject(**_args(6,
'AK6TowerJet',
kw,
sgkey='AntiKt6TowerAODJets,' +
'AntiKt6TowerJets,' + 'AntiKt6H1TowerJets',
prefix='jet_antikt6h1tower_',
exclude=['Constituents'],
allowMissing=True))
#alg += JetD3PDObject (**_args ( 9, 'AK4TopoJetLC', kw,
# sgkey='AntiKt4LCTopoJets', prefix='jet_antikt4lctopo_'))
#alg += JetD3PDObject (**_args ( 9, 'AK6TopoJetLC', kw,
# sgkey='AntiKt6LCTopoMyJets', prefix='jet_antikt6lctopo_'))
#alg += JetD3PDObject (**_args ( 9, 'AK6TopoJetH1', kw,
# sgkey='AntiKt6H1TopoMyJets', prefix='jet_antikt6h1topo_'))
# MET blocks
alg += MissingETD3PDObject(**_args(10, 'MissingET', kw, allowMissing=True))
alg += MissingETGoodnessD3PDObject(**_args(2, 'METGoodness', kw))
# track and cluster blocks
alg += ClusterD3PDObject(**_args(1, 'Cluster', kw))
alg += EMClusterD3PDObject(**_args(2, 'EMCluster', kw))
# Many of these are just being set to the defaults --- that's because
# they're being changed in TrigEgamma...
alg += TrackParticleD3PDObject(
**_args(3,
'TrackParticle',
kw,
TruthParticleTarget='mc_',
storeTruthInfo=True,
trackParametersAtGlobalPerigeeLevelOfDetails=3,
storeDiagonalCovarianceAsErrors=True))
# 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))
# ZDC
alg += ZDCTriggerBitsD3PDObject(**_args(10, 'ZDCTriggerBits', kw))
# Primary vertex block - May be missing in single-beam data.
alg += PrimaryVertexD3PDObject(
**_args(1,
'PrimaryVertex',
kw,
allowMissing=True,
sgkey=D3PDMakerFlags.VertexSGKey(),
prefix='vxp_',
storeVertexTrackAssociation=True,
storeDiagonalCovarianceAsErrors=True))
# Truth
if rec.doTruth():
from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject
alg += TruthMuonD3PDObject(**_args(2, 'TruthMuon', kw))
alg += GenEventD3PDObject(**_args(1, 'GenEvent', kw))
alg += TruthParticleD3PDObject(**_args(1, 'TruthParticle', kw))
alg += JetD3PDObject(**_args(3,
'AK4TruthJet',
kw,
sgkey='AntiKt4TruthJets',
prefix='jet_antikt4truth_',
allowMissing=True))
#alg += JetD3PDObject (**_args ( 3, 'AK6Ttruth', kw,
# sgkey='AntiKt6TruthJets',
# prefix='jet_antikt6truth_'))
# Trigger
if D3PDMakerFlags.DoTrigger():
from TriggerD3PDMaker.TrigDecisionD3PDObject \
import TrigDecisionD3PDObject
alg += TrigDecisionD3PDObject(**_args(2, 'TrigDecision', kw))
TrigEgammaD3PDObjects(alg, **_args(1, 'TrigEgamma', kw))
alg += egammaTriggerBitsD3PDObject(**_args(2, 'EgammaTriggerBits', kw))
alg += MuonTriggerBitsD3PDObject(**_args(2, 'MuonTriggerBits', kw))
alg += METD3PDTriggerBitsObject(**_args(2, 'METTriggerBits', kw))
from TriggerD3PDMaker.EnergySumROID3PDObject import EnergySumROID3PDObject
from TrigMissingETD3PDMaker.TrigMETD3PDObject import TrigMETD3PDObject
alg += EnergySumROID3PDObject(**_args(
2, 'EnergySumROI', kw, prefix="trig_L1_esum_", allowMissing=True))
# 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"))
from TriggerD3PDMaker.BGCodeD3PDObject import BGCodeD3PDObject
alg += BGCodeD3PDObject(**_args(2, 'BGCode', kw))
# Event metadata
alg.MetadataTools += [LBMetadataConfig()]
if D3PDMakerFlags.FilterCollCand():
from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg
alg.filterSeq += CollisionFilterAlg(tuplename + '_CollCandFilter')
return alg
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
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