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 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 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
# Get BoostedTopD3PDMaker which contains MI filler tools import BoostedTopD3PDMaker #Electrons, 10 and 15 ElectronD3PDObject.defineBlock(99, "miniiso10", BoostedTopD3PDMaker.MiniIsolationElectronFillerTool, EMTrackIsolationTool=theemtrackisolationtool, KtDist=10., prefix="MI10_") ElectronD3PDObject.defineBlock(99, "miniiso15", BoostedTopD3PDMaker.MiniIsolationElectronFillerTool, EMTrackIsolationTool=theemtrackisolationtool, KtDist=15., prefix="MI15_") #Get Muon Isolation tool # This is needed to initialize the MuonIsolationTool properly. # Without this, there will be ERRORs! include( "MuonIsolationTools/MuonIsolationTool_jobOptions.py" ) #Muons, 10 and 15 MuonD3PDObject.defineBlock(99, "miniiso10", BoostedTopD3PDMaker.MiniIsolationMuonFillerTool, MuIsolationTool=ToolSvc.MuonIsolationTool, KtDist=10., prefix="MI10_") MuonD3PDObject.defineBlock(99, "miniiso15", BoostedTopD3PDMaker.MiniIsolationMuonFillerTool, MuIsolationTool=ToolSvc.MuonIsolationTool, KtDist=15., prefix="MI15_") ######################################### def MinimalistD3PD(alg): from CaloSysD3PDMaker import ClusterMomentFillerTool as CMFT ClusterD3PDObject.defineBlock (0, 'CenterMagMoments', CMFT, Moments = [CMFT.CENTER_MAG, 'centermag']) alg += ClusterD3PDObject(level=0, sgkey='CaloCalTopoCluster', prefix='cl_') # alg.cl_Filler.cl_Filler_Kinematics.WriteE = True return