def egammaTimeCorrConfig \ (seq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()), prefix = '', sgkey = D3PDMakerFlags.ElectronSGKey(), typeName = 'DataVector<xAOD::Electron_v1>', allowMissing = False): """Configure egammaTimeCorrAlg for D3PD making. SEQ is the Gaudi sequence to which the algorithm should be added. Default is that given by PreD3PDAlgSeqName. PREFIX is a prefix to add to the name of the algorithm scheduled. SGKEY/TYPENAME is the StoreGate key of the input electron container and the name of its type. If ALLOWMISSING is true, don't fail if the SG key doesn't exist. """ if (not D3PDMakerFlags.MakeEgammaUserData() or D3PDMakerFlags.HaveEgammaUserData()): return DVGetter = D3PDMakerCoreComps.SGDataVectorGetterTool resolved_sgkey = resolveSGKey (typeName, sgkey) auxprefix = (D3PDMakerFlags.EgammaUserDataPrefix() + '_' + resolved_sgkey + '_') algName = 'egammaTimeCorrAlg' + resolved_sgkey if not hasattr (seq, algName): from IOVDbSvc.CondDB import conddb conddb.addFolder("LAR_OFL","/LAR/TimeCorrectionOfl/NonRunCon <tag>LARTimeCorrectionOflNonRunCon-00</tag>",force=True) conddb.addFolder("LAR_OFL","/LAR/TimeCorrectionOfl/RunCon <tag>LARTimeCorrectionOflRunCon-00</tag>",force=True) from CaloClusterCorrection.CaloClusterTimeTool import GetCaloClusterTimeTool myCaloClusterTimeTool=GetCaloClusterTimeTool("caloClusterTimeTool", "/LAR/TimeCorrectionOfl/NonRunCon","/LAR/TimeCorrectionOfl/RunCon") seq += egammaD3PDAnalysis.egammaTimeCorrAlg \ (algName, Getter = DVGetter (prefix + 'egammaTimeCorrGetter', TypeName = typeName, SGKey = sgkey), AllowMissing = allowMissing, AuxPrefix = auxprefix, CaloClusterTimeTool = myCaloClusterTimeTool, ) return
def PhotonTruthConfig \ (seq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()), prefix = '', sgkey = D3PDMakerFlags.ElectronSGKey(), typeName = 'ElectronContainer', allowMissing = False): """Configure PhotonTruthAlg for D3PD making. SEQ is the Gaudi sequence to which the algorithm should be added. Default is that given by PreD3PDAlgSeqName. PREFIX is a prefix to add to the name of the algorithm scheduled. SGKEY/TYPENAME is the StoreGate key of the input electron container and the name of its type. If ALLOWMISSING is true, don't fail if the SG key doesn't exist. """ if not rec.doTruth(): return if (not D3PDMakerFlags.MakeEgammaUserData() or D3PDMakerFlags.HaveEgammaUserData()): return DVGetter = D3PDMakerCoreComps.SGDataVectorGetterTool resolved_sgkey = resolveSGKey (typeName, sgkey) auxprefix = (D3PDMakerFlags.EgammaUserDataPrefix() + '_' + resolved_sgkey + '_') from TruthD3PDMaker.MCTruthClassifierConfig \ import D3PDMCTruthClassifier ptaname = 'PhotonTruthAlg_' + resolved_sgkey if not hasattr (seq, ptaname): seq += egammaD3PDAnalysis.PhotonTruthAlg \ (ptaname, PhotonGetter = DVGetter (prefix + 'PhotonTruthAlgGetter', TypeName = typeName, SGKey = sgkey), AllowMissing = allowMissing, AuxPrefix = auxprefix, TruthTool = egammaD3PDAnalysis.PhotonTruthTool ('D3PD__PhotonTruthTool', Classifier = D3PDMCTruthClassifier)) return
def egammaDeltaEmax2Config \ (seq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()), prefix = '', sgkey = D3PDMakerFlags.ElectronSGKey(), typeName = 'DataVector<xAOD::Electron_v1>', allowMissing = False): """Configure egammaDeltaEmax2Alg for D3PD making. SEQ is the Gaudi sequence to which the algorithm should be added. Default is that given by PreD3PDAlgSeqName. PREFIX is a prefix to add to the name of the algorithm scheduled. SGKEY/TYPENAME is the StoreGate key of the input electron container and the name of its type. If ALLOWMISSING is true, don't fail if the SG key doesn't exist. """ if (not D3PDMakerFlags.MakeEgammaUserData() or D3PDMakerFlags.HaveEgammaUserData()): return DVGetter = D3PDMakerCoreComps.SGDataVectorGetterTool resolved_sgkey = resolveSGKey (typeName, sgkey) auxprefix = (D3PDMakerFlags.EgammaUserDataPrefix() + '_' + resolved_sgkey + '_') emax2name = 'DeltaEmax2Alg_' + resolved_sgkey if not hasattr (seq, emax2name): highlum = False if typeName == 'ElectronContainer': from AthenaCommon.BeamFlags import jobproperties if jobproperties.Beam.numberOfCollisions() >= 20 : highlum = True seq += egammaD3PDAnalysis.egammaDeltaEmax2Alg \ (emax2name, Getter = DVGetter (prefix + 'DeltaEmax2Getter', TypeName = typeName, SGKey = sgkey), AllowMissing = allowMissing, HighLum = highlum, AuxPrefix = auxprefix) return
def egammaCalcOQConfig \ (seq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()), prefix = '', sgkey = D3PDMakerFlags.ElectronSGKey(), typeName = 'ElectronContainer', allowMissing = False): """Configure egammaTopoIsoAlg for D3PD making. SEQ is the Gaudi sequence to which the algorithm should be added. Default is that given by PreD3PDAlgSeqName. PREFIX is a prefix to add to the name of the algorithm scheduled. SGKEY/TYPENAME is the StoreGate key of the input electron container and the name of its type. If ALLOWMISSING is true, don't fail if the SG key doesn't exist. """ if (not D3PDMakerFlags.MakeEgammaUserData() or D3PDMakerFlags.HaveEgammaUserData()): return DVGetter = D3PDMakerCoreComps.SGDataVectorGetterTool resolved_sgkey = resolveSGKey (typeName, sgkey) udprefix = (D3PDMakerFlags.EgammaUserDataPrefix() + '_' + resolved_sgkey + '_') oqname = 'egammaCalcOQAlg_' + resolved_sgkey if not hasattr (seq, oqname): from AthenaCommon.AppMgr import ToolSvc ToolSvc += egammaOQFlagsBuilderBase() seq += egammaD3PDAnalysis.egammaCalcOQAlg \ (oqname, egammaOQFlagsBuilder = egammaOQFlagsBuilderBase(), Getter = DVGetter (prefix + 'egammaCalcOQGetter', TypeName = typeName, SGKey = sgkey), AllowMissing = allowMissing, UDPrefix = udprefix ) return
def egammaNbCellsGainAlgConfig \ (seq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()), prefix = '', sgkey = D3PDMakerFlags.ElectronSGKey(), typeName = 'ElectronContainer', allowMissing = False): """Configure egammaNbCellsGainAlg for D3PD making. SEQ is the Gaudi sequence to which the algorithm should be added. Default is that given by PreD3PDAlgSeqName. PREFIX is a prefix to add to the name of the algorithm scheduled. SGKEY/TYPENAME is the StoreGate key of the input electron container and the name of its type. If ALLOWMISSING is true, don't fail if the SG key doesn't exist. """ if (not D3PDMakerFlags.MakeEgammaUserData() or D3PDMakerFlags.HaveEgammaUserData()): return DVGetter = D3PDMakerCoreComps.SGDataVectorGetterTool resolved_sgkey = resolveSGKey (typeName, sgkey) auxprefix = (D3PDMakerFlags.EgammaUserDataPrefix() + '_' + resolved_sgkey + '_') algName = 'egammaNbCellsGainAlg' + resolved_sgkey if not hasattr (seq, algName): myAlg = egammaD3PDAnalysis.egammaNbCellsGainAlg \ (algName, Getter = DVGetter (prefix + 'egammaNbCellsGainAlgGetter', TypeName = typeName, SGKey = sgkey), AllowMissing = allowMissing, AuxPrefix = auxprefix,) seq += myAlg return
from TriggerD3PDMaker.defineTriggerBits import defineTriggerBits from AthenaCommon.AlgSequence import AlgSequence from RecExConfig.RecFlags import rec import egammaD3PDMaker import EventCommonD3PDMaker import TrackD3PDMaker import CaloD3PDMaker import D3PDMakerCoreComps from ROOT import egammaParameters from ROOT import egammaPID ElectronD3PDObject = \ make_SGDataVector_D3PDObject ('ElectronContainer', D3PDMakerFlags.ElectronSGKey(), 'el_', 'QcdElectronD3PDObject') def _electronAlgHook(c, prefix, sgkey, typeName, seq=AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()), *args, **kw): ElectronUserDataConfig(seq=seq, prefix=prefix, sgkey=sgkey, typeName=typeName)
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
## Add the encoded trigger decision. It has to be done at the beginning, ## because some of the following functions would add it with a lower ## detail level. ## if triggerAvailable: from TriggerD3PDMaker.TrigDecisionD3PDObject import TrigDecisionD3PDObject d3pdalg += TrigDecisionD3PDObject(10) pass ## ## Offline e/gamma information: ## oflEgammaIncludes = ['ClusterKin'] from egammaD3PDMaker.ElectronD3PDObject import ElectronD3PDObject added = False for sgkey in D3PDMakerFlags.ElectronSGKey().split(","): if cfgKeyStore.isInInput("ElectronContainer", sgkey): d3pdalg += ElectronD3PDObject(1, include=oflEgammaIncludes) added = True break pass if not added: TriggerD3PDStream_msg.warning("Offline electrons not found in input") pass from egammaD3PDMaker.PhotonD3PDObject import PhotonD3PDObject added = False for sgkey in D3PDMakerFlags.PhotonSGKey().split(","): if cfgKeyStore.isInInput("PhotonContainer", sgkey): d3pdalg += PhotonD3PDObject(1, include=oflEgammaIncludes + ['Samplings'], Samplings_Samplings=[2],
def PhotonCustomMET(): from AthenaCommon.AppMgr import ToolSvc topSequence = AlgSequence() photongetter = D3PDMakerCoreComps.SGDataVectorGetterTool( 'photonTight_Getter', TypeName='PhotonContainer', SGKey=D3PDMakerFlags.PhotonSGKey()) ToolSvc += photongetter electrongetter = D3PDMakerCoreComps.SGDataVectorGetterTool( 'electronTight_Getter', TypeName='ElectronContainer', SGKey=D3PDMakerFlags.ElectronSGKey()) ToolSvc += electrongetter # ------------------------------------------------------------------------------------------- # Filters for NN!!! # add a filter to select NN tight photons photonFilterNNTight = PhotonD3PDMaker.PhotonFilter( OutputCollectionName="SelectedPhotonsNNTight", photonGetter=photongetter, ptCut=20000, etaCut=2.5, IsEM=0, NNCut=True, PhotonNNTool=PhotonNeuralNetworkTool()) topSequence += photonFilterNNTight # add a filter to select normal electrons electrongetter = D3PDMakerCoreComps.SGDataVectorGetterTool( 'electronNNTight_Getter', TypeName='ElectronContainer', SGKey=D3PDMakerFlags.ElectronSGKey()) ToolSvc += electrongetter # add a filter that will create both photon and electron containers, with proper overlap removal (OR) egammaORFilter_NN = PhotonD3PDMaker.EgammaFilter( 'egammaOR_Filter_NN', OutputElectronCollectionName="SelectedORElectronsNNTight", ElectronGetter=electrongetter, ElectronPtCut=10000, ElectronEtaCut=2.47, ElectronIsEM=egammaPID.ElectronIDMediumPP, OutputPhotonCollectionName="SelectedORPhotonsNNTight", PhotonGetter=photongetter, PhotonPtCut=20000, PhotonEtaCut=2.37, PhotonIsEM=0, PhotonNNCut=True, PhotonNNTool=PhotonNeuralNetworkTool()) topSequence += egammaORFilter_NN # add a filter that will create both photon and electron containers, with proper overlap removal (OR) # but using standard Tight egammaORFilter_tight = PhotonD3PDMaker.EgammaFilter( 'egamma_OR_Filter_tight', OutputElectronCollectionName="SelectedORElectronsTight", ElectronGetter=electrongetter, ElectronPtCut=10000, ElectronEtaCut=2.47, ElectronIsEM=egammaPID.ElectronIDMediumPP, OutputPhotonCollectionName="SelectedORPhotonsTight", PhotonGetter=photongetter, PhotonPtCut=20000, PhotonEtaCut=2.37, PhotonIsEM=egammaPID.PhotonIDTight, PhotonNNCut=False, PhotonNNTool=PhotonNeuralNetworkTool()) topSequence += egammaORFilter_tight # add a filter that will create both photon and electron containers, # with proper overlap removal (OR) but using standard Loose egammaORFilter_loose = PhotonD3PDMaker.EgammaFilter( 'egamma_OR_Filter_loose', OutputElectronCollectionName="SelectedORElectronsLoose", ElectronGetter=electrongetter, ElectronPtCut=10000, ElectronEtaCut=2.47, ElectronIsEM=egammaPID.ElectronIDMediumPP, OutputPhotonCollectionName="SelectedORPhotonsLoose", PhotonGetter=photongetter, PhotonPtCut=20000, PhotonEtaCut=2.37, PhotonIsEM=egammaPID.PhotonIDLoose, PhotonNNCut=False, PhotonNNTool=PhotonNeuralNetworkTool()) topSequence += egammaORFilter_loose # Toggle for setting some options that we used to enable for various STVF configurations, # before the MET configuration changes in 17.2.7.4.1. METcollections = [] # Loose photons suffix = '_PhotonLoose_Calib_OR_stdvert' MET_PhotonLoose_Calib_OR_stdvert = make_METRefAlg(_suffix=suffix) MET_PhotonLoose_Calib_OR_stdvert.photon_doPhotonTool = True MET_PhotonLoose_Calib_OR_stdvert.gamma_noCut = True MET_PhotonLoose_Calib_OR_stdvert.gamma_EgammaInputCollectionKey = "SelectedORPhotonsLoose" MET_PhotonLoose_Calib_OR_stdvert.gamma_EleInputCollectionKey = "SelectedORElectronsLoose" MET_PhotonLoose_Calib_OR_stdvert.gamma_calibType = "RefCalib" MET_PhotonLoose_Calib_OR_stdvert.ele_noCut = True MET_PhotonLoose_Calib_OR_stdvert.ele_EgammaInputCollectionKey = "SelectedORElectronsLoose" MET_PhotonLoose_Calib_OR_stdvert.ele_calibType = "RefCalib" MET_PhotonLoose_Calib_OR_stdvert.jet_calibType = 'ExclRefCalib' MET_PhotonLoose_Calib_OR_stdvert.jet_JetInputCollectionKey = "AntiKt4LCTopoNewJets" MET_PhotonLoose_Calib_OR_stdvert.cellout_PUSuppression_JA = False MET_PhotonLoose_Calib_OR_stdvert() METcollections += [suffix] # tight photons suffix = '_PhotonTight_Calib_OR_stdvert' MET_PhotonTight_Calib_OR_stdvert = make_METRefAlg(_suffix=suffix) MET_PhotonTight_Calib_OR_stdvert.photon_doPhotonTool = True MET_PhotonTight_Calib_OR_stdvert.gamma_noCut = True MET_PhotonTight_Calib_OR_stdvert.gamma_EgammaInputCollectionKey = "SelectedORPhotonsTight" MET_PhotonTight_Calib_OR_stdvert.gamma_EleInputCollectionKey = "SelectedORElectronsTight" MET_PhotonTight_Calib_OR_stdvert.gamma_calibType = "RefCalib" MET_PhotonTight_Calib_OR_stdvert.ele_noCut = True MET_PhotonTight_Calib_OR_stdvert.ele_EgammaInputCollectionKey = "SelectedORElectronsTight" MET_PhotonTight_Calib_OR_stdvert.ele_calibType = "RefCalib" MET_PhotonTight_Calib_OR_stdvert.jet_calibType = 'ExclRefCalib' MET_PhotonTight_Calib_OR_stdvert.jet_JetInputCollectionKey = "AntiKt4LCTopoNewJets" MET_PhotonTight_Calib_OR_stdvert.cellout_PUSuppression_JA = False MET_PhotonTight_Calib_OR_stdvert() METcollections += [suffix] # NNTight photons suffix = '_NNTight_Calib_OR_stdvert' MET_NNTight_Calib_OR_stdvert = make_METRefAlg(_suffix=suffix) MET_NNTight_Calib_OR_stdvert.photon_doPhotonTool = True MET_NNTight_Calib_OR_stdvert.gamma_noCut = True MET_NNTight_Calib_OR_stdvert.gamma_EgammaInputCollectionKey = "SelectedORPhotonsNNTight" MET_NNTight_Calib_OR_stdvert.gamma_EleInputCollectionKey = "SelectedORElectronsNNTight" MET_NNTight_Calib_OR_stdvert.gamma_calibType = "RefCalib" MET_NNTight_Calib_OR_stdvert.ele_noCut = True MET_NNTight_Calib_OR_stdvert.ele_EgammaInputCollectionKey = "SelectedORElectronsNNTight" MET_NNTight_Calib_OR_stdvert.ele_calibType = "RefCalib" MET_NNTight_Calib_OR_stdvert.jet_calibType = 'ExclRefCalib' MET_NNTight_Calib_OR_stdvert.jet_JetInputCollectionKey = "AntiKt4LCTopoNewJets" MET_NNTight_Calib_OR_stdvertcellout_PUSuppression_JA = False MET_NNTight_Calib_OR_stdvert() METcollections += [suffix]
def getJetTileD3PDObject(objectname='JetTileD3PDObject', prefix='jet_', btagleveloffset=7): object = make_SGDataVector_D3PDObject('JetCollection', D3PDMakerFlags.JetSGKey(), prefix, objectname) object.defineHook(_fixJetTiming) object.defineBlock(0, 'Kinematics', EventCommonD3PDMaker.FourMomFillerTool, WriteE=True) object.defineBlock(1, 'OriginCorrection', JetD3PDMaker.JetMomentFillerTool, Moments=['EtaOrigin', 'PhiOrigin', 'MOrigin']) object.defineBlock( 1, 'DQMoments', JetD3PDMaker.JetMomentFillerTool, Moments=[ 'WIDTH', 'n90', 'Timing', 'LArQuality', 'nTrk', 'sumPtTrk', 'OriginIndex', 'HECQuality', 'NegativeE', 'AverageLArQF', 'BCH_CORR_CELL', 'BCH_CORR_DOTX', 'BCH_CORR_JET', 'BCH_CORR_JET_FORCELL', 'ENG_BAD_CELLS', 'N_BAD_CELLS', 'N_BAD_CELLS_CORR', 'BAD_CELLS_CORR_E', 'NumTowers', 'ootFracCells5', 'ootFracCells10', 'ootFracClusters5', 'ootFracClusters10' ]) object.defineBlock(1, 'JetSamplingsFrac', JetD3PDMaker.JetSamplingsFracFillerTool) object.defineBlock(1, 'JetQual', JetD3PDMaker.JetCaloUtilsFillerTool) object.defineBlock(1, 'EMFraction', JetD3PDMaker.JetEMFractionFillerTool) object.defineBlock( 1, 'JES', JetD3PDMaker.JetMomentFillerTool, Moments=['Offset', 'EMJES', 'EMJES_EtaCorr', 'EMJESnooffset']) object.defineBlock(1, 'EMScale', JetD3PDMaker.JetSignalStateFillerTool, WriteE=True, SignalStateNumber=0, SignalStatePrefix='emscale') object.defineBlock(2, 'JetTileFiller', JetD3PDMaker.JetTileCellFillerTool) # object.defineBlock(3, 'JVtx', # JetD3PDMaker.JetVtxFillerTool, # JetVertexAssociationTool=_getJvfTool()) object.defineBlock(3, 'Layer', JetD3PDMaker.JetMomentFillerTool, Moments=['GSCFactorF', 'WidthFraction']) object.defineBlock(4, 'Samplings', JetD3PDMaker.JetSamplingsFillerTool) object.defineBlock(5, 'JESMoments', JetD3PDMaker.JetMomentFillerTool, Moments=['LCJES']) # Moments=['GCWJES', 'GCWJES_EtaCorr','CB']) object.defineBlock(5, 'JetShape', JetD3PDMaker.JetShapeFillerTool) object.defineBlock(5, 'Constituents', JetD3PDMaker.JetConstituentFillerTool, SignalStateNumber=0, SignalStatePrefix='emscale') object.defineBlock(5, 'ConstituentScale', JetD3PDMaker.JetSignalStateFillerTool, WriteE=True, SignalStateNumber=2, SignalStatePrefix='constscale') object.defineBlock(6, 'JetLArHVMoment', JetD3PDMaker.JetMomentFillerTool, Moments=['LArBadHVEnergy', 'LArBadHVRatio']) addBTagInfoToJetObject(object, btagleveloffset) # Track association cannot be done unless there are tracks. # As often this is not the case track association will be done only # if this is explicitly asked for. by defining it in the include list. # # You can also enable it by passing an argument to JetD3PDObject # like: # AssocTrackCont_target='mytarget_' def _jetAssocLevel(reqlev, args): return args.has_key('target') or (reqlev >= 999) IndexMultiAssociation(object, JetD3PDMaker.FlavorAssociationTool, 'trk', prefix='flavor_assoctrk_', level=_jetAssocLevel, blockname='AssocTrackCont') object.defineBlock(10, 'JetRoIword', JetD3PDMaker.JetROIWordFillerTool) JetElAssoc = DRAssociation(object, "ElectronContainer", D3PDMakerFlags.ElectronSGKey(), 0.2, prefix='el_', matched="matched", blockname="El02Match") JetMuAssoc = DRAssociation(object, "Analysis::MuonContainer", D3PDMakerFlags.MuonSGKey(), 0.2, prefix='mu_', matched="matched", blockname="Mu02Match") #JetTrkAssoc = DRAssociation(object,"Rec::TrackParticleContainer",D3PDMakerFlags.TrackSGKey(),0.4,prefix='trk_',matched="matched",blockname="Trk04Match") #---------------- Trigger Object ---------------------------- JetL1Assoc = SimpleAssociation( object, JetD3PDMaker.JetL1TriggerObjectAssociationTool, matched='matched', blockname='L1Info', prefix='L1_', MaxDR=0.6, ChainPattern='L1_J.*') JetL1Assoc.defineBlock(99, 'L1Kinematics', EventCommonD3PDMaker.FourMomFillerTool, WriteE=True, WriteEt=False, WriteM=False) JetL2Assoc = SimpleAssociation( object, JetD3PDMaker.JetL2TriggerObjectAssociationTool, matched='matched', blockname='L2Info', prefix='L2_', MaxDR=0.25, ChainPattern='L2_j.*') JetL2Assoc.defineBlock(99, 'L2Kinematics', EventCommonD3PDMaker.FourMomFillerTool, WriteE=True, WriteEt=False, WriteM=False) JetEFAssoc = SimpleAssociation( object, JetD3PDMaker.JetEFTriggerObjectAssociationTool, matched='matched', blockname='EFInfo', prefix='EF_', MaxDR=0.25, ChainPattern='EF_j.*') JetEFAssoc.defineBlock(99, 'EFKinematics', EventCommonD3PDMaker.FourMomFillerTool, WriteE=True, WriteEt=False, WriteM=False) ConstitAssoc = ContainedVectorMultiAssociation \ (object, #JetD3PDMaker.JetConstituentAssociationTool, EventCommonD3PDMaker.NavigableConstituentAssociationTool, 'constit_', TypeName = 'CaloCluster', nrowName = '', level = 1) ConstitAssoc.defineBlock(_constitAssocLevel, 'ConstitIndex', D3PDMakerCoreComps.IndexFillerTool, Target='') return object
def 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 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