def BuildVertexD3PDObject(_prefix='vx_', _label='vx', _sgkey=D3PDMakerFlags.VertexSGKey(), _object_name='PrimaryVertexD3PDObject', trackTarget='trk', trackPrefix='trk_', trackType='Rec::TrackParticleContainer'): object = make_SGDataVector_D3PDObject ( 'VxContainer', _sgkey, _prefix, _object_name, default_allowMissing = True, allow_args = ['storeVertexTrackAssociation', 'storeVertexTrackIndexAssociation', 'storeDiagonalCovarianceAsErrors', 'storeVertexType', 'storeVertexFitQuality', 'storeVertexKinematics', 'storeVertexPurity', 'vertexPositionLevelOfDetails', 'doTruth']) DefineVertexD3PDObject(object, trackTarget, trackPrefix, trackType) return object
import MuonD3PDMaker import D3PDMakerCoreComps import EventCommonD3PDMaker from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags from MuonD3PDMaker.MuonD3PDMakerFlags import MuonD3PDFlags from RecExConfig.RecFlags import rec #from MuonD3PDMaker.MuonD3PDMakerConf import MuonWZTruthTool #TruthTool = MuonWZTruthTool() #ToolSvc += TruthTool MuonSegmentD3PDObject = \ make_SGDataVector_D3PDObject ('Trk::SegmentCollection', D3PDMakerFlags.MuonSegmentSGKey(), 'mu_seg_', 'MuonSegmentD3PDObject') MuonSegmentD3PDObject.defineBlock (1, 'Location', MuonD3PDMaker.MuonSegmentLocationFillerTool) MuonSegmentD3PDObject.defineBlock (1, 'Author', MuonD3PDMaker.MuonSegmentAuthorFillerTool) MuonSegmentD3PDObject.defineBlock (1, 'FitQuality', MuonD3PDMaker.MuonSegmentFitQualityFillerTool) # Include the chamber t0 for the relevant MuonSegment collection, leave out the other MuonSegmentD3PDObject.defineBlock (1, 'MuonboySegmentT0', MuonD3PDMaker.MuonSegmentT0FillerTool,doMuonBoyCSCTiming=True) MuonSegmentD3PDObject.defineBlock (1, 'MooreSegmentT0', MuonD3PDMaker.MuonSegmentT0FillerTool,doMuonBoyCSCTiming=False)
from TriggerD3PDMaker.defineTriggerBits import defineTriggerBits from AthenaCommon.AlgSequence import AlgSequence from RecExConfig.RecFlags import rec import egammaD3PDMaker import EventCommonD3PDMaker import TrackD3PDMaker import CaloD3PDMaker import D3PDMakerCoreComps from ROOT import egammaParameters from ROOT import egammaPID ElectronD3PDObject = \ make_SGDataVector_D3PDObject ('ElectronContainer', D3PDMakerFlags.ElectronSGKey(), 'el_', 'QcdElectronD3PDObject') def _electronAlgHook(c, prefix, sgkey, typeName, seq=AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()), *args, **kw): ElectronUserDataConfig(seq=seq, prefix=prefix, sgkey=sgkey, typeName=typeName)
#### TauRec block #### import TrackD3PDMaker from D3PDMakerCoreComps.ContainedVectorMultiAssociation import ContainedVectorMultiAssociation from D3PDMakerCoreComps.SimpleAssociation import SimpleAssociation #Test A from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags from TauD3PDMaker.TauD3PDMakerConf import D3PD__TauPIDFillerTool from TauD3PDMaker.TauD3PDMakerConf import D3PD__TauJetFillerTool from TauD3PDMaker.TauD3PDMakerConf import D3PD__TauTrackAssociationTool from TauD3PDMaker.TauD3PDMakerConf import D3PD__TauTrackToOriginFillerTool import EventCommonD3PDMaker TauD3PDObject = make_SGDataVector_D3PDObject("Analysis::TauJetContainer", D3PDMakerFlags.TauSGKey(), "tau_", "TauD3PDObject") TauD3PDObject.defineBlock(0, 'Kinematics', EventCommonD3PDMaker.FourMomFillerTool, WriteEt=True, WritePt=True) TauD3PDObject.defineBlock(0, 'Charge', EventCommonD3PDMaker.ChargeFillerTool) TauD3PDObject.defineBlock(0, 'PID', D3PD__TauPIDFillerTool) TauD3PDObject.defineBlock(0, 'TauJet', D3PD__TauJetFillerTool) TauD3PDObject.defineBlock(0, 'TracksToOrigin', D3PD__TauTrackToOriginFillerTool) # Associate tau with its tracks TauTrackAssoc = ContainedVectorMultiAssociation \ (TauD3PDObject, D3PD__TauTrackAssociationTool,prefix='track_')
from CaloD3PDMaker.CaloCellD3PDObject import SelCaloCellD3PDObject scell_alg = MakerAlg ('scells', file = 'scells.root') scell_alg += EventInfoD3PDObject (0) scell_alg += AllCaloCellD3PDObject (2, sgkey = 'SCells', prefix = 'sc_', include = ['RawPosition']) d3pd_tests += [('scells.root', 'scells.ref')] # Test LeadingPtAssociationTool. from D3PDMakerCoreComps.SimpleAssociation import SimpleAssociation from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject import EventCommonD3PDMaker TestJetD3PDObject = make_SGDataVector_D3PDObject ('JetCollection', 'AntiKt4TopoEMJets,' + 'AntiKt4TopoJets,' + 'AntiKt4H1TopoJets', 'testjet_', 'testjet') TestJetD3PDObject.defineBlock (0, 'Kin', EventCommonD3PDMaker.FourMomFillerTool) LeadingConstitAssoc = SimpleAssociation \ (TestJetD3PDObject, EventCommonD3PDMaker.LeadingPtAssociationTool, level = 0, prefix = 'lconstit_', blockname = 'LeadingConstitAssoc', MultiAssocTool = EventCommonD3PDMaker.NavigableConstituentAssociationTool ('LeadingConstitMAssoc', TypeName = 'CaloCluster')) LeadingConstitAssoc.defineBlock (0, 'LeadKin', EventCommonD3PDMaker.FourMomFillerTool)
from D3PDMakerCoreComps.ContainedVectorMultiAssociation import ContainedVectorMultiAssociation #import TrigMuonD3PDMaker import TruthD3PDMaker from RecExConfig.RecFlags import rec from RecExConfig.ObjKeyStore import cfgKeyStore from AthenaCommon.AppMgr import ToolSvc from AthenaCommon.Include import include from MuonD3PDMaker.MuonD3PDMakerFlags import MuonD3PDFlags MuonD3PDObject = \ make_SGDataVector_D3PDObject ('DataVector<xAOD::Muon_v1>', D3PDMakerFlags.MuonSGKey(), 'mu_', 'MuonD3PDObject') MuonD3PDObject.defineBlock(0, 'Kinematics', EventCommonD3PDMaker.FourMomFillerTool, WriteRect=True, WriteE=True, WriteM=True) MuonD3PDObject.defineBlock(0, 'AllAuthor', D3PDMakerCoreComps.AuxDataFillerTool, Vars=['allauthor = allAuthors']) MuonD3PDObject.defineBlock(1, 'Authors',
def getJetD3PDObject(objectname='JetD3PDObject', prefix='jet_', btagleveloffset=7): object = make_SGDataVector_D3PDObject('DataVector<xAOD::Jet_v1>', D3PDMakerFlags.JetSGKey(), prefix, objectname) # object.defineHook (_fixJetTiming) # object.defineHook (_jetVertexAlgHook) # object.defineHook (_jetMomentsHook) # object.defineHook (_jetClusterMomentsHook) object.defineBlock(0, 'Kinematics', EventCommonD3PDMaker.FourMomFillerTool, WriteE=True) # object.defineBlock(1, 'OriginCorrection', # JetD3PDMaker.JetMomentFillerTool, # Moments=['EtaOrigin' , 'PhiOrigin' , 'MOrigin' # ]) # object.defineBlock(1, 'WIDTH', # JetD3PDMaker.JetMomentFillerTool, # Moments=['WIDTH' # ]) object.defineBlock(1, 'DQMoments', D3PDMakerCoreComps.AuxDataFillerTool, Vars=[ 'n90 = N90Cells < int: 0', 'Timing < float: 0', 'LArQuality < float: 0', 'OriginIndex < float: 0', 'HECQuality < float: 0', 'NegativeE < float: 0', 'AverageLArQF < float: 0', 'BCH_CORR_CELL = BchCorrCell < float:0', 'BCH_CORR_DOTX = BchCorrDotx < int:0', 'BCH_CORR_JET = BchCorrJet < int:0', 'BCH_CORR_JET_FORCELL = BchCorrJetForCell < int:0', 'NumTowers < float: 0', 'ootFracCells5 < float: 0', 'ootFracCells10 < float: 0', 'ootFracClusters5 < float: 0', 'ootFracClusters10 < float: 0', ]) # object.defineBlock(1, 'JetSamplingsFrac', # JetD3PDMaker.JetSamplingsFracFillerTool) # object.defineBlock(1, 'JetQual', # JetD3PDMaker.JetCaloUtilsFillerTool) object.defineBlock(1, 'JetQual', D3PDMakerCoreComps.AuxDataFillerTool, Vars=[ 'isBadLoose < int: 0', 'isBadMedium < int: 0', 'isBadTight < int: 0', 'isUgly < int: 0', 'hecf = HECFrac < float: 0', ]) # object.defineBlock(1, 'EMFraction', # JetD3PDMaker.JetEMFractionFillerTool) # object.defineBlock(1, 'JES', # JetD3PDMaker.JetMomentFillerTool, # Moments=[ 'Offset', 'EMJES', 'EMJES_EtaCorr','EMJESnooffset' ]) # object.defineBlock(1, 'JESMoments', # JetD3PDMaker.JetMomentFillerTool, # Moments=['LCJES', 'LCJES_EtaCorr' ]) # object.defineBlock(1, 'EMScale', # JetD3PDMaker.JetSignalStateFillerTool, # WriteE = True, # SignalStateNumber = 0, # SignalStatePrefix = 'emscale') # object.defineBlock(1, 'ActiveArea', # JetD3PDMaker.JetMomentFillerTool, # Moments=['ActiveArea', 'ActiveAreaPx', 'ActiveAreaPy', 'ActiveAreaPz', 'ActiveAreaE']) # # Including JetVertexFraction should also include JVtx and TruthMF, # # unless explicitly excluded. # def _jvfLOD (reqlev, args, hookargs): # if reqlev < 3: return False # if not 'JVtx' in hookargs['exclude']: # hookargs['include'].append ('JVtx') # if not 'TruthMF' in hookargs['exclude']: # hookargs['include'].append ('TruthMF') # return True # try: # # tracksAvailableForJets not defined in every release. Temporarily put it in # # a try / except block # from JetRec.TrackSelectionForJets import tracksAvailableForJets # dotrackVars = tracksAvailableForJets() # except: # dotrackVars = True # if dotrackVars: # object.defineBlock(_jvfLOD, 'JetVertexFraction', # JetD3PDMaker.JetVertexFractionFillerTool, # UDPrefix=D3PDMakerFlags.JetUserDataPrefix(), # ) # object.defineBlock(3, 'JVtx', # JetD3PDMaker.JetVtxFillerTool) # object.defineBlock(3, 'TruthMF', # JetD3PDMaker.JetMomentFillerTool, # Moments=['TruthMFindex','TruthMF']) # object.defineBlock(3, 'Layer', # JetD3PDMaker.JetMomentFillerTool, # Moments=['GSCFactorF','WidthFraction']) # object.defineBlock(4, 'Samplings', # JetD3PDMaker.JetSamplingsFillerTool) # object.defineBlock(4, 'JetShape', # JetD3PDMaker.JetShapeFillerTool) # object.defineBlock(4, 'Constituents', # JetD3PDMaker.JetConstituentFillerTool, # SignalStateNumber = -1, # SignalStatePrefix = 'default') # object.defineBlock(4, 'ConstituentScale', # JetD3PDMaker.JetSignalStateFillerTool, # WriteE = True, # SignalStateNumber = 2, # SignalStatePrefix = 'constscale') # object.defineBlock(5, 'JetLArHVMoment', # JetD3PDMaker.JetMomentFillerTool, # Moments=['LArBadHVEnergy','LArBadHVRatio']) # object.defineBlock(9, 'JetClusterMoment', # JetD3PDMaker.JetMomentFillerTool, # Moments=['CENTER_LAMBDA','SECOND_R','SECOND_LAMBDA', # 'CLUSTER_PT']) # addBTagInfoToJetObject(object,btagleveloffset) # # Track association cannot be done unless there are tracks. # # As often this is not the case track association will be done only # # if this is explicitly asked for. by defining it in the include list. # # # # You can also enable it by passing an argument to JetD3PDObject # # like: # # AssocTrackCont_target='mytarget_' # def _jetAssocLevel (reqlev, args): # return args.has_key ('target') or (reqlev >= 999) # IndexMultiAssociation (object, # JetD3PDMaker.FlavorAssociationTool, # 'trk', # prefix = 'flavor_assoctrk_', # level = _jetAssocLevel, # blockname = 'AssocTrackCont') # object.defineBlock(10, 'JetRoIword', # JetD3PDMaker.JetROIWordFillerTool # ) # #JetElAssoc = DRAssociation(object,"ElectronContainer",D3PDMakerFlags.ElectronSGKey(),0.2,prefix='el_',matched="matched",blockname="El02Match") # #JetMuAssoc = DRAssociation(object,"Analysis::MuonContainer",D3PDMakerFlags.MuonSGKey(),0.2,prefix='mu_',matched="matched",blockname="Mu02Match") # #JetTrkAssoc = DRAssociation(object,"Rec::TrackParticleContainer",D3PDMakerFlags.TrackSGKey(),0.4,prefix='trk_',matched="matched",blockname="Trk04Match") # #---------------- Trigger Object ---------------------------- # #if D3PDMakerFlags.DoTrigger(): # if False: # JetL1Assoc = SimpleAssociation(object, # JetD3PDMaker.JetL1TriggerObjectAssociationTool, # matched = 'matched', # blockname = 'L1Info', # prefix = 'L1_', # MaxDR = 0.6, # ChainPattern = 'L1_J.*') # JetL1Assoc.defineBlock (99, 'L1Kinematics', # EventCommonD3PDMaker.FourMomFillerTool, # WriteE = True, # WriteEt = False, # WriteM = False) # JetL2Assoc = SimpleAssociation(object, # JetD3PDMaker.JetL2TriggerObjectAssociationTool, # matched = 'matched', # blockname = 'L2Info', # prefix = 'L2_', # MaxDR = 0.25, # ChainPattern = 'L2_j.*') # JetL2Assoc.defineBlock (99, 'L2Kinematics', # EventCommonD3PDMaker.FourMomFillerTool, # WriteE = True, # WriteEt = False, # WriteM = False) # JetEFAssoc = SimpleAssociation(object, # JetD3PDMaker.JetEFTriggerObjectAssociationTool, # matched = 'matched', # blockname = 'EFInfo', # prefix = 'EF_', # MaxDR = 0.25, # ChainPattern = 'EF_j.*') # JetEFAssoc.defineBlock (99, 'EFKinematics', # EventCommonD3PDMaker.FourMomFillerTool, # WriteE = True, # WriteEt = False, # WriteM = False) # pass # ConstitAssoc = ContainedVectorMultiAssociation \ # (object, # #JetD3PDMaker.JetConstituentAssociationTool, # EventCommonD3PDMaker.NavigableConstituentAssociationTool, # 'constit_', # TypeName = 'CaloCluster', # nrowName = '', # level = 1) # ConstitAssoc.defineBlock (_constitAssocLevel, 'ConstitIndex', # D3PDMakerCoreComps.IndexFillerTool, # Target = '') # # Beam Background Identification Method # object.defineBlock( 999, 'BeamBackground', # BackgroundD3PDMaker.BeamBackgroundJetFillerTool) # #---------------- special jet moments ---------------------------- # object.defineBlock(999, 'TrackMF', # JetD3PDMaker.JetMomentFillerTool, # Moments=['TrackMFindex','TrackMF']) # object.defineBlock(999, 'TracksMoments', # JetD3PDMaker.JetMomentFillerTool, # Moments=['nTrk_pv0_1GeV', 'sumPtTrk_pv0_1GeV', 'nTrk_allpv_1GeV', 'sumPtTrk_allpv_1GeV', # 'nTrk_pv0_500MeV', 'sumPtTrk_pv0_500MeV', # 'trackWIDTH_pv0_1GeV','trackWIDTH_allpv_1GeV' # ]) # object.defineBlock(999, 'JetLabel', # JetD3PDMaker.JetMomentFillerTool, # Moments=['JetLabel']) # object.defineBlock(999, 'Special', # JetD3PDMaker.JetMomentFillerTool, # Moments=['LikeLihood_0', # 'LowEtConstituentsFrac','KtDr', # ]) # object.defineBlock(999, 'VoronoiArea', # JetD3PDMaker.JetMomentFillerTool, # Moments=['VoronoiArea', 'VoronoiAreaPx', 'VoronoiAreaPy', 'VoronoiAreaPz', 'VoronoiAreaE', # ]) # object.defineBlock(999, 'Isolation', # JetD3PDMaker.JetMomentFillerTool, # Moments=['IsoKR20Perp', 'IsoKR20Par', 'IsoKR20SumPt', 'IsoDelta2Perp', 'IsoDelta2Par', # 'IsoDelta2SumPt', 'IsoFixedCone8Perp', 'IsoFixedCone8Par', 'IsoFixedCone8SumPt', # 'IsoFixedArea13Perp', 'IsoFixedArea13Par', 'IsoFixedArea13SumPt', # 'Iso6To88Perp', 'Iso6To88Par', 'Iso6To88SumPt', # ]) # object.defineBlock(999, 'SplitInfo', # JetD3PDMaker.JetMomentFillerTool, # Moments=['SPLIT12', 'SPLIT23', 'SPLIT34']) # object.defineBlock(999, 'Uncertainties', # JetD3PDMaker.JetMomentFillerTool, # Moments=['SmearingFactor']) return object
# from AthenaCommon.AlgSequence import AlgSequence from RecExConfig.RecFlags import rec import egammaD3PDMaker # import egammaD3PDAnalysis import EventCommonD3PDMaker # import CaloD3PDMaker import D3PDMakerCoreComps import TruthD3PDMaker import TrackD3PDMaker PhotonD3PDObject = \ make_SGDataVector_D3PDObject ('xAOD::PhotonContainer', D3PDMakerFlags.PhotonSGKey(), 'ph_', 'PhotonD3PDObject') # AuxPrefix args need to be deferred in order to add in the sgkey. auxprefix = DeferArg( 'D3PDMakerFlags.EgammaUserDataPrefix() + "_" +' 'resolveSGKey (typeName, sgkey) + "_"', globals()) PhotonD3PDObject.defineBlock(0, 'Kinematics', EventCommonD3PDMaker.FourMomFillerTool, WriteE=True, WriteEt=True, WriteRect=True) PhotonD3PDObject.defineBlock(0, 'Author',
def commonD3PD( alg=None, file='physics.root', tuplename='physics', streamname='d3pdstream', 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', jetEM6Container='AntiKt6TopoEMJets', jetLC4Container='AntiKt4LCTopoJets', jetLC6Container='AntiKt6LCTopoJets', **kw): flags = CommonD3PDMakerFlags # define track and cluster filters preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()) if not hasattr(preseq, "GoodTracks"): filter1 = makeTrackFilterAlg(TracksName=D3PDMakerFlags.TrackSGKey(), OutputTracksName='GoodTracks', ptCut=0.) 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 if not hasattr(preseq, "SUSYTrackCandidate"): filter5 = makeTrackFilterAlg(TracksName=D3PDMakerFlags.TrackSGKey(), OutputTracksName='SUSYTrackCandidate', ptCut=10000.) preseq += filter5 # perform recoil calculation from HadronicRecoil.Configurables import add_hadronic_recoil_filters preseq = 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)) addBunchStructureMetadata(alg) if flags.doEventShape(): alg += EventShapeD3PDObject(**_args(10, 'rho', kw)) if flags.doMuonSpShower2(): alg += MuonSpShowerD3PDObject(**_args(10, 'MuonSpShower', kw)) alg += BackgroundWordD3PDObject(**_args(0, 'BkgWord', kw)) alg += BeamBackgroundD3PDObject(1) alg += DefaultV0D3PDObject(**_args(1, 'V0Objects', kw)) from D3PDMakerConfig.addTauD3PDInfo import addTauD3PDInfo addTauD3PDInfo(alg, file, tuplename, kw) # Eta rings of energy 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 if (stdElectronContainer != 'None'): alg += ElectronD3PDObject(**_args(10, 'Electron', kw, sgkey=stdElectronContainer, include=flags.electronInclude())) if (gsfElectronContainer != 'None') and testSGKey('ElectronContainer', gsfElectronContainer): alg += GSFElectronD3PDObject(**_args(10, 'GSFElectron', kw, sgkey=gsfElectronContainer, prefix='el_gsf_', include=flags.electronInclude())) # define associations if not PhotonD3PDObject.allBlocknames().has_key('RecoveryMatch'): from PhotonD3PDMaker.PhotonRecoveryAssociation import PhotonRecoveryAssociation if (stdElectronContainer != 'None'): PhotonRecoveryAssoc = PhotonRecoveryAssociation( PhotonD3PDObject, 'ElectronContainer', stdElectronContainer, prefix='el_', include=['TrkFitQuality', 'Vertex'], blockname='RecoveryMatch', target='ph_ElectronRecovered_') if (photonContainer != 'None'): alg += PhotonD3PDObject( **_args(10, 'Photon', kw, sgkey=photonContainer, include=flags.photonInclude(), ConversionVertexTrackIndex_target="GSF_trk")) # Muon blocks ### Third muon chain variables! if doThirdMuonChain and muonContainer == 'None': muonContainer = 'Muons' if (muonContainer != 'None'): alg += myMuonD3PDObject(**_args(10, 'Muon', kw, sgkey=muonContainer, prefix='mu_', include=flags.muonInclude() + [ "EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex" ], allowMissing=True)) if (muidMuonContainer != 'None'): alg += myMuonD3PDObject(**_args(10, 'MuidMuon', kw, sgkey=muidMuonContainer, prefix='mu_muid_', include=flags.muonInclude() + [ "EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex" ], allowMissing=True)) if (stacoMuonContainer != 'None'): alg += myMuonD3PDObject(**_args(10, 'StacoMuon', kw, sgkey=stacoMuonContainer, prefix='mu_staco_', include=flags.muonInclude() + [ "EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex", "L2CBInfoIndex" ], allowMissing=True)) if (caloMuonContainer != 'None'): alg += myMuonD3PDObject(**_args( 10, 'CaloMuon', kw, sgkey=caloMuonContainer, prefix='mu_calo_', include=flags.muonInclude() + [ "MuonHitSummary", "Authors", "Likelihood", "CaloEnergyLoss", "Quality" ], #exclude = "Isolation")) allowMissing=True)) # add missingEt info from D3PDMakerConfig.addMissingEtInfo import addMissingEtInfo addMissingEtInfo(alg, file, tuplename, kw) # add Jets info from D3PDMakerConfig.addJetsInfo import addJetsInfo addJetsInfo(alg, file, tuplename, kw) from HiggsD3PDMaker.HSG2VertexReconstruction import addHSG2VertexReconstruction addHSG2VertexReconstruction(alg, muon_target="mu_") alg += HforD3PDObject(**_args(0, 'HforInfo', kw)) # HadronicRecoil blocks alg += ElectronD3PDObject(0, sgkey="HR_selectedElectrons", prefix="hr_el_") alg += MuonD3PDObject(0, sgkey="HR_selectedMuons", prefix="hr_mu_") # track and cluster blocks #alg += ClusterD3PDObject (**_args ( 0, 'Clusters1', kw, # include=['CenterMagMoments'])) #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_')) if flags.doClusterHad(): alg += ClusterD3PDObject(**_args(0, 'CaloCalTopoCluster', kw, prefix='cl_lc_', exclude='SamplingBasics', Kinematics_WriteE=False)) alg += ClusterD3PDObject( **_args(2, 'CaloCalTopoCluster', kw, prefix='cl_', exclude=['Kinematics', 'SamplingBasics'], Kinematics_WriteE=False)) if flags.doClusterEM(): alg += ClusterD3PDObject(**_args(0, 'CaloCalTopoCluster', kw, prefix='cl_em_', exclude='SamplingBasics', Kinematics_WriteE=False, Kinematics_SignalState=0)) # turn on detailed track info if writing SoftQCD version of D3PD if flags.doSoftQCD(): alg += TrackParticleD3PDObject( **_args(3, 'Tracks1', kw, sgkey='GoodTracks', label='trk', prefix='trk_', doTruth=True, TruthParticleTarget='mc_', storeDiagonalCovarianceAsErrors=True, storeHitTruthMatching=True, storePixelHitsOnTrack=False, storePixelHolesOnTrack=False, storePixelOutliersOnTrack=False, storeSCTHitsOnTrack=False, storeTrackFitQuality=True, storeTrackMomentum=True, storeTrackSummary=True, trackParametersAtBeamSpotLevelOfDetails=0, trackParametersAtGlobalPerigeeLevelOfDetails=1, trackParametersAtPrimaryVertexLevelOfDetails=2)) else: alg += TrackParticleD3PDObject(**_args( 10, 'Tracks3', kw, sgkey='SUSYTrackCandidate', label='trk10', prefix='trk10_', include=[ "Isolation", "Isolation_40_1GeV", "Isolation_40_2GeV", "Isolation_40_3GeV", "Isolation_40_3GeV_hitschi", "Isolation_40_4GeV", "Isolation_50_5GeV" ], TruthParticleTarget='mc_', trackParametersAtBeamSpotLevelOfDetails=2, trackParametersAtPrimaryVertexLevelOfDetails=2, #trackParametersAtBeamLineLevelOfDetails=2, # does not work?? trk_TrackSummary_FullInfo=False, doTruth=True)) alg += TrackParticleD3PDObject( **_args(10, 'Tracks1', kw, sgkey='GoodTracks', label='trk', prefix='trk_', exclude=['trk_IPEstimate'], TruthParticleTarget='mc_', trackParametersAtBeamSpotLevelOfDetails=1, trackParametersAtGlobalPerigeeLevelOfDetails=1, trackParametersAtPrimaryVertexLevelOfDetails=2, storeTrackParametersAtCalo=True, storeTrackParametersAtCalo2ndLayer=True, storeDiagonalCovarianceAsErrors=False, storeTrackInfo=True, storeHitTruthMatching=True, doTruth=True)) alg += TrackParticleD3PDObject( **_args(3, 'Tracks2', kw, sgkey='HighPtTracks', label='trk4', prefix='trkpt4_', exclude=['trk_IPEstimate'], doTruth=True, TruthParticleTarget='mc_', storeDiagonalCovarianceAsErrors=True, storeHitTruthMatching=True, storePixelHitsOnTrack=False, storePixelHolesOnTrack=False, storePixelOutliersOnTrack=False, storeSCTHitsOnTrack=False, storeSCTHolesOnTrack=False, storeSCTOutliersOnTrack=False, storeTRTHitsOnTrack=False, storeTRTHolesOnTrack=False, storeTRTOutliersOnTrack=False, storeTrackFitQuality=True, storeTrackMomentum=True, storeTrackSummary=True, trk_TrackSummary_IDOutliers=True, trk_TrackSummary_PixelInfoPlus=True, trk_TrackSummary_SCTInfoPlus=True, trk_TrackSummary_TRTInfoPlus=True, trk_TrackSummary_InfoPlus=True, trk_TrackSummary_MuonHits=True, trackParametersAtBeamSpotLevelOfDetails=0, trackParametersAtGlobalPerigeeLevelOfDetails=2, trackParametersAtPrimaryVertexLevelOfDetails=2, storeTrackParametersAtCalo=False)) # Primary vertex block - May be missing in single-beam data. alg += PrimaryVertexD3PDObject(**_args(3, 'PrimaryVertex', kw, allowMissing=True, sgkey=D3PDMakerFlags.VertexSGKey(), prefix='vxp_', include=['Error'])) # 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(): alg += TruthParticleD3PDObject( 10, sgkey=D3PDMakerFlags.TruthParticlesSGKey()) alg += TruthVertexD3PDObject( **_args(1, 'TruthVertex', kw, sgkey=D3PDMakerFlags.TruthSGKey())) alg += TruthMuonD3PDObject(**_args(2, 'TruthMuon', kw)) alg += GenEventD3PDObject(**_args( 1, 'GenEvent', kw)) #, filter = CoreTruthFilterTool() )) # ... heavy flavor truth information #from TruthD3PDMaker.TruthD3PDMakerKeys import TruthD3PDKeys #TruthD3PDKeys.TruthTrackGetterLabel.set_Value("D3PDTruth_TruthTrack") alg += GenVertexD3PDObject(**_args(0, "hfgenvertex", kw, prefix='mchfvtx_', filter=smwzhfGenVtxFilterTool)) alg += GenTruthTrackD3PDObject(**_args(0, "TruthTracks", kw)) alg += GenParticleD3PDObject( **_args(10, "hfgenparticle", kw, prefix='mchfpart_', filter=smwzhfGenPartFilterTool, GenParticle_WriteMotherType=False, GenParticle_WriteMotherBarcode=False)) # ... leptonic W/Z truth information 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")) alg += egammaTruthD3PDObject(0) if (SUSYD3PDFlags.includeSUSYHardProcess()): alg += SUSYHardProcessD3PDObject(**_args(0, 'HardProcess', kw)) # A dictionary of store gate keys and ntuple variable prefix truthParticleContainers = { 'TruthTopVertexContainer': 'mc_t_vx_', 'TruthWVertexContainer': 'mc_W_vx_', 'TruthZVertexContainer': 'mc_Z_vx_', 'TruthTopDecayContainer': 'mc_t_vx_end_', 'TruthWDecayContainer': 'mc_W_vx_end_', 'TruthZDecayContainer': 'mc_Z_vx_end_', 'TruthWTauContainer': 'mc_W_tau_', 'TruthZTauContainer': 'mc_Z_tau_' } #import D3PDMakerCoreComps from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject from TruthD3PDMaker import TruthParticleGenParticleAssociationTool for contKey, prefix in truthParticleContainers.iteritems(): truthPartObj = make_SGDataVector_D3PDObject( 'TruthParticleContainer', contKey, prefix, "truthPartObj") genPart = SimpleAssociation( truthPartObj, TruthParticleGenParticleAssociationTool) trupart2 = IndexAssociation( genPart, TruthD3PDMaker.GenParticleTruthParticleAssociationTool, target='mc_', Target='mc_') alg += truthPartObj(0, prefix) #if not rec.doTruth(): # alg += BeamSpotD3PDObject(10) # Trigger if D3PDMakerFlags.DoTrigger(): from PhysicsD3PDMaker.SMWZTriggerBitsD3PDObject import SMWZTriggerBitsD3PDObject alg += SMWZTriggerBitsD3PDObject(**_args(10, 'SMWZTriggerBits', kw)) alg += GenericTriggerBitsD3PDObject( **_args(10, 'GenericTriggerBits', kw)) alg += InitTrigD3PDObject(10) # Trigger Decision + metadata alg += TrigDecisionD3PDObject(**_args(10, 'TrigDecision', kw)) #addTrigConfMetadata(alg) ####### begin from TRIGBJET ######## from TriggerD3PDMaker.JetETROID3PDObject import JetETROID3PDObject from JetD3PDMaker.jetMETD3PDTrigger import jetMETTriggerBitsD3PDObject alg += jetMETTriggerBitsD3PDObject(10) alg += JetETROID3PDObject(10) # The L2 JE information: from TrigMissingETD3PDMaker.TrigMETD3PDObject import TrigMETD3PDObject alg += TrigMETD3PDObject(level=10, prefix="trig_L2_je_", sgkey="HLT_L2JetEtSum", allowMissing=True) ###### end from TRIGBJET ######## # Bunch group info alg += BGCodeD3PDObject(**_args(2, 'BGCode', kw)) # Egamma and Mu TrigEgammaD3PDObjects(alg, 10) TrigMuonD3PDObjects(alg, 10, addNaviInfo=True, addConfigInfo=True) alg += egammaTriggerBitsD3PDObject(**_args(0, 'egammaTriggerBits', kw)) alg += MuonTriggerBitsD3PDObject(**_args(2, 'MuonTriggerBits', kw)) alg += JetROID3PDObject( **_args(10, 'JetROI', kw, prefix="trig_L1_jet_")) alg += TrigJetD3PDObject(**_args(2, 'TrigJet', kw, sgkey='HLT_TrigT2CaloJet', prefix='trig_L2_jet_', allowMissing=True)) alg += EFJetD3PDObject(**_args(2, 'EFJet', kw, sgkey='HLT_TrigJetRec', prefix='trig_EF_jet_', allowMissing=True, include=['Triggers'])) # MET TrigMETD3PDObjects(alg) alg += METD3PDTriggerBitsObject(0) # The BJet information: TrigBJetD3PDObjects(alg, level=10, doAddL2ID=True, doAddEFID=True, addNaviInfo=True, addConfigInfo=True, addL1Jet=True) #, addOffTrack = True) alg += QcdTriggerBitsD3PDObject(**_args(10, 'TriggerBits', kw)) from TrigTauD3PDMaker.TrigTauD3PD import TrigTauD3PDObjects TrigTauD3PDObjects(alg, 2) # Event metadata alg.MetadataTools += [LBMetadataConfig()] alg.MetadataTools += [CutFlowMetadataConfig(alg)] # begin for add CutflowSvc #EventBookkeepers #from AthenaCommon.AppMgr import ServiceMgr as svcMgr #from OutputStreamAthenaPool.MultipleStreamManager import MSMgr #if not hasattr(svcMgr,"CutFlowSvc"): # from EventBookkeeperTools.EventBookkeeperToolsConf import CutFlowSvc # svcMgr+=CutFlowSvc() # pass #if rec.readAOD() or rec.readESD(): #force CutFlowSvc execution (necessary for file merging) # theApp.CreateSvc+=['CutFlowSvc'] # pass # Determine current skimming cycle and input stream name #from RecExConfig.InputFilePeeker import inputFileSummary #from RecExConfig.RecoFunctions import GetSkimCycle #inputCycle=GetSkimCycle(inputFileSummary) #if inputCycle<0: # currentCycle=1 #else: # currentCycle=inputCycle+1 # pass #svcMgr.CutFlowSvc.SkimmingCycle=currentCycle #svcMgr.CutFlowSvc.InputStream=rec.mergingStreamName() #Exception for DPD pass-through mode #if rec.doDPD.passThroughMode: # svcMgr.CutFlowSvc.SkimmingCycle=0 # svcMgr.CutFlowSvc.InputStream="Virtual" # pass #if rec.DPDMakerScripts()!=[] and not rec.doDPD.passThroughMode : # #Create a separate EventBookkeeper list to persistify skimming cycle info # from EventBookkeeperTools.BookkeepingInfoWriter import EventBookkeepersWriter # SkimmingCycleDefiner=EventBookkeepersWriter("SkimmingCycleDefiner") # SkimmingCycleDefiner.OutputCollectionName="cycle"+str(currentCycle) # SkimmingCycleDefiner.ParentStreamName=rec.mergingStreamName() # topSequence = AlgSequence() # topSequence+=SkimmingCycleDefiner # #Explicitely add file metadata from input and from transient store # MSMgr.AddMetaDataItemToAllStreams(inputFileSummary['metadata_itemsList']) # MSMgr.AddMetaDataItemToAllStreams( "LumiBlockCollection#*" ) # MSMgr.AddMetaDataItemToAllStreams( "EventBookkeeperCollection#*" ) # MSMgr.AddMetaDataItemToAllStreams( "IOVMetaDataContainer#*" ) # pass # end for add CutflowSvc if D3PDMakerFlags.FilterCollCand(): from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg alg.filterSeq += CollisionFilterAlg(tuplename + '_CollCandFilter') # Add BeamSpot information from TrackD3PDMaker.BeamSpotD3PDObject import BeamSpotD3PDObject alg += BeamSpotD3PDObject(10) #------------------------------------------------------------------------------------- # Diphoton information... in order to run this, need to have setup the diphoton # analysis algorithm. See CommonD3PD_prodJobOFragment.py. # from PhotonD3PDMaker.DiPhotonD3PDObject import DiPhotonD3PDObject alg += DiPhotonD3PDObject(**_args(10, 'DiPhoton', kw)) #------------------------------------------------------------------------------------- #from D3PDMakerCoreComps.resolveSGKey import testSGKey GSFTrackParticlesInSample = testSGKey('Rec::TrackParticleContainer', "GSFTrackParticleCandidate") if GSFTrackParticlesInSample: GSFTrackParticleD3PDObject = TrackD3PDObject( _label='trk', _prefix='trk_', _sgkey=D3PDMakerFlags.TrackSGKey(), _object_name='GSFTrackParticleD3PDObject', typeName='Rec::TrackParticleContainer', vertexTarget='PV_', vertexPrefix='PV_', vertexSGKey='VxPrimaryCandidate', truthTarget='mc', truthPrefix='mc_', detailedTruthPrefix='detailed_mc_', truthMapKey='GSFTrackParticleTruthCollection', SGKeyForTruth="GSFTrackParticleCandidate", detailedTruthMapKey='DetailedTrackTruth', SGKeyForDetailedTruth='Tracks', flags=TrackD3PDFlags) # add a flag for conversion tracks from TrackD3PDMaker import TrackParticleVertexAssociationTool from PhotonD3PDMaker import GSFOriginalTrackParticleAssociationTool convTrackAssociation = SimpleAssociation \ (GSFTrackParticleD3PDObject, TrackParticleVertexAssociationTool, prefix = 'GSF_conv_', blockname='ConversionTrackParticle', VxSGKey='AllPhotonsVxCandidates') origTrackAssociation = IndexAssociation \ (GSFTrackParticleD3PDObject, #PhotonD3PDMaker.GSFOriginalTrackParticleAssociationTool, GSFOriginalTrackParticleAssociationTool, target="trk", prefix="trk_", level=0, blockname="GSFOriginalTPAssoc", allowMissing=False, AssocGetter = D3PDMakerCoreComps.SGObjGetterTool ('GSFAssocGetter', SGKey = D3PDMakerFlags.GSFTrackAssocSGKey(), TypeName = 'TrackParticleAssocs')) alg += GSFTrackParticleD3PDObject(0, sgkey="GSFTrackParticleCandidate", label="GSF_trk", prefix="GSF_trk_") from PhotonD3PDMaker.PhotonPVD3PDObject import PVD3PDObject alg += PVD3PDObject(**_args(0, 'PrimaryVertex', kw, allowMissing=True, sgkey=D3PDMakerFlags.VertexSGKey(), prefix='PhotonPV_')) return alg
def xAODTrackD3PDObject(_label='trkTrack', _prefix='trkTrack_', _sgkey='TrackParticleCandidate', _object_name='TrackD3PDObject', vertexTarget='vx', vertexPrefix='vx_', vertexSGKey='VxPrimaryCandidate', flags=TrackD3PDFlags): object = make_SGDataVector_D3PDObject ( 'xAOD::TrackParticleContainer', _sgkey, _prefix, _object_name, default_allowMissing = True, default_label = _label, allow_args = ['storeTrackMomentum', 'trackParametersAtGlobalPerigeeLevelOfDetails', 'trackParametersAtPrimaryVertexLevelOfDetails', 'trackParametersAtBeamSpotLevelOfDetails', 'storeDiagonalCovarianceAsErrors', 'storeTrackFitQuality', 'storeTrackPredictionAtBLayer', 'storeTrackInfo', 'storeVertexAssociation', 'storeTrackSummary', ]) ## default perigee (at (0,0,0)) PerigeeAssoc = PerigeeAssociation\ (object, TrackD3PDMaker.TrackParticlePerigeeAtOOAssociationTool, "GlobalPerigee", fillMomName = 'storeTrackMomentum', levelName = 'trackParametersAtGlobalPerigeeLevelOfDetails') from AthenaCommon.AppMgr import ToolSvc if hasattr(ToolSvc, 'InDetRecTestBLayerTool'): PerigeeAssoc.defineBlock (flagTestLOD('storeTrackPredictionAtBLayer', flags), _prefix+'BLayerInfo', TrackD3PDMaker.PerigeeBLPredictionFillerTool, InDetTestBLayerTool = ToolSvc.InDetRecTestBLayerTool) # perigee at Primary Vertex PerigeeAtPVAssoc = PerigeeAssociation\ (object, TrackD3PDMaker.TrackParticlePerigeeAtPVAssociationTool, "PerigeeAtPV", suffix='_wrtPV', levelName = 'trackParametersAtPrimaryVertexLevelOfDetails') # perigee at Beam Spot PerigeeAtBSAssoc = PerigeeAssociation\ (object, TrackD3PDMaker.TrackParticlePerigeeAtBSAssociationTool, "PerigeeAtBS", suffix='_wrtBS', levelName = 'trackParametersAtBeamSpotLevelOfDetails') object.defineBlock(flagTestLOD('storeTrackFitQuality', flags), _prefix+'FitQuality', D3PDMakerCoreComps.AuxDataFillerTool, Vars = ['chiSquared', 'numberDoF']) # Track Summary class SumVars: HitSum = 1 << 0 HoleSum = 1 << 1 IDHits = 1 << 2 IDHoles = 1 << 3 IDSharedHits = 1 << 4 IDOutliers = 1 << 5 PixelInfoPlus = 1 << 6 SCTInfoPlus = 1 << 7 TRTInfoPlus = 1 << 8 InfoPlus = 1 << 9 ExpectBLayer = 1 << 10 MuonHits = 1 << 11 DBMHits = 1 << 12 varsTable = [ # ID hits [IDHits, 'nBLHits', 'numberOfInnermostPixelLayerHits'], [IDHits + HitSum, 'nPixHits', 'numberOfPixelHits' ], [IDHits + HitSum, 'nSCTHits', 'numberOfSCTHits' ], [IDHits + HitSum, 'nTRTHits', 'numberOfTRTHits' ], [IDHits, 'nTRTHighTHits', 'numberOfTRTHighThresholdHits'], [IDHits, 'nTRTXenonHits', 'numberOfTRTXenonHits'], # ID holes + dead sensors - needed for appropriate cutting [IDHoles + HoleSum, 'nPixHoles', 'numberOfPixelHoles' ], [IDHoles + HoleSum, 'nSCTHoles', 'numberOfSCTHoles' ], [IDHoles + HoleSum, 'nTRTHoles', 'numberOfTRTHoles' ], [IDHoles, 'nPixelDeadSensors', 'numberOfPixelDeadSensors' ], [IDHoles, 'nSCTDeadSensors', 'numberOfSCTDeadSensors' ], # ID shared & Split hits [IDSharedHits, 'nBLSharedHits', 'numberOfInnermostPixelLayerSharedHits'], [IDSharedHits, 'nPixSharedHits', 'numberOfPixelSharedHits'], [IDSharedHits, 'nSCTSharedHits', 'numberOfSCTSharedHits'], [IDSharedHits, 'nBLayerSplitHits', 'numberOfInnermostPixelLayerSplitHits'], [IDSharedHits, 'nPixSplitHits', 'numberOfPixelSplitHits'], # ID outliers [IDOutliers, 'nBLayerOutliers', 'numberOfInnermostPixelLayerOutliers' ], [IDOutliers, 'nPixelOutliers', 'numberOfPixelOutliers' ], [IDOutliers, 'nSCTOutliers', 'numberOfSCTOutliers' ], [IDOutliers, 'nTRTOutliers', 'numberOfTRTOutliers'], [IDOutliers, 'nTRTHighTOutliers', 'numberOfTRTHighThresholdOutliers'], # Pixel info plus [PixelInfoPlus, 'nContribPixelLayers', 'numberOfContribPixelLayers' ], [PixelInfoPlus, 'nGangedPixels', 'numberOfGangedPixels' ], [PixelInfoPlus, 'nGangedFlaggedFakes', 'numberOfGangedFlaggedFakes' ], [PixelInfoPlus, 'nPixelSpoiltHits', 'numberOfPixelSpoiltHits' ], # SCT info plus [SCTInfoPlus, 'nSCTDoubleHoles', 'numberOfSCTDoubleHoles' ], [SCTInfoPlus, 'nSCTSpoiltHits', 'numberOfSCTSpoiltHits' ], # TRT info plus [TRTInfoPlus, 'nTRTDeadStraws', 'numberOfTRTDeadStraws' ], [TRTInfoPlus, 'nTRTTubeHits', 'numberOfTRTTubeHits' ], [TRTInfoPlus, 'nTRTSharedHits', 'numberOfTRTSharedHits' ], [TRTInfoPlus, 'nTRTHTHitsTotal', 'numberOfTRTHighThresholdHitsTotal' ], # Info plus [InfoPlus, 'nOutliersOnTrack', 'numberOfOutliersOnTrack'], [InfoPlus, 'standardDeviationOfChi2OS',], # Expect BLayer hit [ExpectBLayer, 'expectInnermostPixelLayerHit'], # Muon hits [MuonHits + HitSum, 'numberOfPrecisionLayers'], [MuonHits + HitSum, 'numberOfPrecisionHoleLayers'], [MuonHits + HitSum, 'numberOfPhiLayers'], [MuonHits + HitSum, 'numberOfPhiHoleLayers'], [MuonHits + HitSum, 'numberOfTriggerEtaLayers'], [MuonHits + HitSum, 'numberOfTriggerEtaHoleLayers'], ] @classmethod def varlist (cls, FullInfo, IDHits, IDHoles, IDSharedHits, IDOutliers, PixelInfoPlus, SCTInfoPlus, TRTInfoPlus, InfoPlus, ExpectBLayer, MuonHits, DBMHits, HitSum, HoleSum, ElectronPID, PixeldEdx): ret = [] mask = 0 if FullInfo: mask = ~0 if IDHits: mask |= cls.IDHits if IDHoles: mask |= cls.IDHoles if IDSharedHits: mask |= cls.IDSharedHits if IDOutliers: mask |= cls.IDOutliers if PixelInfoPlus: mask |= cls.PixelInfoPlus if SCTInfoPlus: mask |= cls.SCTInfoPlus if TRTInfoPlus: mask |= cls.TRTInfoPlus if InfoPlus: mask |= cls.InfoPlus if ExpectBLayer: mask |= cls.ExpectBLayer if MuonHits: mask |= cls.MuonHits if DBMHits: mask |= cls.DBMHits if HitSum: mask |= cls.HitSum if HoleSum: mask |= cls.HoleSum for v in cls.varsTable: if (v[0] & mask) != 0: var = v[1] enum = v[2] if len(v) >= 3 else var ret.append (var + ' = ' + enum) if ElectronPID or FullInfo: ret.append ('eProbabilityComb') ret.append ('eProbabilityHT') if PixeldEdx or FullInfo: ret.append ('pixeldEdx') ret.append ('numberOfUsedHitsdEdx') ret.append ('numberOfIBLOverflowsdEdx') return ret sumvarlist = SumVars.varlist ( FullInfo = flags.storeTrackSummary.FullInfo, IDHits = flags.storeTrackSummary.IDHits, IDHoles = flags.storeTrackSummary.IDHoles, IDSharedHits = flags.storeTrackSummary.IDSharedHits, IDOutliers = flags.storeTrackSummary.IDOutliers, PixelInfoPlus = flags.storeTrackSummary.PixelInfoPlus, SCTInfoPlus = flags.storeTrackSummary.SCTInfoPlus, TRTInfoPlus = flags.storeTrackSummary.TRTInfoPlus, InfoPlus = flags.storeTrackSummary.InfoPlus, ExpectBLayer = flags.storeTrackSummary.ExpectBLayer, MuonHits = flags.storeTrackSummary.MuonHits, DBMHits = flags.storeTrackSummary.DBMHits, HitSum = flags.storeTrackSummary.HitSum, HoleSum = flags.storeTrackSummary.HoleSum, ElectronPID = flags.storeTrackSummary.ElectronPID, PixeldEdx = flags.storeTrackSummary.PixeldEdx, ) object.defineBlock (flagTestLOD('storeTrackSummary', flags), _prefix + 'TrackSummary', D3PDMakerCoreComps.AuxDataFillerTool, Vars = sumvarlist) # Track Info object.defineBlock (flagTestLOD('storeTrackInfo', flags), _prefix + 'TrackInfo', D3PDMakerCoreComps.AuxDataFillerTool, Vars = ['trackFitter', 'particleHypothesis', 'trackProperties', 'patternRecoInfo']) # Vertex association VertexAssoc = IndexAssociation ( object, TrackD3PDMaker.TrackParticleVertexAssociationTool, vertexTarget, prefix = vertexPrefix, VxSGKey = vertexSGKey, level = flagTestLOD('storeVertexAssociation', flags)) return object
def getJetTileD3PDObject(objectname='JetTileD3PDObject', prefix='jet_', btagleveloffset=7): object = make_SGDataVector_D3PDObject('JetCollection', D3PDMakerFlags.JetSGKey(), prefix, objectname) object.defineHook(_fixJetTiming) object.defineBlock(0, 'Kinematics', EventCommonD3PDMaker.FourMomFillerTool, WriteE=True) object.defineBlock(1, 'OriginCorrection', JetD3PDMaker.JetMomentFillerTool, Moments=['EtaOrigin', 'PhiOrigin', 'MOrigin']) object.defineBlock( 1, 'DQMoments', JetD3PDMaker.JetMomentFillerTool, Moments=[ 'WIDTH', 'n90', 'Timing', 'LArQuality', 'nTrk', 'sumPtTrk', 'OriginIndex', 'HECQuality', 'NegativeE', 'AverageLArQF', 'BCH_CORR_CELL', 'BCH_CORR_DOTX', 'BCH_CORR_JET', 'BCH_CORR_JET_FORCELL', 'ENG_BAD_CELLS', 'N_BAD_CELLS', 'N_BAD_CELLS_CORR', 'BAD_CELLS_CORR_E', 'NumTowers', 'ootFracCells5', 'ootFracCells10', 'ootFracClusters5', 'ootFracClusters10' ]) object.defineBlock(1, 'JetSamplingsFrac', JetD3PDMaker.JetSamplingsFracFillerTool) object.defineBlock(1, 'JetQual', JetD3PDMaker.JetCaloUtilsFillerTool) object.defineBlock(1, 'EMFraction', JetD3PDMaker.JetEMFractionFillerTool) object.defineBlock( 1, 'JES', JetD3PDMaker.JetMomentFillerTool, Moments=['Offset', 'EMJES', 'EMJES_EtaCorr', 'EMJESnooffset']) object.defineBlock(1, 'EMScale', JetD3PDMaker.JetSignalStateFillerTool, WriteE=True, SignalStateNumber=0, SignalStatePrefix='emscale') object.defineBlock(2, 'JetTileFiller', JetD3PDMaker.JetTileCellFillerTool) # object.defineBlock(3, 'JVtx', # JetD3PDMaker.JetVtxFillerTool, # JetVertexAssociationTool=_getJvfTool()) object.defineBlock(3, 'Layer', JetD3PDMaker.JetMomentFillerTool, Moments=['GSCFactorF', 'WidthFraction']) object.defineBlock(4, 'Samplings', JetD3PDMaker.JetSamplingsFillerTool) object.defineBlock(5, 'JESMoments', JetD3PDMaker.JetMomentFillerTool, Moments=['LCJES']) # Moments=['GCWJES', 'GCWJES_EtaCorr','CB']) object.defineBlock(5, 'JetShape', JetD3PDMaker.JetShapeFillerTool) object.defineBlock(5, 'Constituents', JetD3PDMaker.JetConstituentFillerTool, SignalStateNumber=0, SignalStatePrefix='emscale') object.defineBlock(5, 'ConstituentScale', JetD3PDMaker.JetSignalStateFillerTool, WriteE=True, SignalStateNumber=2, SignalStatePrefix='constscale') object.defineBlock(6, 'JetLArHVMoment', JetD3PDMaker.JetMomentFillerTool, Moments=['LArBadHVEnergy', 'LArBadHVRatio']) addBTagInfoToJetObject(object, btagleveloffset) # Track association cannot be done unless there are tracks. # As often this is not the case track association will be done only # if this is explicitly asked for. by defining it in the include list. # # You can also enable it by passing an argument to JetD3PDObject # like: # AssocTrackCont_target='mytarget_' def _jetAssocLevel(reqlev, args): return args.has_key('target') or (reqlev >= 999) IndexMultiAssociation(object, JetD3PDMaker.FlavorAssociationTool, 'trk', prefix='flavor_assoctrk_', level=_jetAssocLevel, blockname='AssocTrackCont') object.defineBlock(10, 'JetRoIword', JetD3PDMaker.JetROIWordFillerTool) JetElAssoc = DRAssociation(object, "ElectronContainer", D3PDMakerFlags.ElectronSGKey(), 0.2, prefix='el_', matched="matched", blockname="El02Match") JetMuAssoc = DRAssociation(object, "Analysis::MuonContainer", D3PDMakerFlags.MuonSGKey(), 0.2, prefix='mu_', matched="matched", blockname="Mu02Match") #JetTrkAssoc = DRAssociation(object,"Rec::TrackParticleContainer",D3PDMakerFlags.TrackSGKey(),0.4,prefix='trk_',matched="matched",blockname="Trk04Match") #---------------- Trigger Object ---------------------------- JetL1Assoc = SimpleAssociation( object, JetD3PDMaker.JetL1TriggerObjectAssociationTool, matched='matched', blockname='L1Info', prefix='L1_', MaxDR=0.6, ChainPattern='L1_J.*') JetL1Assoc.defineBlock(99, 'L1Kinematics', EventCommonD3PDMaker.FourMomFillerTool, WriteE=True, WriteEt=False, WriteM=False) JetL2Assoc = SimpleAssociation( object, JetD3PDMaker.JetL2TriggerObjectAssociationTool, matched='matched', blockname='L2Info', prefix='L2_', MaxDR=0.25, ChainPattern='L2_j.*') JetL2Assoc.defineBlock(99, 'L2Kinematics', EventCommonD3PDMaker.FourMomFillerTool, WriteE=True, WriteEt=False, WriteM=False) JetEFAssoc = SimpleAssociation( object, JetD3PDMaker.JetEFTriggerObjectAssociationTool, matched='matched', blockname='EFInfo', prefix='EF_', MaxDR=0.25, ChainPattern='EF_j.*') JetEFAssoc.defineBlock(99, 'EFKinematics', EventCommonD3PDMaker.FourMomFillerTool, WriteE=True, WriteEt=False, WriteM=False) ConstitAssoc = ContainedVectorMultiAssociation \ (object, #JetD3PDMaker.JetConstituentAssociationTool, EventCommonD3PDMaker.NavigableConstituentAssociationTool, 'constit_', TypeName = 'CaloCluster', nrowName = '', level = 1) ConstitAssoc.defineBlock(_constitAssocLevel, 'ConstitIndex', D3PDMakerCoreComps.IndexFillerTool, Target='') return object
def JSD3PD(jetsToWrite, alg=None, scheduleOnly=False, level=10, file='js.root', tuplename='js'): if not alg: from OutputStreamAthenaPool.MultipleStreamManager import MSMgr alg = MSMgr.NewRootStream(tuplename, file, asAlg=True) commonExcludeList = [ 'El02Match', 'Mu02Match', 'L1Info', 'L2Info', 'EFInfo' ] commonIncludeList = [] import re JetAlgPattern = re.compile( r'^(\D+)(\d{1,2})(\D+)Jets') #assuming standard notation ars = JetAlgPattern.match(jetsToWrite[0]).groups() parentJets = ''.join(ars) #remove the 'Jets' at the end groomedJetsList = jetsToWrite[1] parentJetsWithoutJS = parentJets if parentJets[-2:] == 'JS': parentJetsWithoutJS = parentJets[:-2] parentJetsWithoutJSForGrooming = parentJetsWithoutJS if scheduleOnly: parentJetsWithoutJS += "Jets" filteredSequence = AlgSequence('TopWGFilter') theZeroLevel = 0 if not scheduleOnly: MyJetD3PDObject = getJetD3PDObject(objectname='MyJetD3PDObject') MyJetD3PDObject._hookArgs['seq'] = filteredSequence else: from TopInputsD3PDMaker.topInputsD3PD import JetD3PDObject MyJetD3PDObject = JetD3PDObject mylod = myLOD('jet_' + parentJetsWithoutJS + '_') theZeroLevel = mylod._prefixLOD MyGroomedJetD3PDObject = getJetD3PDObject( objectname='MyGroomedJetD3PDObject') MyGroomedJetD3PDObject._hookArgs['seq'] = filteredSequence ## Electron LC cluster overlap map if ('LCTopo' in parentJets) and (not hasattr( alg, 'ElecTopoClusterAssoc_Filler')): MyJetAssocD3PDObject = make_SGDataVector_D3PDObject( 'DataVector<INavigable4Momentum>', 'ElectronAODCollection_CaloCalTopoCluster_jetsubstructure_electrons', 'ElecTopoClusterAssoc_', 'myJetAssocD3PDObject') AddAssocConstitIndex(MyJetAssocD3PDObject) AddAssocConstitIndex(MyJetAssocD3PDObject, 'CaloCluster', 'cl_') alg += MyJetAssocD3PDObject(0) if 'Track' in parentJets: AddConstitIndex(MyGroomedJetD3PDObject, typename='Rec::TrackParticle', target='trk') AddConstitIndex(MyJetD3PDObject, typename='Rec::TrackParticle', target='trk', level=theZeroLevel) AddLeptonicInfo(MyJetD3PDObject, level=theZeroLevel) AddLeptonicInfo(MyGroomedJetD3PDObject, 99) elif 'Topo' in parentJets: AddConstitIndex(MyGroomedJetD3PDObject) AddConstitIndex(MyJetD3PDObject, level=theZeroLevel) AddLeptonicInfo(MyJetD3PDObject, level=theZeroLevel) AddLeptonicInfo(MyGroomedJetD3PDObject, 99) elif 'Truth' in parentJets: if ars[1] == '4': from JetD3PDMaker.JetD3PDMakerConf import D3PD__JetShapeFillerTool from JetD3PDMaker.JetD3PDMakerConf import D3PD__JetTrueTagFillerTool MyJetD3PDObject.defineBlock(theZeroLevel, 'myJetShape', D3PD__JetShapeFillerTool) MyJetD3PDObject.defineBlock(theZeroLevel, 'TrueFlavorComponents', D3PD__JetTrueTagFillerTool) AddConstitTruthIndex(MyJetD3PDObject, level=theZeroLevel) AddTruthLeptonicInfo(MyJetD3PDObject, level=theZeroLevel) AddTruthLeptonicInfo(MyGroomedJetD3PDObject, level=99) AddConstitTruthIndex(MyGroomedJetD3PDObject) if 'Track' not in parentJets and 'Truth' not in parentJets: AddAssocJetsIndex(MyJetD3PDObject, 'TrackJets', 'jet_' + ars[0] + ars[1] + 'TrackZ_', level=theZeroLevel) if rec.doTruth(): AddAssocJetsIndex(MyJetD3PDObject, 'TruthJets', 'jet_' + ars[0] + ars[1] + 'Truth_', level=theZeroLevel) JetQualInclude = [] if 'Topo' in parentJets: commonIncludeList += ['ConstituentScale', 'EMScale'] if not scheduleOnly: AddHadronicInfo(MyJetD3PDObject, [ 'OriginIndex', 'nTrk', 'sumPtTrk', 'EtaOrigin', 'PhiOrigin', 'MOrigin' ], theblockname='OriginIndexBlock') AddHadronicInfo(MyGroomedJetD3PDObject, ['EtaOrigin', 'PhiOrigin', 'MOrigin'], theblockname='OriginIndexBlock', level=99) if (parentJetsWithoutJS == 'AntiKt10LCTopo') or (parentJetsWithoutJS == 'CamKt12LCTopo'): AddHadronicInfo(MyJetD3PDObject, ['LCJES', 'LCJES_EtaCorr', 'LCJES_MassCorr'], theblockname='LCJESBlock', level=theZeroLevel) AddHadronicInfo(MyGroomedJetD3PDObject, ['LCJES', 'LCJES_EtaCorr', 'LCJES_MassCorr'], theblockname='LCJESBlock') if ars[1] == '4' or ars[1] == '6': if not scheduleOnly: AddHadronicInfo(MyJetD3PDObject, ['EMJES', 'EMJES_EtaCorr'], theblockname='EMJESBlock', level=99) AddHadronicInfo(MyJetD3PDObject, ['LCJES', 'LCJES_EtaCorr'], theblockname='LCJESBlock', level=99) AddHadronicInfo(MyJetD3PDObject, [ 'Timing', 'LArQuality', 'HECQuality', 'NegativeE', 'AverageLArQF' ], theblockname='QMomentsBlock') if 'TopoEM' in ars[2]: JetQualInclude += ['EMJESBlock', 'JetQual'] elif 'LCTopo' in ars[2]: JetQualInclude += ['LCJESBlock', 'JetQual'] VtxInclude = [] if 'Topo' in parentJets: VtxInclude += ['JVtx', 'JetVertexFraction'] elif 'Track' in parentJets: VtxInclude += ['JVtx'] AddAssocJetsIndex(MyGroomedJetD3PDObject, 'Parent', 'jet_' + parentJetsWithoutJS + '_') for gr in groomedJetsList: AddAssocJetsIndex(MyJetD3PDObject, gr, 'jet_' + parentJetsWithoutJSForGrooming + gr + '_', level=theZeroLevel) MyGroomedJetCollectionD3PDObject = getJetCollectionD3PDObject( objectname="MyGroomedJetCollectionD3PDObject") AddUniqueMoments(MyGroomedJetCollectionD3PDObject, ['SmallR', 'PtFrac'], theblockname='TrimConfigMoments', level=99) #AddUniqueMoments(MyGroomedJetCollectionD3PDObject, ['NSubjets','ktycut2','massFraction','minRfilt','minSplitR'], theblockname = 'FiltConfigMoments', level = 99) #AddUniqueMoments(MyGroomedJetCollectionD3PDObject, ['RcutFactor', 'Zcut'], theblockname = 'PrunConfigMoments', level = 99) AddHadronicInfo(MyGroomedJetD3PDObject, ['CORE_RBB', 'CORE_RFILT'], theblockname='FiltMoments', level=99) listOfMoments = [ 'Tau1', 'Tau2', 'Tau3', 'SPLIT12', 'SPLIT23', 'SPLIT34', 'ZCUT12', 'ZCUT23', 'ZCUT34', 'QW', 'PullMag', 'PullPhi', 'Pull_C00', 'Pull_C01', 'Pull_C10', 'Pull_C11', 'WIDTH' ] if not scheduleOnly: listOfMoments_ = listOfMoments else: listOfMoments_ = listOfMoments[:-1] # without WIDTH AddHadronicInfo(MyGroomedJetD3PDObject, listOfMoments, theblockname='jsObsblock', level=99) AddHadronicInfo(MyJetD3PDObject, listOfMoments_, theblockname='jsObsblock', level=theZeroLevel) if not scheduleOnly: alg += MyJetD3PDObject(0, prefix='jet_' + parentJetsWithoutJS + '_', sgkey=parentJets + 'Jets', exclude=commonExcludeList, include=commonIncludeList + VtxInclude + JetQualInclude) for gr in groomedJetsList: includelist = [] includelist_unique = [] if 'Trim' in gr: includelist_unique += ['TrimConfigMoments'] includelist += ['jsObsblock'] if 'Topo' in parentJets: includelist += [ 'OriginIndexBlock', 'EMScale', 'ConstituentScale', 'elecblockindex', 'muonblockindex' ] elif 'Truth' in parentJets: includelist += ['TruthParticleLeptonblockindex'] elif 'Track' in parentJets: includelist += ['elecblockindex', 'muonblockindex'] alg += MyGroomedJetCollectionD3PDObject( 0, prefix='jet_' + parentJetsWithoutJSForGrooming + gr + '_config_', sgkey=parentJets + gr + 'Jets', include=includelist_unique) elif 'Filt' in gr: includelist += ['FiltMoments', 'jsObsblock'] #includelist_unique += ['FiltConfigMoments'] elif 'Prun' in gr: #includelist_unique += ['PrunConfigMoments'] includelist += ['jsObsblock'] alg += MyGroomedJetD3PDObject( 0, prefix='jet_' + parentJetsWithoutJSForGrooming + gr + '_', sgkey=parentJets + gr + 'Jets', include=includelist, exclude=commonExcludeList) return alg
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration # $Id: ZdcD3PDObject.py 470583 2011-11-25 10:33:45Z krasznaa $ from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject import ForwardDetectorsD3PDMaker ZdcD3PDObject = make_SGDataVector_D3PDObject("ZdcRawChannelCollection", "ZdcRawChannelCollection", "Zdc_", "ZdcD3PDObject") ZdcD3PDObject.defineBlock(0, 'ZdcRawChannel', ForwardDetectorsD3PDMaker.ZdcFillerTool)
# $Id$ # # @file MuonD3PDMaker/python/MuonSpShowerD3PDObject.py # @author Michiru Kaneda <*****@*****.**> # @date Jan., 2011 # @brief MuonSpShower filler tool # import D3PDMakerCoreComps from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject from MuonD3PDMaker.MuonD3PDMakerConf import D3PD__MuonSpShowerFillerTool as MuonSpShowerFillerTool MuonSpShowerD3PDObject = \ make_SGDataVector_D3PDObject ('Rec::MuonSpShowerContainer', 'MuonSpShowers', 'musp_', 'MuonSpShowerD3PDObject') MuonSpShowerD3PDObject.defineBlock(0, 'Position', MuonSpShowerFillerTool, WritePosition=True, WriteHits=False, WriteSegments=False) MuonSpShowerD3PDObject.defineBlock(1, 'Hits', MuonSpShowerFillerTool, WritePosition=False, WriteHits=True, WriteSegments=False)
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration # $Id: MuonROID3PDObject.py 620244 2014-10-06 19:02:48Z ssnyder $ # # D3PD object saving the LVL1 muon RoI information into the D3PD # from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject import TriggerD3PDMaker import EventCommonD3PDMaker import D3PDMakerCoreComps MuonROID3PDObject = \ make_SGDataVector_D3PDObject( "xAOD::MuonRoIContainer_v1", "LVL1MuonRoIs", "trig_L1_mu_", "MuonROID3PDObject") MuonROID3PDObject.defineBlock ( 0, 'Kinematics', D3PDMakerCoreComps.AuxDataFillerTool, Vars = ['eta', 'phi']) MuonROID3PDObject.defineBlock ( 0, 'ThrInfo', D3PDMakerCoreComps.AuxDataFillerTool, Vars = ['thrName', 'thrValue']) MuonROID3PDObject.defineBlock ( 2, 'RoIWord', D3PDMakerCoreComps.AuxDataFillerTool, Vars = ['RoIWord = roiWord']) MuonROID3PDObject.defineBlock( 1, "DecodedInfo",
alg = D3PDMakerCoreComps.MakerAlg('test1', topSequence, 'test1.root') from D3PDMakerCoreComps.D3PDObject import \ make_SGDataVector_D3PDObject, make_SG_D3PDObject, make_Void_D3PDObject from D3PDMakerCoreComps.SimpleAssociation import SimpleAssociation from D3PDMakerCoreComps.ContainedVectorMultiAssociation \ import ContainedVectorMultiAssociation from D3PDMakerCoreComps.ContainedMultiAssociation \ import ContainedMultiAssociation ########################################################################### Obj1D3PDObject = \ make_SGDataVector_D3PDObject ('D3PDTest::Obj1Container', 'obj1container', 'o1_') Obj1D3PDObject.defineBlock(0, 'Obj1', D3PDMakerTest.Obj1FillerTool) Obj1D3PDObject.defineBlock(0, 'Obj1a', D3PDMakerTest.Obj12FillerTool) Obj1D3PDObject.defineBlock(0, 'Def2', D3PDMakerTest.DefaultFillerTool2) ##################### Obj2aAssoc = SimpleAssociation(Obj1D3PDObject, D3PDMakerTest.Obj1Obj2AssociationTool, prefix='o2a_') Obj2aAssoc.defineBlock(0, 'Obj2Assoc', D3PDMakerTest.Obj2FillerTool) Obj2bAssoc = ContainedVectorMultiAssociation \ (Obj1D3PDObject, D3PDMakerTest.Obj1Obj2MultiAssociationTool,
# Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration import CaloD3PDMaker import CaloSysD3PDMaker import D3PDMakerCoreComps import EventCommonD3PDMaker from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags EMClusterD3PDObject = \ make_SGDataVector_D3PDObject ('CaloClusterContainer', D3PDMakerFlags.EMTopoClusterSGKey(), 'emcl_', 'EMClusterD3PDObject') EMClusterD3PDObject.defineBlock(0, 'Kinematics', EventCommonD3PDMaker.FourMomFillerTool, WriteE=True) EMClusterD3PDObject.defineBlock(0, 'SamplingBasics', CaloD3PDMaker.ClusterSamplingFillerTool) from CaloSysD3PDMaker import ClusterMomentFillerTool as CMFT EMClusterD3PDObject.defineBlock( 1, 'Moments', CMFT, Moments=[ CMFT.FIRST_ENG_DENS, 'firstEdens', CMFT.ENG_FRAC_MAX, 'cellmaxfrac',
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration # $Id$ import CaloD3PDMaker from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject """ level of details: 0: digits 1: digit+SCA index 2: OF Iteration results Note: 1 and 2 are not available in ESD. They are available when running recon on raw data. """ LArDigitD3PDObject = make_SGDataVector_D3PDObject("LArDigitContainer", "LArDigitContainer_Thinned", "lardigit_", "LArDigitD3PDObject") LArDigitD3PDObject.defineBlock(0, 'Digits', CaloD3PDMaker.LArDigitFillerTool, SaveDigit=True, SaveId=True, SaveSCAAddress=False, DumpIterResults=False) LArDigitD3PDObject.defineBlock(1, 'SCA', CaloD3PDMaker.LArDigitFillerTool, SaveDigit=False, SaveId=False,
def TrackD3PDObject(_label='trkTrack', _prefix='trkTrack_', _sgkey='Tracks', _object_name='TrackD3PDObject', typeName='TrackCollection', vertexTarget='vx', vertexPrefix='vx_', vertexSGKey='VxPrimaryCandidate', truthTarget='mc', truthPrefix='mc_', detailedTruthPrefix='detailed_mc_', truthMapKey='TrackTruthCollection', SGKeyForTruth='Tracks', detailedTruthMapKey='DetailedTrackTruth', SGKeyForDetailedTruth='Tracks', flags=TrackD3PDFlags): object = make_SGDataVector_D3PDObject ( typeName, _sgkey, _prefix, _object_name, default_allowMissing = True, default_label = _label, allow_args = ['GenParticleTarget', 'TruthParticleTarget', 'storeTruthInfo', 'storeTrackMomentum', 'trackParametersAtGlobalPerigeeLevelOfDetails', 'trackParametersAtPrimaryVertexLevelOfDetails', 'trackParametersAtBeamSpotLevelOfDetails', 'trackParameterAtBeamLineLevelOfDetails', 'storeDiagonalCovarianceAsErrors', 'storeTrackParametersAtCalo', 'storeTrackParametersAtCalo2ndLayer', 'storeTrackFitQuality', 'storeTrackPredictionAtBLayer', 'storeTrackInfo', 'storeVertexAssociation', 'storeDetailedTruth', 'storeBLayerHitsOnTrack', 'storePixelHitsOnTrack', 'storeSCTHitsOnTrack', 'storeTRTHitsOnTrack', 'storeMDTHitsOnTrack', 'storeCSCHitsOnTrack', 'storeRPCHitsOnTrack', 'storeTGCHitsOnTrack', 'storeBLayerOutliersOnTrack', 'storePixelOutliersOnTrack', 'storeSCTOutliersOnTrack', 'storeTRTOutliersOnTrack', 'storeMDTOutliersOnTrack', 'storeCSCOutliersOnTrack', 'storeRPCOutliersOnTrack', 'storeTGCOutliersOnTrack', 'storeBLayerHolesOnTrack', 'storePixelHolesOnTrack', 'storeSCTHolesOnTrack', 'storeTRTHolesOnTrack', 'storeMDTHolesOnTrack', 'storeCSCHolesOnTrack', 'storeRPCHolesOnTrack', 'storeTGCHolesOnTrack', 'storePullsAndResiduals', 'storeTrackUnbiasedIPAtPV', 'storeHitTruthMatching', 'storeTrackSummary', 'doTruth', ]) if typeName=='TrackCollection': PerigeeAssociationTool = TrackD3PDMaker.TrkTrackPerigeeAssociationTool PerigeeAtPVAssociationTool = TrackD3PDMaker.TrkTrackPerigeeAtPVAssociationTool PerigeeAtBSAssociationTool = TrackD3PDMaker.TrkTrackPerigeeAtBSAssociationTool FitQualityAssociationTool = TrackD3PDMaker.TrkTrackFitQualityAssociationTool TrackSummaryAssociationTool = TrackD3PDMaker.TrkTrackTrackSummaryAssociationTool TrackInfoAssociationTool = TrackD3PDMaker.TrkTrackInfoAssociationTool HitAssociationTool = TrackD3PDMaker.TrkTrackTSOAssociationTool VertexAssociationTool = TrackD3PDMaker.TrkTrackVertexAssociationTool TruthAssociationTool = TrackD3PDMaker.TrkTrackTruthAssociationTool DetailedTruthAssociationTool = TrackD3PDMaker.TrkTrackDetailedTruthAssociationTool ParametersAtBLFillerTool = TrackD3PDMaker.TrkTrackParametersAtBLFillerTool if typeName=='Rec::TrackParticleContainer': PerigeeAssociationTool = TrackD3PDMaker.TrackParticlePerigeeAtOOAssociationTool PerigeeAtPVAssociationTool = TrackD3PDMaker.TrackParticlePerigeeAtPVAssociationTool PerigeeAtBSAssociationTool = TrackD3PDMaker.TrackParticlePerigeeAtBSAssociationTool FitQualityAssociationTool = TrackD3PDMaker.TrackParticleFitQualityAssociationTool TrackSummaryAssociationTool = TrackD3PDMaker.TrackParticleTrackSummaryAssociationTool TrackInfoAssociationTool = TrackD3PDMaker.TrackParticleInfoAssociationTool HitAssociationTool = TrackD3PDMaker.TrackParticleTSOAssociationTool VertexAssociationTool = TrackD3PDMaker.TrackParticleVertexAssociationTool TruthAssociationTool = TrackD3PDMaker.TrackParticleTruthAssociationTool DetailedTruthAssociationTool = TrackD3PDMaker.TrackParticleDetailedTruthAssociationTool ParametersAtBLFillerTool = TrackD3PDMaker.TrackParticleParametersAtBLFillerTool # This generates ERROR messages. Disabled for now. #object.defineBlock(1, "Isolation", TrackD3PDMaker.TrackIsolationFillerTool) ## default perigee (at (0,0,0)) PerigeeAssoc = PerigeeAssociation\ (object, PerigeeAssociationTool, "GlobalPerigee", fillMomName = 'storeTrackMomentum', levelName = 'trackParametersAtGlobalPerigeeLevelOfDetails') # Unbiased impact parameters at PV PerigeeAssoc.defineBlock (flagTestLOD('storeTrackUnbiasedIPAtPV', flags, _get_estimator), _prefix+"IPEstimate", TrackD3PDMaker.PerigeeUnbiasedIPAtPVFillerTool, # Filled in by LOD function. TrackToVertexIPEstimator=None, Prefix = 'IPEstimate_', Suffix = '_wrtPV') # perigee at Primary Vertex PerigeeAtPVAssoc = PerigeeAssociation\ (object, PerigeeAtPVAssociationTool, "PerigeeAtPV", suffix='_wrtPV', levelName = 'trackParametersAtPrimaryVertexLevelOfDetails') # perigee at Beam Spot PerigeeAtBSAssoc = PerigeeAssociation\ (object, PerigeeAtBSAssociationTool, "PerigeeAtBS", suffix='_wrtBS', levelName = 'trackParametersAtBeamSpotLevelOfDetails') # perigee at Beam Line from TrackD3PDMaker.PerigeeAssociation import perigeeLOD # Not implemented in TrackToVertex. #object.defineBlock(perigeeLOD ('trackParametersAtBeamLineLevelOfDetails>0', # flags), # _prefix+"ParametersAtBL", # ParametersAtBLFillerTool, # levelOfDetails = deferFlag ('trackParametersAtBeamLineLevelOfDetails', flags)) # parameters at Calo object.defineBlock(flagTestLOD('storeTrackParametersAtCalo', flags), _prefix+"ParametersAtCalo", ParametersAtCaloFillerTool) # parameters at Calo 2nd layer object.defineBlock(flagTestLOD('storeTrackParametersAtCalo2ndLayer', flags), _prefix+"ParametersAtCalo2ndLayer", ParametersAtCaloFillerTool, Sampling = 1, Suffix = '2ndLayer') # Fit Quality FitQualityAssoc = SimpleAssociation\ (object, FitQualityAssociationTool, level = flagTestLOD('storeTrackFitQuality', flags)) FitQualityAssoc.defineBlock(flagTestLOD('storeTrackFitQuality', flags), _prefix+'FitQuality', TrackD3PDMaker.TrackFitQualityFillerTool) # Track Summary TrackSummaryAssoc = SimpleAssociation\ (object, TrackSummaryAssociationTool, level = flagTestLOD('storeTrackSummary', flags)) TrackSummaryAssoc.defineBlock(flagTestLOD('storeTrackSummary', flags), _prefix+'TrackSummary', TrackD3PDMaker.TrackTrackSummaryFillerTool, FullInfo = flags.storeTrackSummary.FullInfo, IDHits = flags.storeTrackSummary.IDHits, IDHoles = flags.storeTrackSummary.IDHoles, IDSharedHits = flags.storeTrackSummary.IDSharedHits, IDOutliers = flags.storeTrackSummary.IDOutliers, PixelInfoPlus = flags.storeTrackSummary.PixelInfoPlus, SCTInfoPlus = flags.storeTrackSummary.SCTInfoPlus, TRTInfoPlus = flags.storeTrackSummary.TRTInfoPlus, InfoPlus = flags.storeTrackSummary.InfoPlus, MuonHits = flags.storeTrackSummary.MuonHits, MuonHoles = flags.storeTrackSummary.MuonHoles, ExpectBLayer = flags.storeTrackSummary.ExpectBLayer, HitSum = flags.storeTrackSummary.HitSum, HoleSum = flags.storeTrackSummary.HoleSum, HitPattern = flags.storeTrackSummary.HitPattern, SiHits = flags.storeTrackSummary.SiHits, TRTRatio = flags.storeTrackSummary.TRTRatio, PixeldEdx = flags.storeTrackSummary.PixeldEdx, ElectronPID = flags.storeTrackSummary.ElectronPID) # Track Info TrackInfoAssoc = SimpleAssociation\ (object, TrackInfoAssociationTool, level = flagTestLOD('storeTrackInfo', flags)) TrackInfoAssoc.defineBlock(flagTestLOD('storeTrackInfo', flags), _prefix+'TrackInfo', TrackD3PDMaker.TrackInfoFillerTool) ## B-Layer predictions from AthenaCommon.AppMgr import ToolSvc if hasattr(ToolSvc, 'InDetRecTestBLayerTool'): BLayerPredictionAssoc = SimpleAssociation\ (object, PerigeeAssociationTool, prefix = 'blayerPrediction_', blockname = _prefix+'BLayerInfoAssoc', level = flagTestLOD('storeTrackPredictionAtBLayer', flags)) BLayerPredictionAssoc.defineBlock (flagTestLOD('storeTrackPredictionAtBLayer', flags), _prefix+'BLayerInfo', TrackD3PDMaker.PerigeeBLPredictionFillerTool, InDetTestBLayerTool = ToolSvc.InDetRecTestBLayerTool) tsos_table = [ ('storeBLayerHitsOnTrack', 'BLayer_hit_', 'getBLayerMeasurements'), ('storePixelHitsOnTrack', 'Pixel_hit_', 'getPixelMeasurements'), ('storeSCTHitsOnTrack', 'SCT_hit_', 'getSCTMeasurements'), ('storeTRTHitsOnTrack', 'TRT_hit_', 'getTRTMeasurements'), ('storeMDTHitsOnTrack', 'MDT_hit_', 'getMDTMeasurements'), ('storeCSCHitsOnTrack', 'CSC_hit_', 'getCSCMeasurements'), ('storeRPCHitsOnTrack', 'RPC_hit_', 'getRPCMeasurements'), ('storeTGCHitsOnTrack', 'TGC_hit_', 'getTGCMeasurements'), ('storeBLayerOutliersOnTrack', 'BLayer_outlier_', 'getBLayerOutliers'), ('storePixelOutliersOnTrack', 'Pixel_outlier_', 'getPixelOutliers'), ('storeSCTOutliersOnTrack', 'SCT_outlier_', 'getSCTOutliers'), ('storeTRTOutliersOnTrack', 'TRT_outlier_', 'getTRTOutliers'), ('storeMDTOutliersOnTrack', 'MDT_outlier_', 'getMDTOutliers'), ('storeCSCOutliersOnTrack', 'CSC_outlier_', 'getCSCOutliers'), ('storeRPCOutliersOnTrack', 'RPC_outlier_', 'getRPCOutliers'), ('storeTGCOutliersOnTrack', 'TGC_outlier_', 'getTGCOutliers'), ('storeBLayerHolesOnTrack', 'BLayer_hole_', 'getBLayerHoles'), ('storePixelHolesOnTrack', 'Pixel_hole_', 'getPixelHoles'), ('storeSCTHolesOnTrack', 'SCT_hole_', 'getSCTHoles'), ('storeTRTHolesOnTrack', 'TRT_hole_', 'getTRTHoles'), ('storeMDTHolesOnTrack', 'MDT_hole_', 'getMDTHoles'), ('storeCSCHolesOnTrack', 'CSC_hole_', 'getCSCHoles'), ('storeRPCHolesOnTrack', 'RPC_hole_', 'getRPCHoles'), ('storeTGCHolesOnTrack', 'TGC_hole_', 'getTGCHoles'), ] for flag, pref, opt in tsos_table: TrackStateOnSurfaceAssociation (object, HitAssociationTool, pref, _prefix + pref, flagTestLOD(flag, flags), fillPullsName = 'storePullsAndResiduals' if flag.find('Holes')<0 else 'False', **{opt : True}) # Vertex association VertexAssoc = IndexAssociation ( object, VertexAssociationTool, vertexTarget, prefix = vertexPrefix, VxSGKey = vertexSGKey, level = flagTestLOD('storeVertexAssociation', flags)) # Truth matching if rec.doTruth(): # Simple truth matching # Allow associating to either GenParticles or TruthParticles. def _levelAssocToGP (reqlev, args, hookargs): if reqlev < 1: return False if hookargs.get ('TruthParticleTarget'): return False if hookargs.get ('GenParticleTarget'): args['Target'] = hookargs.get ('GenParticleTarget') return True def _levelAssocToTP (reqlev, args, hookargs): if reqlev < 1: return False tpt = hookargs.get ('TruthParticleTarget') if not tpt: return False args['Target'] = tpt return True TruthAssoc = SimpleAssociation\ (object, TruthAssociationTool, prefix = truthPrefix, SGKey = SGKeyForTruth, MapKey = truthMapKey, level = flagTestLOD('doTruth and storeHitTruthMatching', flags)) TruthAssoc.defineBlock (_levelAssocToGP, 'TruthAssocIndex', D3PDMakerCoreComps.IndexFillerTool, Target = truthTarget) # TruthAssocTP = SimpleAssociation\ # (TruthAssoc, # TruthD3PDMaker.GenParticleTruthParticleAssociationTool, # level = _levelAssocToTP) # TruthAssocTP.defineBlock (_levelAssocToTP, # 'TruthAssocIndexTP', # D3PDMakerCoreComps.IndexFillerTool, # Target = truthTarget) # _levelTruthInfo = flagTestLOD ('doTruth and storeHitTruthMatching and reqlev>=2 and storeTruthInfo', flags) # TruthAssoc.defineBlock (_levelTruthInfo, # 'TruthPerigee', # TruthD3PDMaker.GenParticlePerigeeFillerTool) # # if typeName == 'Rec::TrackParticleContainer': # from TruthD3PDMaker.MCTruthClassifierConfig import \ # D3PDMCTruthClassifier # object.defineBlock \ # (_levelTruthInfo, # 'MCClassification', # TrackD3PDMaker.TrackParticleMCClassifierFillerTool, # prefix = 'mc_', # Classifier = D3PDMCTruthClassifier) # Detailed truth matching DetailedTruthAssoc = IndexMultiAssociation ( object, DetailedTruthAssociationTool, truthTarget, prefix = detailedTruthPrefix, level = flagTestLOD('doTruth and storeDetailedTruth and reqlev>=1', flags), SGKey = SGKeyForDetailedTruth, MapKey = detailedTruthMapKey) # if typeName == 'Rec::TrackParticleContainer': # from TrackD3PDMaker.trackIsolationTool import \ # trackIsolationTool_500MeV, \ # trackIsolationTool_1GeV, \ # trackIsolationTool_2GeV, \ # trackIsolationTool_3GeV, \ # trackIsolationTool_4GeV, \ # trackIsolationTool_5GeV, \ # trackIsolationTool_3GeV_hitschi # from TrackD3PDMaker.addTrackIsolationCones import addTrackIsolationCones # addTrackIsolationCones ( # object, 'Isolation', level=999, # sizes = [0.2, 0.3, 0.4], # caloIsoVar = 'cone%%_caloIso', # trackIsoVar = 'cone%%_trackIso', # nTrackIsoVar = 'cone%%_nTrackIso', # isolationTool = DeferArg('tool()', # tool=trackIsolationTool_500MeV)) # iso4blocks = [[trackIsolationTool_1GeV, '1GeV', 'ptmin1gev_'], # [trackIsolationTool_2GeV, '2GeV', 'ptmin2gev_'], # [trackIsolationTool_3GeV, '3GeV', 'ptmin3gev_'], # [trackIsolationTool_3GeV_hitschi, '3GeV_hitschi', 'ptmin3gev_hitschi_'], # [trackIsolationTool_4GeV, '4GeV', 'ptmin4gev_'], # [trackIsolationTool_5GeV, '5GeV', 'ptmin5gev_'], # ] # for (tool, blksuff, varsuff) in iso4blocks: # object.defineBlock (999, 'Isolation_40_' + blksuff, # TrackD3PDMaker.TrackIsolationFillerTool, # ConeSize = 0.4, # prefix = 'cone40_' + varsuff, # TrackIsolationTool = DeferArg('tool()', # tool=tool)) return object
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration # $Id$ # # @file CaloD3PDMaker/python/MBTSD3PDObject.py # @author scott snyder <*****@*****.**> # @date Nov, 2009 # @brief D3PD object for MBTS. # # We require TileID. # If identifiers have not yet been configured, request a minimal # setup (that doesn't use GeoModelSvc). from AthenaCommon.AppMgr import ServiceMgr if not hasattr (ServiceMgr, 'DetDescrCnvSvc'): import DetDescrCnvSvc.DetStoreConfig ServiceMgr.DetDescrCnvSvc.DoInitNeighbours = False import CaloD3PDMaker from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject MBTSD3PDObject = \ make_SGDataVector_D3PDObject ('TileContainer<TileCell>', D3PDMakerFlags.MBTSSGKey(), 'mb_', 'MBTSD3PDObject') MBTSD3PDObject.defineBlock (0, 'MBTS', CaloD3PDMaker.MBTSFillerTool)
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration # $Id: ZdcDigitsD3PDObject.py 470583 2011-11-25 10:33:45Z krasznaa $ from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject import ForwardDetectorsD3PDMaker ZdcDigitsD3PDObject = make_SGDataVector_D3PDObject("ZdcDigitsCollection", "ZdcDigitsCollection", "ZdcDigits_", "ZdcDigitsD3PDObject") ZdcDigitsD3PDObject.defineBlock(0, 'ZdcDigits', ForwardDetectorsD3PDMaker.ZdcDigitsFillerTool)
#alg += CaloInfoD3PDObject (10) #alg += ClusterD3PDObject (10) #alg += LArDigitD3PDObject (2) alg += AllCaloCellD3PDObject(1, sgkey='SCellContainer', prefix='scells_') alg.scells_Filler.scells_Filler_Detail1.SaveId = True import CaloD3PDMaker from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject if doRawData: LArDigitD3PDObject = make_SGDataVector_D3PDObject("LArDigitContainer", "LArDigitContainer_MC", "lardigit_", "LArDigitD3PDObject") LArDigitD3PDObject.defineBlock(0, 'Digits', CaloD3PDMaker.LArDigitFillerTool, SaveDigit=True, SaveId=True, SaveSCAAddress=False, DumpIterResults=False) alg += LArDigitD3PDObject(0) TileDigitD3PDObject = D3PDObject(makeTileDigitD3PDObject, 'tiledigit_', 'TileDigitD3PDObject') TileDigitD3PDObject.defineBlock(
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration import MuonD3PDMaker import D3PDMakerCoreComps import EventCommonD3PDMaker from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject from D3PDMakerCoreComps.SimpleAssociation import SimpleAssociation from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags from RecExConfig.RecFlags import rec MuonSegmentTruthD3PDObject = \ make_SGDataVector_D3PDObject ('Trk::SegmentCollection', 'MuonSegments', 'mu_segmentTruth_', 'MuonSegmentTruthD3PDObject') MuonSegmentTruthD3PDObject.defineBlock( 1, 'PatternTruthCombination', MuonD3PDMaker.MuonSegmentTruthFillerTool)
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration # $Id: EmTauROID3PDObject.py 633616 2014-12-04 10:10:12Z ssnyder $ # # D3PD object saving the LVL1 Em/Tau RoI information into the D3PD # from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject import TriggerD3PDMaker import EventCommonD3PDMaker import D3PDMakerCoreComps EmTauROID3PDObject = \ make_SGDataVector_D3PDObject( 'xAOD::EmTauRoIContainer', "HLT_xAOD__EmTauRoIContainer_L1TopoEM,LVL1EmTauRoIs", "trig_L1_emtau_", "EmTauROID3PDObject") EmTauROID3PDObject.defineBlock(0, 'Kinematics', D3PDMakerCoreComps.AuxDataFillerTool, Vars=['eta', 'phi']) EmTauROID3PDObject.defineBlock(0, 'ThrInfo', D3PDMakerCoreComps.AuxDataFillerTool, Vars=['thrNames', 'thrValues']) EmTauROID3PDObject.defineBlock(1, 'DecodedInfo', D3PDMakerCoreComps.AuxDataFillerTool,
def __init__(self, jetsToWrite): self.commonExcludeList = [ ] #'El02Match','Mu02Match','L1Info','L2Info','EFInfo'] self.commonIncludeList = [ 'El02Match', 'Mu02Match', 'L1Info', 'L2Info', 'EFInfo', 'SubjetMomentsHadronic' ] MyJetD3PDObject = getJetD3PDObject(objectname='MyJetD3PDObject') MyGroomedJetD3PDObject = getJetD3PDObject( objectname='MyGroomedJetD3PDObject') import re JetAlgPattern = re.compile( r'^(\D+)(\d{1,2})(\D+)Jets') #assuming standard notation ars = JetAlgPattern.match(jetsToWrite[0]).groups() self.parentJets = ''.join(ars) #remove the 'Jets' at the end #global self.parentJets self.groomedJetsList = jetsToWrite[1] ## Electron LC cluster overlap map if ('LCTopo' in self.parentJets): MyJetAssocD3PDObject = make_SGDataVector_D3PDObject( 'DataVector<INavigable4Momentum>', 'ElectronAODCollection_CaloCalTopoCluster_jetsubstructure_electrons', 'ElecTopoClusterAssoc_', 'myJetAssocD3PDObject') AddAssocConstitIndex(MyJetAssocD3PDObject) AddAssocConstitIndex(MyJetAssocD3PDObject, 'CaloCluster', 'cl_lc_') #alg += MyJetAssocD3PDObject(0) if 'Track' in self.parentJets: AddConstitIndex(MyGroomedJetD3PDObject, typename='Rec::TrackParticle', target='trk') AddConstitIndex(MyJetD3PDObject, typename='Rec::TrackParticle', target='trk') #AddLeptonicInfo(MyJetD3PDObject,level=0) #AddLeptonicInfo(MyGroomedJetD3PDObject,99) elif 'Topo' in self.parentJets: AddConstitIndex(MyGroomedJetD3PDObject) AddConstitIndex(MyJetD3PDObject) AddLeptonicInfo(MyJetD3PDObject, level=0) AddLeptonicInfo(MyGroomedJetD3PDObject, 99) AddAssocJetsIndex(MyJetD3PDObject, 'TrackAssoc', 'trk') AddAssocJetsIndex(MyGroomedJetD3PDObject, 'TrackAssoc', 'trk') elif 'Truth' in self.parentJets: AddConstitTruthIndex(MyJetD3PDObject) AddConstitTruthIndex(MyGroomedJetD3PDObject) AddTruthLeptonicInfo(MyJetD3PDObject, level=0) AddTruthLeptonicInfo(MyGroomedJetD3PDObject, level=0) if 'Track' not in self.parentJets and 'Truth' not in self.parentJets: AddAssocJetsIndex(MyJetD3PDObject, 'TrackJets', 'jet_' + ars[0] + ars[1] + 'TrackZ_') if rec.doTruth(): if self.parentJets == "AntiKt10LCTopo" or self.parentJets == "CamKt12LCTopo": AddAssocJetsIndex(MyJetD3PDObject, 'TruthJets', 'jet_' + ars[0] + ars[1] + 'Truth_') else: AddAssocJetsIndex(MyJetD3PDObject, 'TruthJets', 'jet_' + ars[0] + ars[1] + 'Truth_') #AddAssocJetsIndex(MyJetD3PDObject, 'TruthJets', 'jet_' + ars[0] + ars[1] + 'Truth_') self.JetQualInclude = [] if 'Topo' in self.parentJets or 'LCTopo' in self.parentJets: self.commonIncludeList += [ 'ConstituentScale', 'EMScale', 'EMFraction', 'JetSamplingsFrac' ] #, 'El02Match', 'Mu02Match', 'L1Info', 'L2Info', 'EFInfo'] AddHadronicInfo(MyJetD3PDObject, [ 'OriginIndex', 'nTrk', 'sumPtTrk', 'EtaOrigin', 'PhiOrigin', 'MOrigin' ], theblockname='OriginIndexBlock') AddHadronicInfo(MyGroomedJetD3PDObject, ['EtaOrigin', 'PhiOrigin', 'MOrigin'], theblockname='OriginIndexBlock') if (self.parentJets == 'AntiKt10LCTopo') or (self.parentJets == 'CamKt12LCTopo'): AddHadronicInfo(MyJetD3PDObject, ['LCJES', 'LCJES_EtaCorr', 'LCJES_MassCorr'], theblockname='LCJESBlock') AddHadronicInfo(MyGroomedJetD3PDObject, ['LCJES', 'LCJES_EtaCorr', 'LCJES_MassCorr'], theblockname='LCJESBlock') self.VtxInclude = [] #if 'Topo' in self.parentJets: # self.VtxInclude += ['JVtx','JetVertexFraction'] self.VtxInclude += ['JVtx', 'JetVertexFraction'] tmpParentJets = self.parentJets.replace("JS", "") AddAssocJetsIndex(MyGroomedJetD3PDObject, 'Parent', 'jet_' + tmpParentJets + '_') for gr in self.groomedJetsList: AddAssocJetsIndex(MyJetD3PDObject, gr, 'jet_' + tmpParentJets + gr + '_') MyGroomedJetCollectionD3PDObject = getJetCollectionD3PDObject( objectname="MyGroomedJetCollectionD3PDObject") AddUniqueMoments(MyGroomedJetCollectionD3PDObject, ['SmallR', 'PtFrac', 'NSub'], theblockname='TrimConfigMoments', level=99) AddUniqueMoments( MyGroomedJetCollectionD3PDObject, ['NSubjets', 'ktycut2', 'massFraction', 'minRfilt', 'minSplitR'], theblockname='FiltConfigMoments', level=0) AddHadronicInfo(MyGroomedJetD3PDObject, ['CORE_RBB', 'CORE_RFILT'], theblockname='FiltMoments', level=99) AddHadronicInfo(MyGroomedJetD3PDObject, [ 'Tau1', 'Tau2', 'Tau3', 'WIDTH', 'SPLIT12', 'SPLIT23', 'SPLIT34', 'ZCUT12', 'ZCUT23', 'ZCUT34', 'Dip12', 'Dip13', 'Dip23', 'DipExcl12', 'PlanarFlow', 'Angularity', 'ActiveArea', 'ActiveArea_px', 'ActiveArea_py', 'ActiveArea_pz', 'ActiveArea_e', 'VoronoiArea', 'QW', 'PullMag', 'PullPhi', 'Pull_C00', 'Pull_C01', 'Pull_C10', 'Pull_C11' ], theblockname='jsObsblock') AddHadronicInfo(MyJetD3PDObject, [ 'Tau1', 'Tau2', 'Tau3', 'WIDTH', 'SPLIT12', 'SPLIT23', 'SPLIT34', 'ZCUT12', 'ZCUT23', 'ZCUT34', 'Dip12', 'Dip13', 'Dip23', 'DipExcl12', 'PlanarFlow', 'Angularity', 'ActiveArea', 'ActiveArea_px', 'ActiveArea_py', 'ActiveArea_pz', 'ActiveArea_e', 'VoronoiArea', 'QW', 'PullMag', 'PullPhi', 'Pull_C00', 'Pull_C01', 'Pull_C10', 'Pull_C11' ], theblockname='jsObsblock') #add area corrected kinematics for the groomed jets from D3PDMakerConfig.CommonGroomedJetsConfig import getGroomedJetsConfig dictsConfig = getGroomedJetsConfig() from D3PDMakerConfig.CommonJSjets import buildName self.AreaCorr = [] for dC in dictsConfig: for l in dC[1]: if 'AreaCorr' in l['args']: if l['args']['AreaCorr']: self.AreaCorr.append(buildName(l)) if (self.AreaCorr) and ((self.parentJets == 'AntiKt10LCTopo') or (self.parentJets == 'CamKt12LCTopo')): AddHadronicInfo(MyGroomedJetD3PDObject, [ 'm_areacorrected', 'pt_areacorrected', 'phi_areacorrected', 'eta_areacorrected', 'm_voronoiareacorrected', 'pt_voronoiareacorrected', 'phi_voronoiareacorrected', 'eta_voronoiareacorrected', 'm_voronoighostareacorrected', 'pt_voronoighostareacorrected', 'phi_voronoighostareacorrected', 'eta_voronoighostareacorrected' ], theblockname='AreaCorrectedMoments', level=99) ## in groomedJetsList, subjets name should follow the name of the 'full/composite' jet. for idx, gr in enumerate(self.groomedJetsList): ## names are unique if 'KtSubjets' in gr: #AddBTaggingInfoFromSubjets(MyGroomedJetD3PDObject, sj_assoc_name = gr, sj_prefix = gr, level = 99) AddAssocJetsIndex(MyGroomedJetD3PDObject, gr, 'jet_' + tmpParentJets + gr + '_', intermediate_names=['Parent'], level=99) elif 'Subjets' in gr and idx != 0 and 'Subjets' not in self.groomedJetsList[ idx - 1]: #AddBTaggingInfoFromSubjets(MyGroomedJetD3PDObject, sj_assoc_name = gr, sj_prefix = gr, level = 99) AddAssocJetsIndex(MyGroomedJetD3PDObject, gr, 'jet_' + tmpParentJets + gr + '_', intermediate_names=['Parent'], level=99) if 'LCTopo' in self.parentJets: AddBTaggingInfoFromSubjets(MyGroomedJetD3PDObject, sj_assoc_name=gr, sj_prefix=gr, level=99) elif 'Subjets' in gr: raise ValueError("Subjets without full composite jet ?" ) ## not suppose to happen self.MyJetD3PDObject = MyJetD3PDObject self.MyGroomedJetD3PDObject = MyGroomedJetD3PDObject self.MyGroomedJetCollectionD3PDObject = MyGroomedJetCollectionD3PDObject if ('LCTopo' in self.parentJets): self.MyJetAssocD3PDObject = MyJetAssocD3PDObject
from D3PDMakerCoreComps.D3PDObject import DeferArg from D3PDMakerCoreComps.resolveSGKey import resolveSGKey from AthenaCommon.AlgSequence import AlgSequence import EventCommonD3PDMaker import D3PDMakerCoreComps import egammaD3PDMaker import CaloD3PDMaker auxprefix = DeferArg( 'D3PDMakerFlags.EgammaUserDataPrefix() + "_" +' 'resolveSGKey (typeName, sgkey) + "_"', globals()) CorrectionClusterD3PDObject = \ make_SGDataVector_D3PDObject ('DataVector<xAOD::CaloCluster_v1>', 'egClusterCollection', 'cl_', 'CorrectionClusterD3PDObject') CorrectionClusterD3PDObject.defineBlock(0, 'Kinematics', EventCommonD3PDMaker.FourMomFillerTool, WriteE=True) CorrectionClusterD3PDObject.defineBlock( 0, 'Samplings', CaloD3PDMaker.ClusterSamplingFillerTool, SamplingEnergies=True, SamplingEtaPhi=True, SamplingEtaPhiRaw=True, #SamplingEtamax = True, Samplings=[0, 1, 2, 3, 4, 5, 6, 7])
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration import D3PDMakerCoreComps import EventCommonD3PDMaker import JetD3PDMaker from D3PDMakerCoreComps.D3PDObject import D3PDObject from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags from RecExConfig.RecFlags import rec TruthJetD3PDObject = make_SGDataVector_D3PDObject('JetCollection', D3PDMakerFlags.JetSGKey(), 'truthjet_', 'TruthJetD3PDObject') TruthJetD3PDObject.defineBlock(0, 'Kinematics', EventCommonD3PDMaker.FourMomFillerTool, WriteE=True) TruthJetD3PDObject.defineBlock(2, 'JetShape', JetD3PDMaker.JetShapeFillerTool) if rec.doTruth: TruthJetD3PDObject.defineBlock(2, 'TrueFlavorComponents', JetD3PDMaker.JetTrueTagFillerTool)
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration # $Id$ # # @file QcdD3PDMaker/python/QcdMuonSpShowerD3PDObject.py # @author Michiru Kaneda <*****@*****.**> # @date Jan., 2011 # @brief MuonSpShower filler tool # from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject from QcdD3PDMaker.QcdD3PDMakerConf import QcdD3PD__MuonSpShowerFillerTool as MuonSpShowerFillerTool MuonSpShowerD3PDObject = make_SGDataVector_D3PDObject( "Rec::MuonSpShowerContainer", "MuonSpShowers", "musp_", "QcdMuonSpShowerD3PDObject") MuonSpShowerD3PDObject.defineBlock(0, 'Position', MuonSpShowerFillerTool, WritePosition=True, WriteHits=False, WriteSegments=False) MuonSpShowerD3PDObject.defineBlock(1, 'Hits', MuonSpShowerFillerTool, WritePosition=False, WriteHits=True, WriteSegments=False)
# Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration import CaloD3PDMaker import CaloSysD3PDMaker import D3PDMakerCoreComps import EventCommonD3PDMaker from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags from D3PDMakerCoreComps.ContainedVectorMultiAssociation import ContainedVectorMultiAssociation ClusterD3PDObject = \ make_SGDataVector_D3PDObject ('CaloClusterContainer', D3PDMakerFlags.ClusterSGKey(), 'cl_', 'ClusterD3PDObject') ClusterD3PDObject.defineBlock(0, 'Kinematics', EventCommonD3PDMaker.FourMomFillerTool, WriteE=False, WriteM=False) ClusterD3PDObject.defineBlock(0, 'SamplingBasics', CaloD3PDMaker.ClusterSamplingFillerTool) from CaloSysD3PDMaker import ClusterMomentFillerTool as CMFT ClusterD3PDObject.defineBlock( 1, 'Moments', CMFT,
# @file MuonD3PDMaker/python/TruthMuonD3PDObject.py # $author Srivas Prasad <*****@*****.**> # @date March 2010 # @brief dump true muons - modeled on Tau code import MuonD3PDMaker import EventCommonD3PDMaker from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject from D3PDMakerCoreComps.resolveSGKey import testSGKey from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags from AthenaCommon.AlgSequence import AlgSequence from RecExConfig.ObjKeyStore import cfgKeyStore import TruthD3PDMaker TruthMuonD3PDObject = make_SGDataVector_D3PDObject( 'DataVector<xAOD::TruthParticle_v1>', 'TruthMuons', 'muonTruth_', 'TruthMuonD3PDObject') def _truthMuonAlgHook(c, prefix, sgkey, TruthContainer='TruthParticles', **kw): preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()) # Is the container already in SG? if cfgKeyStore.isInInput('DataVector<xAOD::TruthParticle_v1>', sgkey): return # Is the algorithm already in the sequence? algname = prefix + 'TruthMuonsToSG' if hasattr(preseq, algname): return