def ClusterCorrectionD3PD(alg): alg += EventInfoD3PDObject(10) alg += ElectronD3PDObject(10, exclude=[ 'L1Index', 'L2Index', 'EFIndex', 'trackPVPerigeeAssoc', 'trackPerigeeAssoc' ]) alg += PhotonD3PDObject(10, exclude=['L1Index', 'L2Index', 'EFIndex']) alg += ClusterD3PDObject(10, sgkey='egClusterCollection') addCluster(alg, 'ele', 5, 5, 'cl_ele55_') addCluster(alg, 'ele', 3, 5, 'cl_ele35_') addCluster(alg, 'ele', 3, 7, 'cl_ele37_') addCluster(alg, 'gam', 5, 5, 'cl_gam55_') addCluster(alg, 'gam', 3, 5, 'cl_gam35_') addCluster(alg, 'gam', 3, 7, 'cl_gam37_') if rec.doTruth(): alg += egammaTruthD3PDObject(10, prefix='mc_') return
def metPerformanceD3PD(file, level=3, tuplename='metPerfD3PD', seq=topSequence, D3PDSvc='D3PD::RootD3PDSvc'): from AthenaCommon.AlgSequence import AlgSequence alg = AlgSequence() subAlg = D3PDMakerCoreComps.MakerAlg(tuplename, seq, file=file, D3PDSvc=D3PDSvc) subAlg += EventInfoD3PDObject(0) subAlg += ElectronD3PDObject(0) subAlg += PhotonD3PDObject(0) subAlg += MuonD3PDObject(0) subAlg += JetD3PDObject(level) ##subAlg += JetD3PDObject (level, sgkey='AntiKt4H1TopoJets',prefix='AntiKt4H1Topo_') example to change container subAlg += ClusterD3PDObject(3) ##subAlg += CellD3PDObject(3) don't turn on unless needed. filesize explodes alg += subAlg alg += METPhysicsD3PD( file, tuplename=tuplename, level=level) ##might need MissingETD3PDMaker-00-00-24 for this to work return alg
def JetD3PD(file, level=4, tuplename='jet', seq=topSequence, D3PDSvc='D3PD::RootD3PDSvc', streamNameRoot=None, **kw): alg = D3PDMakerCoreComps.MakerAlg(tuplename, seq, file=file, D3PDSvc=D3PDSvc, streamNameRoot=streamNameRoot) JetIncludes = ['AssocTrackCont'] alg += EventInfoD3PDObject(**_args(level, 'EventInfo', kw)) alg += ElectronD3PDObject(**_args(level, 'Electron', kw)) alg += PhotonD3PDObject(**_args(level, 'Photon', kw)) alg += MuonD3PDObject(**_args(level, 'Muon', kw)) #alg += MissingETD3PDObject (**_args (level, 'MissingET', kw)) #at the moment only the first one holds also b tagging information alg += JetD3PDObject(**_args(level, 'AntiKt4H1TopoJets', kw, sgkey='AntiKt4H1TopoJets', prefix='AntiKt4H1Topo_')) alg += JetD3PDObject(**_args(level, 'AntiKt6H1TopoJets', kw, sgkey='AntiKt6H1TopoJets', prefix='AntiKt6H1Topo_')) if D3PDMakerFlags.DoTrigger(): alg += jetMETTriggerBitsD3PDObject(level) alg += PrimaryVertexD3PDObject(**_args(1, 'PrimaryVertex', kw, allowMissing=True, sgkey=D3PDMakerFlags.VertexSGKey(), prefix='vxp_')) if rec.doTruth(): alg += GenEventD3PDObject(**_args(1, 'GenEvent', kw)) alg += TruthParticleD3PDObject(**_args(1, 'TruthParticle', kw)) alg += JetD3PDObject(**_args(1, 'AntiKt4TruthJets', kw, sgkey='AntiKt4TruthJets', prefix='AntiKt4Truth_')) #alg += JetD3PDObject (level, sgkey='AntiKt6TruthJets', prefix='AntiKt6Truth_' ) alg.MetadataTools += [LBMetadataConfig()] return alg
## 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], Samplings_WriteEnergy=False, Samplings_WritePhi=False)
def VertexGroupD3PD(alg=None, file=VertexD3PDAnalysisKeys.D3PDFileName(), treeName=VertexD3PDAnalysisKeys.D3PDTreeName(), **kw): print '[TrackD3PDMaker.VertexGroupD3PD] Vertex group D3PD settings:' print 'VertexD3PDAnalysisFlags' print VertexD3PDAnalysisFlags print 'VertexD3PDAnalysisKeys' print VertexD3PDAnalysisKeys if not alg: ## Create a new algorithm from OutputStreamAthenaPool.MultipleStreamManager import MSMgr alg = MSMgr.NewRootStream(treeName, file) ## General event information (custom options prefix: 'ei_') if VertexD3PDAnalysisFlags.useEventInfo(): from EventCommonD3PDMaker.EventInfoD3PDObject import EventInfoD3PDObject alg += EventInfoD3PDObject(**_args('ei_', kw, level=0, prefix='ei_')) ## Trigger information (custom options prefix: 'trig_') if VertexD3PDAnalysisFlags.useTrigger(): from TriggerJobOpts.TriggerConfigGetter import TriggerConfigGetter cfg = TriggerConfigGetter("ReadPool") from TriggerD3PDMaker.defineTriggerBits import defineTriggerBits from TriggerD3PDMaker.TrigConfMetadata import addTrigConfMetadata from TriggerD3PDMaker.TrigDecisionD3PDObject import TrigDecisionD3PDObject alg += TrigDecisionD3PDObject(**_args('trig_', kw, level=2)) addTrigConfMetadata(alg) if VertexD3PDAnalysisFlags.useTriggerRaw(): from TriggerJobOpts.TriggerConfigGetter import TriggerConfigGetter cfg = TriggerConfigGetter("ReadPool") from TriggerD3PDMaker.defineTriggerBits import defineTriggerBits from TriggerD3PDMaker.TrigConfMetadata import addTrigConfMetadata #Setup custom D3PD object with raw trigger info only (e.g. calibration_vdM streams) from D3PDMakerCoreComps.D3PDObject import make_Void_D3PDObject import TriggerD3PDMaker TrigDecisionD3PDObjectRaw = make_Void_D3PDObject( "trigRaw_", "TrigDecisionD3PDObjectRaw", default_name="TrigDecisionFillerRaw") if not VertexD3PDAnalysisFlags.useTrigger(): TrigDecisionD3PDObjectRaw.defineBlock( 0, "TriggerRawInfo", TriggerD3PDMaker.TrigDecisionFillerTool, SaveLVL1Raw=True, SaveHLTRaw=True, SaveBGCode=True) else: TrigDecisionD3PDObjectRaw.defineBlock( 0, "TriggerRawInfo", TriggerD3PDMaker.TrigDecisionFillerTool, SaveHLTRaw=True, SaveBGCode=True) #Finally add object to algorithms alg += TrigDecisionD3PDObjectRaw(**_args('trig_', kw, level=0)) if not VertexD3PDAnalysisFlags.useTrigger(): #unless we've already added it, add meta-data as well addTrigConfMetadata(alg) ## Beam background information (custom options prefix: 'bkg_') if VertexD3PDAnalysisFlags.useBackgroundWord(): from BackgroundD3PDMaker.BackgroundWordD3PDObject import BackgroundWordD3PDObject alg += BackgroundWordD3PDObject(**_args('bkg_', kw, level=0)) ## Tracks and V0 information (custom options prefix: 'trk_', and 'v0_') if VertexD3PDAnalysisFlags.useTracks(): labelDefaultVtx = VertexD3PDAnalysisKeys.LabelDefaultVtx() prefixDefaultVtx = labelDefaultVtx + '_' #Add trailing '_' import TrackD3PDMaker from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags from TrackD3PDMaker.TrackD3PDObject import TrackD3PDObject from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags from TruthD3PDMaker.TruthD3PDMakerFlags import TruthD3PDFlags from TruthD3PDMaker.TruthD3PDMakerKeys import TruthD3PDKeys VtxD3PD_Track_Exclude = ['vx_weight'] TrackD3PDMaker.PerigeeUnbiasedIPAtPVFillerTool.DoBiased = False #Switch off biased perigee TrackParticleD3PDObjectForVertex = TrackD3PDObject( _label='trk', _prefix='trk_', _sgkey=D3PDMakerFlags.TrackSGKey(), _object_name='TrackParticleD3PDObjectForVertex', typeName='Rec::TrackParticleContainer', vertexTarget=labelDefaultVtx, vertexPrefix=prefixDefaultVtx, vertexSGKey='VxPrimaryCandidate', truthTarget=TruthD3PDFlags.GenParticleAssocLabel(), truthPrefix=TruthD3PDKeys.GenParticlePrefix(), detailedTruthPrefix='', # 'mc_detailed_' SGKeyForTruth=D3PDMakerFlags.TrackSGKey(), truthMapKey='TrackParticleTruthCollection', detailedTruthMapKey='', #'DetailedTrackTruth' flags=TrackD3PDFlags) alg += TrackParticleD3PDObjectForVertex( **_args('trk_', kw, level=8, exclude=VtxD3PD_Track_Exclude)) if VertexD3PDAnalysisFlags.useSecondaryVertex(): from TrackD3PDMaker.V0D3PDObject import V0D3PDObject alg += V0D3PDObject(**_args('v0_', kw, level=10)) ## Store beamspot information (custom option perfix: 'bs_') if VertexD3PDAnalysisFlags.useBeamspot(): from TrackD3PDMaker.BeamSpotD3PDObject import BeamSpotD3PDObject alg += BeamSpotD3PDObject(**_args('bs_', kw, level=0)) ## Store vertex information (custom options prefix: 'vtx_' or 'vtx' for BuildVertexD3PDObject) from TrackD3PDMaker.VertexD3PDObject import PrimaryVertexD3PDObject from TrackD3PDMaker.VertexD3PDObject import BuildVertexD3PDObject from InDetRecExample.InDetKeys import InDetKeys from InDetRecExample.InDetJobProperties import InDetFlags #First dump existing content labelDefaultVtx = VertexD3PDAnalysisKeys.LabelDefaultVtx() prefixDefaultVtx = labelDefaultVtx + '_' #Add trailing '_' VtxDefaultD3PDObj = BuildVertexD3PDObject( **_args('vtx', kw, _prefix=prefixDefaultVtx, _label=labelDefaultVtx, _sgkey=InDetKeys.PrimaryVertices(), trackTarget='trk', trackPrefix='trk_', trackType='Rec::TrackParticleContainer')) alg += VtxDefaultD3PDObj(**_args('vtx_', kw, level=10)) #Then also dump the other vertex collections if VertexD3PDAnalysisFlags.useAllVertexCollections: #Use non BC and split collections (sorry, no customization of parameters here) if not InDetFlags.doSplitVertexFindingForMonitoring(): #raise NameError('Requesting split vertices but algorith has not run!') #pass print( '[TrackD3PDMaker.VertexGroupD3PD] WARNING: Requested split vertices, but algorithm has not run! Skipped.' ) else: SplitPrimaryVertexD3PDObject = BuildVertexD3PDObject( _prefix='vxsplit_', _label='vxsplit', _sgkey=InDetKeys.PrimaryVerticesSplitStream(), trackTarget='trk', trackPrefix='trk_', trackType='Rec::TrackParticleContainer') alg += SplitPrimaryVertexD3PDObject(8) #Then store also non beamspot constrained ones if not InDetFlags.doVertexFindingForMonitoring(): #raise NameError('Requesting NBC vertices but algorith has not run!') #pass print( '[TrackD3PDMaker.VertexGroupD3PD] WARNING: Requested non beamspot constrained vertices, but algorithm has not run! Skipped.' ) else: NoBeamConstraintPrimaryVertexD3PDObject = BuildVertexD3PDObject( _prefix='vxnbc_', _label='vxnbc', _sgkey=InDetKeys.PrimaryVerticesWithoutBeamConstraint(), trackTarget='trk', trackPrefix='trk_', trackType='Rec::TrackParticleContainer') alg += NoBeamConstraintPrimaryVertexD3PDObject(8) ## Store truth-level information (custom options prefix: 'tuthVtx_', 'truthEvt_', 'truthPart_') if VertexD3PDAnalysisFlags.useTruth(): from TruthD3PDAnalysis.TruthD3PDAnalysisConf import D3PD__GenObjectsFilterTool trackGenObjectsFilterTool = D3PD__GenObjectsFilterTool( "trackGenObjectsFilterTool") from AthenaCommon.AppMgr import ToolSvc ToolSvc += trackGenObjectsFilterTool if (VertexD3PDAnalysisFlags.filterTightTruth()): trackGenObjectsFilterTool.SelectTruthTracks = True trackGenObjectsFilterTool.PtMin = VertexD3PDAnalysisKeys.TruthTrackCutPtMin( ) trackGenObjectsFilterTool.EtaMax = VertexD3PDAnalysisKeys.TruthTrackCutEtaMax( ) trackGenObjectsFilterTool.RemoveEmptyEvents = True trackGenObjectsFilterTool.RemoveDummyEvents = True trackGenObjectsFilterTool.RemoveInTimePileUp = False trackGenObjectsFilterTool.Remove2BCPileUp = True trackGenObjectsFilterTool.Remove800nsPileUp = True trackGenObjectsFilterTool.RemoveCavernBkg = False trackGenObjectsFilterTool.AddOnlyFirstVertex = VertexD3PDAnalysisKeys.TruthAddOnlyFirstVertex( ) else: #Use a more inclusive truth policy trackGenObjectsFilterTool.SelectTruthTracks = False trackGenObjectsFilterTool.PtMin = VertexD3PDAnalysisKeys.TruthTrackCutPtMin( ) trackGenObjectsFilterTool.EtaMax = VertexD3PDAnalysisKeys.TruthTrackCutEtaMax( ) trackGenObjectsFilterTool.RemoveEmptyEvents = True trackGenObjectsFilterTool.RemoveDummyEvents = True trackGenObjectsFilterTool.AddOnlyFirstVertex = VertexD3PDAnalysisKeys.TruthAddOnlyFirstVertex( ) from TruthD3PDMaker.GenEventD3PDObject import GenEventD3PDObject alg += GenEventD3PDObject( **_args('truthEvt_', kw, level=10, filter=trackGenObjectsFilterTool, pileup_CollectionGetterRegistry=alg.name() + '_CollectionGetterRegistry')) from TruthD3PDMaker.GenVertexD3PDObject import GenVertexD3PDObject alg += GenVertexD3PDObject(**_args( 'truthVtx_', kw, level=1, filter=trackGenObjectsFilterTool)) from TruthD3PDMaker.GenParticleD3PDObject import GenParticleD3PDObject alg += GenParticleD3PDObject(**_args( 'truthPart_', kw, level=10, filter=trackGenObjectsFilterTool)) from TruthD3PDMaker.GenParticleD3PDObject import GenTruthTrackD3PDObject alg += GenTruthTrackD3PDObject(**_args('truthTrack_', kw, level=0)) ## Dump higher level objects # Missing Energy (custom options prefix with VertexD3PDAnalysisKeys.MetCollections+'_') if VertexD3PDAnalysisFlags.useMET(): for MET in VertexD3PDAnalysisKeys.MetCollections(): VtxD3PD_Met_Key = MET VtxD3PD_Met_Prefix = MET.replace('_', '') + '_' VtxD3PD_Met_Level = 0 #Only basic info VtxD3PD_Met_Exclude = ['MET_Regions', 'L1_', 'L2_', 'EF_'] from MissingETD3PDMaker.MissingETD3PDObject import RefFinalMETD3PDObject VtxD3PD_Met_Obj = RefFinalMETD3PDObject( **_args(MET + '_', kw, level=VtxD3PD_Met_Level, sgkey=VtxD3PD_Met_Key, prefix=VtxD3PD_Met_Prefix, exclude=VtxD3PD_Met_Exclude)) alg += VtxD3PD_Met_Obj #Muons (custom options prefix VtxD3PD_Muon_Prefix -- see below [e.g. muid_, staco_, ...]) if VertexD3PDAnalysisFlags.useMuons(): from MuonD3PDMaker.MuonD3PDObject import MuonD3PDObject for Muon in VertexD3PDAnalysisKeys.MuonCollections(): VtxD3PD_Muon_Key = Muon VtxD3PD_Muon_Prefix = Muon + '_' if VtxD3PD_Muon_Key == 'MuidMuonCollection': VtxD3PD_Muon_Prefix = 'muid_' elif VtxD3PD_Muon_Key == 'StacoMuonCollection': VtxD3PD_Muon_Prefix = 'staco_' VtxD3PD_Muon_Level = 0 #Only basic info VtxD3PD_Muon_Exclude = [ 'EFCBInfo', 'EFMGInfo', 'EFMEInfo', 'L2CBInfo', 'L1Info', 'L1_', 'L2_', 'EF_' ] VtxD3PD_Muon_Obj = MuonD3PDObject( **_args(VtxD3PD_Muon_Prefix, kw, level=VtxD3PD_Muon_Level, sgkey=VtxD3PD_Muon_Key, prefix=VtxD3PD_Muon_Prefix, allowMissing=True, exclude=VtxD3PD_Muon_Exclude)) alg += VtxD3PD_Muon_Obj #Electrons (custom options prefix: 'el_') if VertexD3PDAnalysisFlags.useElectrons(): from egammaD3PDMaker.ElectronD3PDObject import ElectronD3PDObject alg += ElectronD3PDObject(**_args('el_', kw, prefix='el_', level=0)) #Photons (custom options prefix: 'ph_') if VertexD3PDAnalysisFlags.usePhotons(): from egammaD3PDMaker.PhotonD3PDObject import PhotonD3PDObject alg += PhotonD3PDObject(**_args('ph_', kw, prefix='ph_', level=0)) #Jets, JVF, b-jets (custom options prefix: 'jet_') if VertexD3PDAnalysisFlags.useJets(): from JetD3PDMaker.JetD3PDObject import JetD3PDObject from JetTagD3PDMaker.JetTagD3PDMakerKeys import JetTagD3PDKeys from JetTagD3PDMaker.AddBTagD3PDInfo import addBTagInfoToJetObject addBTagInfoToJetObject(JetD3PDObject, btagLevelOffset=0) VtxD3PD_Jet_Include = [ 'Kinematics', 'JetVertexFraction', 'JVtx', 'EMFraction', 'TrueFlavorComponents', JetTagD3PDKeys.BTagWeightsBlockName() ] for JET in VertexD3PDAnalysisKeys.JetCollections(): VtxD3PD_Jet_Prefix = JET.replace('_', '') + '_' if len(VertexD3PDAnalysisKeys.JetCollections()) == 1: #only 1 element, simplify prefix VtxD3PD_Jet_Prefix = 'jet_' alg += JetD3PDObject(**_args('jet_', kw, sgkey=JET, prefix=VtxD3PD_Jet_Prefix, level=0, include=VtxD3PD_Jet_Include)) #Taus if VertexD3PDAnalysisFlags.useTaus(): from TauD3PDMaker.TauD3PDObject import TauD3PDObject VtxD3PD_Tau_Include = ['TauPriVtx'] alg += TauD3PDObject(**_args( 'tau_', kw, prefix='tau_', level=0, include=VtxD3PD_Tau_Include)) ## Return algorithm return alg
def physicsD3PD(alg=None, trigalg=None, file='physics.root', tuplename='physics', **kw): # Core algorithm # By default the user of this function should have created an algorithm already. # But for backwards compatibility let the function create its own algorithm if # needed... if not alg: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr alg = MSMgr.NewRootStream(tuplename, file) alg += EventInfoD3PDObject(**_args(10, 'EventInfo', kw)) # Segregate trigger decision flags in a separate tree. if not trigalg: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr trigalg = MSMgr.NewRootStream(tuplename + ':' + tuplename + 'TrigDec', FileName=file, TreeName=tuplename + 'TrigDec') trigalg += EventInfoD3PDObject(0) alg.Stream.trigDecisionTree = trigalg # Add bunch structure metadata. from TriggerD3PDMaker.BunchStructureMetadata \ import addBunchStructureMetadata addBunchStructureMetadata(alg) # Make track jets, but we can only do this if we have vertices. if testSGKey('VxContainer', 'VxPrimaryCandidate'): from D3PDMakerConfig.createTrackJets import createTrackJets createTrackJets(AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName())) alg += JetD3PDObject(**_args( -1, 'TrackJet', kw, prefix='trackjet_', sgkey='AntiKtZ5TrackJets')) k = 'Electron_EgammaTrackJetSignedIPAndPTRel_target' if not kw.has_key(k): kw[k] = 'trackjet_' alg += LArCollisionTimeD3PDObject(**_args(10, 'LArCollisionTime', kw)) # Electron/Photon blocks alg += ElectronD3PDObject( **_args(10, 'Electron', kw, EgammaJetSignedIPAndPTRel_target='jet_antikt4h1topo_')) alg += PhotonD3PDObject( **_args(10, 'Photon', kw, ConversionVertexTrackIndex_target='trk')) if testSGKey('ElectronContainer', D3PDMakerFlags.GSFElectronSGKey()): alg += GSFElectronD3PDObject( **_args(level, 'GSFElectron', kw, sgkey=D3PDMakerFlags.GSFElectronSGKey(), prefix='el_gsf_')) # Muon blocks alg += MuonD3PDObject(**_args(10, 'MuidMuon', kw, sgkey='MuidMuonCollection', prefix='mu_muid_', allowMissing=True)) alg += MuonD3PDObject(**_args(10, 'StacoMuon', kw, sgkey='StacoMuonCollection', prefix='mu_staco_', allowMissing=True)) alg += MuonD3PDObject(**_args( 10, 'Muons', kw, sgkey='Muons', prefix='mu_', allowMissing=True)) # Tau block alg += TauD3PDObject(**_args(1, 'Tau', kw)) # Jet blocks alg += JetD3PDObject(**_args(9, 'AK4TopoJet', kw, sgkey='AntiKt4TopoEMJets,' + 'AntiKt4TopoJets,' + 'AntiKt4H1TopoJets', prefix='jet_antikt4h1topo_', ConstitIndex_Target='cl_', exclude=['Constituents'], allowMissing=True)) alg += JetD3PDObject(**_args(6, 'AK4TowerJet', kw, sgkey='AntiKt4TowerAODJets,' + 'AntiKt4TowerJets,' + 'AntiKt4H1TowerJets', prefix='jet_antikt4h1tower_', exclude=['Constituents'], allowMissing=True)) alg += JetD3PDObject(**_args(6, 'AK6TowerJet', kw, sgkey='AntiKt6TowerAODJets,' + 'AntiKt6TowerJets,' + 'AntiKt6H1TowerJets', prefix='jet_antikt6h1tower_', exclude=['Constituents'], allowMissing=True)) #alg += JetD3PDObject (**_args ( 9, 'AK4TopoJetLC', kw, # sgkey='AntiKt4LCTopoJets', prefix='jet_antikt4lctopo_')) #alg += JetD3PDObject (**_args ( 9, 'AK6TopoJetLC', kw, # sgkey='AntiKt6LCTopoMyJets', prefix='jet_antikt6lctopo_')) #alg += JetD3PDObject (**_args ( 9, 'AK6TopoJetH1', kw, # sgkey='AntiKt6H1TopoMyJets', prefix='jet_antikt6h1topo_')) # MET blocks alg += MissingETD3PDObject(**_args(10, 'MissingET', kw, allowMissing=True)) alg += MissingETGoodnessD3PDObject(**_args(2, 'METGoodness', kw)) # track and cluster blocks alg += ClusterD3PDObject(**_args(1, 'Cluster', kw)) alg += EMClusterD3PDObject(**_args(2, 'EMCluster', kw)) # Many of these are just being set to the defaults --- that's because # they're being changed in TrigEgamma... alg += TrackParticleD3PDObject( **_args(3, 'TrackParticle', kw, TruthParticleTarget='mc_', storeTruthInfo=True, trackParametersAtGlobalPerigeeLevelOfDetails=3, storeDiagonalCovarianceAsErrors=True)) # MBTS alg += MBTSD3PDObject(**_args(10, 'MBTS', kw)) alg += MBTSTimeD3PDObject(**_args(10, 'MBTSTime', kw)) alg += MBTSTriggerBitsD3PDObject(**_args(10, 'MBTSTriggerBits', kw)) alg += CollisionDecisionD3PDObject(**_args(10, 'CollisionDecision', kw)) # ZDC alg += ZDCTriggerBitsD3PDObject(**_args(10, 'ZDCTriggerBits', kw)) # Primary vertex block - May be missing in single-beam data. alg += PrimaryVertexD3PDObject( **_args(1, 'PrimaryVertex', kw, allowMissing=True, sgkey=D3PDMakerFlags.VertexSGKey(), prefix='vxp_', storeVertexTrackAssociation=True, storeDiagonalCovarianceAsErrors=True)) # Truth if rec.doTruth(): from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject alg += TruthMuonD3PDObject(**_args(2, 'TruthMuon', kw)) alg += GenEventD3PDObject(**_args(1, 'GenEvent', kw)) alg += TruthParticleD3PDObject(**_args(1, 'TruthParticle', kw)) alg += JetD3PDObject(**_args(3, 'AK4TruthJet', kw, sgkey='AntiKt4TruthJets', prefix='jet_antikt4truth_', allowMissing=True)) #alg += JetD3PDObject (**_args ( 3, 'AK6Ttruth', kw, # sgkey='AntiKt6TruthJets', # prefix='jet_antikt6truth_')) # Trigger if D3PDMakerFlags.DoTrigger(): from TriggerD3PDMaker.TrigDecisionD3PDObject \ import TrigDecisionD3PDObject alg += TrigDecisionD3PDObject(**_args(2, 'TrigDecision', kw)) TrigEgammaD3PDObjects(alg, **_args(1, 'TrigEgamma', kw)) alg += egammaTriggerBitsD3PDObject(**_args(2, 'EgammaTriggerBits', kw)) alg += MuonTriggerBitsD3PDObject(**_args(2, 'MuonTriggerBits', kw)) alg += METD3PDTriggerBitsObject(**_args(2, 'METTriggerBits', kw)) from TriggerD3PDMaker.EnergySumROID3PDObject import EnergySumROID3PDObject from TrigMissingETD3PDMaker.TrigMETD3PDObject import TrigMETD3PDObject alg += EnergySumROID3PDObject(**_args( 2, 'EnergySumROI', kw, prefix="trig_L1_esum_", allowMissing=True)) # The LVL2 information: alg += TrigMETD3PDObject(**_args( 2, 'TrigMETL2', kw, prefix="trig_L2_met_", sgkey="HLT_T2MissingET")) # The EF information: alg += TrigMETD3PDObject(**_args(2, 'TrigMETEF', kw, prefix="trig_EF_met_", sgkey="HLT_TrigEFMissingET")) from TriggerD3PDMaker.BGCodeD3PDObject import BGCodeD3PDObject alg += BGCodeD3PDObject(**_args(2, 'BGCode', kw)) # Event metadata alg.MetadataTools += [LBMetadataConfig()] if D3PDMakerFlags.FilterCollCand(): from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg alg.filterSeq += CollisionFilterAlg(tuplename + '_CollCandFilter') return alg
def JetD3PD(file, level=4, tuplename='jet', seq=topSequence, D3PDSvc='D3PD::RootD3PDSvc'): egammaUserDataConfig(seq) if rec.doTruth(): truthParticleConfig(seq) JetIncludes = ['AssocTrackCont'] alg = D3PDMakerCoreComps.MakerAlg(tuplename, seq, file=file, D3PDSvc=D3PDSvc) #-- General alg += EventInfoD3PDObject(level) alg += ElectronD3PDObject(0) alg += PhotonD3PDObject(0) alg += MuonD3PDObject(0) alg += PrimaryxAODVertexD3PDObject(4, allowMissing=True, sgkey=D3PDMakerFlags.VertexSGKey(), prefix='vxp_') #-- JET alg += JetD3PDObject(level, sgkey='AntiKt4H1TopoJets', include=JetIncludes, prefix='AntiKt4H1Topo_') alg += JetD3PDObject(level, sgkey='AntiKt6H1TopoJets', include=JetIncludes, prefix='AntiKt6H1Topo_') #alg += JetD3PDObject (level, sgkey='Cone4H1TopoJets', include = JetIncludes, prefix='Cone4H1Topo_' ) #-- MET alg += RefFinalMETD3PDObject(level) alg += MuonMETD3PDObject(level) alg += MuonBoyMETD3PDObject(level) alg += FinalMETD3PDObject(level) alg += CryoMETD3PDObject(level) alg += CryoConeMETD3PDObject(level) alg += RefEleMETD3PDObject(level) alg += RefJetMETD3PDObject(level) alg += RefGammaMETD3PDObject(level) alg += RefTauMETD3PDObject(level) alg += CellOutMETD3PDObject(level) alg += BaseMETD3PDObject(level) alg += Base0METD3PDObject(level) alg += CalibMETD3PDObject(level) alg += MuonBoySpectroMETD3PDObject(level) alg += MuonBoyTrackMETD3PDObject(level) alg += TopoMETD3PDObject(level) alg += CorrTopoMETD3PDObject(level) alg += LocHadTopoMETD3PDObject(level) alg += TopoObjMETD3PDObject(level) #-- Trigger if D3PDMakerFlags.DoTrigger(): alg += jetMETTriggerBitsD3PDObject(level) #-- Truth if rec.doTruth(): alg += GenEventD3PDObject(1) #alg += TruthParticleD3PDObject (level) #alg += JetD3PDObject (level, sgkey='Cone4TruthJets' , prefix='Cone4Truth_' ) alg += JetD3PDObject(3, sgkey='AntiKt4TruthJets', prefix='AntiKt4Truth_') #alg += JetD3PDObject (3, sgkey='AntiKt6TruthJets', prefix='AntiKt6Truth_' ) #-- Meta Data alg.MetadataTools += [LBMetadataConfig()] return alg
def egammaD3PD(alg=None, trigalg=None, level=10, file='egamma.root', tuplename='egamma', **kw): preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()) createxAOD(preseq) if not cfgKeyStore.isInInput('xAOD::ElectronContainer', 'AllElectrons'): preseq += MergeElectrons() # Core algorithm # By default the user of this function should have created an algorithm already. # But for backwards compatibility let the function create its own algorithm if # needed... if not alg: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr alg = MSMgr.NewRootStream(tuplename, file) alg += EventInfoD3PDObject(**_args(level, 'EventInfo', kw)) # Segregate trigger decision flags in a separate tree. if not trigalg: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr trigalg = MSMgr.NewRootStream(tuplename + ':' + tuplename + 'TrigDec', FileName=file, TreeName=tuplename + 'TrigDec') trigalg += EventInfoD3PDObject(0) alg.Stream.trigDecisionTree = trigalg # Add bunch structure metadata. from TriggerD3PDMaker.BunchStructureMetadata \ import addBunchStructureMetadata addBunchStructureMetadata(alg) alg += LArCollisionTimeD3PDObject(**_args(level, 'LArCollisionTime', kw)) alg += ElectronD3PDObject(**_args( level, 'Electron', kw, EgammaJetSignedIPAndPTRel_target='jet_')) alg += PhotonD3PDObject(**_args(level, 'Photon', kw)) # # Additional muon variables for Zg skims. # if not MuonD3PDObject.allBlocknames().has_key("MuonScatteringAngleSignificance"): # from AthenaCommon.AppMgr import ToolSvc # muonScatteringSigTool=None # if hasattr(ToolSvc, "MuonScatteringSigTool"): # muonScatteringSigTool=ToolSvc.MuonScatteringSigTool # from JetTagD3PDMaker import MuonScatteringAngleSignificanceFillerTool # MuonD3PDObject.defineBlock (100, "MuonScatteringAngleSignificance", # MuonScatteringAngleSignificanceFillerTool, # ScatteringSigTool=muonScatteringSigTool) alg += MuonD3PDObject(**_args( 10, 'Muons', kw, sgkey='StacoMuonCollection,Muons', prefix='mu_', include=[ "EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex", "L1InfoIndex", "MuonScatteringAngleSignificance" ], exclude=["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"], allowMissing=True)) alg += JetD3PDObject( **_args(0, 'Jet', kw, include=['JetQual', 'DQMoments'])) alg += MBTSD3PDObject(**_args(level, 'MBTS', kw)) alg += MBTSTimeD3PDObject(**_args(level, 'MBTSTime', kw)) # alg += MBTSTriggerBitsD3PDObject (**_args (level, 'MBTSTriggerBits', kw)) # alg += ZDCTriggerBitsD3PDObject (**_args (level, 'ZDCTriggerBits', kw)) alg += CollisionDecisionD3PDObject(**_args(level, 'CollisionDecision', kw)) alg += MissingETD3PDObject(**_args(level, 'MissingET', kw, sgkey='MET_Core_AntiKt4EMTopo', prefix='MET_RefFinal_')) if D3PDMakerFlags.DoTrigger(): from TriggerD3PDMaker.TrigDecisionD3PDObject \ import TrigDecisionD3PDObject alg += TrigDecisionD3PDObject(**_args(2, 'TrigDecision', kw)) #TrigEgammaD3PDObjects (alg, **_args (1, 'TrigEgamma', kw, # TrigEMCluster_level = 2)) # from TriggerD3PDMaker.EnergySumROID3PDObject import EnergySumROID3PDObject # from TrigMissingETD3PDMaker.TrigMETD3PDObject import TrigMETD3PDObject # alg += EnergySumROID3PDObject(**_args (level, 'EnergySumROI', kw, # prefix = "trig_L1_esum_", # allowMissing = True)) # # The LVL2 information: # alg += TrigMETD3PDObject(**_args( level, 'TrigMETL2', kw, # prefix = "trig_L2_met_", # sgkey = "HLT_T2MissingET" )) # if cfgKeyStore.isInInputFile( "TrigMissingETContainer", "HLT_L2MissingET_FEB" ): # alg += TrigMETD3PDObject(**_args( level, 'TrigMETL2_FEB', kw, # prefix = "trig_L2_feb_met_", # sgkey = "HLT_L2MissingET_FEB" )) # # The EF information: # alg += TrigMETD3PDObject(**_args ( level, 'TrigMETEF', kw, # prefix = "trig_EF_met_", # sgkey = "HLT_TrigEFMissingET" )) # from TriggerD3PDMaker.BGCodeD3PDObject import BGCodeD3PDObject # alg += BGCodeD3PDObject (**_args (2, 'BGCode', kw)) # May be missing in single-beam data. alg += PrimaryxAODVertexD3PDObject(**_args( 1, 'PrimaryVertex', kw, #allowMissing = True, sgkey=D3PDMakerFlags.VertexSGKey(), prefix='vxp_', storeVertexTrackIndexAssociation=False, storeVertexTrackAssociation=True, storeDiagonalCovarianceAsErrors=True)) if rec.doTruth(): from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject alg += TruthMuonD3PDObject(**_args(level, 'TruthMuon', kw)) alg += TruthEventD3PDObject(**_args(1, 'TruthEvent', kw)) alg += TruthParticleD3PDObject(**_args(level, 'TruthParticle', kw)) # alg.MetadataTools += [LBMetadataConfig()] # if D3PDMakerFlags.FilterCollCand(): # from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg # alg.filterSeq += CollisionFilterAlg (tuplename + '_CollCandFilter') return alg
# track isolation for electrons, using new pt track cut -> 0.5GeV from SUSYD3PDMaker.SUSYD3PDMakerConf import SUSYD3PD__SUSYEleTrkIsoFillerTool as SUSYEleTrkIsoFillerTool #ElectronD3PDObject.defineBlock(1, "Isolation_500MeV", SUSYEleTrkIsoFillerTool, TrackIsolationTool="TrackIsolationTool/TrackIsolationTool") try: from egammaTools.EMTrackIsolationToolBase import EMTrackIsolationToolBase theemtrackisolationtool = EMTrackIsolationToolBase("emtrackisolationtool") theemtrackisolationtool.useBremAssoc = True ToolSvc += theemtrackisolationtool except Exception: traceback.print_exc() ElectronD3PDObject.defineBlock( 99, "miniiso10", BoostedTopD3PDMaker.MiniIsolationElectronFillerTool, EMTrackIsolationTool=theemtrackisolationtool, KtDist=10., prefix="MI10_") ElectronD3PDObject.defineBlock( 99, "miniiso15", BoostedTopD3PDMaker.MiniIsolationElectronFillerTool, EMTrackIsolationTool=theemtrackisolationtool, KtDist=15., prefix="MI15_") # track isolation for muons, using new pt track cut -> 0.5GeV #from SUSYD3PDMaker.SUSYD3PDMakerConf import SUSYD3PD__SUSYMuTrkIsoFillerTool as SUSYMuTrkIsoFillerTool #myMuonD3PDObject.defineBlock(1, "Isolation_500MeV", SUSYMuTrkIsoFillerTool, TrackIsolationTool="TrackIsolationTool/TrackIsolationTool", NamePrefix="trk500MeV") #myMuonD3PDObject.defineBlock(1, "Isolation_elstyletracks", SUSYMuTrkIsoFillerTool, TrackIsolationTool="TrackIsolationTool/TrackIsolationTool7",NamePrefix="trkelstyle")
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
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 add_met (alg): ### adding HSG5 MET from MissingET.METRefGetter_plup import * METRefAlg_HSG5 = make_METRefAlg(_suffix='_HSG5') METRefAlg_HSG5.sequence = AlgSequence( D3PDMakerFlags.PreD3PDAlgSeqName() ) METRefAlg_HSG5.jet_JetInputCollectionKey = "AntiKt4TopoEMJets" METRefAlg_HSG5.jet_JetPtCut = 20.0*GeV METRefAlg_HSG5.jet_ApplyJetScale = "No" METRefAlg_HSG5.jet_UseJetMomentForScale = True METRefAlg_HSG5.jet_JetMomentForScale = "EMJES" METRefAlg_HSG5.jet_RunSoftJetsTool = False METRefAlg_HSG5.jet_SoftJetsPtCut = 7.0*GeV METRefAlg_HSG5.jet_SoftJetsMaxPtCut = 20.0*GeV METRefAlg_HSG5.photon_doPhotonTool = False METRefAlg_HSG5.tau_doTauTool = False METRefAlg_HSG5.jet_SoftJetsCalibType = "EmScale" METRefAlg_HSG5.jet_ApplySoftJetsScale = "No" METRefAlg_HSG5.jet_calibType = "ExclRefCalib" METRefAlg_HSG5.ele_calibType = "RefCalib" METRefAlg_HSG5.gamma_calibType = "EmScale" METRefAlg_HSG5.cellout_calibType = "Eflow" METRefAlg_HSG5.tau_calibType = "EmScale" METRefAlg_HSG5.cryo_ApplyCorrection = "Off" METRefAlg_HSG5.muon_container = "MuidMuonCollection" METRefAlg_HSG5.muon_algorithm = "Muid" METRefAlg_HSG5.muon_isolationAlg = "dRJet" # METRefAlg_HSG5.jet_ApplyJetJVF = "Yes" # METRefAlg_HSG5.plupSuppCorr ='STVF' # METRefAlg_HSG5.celloutCorrection ='STVF' print METRefAlg_HSG5 METRefAlg_HSG5() customMETs = ['MET_RefFinal', 'MET_RefGamma', 'MET_RefEle', 'MET_RefTau', 'MET_RefJet', 'MET_CellOut', 'MET_Cryo', 'MET_SoftJets', 'MET_RefJet_JVF', 'MET_RefJet_JVFCut', 'MET_CellOut_Eflow_STVF', 'MET_CellOut_Eflow_JetArea', 'MET_RefFinal_STVF' ] for custom in customMETs: alg += MissingETD3PDObject (level=0, sgkey = custom+'_HSG5',prefix='MET_HSG5_'+custom[4:], allowMissing=True) alg += MissingETCompositionD3PDObject ( level=4, sgkey = 'MET_RefComposition_HSG5', suffix='HSG5_', allowMissing =True, jetSGKey='AntiKt4TopoEMJets', jetPrefix='jet_AntiKt4TopoEMJet_MET_') # adding STVF weights # alg += MissingETCompositionD3PDObject ( level=4, # sgkey = 'MET_RefComposition_HSG5', # suffix='STVF_', # allowMissing=True, # jetSGKey='AntiKt4TopoEMJets', # jetPrefix='jet_AntiKt4TopoEMJets_MET_') # exclude = ['MET_Muid_Weights','MET_Muons_Weights'] # HadronicRecoil blocks alg += ElectronD3PDObject(0, sgkey = "HR_selectedElectrons", prefix = "hr_el_") alg += MuonD3PDObject( 0, sgkey = "HR_selectedMuons", prefix = "hr_mu_" ) add_met1 (alg, '15') add_met1 (alg, '20', add_pieces = ['clusNoTrack_']) add_met1 (alg, '25') # HR using truth leptons if rec.doTruth(): add_met1 (alg, '15', True) add_met1 (alg, '20', True) add_met1 (alg, '25', True) return
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
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration # $Id: GSFElectronD3PDObject.py 523036 2012-10-24 15:50:12Z ssnyder $ # # @file egammaD3PDMaker/python/GSFElectronD3PDObject.py # @author scott snyder <*****@*****.**> # @date 2009 # @brief Configure GSF electron D3PD object. # from egammaD3PDMaker.defineBlockAndAlg import defineBlockAndAlg from D3PDMakerCoreComps.D3PDObject import DeferArg from D3PDMakerCoreComps.resolveSGKey import resolveSGKey from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags from AthenaCommon.AlgSequence import AlgSequence from RecExConfig.RecFlags import rec import egammaD3PDMaker import egammaD3PDAnalysis import EventCommonD3PDMaker import D3PDMakerCoreComps from egammaD3PDMaker.ElectronD3PDObject import ElectronD3PDObject GSFElectronD3PDObject = ElectronD3PDObject.copy()
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
import D3PDMakerReader service = D3PDMakerReader.RootReaderD3PDSvc("RootReaderD3PDSvc") service.Version = 2 service.OutputLevel = 1 ServiceMgr += service d3pdalg = D3PDMakerReader.MultiReaderAlg("ReaderAlg", Directory="../test", TuplePath="D3PDReader/Test", D3PDSvc=service) from EventCommonD3PDMaker.EventInfoD3PDObject import EventInfoD3PDObject d3pdalg += EventInfoD3PDObject(10) from TrigMuonD3PDMaker.TrigMuonD3PD import TrigMuonD3PDObjects TrigMuonD3PDObjects(d3pdalg, addNaviInfo=False) from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags D3PDMakerFlags.DoTrigger = False from egammaD3PDMaker.ElectronD3PDObject import ElectronD3PDObject d3pdalg += ElectronD3PDObject(10) from egammaD3PDMaker.PhotonD3PDObject import PhotonD3PDObject d3pdalg += PhotonD3PDObject(10) # Do some of the additional setup: from AthenaCommon.AppMgr import theApp, ServiceMgr theApp.EvtMax = athenaCommonFlags.EvtMax() ServiceMgr.MessageSvc.OutputLevel = INFO
# MyCompositeD3PDObject.defineBlock (0, 'Kinematics', # EventCommonD3PDMaker.FourMomFillerTool) # IndexMultiAssociation (MyCompositeD3PDObject, # EventCommonD3PDMaker.CompositeParticleAssociationTool, # ['el_', 'mu_'], # containerIndexName = 'cont', # nrowName = '') # alg += MyCompositeD3PDObject (10) # Test non-existent egamma. alg += ElectronD3PDObject (0, sgkey = 'xxx', prefix = 'el_xxx_', allowMissing = True) from egammaD3PDMaker.PhotonD3PDObject import PhotonD3PDObject alg += PhotonD3PDObject (0, sgkey = 'xxx', prefix = 'ph_xxx_', allowMissing = True) from MuonD3PDMaker.MuonD3PDObject import MuonD3PDObject alg += MuonD3PDObject (0, sgkey = 'xxx', prefix = 'mu_xxx_', allowMissing = True) from JetD3PDMaker.JetD3PDObject import JetD3PDObject
def SMWZLightD3PD (alg = None, file = 'smlight.root', tuplename = 'physics', streamname = 'd3pdstream', stdElectronContainer = 'None', gsfElectronContainer = 'None', stacoMuonContainer = 'None', muidMuonContainer = 'None', photonContainer = 'None', jetContainer = 'None', clusterContainer = 'None', tauContainer = 'None', trackContainer = 'None', **kw): preseq = AlgSequence (D3PDMakerFlags.PreD3PDAlgSeqName()) # perform recoil calculation import HadronicRecoil.Configurables as hrc preseq = hrc.add_hadronic_recoil_filters(preseq) # configure the D3PD if not alg: alg = MSMgr.NewRootStream(StreamName = streamname, FileName = file, TreeName = tuplename) alg += EventInfoD3PDObject (**_args (10, 'EventInfo', kw)) alg += LArCollisionTimeD3PDObject (**_args (10, 'LArCollisionTime', kw)) from TriggerD3PDMaker.BunchStructureMetadata import addBunchStructureMetadata addBunchStructureMetadata (alg) # Electron/Photon blocks if stdElectronContainer != 'None': alg += ElectronD3PDObject (**_args (10, 'Electron', kw, sgkey = stdElectronContainer, prefix = 'el_', exclude = ['EMTrackFit','EMTrackFitDetailsBrem', 'EMTrackFitDetailsRefit', 'EMTrackFitDetailsRefitCov'], allowMissing = True )) if (gsfElectronContainer != 'None') and testSGKey ('ElectronContainer', gsfElectronContainer): alg += GSFElectronD3PDObject (**_args (1, 'GSFElectron', kw, sgkey = gsfElectronContainer, prefix = 'el_gsf_', exclude = ['EMTrackFit','EMTrackFitDetailsBrem', 'EMTrackFitDetailsRefit', 'EMTrackFitDetailsRefitCov'], allowMissing = True )) D3PDMakerFlags.DoPAU = False if photonContainer != 'None': alg += PhotonD3PDObject (**_args (10, 'Photon', kw, sgkey = photonContainer, prefix = 'ph_', exclude = ['OQRecalc'], allowMissing = True )) # Muon blocks # ... add the scattering significance filler - to be removed when added in the MuonD3PDMaker if not MuonD3PDObject.allBlocknames().has_key("MuonScatteringAngleSignificance"): from AthenaCommon.AppMgr import ToolSvc muonScatteringSigTool=None if hasattr(ToolSvc, "MuonScatteringSigTool"): muonScatteringSigTool=ToolSvc.MuonScatteringSigTool from JetTagD3PDMaker import MuonScatteringAngleSignificanceFillerTool MuonD3PDObject.defineBlock (100, "MuonScatteringAngleSignificance", MuonScatteringAngleSignificanceFillerTool, ScatteringSigTool=muonScatteringSigTool) if stacoMuonContainer != 'None': alg += MuonD3PDObject (**_args (10, 'StacoMuon', kw, sgkey=stacoMuonContainer, prefix='mu_staco_', include = ['EFCBInfoIndex', 'EFMGInfoIndex', 'EFMEInfoIndex', 'MuonScatteringAngleSignificance'], exclude = ['EFCBInfo', 'EFMGInfo', 'EFMEInfo', 'L2CBInfo', 'L1Info', 'MuonTimingFillerTool'], allowMissing = True )) if muidMuonContainer != 'None': alg += MuonD3PDObject (**_args (10, 'MuidMuon', kw, sgkey=muidMuonContainer, prefix='mu_muid_', include = ['EFCBInfoIndex', 'EFMGInfoIndex', 'EFMEInfoIndex', 'MuonScatteringAngleSignificance'], exclude = ['EFCBInfo', 'EFMGInfo', 'EFMEInfo', 'L2CBInfo', 'L1Info', 'MuonTimingFillerTool'], allowMissing = True )) # Jet block from JetTagD3PDMaker.JetTagD3PDMakerFlags import JetTagD3PDFlags from JetTagD3PDMaker.JetTagD3PDMakerKeys import JetTagD3PDKeys if jetContainer != 'None': alg += JetD3PDObject (**_args ( 3, 'AK4TopoEMJet', kw, sgkey=jetContainer, allowMissing=True, prefix='jet_AntiKt4TopoEM_', JetVertexFraction_FromUD=True, JetVertexFraction_FillFullJVF=True, include = [ JetTagD3PDKeys.BTagWeightsBlockName(), JetTagD3PDKeys.TruthInfoBlockName() ] )) # Tau block if tauContainer != 'None': alg += TauD3PDObject (**_args ( 0, 'Tau', kw, allowMissing=True, sgkey=tauContainer )) # HF overlap removal (ALPGEN) from TopInputsD3PDMaker.HforD3PDObject import HforD3PDObject alg += HforD3PDObject(**_args (0, 'HforInfo', kw)) # MET blocks # a whole mess to remove x,y components separately for all flavours alg += MissingETD3PDObject (**_args (10, 'MissingET', kw, exclude=['MET_Base','MET_Base0','MET_Truth', 'MET_RefFinal_Comps','MET_RefFinal_Regions', 'MET_LocHadTopo_Comps','MET_LocHadTopo_Regions', 'MET_CellOut_Comps','MET_CellOut_Regions', 'MET_Calib', 'MET_CorrTopo', 'MET_Cryo', 'MET_CryoCone', 'MET_Final', 'MET_LocHadTopoObj', 'MET_Muid', 'MET_Muid_Spectro', 'MET_Muid_Track', 'MET_MuonBoy', 'MET_MuonBoy_Spectro', 'MET_MuonBoy_Track', 'MET_MuonMuid', 'MET_Muon', 'MET_Muon_Isol_Muid', 'MET_Muon_Isol_Staco', 'MET_Muon_NonIsol_Muid', 'MET_Muon_NonIsol_Staco', 'MET_Muon_Total_Muid', 'MET_Muon_Total_Staco', 'MET_RefEle_Comps','MET_RefEle_Regions', 'MET_RefEle_em_Comps','MET_RefEle_em_Regions', 'MET_RefGamma_Comps','MET_RefGamma_Regions', 'MET_RefGamma_em_Comps','MET_RefGamma_em_Regions', 'MET_RefJet_Comps','MET_RefJet_Regions', 'MET_RefJet_em_Comps','MET_RefJet_em_Regions', 'MET_RefMuon_Comps','MET_RefMuon_Regions', 'MET_RefMuon_Muid_Comps','MET_RefMuon_Muid_Regions', 'MET_RefMuon_Staco_Comps','MET_RefMuon_Staco_Regions', 'MET_RefMuon_Track_Muid_Comps','MET_RefMuon_Track_Muid_Regions', 'MET_RefMuon_Track_Staco_Comps','MET_RefMuon_Track_Staco_Regions', 'MET_RefMuon_Track_em_Comps','MET_RefMuon_Track_em_Regions', 'MET_RefMuon_Track_Comps','MET_RefMuon_Track_Regions', 'MET_RefMuon_em_Comps','MET_RefMuon_em_Regions', 'MET_RefTau_Comps','MET_RefTau_Regions', 'MET_RefTau_em_Comps','MET_RefTau_em_Regions', 'MET_SoftJets_Comps','MET_SoftJets_Regions', 'MET_SoftJets_em_Comps','MET_SoftJets_em_Regions', 'MET_Topo', 'MET_TopoObj_Comps','MET_TopoObj_Regions', 'MET_Track_Comps','MET_Track_Regions', 'MET_Comps', 'MET_Track_Weights','MET_Cluster_Weights', 'MET_Regions','MET_Composition'], allowMissing=True )) # HadronicRecoil blocks alg += ElectronD3PDObject(0, sgkey = 'HR_selectedElectrons', prefix = 'hr_el_',allowMissing=True ) alg += MuonD3PDObject( 0, sgkey = 'HR_selectedMuons', prefix = 'hr_mu_', allowMissing=True ) # ... DR = 0.15 alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_15', prefix = 'hr_roughRecoil_15', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_15', prefix = 'hr_ueCorrection_15', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_15', prefix = 'hr_corrRecoil_15', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_15', prefix = 'hr_MET_15', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_Eflow_15', prefix = 'hr_roughRecoil_Eflow_15', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_Eflow_15', prefix = 'hr_ueCorrection_Eflow_15', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_Eflow_15', prefix = 'hr_corrRecoil_Eflow_15', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_Eflow_15', prefix = 'hr_MET_Eflow_15', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_track_15", prefix = "hr_roughRecoil_track_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_track_15", prefix = "hr_ueCorrection_track_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_track_15", prefix = "hr_corrRecoil_track_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "MET_HR_track_15", prefix = "hr_MET_track_15", exclude=['MET_Regions','MET_Comps'] ) # ... DR = 0.20 alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_20', prefix = 'hr_roughRecoil_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_20', prefix = 'hr_ueCorrection_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_20', prefix = 'hr_corrRecoil_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_20', prefix = 'hr_MET_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_track_20', prefix = 'hr_roughRecoil_track_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_track_20', prefix = 'hr_ueCorrection_track_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_track_20', prefix = 'hr_corrRecoil_track_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_track_20', prefix = 'hr_MET_track_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_clusNoTrack_20', prefix = 'hr_roughRecoil_clusNoTrack_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_clusNoTrack_20', prefix = 'hr_ueCorrection_clusNoTrack_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_clusNoTrack_20', prefix = 'hr_corrRecoil_clusNoTrack_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_clusNoTrack_20', prefix = 'hr_MET_clusNoTrack_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_Eflow_20', prefix = 'hr_roughRecoil_Eflow_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_Eflow_20', prefix = 'hr_ueCorrection_Eflow_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_Eflow_20', prefix = 'hr_corrRecoil_Eflow_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_Eflow_20', prefix = 'hr_MET_Eflow_20', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) # ... DR = 0.25 alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_25', prefix = 'hr_roughRecoil_25', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_25', prefix = 'hr_ueCorrection_25', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_25', prefix = 'hr_corrRecoil_25', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_25', prefix = 'hr_MET_25', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RoughRecoil_Eflow_25', prefix = 'hr_roughRecoil_Eflow_25', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'ueCorrection_Eflow_25', prefix = 'hr_ueCorrection_Eflow_25', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'RefinedRecoil_Eflow_25', prefix = 'hr_corrRecoil_Eflow_25', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = 'MET_HR_Eflow_25', prefix = 'hr_MET_Eflow_25', exclude=['MET_Regions','MET_Comps'], allowMissing=True ) alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_track_25", prefix = "hr_roughRecoil_track_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_track_25", prefix = "hr_ueCorrection_track_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_track_25", prefix = "hr_corrRecoil_track_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "MET_HR_track_25", prefix = "hr_MET_track_25", exclude=['MET_Regions','MET_Comps'] ) # HR using truth leptons if rec.doTruth(): ## ... DR = 0.15 alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_15", prefix = "hr_roughRecoil_trLep_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_15", prefix = "hr_ueCorrection_trLep_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_15", prefix = "hr_corrRecoil_trLep_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_15", prefix = "hr_MET_trLep_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_Eflow_15", prefix = "hr_roughRecoil_trLep_Eflow_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_Eflow_15", prefix = "hr_ueCorrection_trLep_Eflow_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_Eflow_15", prefix = "hr_corrRecoil_trLep_Eflow_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_Eflow_15", prefix = "hr_MET_trLep_Eflow_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_track_15", prefix = "hr_roughRecoil_trLep_track_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_track_15", prefix = "hr_ueCorrection_trLep_track_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_track_15", prefix = "hr_corrRecoil_trLep_track_15", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_track_15", prefix = "hr_MET_trLep_track_15", exclude=['MET_Regions','MET_Comps'] ) ## ... DR = 0.20 alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_20", prefix = "hr_roughRecoil_trLep_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_20", prefix = "hr_ueCorrection_trLep_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_20", prefix = "hr_corrRecoil_trLep_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_20", prefix = "hr_MET_trLep_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_Eflow_20", prefix = "hr_roughRecoil_trLep_Eflow_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_Eflow_20", prefix = "hr_ueCorrection_trLep_Eflow_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_Eflow_20", prefix = "hr_corrRecoil_trLep_Eflow_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_Eflow_20", prefix = "hr_MET_trLep_Eflow_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_track_20", prefix = "hr_roughRecoil_trLep_track_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_track_20", prefix = "hr_ueCorrection_trLep_track_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_track_20", prefix = "hr_corrRecoil_trLep_track_20", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_track_20", prefix = "hr_MET_trLep_track_20", exclude=['MET_Regions','MET_Comps'] ) ## ... DR = 0.25 alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_25", prefix = "hr_roughRecoil_trLep_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_25", prefix = "hr_ueCorrection_trLep_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_25", prefix = "hr_corrRecoil_trLep_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_25", prefix = "hr_MET_trLep_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_Eflow_25", prefix = "hr_roughRecoil_trLep_Eflow_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_Eflow_25", prefix = "hr_ueCorrection_trLep_Eflow_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_Eflow_25", prefix = "hr_corrRecoil_trLep_Eflow_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_Eflow_25", prefix = "hr_MET_trLep_Eflow_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RoughRecoil_TruthLep_track_25", prefix = "hr_roughRecoil_trLep_track_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "ueCorrection_TruthLep_track_25", prefix = "hr_ueCorrection_trLep_track_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_track_25", prefix = "hr_corrRecoil_trLep_track_25", exclude=['MET_Regions','MET_Comps'] ) alg += MissingETD3PDObject( 0, sgkey = "RefinedRecoil_TruthLep_track_25", prefix = "hr_MET_trLep_track_25", exclude=['MET_Regions','MET_Comps'] ) # Cluster block # ... all clusters, very low LOD if clusterContainer != 'None': alg += ClusterD3PDObject (**_args ( 0, 'Clusters', kw, sgkey = clusterContainer, exclude='SamplingBasics', allowMissing=True )) # Track block # ... good tracks only (nSCT>=6; no pt cut) if trackContainer != 'None': alg += TrackParticleD3PDObject (**_args ( 3, 'Tracks', kw, sgkey = trackContainer, label = 'trk', prefix = 'trk_', allowMissing=True )) # Primary vertex block - May be missing in single-beam data. alg += PrimaryVertexD3PDObject (**_args (1, 'PrimaryVertex', kw, sgkey = D3PDMakerFlags.VertexSGKey(), prefix = 'vxp_', allowMissing=True )) # Truth if rec.doTruth(): from TruthD3PDMaker.TruthParticleD3PDObject import TruthParticleD3PDObject from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject alg += TruthMuonD3PDObject (**_args ( 2, 'TruthMuon', kw)) from AthenaCommon.AppMgr import ToolSvc from TruthD3PDAnalysis.TruthD3PDAnalysisConf import D3PD__GenObjectsFilterTool # ... remove empty GenEvents smlightGenEvtFilterTool = D3PD__GenObjectsFilterTool( "smlightGenEvtFilterTool" ) ToolSvc += smlightGenEvtFilterTool smlightGenEvtFilterTool.RemoveDummyEvents = True smlightGenEvtFilterTool.RemoveInTimePileUp = True smlightGenEvtFilterTool.Remove2BCPileUp = True smlightGenEvtFilterTool.Remove800nsPileUp = True smlightGenEvtFilterTool.RemoveCavernBkg = True smlightGenEvtFilterTool.RemoveEmptyEvents = True from TruthD3PDMaker.GenEventD3PDObject import GenEventD3PDObject alg += GenEventD3PDObject (**_args ( 0, 'GenEvent', kw, filter = smlightGenEvtFilterTool )) # ... leptonic W/Z truth information smlightLepWZFilterTool = D3PD__GenObjectsFilterTool( "smlightLepWZFilterTool" ) ToolSvc += smlightLepWZFilterTool smlightLepWZFilterTool.RemoveInTimePileUp = True smlightLepWZFilterTool.Remove2BCPileUp = True smlightLepWZFilterTool.Remove800nsPileUp = True smlightLepWZFilterTool.RemoveCavernBkg = True smlightLepWZFilterTool.RemoveEmptyEvents = True smlightLepWZFilterTool.RemoveDummyEvents = True smlightLepWZFilterTool.RemoveUnrequestedParticles=True smlightLepWZFilterTool.KeepLeptonicWZBosons=True smlightLepWZFilterTool.KeepLeptonicWZBosonDecayChains=True smlightLepWZFilterTool.KeepLeptonicWZBosonsParents=True from TruthD3PDMaker.GenParticleD3PDObject import GenParticleD3PDObject alg += GenParticleD3PDObject( **_args(10, "lepwzgenparticle", kw, prefix='mclepwzpart_', filter = smlightLepWZFilterTool, label = "LepWZTruthD3PDObject", exclude = ["GenPartProdVertexAssoc","GenPartDecayVertexAssoc"], GenParticle_WriteMotherType=False, GenParticle_WriteMotherBarcode=False, GenPartMotherAssoc_target="LepWZTruthD3PDObject", GenPartChildAssoc_target="LepWZTruthD3PDObject" ) ) if not rec.doTruth(): alg += BeamSpotD3PDObject(10) # Trigger if D3PDMakerFlags.DoTrigger(): # RedefineTriggerBits(alg, 'EF*') # alg += SMWZLightTriggerBitsD3PDObject (**_args (10, 'SMWZLightTriggerBits', kw)) # metadata addTrigConfMetadata(alg) # Bunch group info alg += BGCodeD3PDObject (**_args (2, 'BGCode', kw)) # Egamma EF information alg += EFElectronD3PDObject(0, name='trig_EF_el_', sgkey='HLT_egamma_Electrons,HLT_egamma', prefix='trig_EF_el_', exclude=['Author','IsEM','IsEMCuts'], include=['Triggers'], allowMissing = True) # alg += EFPhotonD3PDObject(0, name='trig_EF_ph_', # sgkey='HLT_egamma_Photons,HLT_egamma', # prefix='trig_EF_ph_', # exclude=['Author','Conversion0','IsEM','IsEMCuts'], # include=['Triggers'], # allowMissing = True) # Muon EF information alg += TrigMuonEFInfoD3PDObject(0, include=['Decision'], exclude=['TrackDetails','SpectrometerTrackBasics','ExtrapolatedTrackBasics'], allowMissing = True) alg += TrigMuonEFInfoD3PDObject(0, name = "trig_EF_trigmugirl_", sgkey = "HLT_eMuonEFInfo", prefix = "trig_EF_trigmugirl_", exclude=['TrackDetails','SpectrometerTrackBasics','ExtrapolatedTrackBasics'], include=['Decision'], allowMissing = True) # MET EF information # alg += TrigMETD3PDObject(**_args ( 0, 'TrigMETEF', kw, # prefix = "trig_EF_met_", # sgkey = "HLT_TrigEFMissingET" )) # Event metadata alg.MetadataTools += [LBMetadataConfig()] if D3PDMakerFlags.FilterCollCand(): from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg alg.filterSeq += CollisionFilterAlg (tuplename + '_CollCandFilter') return alg
def 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