def configure(self): mlog = logging.getLogger('METGetterAOD::configure:') mlog.info('entering') # now configure the algorithm try: from MissingET.MissingETConf import METAlg theMETAlg = METAlg("METAlg") except: mlog.error("could not import MissingET.METAlg") print traceback.format_exc() return False #------------------------------------------------------------------------------------------------ # configure tools: METFinal try: from MissingET.MissingETConf import METFinalTool theMETRefFinal = METFinalTool( "RefFinal", WhichCalc="RefCalib", # Refined Calib applied EleRefKey="MET_RefEle", # Specify key for Ref Ele GammaRefKey="MET_RefGamma", # Specify key for Ref Gamma #MuoRefKey = "MET_RefMuon", # Specify key for Ref Muon #TauRefKey = "MET_RefTau", # Specify key for Ref Tau JetRefKey="MET_RefJet", # Specify key for Ref Jet CellOutKey="MET_CellOut", # Specify key for Ref CellOut muonKey= "MET_MuonBoy", # Key for Muon contrib: MET_Muon, MET_MuonBoy cryoTerm="Off", # "On"/"Off"= cryostat corr On / Off cryoKey="MET_Cryo", # Key for Cryo corr: MET_Cryo, MET_CryoCone outKey="MET_RefFinal") except: mlog.error("could not get handle to METRefFinal Quit") print traceback.format_exc() return False # add METFinalTool to list of tools theMETAlg.AlgTools += [theMETRefFinal.getFullName()] # add tools to alg theMETAlg += theMETRefFinal #------------------------------------------------------------------------------------------------ # add algorithm to topSequence (this should always come at the end) mlog.info(" now adding to topSequence") from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence.ZeeSequence += theMETAlg return True
def configure(self): mlog = logging.getLogger('METGetterTrack::configure:') mlog.info('entering') # now configure the algorithm try: from MissingET.MissingETConf import METAlg theMETAlg = METAlg("METAlg") except: mlog.error("could not import MissingET.METAlg") mlog.error(traceback.format_exc()) return False from AthenaCommon.DetFlags import DetFlags if DetFlags.detdescr.ID_on(): try: from MissingET.MissingETConf import METTrackTool theMETTrackTool = METTrackTool("METTrack") # if doFastCaloSim set calibrator tool for ATLFAST2 from CaloRec.CaloCellFlags import jobproperties if jobproperties.CaloCellFlags.doFastCaloSim: doAtlfastII = True else: doAtlfastII = False cellcalibtool = getStandardCalibTool(doAtlfastII) calibtool_name = cellcalibtool.name() # add track select user interface theMETTrackTool.trackd0 = 1.5 # cut on trackd0 theMETTrackTool.trackz0 = 1.50 # cut on trackz0 theMETTrackTool.trackPtMin = 500.0 # cut on trackPtMin theMETTrackTool.trackPtMax = 9999999.0 theMETTrackTool.trackPixelHits = 1 theMETTrackTool.trackSCTHits = 6 theMETTrackTool.trackChi2OverNdf = 999999 theMETTrackTool.UseInsideOut = 1 theMETTrackTool.outKey = "MET_Track" except: mlog.error("could not get handle to METTrackTool Quit") mlog.error(traceback.format_exc()) return False # add cellcalibtool theMETTrackTool += cellcalibtool # add METTrackTool to list of tools theMETAlg.AlgTools += [theMETTrackTool.getFullName()] # add tools to alg theMETAlg += theMETTrackTool #------------------------------------------------------------------------------------------------ # add algorithm to topSequence (this should always come at the end) mlog.info(" now adding to topSequence") from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence += theMETAlg return True
doMissingET = True # main jobOption include("RecExCommon/RecExCommon_flags.py") include("RecExCommon/RecExCommon_topOptions.py") GeoModelSvc = Service("GeoModelSvc") GeoModelSvc.IgnoreTagDifference = True from AthenaCommon.GlobalFlags import globalflags globalflags.DetDescrVersion = "ATLAS-GEO-02-01-00" include("RecExCond/AllDet_detDescr.py") ############################################################################################ #configure MET muon term re-reconstruction since it is off by default ############################################################################################ from MissingET.MissingETConf import METAlg theMETAlg = METAlg("METAlg") from MissingET.MissingETConf import METMuonTool theMETMuonBoyTrackTool = METMuonTool( "MuonBoyTrack", MuonContainer="StacoMuonCollection", outKey="MET_MuonBoy_Track", ApplyChi2OverDoFCut="Off", cut1Chi2OverDoF=0., cut2Chi2OverDoF=10., CaloMuonCollection="CaloMuonCollection", MuTagCollection="StacoMuonCollection", JetContainerName="AntiKt6LCTopoJets", Muon_Selected_Type="Isol", # Isol = use muon tracks Muon_Add_Crack="On" # add muon tracks from cracks )
#---------------------------------------------------------------------- # jobOptions for MissingET package #---------------------------------------------------------------------- from MissingET.MissingETConf import METAlg topSequence += METAlg() from MissingET.MissingETConf import METPartTruthTool METPartTruth = METPartTruthTool('Truth') #---------------------------------------------------------------------- # Name of MissingET AlgTools: #---------------------------------------------------------------------- topSequence.METAlg.AlgTools = [METPartTruth.getFullName()] #---------------------------------------------------------------------- # AlgTools steering #---------------------------------------------------------------------- # # - METPartTruthTool # METPartTruth.etafullsim = 3.2 METPartTruth.outKey = "MET_Truth"
def configure(self): mlog = logging.getLogger('METRefGetter_newplup::configure:') mlog.info('entering') # now configure the algorithm try: from MissingET.MissingETConf import METRefinedAlgorithm theMETRefAlg = METRefinedAlgorithm("METRefAlg" + self.suffix) theMETRefAlgMu = METRefinedAlgorithm("METRefAlgMu" + self.suffix) from RecExConfig.RecFlags import rec theMETRefAlg.CompositionMapKey = "MET_RefComposition" + self.suffix if rec.readAOD(): theMETRefAlg.UseCells = False theMETRefAlgMu.UseCells = False else: theMETRefAlg.UseCells = True theMETRefAlgMu.UseCells = True except: mlog.error("could not import MissingET.METRefAlg") mlog.error(traceback.format_exc()) return False #------------------------------------------------------------------------------------------------ # configure the tools: METRefinedEleTool => calibrator Tool for ATLFASTII try: from MissingET.MissingETConf import METRefinedEleTool theMETRefinedEleTool = METRefinedEleTool("METRefEle" + self.suffix) # refEleTool = theMETRefinedEleTool.getHandle() theMETRefinedEleTool.EgammaInputCollectionKey = self.ele_EgammaInputCollectionKey theMETRefinedEleTool.noCut = self.ele_noCut theMETRefinedEleTool.isEM = self.ele_isEM theMETRefinedEleTool.ElectronEtCut = self.ele_EtCut theMETRefinedEleTool.CalibType = self.ele_calibType # H1 or EmScale or KFact or RefCalib # if doFastCaloSim set calibrator tool for ATLFAST2 from CaloRec.CaloCellFlags import jobproperties if jobproperties.CaloCellFlags.doFastCaloSim: doAtlfastII = True else: doAtlfastII = False cellcalibtool = getStandardCalibTool(doAtlfastII) calibtool_name = cellcalibtool.name() theMETRefinedEleTool.CalibToolName = 'H1WeightToolCSC12Generic/' + calibtool_name theMETRefinedEleTool.BackNavigationTo = "Cell" # to "Cell" theMETRefinedEleTool.MissingETOutKey = "MET_RefEle" + self.suffix print("******************* key = " + theMETRefinedEleTool.MissingETOutKey) print("******************* key2 = " + theMETRefinedEleTool.MissingETOutKey) #----------------- from MissingET.MissingETConf import METClusterResolverTool theMETEleResolver = METClusterResolverTool("EleResolve" + self.suffix) theMETEleResolver.ReferenceClusterContainer = "CaloCalTopoCluster" theMETRefinedEleTool.ClusterResolverTool = theMETEleResolver.getFullName( ) #------------------------------------------------------------------------------------ if self.photon_doPhotonTool: theMETRefinedGammaTool = METRefinedEleTool("METRefGamma" + self.suffix) theMETRefinedGammaTool.EgammaInputCollectionKey = self.gamma_EgammaInputCollectionKey theMETRefinedGammaTool.EleInputCollectionKey = self.gamma_EleInputCollectionKey theMETRefinedGammaTool.isEM = self.gamma_isEM theMETRefinedGammaTool.noCut = self.gamma_noCut theMETRefinedGammaTool.ElectronEtCut = self.gamma_EtCut theMETRefinedGammaTool.CalibType = self.gamma_calibType # H1 or EmScale or KFact or RefCalib theMETRefinedGammaTool.isEMMatch = self.gamma_isEMMatch theMETRefinedGammaTool.ElectronEtCutMatch = self.gamma_ElectronEtCutMatch from CaloRec.CaloCellFlags import jobproperties if jobproperties.CaloCellFlags.doFastCaloSim: doAtlfastII = True else: doAtlfastII = False cellcalibtool = getStandardCalibTool(doAtlfastII) calibtool_name = cellcalibtool.name() theMETRefinedGammaTool.CalibToolName = 'H1WeightToolCSC12Generic/' + calibtool_name theMETRefinedGammaTool.BackNavigationTo = "Cell" # to "Cell" theMETRefinedGammaTool.MissingETOutKey = "MET_RefGamma" + self.suffix #----------------- theMETGammaResolver = METClusterResolverTool("GammaResolve" + self.suffix) theMETGammaResolver.ReferenceClusterContainer = "CaloCalTopoCluster" theMETRefinedGammaTool.ClusterResolverTool = theMETGammaResolver.getFullName( ) except: mlog.error("could not get handle to METRefinedEleTool Quit") mlog.error(traceback.format_exc()) return False # add cellcalibtool theMETRefinedEleTool += cellcalibtool theMETRefinedEleTool += theMETEleResolver if self.photon_doPhotonTool: theMETRefinedGammaTool += cellcalibtool theMETRefinedGammaTool += theMETGammaResolver # add the METRefinedEleTool to list of tools theMETRefAlg.AlgTools += [theMETRefinedEleTool.getFullName()] if self.photon_doPhotonTool: theMETRefAlg.AlgTools += [theMETRefinedGammaTool.getFullName()] # add tools to alg theMETRefAlg += theMETRefinedEleTool if self.photon_doPhotonTool: theMETRefAlg += theMETRefinedGammaTool #theMETRefAlg.OutputLevel = DEBUG #------------------------------------------------------------------------------------------------ # configure tools: METRefinedTauTool => calibrator Tool for ATLFASTII if self.tau_doTauTool: try: from MissingET.MissingETConf import METRefinedTauTool theMETRefinedTauTool = METRefinedTauTool("METRefTau" + self.suffix) theMETRefinedTauTool.TauInputCollectionKey = self.tau_TauInputCollectionKey # or Tau1P3PContainer theMETRefinedTauTool.isTau = self.tau_isTau #"Tight" # Tight, Medium, Loose, Old theMETRefinedTauTool.CalibType = self.tau_calibType # H1 or LocHad theMETRefinedTauTool.TauSignalConeSize = self.tau_TauSignalConeSize theMETRefinedTauTool.TauPtCut = self.tau_TauPtCut theMETRefinedTauTool.RemoveResiduals = self.tau_RemoveResiduals theMETRefinedTauTool.MinimumMETContribution = self.tau_MinimumMETContribution # if doFastCaloSim set calibrator tool for ATLFAST2 from CaloRec.CaloCellFlags import jobproperties if jobproperties.CaloCellFlags.doFastCaloSim: doAtlfastII = True else: doAtlfastII = False cellcalibtool = getStandardCalibTool(doAtlfastII) calibtool_name = cellcalibtool.name() theMETRefinedTauTool.CalibToolName = 'H1WeightToolCSC12Generic/' + calibtool_name theMETRefinedTauTool.BackNavigationTo = "Topo" theMETRefinedTauTool.Cell2ClusterMapKey = "CaloCell2TopoCluster" theMETRefinedTauTool.MissingETOutKey = "MET_RefTau" + self.suffix except: mlog.error("could not get handle to METRefinedTauTool Quit") mlog.error(traceback.format_exc()) return False # add cellcalibtool theMETRefinedTauTool += cellcalibtool # add METRefinedTauTool to list of tools theMETRefAlg.AlgTools += [theMETRefinedTauTool.getFullName()] # add tools to alg theMETRefAlg += theMETRefinedTauTool #------------------------------------------------------------------------------------------------ # configure tools: METRefinedJetTool => calibrator Tool for ATLFASTII try: from MissingET.MissingETConf import METRefinedJetTool theMETRefinedJetTool = METRefinedJetTool("METRefJet" + self.suffix) if rec.readAOD(): theMETRefinedJetTool.JetInputCollectionKey = self.jet_JetInputCollectionKey theMETRefinedJetTool.VxContainerKey = self.jet_vxcontainerkey theMETRefinedJetTool.JVFTool = jvatool theMETRefinedJetTool.UseCustomVxContainer = self.jet_UseCustomVxContainer theMETRefinedJetTool.JetPtCut = self.jet_JetPtCut # cut on jet pt #theMETRefinedJetTool.JetMaxPtCut = self.jet_JetMaxPtCut # cut on jet pt theMETRefinedJetTool.CalibType = self.jet_calibType # H1 or LocHad theMETRefinedJetTool.ApplyJetScale = self.jet_ApplyJetScale theMETRefinedJetTool.UseJetMomentForScale = self.jet_UseJetMomentForScale theMETRefinedJetTool.JetMomentForScale = self.jet_JetMomentForScale theMETRefinedJetTool.ApplyJetJVF = self.jet_ApplyJetJVF theMETRefinedJetTool.UseJetMomentForScale = self.jet_UseJetMomentForScale theMETRefinedJetTool.MissingETOutKey = "MET_RefJet" + self.suffix theMETRefinedJetTool.RemoveResiduals = self.jet_RemoveResiduals theMETRefinedJetTool.MinimumMETContribution = self.jet_MinimumMETContribution else: theMETRefinedJetTool.JetInputCollectionKey = self.jet_JetInputCollectionKey theMETRefinedJetTool.VxContainerKey = self.jet_vxcontainerkey theMETRefinedJetTool.JVFTool = jvatool theMETRefinedJetTool.UseCustomVxContainer = self.jet_UseCustomVxContainer theMETRefinedJetTool.JetPtCut = self.jet_JetPtCut theMETRefinedJetTool.JetMaxPtCut = self.jet_JetMaxPtCut # cut on jet pt theMETRefinedJetTool.CalibType = self.jet_calibType # H1 or LocHad theMETRefinedJetTool.ApplyJetScale = self.jet_ApplyJetScale theMETRefinedJetTool.UseJetMomentForScale = self.jet_UseJetMomentForScale theMETRefinedJetTool.JetMomentForScale = self.jet_JetMomentForScale theMETRefinedJetTool.ApplyJetJVF = self.jet_ApplyJetJVF theMETRefinedJetTool.UseJetMomentForScale = self.jet_UseJetMomentForScale theMETRefinedJetTool.BackNavigationTo = "Topo" # to "Topo" or to "Cell" theMETRefinedJetTool.MissingETOutKey = "MET_RefJet" + self.suffix theMETRefinedJetTool.RemoveResiduals = True theMETRefinedJetTool.MinimumMETContribution = 0.5 # if doFastCaloSim set calibrator tool for ATLFAST2 from CaloRec.CaloCellFlags import jobproperties if jobproperties.CaloCellFlags.doFastCaloSim: doAtlfastII = True else: doAtlfastII = False cellcalibtool = getStandardCalibTool(doAtlfastII) calibtool_name = cellcalibtool.name() theMETRefinedJetTool.CalibToolName = 'H1WeightToolCSC12Generic/' + calibtool_name except: mlog.error("could not get handle to METRefinedJetTool Quit") mlog.error(traceback.format_exc()) return False # add cellcalibtool theMETRefinedJetTool += cellcalibtool # add METRefinedJetTool to list of tools theMETRefAlg.AlgTools += [theMETRefinedJetTool.getFullName()] # add tools to alg theMETRefAlg += theMETRefinedJetTool #------------------------------------------------------------------------------------------------ # configure tools: METSoftJetsTool if self.jet_RunSoftJetsTool: try: from MissingET.MissingETConf import METRefinedJetTool theMETSoftJetsTool = METRefinedJetTool("METSoftJets" + self.suffix) if rec.readAOD(): theMETSoftJetsTool.JetInputCollectionKey = self.jet_JetInputCollectionKey theMETSoftJetsTool.JVFTool = jvatool theMETSoftJetsTool.UseCustomVxContainer = False theMETSoftJetsTool.JetPtCut = self.jet_SoftJetsPtCut # cut on jet pt theMETSoftJetsTool.JetMaxPtCut = self.jet_SoftJetsMaxPtCut # cut on jet pt theMETSoftJetsTool.CalibType = self.jet_SoftJetsCalibType theMETSoftJetsTool.ApplyJetScale = self.jet_ApplySoftJetsScale theMETSoftJetsTool.UseJetMomentForScale = self.jet_UseJetMomentForScale theMETSoftJetsTool.JetMomentForScale = self.jet_JetMomentForScale theMETSoftJetsTool.MissingETOutKey = "MET_SoftJets" + self.suffix theMETSoftJetsTool.RemoveResiduals = self.jet_SoftJetsRemoveResiduals theMETSoftJetsTool.MinimumMETContribution = self.jet_SoftJetsMinimumMETContribution else: theMETSoftJetsTool.JetInputCollectionKey = self.jet_JetInputCollectionKey theMETSoftJetsTool.JVFTool = jvatool theMETSoftJetsTool.UseCustomVxContainer = False theMETSoftJetsTool.JetPtCut = self.jet_SoftJetsPtCut theMETSoftJetsTool.JetMaxPtCut = self.jet_SoftJetsMaxPtCut theMETSoftJetsTool.CalibType = self.jet_SoftJetsCalibType theMETSoftJetsTool.ApplyJetScale = self.jet_ApplySoftJetsScale theMETSoftJetsTool.UseJetMomentForScale = self.jet_UseJetMomentForScale theMETSoftJetsTool.JetMomentForScale = self.jet_JetMomentForScale theMETSoftJetsTool.BackNavigationTo = "Topo" # to "Topo" or to "Cell" theMETSoftJetsTool.MissingETOutKey = "MET_SoftJets" + self.suffix theMETSoftJetsTool.RemoveResiduals = True theMETSoftJetsTool.MinimumMETContribution = 0.5 # if doFastCaloSim set calibrator tool for ATLFAST2 from CaloRec.CaloCellFlags import jobproperties if jobproperties.CaloCellFlags.doFastCaloSim: doAtlfastII = True else: doAtlfastII = False cellcalibtool = getStandardCalibTool(doAtlfastII) calibtool_name = cellcalibtool.name() theMETSoftJetsTool.CalibToolName = 'H1WeightToolCSC12Generic/' + calibtool_name except: mlog.error("could not get handle to METSoftJetsTool Quit") mlog.error(traceback.format_exc()) return False # add cellcalibtool theMETSoftJetsTool += cellcalibtool # add METSoftJetsTool to list of tools theMETRefAlg.AlgTools += [theMETSoftJetsTool.getFullName()] # add tools to alg theMETRefAlg += theMETSoftJetsTool #------------------------------------------------------------------------------------------------ # configure tools: METRefinedMuonTool if not rec.readAOD(): try: from AthenaCommon.DetFlags import DetFlags if DetFlags.detdescr.Muon_on(): try: from MissingET.MissingETConf import METRefinedMuonTool theMETRefMuonTrackTool = METRefinedMuonTool( "METRefMuonTrack" + self.suffix, MuonContainer=self.muon_Container(), outKey="MET_RefMuon_Track_" + self.muon_algorithm + self.suffix, cut1Chi2OverDoF=-1000., # or 0. if Muid cut2Chi2OverDoF=1000., # or 10. if Muid CaloMuonCollection="CaloMuonCollection", MuTagCollection=self.muon_Container(), JetContainerName=self. jet_JetInputCollectionKey, #theMETRefinedJetTool.JetInputCollectionKey, Muon_Selected_Type="Isol", # Isol = use muon tracks Muon_Add_Crack="On", # add muon tracks from cracks IsolDefinition=self.muon_isolationAlg, fillComposition=False) theMETRefMuonSpectroTool = METRefinedMuonTool( "METRefMuonSpectro" + self.suffix, MuonContainer=self.muon_Container( ), # or "MuidMuonCollection" outKey="MET_RefMuon_" + self.muon_algorithm + self.suffix, cut1Chi2OverDoF=-1000., # or 0. if Muid cut2Chi2OverDoF=1000., # or 10. if Muid CaloMuonCollection="CaloMuonCollection", MuTagCollection=self.muon_Container(), JetContainerName=self. jet_JetInputCollectionKey, #theMETRefinedJetTool.JetInputCollectionKey, Muon_Selected_Type= "NonIsol", # NonIsol = use spectro muons IsolDefinition=self.muon_isolationAlg, Muon_Add_Crack="Off") # add theMETRefMuonTool to list of tools theMETRefAlg.AlgTools += [ theMETRefMuonTrackTool.getFullName() ] theMETRefAlg.AlgTools += [ theMETRefMuonSpectroTool.getFullName() ] # add tool to alg theMETRefAlg += theMETRefMuonTrackTool theMETRefAlg += theMETRefMuonSpectroTool except: mlog.error( "could not get handle to METRefinedMuonTool Quit") mlog.error(traceback.format_exc()) return False except: mlog.error("could not import DetFlags") #------------------------------------------------------------------------------------------------ # configure tools: METRefinedClusterTool => calibrator Tool for ATLFASTII try: from MissingET.MissingETConf import METRefinedClusterTool from MissingET.MissingETConf import METTrackSelectorTool from AthenaCommon.AppMgr import ToolSvc ToolSvc += METTrackSelectorTool("METTrackSelTool" + self.suffix) theMETRefinedClusterTool = METRefinedClusterTool("METRefCluster" + self.suffix) theMETRefinedClusterTool.ClusterInputCollectionKey = "CaloCalTopoCluster" theMETRefinedClusterTool.VxContainerKey = self.cellout_vxcontainerkey theMETRefinedClusterTool.CalibType = self.cellout_calibType # Eflow, Tracks theMETRefinedClusterTool.TrackType = self.cellout_trackType # STTrack, STTrackPV,STTrackCone theMETRefinedClusterTool.MissingETOutKey = "MET_CellOut" + self.suffix mytrackselector = METTrackSelectorTool("METTrackSelTool" + self.suffix) mytrackselector.JetContainerName = self.cellout_JetInputCollectionKey mytrackselector.MinPtTrack = self.cellout_pttrack theMETRefinedClusterTool.METTrackSelTool = mytrackselector # if doFastCaloSim set calibrator tool for ATLFAST2 from CaloRec.CaloCellFlags import jobproperties if jobproperties.CaloCellFlags.doFastCaloSim: doAtlfastII = True else: doAtlfastII = False cellcalibtool = getStandardCalibTool(doAtlfastII) calibtool_name = cellcalibtool.name() theMETRefinedClusterTool.CalibToolName = 'H1WeightToolCSC12Generic/' + calibtool_name except: mlog.error("could not get handle to METRefinedClusterTool Quit") mlog.error(traceback.format_exc()) return False # add cellcalibtool theMETRefinedClusterTool += cellcalibtool # add METRefinedClusterTool to list of tools theMETRefAlg.AlgTools += [theMETRefinedClusterTool.getFullName()] # add tools to alg theMETRefAlg += theMETRefinedClusterTool #-------------------------------------------------------------------------------- # configure tools: METRefinedClusterTool (2) => only for STVF pile-up suppression if self.plupSuppCorr == "STVF": try: from MissingET.MissingETConf import METRefinedClusterTool from MissingET.MissingETConf import METTrackSelectorTool from AthenaCommon.AppMgr import ToolSvc ToolSvc += METTrackSelectorTool("METTrackSelTool" + self.suffix) theMETRefinedClusterTrackTool = METRefinedClusterTool( "METRefClusterTrack" + self.suffix) theMETRefinedClusterTrackTool.ClusterInputCollectionKey = "CaloCalTopoCluster" theMETRefinedClusterTrackTool.VxContainerKey = self.cellout_vxcontainerkey theMETRefinedClusterTrackTool.CalibType = self.cellout_calibType2 # Eflow, Tracks theMETRefinedClusterTrackTool.TrackType = self.cellout_trackType2 # STTrack, STTrackPV,STTrackCone theMETRefinedClusterTrackTool.MissingETOutKey = "MET_CellOut_Track" + self.suffix mytrackselector = METTrackSelectorTool("METTrackSelTool" + self.suffix) mytrackselector.JetContainerName = self.cellout_JetInputCollectionKey mytrackselector.MinPtTrack = self.cellout_pttrack theMETRefinedClusterTrackTool.METTrackSelTool = mytrackselector except: mlog.error( "could not get handle to METRefinedClusterTool Quit") mlog.error(traceback.format_exc()) return False # add cellcalibtool theMETRefinedClusterTrackTool += cellcalibtool # add METRefinedClusterTool to list of tools theMETRefAlg.AlgTools += [ theMETRefinedClusterTrackTool.getFullName() ] # add tools to alg theMETRefAlg += theMETRefinedClusterTrackTool #-------------------------------------------------------------------------------- # configure tools: METRefinedClusterTool (3) => only for STVF pile-up suppression try: from MissingET.MissingETConf import METRefinedClusterTool from MissingET.MissingETConf import METTrackSelectorTool from AthenaCommon.AppMgr import ToolSvc ToolSvc += METTrackSelectorTool("METTrackSelTool" + self.suffix) theMETRefinedClusterTrackPVTool = METRefinedClusterTool( "METRefClusterTrackPV" + self.suffix) theMETRefinedClusterTrackPVTool.ClusterInputCollectionKey = "CaloCalTopoCluster" theMETRefinedClusterTrackPVTool.VxContainerKey = self.cellout_vxcontainerkey theMETRefinedClusterTrackPVTool.CalibType = self.cellout_calibType3 # Eflow, Tracks theMETRefinedClusterTrackPVTool.TrackType = self.cellout_trackType3 # STTrack, STTrackPV,STTrackCone theMETRefinedClusterTrackPVTool.MissingETOutKey = "MET_CellOut_TrackPV" + self.suffix mytrackselector = METTrackSelectorTool("METTrackSelTool" + self.suffix) mytrackselector.JetContainerName = self.cellout_JetInputCollectionKey mytrackselector.MinPtTrack = self.cellout_pttrack theMETRefinedClusterTrackPVTool.METTrackSelTool = mytrackselector except: mlog.error( "could not get handle to METRefinedClusterTool Quit") mlog.error(traceback.format_exc()) return False # add cellcalibtool theMETRefinedClusterTrackPVTool += cellcalibtool # add METRefinedClusterTool to list of tools theMETRefAlg.AlgTools += [ theMETRefinedClusterTrackPVTool.getFullName() ] # add tools to alg theMETRefAlg += theMETRefinedClusterTrackPVTool #------------------------------------------------------------------------------------------------ # configure tools: METMuonTool from AthenaCommon.DetFlags import DetFlags if DetFlags.detdescr.Muon_on(): try: from MissingET.MissingETConf import METMuonTool theMETMuonBoyTrackTool = METMuonTool( "MuonIsol" + self.suffix, MuonContainer=self.muon_Container(), outKey="MET_Muon_Isol_" + self.muon_algorithm + self.suffix, ApplyChi2OverDoFCut="Off", cut1Chi2OverDoF=0., cut2Chi2OverDoF=10., CaloMuonCollection="CaloMuonCollection", MuTagCollection=self.muon_Container(), JetContainerName=theMETRefinedJetTool. JetInputCollectionKey, Muon_Selected_Type="Isol", # Isol = use muon tracks Add_MuTag="On", # add muon tracks from cracks IsolDefinition=self.muon_isolationAlg, TrackMethod=self.muon_trackMethod()) theMETMuonBoySpectroTool = METMuonTool( "MuonNonIsol" + self.suffix, MuonContainer=self.muon_Container(), outKey="MET_Muon_NonIsol_" + self.muon_algorithm + self.suffix, ApplyChi2OverDoFCut="Off", cut1Chi2OverDoF=0., cut2Chi2OverDoF=10., CaloMuonCollection="CaloMuonCollection", MuTagCollection=self.muon_Container(), JetContainerName=theMETRefinedJetTool. JetInputCollectionKey, Muon_Selected_Type="NonIsol", # NonIsol = use spectro muons IsolDefinition=self.muon_isolationAlg, TrackMethod=self.muon_trackMethod()) theMETMuonTool = METMuonTool( "Muon" + self.suffix, MuonContainer=self.muon_Container(), outKey="MET_Muon_" + self.muon_algorithm + self.suffix, ApplyChi2OverDoFCut="Off", cut1Chi2OverDoF=0., cut2Chi2OverDoF=10., CaloMuonCollection="CaloMuonCollection", MuTagCollection=self.muon_Container(), JetContainerName=theMETRefinedJetTool. JetInputCollectionKey, Muon_Selected_Type="All", # All = use spectro muons IsolDefinition=self.muon_isolationAlg, TrackMethod=self.muon_trackMethod()) except: mlog.error("could not get handle to METMuonTool Quit") mlog.error(traceback.format_exc()) return False # add the METMuonTool to list of tools theMETRefAlg.AlgTools += [theMETMuonBoyTrackTool.getFullName()] theMETRefAlg.AlgTools += [theMETMuonBoySpectroTool.getFullName()] theMETRefAlgMu.AlgTools += [theMETMuonTool.getFullName()] # add tool to alg theMETRefAlg += theMETMuonBoyTrackTool theMETRefAlg += theMETMuonBoySpectroTool theMETRefAlgMu += theMETMuonTool #------------------------------------------------------------------------------------------------ mlog.info(" now adding to sequence") self.sequence += theMETRefAlg from AthenaCommon.DetFlags import DetFlags if DetFlags.detdescr.Muon_on(): self.sequence += theMETRefAlgMu # # # # # # # # # # try: from MissingET.MissingETConf import METAlg theMETAlg = METAlg("METAlg" + self.suffix) except: mlog.error("could not import MissingET.METAlg") mlog.error(traceback.format_exc()) return False #------------------------------------------------------------------------------------------------ try: from MissingET.MissingETConf import METCryoTool theMETCryoTopoTool = METCryoTool("CryoTopo" + self.suffix) theMETCryoTopoTool.JetCollectionName = theMETRefinedJetTool.JetInputCollectionKey # if doFastCaloSim set calibrator tool for ATLFAST2 from CaloRec.CaloCellFlags import jobproperties if jobproperties.CaloCellFlags.doFastCaloSim: doAtlfastII = True else: doAtlfastII = False cellcalibtool = getStandardCalibTool(doAtlfastII) calibtool_name = cellcalibtool.name() theMETCryoTopoTool.CalibToolName = 'H1WeightToolCSC12Generic/' + calibtool_name theMETCryoTopoTool.outKey = "MET_Cryo" + self.suffix # add cellcalibtool theMETCryoTopoTool += cellcalibtool # add theMETCryoTool to list of tools theMETAlg.AlgTools += [theMETCryoTopoTool.getFullName()] # add tool to alg theMETAlg += theMETCryoTopoTool except: mlog.error("could not get handle to METCryoTopoTool Quit") mlog.error(traceback.format_exc()) return False #------------------------------------------------------------------------------------------------ # configure tools: METFinal try: from MissingET.MissingETConf import METFinalTool theMETMuonFinal = METFinalTool( "MuFinal" + self.suffix, WhichCalc="MuonCalc", # calculate final muon term outKey="MET_Muon_Total_" + self.muon_algorithm + self.suffix, # output key muonBOYTrack="MET_Muon_Isol_" + self.muon_algorithm + self.suffix, # key for track muons muonBOYSpectro="MET_Muon_NonIsol_" + self.muon_algorithm + self.suffix, # key for spectro muons ) if self.jet_RunSoftJetsTool: theMETRefFinal = METFinalTool( "RefFinal" + self.suffix, WhichCalc="RefCalib", # Refined Calib applied plupSupp=self.plupSuppCorr, # Off, STVF EleRefKey="MET_RefEle" + self.suffix, # Specify key for Ref Ele GammaRefKey="MET_RefGamma" + self.suffix, # Specify key for Ref Gamma MuoRefKey="MET_RefMuon_" + self.muon_algorithm + self.suffix, # Specify key for Ref Muon TauRefKey="MET_RefTau" + self.suffix, # Specify key for Ref Tau JetRefKey="MET_RefJet" + self.suffix, # Specify key for Ref Jet SoftJetsKey="MET_SoftJets" + self.suffix, # Specify key for SoftJets CellOutKey="MET_CellOut" + self.suffix, # Specify key for Ref CellOut muonKey="MET_Muon_Total_" + self.muon_algorithm + self.suffix, # Key for Muon contrib cryoTerm=self. cryo_ApplyCorrection, # "On"/"Off"= cryostat corr On / Off cryoKey="MET_Cryo" + self.suffix, # Key for Cryo corr: MET_Cryo, MET_CryoCone outKey="MET_RefFinal" + self.suffix) if not self.jet_RunSoftJetsTool and self.plupSuppCorr != "STVF": theMETRefFinal = METFinalTool( "RefFinal" + self.suffix, WhichCalc="RefCalib", # Refined Calib applied plupSupp=self.plupSuppCorr, # Off, STVF EleRefKey="MET_RefEle" + self.suffix, # Specify key for Ref Ele GammaRefKey="MET_RefGamma" + self.suffix, # Specify key for Ref Gamma MuoRefKey="MET_RefMuon_" + self.muon_algorithm + self.suffix, # Specify key for Ref Muon TauRefKey="MET_RefTau" + self.suffix, # Specify key for Ref Tau JetRefKey="MET_RefJet" + self.suffix, # Specify key for Ref Jet CellOutKey="MET_CellOut" + self.suffix, # Specify key for Ref CellOut muonKey="MET_Muon_Total_" + self.muon_algorithm + self.suffix, # Key for Muon contrib cryoTerm=self. cryo_ApplyCorrection, # "On"/"Off"= cryostat corr On / Off cryoKey="MET_Cryo" + self.suffix, # Key for Cryo corr: MET_Cryo, MET_CryoCone outKey="MET_RefFinal" + self.suffix) if not self.jet_RunSoftJetsTool and self.plupSuppCorr == "STVF": theMETRefFinal = METFinalTool( "RefFinal" + self.suffix, WhichCalc="RefCalib", # Refined Calib applied plupSupp=self.plupSuppCorr, # Off, STVF EleRefKey="MET_RefEle" + self.suffix, # Specify key for Ref Ele GammaRefKey="MET_RefGamma" + self.suffix, # Specify key for Ref Gamma MuoRefKey="MET_RefMuon_" + self.muon_algorithm + self.suffix, # Specify key for Ref Muon TauRefKey="MET_RefTau" + self.suffix, # Specify key for Ref Tau JetRefKey="MET_RefJet", # Specify key for default Ref Jet SoftJetsKey= "MET_SoftJets", # Specify key for default SoftJets CellOutKey= "MET_CellOut_Eflow", # Specify key for default CellOutEflow JetRefCorrKey="MET_RefJet" + self.suffix, # Specify key for Ref Jet Corr CellOutEflowKey="MET_CellOut" + self.suffix, # Specify key for Ref CellOut celloutTrackKey="MET_CellOut_Track" + self.suffix, # Specify key for Ref CellOut celloutTrackPVKey="MET_CellOut_TrackPV" + self.suffix, # Specify key for Ref CellOut muonKey="MET_Muon_Total_" + self.muon_algorithm + self.suffix, # Key for Muon contrib cryoTerm=self. cryo_ApplyCorrection, # "On"/"Off"= cryostat corr On / Off cryoKey="MET_Cryo" + self.suffix, # Key for Cryo corr: MET_Cryo, MET_CryoCone outKey="MET_RefFinal" + self.suffix) if self.plupSuppCorr == "STVF": theMETCellOutSTVF = METFinalTool( "CellOutCorr" + self.suffix, WhichCalc="RefCalib", # Refined Calib applied plupSupp=self.plupSuppCorr, # Off, STVF cellOutCorr=self.celloutCorrection, EleRefKey="MET_RefEle" + self.suffix, # Specify key for Ref Ele GammaRefKey="MET_RefGamma" + self.suffix, # Specify key for Ref Gamma MuoRefKey="MET_RefMuon_" + self.muon_algorithm + self.suffix, # Specify key for Ref Muon TauRefKey="MET_RefTau" + self.suffix, # Specify key for Ref Tau JetRefKey="MET_RefJet", # Specify key for Ref Jet SoftJetsKey= "MET_SoftJets", # Specify key for default SoftJets CellOutKey= "MET_CellOut_Eflow", # Specify key for default CellOutEflow JetRefCorrKey="MET_RefJet" + self.suffix, # Specify key for Ref Jet CellOutEflowKey="MET_CellOut" + self.suffix, # Specify key for Ref CellOut celloutTrackKey="MET_CellOut_Track" + self.suffix, # Specify key for Ref CellOut celloutTrackPVKey="MET_CellOut_TrackPV" + self.suffix, # Specify key for Ref CellOut muonKey="MET_Muon_Total_" + self.muon_algorithm + self.suffix, # Key for Muon contrib cryoTerm=self. cryo_ApplyCorrection, # "On"/"Off"= cryostat corr On / Off cryoKey="MET_Cryo" + self.suffix, # Key for Cryo corr: MET_Cryo, MET_CryoCone outKey="MET_CellOutCorr" + self.suffix) except: mlog.error("could not get handle to METRefFinal Quit") mlog.error(traceback.format_exc()) return False # add METFinalTool to list of tools theMETAlg.AlgTools += [theMETMuonFinal.getFullName()] theMETAlg.AlgTools += [theMETRefFinal.getFullName()] if self.plupSuppCorr == "STVF": theMETAlg.AlgTools += [theMETCellOutSTVF.getFullName()] # add tools to alg theMETAlg += theMETMuonFinal theMETAlg += theMETRefFinal if self.plupSuppCorr == "STVF": theMETAlg += theMETCellOutSTVF #------------------------------------------------------------------------------------------------ # add algorithm to the specified Sequence (this should always come at the end) mlog.info(" now adding to sequence") self.sequence += theMETAlg return True