def BTaggingD3PD(alg=None, file=JetTagD3PDKeys.D3PDFileName(), algname=JetTagD3PDKeys.D3PDAlgName(), **kw): print "printing additional d3pd properties from dictionary" print kw if not alg: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr alg = MSMgr.NewRootStream(JetTagD3PDKeys.D3PDAlgName(), JetTagD3PDKeys.D3PDFileName(), JetTagD3PDKeys.D3PDTupleName()) selectedJetCollections = [] if len(JetTagD3PDFlags.JetCollections()) != 0: from JetTagD3PDMaker.JetTagJetD3PDObject import getJetTagJetD3PDObject for jetcoll in JetTagD3PDFlags.JetCollections(): filteredcoll = jetcoll + JetTagD3PDKeys.FilteredJetCollectionPostfix( ) ### you can add specific selection for a certain jet collection as argument to the function bellow ### otherwise the one specified by JetTagD3PDFlags will be used alg += getJetTagJetD3PDObject(**_args( jetcoll, kw, filteredsgkey=filteredcoll, origsgkey=jetcoll)) selectedJetCollections.append(filteredcoll) else: print "Warning: you didn't specify any jet collection for the JetTag D3PD" if len(selectedJetCollections) != 0: ### add muon in jets object if JetTagD3PDFlags.AddMuonInJetsObject(): from JetTagD3PDMaker.JetTagMuonInJetD3PDObject import getJetTagMuonInJetObject alg += getJetTagMuonInJetObject( **_args("muon1injet", kw, level=10, jetCollections=selectedJetCollections)) if JetTagD3PDFlags.AddSecondMuonCollection(): alg += getJetTagMuonInJetObject( **_args("muon2injet", kw, level=10, jetCollections=selectedJetCollections, prefix=JetTagD3PDKeys.Muon2InJetPrefix(), object_name='JetTagMuon2InJetD3PDObject', label=JetTagD3PDKeys.Muon2InJetGetterLabel(), muonsName="SecondMuons")) ### add electron in jets object if JetTagD3PDFlags.AddElectronInJetsObject(): from JetTagD3PDMaker.JetTagElectronInJetD3PDObject import getJetTagElectronInJetD3PDObject alg += getJetTagElectronInJetD3PDObject( **_args("electroninjet", kw, level=10, jetCollections=selectedJetCollections)) ### add photon in jets object if JetTagD3PDFlags.AddPhotonInJetsObject(): from JetTagD3PDMaker.JetTagPhotonInJetD3PDObject import getJetTagPhotonInJetD3PDObject alg += getJetTagPhotonInJetD3PDObject( **_args("photoninjet", kw, level=10, jetCollections=selectedJetCollections)) ### add VxOnJetAxis object if JetTagD3PDFlags.AddVxOnJetAxisInJetsObject(): from JetTagD3PDMaker.JetTagVxOnJetAxisD3PDObject import getJetTagVxOnJetAxisD3PDObject alg += getJetTagVxOnJetAxisD3PDObject( **_args("vxonjetaxis", kw, level=0, jetCollections=selectedJetCollections)) ### add TwoTrackVertex object if JetTagD3PDFlags.AddTwoTrackVertexInJetsObject(): from JetTagD3PDMaker.JetTagTwoTrackVertexD3PDObject import getJetTagTwoTrackVertexD3PDObject alg += getJetTagTwoTrackVertexD3PDObject( **_args("twotrackvertex", kw, level=0, jetCollections=selectedJetCollections)) ### add MSVVtxInfo object if JetTagD3PDFlags.AddMSVVtxInfoInJetsObject(): from JetTagD3PDMaker.JetTagMSVVtxInJetD3PDObject import getJetTagMSVVtxInfoInJetD3PDObject alg += getJetTagMSVVtxInfoInJetD3PDObject( **_args("msvvtxinfo", kw, level=1, jetCollections=selectedJetCollections)) ### add event info object if JetTagD3PDFlags.AddEventInfoObject(): from JetTagD3PDMaker.JetTagEventInfoD3PDObject import getJetTagEventInfoD3PDObject alg += getJetTagEventInfoD3PDObject(**_args("eventinfo", kw, level=1)) ### add pileup event info object if rec.doTruth and JetTagD3PDFlags.AddPileUpEventInfoObject(): from TruthD3PDMaker.PileUpInfoD3PDObject import PileUpInfoD3PDObject alg += PileUpInfoD3PDObject(0, "pileupinfo", "pileupinfo_", allowMissing=True) ### add track object if JetTagD3PDFlags.AddTrackObject(): from JetTagD3PDMaker.JetTagTrackD3PDObject import getJetTagTrackD3PDObject alg += getJetTagTrackD3PDObject(**_args("track", kw)) ### add MET objects for MET in JetTagD3PDFlags.METObjects(): from JetTagD3PDMaker.JetTagMETD3PDObject import getJetTagMETD3PDObject alg += getJetTagMETD3PDObject(**_args(MET, kw, sgkey=MET)) ### add event shape objects from QcdD3PDMaker.QcdEventShapeD3PDObject import EventShapeD3PDObject alg += EventShapeD3PDObject(level=0) ### add pixel clusters object if JetTagD3PDFlags.AddPixelClusterObject(): from JetTagD3PDMaker.JetTagClustersD3PDObject import getJetTagClusterD3PDObject alg += getJetTagClusterD3PDObject(**_args("pixelcluster", kw, level=0)) ### add primary vertex object if JetTagD3PDFlags.AddPrimaryVertexObject(): from JetTagD3PDMaker.JetTagPrimaryVertexD3PDObject import getJetTagPrimaryVertexD3PDObject alg += getJetTagPrimaryVertexD3PDObject(**_args("pv", kw)) ### add beam spot object if JetTagD3PDFlags.AddBeamSpotObject(): from TrackD3PDMaker.BeamSpotD3PDObject import BeamSpotD3PDObject alg += BeamSpotD3PDObject(10) ### add muid object if JetTagD3PDFlags.AddMuonMuidObject(): from MuonD3PDMaker.MuonD3PDObject import MuonD3PDObject _modifyMuonObject(MuonD3PDObject) alg += MuonD3PDObject(**_args( 'MuonMuid', kw, level=10, sgkey='MuidMuonCollection', prefix='mu_muid_', allowMissing=True, exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"], include=[ "BtagMuonTrackMatchingBlock", "EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex", "L1InfoIndex" ])) if JetTagD3PDFlags.AddMuonStacoObject(): from MuonD3PDMaker.MuonD3PDObject import MuonD3PDObject _modifyMuonObject(MuonD3PDObject) alg += MuonD3PDObject(**_args( 'MuonStaco', kw, level=10, sgkey='StacoMuonCollection', prefix='mu_staco_', allowMissing=True, exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"], include=[ "BtagMuonTrackMatchingBlock", "EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex", "L1InfoIndex" ])) ### add truth info with a filter if rec.doTruth and JetTagD3PDFlags.AddGenObjects(): from AthenaCommon.AppMgr import ToolSvc from TruthD3PDAnalysis.TruthD3PDAnalysisConf import D3PD__GenObjectsFilterTool jetTagGenObjectsFilterTool = D3PD__GenObjectsFilterTool( "JetTagGenObjectsFilterTool") ToolSvc += jetTagGenObjectsFilterTool jetTagGenObjectsFilterTool.SelectTruthTracks = False jetTagGenObjectsFilterTool.PtMin = JetTagD3PDFlags.MCPtMinCut() jetTagGenObjectsFilterTool.EtaMax = JetTagD3PDFlags.MCEtaCut() jetTagGenObjectsFilterTool.RemoveEmptyEvents = not JetTagD3PDFlags.MCEmptyEvents( ) jetTagGenObjectsFilterTool.RemoveDummyEvents = not JetTagD3PDFlags.MCDummyEvents( ) if not JetTagD3PDFlags.MCPileUp(): jetTagGenObjectsFilterTool.RemoveInTimePileUp = True jetTagGenObjectsFilterTool.Remove2BCPileUp = True jetTagGenObjectsFilterTool.Remove800nsPileUp = True jetTagGenObjectsFilterTool.RemoveCavernBkg = True jetTagGenObjectsFilterTool.RemoveEmptyEvents = True jetTagGenObjectsFilterTool.RemoveDummyEvents = True if JetTagD3PDFlags.AddGenEventObjects(): from TruthD3PDMaker.GenEventD3PDObject import GenEventD3PDObject alg += GenEventD3PDObject(**_args("genevent", kw, level=10, filter = jetTagGenObjectsFilterTool, pileup_CollectionGetterRegistry=\ alg.name()+'_CollectionGetterRegistry' ) ) if JetTagD3PDFlags.AddGenVertexObjects(): from TruthD3PDMaker.GenVertexD3PDObject import GenVertexD3PDObject alg += GenVertexD3PDObject(**_args( "genvertex", kw, level=10, filter=jetTagGenObjectsFilterTool)) if JetTagD3PDFlags.AddGenParticleObjects(): from TruthD3PDMaker.GenParticleD3PDObject import GenParticleD3PDObject alg += GenParticleD3PDObject(**_args( "genparticle", kw, level=10, filter=jetTagGenObjectsFilterTool)) if JetTagD3PDFlags.AddTruthTrackObjects(): jetTagTruthTrackObjectsFilterTool = D3PD__GenObjectsFilterTool( "JetTagTruthTrackObjectsFilterTool") ToolSvc += jetTagTruthTrackObjectsFilterTool jetTagTruthTrackObjectsFilterTool.SelectTruthTracks = True jetTagTruthTrackObjectsFilterTool.PtMin = JetTagD3PDFlags.MCPtMinCut( ) jetTagTruthTrackObjectsFilterTool.EtaMax = JetTagD3PDFlags.MCEtaCut( ) jetTagTruthTrackObjectsFilterTool.RemoveEmptyEvents = not JetTagD3PDFlags.MCEmptyEvents( ) jetTagTruthTrackObjectsFilterTool.RemoveDummyEvents = not JetTagD3PDFlags.MCDummyEvents( ) if not JetTagD3PDFlags.MCPileUp(): jetTagTruthTrackObjectsFilterTool.RemoveInTimePileUp = True jetTagTruthTrackObjectsFilterTool.Remove2BCPileUp = True jetTagTruthTrackObjectsFilterTool.Remove800nsPileUp = True jetTagTruthTrackObjectsFilterTool.RemoveCavernBkg = True jetTagTruthTrackObjectsFilterTool.RemoveEmptyEvents = True jetTagTruthTrackObjectsFilterTool.RemoveDummyEvents = True from TruthD3PDMaker.GenParticleD3PDObject import GenTruthTrackD3PDObject alg += GenTruthTrackD3PDObject( **_args("truthtrack", kw, level=10, filter=jetTagTruthTrackObjectsFilterTool)) ### add trigger if JetTagD3PDFlags.AddTriggerObject(): from TriggerD3PDMaker.TrigDecisionD3PDObject import TrigDecisionD3PDObject alg += TrigDecisionD3PDObject(**_args("trigdecision", kw, level=2)) from TriggerD3PDMaker.TrigConfMetadata import addTrigConfMetadata addTrigConfMetadata(alg) if JetTagD3PDFlags.AddTriggerBits(): from JetTagD3PDMaker.JetTagTriggerBitsD3PDObject import getJetTagTriggerBitsD3PDObject alg += getJetTagTriggerBitsD3PDObject( JetTagD3PDFlags.TriggerBitsList()) if JetTagD3PDFlags.AddJetTriggerObject(): from TrigJetD3PDMaker.TrigJetD3PD import TrigJetD3PDObjects TrigJetD3PDObjects(alg, level=10, addNaviInfo=True, addConfigInfo=False) if JetTagD3PDFlags.AddBJetTriggerObject(): from TrigBJetD3PDMaker.TrigBJetD3PD import TrigBJetD3PDObjects bjettriglevel = 1 if JetTagD3PDFlags.AddTrigL2IDTracks( ) or JetTagD3PDFlags.AddTrigEFIDTracks(): bjettriglevel = 11 TrigBJetD3PDObjects(alg, level=bjettriglevel, doAddL2ID=JetTagD3PDFlags.AddTrigL2IDTracks(), doAddEFID=JetTagD3PDFlags.AddTrigEFIDTracks()) if JetTagD3PDFlags.AddPixCond(): if hasattr(ServiceMgr, "PixelConditionsSummarySvc"): from JetTagD3PDMaker.JetTagPixModCondD3PDObject import getJetTagPixModCondD3PDObject alg += getJetTagPixModCondD3PDObject( PixSummarySvc=ServiceMgr.PixelConditionsSummarySvc) else: print "Warning: JetTagPixModCondD3PDObject requested but PixelConditionsSummarySvc not configured" #### add fat jets and subjets if JetTagD3PDFlags.AddFatJets(): from JetTagD3PDMaker.JetTagJSD3PDObjects import JSD3PD_Tool for xx in JetTagD3PDKeys.FatJetsList(): if xx[0] != None and xx[1] != None: jsD3PD = JSD3PD_Tool(xx) jsD3PD.addToAlg(alg) ### add skiming if JetTagD3PDFlags.SkimD3PD(): __muonAssocObjects = ["Muons"] if JetTagD3PDFlags.AddSecondMuonCollection(): __muonAssocObjects = ["Muons", "Muons2"] from JetTagD3PDMaker.JetTagD3PDMakerConf import D3PD__JetTagD3PDEventFilter JetTagD3PDEventFilter = D3PD__JetTagD3PDEventFilter( "JetTagD3PDEventFilter", UseMuonFilter=JetTagD3PDFlags.UseMuonEventFilter(), UseJetFilter=JetTagD3PDFlags.UseJetEventFilter(), JetCollections=selectedJetCollections, JetPtCut=JetTagD3PDFlags.FilterJetPtCut(), JetEtaCut=JetTagD3PDFlags.FilterJetEtaCut(), JetWithMuonPtCut=JetTagD3PDFlags.FilterJetWithMuonPtCut(), SoftMuonPtCut=JetTagD3PDFlags.FilterMuonInJetPtCut(), MinNumberOfJets=JetTagD3PDFlags.FilterMinNJets(), MinNumberOfJetsWithMuon=JetTagD3PDFlags.FilterMinNJetsMuon(), MuonAssocObjects=__muonAssocObjects, MuonCollections=JetTagD3PDFlags.FilterMuonCollections(), MuonPtCut=JetTagD3PDFlags.FilterMuonPtCut(), MuonEtaCut=JetTagD3PDFlags.FilterMuonEtaCut(), MuonIsTightCut=JetTagD3PDFlags.FilterMuonTightCut(), MinNumberOfMuons=JetTagD3PDFlags.FilterMinNumberOfMuons()) alg.filterSeq += JetTagD3PDEventFilter from EventCommonD3PDMaker.LBMetadataConfig import LBMetadataConfig alg.MetadataTools += [LBMetadataConfig()] return alg
def WPrimeEND3PD(alg=None, file='smwz.root', tuplename='physics', streamname='d3pdstream', doSoftQCD=False, **kw): # now configure the D3PD if not alg: alg = MSMgr.NewRootStream(StreamName=streamname, FileName=file, TreeName=tuplename) alg += EventInfoD3PDObject(**_args(10, 'EventInfo', kw)) # Electron/Photon blocks elInclude = [ 'Kinematics', 'Charge', 'Author', 'isEM', 'OQ', 'HadLeakage', 'Layer1Shape', 'Layer1ShapeExtra', 'Layer2Shape', 'Layer3Shape', 'Iso', 'IsoPtCorrected', 'ConvFlags', 'TrkMatch', 'Retaphi', 'Pointing', 'Samplings', 'ClusterKin', 'D3PD__egammaRawClusterAssociationTool', 'TrkInfo', 'Truth', 'Trk', 'TrkFitQuality', 'IDHits', 'TrackSummaryPID', 'Vertex', 'trackOldImpactpvunbiased', 'trackImpactpvunbiased', 'IsIso', 'MVAIso', 'PAU', 'PAUVariables', 'EFIndex', 'L1Index', 'trackImpactpv', 'trackPVPerigeeAssoc' ] alg += ElectronD3PDObject( **_args(0, 'Electron', kw, sgkey=kw.get('electronContainer', 'ElectronAODCollection'), include=elInclude)) alg += PhotonD3PDObject(**_args(0, 'Photon', kw, include=['ClusterKin'], exclude=['IsEMCuts', 'IsGoodOQCuts'])) # Jet blocks from JetTagD3PDMaker.JetTagD3PDMakerFlags import JetTagD3PDFlags alg += JetD3PDObject( **_args(1, 'AK4TopoEMJet', kw, sgkey='AntiKt4TopoEMJets', prefix='jet_AntiKt4TopoEM_', include=[], exclude=[ 'JESMoments', 'JVtx', 'OriginCorrection', 'El02Match', 'Mu02Match', 'L1Info', 'L2Info', 'EFInfo' ], allowMissing=True)) alg += JetD3PDObject( **_args(1, 'AK4LCTopoJet', kw, sgkey='AntiKt4LCTopoJets', prefix='jet_AntiKt4LCTopo_', include=[], exclude=[ 'JESMoments', 'JVtx', 'OriginCorrection', 'El02Match', 'Mu02Match', 'L1Info', 'L2Info', 'EFInfo' ], allowMissing=True)) # EventShape variables alg += EventShapeD3PDObject(**_args(0, 'rho', kw)) #MET metKeys = [ 'MET_LocHadTopo', 'MET_RefFinal', 'MET_RefEle', 'MET_RefFinal_em', 'MET_CellOut_Eflow', 'MET_MuonBoy', 'MET_RefMuons', 'MET_RefMuon', 'MET_Truth_NonInt', 'MET_RefJet', 'MET_SoftJets', 'MET_RefGamma', 'MET_RefTau', 'MET_CellOut', 'MET_RefFinal_STVF', 'MET_RefJet_JVF', 'MET_RefJet_JVFCut', 'MET_CellOut_Eflow_STVF', 'MET_CellOut_Eflow_JetArea', 'MET_CellOut_Eflow_JetAreaRhoEta5JVF' ] for key in metKeys: alg += MissingETD3PDObject(**_args( 4, key, kw, prefix=key, sgkey=key, #include=['MET_Phi','MET_Et','MET_SumEt','MET_etx','MET_ety','MissingETComposition'], exclude=[ 'MET_Calo', 'MET_Calo_Phi', 'MET_Calo_Et', 'MET_Calo_SumEt', 'MET_Calo_EMFracSET', 'MET_Calo_Samplings', 'MET_Calo_Regions' ], allowMissing=True)) #EMFrac for MET_LocHadTopo alg += TopoMETD3PDObject( **_args(-1, 'MET_LocHadTopo_SUMET_EMFrac', kw, prefix='MET_LocHadTopo_', name_prefix='MET_LocHadTopo_SUMET_EMFrac_', sgkey='MET_LocHadTopo', include=['MET_Calo_EMFracSET'], exclude=[], allowMissing=True)) alg += MissingETCompositionD3PDObject( **_args(4, "MissingETComposition", kw)) # Primary vertex block - May be missing in single-beam data. alg += PrimaryVertexD3PDObject(**_args(1, 'PrimaryVertex', kw, allowMissing=True, sgkey=D3PDMakerFlags.VertexSGKey(), prefix='vxp_')) # Trigger if D3PDMakerFlags.DoTrigger(): alg += WPrimeENTriggerBitsD3PDObject( **_args(10, 'WPrimeENTriggerBits', kw)) # Trigger Decision + metadata alg += TrigDecisionD3PDObject(**_args(10, 'TrigDecision', kw)) addTrigConfMetadata(alg) # Egamma alg += InitTrigD3PDObject(1) alg += EFElectronD3PDObject(1, name='trig_EF_el_', sgkey='HLT_egamma_Electrons,HLT_egamma', prefix='trig_EF_el_', allowMissing=True) alg += EFPhotonD3PDObject(1, name='trig_EF_ph_', sgkey='HLT_egamma_Photons,HLT_egamma', prefix='trig_EF_ph_', allowMissing=True) # Event metadata alg.MetadataTools += [LBMetadataConfig()] if D3PDMakerFlags.FilterCollCand(): from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg alg.filterSeq += CollisionFilterAlg(tuplename + '_CollCandFilter') return alg
QcdD3PDMakerFlags.doMoreTrig.set_Value_and_Lock(False) QcdD3PDMakerFlags.doTrack.set_Value_and_Lock(False) QcdD3PDMakerFlags.doMET.set_Value_and_Lock(False) QcdD3PDMakerFlags.doClusterHad.set_Value_and_Lock(False) QcdD3PDMakerFlags.doMuonSpShower2.set_Value_and_Lock(False) QcdD3PDMakerFlags.doRecJet.set_Value_and_Lock(False) QcdD3PDMakerFlags.doRecJetOnlyAdditional.set_Value_and_Lock(False) #QcdD3PDMakerFlags.useSPESD.set_Value_and_Lock(False) QcdD3PDMakerFlags.doTopoJet.set_Value_and_Lock(True) QcdD3PDMakerFlags.doLCTopoJet.set_Value_and_Lock(True) # https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/D3PDVariablesForPileup flags = QcdD3PDMakerFlags jetInclude = flags.jetInclude() #jetInclude+=['Samplings','BTagComponents','BTagDefault','BTag'] # for slim jetInclude += jetIncludes jetIncludeNew = flags.jetInclude() jetIncludeNew += ['BTagComponents', 'BTagDefault', 'BTag'] # for full jetExclude = flags.jetExclude() alg += JetD3PDObject(5, prefix='jet_AntiKt4TopoEM_', sgkey='AntiKt4TopoEMJets') alg += JetD3PDObject(5, prefix='jet_AntiKt4LCTopo_', sgkey='AntiKt4LCTopoJets') alg += JetD3PDObject(0, prefix='jet_AntiKt4Truth_', sgkey='AntiKt4TruthJets') from QcdD3PDMaker.QcdEventShapeD3PDObject import EventShapeD3PDObject alg += EventShapeD3PDObject(**_args(0, 'rho', kw)) #, include = jetInclude, exclude = jetExclude))
def SMWZD3PD (alg = None, file = 'smwz.root', tuplename = 'physics', streamname = 'd3pdstream', doSoftQCD = False, doThirdMuonChain = True, stdElectronContainer = D3PDMakerFlags.ElectronSGKey(), gsfElectronContainer = D3PDMakerFlags.GSFElectronSGKey(), muonContainer = 'None', # can be 'Muons' for third muon chain stacoMuonContainer = 'StacoMuonCollection', muidMuonContainer = 'MuidMuonCollection', caloMuonContainer = 'CaloMuonCollection', photonContainer = D3PDMakerFlags.PhotonSGKey(), tauContainer = D3PDMakerFlags.TauSGKey(), jetEM4Container = 'AntiKt4TopoEMJets', #Commented by Bertrand jetEM6Container = 'AntiKt6TopoEMJets', jetLC4Container = 'AntiKt4LCTopoJets', jetLC6Container = 'AntiKt6LCTopoJets', #jetEM4Container = 'AntiKt4TopoEMJetsReTagged', #jetEM6Container = 'AntiKt6TopoEMJetsReTagged', #jetLC4Container = 'AntiKt4LCTopoJetsReTagged', #jetLC6Container = 'AntiKt6LCTopoJetsReTagged', jetDetails = 3, # for the moment only level 2 and 3 are defined METDetails = 3, # for the moment only level 2 and 3 are defined **kw): if doThirdMuonChain and muonContainer == 'None': muonContainer = 'Muons' # define associations if not PhotonD3PDObject.allBlocknames().has_key('RecoveryMatch'): from PhotonD3PDMaker.PhotonRecoveryAssociation import PhotonRecoveryAssociation if (stdElectronContainer != 'None'): PhotonRecoveryAssoc = PhotonRecoveryAssociation(PhotonD3PDObject, 'ElectronContainer', stdElectronContainer, prefix = 'el_', blockname = 'RecoveryMatch', target = 'ph_ElectronRecovered_') # define track and cluster filters preseq = AlgSequence (D3PDMakerFlags.PreD3PDAlgSeqName()) if not hasattr( preseq, "GoodTracks" ): filter1 = makeTrackFilterAlg(TracksName = D3PDMakerFlags.TrackSGKey(), OutputTracksName='GoodTracks', ptCut=0.,nSCTPix=4) preseq += filter1 if not hasattr( preseq, "HighPtTracks" ): filter2 = makeTrackFilterAlg(TracksName = D3PDMakerFlags.TrackSGKey(), OutputTracksName='HighPtTracks', ptCut=4000.,nSCTPix=4) preseq += filter2 if not hasattr( preseq, "HighPtClusters" ): filter3 = makeClusterFilter(InputName = D3PDMakerFlags.ClusterSGKey(), OutputName = 'HighPtClusters', ptCut=10000.) preseq += filter3 if not hasattr( preseq, "HighPtEMClusters" ): filter4 = makeClusterFilter(InputName = D3PDMakerFlags.EMTopoClusterSGKey(), OutputName = 'HighPtEMClusters', ptCut=10000.) preseq += filter4 # perform recoil calculation import HadronicRecoil.Configurables as hrc preseq = hrc.add_hadronic_recoil_filters(preseq) # beam background stuff from RecBackgroundAlgs.RecBackgroundAlgsConf import BeamBackgroundFiller if not hasattr( preseq, "BeamBackgroundFiller" ): BeamBackgroundFiller=BeamBackgroundFiller() preseq += BeamBackgroundFiller # now configure the D3PD if not alg: alg = MSMgr.NewRootStream(StreamName = streamname, FileName = file, TreeName = tuplename) alg += EventInfoD3PDObject (**_args (10, 'EventInfo', kw)) alg += LArCollisionTimeD3PDObject (**_args (10, 'LArCollisionTime', kw)) from TriggerD3PDMaker.BunchStructureMetadata import addBunchStructureMetadata addBunchStructureMetadata (alg) from BackgroundD3PDMaker.BeamBackgroundD3PDObject import BeamBackgroundD3PDObject from BackgroundD3PDMaker.BackgroundWordD3PDObject import BackgroundWordD3PDObject alg += BackgroundWordD3PDObject (**_args(0, 'BkgWord', kw)) alg += BeamBackgroundD3PDObject(1) # Electron/Photon blocks if (stdElectronContainer != 'None'): alg += ElectronD3PDObject (**_args (10, 'Electron', kw, sgkey = stdElectronContainer)) if (gsfElectronContainer != 'None') and testSGKey ('ElectronContainer', gsfElectronContainer): alg += GSFElectronD3PDObject (**_args (10, 'GSFElectron', kw, sgkey = gsfElectronContainer, prefix = 'el_gsf_')) if (photonContainer != 'None'): alg += PhotonD3PDObject (**_args (10, 'Photon', kw, sgkey = photonContainer)) # Muon blocks ### Third muon chain variables! if (muonContainer != 'None'): alg += MuonD3PDObject (**_args (10, 'Muon', kw, sgkey=muonContainer, prefix='mu_', include = ["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex", "L1InfoIndex"], exclude = ["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"], allowMissing = True )) ### Third muon chain variables! if (muidMuonContainer != 'None'): alg += MuonD3PDObject (**_args (10, 'MuidMuon', kw, sgkey=muidMuonContainer, prefix='mu_muid_', include = ["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex", "L1InfoIndex"], exclude = ["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"], allowMissing = True )) if (stacoMuonContainer != 'None'): alg += MuonD3PDObject (**_args (10, 'StacoMuon', kw, sgkey=stacoMuonContainer, prefix='mu_staco_', include = ["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex", "L1InfoIndex"], exclude = ["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"], allowMissing = True )) if (caloMuonContainer != 'None'): alg += MuonD3PDObject (**_args (10, 'CaloMuon', kw, sgkey=caloMuonContainer, prefix='mu_calo_', include = ["MuonHitSummary", "Authors", "Likelihood", "Isolation", "CaloEnergyLoss", "Quality"] )) # Tau block if (tauContainer != 'None'): alg += TauD3PDObject (**_args ( 1, 'Tau', kw, sgkey = tauContainer)) # Jet blocks from JetTagD3PDMaker.JetTagD3PDMakerFlags import JetTagD3PDFlags from JetTagD3PDMaker.JetTagD3PDMakerKeys import JetTagD3PDKeys ## add MSV target to the jetd3pd object properties if not kw.has_key ('AK4TopoEMJet_'+JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName()+'_target'): kw['AK4TopoEMJet_'+JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName()+'_target']= JetTagD3PDKeys.MSVVtxInfoInJetGetterLabel() if not kw.has_key ('AK6TopoEMJet_'+JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName()+'_target'): kw['AK6TopoEMJet_'+JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName()+'_target']= JetTagD3PDKeys.MSVVtxInfoInJetGetterLabel() ## add track index for IPInfoPlus if not kw.has_key ('AK4TopoEMJet_'+JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()+'_target'): kw['AK4TopoEMJet_'+JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()+'_target']= "trk" if not kw.has_key ('AK6TopoEMJet_'+JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()+'_target'): kw['AK6TopoEMJet_'+JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()+'_target']= "trk" ## add track index for SVInfoPlus if not kw.has_key ('AK4TopoEMJet_'+JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName()+'_target'): kw['AK4TopoEMJet_'+JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName()+'_target']= "trk" if not kw.has_key ('AK6TopoEMJet_'+JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName()+'_target'): kw['AK6TopoEMJet_'+JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName()+'_target']= "trk" ## add track index for SV0InfoPlus if not kw.has_key ('AK4TopoEMJet_'+JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName()+'_target'): kw['AK4TopoEMJet_'+JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName()+'_target']= "trk" if not kw.has_key ('AK6TopoEMJet_'+JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName()+'_target'): kw['AK6TopoEMJet_'+JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName()+'_target']= "trk" ## add MSV target to the jetd3pd object properties if not kw.has_key ('AK4LCTopoJet_'+JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName()+'_target'): kw['AK4LCTopoJet_'+JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName()+'_target']= JetTagD3PDKeys.MSVVtxInfoInJetGetterLabel() if not kw.has_key ('AK6LCTopoJet_'+JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName()+'_target'): kw['AK6LCTopoJet_'+JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName()+'_target']= JetTagD3PDKeys.MSVVtxInfoInJetGetterLabel() ## add track index for IPInfoPlus if not kw.has_key ('AK4LCTopoJet_'+JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()+'_target'): kw['AK4LCTopoJet_'+JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()+'_target']= "trk" if not kw.has_key ('AK6LCTopoJet_'+JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()+'_target'): kw['AK6LCTopoJet_'+JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName()+'_target']= "trk" ## add track index for SVInfoPlus if not kw.has_key ('AK4LCTopoJet_'+JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName()+'_target'): kw['AK4LCTopoJet_'+JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName()+'_target']= "trk" if not kw.has_key ('AK6LCTopoJet_'+JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName()+'_target'): kw['AK6LCTopoJet_'+JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName()+'_target']= "trk" ## add track index for SV0InfoPlus if not kw.has_key ('AK4LCTopoJet_'+JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName()+'_target'): kw['AK4LCTopoJet_'+JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName()+'_target']= "trk" if not kw.has_key ('AK6LCTopoJet_'+JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName()+'_target'): kw['AK6LCTopoJet_'+JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName()+'_target']= "trk" if jetDetails == 3: jetInclude = JetTagD3PDFlags.StdInfoInclude()+[JetTagD3PDKeys.MultiSVInfoPlusBlockName()] jetInclude += [JetTagD3PDKeys.JetFitterCharmTagInfoBlockName(), JetTagD3PDKeys.JetFitterCharmInfoBaseBlockName()] else: jetInclude = [ JetTagD3PDKeys.BTagWeightsBlockName(), JetTagD3PDKeys.TruthInfoBlockName() ] if (jetEM4Container != 'None'): alg += JetD3PDObject (**_args ( 4, 'AK4TopoEMJet', kw, sgkey=jetEM4Container, prefix='jet_AntiKt4TopoEM_', include = jetInclude+['BeamBackground','ConstituentScale','TracksMoments'], JetVertexFraction_FromUD=False, JetVertexFraction_FillFullJVF=False, allowMissing = True)) if (jetEM6Container != 'None'): alg += JetD3PDObject (**_args ( 4, 'AK6TopoEMJet', kw, sgkey=jetEM6Container, prefix='jet_AntiKt6TopoEM_', include = jetInclude+['BeamBackground','ConstituentScale','TracksMoments'], JetVertexFraction_FromUD=False, JetVertexFraction_FillFullJVF=False, allowMissing = True)) if (jetLC4Container != 'None'): alg += JetD3PDObject (**_args ( 4, 'AK4LCTopoJet', kw, sgkey=jetLC4Container, prefix='jet_AntiKt4LCTopo_', include = jetInclude+['BeamBackground','ConstituentScale','TracksMoments'], JetVertexFraction_FromUD=False, JetVertexFraction_FillFullJVF=False, allowMissing = True)) if (jetLC6Container != 'None'): alg += JetD3PDObject (**_args ( 4, 'AK6LCTopoJet', kw, sgkey=jetLC6Container, prefix='jet_AntiKt6LCTopo_', include = jetInclude+['BeamBackground','ConstituentScale','TracksMoments'], JetVertexFraction_FromUD=False, JetVertexFraction_FillFullJVF=False, allowMissing = True)) ### add the MSV block MSVJetCollections = [] if (jetEM4Container != 'None'): MSVJetCollections += [jetEM4Container] if (jetEM6Container != 'None'): MSVJetCollections += [jetEM6Container] if (jetLC4Container != 'None'): MSVJetCollections += [jetLC4Container] if (jetLC6Container != 'None'): MSVJetCollections += [jetLC6Container] ### link multisv to tracks if not kw.has_key ('msvvtxinfo_JetTag_JetMultiSVVtxAssoc_target'): kw['msvvtxinfo_JetTag_JetMultiSVVtxAssoc_target']= "trk" from JetTagD3PDMaker.JetTagMSVVtxInJetD3PDObject import getJetTagMSVVtxInfoInJetD3PDObject alg += getJetTagMSVVtxInfoInJetD3PDObject(**_args(1,"msvvtxinfo", kw, jetCollections=MSVJetCollections) ) from TopInputsD3PDMaker.HforD3PDObject import HforD3PDObject alg += HforD3PDObject(**_args (0, 'HforInfo', kw)) # MET blocks # a whole mess to remove x,y components separately for all flavours if METDetails >= 3: alg += MissingETD3PDObject (**_args (10, 'MissingET', kw, exclude=['MET_Base', 'MET_Base0', 'MET_Truth_Int', 'MET_RefFinal_Comps','MET_Calib_Comps','MET_CellOut_Comps', 'MET_CorrTopo_Comps','MET_Cryo_Comps','MET_CryoCone_Comps', 'MET_Final_Comps','MET_LocHadTopo_Comps', 'MET_LocHadTopoObj_Comps','MET_Muid_Comps', 'MET_Muid_Spectro_Comps','MET_Muid_Track_Comps', 'MET_MuonBoy_Comps','MET_MuonBoy_Spectro_Comps', 'MET_MuonBoy_Track_Comps','MET_MuonMuid_Comps', 'MET_Muon_Comps','MET_Muon_Isol_Muid_Comps', 'MET_Muon_Isol_Staco_Comps','MET_Muon_NonIsol_Muid_Comps', 'MET_Muon_NonIsol_Staco_Comps','MET_Muon_Total_Muid_Comps', 'MET_Muon_Total_Staco_Comps','MET_RefEle_Comps', 'MET_RefEle_em_Comps','MET_RefGamma_Comps', 'MET_RefGamma_em_Comps','MET_RefJet_Comps', 'MET_RefJet_em_Comps','MET_RefMuon_Comps', 'MET_RefMuon_Muid_Comps','MET_RefMuon_Staco_Comps', 'MET_RefMuon_Track_Muid_Comps','MET_RefMuon_Track_Staco_Comps', 'MET_RefMuon_Track_em_Comps','MET_RefMuon_Track_Comps', 'MET_RefMuon_em_Comps','MET_RefTau_Comps', 'MET_RefTau_em_Comps','MET_SoftJets_Comps', 'MET_SoftJets_em_Comps','MET_Topo_Comps', 'MET_TopoObj_Comps','MET_Track_Comps','MET_Comps', 'MET_Track_Weights','MET_Cluster_Weights'], allowMissing=True)) elif METDetails > 0: alg += MissingETD3PDObject (**_args (10, 'MissingET', kw, exclude=['MET_Base','MET_Base0','MET_Truth', 'MET_CellOut_Comps','MET_CellOut_Regions', 'MET_CellOut_em_Comps','MET_CellOut_em_Regions', 'MET_CellOut_Eflow_Comps','MET_CellOut_Eflow_Regions', 'MET_Calib', 'MET_CorrTopo', 'MET_Cryo', 'MET_CryoCone', 'MET_Final', 'MET_LocHadTopo_Comps', 'MET_LocHadTopoObj', 'MET_Muid', 'MET_Muid_Spectro', 'MET_Muid_Track', 'MET_MuonBoy_Regions', 'MET_MuonBoy_Spectro', 'MET_MuonBoy_Track', 'MET_MuonMuid', 'MET_Muon', 'MET_Muon_Isol_Muid', 'MET_Muon_Isol_Staco', 'MET_Muon_NonIsol_Muid', 'MET_Muon_NonIsol_Staco', 'MET_Muon_Total_Muid', 'MET_Muon_Total_Staco', 'MET_RefEle_Comps','MET_RefEle_Regions', 'MET_RefEle_em_Comps','MET_RefEle_em_Regions', 'MET_RefGamma_Comps','MET_RefGamma_Regions', 'MET_RefGamma_em_Comps','MET_RefGamma_em_Regions', 'MET_RefJet_Comps','MET_RefJet_Regions', 'MET_RefJet_em_Comps','MET_RefJet_em_Regions', 'MET_RefMuon_Comps','MET_RefMuon_Regions', 'MET_RefMuon_Muid_Comps','MET_RefMuon_Muid_Regions', 'MET_RefMuon_Staco_Comps','MET_RefMuon_Staco_Regions', 'MET_RefMuon_Track_Muid_Comps','MET_RefMuon_Track_Muid_Regions', 'MET_RefMuon_Track_Staco_Comps','MET_RefMuon_Track_Staco_Regions', 'MET_RefMuon_Track_em_Comps','MET_RefMuon_Track_em_Regions', 'MET_RefMuon_Track_Comps','MET_RefMuon_Track_Regions', 'MET_RefMuon_em_Comps','MET_RefMuon_em_Regions', 'MET_RefTau_Comps','MET_RefTau_Regions', 'MET_RefTau_em_Comps','MET_RefTau_em_Regions', 'MET_SoftJets_Comps','MET_SoftJets_Regions', 'MET_SoftJets_em_Comps','MET_SoftJets_em_Regions', 'MET_Topo', 'MET_TopoObj_Comps','MET_TopoObj_Regions', 'MET_Track_Comps','MET_Track_Regions', 'MET_Track_Weights','MET_Cluster_Weights', 'MET_Comps' ], allowMissing=True )) if METDetails > 0: add_met (alg) # track and cluster blocks # ... all clusters, very low LOD alg += ClusterD3PDObject (**_args ( 0, 'Clusters1', kw, exclude='SamplingBasics')) # ... higher LOD for pt>10 GeV alg += ClusterD3PDObject (**_args ( 2, 'Clusters2', kw, sgkey = 'HighPtClusters', prefix = 'clpt10_')) alg += ClusterD3PDObject (**_args ( 3, 'Clusters3', kw, sgkey = 'HighPtEMClusters', prefix = 'emclpt10_')) from TrackD3PDMaker.TrackD3PDObject import TrackD3PDObject # ... good tracks only (nSCT>3; no pt cut) # turn on detailed track info if writing SoftQCD version of D3PD if doSoftQCD : from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags as softQcdFlags softQcdFlags.doTruth = True softQcdFlags.storeDetailedTruth = False softQcdFlags.storeDiagonalCovarianceAsErrors = True softQcdFlags.storeHitTruthMatching = True softQcdFlags.storePixelHitsOnTrack = False softQcdFlags.storePixelHolesOnTrack = False softQcdFlags.storePixelOutliersOnTrack = False softQcdFlags.storeSCTHitsOnTrack = False softQcdFlags.storeSCTHolesOnTrack = False softQcdFlags.storeSCTOutliersOnTrack = False softQcdFlags.storeTRTHitsOnTrack = False softQcdFlags.storeTRTHolesOnTrack = False softQcdFlags.storeTRTOutliersOnTrack = False softQcdFlags.storeTrackFitQuality = True softQcdFlags.storeTrackInfo = True softQcdFlags.storeTrackMomentum = True softQcdFlags.storeTrackPredictionAtBLayer = True softQcdFlags.storeTrackSummary = True softQcdFlags.trackParametersAtBeamSpotLevelOfDetails = 0 softQcdFlags.trackParametersAtGlobalPerigeeLevelOfDetails = 2 softQcdFlags.trackParametersAtPrimaryVertexLevelOfDetails = 2 SoftQCDTrackParticleD3PDObject = TrackD3PDObject(_label='trk', _prefix='trk_', _sgkey='GoodTracks', typeName='Rec::TrackParticleContainer', truthMapKey='TrackParticleTruthCollection', SGKeyForTruth=D3PDMakerFlags.TrackSGKey(), flags=softQcdFlags) alg += SoftQCDTrackParticleD3PDObject(**_args ( 3, 'Tracks1', kw, sgkey = 'GoodTracks', label = 'trk', prefix = 'trk_')) else : # ... use standard level of track info for 'GoodTracks' alg += TrackParticleD3PDObject (**_args ( 3, 'Tracks1', kw, sgkey = 'GoodTracks', label = 'trk', prefix = 'trk_')) # ... high-pt tracks (nSCT>3; pt>5 GeV) from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags as highPtFlags highPtFlags.doTruth = True highPtFlags.storeDiagonalCovarianceAsErrors = True highPtFlags.storeHitTruthMatching = True highPtFlags.storePixelHitsOnTrack = False highPtFlags.storePixelHolesOnTrack = False highPtFlags.storePixelOutliersOnTrack = False highPtFlags.storeSCTHitsOnTrack = False highPtFlags.storeSCTHolesOnTrack = False highPtFlags.storeSCTOutliersOnTrack = False highPtFlags.storeTRTHitsOnTrack = False highPtFlags.storeTRTHolesOnTrack = False highPtFlags.storeTRTOutliersOnTrack = False highPtFlags.storeTrackFitQuality = True highPtFlags.storeTrackMomentum = True highPtFlags.storeTrackSummary = True highPtFlags.storeTrackSummary.IDOutliers = True highPtFlags.storeTrackSummary.PixelInfoPlus = True highPtFlags.storeTrackSummary.SCTInfoPlus = True highPtFlags.storeTrackSummary.TRTInfoPlus = True highPtFlags.storeTrackSummary.InfoPlus = True highPtFlags.trackParametersAtBeamSpotLevelOfDetails = 0 highPtFlags.trackParametersAtGlobalPerigeeLevelOfDetails = 2 highPtFlags.trackParametersAtPrimaryVertexLevelOfDetails = 3 HighPtTrackParticleD3PDObject = TrackD3PDObject(_label='trkpt4', _prefix='trkpt4_', _sgkey='HighPtTracks', typeName='Rec::TrackParticleContainer', truthMapKey='TrackParticleTruthCollection', SGKeyForTruth=D3PDMakerFlags.TrackSGKey(), flags=highPtFlags) alg += HighPtTrackParticleD3PDObject(**_args ( 3, 'Tracks2', kw, sgkey = 'HighPtTracks', label = 'trkpt4', prefix = 'trkpt4_')) # Primary vertex block - May be missing in single-beam data. alg += PrimaryVertexD3PDObject (**_args (1, 'PrimaryVertex', kw, allowMissing = True, sgkey = D3PDMakerFlags.VertexSGKey(), prefix = 'vxp_')) # MBTS alg += MBTSD3PDObject (**_args (10, 'MBTS', kw)) alg += MBTSTimeD3PDObject (**_args (10, 'MBTSTime', kw)) alg += MBTSTriggerBitsD3PDObject (**_args (10, 'MBTSTriggerBits', kw)) #alg += CollisionDecisionD3PDObject(**_args (10, 'CollisionDecision', kw)) ### EventShape variables Bertrand alg += EventShapeD3PDObject(**_args(0, 'rho', kw)) # Truth if rec.doTruth(): from TruthD3PDMaker.TruthParticleD3PDObject import TruthParticleD3PDObject alg += TruthParticleD3PDObject(**_args ( 1, 'TruthParticle', kw)) from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject alg += TruthMuonD3PDObject (**_args ( 2, 'TruthMuon', kw)) from AthenaCommon.AppMgr import ToolSvc from TruthD3PDAnalysis.TruthD3PDAnalysisConf import D3PD__GenObjectsFilterTool # ... remove empty GenEvents smwzGenEvtFilterTool = D3PD__GenObjectsFilterTool( "smwzGenEvtFilterTool" ) ToolSvc += smwzGenEvtFilterTool smwzGenEvtFilterTool.RemoveDummyEvents = True smwzGenEvtFilterTool.RemoveInTimePileUp = True smwzGenEvtFilterTool.Remove2BCPileUp = True smwzGenEvtFilterTool.Remove800nsPileUp = True smwzGenEvtFilterTool.RemoveCavernBkg = True smwzGenEvtFilterTool.RemoveEmptyEvents = True from TruthD3PDMaker.GenEventD3PDObject import GenEventD3PDObject alg += GenEventD3PDObject (**_args ( 0, 'GenEvent', kw, filter = smwzGenEvtFilterTool )) # ... TruthJets if not testSGKey ('JetCollection', 'AntiKt6TruthJets'): make_StandardJetGetter('AntiKt', 0.6, 'Truth') alg += JetD3PDObject (**_args ( 1, 'AK4TruthJet', kw, sgkey='AntiKt4TruthJets',prefix='jet_AntiKt4Truth_', allowMissing = True)) alg += JetD3PDObject (**_args ( 1, 'AK6TruthJet', kw, sgkey='AntiKt6TruthJets', prefix='jet_AntiKt6Truth_', allowMissing = True)) alg += JetD3PDObject (**_args ( 1, 'AK4TruthJetALL', kw, sgkey='AntiKt4TruthJets_ALL', prefix='jet_AntiKt4TruthALL_', allowMissing = True)) alg += JetD3PDObject (**_args ( 1, 'AK6TruthJetALL', kw, sgkey='AntiKt6TruthJets_ALL', prefix='jet_AntiKt6TruthALL_', allowMissing = True)) alg += JetD3PDObject (**_args ( 1, 'AK4TruthJetWZ', kw, sgkey='AntiKt4TruthJets_WZ', prefix='jet_AntiKt4TruthWZ_', allowMissing = True)) alg += JetD3PDObject (**_args ( 1, 'AK6TruthJetWZ', kw, sgkey='AntiKt6TruthJets_WZ', prefix='jet_AntiKt6TruthWZ_', allowMissing = True)) # ... heavy flavor truth information from AthenaCommon.AppMgr import ToolSvc from TruthD3PDAnalysis.TruthD3PDAnalysisConf import D3PD__GenObjectsFilterTool smwzhfGenVtxFilterTool = D3PD__GenObjectsFilterTool( "SMWZHFGenVtxFilterTool" ) ToolSvc += smwzhfGenVtxFilterTool smwzhfGenVtxFilterTool.RemoveInTimePileUp = False smwzhfGenVtxFilterTool.Remove2BCPileUp = True smwzhfGenVtxFilterTool.Remove800nsPileUp = True smwzhfGenVtxFilterTool.RemoveCavernBkg = True smwzhfGenVtxFilterTool.RemoveEmptyEvents = True smwzhfGenVtxFilterTool.RemoveDummyEvents = True smwzhfGenVtxFilterTool.RemoveUnrequestedParticles=True smwzhfGenVtxFilterTool.KeepBCHadrons=True from TruthD3PDMaker.GenVertexD3PDObject import GenVertexD3PDObject alg += GenVertexD3PDObject( **_args(0, "hfgenvertex", kw, prefix='mchfvtx_', filter = smwzhfGenVtxFilterTool ) ) smwzhfGenPartFilterTool = D3PD__GenObjectsFilterTool( "SMWZHFGenPartFilterTool" ) ToolSvc += smwzhfGenPartFilterTool smwzhfGenPartFilterTool.RemoveInTimePileUp = False smwzhfGenPartFilterTool.Remove2BCPileUp = True smwzhfGenPartFilterTool.Remove800nsPileUp = True smwzhfGenPartFilterTool.RemoveCavernBkg = True smwzhfGenPartFilterTool.RemoveEmptyEvents = True smwzhfGenPartFilterTool.RemoveDummyEvents = True smwzhfGenPartFilterTool.RemoveUnrequestedParticles=True smwzhfGenPartFilterTool.KeepBCQuarks=True smwzhfGenPartFilterTool.KeepBCQuarkAncestors=True smwzhfGenPartFilterTool.KeepBCHadrons=True smwzhfGenPartFilterTool.KeepBCHadronDecayChain=True smwzhfGenPartFilterTool.BCHadronsDescendantsPtCut=200 smwzhfGenPartFilterTool.BCHadronsDescendantsBarcodeCut=300000 smwzhfGenPartFilterTool.BCHadronsDescendantsEtaCut=5 from TruthD3PDMaker.GenParticleD3PDObject import GenParticleD3PDObject alg += GenParticleD3PDObject( **_args(10, "hfgenparticle", kw, prefix='mchfpart_', filter = smwzhfGenPartFilterTool, GenParticle_WriteMotherType=False, GenParticle_WriteMotherBarcode=False ) ) # ... leptonic W/Z truth information smwzlepwzGenPartFilterTool = D3PD__GenObjectsFilterTool( "SMWZLepWZGenPartFilterTool" ) ToolSvc += smwzlepwzGenPartFilterTool smwzlepwzGenPartFilterTool.RemoveInTimePileUp = True smwzlepwzGenPartFilterTool.Remove2BCPileUp = True smwzlepwzGenPartFilterTool.Remove800nsPileUp = True smwzlepwzGenPartFilterTool.RemoveCavernBkg = True smwzlepwzGenPartFilterTool.RemoveEmptyEvents = True smwzlepwzGenPartFilterTool.RemoveDummyEvents = True smwzlepwzGenPartFilterTool.RemoveUnrequestedParticles=True smwzlepwzGenPartFilterTool.KeepLeptonicWZBosons=True smwzlepwzGenPartFilterTool.KeepLeptonicWZBosonDecayChains=True smwzlepwzGenPartFilterTool.KeepLeptonicWZBosonsParents=True from TruthD3PDMaker.GenParticleD3PDObject import GenParticleD3PDObject alg += GenParticleD3PDObject( **_args(10, "lepwzgenparticle", kw, prefix='mclepwzpart_', filter = smwzlepwzGenPartFilterTool, label = "LepWZTruthD3PDObject", exclude = ["GenPartProdVertexAssoc","GenPartDecayVertexAssoc"], GenParticle_WriteMotherType=False, GenParticle_WriteMotherBarcode=False, GenPartMotherAssoc_target="LepWZTruthD3PDObject", GenPartChildAssoc_target="LepWZTruthD3PDObject" ) ) if not rec.doTruth(): alg += BeamSpotD3PDObject(10) # Trigger if D3PDMakerFlags.DoTrigger(): alg += SMWZTriggerBitsD3PDObject (**_args (10, 'SMWZTriggerBits', kw)) # Trigger Decision + metadata alg += TrigDecisionD3PDObject (**_args(10, 'TrigDecision', kw)) addTrigConfMetadata(alg) # Bunch group info alg += BGCodeD3PDObject (**_args (2, 'BGCode', kw)) # Egamma and Mu TrigEgammaD3PDObjects (alg, 1) TrigMuonD3PDObjects( alg, 1) # MET TrigMETD3PDObjects (alg, 2) # The BJet information: TrigBJetD3PDObjects(alg,10, False, False, True, True, True) # Event metadata alg.MetadataTools += [LBMetadataConfig()] if D3PDMakerFlags.FilterCollCand(): from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg alg.filterSeq += CollisionFilterAlg (tuplename + '_CollCandFilter') return alg
def ZPrimeEED3PD(alg=None, file='smwz.root', tuplename='physics', streamname='d3pdstream', doSoftQCD=False, **kw): # now configure the D3PD if not alg: alg = MSMgr.NewRootStream(StreamName=streamname, FileName=file, TreeName=tuplename) alg += EventInfoD3PDObject(**_args(10, 'EventInfo', kw)) alg += LArCollisionTimeD3PDObject(**_args(10, 'LArCollisionTime', kw)) # Electron/Photon blocks elInclude = [ 'HadLeakage', 'Layer1Shape', 'Layer1ShapeExtra', 'Layer2Shape', 'Layer3Shape', 'Iso', 'IsoPtCorrected', 'ConvFlags', 'Conversion', 'TrkMatch', 'Retaphi', 'Rings', 'ElecDiscrim', 'Pointing', 'Samplings', 'ClusterKin', 'FwdEVars', 'D3PD__egammaRawClusterAssociationTool', 'RawSamplings', 'RawClusterKin', 'TrkInfo', 'Trk', 'TrkFitQuality', 'IDHits', 'TrackSummaryPID', 'Vertex', 'trackImpactbeam', 'trackImpactSigbeam', 'trackImpactpv', 'trackImpactSigpv', 'trackOldImpactpvunbiased', 'trackImpactpvunbiased', 'UDLayer1Shape', 'UDShowerDepth', 'IsIso', 'MVAIso', 'JetMatch', 'JetKinematics', 'PAU', 'PAUVariables', 'EFIndex', 'L2Index', 'L1Index', ] elExclude = [] alg += ElectronD3PDObject( **_args(0, 'Electron', kw, sgkey=kw.get('electronContainer', 'ElectronAODCollection'), include=elInclude, exclude=elExclude)) phInclude = [ 'HadLeakage', 'Layer1Shape', 'Layer1ShapeExtra', 'Layer2Shape', 'Iso', 'IsoPtCorrected', 'Conversion', 'Retaphi', 'TopoClusterIsolationCones', 'Pointing', 'ClusterKin', 'Samplings', 'UDTopoCones', 'CorrIso', 'ConvIP', 'TopoMatch', 'TopoKinematics', 'TopoEMMatch', 'TopoEMKinematics' ] phExclude = [] alg += PhotonD3PDObject( **_args(0, 'Photon', kw, sgkey=kw.get('photonContainer', 'PhotonAODCollection'), include=phInclude, exclude=phExclude)) # Muon blocks muInclude = ['AcceptMethods'] muExclude = [ 'TrkInfo', 'EFCBInfoIndex', 'EFCBInfo', 'EFMGInfo', 'EFMEInfo', 'L2CBInfoIndex', 'L2CBInfo', 'L1InfoIndex', 'L1Info', 'AllAuthor', 'SelectionFlagging', 'CBTrackDetails', 'MGTrackDetails' ] #Muid if cfgKeyStore.isInInput("Analysis::MuonContainer", "MuidMuonCollection"): alg += MuonD3PDObject(**_args(0, 'MuidMuon', kw, sgkey='MuidMuonCollection', prefix='mu_muid_', include=muInclude, exclude=muExclude, allowMissing=True)) #Staco if cfgKeyStore.isInInput("Analysis::MuonContainer", "StacoMuonCollection"): alg += MuonD3PDObject(**_args(0, 'StacoMuon', kw, sgkey='StacoMuonCollection', prefix='mu_staco_', include=muInclude, exclude=muExclude, allowMissing=True)) #Third chain if cfgKeyStore.isInInput("Analysis::MuonContainer", "Muons"): alg += MuonD3PDObject(**_args(0, 'Muons', kw, sgkey='Muons', prefix='mu_', include=muInclude, exclude=muExclude, allowMissing=True)) # Jet blocks from JetTagD3PDMaker.JetTagD3PDMakerFlags import JetTagD3PDFlags alg += JetD3PDObject(**_args(1, 'AK4TopoEMJet', kw, sgkey='AntiKt4TopoEMJets', prefix='jet_AntiKt4TopoEM_', include=[], exclude=[ 'JESMoments', 'JVtx', 'El02Match', 'Mu02Match', 'L1Info', 'L2Info', 'EFInfo' ], allowMissing=True)) # EventShape variables alg += EventShapeD3PDObject(**_args(0, 'rho', kw)) #MET metKeys = [ 'MET_LocHadTopo', 'MET_RefFinal', 'MET_RefEle', 'MET_RefMuon', 'MET_RefMuon_Staco', 'MET_RefMuon_Muid', 'MET_CorrTopo', 'MET_RefFinal_em', 'MET_Topo', 'MET_Calib', 'MET_CellOut_Eflow_Muons', 'MET_CellOut_Eflow', 'MET_CellOut_Eflow_Muid', 'MET_MuonBoy', 'MET_Muons', 'MET_Muid', 'MET_RefMuons', 'MET_RefFinal_STVF', 'MET_RefJet_JVF', 'MET_RefJet_JVFCut', 'MET_CellOut_Eflow_STVF', 'MET_CellOut_Eflow_JetArea' ] for key in metKeys: alg += MissingETD3PDObject( **_args(-1, key, kw, prefix=key, sgkey=key, include=['MET_Phi', 'MET_Et', 'MET_SumEt'], exclude=[], allowMissing=True)) #EMFrac for MET_LocHadTopo alg += TopoMETD3PDObject( **_args(-1, 'MET_LocHadTopo_SUMET_EMFrac', kw, prefix='MET_LocHadTopo_', name_prefix='MET_LocHadTopo_SUMET_EMFrac_', sgkey='MET_LocHadTopo', include=['MET_Calo_EMFracSET'], exclude=[], allowMissing=True)) # Primary vertex block - May be missing in single-beam data. alg += PrimaryVertexD3PDObject(**_args(1, 'PrimaryVertex', kw, allowMissing=True, sgkey=D3PDMakerFlags.VertexSGKey(), prefix='vxp_')) # Truth if rec.doTruth(): from TruthD3PDMaker.TruthParticleD3PDObject import TruthParticleD3PDObject from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject alg += TruthMuonD3PDObject(**_args(2, 'TruthMuon', kw)) alg += GenEventD3PDObject(**_args(1, 'GenEvent', kw)) alg += TruthParticleD3PDObject(**_args(1, 'TruthParticle', kw)) # TruthJets alg += JetD3PDObject(**_args(1, 'AK4TruthJet', kw, sgkey='AntiKt4TruthJets', prefix='jet_AntiKt4Truth_', allowMissing=True)) if not rec.doTruth(): alg += BeamSpotD3PDObject(10) # Trigger if D3PDMakerFlags.DoTrigger(): alg += ZPrimeEETriggerBitsD3PDObject( **_args(10, 'ZPrimeEETriggerBits', kw)) # Trigger Decision + metadata alg += TrigDecisionD3PDObject(**_args(10, 'TrigDecision', kw)) addTrigConfMetadata(alg) # Egamma alg += InitTrigD3PDObject(1) alg += EmTauROID3PDObject(1, prefix="trig_L1_emtau_", exclude=['ThrInfo']) alg += TrigElectronD3PDObject( 1, name='trig_L2_el_', prefix='trig_L2_el_', sgkey='HLT_L2ElectronFex,HLT_L2IDCaloFex', allowMissing=True) alg += TrigPhotonD3PDObject(1, name='trig_L2_ph_', prefix='trig_L2_ph_') alg += EFElectronD3PDObject(1, name='trig_EF_el_', sgkey='HLT_egamma_Electrons,HLT_egamma', prefix='trig_EF_el_', allowMissing=True) alg += EFPhotonD3PDObject(1, name='trig_EF_ph_', sgkey='HLT_egamma_Photons,HLT_egamma', prefix='trig_EF_ph_', allowMissing=True) # Event metadata alg.MetadataTools += [LBMetadataConfig()] if D3PDMakerFlags.FilterCollCand(): from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg alg.filterSeq += CollisionFilterAlg(tuplename + '_CollCandFilter') return alg
def ZPrimeMMD3PD(alg=None, file='smwz.root', tuplename='physics', streamname='d3pdstream', doSoftQCD=False, doThirdMuonChain=True, **kw): # define associations if not PhotonD3PDObject.allBlocknames().has_key('RecoveryMatch'): from PhotonD3PDMaker.PhotonRecoveryAssociation import PhotonRecoveryAssociation PhotonRecoveryAssoc = PhotonRecoveryAssociation( PhotonD3PDObject, 'ElectronContainer', D3PDMakerFlags.ElectronSGKey(), prefix='el_', blockname='RecoveryMatch', target='ph_ElectronRecovered_') # define track and cluster filters preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()) if not hasattr(preseq, "GoodTracks"): filter1 = makeTrackFilterAlg(TracksName=D3PDMakerFlags.TrackSGKey(), OutputTracksName='GoodTracks', ptCut=0., nSCTPix=4) preseq += filter1 if not hasattr(preseq, "HighPtTracks"): filter2 = makeTrackFilterAlg(TracksName=D3PDMakerFlags.TrackSGKey(), OutputTracksName='HighPtTracks', ptCut=4000., nSCTPix=4) preseq += filter2 if not hasattr(preseq, "HighPtClusters"): filter3 = makeClusterFilter(InputName=D3PDMakerFlags.ClusterSGKey(), OutputName='HighPtClusters', ptCut=10000.) preseq += filter3 if not hasattr(preseq, "HighPtEMClusters"): filter4 = makeClusterFilter( InputName=D3PDMakerFlags.EMTopoClusterSGKey(), OutputName='HighPtEMClusters', ptCut=10000.) preseq += filter4 # perform recoil calculation import HadronicRecoil.Configurables as hrc preseq = hrc.add_hadronic_recoil_filters(preseq) # now configure the D3PD if not alg: alg = MSMgr.NewRootStream(StreamName=streamname, FileName=file, TreeName=tuplename) alg += EventInfoD3PDObject(**_args(10, 'EventInfo', kw)) alg += LArCollisionTimeD3PDObject(**_args(10, 'LArCollisionTime', kw)) from TriggerD3PDMaker.BunchStructureMetadata import addBunchStructureMetadata addBunchStructureMetadata(alg) # Electron/Photon blocks alg += ElectronD3PDObject(**_args(10, 'Electron', kw)) if testSGKey('ElectronContainer', D3PDMakerFlags.GSFElectronSGKey()): alg += GSFElectronD3PDObject( **_args(10, 'GSFElectron', kw, sgkey=D3PDMakerFlags.GSFElectronSGKey(), prefix='el_gsf_')) alg += PhotonD3PDObject(**_args(10, 'Photon', kw)) # Muon blocks ### add the scattering significance filler - to be removed when added in the MuonD3PDMaker if not MuonD3PDObject.allBlocknames().has_key( "MuonScatteringAngleSignificance"): from AthenaCommon.AppMgr import ToolSvc muonScatteringSigTool = None if hasattr(ToolSvc, "MuonScatteringSigTool"): muonScatteringSigTool = ToolSvc.MuonScatteringSigTool from JetTagD3PDMaker import MuonScatteringAngleSignificanceFillerTool MuonD3PDObject.defineBlock(100, "MuonScatteringAngleSignificance", MuonScatteringAngleSignificanceFillerTool, ScatteringSigTool=muonScatteringSigTool) ### Third muon chain variables! if doThirdMuonChain: if cfgKeyStore.isInInput("Analysis::MuonContainer", "Muons"): alg += MuonD3PDObject(**_args( 10, 'Muon', kw, sgkey='Muons', prefix='mu_', include=[ "EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex", "L1InfoIndex", "MuonScatteringAngleSignificance" ], exclude=[ "EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info" ], allowMissing=True)) ### Third muon chain variables! if cfgKeyStore.isInInput("Analysis::MuonContainer", "MuidMuonCollection"): alg += MuonD3PDObject(**_args( 10, 'MuidMuon', kw, sgkey='MuidMuonCollection', prefix='mu_muid_', include=[ "EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex", "L1InfoIndex", "MuonScatteringAngleSignificance" ], exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"], allowMissing=True)) if cfgKeyStore.isInInput("Analysis::MuonContainer", "StacoMuonCollection"): alg += MuonD3PDObject(**_args( 10, 'StacoMuon', kw, sgkey='StacoMuonCollection', prefix='mu_staco_', include=[ "EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex", "L1InfoIndex", "MuonScatteringAngleSignificance" ], exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"], allowMissing=True)) if cfgKeyStore.isInInput("Analysis::MuonContainer", "CaloMuonCollection"): alg += MuonD3PDObject( **_args(0, 'CaloMuon', kw, sgkey='CaloMuonCollection', prefix='mu_calo_', include=[ "MuonHitSummary", "Authors", "Likelihood", "Isolation", "CaloEnergyLoss", "Quality" ])) # Tau block alg += TauD3PDObject(**_args(1, 'Tau', kw)) # Jet blocks from JetTagD3PDMaker.JetTagD3PDMakerFlags import JetTagD3PDFlags from JetTagD3PDMaker.JetTagD3PDMakerKeys import JetTagD3PDKeys ## add MSV target to the jetd3pd object properties if not kw.has_key('AK4TopoEMJet_' + JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName() + '_target'): kw['AK4TopoEMJet_' + JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName() + '_target'] = JetTagD3PDKeys.MSVVtxInfoInJetGetterLabel() if not kw.has_key('AK6TopoEMJet_' + JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName() + '_target'): kw['AK6TopoEMJet_' + JetTagD3PDKeys.MultiSVInfoPlusMSVVtxAssocBlockName() + '_target'] = JetTagD3PDKeys.MSVVtxInfoInJetGetterLabel() ## add track index for IPInfoPlus if not kw.has_key('AK4TopoEMJet_' + JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName() + '_target'): kw['AK4TopoEMJet_' + JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName() + '_target'] = "trk" if not kw.has_key('AK6TopoEMJet_' + JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName() + '_target'): kw['AK6TopoEMJet_' + JetTagD3PDKeys.IPInfoPlusTrackAssocBlockName() + '_target'] = "trk" ## add track index for SVInfoPlus if not kw.has_key('AK4TopoEMJet_' + JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName() + '_target'): kw['AK4TopoEMJet_' + JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName() + '_target'] = "trk" if not kw.has_key('AK6TopoEMJet_' + JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName() + '_target'): kw['AK6TopoEMJet_' + JetTagD3PDKeys.SVInfoPlusTrackAssocBlockName() + '_target'] = "trk" ## add track index for SV0InfoPlus if not kw.has_key('AK4TopoEMJet_' + JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName() + '_target'): kw['AK4TopoEMJet_' + JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName() + '_target'] = "trk" if not kw.has_key('AK6TopoEMJet_' + JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName() + '_target'): kw['AK6TopoEMJet_' + JetTagD3PDKeys.SV0InfoPlusTrackAssocBlockName() + '_target'] = "trk" alg += JetD3PDObject(**_args(3, 'AK4TopoEMJet', kw, sgkey='AntiKt4TopoEMJets', prefix='jet_AntiKt4TopoEM_', include=JetTagD3PDFlags.StdInfoInclude() + [JetTagD3PDKeys.MultiSVInfoPlusBlockName()], JetVertexFraction_FromUD=True, JetVertexFraction_FillFullJVF=True, allowMissing=True)) alg += JetD3PDObject(**_args(3, 'AK6TopoEMJet', kw, sgkey='AntiKt6TopoEMJets', prefix='jet_AntiKt6TopoEM_', include=JetTagD3PDFlags.StdInfoInclude() + [JetTagD3PDKeys.MultiSVInfoPlusBlockName()], JetVertexFraction_FromUD=True, JetVertexFraction_FillFullJVF=True, allowMissing=True)) alg += JetD3PDObject(**_args(3, 'AK4LCTopoJet', kw, sgkey='AntiKt4LCTopoJets', prefix='jet_AntiKt4LCTopo_', JetVertexFraction_FromUD=True, JetVertexFraction_FillFullJVF=True, allowMissing=True)) alg += JetD3PDObject(**_args(3, 'AK6LCTopoJet', kw, sgkey='AntiKt6LCTopoJets', prefix='jet_AntiKt6LCTopo_', JetVertexFraction_FromUD=True, JetVertexFraction_FillFullJVF=True, allowMissing=True)) ### add the MSV block MSVJetCollections = ['AntiKt4TopoEMJets', 'AntiKt6TopoEMJets'] ### link multisv to tracks if not kw.has_key('msvvtxinfo_JetTag_JetMultiSVVtxAssoc_target'): kw['msvvtxinfo_JetTag_JetMultiSVVtxAssoc_target'] = "trk" from JetTagD3PDMaker.JetTagMSVVtxInJetD3PDObject import getJetTagMSVVtxInfoInJetD3PDObject alg += getJetTagMSVVtxInfoInJetD3PDObject( **_args(1, "msvvtxinfo", kw, jetCollections=MSVJetCollections)) from TopInputsD3PDMaker.HforD3PDObject import HforD3PDObject alg += HforD3PDObject(**_args(0, 'HforInfo', kw)) # EventShape variables alg += EventShapeD3PDObject(**_args(0, 'rho', kw)) # MET blocks # a whole mess to remove x,y components separately for all flavours alg += MissingETD3PDObject(**_args( 10, 'MissingET', kw, exclude=[ 'MET_Base', 'MET_Base0', 'MET_Truth_Int', 'MET_RefFinal_Comps', 'MET_Calib_Comps', 'MET_CellOut_Comps', 'MET_CorrTopo_Comps', 'MET_Cryo_Comps', 'MET_CryoCone_Comps', 'MET_Final_Comps', 'MET_LocHadTopo_Comps', 'MET_LocHadTopoObj_Comps', 'MET_Muid_Comps', 'MET_Muid_Spectro_Comps', 'MET_Muid_Track_Comps', 'MET_MuonBoy_Comps', 'MET_MuonBoy_Spectro_Comps', 'MET_MuonBoy_Track_Comps', 'MET_MuonMuid_Comps', 'MET_Muon_Comps', 'MET_Muon_Isol_Muid_Comps', 'MET_Muon_Isol_Staco_Comps', 'MET_Muon_NonIsol_Muid_Comps', 'MET_Muon_NonIsol_Staco_Comps', 'MET_Muon_Total_Muid_Comps', 'MET_Muon_Total_Staco_Comps', 'MET_RefEle_Comps', 'MET_RefEle_em_Comps', 'MET_RefGamma_Comps', 'MET_RefGamma_em_Comps', 'MET_RefJet_Comps', 'MET_RefJet_em_Comps', 'MET_RefMuon_Comps', 'MET_RefMuon_Muid_Comps', 'MET_RefMuon_Staco_Comps', 'MET_RefMuon_Track_Muid_Comps', 'MET_RefMuon_Track_Staco_Comps', 'MET_RefMuon_Track_em_Comps', 'MET_RefMuon_Track_Comps', 'MET_RefMuon_em_Comps', 'MET_RefTau_Comps', 'MET_RefTau_em_Comps', 'MET_SoftJets_Comps', 'MET_SoftJets_em_Comps', 'MET_Topo_Comps', 'MET_TopoObj_Comps', 'MET_Track_Comps', 'MET_Comps', 'MET_Track_Weights', 'MET_Cluster_Weights' 'MET_RefFinal_STVF', 'MET_RefJet_JVF', 'MET_RefJet_JVFCut', 'MET_CellOut_Eflow_STVF', 'MET_CellOut_Eflow_JetArea' ], allowMissing=True)) # ... DR = 0.15 alg += MissingETD3PDObject(0, sgkey="RoughRecoil_15", prefix="hr_roughRecoil_15", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="ueCorrection_15", prefix="hr_ueCorrection_15", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="RefinedRecoil_15", prefix="hr_corrRecoil_15", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="MET_HR_15", prefix="hr_MET_15", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="RoughRecoil_Eflow_15", prefix="hr_roughRecoil_Eflow_15", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="ueCorrection_Eflow_15", prefix="hr_ueCorrection_Eflow_15", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="RefinedRecoil_Eflow_15", prefix="hr_corrRecoil_Eflow_15", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="MET_HR_Eflow_15", prefix="hr_MET_Eflow_15", exclude=['MET_Regions', 'MET_Comps']) # ... DR = 0.20 alg += MissingETD3PDObject(0, sgkey="RoughRecoil_20", prefix="hr_roughRecoil_20", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="ueCorrection_20", prefix="hr_ueCorrection_20", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="RefinedRecoil_20", prefix="hr_corrRecoil_20", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="MET_HR_20", prefix="hr_MET_20", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="RoughRecoil_track_20", prefix="hr_roughRecoil_track_20", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="ueCorrection_track_20", prefix="hr_ueCorrection_track_20", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="RefinedRecoil_track_20", prefix="hr_corrRecoil_track_20", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="MET_HR_track_20", prefix="hr_MET_track_20", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="RoughRecoil_clusNoTrack_20", prefix="hr_roughRecoil_clusNoTrack_20", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="ueCorrection_clusNoTrack_20", prefix="hr_ueCorrection_clusNoTrack_20", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="RefinedRecoil_clusNoTrack_20", prefix="hr_corrRecoil_clusNoTrack_20", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="MET_HR_clusNoTrack_20", prefix="hr_MET_clusNoTrack_20", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="RoughRecoil_Eflow_20", prefix="hr_roughRecoil_Eflow_20", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="ueCorrection_Eflow_20", prefix="hr_ueCorrection_Eflow_20", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="RefinedRecoil_Eflow_20", prefix="hr_corrRecoil_Eflow_20", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="MET_HR_Eflow_20", prefix="hr_MET_Eflow_20", exclude=['MET_Regions', 'MET_Comps']) # ... DR = 0.25 alg += MissingETD3PDObject(0, sgkey="RoughRecoil_25", prefix="hr_roughRecoil_25", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="ueCorrection_25", prefix="hr_ueCorrection_25", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="RefinedRecoil_25", prefix="hr_corrRecoil_25", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="MET_HR_25", prefix="hr_MET_25", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="RoughRecoil_Eflow_25", prefix="hr_roughRecoil_Eflow_25", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="ueCorrection_Eflow_25", prefix="hr_ueCorrection_Eflow_25", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="RefinedRecoil_Eflow_25", prefix="hr_corrRecoil_Eflow_25", exclude=['MET_Regions', 'MET_Comps']) alg += MissingETD3PDObject(0, sgkey="MET_HR_Eflow_25", prefix="hr_MET_Eflow_25", exclude=['MET_Regions', 'MET_Comps']) # track and cluster blocks # ... all clusters, very low LOD alg += ClusterD3PDObject( **_args(0, 'Clusters1', kw, exclude='SamplingBasics')) # ... higher LOD for pt>10 GeV alg += ClusterD3PDObject( **_args(2, 'Clusters2', kw, sgkey='HighPtClusters', prefix='clpt10_')) alg += ClusterD3PDObject(**_args( 3, 'Clusters3', kw, sgkey='HighPtEMClusters', prefix='emclpt10_')) from TrackD3PDMaker.TrackD3PDObject import TrackD3PDObject # ... good tracks only (nSCT>3; no pt cut) # turn on detailed track info if writing SoftQCD version of D3PD if doSoftQCD: from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags as softQcdFlags softQcdFlags.doTruth = True softQcdFlags.storeDetailedTruth = False softQcdFlags.storeDiagonalCovarianceAsErrors = True softQcdFlags.storeHitTruthMatching = True softQcdFlags.storePixelHitsOnTrack = False softQcdFlags.storePixelHolesOnTrack = False softQcdFlags.storePixelOutliersOnTrack = False softQcdFlags.storeSCTHitsOnTrack = False softQcdFlags.storeSCTHolesOnTrack = False softQcdFlags.storeSCTOutliersOnTrack = False softQcdFlags.storeTRTHitsOnTrack = False softQcdFlags.storeTRTHolesOnTrack = False softQcdFlags.storeTRTOutliersOnTrack = False softQcdFlags.storeTrackFitQuality = True softQcdFlags.storeTrackInfo = True softQcdFlags.storeTrackMomentum = True softQcdFlags.storeTrackPredictionAtBLayer = True softQcdFlags.storeTrackSummary = True softQcdFlags.trackParametersAtBeamSpotLevelOfDetails = 0 softQcdFlags.trackParametersAtGlobalPerigeeLevelOfDetails = 2 softQcdFlags.trackParametersAtPrimaryVertexLevelOfDetails = 2 SoftQCDTrackParticleD3PDObject = TrackD3PDObject( _label='trk', _prefix='trk_', _sgkey='GoodTracks', typeName='Rec::TrackParticleContainer', flags=softQcdFlags) alg += SoftQCDTrackParticleD3PDObject(**_args( 3, 'Tracks1', kw, sgkey='GoodTracks', label='trk', prefix='trk_')) else: # ... use standard level of track info for 'GoodTracks' alg += TrackParticleD3PDObject(**_args( 3, 'Tracks1', kw, sgkey='GoodTracks', label='trk', prefix='trk_')) # ... high-pt tracks (nSCT>3; pt>5 GeV) from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags as highPtFlags highPtFlags.doTruth = True highPtFlags.storeDiagonalCovarianceAsErrors = True highPtFlags.storeHitTruthMatching = True highPtFlags.storePixelHitsOnTrack = False highPtFlags.storePixelHolesOnTrack = False highPtFlags.storePixelOutliersOnTrack = False highPtFlags.storeSCTHitsOnTrack = False highPtFlags.storeSCTHolesOnTrack = False highPtFlags.storeSCTOutliersOnTrack = False highPtFlags.storeTRTHitsOnTrack = False highPtFlags.storeTRTHolesOnTrack = False highPtFlags.storeTRTOutliersOnTrack = False highPtFlags.storeTrackFitQuality = True highPtFlags.storeTrackMomentum = True highPtFlags.storeTrackSummary = True highPtFlags.storeTrackSummary.IDOutliers = True highPtFlags.storeTrackSummary.PixelInfoPlus = True highPtFlags.storeTrackSummary.SCTInfoPlus = True highPtFlags.storeTrackSummary.TRTInfoPlus = True highPtFlags.storeTrackSummary.InfoPlus = True highPtFlags.trackParametersAtBeamSpotLevelOfDetails = 0 highPtFlags.trackParametersAtGlobalPerigeeLevelOfDetails = 2 highPtFlags.trackParametersAtPrimaryVertexLevelOfDetails = 3 HighPtTrackParticleD3PDObject = TrackD3PDObject( _label='trkpt4', _prefix='trkpt4_', _sgkey='HighPtTracks', typeName='Rec::TrackParticleContainer', flags=highPtFlags) alg += HighPtTrackParticleD3PDObject(**_args(3, 'Tracks2', kw, sgkey='HighPtTracks', label='trkpt4', prefix='trkpt4_')) # Primary vertex block - May be missing in single-beam data. alg += PrimaryVertexD3PDObject(**_args(1, 'PrimaryVertex', kw, allowMissing=True, sgkey=D3PDMakerFlags.VertexSGKey(), prefix='vxp_')) # MBTS alg += MBTSD3PDObject(**_args(10, 'MBTS', kw)) alg += MBTSTimeD3PDObject(**_args(10, 'MBTSTime', kw)) alg += MBTSTriggerBitsD3PDObject(**_args(10, 'MBTSTriggerBits', kw)) #alg += CollisionDecisionD3PDObject(**_args (10, 'CollisionDecision', kw)) # Truth if rec.doTruth(): from TruthD3PDMaker.TruthParticleD3PDObject import TruthParticleD3PDObject from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject alg += TruthMuonD3PDObject(**_args(2, 'TruthMuon', kw)) alg += GenEventD3PDObject(**_args(1, 'GenEvent', kw)) alg += TruthParticleD3PDObject(**_args(1, 'TruthParticle', kw)) # TruthJets alg += JetD3PDObject(**_args(1, 'AK4TruthJet', kw, sgkey='AntiKt4TruthJets', prefix='jet_AntiKt4Truth_', allowMissing=True)) alg += JetD3PDObject(**_args(1, 'AK6TruthJet', kw, sgkey='AntiKt6TruthJets', prefix='jet_AntiKt6Truth_', allowMissing=True)) alg += JetD3PDObject(**_args(1, 'AK4TruthJetALL', kw, sgkey='AntiKt4TruthJets_ALL', prefix='jet_AntiKt4TruthALL_', allowMissing=True)) alg += JetD3PDObject(**_args(1, 'AK6TruthJetALL', kw, sgkey='AntiKt6TruthJets_ALL', prefix='jet_AntiKt6TruthALL_', allowMissing=True)) alg += JetD3PDObject(**_args(1, 'AK4TruthJetWZ', kw, sgkey='AntiKt4TruthJets_WZ', prefix='jet_AntiKt4TruthWZ_', allowMissing=True)) alg += JetD3PDObject(**_args(1, 'AK6TruthJetWZ', kw, sgkey='AntiKt6TruthJets_WZ', prefix='jet_AntiKt6TruthWZ_', allowMissing=True)) ### heavy flavor truth information from AthenaCommon.AppMgr import ToolSvc from TruthD3PDAnalysis.TruthD3PDAnalysisConf import D3PD__GenObjectsFilterTool smwzhfGenVtxFilterTool = D3PD__GenObjectsFilterTool( "SMWZHFGenVtxFilterTool") ToolSvc += smwzhfGenVtxFilterTool smwzhfGenVtxFilterTool.RemoveInTimePileUp = False smwzhfGenVtxFilterTool.Remove2BCPileUp = True smwzhfGenVtxFilterTool.Remove800nsPileUp = True smwzhfGenVtxFilterTool.RemoveCavernBkg = True smwzhfGenVtxFilterTool.RemoveEmptyEvents = True smwzhfGenVtxFilterTool.RemoveDummyEvents = True smwzhfGenVtxFilterTool.RemoveUnrequestedParticles = True smwzhfGenVtxFilterTool.KeepBCHadrons = True from TruthD3PDMaker.GenVertexD3PDObject import GenVertexD3PDObject alg += GenVertexD3PDObject(**_args(0, "hfgenvertex", kw, prefix='mchfvtx_', filter=smwzhfGenVtxFilterTool)) smwzhfGenPartFilterTool = D3PD__GenObjectsFilterTool( "SMWZHFGenPartFilterTool") ToolSvc += smwzhfGenPartFilterTool smwzhfGenPartFilterTool.RemoveInTimePileUp = False smwzhfGenPartFilterTool.Remove2BCPileUp = True smwzhfGenPartFilterTool.Remove800nsPileUp = True smwzhfGenPartFilterTool.RemoveCavernBkg = True smwzhfGenPartFilterTool.RemoveEmptyEvents = True smwzhfGenPartFilterTool.RemoveDummyEvents = True smwzhfGenPartFilterTool.RemoveUnrequestedParticles = True smwzhfGenPartFilterTool.KeepBCQuarks = True smwzhfGenPartFilterTool.KeepBCQuarkAncestors = True smwzhfGenPartFilterTool.KeepBCHadrons = True smwzhfGenPartFilterTool.KeepBCHadronDecayChain = True smwzhfGenPartFilterTool.BCHadronsDescendantsPtCut = 200 smwzhfGenPartFilterTool.BCHadronsDescendantsBarcodeCut = 300000 smwzhfGenPartFilterTool.BCHadronsDescendantsEtaCut = 5 from TruthD3PDMaker.GenParticleD3PDObject import GenParticleD3PDObject alg += GenParticleD3PDObject( **_args(10, "hfgenparticle", kw, prefix='mchfpart_', filter=smwzhfGenPartFilterTool, GenParticle_WriteMotherType=False, GenParticle_WriteMotherBarcode=False)) ### leptonic W/Z truth information smwzlepwzGenPartFilterTool = D3PD__GenObjectsFilterTool( "SMWZLepWZGenPartFilterTool") ToolSvc += smwzlepwzGenPartFilterTool smwzlepwzGenPartFilterTool.RemoveInTimePileUp = True smwzlepwzGenPartFilterTool.Remove2BCPileUp = True smwzlepwzGenPartFilterTool.Remove800nsPileUp = True smwzlepwzGenPartFilterTool.RemoveCavernBkg = True smwzlepwzGenPartFilterTool.RemoveEmptyEvents = True smwzlepwzGenPartFilterTool.RemoveDummyEvents = True smwzlepwzGenPartFilterTool.RemoveUnrequestedParticles = True smwzlepwzGenPartFilterTool.KeepLeptonicWZBosons = True smwzlepwzGenPartFilterTool.KeepLeptonicWZBosonDecayChains = True smwzlepwzGenPartFilterTool.KeepLeptonicWZBosonsParents = True from TruthD3PDMaker.GenParticleD3PDObject import GenParticleD3PDObject alg += GenParticleD3PDObject(**_args( 10, "lepwzgenparticle", kw, prefix='mclepwzpart_', filter=smwzlepwzGenPartFilterTool, label="LepWZTruthD3PDObject", exclude=["GenPartProdVertexAssoc", "GenPartDecayVertexAssoc"], GenParticle_WriteMotherType=False, GenParticle_WriteMotherBarcode=False, GenPartMotherAssoc_target="LepWZTruthD3PDObject", GenPartChildAssoc_target="LepWZTruthD3PDObject")) if not rec.doTruth(): alg += BeamSpotD3PDObject(10) # Trigger if D3PDMakerFlags.DoTrigger(): alg += ZPrimeMMTriggerBitsD3PDObject( **_args(10, 'ZPrimeMMTriggerBits', kw)) # Trigger Decision + metadata alg += TrigDecisionD3PDObject(**_args(10, 'TrigDecision', kw)) addTrigConfMetadata(alg) # Bunch group info alg += BGCodeD3PDObject(**_args(2, 'BGCode', kw)) # Egamma and Mu TrigEgammaD3PDObjects(alg, 1) TrigMuonD3PDObjects(alg, 1) # Esum alg += EnergySumROID3PDObject( **_args(2, 'EnergySumROI', kw, prefix="trig_L1_esum_")) # The LVL2 information: alg += TrigMETD3PDObject(**_args( 2, 'TrigMETL2', kw, prefix="trig_L2_met_", sgkey="HLT_T2MissingET")) # The EF information: alg += TrigMETD3PDObject(**_args(2, 'TrigMETEF', kw, prefix="trig_EF_met_", sgkey="HLT_TrigEFMissingET")) # The BJet information: TrigBJetD3PDObjects(alg, 10, False, False, True, True, True) # Event metadata alg.MetadataTools += [LBMetadataConfig()] if D3PDMakerFlags.FilterCollCand(): from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg alg.filterSeq += CollisionFilterAlg(tuplename + '_CollCandFilter') return alg
def WPrimeMND3PD (alg = None, file = 'smwz.root', tuplename = 'physics', streamname = 'd3pdstream', doSoftQCD = False, doThirdMuonChain = True, **kw): # 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)) # Muon blocks ### 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"], exclude = ["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info","SelectionFlagging", "Likelihood","TrkMatchQuality","Quality","MuonTimingFillerTool","TrkParameters", "TrkCovDiag","TrkCovOffDiag","TrkFitQuality","TrkInfoInDet","L2CBInfoIndex", "L1InfoIndex"], allowMissing = True )) ### Third muon chain variables! if cfgKeyStore.isInInput( "Analysis::MuonContainer", "StacoMuonCollection" ): alg += MuonD3PDObject (**_args (10, 'StacoMuon', kw, sgkey='StacoMuonCollection', prefix='mu_staco_', include = ["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex"], exclude = ["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info","SelectionFlagging", "Likelihood","TrkMatchQuality","Quality","MuonTimingFillerTool","TrkParameters", "TrkCovDiag","TrkCovOffDiag","TrkFitQuality","TrkInfoInDet","L2CBInfoIndex", "L1InfoIndex"], allowMissing = True )) # Jet blocks from JetTagD3PDMaker.JetTagD3PDMakerFlags import JetTagD3PDFlags alg += JetD3PDObject (**_args ( 1, 'AK4TopoEMJet', kw, sgkey='AntiKt4TopoEMJets', prefix='jet_AntiKt4TopoEM_', include = [], exclude = ['JESMoments','JVtx','OriginCorrection', 'El02Match','Mu02Match','L1Info','L2Info','EFInfo'], allowMissing = True)) # EventShape variables alg += EventShapeD3PDObject(**_args(0, 'rho', kw)) alg += MissingETD3PDObject (**_args (0, 'MissingET', kw, include=['MET_RefFinal_Comps','MET_CellOut_Comps','MET_REfFinal','MET_CellOut','MET_CellOut_Eflow', 'MET_LocHadTopo_Comps','MET_LocHadTopo', 'MET_LocHadTopoObj_Comps','MET_LocHadTopoObj', 'MET_MuonBoy_Comps','MET_MuonBoy', 'MET_MuonBoy_Track_Comps','MET_MuonBoy_Track', 'MET_RefMuon_Comps','MET_RefMuon','MET_RefMuon_em', 'MET_RefMuon_Track_em_Comps','MET_RefMuon_Track_Comps','MET_RefMuon_Track', 'MET_RefMuon_em_Comps','MET_SoftJets_Comps','MET_SoftJets','MET_RefMuon_em' 'MET_SoftJets_em_Comps','MET_Topo_Comps', 'MET_TopoObj_Comps','MET_Track_Comps','MET_Comps', 'MET_RefFinal_STVF','MET_RefJet_JVF', 'MET_RefJet_JVFCut', 'MET_CellOut_Eflow_STVF','MET_CellOut_Eflow_JetArea', 'MET_Truth_NonInt','MET_Truth_NonInt_Phi','MET_Truth_NonInt_Et','MET_Truth_NonInt_SumEt', 'MET_CellOut_Eflow_JetAreaRhoEta5JVF', ], allowMissing=True)) alg+=MissingETCompositionD3PDObject(**_args(4,"MissingETComposition",kw)) # Primary vertex block - May be missing in single-beam data. alg += PrimaryVertexD3PDObject (**_args (1, 'PrimaryVertex', kw, allowMissing = True, sgkey = D3PDMakerFlags.VertexSGKey(), exclude = ["Error","DiagCovariance","Covariance","Purity","TrackAtVertex"], prefix = 'vxp_')) # Trigger if D3PDMakerFlags.DoTrigger(): alg += WPrimeMNTriggerBitsD3PDObject (**_args (10, 'WPrimeMNTriggerBits', kw)) # Trigger Decision + metadata alg += TrigDecisionD3PDObject (**_args(0, 'TrigDecision', kw)) addTrigConfMetadata(alg) from TrigMuonD3PDMaker.TrigMuonEFInfoD3PDObject import TrigMuonEFInfoD3PDObject alg += TrigMuonEFInfoD3PDObject( **_args( -1, "TrigMuonEF", kw, include=["Decision"] ) ) #Mu # TrigMuonD3PDObjects( alg, 1) # Event metadata alg.MetadataTools += [LBMetadataConfig()] if D3PDMakerFlags.FilterCollCand(): from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg alg.filterSeq += CollisionFilterAlg (tuplename + '_CollCandFilter') return alg
def HSG2physicsD3PD(name, file, tuplename='physics', **kw): from AthenaCommon.AlgSequence import AlgSequence # needed for attila's code from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags # needed for attila's code # define track and cluster filters filter1 = makeTrackFilterAlg(TracksName=D3PDMakerFlags.TrackSGKey(), OutputTracksName='GoodTracks' + name, ptCut=0., nSCTPix=4) filter2 = makeTrackFilterAlg(TracksName=D3PDMakerFlags.TrackSGKey(), OutputTracksName='HighPtTracks' + name, ptCut=5000., nSCTPix=4) preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()) preseq += filter1 preseq += filter2 # now configure the D3PD from OutputStreamAthenaPool.MultipleStreamManager import MSMgr alg = MSMgr.NewRootStream(name, file, TreeName=tuplename) #alg = D3PDMakerCoreComps.MakerAlg(tuplename, seq, # file = file, # D3PDSvc = D3PDSvc, # streamNameRoot = streamNameRoot) alg += EventInfoD3PDObject(**_args(10, 'EventInfo', kw)) alg += LArCollisionTimeD3PDObject(**_args(10, 'LArCollisionTime', kw)) from D3PDMakerCoreComps.D3PDObject import make_SG_D3PDObject import EventCommonD3PDMaker # Electron/Photon block alg += ElectronD3PDObject( **_args(10, 'Electron', kw, exclude=[ 'L1Index', 'L2Index', 'EMTrackFitDetails', 'EgammaJetSignedIPAndPTRelKin' ])) # Photon block alg += PhotonD3PDObject(**_args(10, 'Photon', kw)) # Muon blocks alg += MuonD3PDObject(**_args( 10, 'MuidMuon', kw, sgkey='MuidMuonCollection', prefix='mu_muid_', include=["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex"], exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"], allowMissing=True)) alg += MuonD3PDObject(**_args( 10, 'StacoMuon', kw, sgkey='StacoMuonCollection', prefix='mu_staco_', include=["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex"], exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"], allowMissing=True)) alg += MuonD3PDObject(**_args( 10, 'CaloMuon', kw, sgkey='CaloMuonCollection', prefix='mu_calo_', include=["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex"], exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"], allowMissing=True)) alg += MuonD3PDObject(**_args( 10, 'Muons', kw, sgkey='Muons', prefix='mu_muon_', include=["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex"], exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"], allowMissing=True)) # Quadruplet vertex block from AthenaCommon.AlgSequence import AlgSequence from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags from HSG2VertexCreation.HSG2VertexReconstruction import HSG2VertexReconstruction HSG2VertexReconstruction("HSG2VertexReconstruction", AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName())) from HiggsD3PDMaker.HSG2VertexReconstruction import addHSG2VertexReconstruction addHSG2VertexReconstruction(alg, electron_target="el_", muid_target="mu_muid_", staco_target="mu_staco_", calo_target="mu_calo_", muon_target="mu_muon_") # Tau block alg += TauD3PDObject(**_args(1, 'Tau', kw)) # Jet blocks alg += JetD3PDObject(**_args( 3, 'AK4TopoEMJet', kw, sgkey='AntiKt4TopoEMJets' + JetTagD3PD_CollectionPostfix, prefix='jet_akt4topoem_', #include = ['BTag','TrueFlavorComponents','BTagComponents'], include=[ JetTagD3PDKeys.BTagWeightsBlockName(), JetTagD3PDKeys.JetFitterCharmTagInfoBlockName(), JetTagD3PDKeys.JetFitterCharmInfoBaseBlockName(), JetTagD3PDKeys.TruthInfoBlockName(), "Constituents", 'TracksMoments', 'Samplings', # For GSC corrections ], allowMissing=True)) # For VBF and ZH(->inv) analyses alg += JetD3PDObject(**_args( 3, 'AK4LCTopoJet', kw, sgkey='AntiKt4LCTopoJets' + JetTagD3PD_CollectionPostfix, prefix='jet_AntiKt4LCTopo_', include=[ JetTagD3PDKeys.BTagWeightsBlockName(), JetTagD3PDKeys.JetFitterCharmTagInfoBlockName(), JetTagD3PDKeys.JetFitterCharmInfoBaseBlockName(), JetTagD3PDKeys.TruthInfoBlockName(), "Constituents", "ConstituentScale", # For ZH(->inv) analysis 'TracksMoments', 'Samplings', # For GSC corrections ], allowMissing=True)) # MET blocks # a whole mess to remove x,y components separately for all flavours alg += MissingETD3PDObject(**_args( 10, 'MissingET', kw, exclude=[ 'MET_Base', 'MET_Base0', 'MET_Truth_Int', 'MET_RefFinal_Comps', 'MET_Calib_Comps', 'MET_CellOut_Comps', 'MET_CorrTopo_Comps', 'MET_Cryo_Comps', 'MET_CryoCone_Comps', 'MET_Final_Comps', 'MET_LocHadTopo_Comps', 'MET_LocHadTopoObj_Comps', 'MET_Muid_Comps', 'MET_Muid_Spectro_Comps', 'MET_Muid_Track_Comps', 'MET_MuonBoy_Comps', 'MET_MuonBoy_Spectro_Comps', 'MET_MuonBoy_Track_Comps', 'MET_MuonMuid_Comps', 'MET_Muon_Comps', 'MET_Muon_Isol_Muid_Comps', 'MET_Muon_Isol_Staco_Comps', 'MET_Muon_NonIsol_Muid_Comps', 'MET_Muon_NonIsol_Staco_Comps', 'MET_Muon_Total_Muid_Comps', 'MET_Muon_Total_Staco_Comps', 'MET_RefEle_Comps', 'MET_RefEle_em_Comps', 'MET_RefGamma_Comps', 'MET_RefGamma_em_Comps', 'MET_RefJet_Comps', 'MET_RefJet_em_Comps', 'MET_RefMuon_Comps', 'MET_RefMuon_Muid_Comps', 'MET_RefMuon_Staco_Comps', 'MET_RefMuon_Track_Muid_Comps', 'MET_RefMuon_Track_Staco_Comps', 'MET_RefMuon_Track_em_Comps', 'MET_RefMuon_Track_Comps', 'MET_RefMuon_em_Comps', 'MET_RefTau_Comps', 'MET_RefTau_em_Comps', 'MET_SoftJets_Comps', 'MET_SoftJets_em_Comps', 'MET_Topo_Comps', 'MET_TopoObj_Comps', 'MET_Track_Comps' ], allowMissing=True)) # Pileup-subtracted MET RefFinal for ZH(->inv) analysis alg += MissingETCompositionD3PDObject(level=4, sgkey='MET_RefComposition_STVF', suffix='STVF_', allowMissing=True, jetSGKey='AntiKt4LCTopoJets', jetPrefix='jet_AntiKt4LCTopo_MET_') # ... good tracks only (nSCT>3; no pt cut) alg += TrackParticleD3PDObject(**_args(3, 'Tracks1', kw, sgkey='GoodTracks' + name, label='trk', prefix='trk_')) # ... high-pt tracks (nSCT>3; pt>5 GeV) from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags as highPtFlags highPtFlags.doTruth = True highPtFlags.storeDiagonalCovarianceAsErrors = True highPtFlags.storeHitTruthMatching = True highPtFlags.storePixelHitsOnTrack = False highPtFlags.storePixelHolesOnTrack = False highPtFlags.storePixelOutliersOnTrack = False highPtFlags.storeSCTHitsOnTrack = False highPtFlags.storeSCTHolesOnTrack = False highPtFlags.storeSCTOutliersOnTrack = False highPtFlags.storeTRTHitsOnTrack = False highPtFlags.storeTRTHolesOnTrack = False highPtFlags.storeTRTOutliersOnTrack = False highPtFlags.storeTrackFitQuality = True highPtFlags.storeTrackMomentum = True highPtFlags.storeTrackSummary = True highPtFlags.trackParametersAtBeamSpotLevelOfDetails = 0 highPtFlags.trackParametersAtGlobalPerigeeLevelOfDetails = 2 highPtFlags.trackParametersAtPrimaryVertexLevelOfDetails = 3 alg += TrackParticleD3PDObject(**_args(3, 'Tracks2', kw, sgkey='HighPtTracks' + name, label='trkpt5', prefix='trkpt5_')) # Primary vertex block - May be missing in single-beam data. alg += PrimaryVertexD3PDObject(**_args(1, 'PrimaryVertex', kw, allowMissing=True, sgkey=D3PDMakerFlags.VertexSGKey(), prefix='vxp_')) # Truth if rec.doTruth(): from TruthD3PDMaker.GenEventD3PDObject import GenEventD3PDObject from TruthD3PDMaker.TruthParticleD3PDObject import TruthParticleD3PDObject from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject alg += TruthMuonD3PDObject(**_args(2, 'TruthMuon', kw)) alg += GenEventD3PDObject(**_args(1, 'GenEvent', kw)) alg += TruthParticleD3PDObject(**_args(1, 'TruthParticle', kw)) # TruthJets alg += JetD3PDObject(**_args(1, 'AK4TruthJet', kw, sgkey='AntiKt4TruthJets', prefix='jet_antikt4truth_', allowMissing=True)) # add Heavy flavour overlap from TopInputsD3PDMaker.HforD3PDObject import HforD3PDObject alg += HforD3PDObject(**_args(0, 'HforD3PD', kw)) # add mcVx information from TrackD3PDMaker.TruthVertexD3PDObject import TruthVertexD3PDObject alg += TruthVertexD3PDObject(**_args(0, 'TruthVertex', kw)) if not rec.doTruth(): alg += BeamSpotD3PDObject(10) if D3PDMakerFlags.DoTrigger(): # Trigger Decision + metadata alg += TrigDecisionD3PDObject(**_args(10, 'TrigDecision', kw)) addTrigConfMetadata(alg) from TrigMissingETD3PDMaker.TrigMETD3PD import TrigMETD3PDObjects TrigMETD3PDObjects(alg) from TrigEgammaD3PDMaker.TrigEgammaD3PD import TrigEgammaD3PDObjects TrigMuonD3PDObjects(alg, 1) TrigEgammaD3PDObjects(alg, level=10) # Event metadata alg.MetadataTools += [LBMetadataConfig()] from EventCommonD3PDMaker.CutFlowMetadataConfig import CutFlowMetadataConfig alg.MetadataTools += [CutFlowMetadataConfig(alg)] # Bunch train information from TriggerD3PDMaker.BunchStructureMetadata import addBunchStructureMetadata addBunchStructureMetadata(alg) ## Silence the trigger navigation warnings about missing containers: from AthenaCommon.AppMgr import ToolSvc if not hasattr(ToolSvc, "TrigDecisionTool"): from TrigDecisionTool.TrigDecisionToolConf import Trig__TrigDecisionTool ToolSvc += Trig__TrigDecisionTool("TrigDecisionTool") pass ToolSvc.TrigDecisionTool.Navigation.OutputLevel = 5 # EventShape variables # https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/D3PDVariablesForPileup#EventShape_variables from QcdD3PDMaker.QcdEventShapeD3PDObject import EventShapeD3PDObject alg += EventShapeD3PDObject(**_args(0, 'rho', kw)) return alg