def egammaTruthParticleConfig \ (seq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()), sgkey = 'egammaTruth', prefix = '', doPileup = D3PDMakerFlags.TruthDoPileup(), **kwargs): if not rec.doTruth(): return # Is the container already in SG? if cfgKeyStore.isInInput ('DataVector<xAOD::TruthParticle_v1>', sgkey): return algname = prefix + sgkey + 'Builder' if not hasattr (seq, algname): import AthenaCommon.CfgMgr as CfgMgr from egammaRec.Factories import ToolFactory exten = ToolFactory (CfgMgr.Trk__ParticleCaloExtensionTool, name="GSFParticleCaloExtensionTool", StartFromPerigee = True)() seq += egammaD3PDAnalysis.egammaTruthAlg ( algname, InputKey = D3PDMakerFlags.TruthSGKey(), OutputKey = sgkey, ParticleCaloExtensionTool = exten, AuxPrefix = D3PDMakerFlags.EgammaUserDataPrefix()) cfgKeyStore.addTransient ('DataVector<xAOD::TruthParticle_v1>', sgkey) return
def simpleParticleConfig(seq=AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()), sgkey='SimpleTruthCollection', prefix='', pdg_id=11, min_pt=-1. * GeV): # Is the container already in SG? if cfgKeyStore.isInInput('TruthParticleContainer', sgkey): return # Is the algorithm already registered? algname = prefix + sgkey + 'Builder' if hasattr(seq, algname): return filtname = prefix + sgkey + 'Filter' seq += createMcAodBuilder\ (algname, inMcEvtCollection = D3PDMakerFlags.TruthSGKey(), outMcEvtCollection = sgkey + '_GEN_D3PD', outTruthParticles = sgkey, filterTool = TruthD3PDAnalysis.SimpleTruthParticleFilterTool (filtname, PDG_ID = pdg_id, MinPt = min_pt), cnvTool = CfgMgr.TruthParticleCnvTool('D3PDTruthParticleCnvTool'), ) cfgKeyStore.addTransient('TruthParticleContainer', sgkey) return
def JetTileD3PD(file, level=4, tuplename='MyTuple', 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 += JetTileD3PDObject(**_args( level, inputSGkey, kw, sgkey=inputSGkey, prefix='AntiKt4Topo_')) from TriggerD3PDMaker.BGCodeD3PDObject import BGCodeD3PDObject from TriggerD3PDMaker.BunchStructureMetadata import addBunchStructureMetadata alg += BGCodeD3PDObject(**_args(2, 'BGCode', kw)) addBunchStructureMetadata(alg) from TriggerD3PDMaker.TrigDecisionD3PDObject import TrigDecisionD3PDObject from TriggerD3PDMaker.TrigConfMetadata import addTrigConfMetadata alg += TrigDecisionD3PDObject(**_args(10, 'TrigDecision', kw)) addTrigConfMetadata(alg) if D3PDMakerFlags.DoTrigger(): alg += jetMETTriggerBitsD3PDObject(level) from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags TrackD3PDFlags.storeVertexTrackIndexAssociation.set_Value_and_Lock(False) TrackD3PDFlags.storeVertexTrackAssociation.set_Value_and_Lock(False) TrackD3PDFlags.storeVertexFitQuality.set_Value_and_Lock(False) from TrackD3PDMaker.xAODVertexD3PDObject import PrimaryxAODVertexD3PDObject alg += PrimaryxAODVertexD3PDObject( **_args(0, '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 += JetTileD3PDObject(**_args(1, 'AntiKt4TruthJets', kw, sgkey='AntiKt4TruthJets', prefix='AntiKt4Truth_')) alg.MetadataTools += [LBMetadataConfig()] 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
def egammaTimeCorrConfig \ (seq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()), prefix = '', sgkey = D3PDMakerFlags.ElectronSGKey(), typeName = 'DataVector<xAOD::Electron_v1>', allowMissing = False): """Configure egammaTimeCorrAlg for D3PD making. SEQ is the Gaudi sequence to which the algorithm should be added. Default is that given by PreD3PDAlgSeqName. PREFIX is a prefix to add to the name of the algorithm scheduled. SGKEY/TYPENAME is the StoreGate key of the input electron container and the name of its type. If ALLOWMISSING is true, don't fail if the SG key doesn't exist. """ if (not D3PDMakerFlags.MakeEgammaUserData() or D3PDMakerFlags.HaveEgammaUserData()): return DVGetter = D3PDMakerCoreComps.SGDataVectorGetterTool resolved_sgkey = resolveSGKey (typeName, sgkey) auxprefix = (D3PDMakerFlags.EgammaUserDataPrefix() + '_' + resolved_sgkey + '_') algName = 'egammaTimeCorrAlg' + resolved_sgkey if not hasattr (seq, algName): from IOVDbSvc.CondDB import conddb conddb.addFolder("LAR_OFL","/LAR/TimeCorrectionOfl/NonRunCon <tag>LARTimeCorrectionOflNonRunCon-00</tag>",force=True) conddb.addFolder("LAR_OFL","/LAR/TimeCorrectionOfl/RunCon <tag>LARTimeCorrectionOflRunCon-00</tag>",force=True) from CaloClusterCorrection.CaloClusterTimeTool import GetCaloClusterTimeTool myCaloClusterTimeTool=GetCaloClusterTimeTool("caloClusterTimeTool", "/LAR/TimeCorrectionOfl/NonRunCon","/LAR/TimeCorrectionOfl/RunCon") seq += egammaD3PDAnalysis.egammaTimeCorrAlg \ (algName, Getter = DVGetter (prefix + 'egammaTimeCorrGetter', TypeName = typeName, SGKey = sgkey), AllowMissing = allowMissing, AuxPrefix = auxprefix, CaloClusterTimeTool = myCaloClusterTimeTool, ) return
def TileGapConfig \ (seq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()), prefix = '', sgkey = 'egClusterCollection', typeName = 'DataVector<xAOD::CaloCluster_v1>', allowMissing = False): """Configure egammaMaxECellAlg for D3PD making. SEQ is the Gaudi sequence to which the algorithm should be added. Default is that given by PreD3PDAlgSeqName. PREFIX is a prefix to add to the name of the algorithm scheduled. SGKEY/TYPENAME is the StoreGate key of the input electron container and the name of its type. If ALLOWMISSING is true, don't fail if the SG key doesn't exist. """ if (not D3PDMakerFlags.MakeEgammaUserData() or D3PDMakerFlags.HaveEgammaUserData()): return DVGetter = D3PDMakerCoreComps.SGDataVectorGetterTool resolved_sgkey = resolveSGKey (typeName, sgkey) auxprefix = (D3PDMakerFlags.EgammaUserDataPrefix() + '_' + resolved_sgkey + '_') algName = 'TileGapSumAlg' + resolved_sgkey if not hasattr (seq, algName): gapsel = TileGapSelectionGetter (seq) myAlg = egammaD3PDAnalysis.TileGapSumAlg \ (algName, ClusterGetter = DVGetter (prefix + 'TileGapAlgGetter', TypeName = typeName, SGKey = sgkey), CellGetter = SGDataVectorGetterTool (prefix + 'TileGapAlgCellGetter', SGKey = gapsel.outputKey(), TypeName = gapsel.outputType()), AllowMissing = allowMissing, AuxPrefix = auxprefix,) seq += myAlg return
def PhotonTruthConfig \ (seq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()), prefix = '', sgkey = D3PDMakerFlags.ElectronSGKey(), typeName = 'ElectronContainer', allowMissing = False): """Configure PhotonTruthAlg for D3PD making. SEQ is the Gaudi sequence to which the algorithm should be added. Default is that given by PreD3PDAlgSeqName. PREFIX is a prefix to add to the name of the algorithm scheduled. SGKEY/TYPENAME is the StoreGate key of the input electron container and the name of its type. If ALLOWMISSING is true, don't fail if the SG key doesn't exist. """ if not rec.doTruth(): return if (not D3PDMakerFlags.MakeEgammaUserData() or D3PDMakerFlags.HaveEgammaUserData()): return DVGetter = D3PDMakerCoreComps.SGDataVectorGetterTool resolved_sgkey = resolveSGKey (typeName, sgkey) auxprefix = (D3PDMakerFlags.EgammaUserDataPrefix() + '_' + resolved_sgkey + '_') from TruthD3PDMaker.MCTruthClassifierConfig \ import D3PDMCTruthClassifier ptaname = 'PhotonTruthAlg_' + resolved_sgkey if not hasattr (seq, ptaname): seq += egammaD3PDAnalysis.PhotonTruthAlg \ (ptaname, PhotonGetter = DVGetter (prefix + 'PhotonTruthAlgGetter', TypeName = typeName, SGKey = sgkey), AllowMissing = allowMissing, AuxPrefix = auxprefix, TruthTool = egammaD3PDAnalysis.PhotonTruthTool ('D3PD__PhotonTruthTool', Classifier = D3PDMCTruthClassifier)) return
def makeD3PDObject(name, prefix, object_name, getter=None, sgkey=None, label=None): if sgkey == None: sgkey = "LArHits" if label == None: label = prefix if prefix == "hitemb_": sgkey = "LArHitEMB" elif prefix == "hitemec_": sgkey = "LArHitEMEC" elif prefix == "hithec_": sgkey = "LArHitHEC" elif prefix == "hitfcal_": sgkey = "LArHitFCAL" if not getter: getter = CaloSysD3PDMaker.LArHitContainerGetterTool \ (name + '_Getter', TypeName = 'LArHitContainer', SGKey = sgkey, Label = label) return D3PDMakerCoreComps.VectorFillerTool (name, Prefix = prefix, Getter = getter, ObjectName = object_name, SaveMetadata = \ D3PDMakerFlags.SaveObjectMetadata())
def makeCellD3PDObject(name, prefix, object_name, getter=None, sgkey=None, label=None): if sgkey == None: sgkey = 'AllCalo' if label == None: label = prefix if prefix in prefix_to_det.keys(): sgkey = prefix #print " makeCellD3PDObject: sgkey = ", sgkey if not getter: getter = D3PDMakerCoreComps.SGDataVectorGetterTool \ (name + '_Getter', TypeName = 'CaloCellContainer', SGKey = sgkey, Label = label) # create the selected cells from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags return D3PDMakerCoreComps.VectorFillerTool (name, Prefix = prefix, Getter = getter, ObjectName = object_name, SaveMetadata = \ D3PDMakerFlags.SaveObjectMetadata())
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
def make_obj (name, prefix, object_name): from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags return D3PDMakerCoreComps.VoidObjFillerTool (name, Prefix = prefix, ObjectName = object_name, SaveMetadata = \ D3PDMakerFlags.SaveObjectMetadata())
def _larCollTimeAlgHook(c, seq=AlgSequence( D3PDMakerFlags.PreD3PDAlgSeqName()), *args, **kw): LArCollisionTimeGetter(seq) return
def make_JetTagJet_D3PDObject(name, prefix, object_name, sgkey, label, allowMissing=False, **kw): getter = D3PDMakerCoreComps.SGDataVectorGetterTool( name + '_Getter', SGKey=sgkey, TypeName='JetCollection', Label=label) defs = kw # select valid argument for VectorFillerTool # needed to remove argument for the hook function for k in defs.keys(): if not hasattr(D3PDMakerCoreComps.VectorFillerTool, k): del defs[k] from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags return D3PDMakerCoreComps.VectorFillerTool (name, Prefix = prefix, Getter = getter, ObjectName = object_name, AllowMissing=allowMissing, SaveMetadata = \ D3PDMakerFlags.SaveObjectMetadata(), **defs)
def _jetFilterAlgHook(c, prefix, sgkey, JetContainer, **kw): preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()) # Is the container already in SG? if cfgKeyStore.isInInput('JetContainer', sgkey): return # Is the algorithm already in the sequence? algname = sgkey + JetTagD3PDKeys.FilteredJetMakerAlgPostfix() if hasattr(preseq, algname): return # select valid argument for JetTagJetFilterAlg filterargs = kw for k in filterargs.keys(): if not hasattr(JetTagD3PDMaker.JetTagJetFilterAlg, k): del filterargs[k] del filterargs['name'] ### if some argument do not exist set them to the flag values if not 'PtMinCut' in filterargs: filterargs['PtMinCut'] = JetTagD3PDFlags.JetFilterPtMinCut() if not 'EtaCut' in filterargs: filterargs['EtaCut'] = JetTagD3PDFlags.JetFilterEtaCut() if not 'UseEMScale' in filterargs: filterargs['UseEMScale'] = JetTagD3PDFlags.JetFilterUseEMScale() preseq += JetTagD3PDMaker.JetTagJetFilterAlg(algname, FilteredJetContainer=sgkey, JetContainer=JetContainer, **filterargs) return
def makeTruthTrackD3PDObject (name, prefix, object_name, getter = None, sgkey = "TruthEvent,GEN_AOD", typename = 'McEventCollection', label = 'mc'): if not getter: from InDetD3PDMaker import TruthTrackGetterTool getter = TruthTrackGetterTool (name + '_Getter', SGKey = sgkey, TypeName = typename, Label = label, KeepOnlyPrimaryParticles = False, KeepOnlyChargedParticles = False, KeepV0 = True, TrueTrackPtCut = 0, TrueTrackEtaCut = 99999., MaxRAll = 2000000, MaxZAll = 2000000, MaxRPrimary = 25, MaxZPrimary = 200) from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags return D3PDMakerCoreComps.VectorFillerTool (name, Prefix = prefix, Getter = getter, ObjectName = object_name, SaveMetadata = \ D3PDMakerFlags.SaveObjectMetadata())
def makeV0D3PDObject(name, prefix, object_name, getter=None, sgkey=_sgkey, label=_label): if sgkey == None: sgkey = 'SimpleV0Candidates' if label == None: label = prefix if not getter: from InDetD3PDMaker import V0ContainerGetterTool getter = V0ContainerGetterTool\ (name + '_Getter', TypeName = 'V0Container', SGKey = sgkey, Label = label) from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags return D3PDMakerCoreComps.VectorFillerTool (name, Prefix = prefix, Getter = getter, ObjectName = object_name, AllowMissing = True, SaveMetadata = \ D3PDMakerFlags.SaveObjectMetadata())
def __vertexReco(c, **kw): from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags from AthenaCommon.AlgSequence import AlgSequence from HSG2VertexCreation.HSG2VertexReconstruction import HSG2VertexReconstruction HSG2VertexReconstruction("HSG2VertexReconstruction", AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName())) return
def makeTowerD3PDObject(name, prefix, object_name='TowerD3PDObject', getter=None, sgkey=None, label=None): if sgkey == None: sgkey = 'CombinedTower' if label == None: label = prefix ContainerType = 'CaloTowerContainer' if sgkey == 'TopoTower': ContainerType = 'CaloTopoTowerContainer' print " makeTowerD3PDObject: name = ", name print " makeTowerD3PDObject: prefix = ", prefix print " makeTowerD3PDObject: object_name = ", object_name print " makeTowerD3PDObject: sgkey = ", sgkey if not getter: getter = D3PDMakerCoreComps.SGDataVectorGetterTool \ (name + '_Getter', TypeName = ContainerType, SGKey = sgkey, Label = label) # create the selected cells from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags return D3PDMakerCoreComps.VectorFillerTool (name, Prefix = prefix, Getter = getter, ObjectName = object_name, SaveMetadata = \ D3PDMakerFlags.SaveObjectMetadata())
def make_obj(name, prefix, object_name, getter=None, sgkey=None, filter=default_filter, label=default_label, **kw): if sgkey == None: sgkey = default_sgkey if label == None: label = TruthD3PDKeys.GenEventGetterLabel() if getter == None: getter = TruthD3PDMaker.GenEventGetterTool(name + '_Getter', Label=label, Selector=filter, SGKey=sgkey) defs = other_defaults.copy() defs.update(kw) from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags return D3PDMakerCoreComps.VectorFillerTool( name, Prefix = prefix, Getter = getter, ObjectName = object_name, SaveMetadata = \ D3PDMakerFlags.SaveObjectMetadata(), **defs )
def _electronAlgHook(c, prefix, sgkey, typeName, seq=AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()), *args, **kw): ElectronUserDataConfig(seq=seq, prefix=prefix, sgkey=sgkey, typeName=typeName) from PhotonAnalysisUtils.PhotonAnalysisUtilsFlags import jobproperties # set some options here. jobproperties.PhotonAnalysisUtilsFlags.DumpNtuple = False jobproperties.PhotonAnalysisUtilsFlags.DumpHistograms = False if hasattr(jobproperties.PhotonAnalysisUtilsFlags, 'DumpTimeDifference'): jobproperties.PhotonAnalysisUtilsFlags.DumpTimeDifference = False jobproperties.PhotonAnalysisUtilsFlags.AlgSequence = seq.getName() jobproperties.PhotonAnalysisUtilsFlags.DoReRunJetFinding = True # probably a few more need to be set rlist = release_version() if rlist == None: # Assume an old version if no version string was stored. jobproperties.PhotonAnalysisUtilsFlags.ProductionRelease = 15.0 elif rlist: jobproperties.PhotonAnalysisUtilsFlags.ProductionRelease = \ rlist[0] + float(rlist[1])/10 #commented out PUU #from PhotonAnalysisUtils.PhotonAnalysisUtilsGetter import PhotonAnalysisUtilsGetter #pau = PhotonAnalysisUtilsGetter() return
def makeTileD3PDObject(name, prefix, object_name='TileDetailsD3PDObject', getter=None, sgkey=None, label=None): global BaseSGKey BaseSGKey = sgkey sgkey = prefix if label == None: label = prefix print " makeTileD3PDObject: name = ", name print " makeTileD3PDObject: prefix = ", prefix print " makeTileD3PDObject: object_name = ", object_name print " makeTileD3PDObject: sgkey = ", sgkey if not getter: getter = D3PDMakerCoreComps.SGDataVectorGetterTool \ (name + '_Getter', TypeName = 'CaloCellContainer', SGKey = sgkey, Label = label) # create the selected cells from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags return D3PDMakerCoreComps.VectorFillerTool (name, Prefix = prefix, Getter = getter, ObjectName = object_name, SaveMetadata = \ D3PDMakerFlags.SaveObjectMetadata())
def makeTileCosmicMuonD3PDObject (name, prefix, object_name='TileCosmicMuonD3PDObject', getter = None, sgkey = None, label = None): if sgkey == None: sgkey = 'TileCosmicMuonHT' if label == None: label = prefix print " makeTileCosmicMuonD3PDObject: name = ", name print " makeTileCosmicMuonD3PDObject: prefix = ", prefix print " makeTileCosmicMuonD3PDObject: object_name = ", object_name print " makeTileCosmicMuonD3PDObject: sgkey = ", sgkey if not getter: getter = D3PDMakerCoreComps.SGDataVectorGetterTool \ (name + '_Getter', TypeName = 'TileCosmicMuonContainer', SGKey = sgkey, Label = label) from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags return D3PDMakerCoreComps.VectorFillerTool (name, Prefix = prefix, Getter = getter, ObjectName = object_name, SaveMetadata = \ D3PDMakerFlags.SaveObjectMetadata())
def make_TwoTrackVertex_D3PDObject( name, prefix, object_name, sgkey, label=JetTagD3PDKeys.JFTwoTrackVertexGetterLabel(), allowMissing=False, **kw): getter = D3PDMakerCoreComps.SGDataVectorGetterTool( name + '_Getter', SGKey=sgkey, TypeName='JetTagTwoTrackVertexDataHolder', Label=label) defs = kw for k in defs.keys(): if not hasattr(D3PDMakerCoreComps.VectorFillerTool, k): del defs[k] if not defs.has_key("SaveMetadata"): defs["SaveMetadata"] = D3PDMakerFlags.SaveObjectMetadata() return D3PDMakerCoreComps.VectorFillerTool(name, Prefix=prefix, Getter=getter, ObjectName=object_name, AllowMissing=allowMissing, **defs)
def _jetTwoTrackVertexTagAlgHook( c, prefix, sgkey, jetCollections, InfoName=JetTagD3PDFlags.JetFitterVertexFinderObjects(), **kw): preseq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()) # Is the container already in SG? if cfgKeyStore.isInInput('JetTagTwoTrackVertexDataHolder', sgkey): return # Is the algorithm already in the sequence? algname = sgkey + JetTagD3PDKeys.JFTwoTrackVertexMakerAlgPostfix() if hasattr(preseq, algname): return filterargs = kw for k in filterargs.keys(): if not hasattr(JetTagD3PDMaker.JetTagJetFitterDataToSGAlg, k): del filterargs[k] del filterargs['name'] preseq += JetTagD3PDMaker.JetTagJetFitterDataToSGAlg( algname, TwoTrackVertexName=sgkey, FillTwoTrackVertex=True, JetCollections=jetCollections, InfoName=InfoName, **filterargs) return
def egammaDeltaEmax2Config \ (seq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()), prefix = '', sgkey = D3PDMakerFlags.ElectronSGKey(), typeName = 'DataVector<xAOD::Electron_v1>', allowMissing = False): """Configure egammaDeltaEmax2Alg for D3PD making. SEQ is the Gaudi sequence to which the algorithm should be added. Default is that given by PreD3PDAlgSeqName. PREFIX is a prefix to add to the name of the algorithm scheduled. SGKEY/TYPENAME is the StoreGate key of the input electron container and the name of its type. If ALLOWMISSING is true, don't fail if the SG key doesn't exist. """ if (not D3PDMakerFlags.MakeEgammaUserData() or D3PDMakerFlags.HaveEgammaUserData()): return DVGetter = D3PDMakerCoreComps.SGDataVectorGetterTool resolved_sgkey = resolveSGKey (typeName, sgkey) auxprefix = (D3PDMakerFlags.EgammaUserDataPrefix() + '_' + resolved_sgkey + '_') emax2name = 'DeltaEmax2Alg_' + resolved_sgkey if not hasattr (seq, emax2name): highlum = False if typeName == 'ElectronContainer': from AthenaCommon.BeamFlags import jobproperties if jobproperties.Beam.numberOfCollisions() >= 20 : highlum = True seq += egammaD3PDAnalysis.egammaDeltaEmax2Alg \ (emax2name, Getter = DVGetter (prefix + 'DeltaEmax2Getter', TypeName = typeName, SGKey = sgkey), AllowMissing = allowMissing, HighLum = highlum, AuxPrefix = auxprefix) return
def _electronRawClusterAssocHook(c, prefix, sgkey, typeName, *args, **kw): assoc = getattr(c, c.name() + '_D3PD__egammaRawClusterAssociationTool', None) if assoc: assoc.Associator.AssocGetter.SGKey = \ (resolveSGKey(typeName, sgkey) + D3PDMakerFlags.RawClustersAssocSGKeySuffix()) return
def _egammaTruthAlgHook(c, prefix, sgkey, seq=AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()), *args, **kw): egammaTruthParticleConfig(seq=seq, prefix=prefix, sgkey=sgkey) return
def _fixJetTiming(c, **kw): # Check version number of the input data. # If no version is found, assume old. rlist = release_version() if rlist: if rlist[0] >= 16: return if rlist[0] == 15 and rlist[1] >= 7: return if rlist[0] == 15 and rlist[1] == 6 and rlist[2] >= 8: return sgkey_in = c.Getter.SGKey sgkey_in = resolveSGKey('JetCollection', sgkey_in) sgkey_out = sgkey_in + '_timing' seq = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName()) if not hasattr(seq, sgkey_out): tools = [] caloqual_kw = { 'doCellBasedVariables': True, 'doConstituentBasedVariables': True, 'doSamplingBasedVariables': True, 'cutOnTile': 254, 'cutOnLAr': 4000, 'doTileQuality': True, 'doLArQuality': True } if hasattr(JetRecToolsConf, 'JetTimeQualityTool'): # rel 15 setup tool1 = JetRecToolsConf.JetTimeQualityTool(sgkey_out + 'TimeTool', DoTime=False, DoQuality=False, UseCells=False) if rec.readESD() or rec.readRDO(): tool1.DoTime = True tool1.DoQuality = True tool1.UseCells = True if rec.readAOD() and (sgkey_in.find('H1Topo') >= 0 or sgkey_in.find('LCTopo') >= 0): tool1.DoTime = True tools.append(tool1) else: # rel 16 caloqual_kw['doTiming'] = True tool2 = JetCaloQualityTool(sgkey_out + 'QualTool', **caloqual_kw) tools.append(tool2) alg = JetD3PDMaker.JetFixupAlg(sgkey_out, InputKey=sgkey_in, OutputKey=sgkey_out, Tools=tools) for t in tools: alg += t seq += alg c.Getter.SGKey = sgkey_out return
def tileMuonFiller(name, prefix, object_name): tileMuonGetter = SGDataVectorGetterTool('Muon_getter', TypeName = 'xAOD::MuonContainer', SGKey = 'SelectedMuons') return VectorFillerTool(name, Prefix = prefix, Getter = tileMuonGetter, ObjectName = 'muons', SaveMetadata = D3PDMakerFlags.SaveObjectMetadata())
def tileCellFiller(name, prefix, object_name): tilecell_getter = SGDataVectorGetterTool('cell_getter', TypeName = 'CaloCellContainer', SGKey = 'SelectedCells') return VectorFillerTool(name, Prefix = prefix, Getter = tilecell_getter, ObjectName = 'calocells', SaveMetadata = D3PDMakerFlags.SaveObjectMetadata())