def getTauWPDecoratorJetRNN(): _name = sPrefix + 'TauWPDecoratorJetRNN' if _name in cached_instances: return cached_instances[_name] import PyUtils.RootUtils as ru ROOT = ru.import_root() import cppyy cppyy.loadDictionary('xAODTau_cDict') from AthenaCommon.AppMgr import ToolSvc from tauRecTools.tauRecToolsConf import TauWPDecorator TauWPDecorator = TauWPDecorator( name=_name, flatteningFile0Prong = "rnnid_flat_0p_v4.root", flatteningFile1Prong = "rnnid_flat_1p_v4.root", flatteningFile3Prong = "rnnid_flat_mp_v4.root", CutEnumVals = [ ROOT.xAOD.TauJetParameters.JetRNNSigVeryLoose, ROOT.xAOD.TauJetParameters.JetRNNSigLoose, ROOT.xAOD.TauJetParameters.JetRNNSigMedium, ROOT.xAOD.TauJetParameters.JetRNNSigTight ], SigEff0P = [0.98, 0.90, 0.65, 0.50], SigEff1P = [0.992, 0.99, 0.965, 0.94], SigEff3P = [0.99, 0.98, 0.865, 0.80], ScoreName = "RNNJetScore", NewScoreName = "RNNJetScoreSigTrans", DefineWPs = True, ) ToolSvc += TauWPDecorator cached_instances[_name] = TauWPDecorator return TauWPDecorator
def getTauWPDecoratorJetBDT(): import PyUtils.RootUtils as ru ROOT = ru.import_root() import cppyy cppyy.loadDictionary('xAODTau_cDict') _name = sPrefix + 'TauWPDecoratorJetBDT' from tauRecTools.tauRecToolsConf import TauWPDecorator myTauWPDecorator = TauWPDecorator( name=_name, flatteningFile1Prong="FlatJetBDT1Pv2.root", #update flatteningFile3Prong="FlatJetBDT3Pv2.root", #update CutEnumVals=[ ROOT.xAOD.TauJetParameters.JetBDTSigVeryLoose, ROOT.xAOD.TauJetParameters.JetBDTSigLoose, ROOT.xAOD.TauJetParameters.JetBDTSigMedium, ROOT.xAOD.TauJetParameters.JetBDTSigTight ], SigEff1P=[0.95, 0.85, 0.75, 0.60], SigEff3P=[0.95, 0.75, 0.60, 0.45], ScoreName="BDTJetScore", NewScoreName="BDTJetScoreSigTrans", DefineWPs=True, ) cached_instances[_name] = myTauWPDecorator return myTauWPDecorator
def getTauWPDecoratorEleBDT(): import PyUtils.RootUtils as ru ROOT = ru.import_root() import cppyy cppyy.loadDictionary('xAODTau_cDict') _name = sPrefix + 'TauWPDecoratorEleBDT' from tauRecTools.tauRecToolsConf import TauWPDecorator TauScoreFlatteningTool = TauWPDecorator( name=_name, flatteningFile1Prong="EleBDTFlat1P.root", #update flatteningFile3Prong= "EleBDTFlat3P.root", #update UseEleBDT=True, ScoreName="BDTEleScore", NewScoreName="BDTEleScoreSigTrans", #dynamic DefineWPs=True, CutEnumVals=[ ROOT.xAOD.TauJetParameters.EleBDTLoose, ROOT.xAOD.TauJetParameters.EleBDTMedium, ROOT.xAOD.TauJetParameters.EleBDTTight ], SigEff1P=[0.95, 0.85, 0.75], SigEff3P=[0.95, 0.85, 0.75], ) cached_instances[_name] = TauScoreFlatteningTool return TauScoreFlatteningTool
def MC12PlusTruthServiceCfg(ConfigFlags, name="ISF_MC12PlusTruthService", **kwargs): # importing Reflex dictionary to access AtlasDetDescr::AtlasRegion enum import ROOT, cppyy cppyy.loadDictionary("AtlasDetDescrDict") AtlasRegion = ROOT.AtlasDetDescr kwargs.setdefault("ForceEndVtxInRegions", [AtlasRegion.fAtlasID] ) return MC12TruthServiceCfg(ConfigFlags, name, **kwargs)
def getTauTrackRNNClassifier(): _name = sPrefix + 'TauTrackRNNClassifier' if _name in cached_instances: return cached_instances[_name] from AthenaCommon.AppMgr import ToolSvc from tauRecTools.tauRecToolsConf import tauRecTools__TauTrackRNNClassifier as TauTrackRNNClassifier from tauRecTools.tauRecToolsConf import tauRecTools__TrackRNN as TrackRNN import cppyy cppyy.loadDictionary('xAODTau_cDict') _RNN = TrackRNN( name=_name + "_0", InputWeightsPath=tauFlags.tauRecRNNTrackClassificationConfig()[0], calibFolder=tauFlags.tauRecToolsCVMFSPath(), ) ToolSvc += _RNN cached_instances[_RNN.name] = _RNN # create tool alg myTauTrackClassifier = TauTrackRNNClassifier(name=_name, Classifiers=[_RNN]) cached_instances[_name] = myTauTrackClassifier return myTauTrackClassifier
def have_cppyy(): import sys, platform try: import cppyy as Dict if platform.system() == 'Linux': Dict.loadDictionary('libOnlineKernelDict') else: Dict.loadDictionary('OnlineKernelDict.dll') CPP = Dict.makeNamespace('CPP') gbl = Dict.gbl std = gbl.std Interactor = CPP.PyInteractor Event = CPP.Event BaseSensor = CPP.Sensor IocSensor = CPP.IocSensor TimeSensor = CPP.TimeSensor Sensor = gbl.UpiSensor UpiSensor = gbl.UpiSensor return True except Exception, X: print 'OnlineKernel: Failed to use cppyy - you need to live without. [%s]' % ( str(X), ) return None
def getTauWPDecoratorJetBDT(): _name = sPrefix + 'TauWPDecoratorJetBDT' if _name in cached_instances: return cached_instances[_name] import PyUtils.RootUtils as ru ROOT = ru.import_root() import cppyy cppyy.loadDictionary('xAODTau_cDict') from AthenaCommon.AppMgr import ToolSvc from tauRecTools.tauRecToolsConf import TauWPDecorator TauWPDecorator = TauWPDecorator( name=_name, flatteningFile1Prong="FlatJetBDT1P_trigger_v1.root", flatteningFile3Prong="FlatJetBDT3P_trigger_v1.root", CutEnumVals=[ ROOT.xAOD.TauJetParameters.JetBDTSigVeryLoose, ROOT.xAOD.TauJetParameters.JetBDTSigLoose, ROOT.xAOD.TauJetParameters.JetBDTSigMedium, ROOT.xAOD.TauJetParameters.JetBDTSigTight ], SigEff1P=[0.995, 0.99, 0.97, 0.90], SigEff3P=[0.995, 0.94, 0.88, 0.78], ScoreName="BDTJetScore", NewScoreName="BDTJetScoreSigTrans", DefineWPs=True) ToolSvc += TauWPDecorator cached_instances[_name] = TauWPDecorator return TauWPDecorator
def getTauTrackClassifier(): _name = sPrefix + 'TauTrackClassifier' if _name in cached_instances: return cached_instances[_name] from AthenaCommon.AppMgr import ToolSvc from tauRecTools.tauRecToolsConf import tauRecTools__TauTrackClassifier as TauTrackClassifier from tauRecTools.tauRecToolsConf import tauRecTools__TrackMVABDT as TrackMVABDT import PyUtils.RootUtils as ru ROOT = ru.import_root() import cppyy cppyy.loadDictionary('xAODTau_cDict') input_file_name = 'EFtracks_BDT_classifier_v0.root' BDTcut = 0.45 deltaZ0 = 1.0 # ========================================================================= EFtrackBDT = TrackMVABDT( name=_name + "_MVABDT", InputWeightsPath=input_file_name, Threshold=BDTcut, DeltaZ0=deltaZ0, ExpectedFlag=ROOT.xAOD.TauJetParameters.unclassified, inTrigger=True) ToolSvc += EFtrackBDT trackclassifier = TauTrackClassifier(name=_name, Classifiers=[EFtrackBDT]) cached_instances[_name] = trackclassifier return trackclassifier
def getMC15aPlusTruthService(name="ISF_MC15aPlusTruthService", **kwargs): # importing Reflex dictionary to access AtlasDetDescr::AtlasRegion enum import ROOT, cppyy cppyy.loadDictionary('AtlasDetDescrDict') AtlasRegion = ROOT.AtlasDetDescr kwargs.setdefault('ForceEndVtxInRegions', [AtlasRegion.fAtlasID]) return getMC15TruthService(name, **kwargs)
def _installBindings(): """load the python bindings to FourMomUtils' function, at module import """ import ROOT import cppyy cppyy.loadDictionary('libFourMomUtilsDict') return
def getParticlePositionFilterID(name="ISF_ParticlePositionFilterID", **kwargs): # importing Reflex dictionary to access AtlasDetDescr::AtlasRegion enum import ROOT, cppyy cppyy.loadDictionary('AtlasDetDescrDict') AtlasRegion = ROOT.AtlasDetDescr kwargs.setdefault('CheckRegion', [AtlasRegion.fAtlasID]) return getParticlePositionFilter(name, **kwargs)
def _installBindings(): """load the python bindings to FourMomUtils' function, at module import """ import cppyy cppyy.loadDictionary('libFourMomUtilsDict') x = cppyy.gbl.xAOD.Helpers._importHelper() return
def ParticlePositionFilterIDCfg(ConfigFlags, name="ISF_ParticlePositionFilterID", **kwargs): # importing Reflex dictionary to access AtlasDetDescr::AtlasRegion enum import ROOT, cppyy cppyy.loadDictionary("AtlasDetDescrDict") AtlasRegion = ROOT.AtlasDetDescr kwargs.setdefault("CheckRegion", [AtlasRegion.fAtlasID]) return ParticlePositionFilterCfg(ConfigFlags, name, **kwargs)
def ParticlePositionFilterMSCfg(name="ISF_ParticlePositionFilterMS", **kwargs): # importing Reflex dictionary to access AtlasDetDescr::AtlasRegion enum import ROOT, cppyy cppyy.loadDictionary("AtlasDetDescrDict") AtlasRegion = ROOT.AtlasDetDescr kwargs.setdefault("CheckRegion", [ AtlasRegion.fAtlasID, AtlasRegion.fAtlasForward, AtlasRegion.fAtlasCalo, AtlasRegion.fAtlasMS ]) return ParticlePositionFilterCfg(name, **kwargs)
def initialize (self): import ROOT import cppyy cppyy.loadDictionary("libDataModelTestDataCommonDict") cppyy.loadDictionary("libDataModelTestDataReadDict") ROOT.DMTest.B ROOT.gROOT.GetClass('DMTest::HAuxContainer_v1') ROOT.gROOT.GetClass('DataVector<DMTest::H_v1>') ROOT.gROOT.GetClass('DMTest::HView_v1') ROOT.DMTest.setConverterLibrary ('libDataModelTestDataReadCnvPoolCnv.so') ROOT.DMTest.setTrigConverterLibrary ('libDataModelTestDataReadSerCnv.so') return StatusCode.Success
def BDTtoolset(self): if TriggerFlags.run2Config == '2016': from TauDiscriminant.TauDiscriminantConf import TauJetBDT bdt_set = TauJetBDT(inTrigger=True, calibFolder='TrigTauRec/00-11-01/', jetBDT="bdt.2016.bin", jetSigBits="trigger.sig.bits.jet.BDT.txt") return [bdt_set] else: from tauRecTools.tauRecToolsConf import TauJetBDTEvaluator # BDT evaluators 1p / mp bdt_1p = TauJetBDTEvaluator( name="TrigTauJetBDT1P", calibFolder='tauRecTools/00-02-00/', weightsFile='vars2016_pt_gamma_1p_isofix.root', inTrigger=True, minNTracks=0, maxNTracks=1) bdt_mp = TauJetBDTEvaluator( name="TrigTauJetBDTMP", calibFolder='tauRecTools/00-02-00/', weightsFile='vars2016_pt_gamma_3p_isofix.root', inTrigger=True, minNTracks=2, maxNTracks=1000) import PyUtils.RootUtils as ru ROOT = ru.import_root() import cppyy cppyy.loadDictionary('xAODTau_cDict') from tauRecTools.tauRecToolsConf import TauWPDecorator # wp creators 1p / mp wp_decorator = TauWPDecorator( name="TrigTauJetWPDecorator", calibFolder='TrigTauRec/00-11-01/', inTrigger=True, flatteningFile1Prong="FlatJetBDT1P_trigger_v1.root", flatteningFile3Prong="FlatJetBDT3P_trigger_v1.root", CutEnumVals=[ ROOT.xAOD.TauJetParameters.JetBDTSigVeryLoose, ROOT.xAOD.TauJetParameters.JetBDTSigLoose, ROOT.xAOD.TauJetParameters.JetBDTSigMedium, ROOT.xAOD.TauJetParameters.JetBDTSigTight ], SigEff1P=[0.995, 0.99, 0.97, 0.90], SigEff3P=[0.995, 0.94, 0.88, 0.78], ScoreName="BDTJetScore", NewScoreName="BDTJetScoreSigTrans", DefineWPs=True) return [bdt_1p, bdt_mp, wp_decorator]
def getMC15TruthService(name="ISF_MC15TruthService", **kwargs): # importing Reflex dictionary to access AtlasDetDescr::AtlasRegion enum import ROOT, cppyy cppyy.loadDictionary('AtlasDetDescrDict') AtlasRegion = ROOT.AtlasDetDescr kwargs.setdefault('TruthStrategies', ['ISF_MCTruthStrategyGroupID_MC15', 'ISF_MCTruthStrategyGroupIDHadInt_MC15', 'ISF_MCTruthStrategyGroupCaloMuBrem', #FIXME this should be ISF_MCTruthStrategyGroupCaloMuBrem_MC15!! 'ISF_MCTruthStrategyGroupCaloDecay_MC15']) kwargs.setdefault('IgnoreUndefinedBarcodes', False) kwargs.setdefault('PassWholeVertices', False) # new for MC15 - can write out partial vertices. kwargs.setdefault('ForceEndVtxInRegions', [AtlasRegion.fAtlasID]) return getGenericTruthService(name, **kwargs)
def getMC15TruthService(name="ISF_MC15TruthService", **kwargs): # importing Reflex dictionary to access AtlasDetDescr::AtlasRegion enum import ROOT, cppyy cppyy.loadDictionary('AtlasDetDescrDict') AtlasRegion = ROOT.AtlasDetDescr beam_pipe_strategies = getMC15BeamPipeTruthStrategies() id_strategies = getMC15IDTruthStrategies() calo_strategies = getMC15CaloTruthStrategies() ms_strategies = getMC15MSTruthStrategies() kwargs.setdefault( 'BeamPipeTruthStrategies', beam_pipe_strategies ) # this is used for beam pipe but not BeamPipeCentral which uses same as ID kwargs.setdefault('IDTruthStrategies', id_strategies) kwargs.setdefault('CaloTruthStrategies', calo_strategies) kwargs.setdefault('MSTruthStrategies', ms_strategies) kwargs.setdefault('IgnoreUndefinedBarcodes', False) kwargs.setdefault('PassWholeVertices', False) # new for MC15 - can write out partial vertices. kwargs.setdefault('ForceEndVtxInRegions', [AtlasRegion.fAtlasID]) return getGenericTruthService(name, **kwargs)
def MC15TruthServiceCfg(ConfigFlags, name="ISF_MC15TruthService", **kwargs): result = ComponentAccumulator() # importing Reflex dictionary to access AtlasDetDescr::AtlasRegion enum import ROOT, cppyy cppyy.loadDictionary("AtlasDetDescrDict") AtlasRegion = ROOT.AtlasDetDescr if "TruthStrategies" not in kwargs: truthCfgs = [ TruthStrategyGroupID_MC15Cfg, TruthStrategyGroupIDHadInt_MC15Cfg, TruthStrategyGroupCaloMuBrem_MC15Cfg, TruthStrategyGroupCaloDecay_MC15Cfg, ] truthStrats = [result.popToolsAndMerge(cfg(ConfigFlags)) for cfg in truthCfgs] kwargs.setdefault("TruthStrategies", truthStrats) kwargs.setdefault("IgnoreUndefinedBarcodes", False) kwargs.setdefault("PassWholeVertices", False) # new for MC15 - can write out partial vertices. kwargs.setdefault("ForceEndVtxInRegions", [AtlasRegion.fAtlasID]) truthService = GenericTruthServiceCfg(ConfigFlags, name, **kwargs) result.addService(truthService.getPrimary(), primary=True) result.merge(truthService) return result
def initialize(self): import ROOT import cppyy cppyy.loadDictionary("libDataModelTestDataCommonDict") cppyy.loadDictionary("libDataModelTestDataWriteDict") cppyy.loadDictionary("libDataModelTestDataWriteCnvDict") ROOT.DMTest.B ROOT.DMTest.setConverterLibrary( 'libDataModelTestDataWriteCnvPoolCnv.so') ROOT.DMTest.setTrigConverterLibrary( 'libDataModelTestDataWriteSerCnv.so') return StatusCode.Success
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration __doc__ = "Configure the electron and photon selectors." from AthenaCommon.Logging import logging from AthenaConfiguration.ComponentFactory import CompFactory from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator EMPIDBuilder = CompFactory.EMPIDBuilder from ROOT import egammaPID import cppyy cppyy.loadDictionary('ElectronPhotonSelectorToolsDict') def EMPIDBuilderElectronCfg(flags, name='EMPIDBuilderElectron', **kwargs): mlog = logging.getLogger(name) mlog.debug('Start configuration') acc = ComponentAccumulator() # Electron Selectors # Cut based from ROOT import LikeEnum from ElectronPhotonSelectorTools.AsgElectronIsEMSelectorsConfig import AsgElectronIsEMSelectorCfg if "electronIsEMselectors" not in kwargs: LooseElectronSelectorAcc = AsgElectronIsEMSelectorCfg( flags, "LooseElectronSelector", egammaPID.ElectronIDLoosePP) MediumElectronSelectorAcc = AsgElectronIsEMSelectorCfg( flags, "MediumElectronSelector", egammaPID.ElectronIDMediumPP) TightElectronSelectorAcc = AsgElectronIsEMSelectorCfg( flags, "TightElectronSelector", egammaPID.ElectronIDTightPP)
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration ######################################################################## # # # ConstModUtils: A module for configuring constituent modifiers # # Author: TJ Khoo # # # ######################################################################## import cppyy try: cppyy.loadDictionary('xAODBaseObjectTypeDict') except Exception: pass from ROOT import xAODType xAODType.ObjectType from AthenaCommon import Logging constmodlog = Logging.logging.getLogger('ConstModHelpers') from AthenaConfiguration.ComponentFactory import CompFactory # Tool types and configs can be expanded if the user # wishes to add their own custom definitions # Maybe we need a config class in JetDefinition? ConstModTools = { # Topoclusters "Origin": CompFactory.CaloClusterConstituentsOrigin, "EM": CompFactory.ClusterAtEMScaleTool, # Particle flow "CorrectPFO": CompFactory.CorrectPFOTool,
##============================================================================= ## Name: ElectronIsEMSelectorMapping.py ## ## Author: Tulay Cuhadar Donszelmann, Jovan Mitrevski ## Created: Dec 2011 ## ## Description: Find mapping of mask and function for ID quality ##============================================================================= import cppyy try : cppyy.loadDictionary('ElectronPhotonSelectorToolsDict') except : pass from ROOT import egammaPID class electronPIDmenu: menu2011 = 0 menu2012 = 1 origMenu2012 = 2 menuH4l2011 = 3 menuTrig2012 = 4 menuTrigDC14 = 5 menuDC14 = 6 import ElectronPhotonSelectorTools.ElectronIsEMSelectorCutDefs as ElectronIsEMSelectorCutDefs import ElectronPhotonSelectorTools.ElectronIsEMLooseSelectorCutDefs as ElectronIsEMLooseSelectorCutDefs import ElectronPhotonSelectorTools.ElectronIsEMMediumSelectorCutDefs as ElectronIsEMMediumSelectorCutDefs import ElectronPhotonSelectorTools.ElectronIsEMTightSelectorCutDefs as ElectronIsEMTightSelectorCutDefs import ElectronPhotonSelectorTools.ElectronIsEMH4l2011SelectorCutDefs as ElectronIsEMH4l2011SelectorCutDefs
DMTest__xAODTestWriteCInfo, \ DMTest__xAODTestWriteCVecConst, \ DMTest__xAODTestWrite topSequence += DMTest__xAODTestWriteCVec("xAODTestWriteCVec") topSequence += DMTest__xAODTestWriteHVec("xAODTestWriteHVec") topSequence += DMTest__xAODTestWriteCView("xAODTestWriteCView") topSequence += DMTest__xAODTestWriteCInfo("xAODTestWriteCInfo") topSequence += DMTest__xAODTestWrite("xAODTestWrite") topSequence += DMTest__xAODTestWriteCVecConst("xAODTestWriteCVecConst") #-------------------------------------------------------------- # Output options #-------------------------------------------------------------- import ROOT import cppyy cppyy.loadDictionary("libDataModelTestDataCommonDict") cppyy.loadDictionary("libDataModelTestDataWriteDict") ROOT.DMTest.B ROOT.DMTest.setConverterLibrary('libDataModelTestDataWriteCnvPoolCnv.so') theApp.CreateSvc += ['xAODMaker::EventFormatSvc'] # ItemList: include("EventAthenaPool/EventAthenaPoolItemList_joboptions.py") fullItemList += ["DMTest::CVec#cvec"] fullItemList += ["DMTest::CAuxContainer#cvecAux."] fullItemList += ["DMTest::CVecWithData#cvecWD"] fullItemList += ["DMTest::CView#cview"] fullItemList += ["DMTest::CAuxContainer#cvecWDAux."] fullItemList += ["DMTest::GVec#gvec"] fullItemList += ["DMTest::GAuxContainer#gvecAux."]
def declareDefaultTools(): from JetRecConfig.JetRecFlags import jetFlags from JetRecConfig.JetRecStandardToolManager import jtm try: from JetMomentTools.JetMomentToolsConf import JetCaloCellQualityTool jtm.haveJetCaloCellQualityTool = True except ImportError: jtm.haveJetCaloCellQualityTool = False try: from JetMomentTools.JetMomentToolsConf import JetJetBadChanCorrTool jtm.haveJetBadChanCorrTool = True except ImportError: jtm.haveJetBadChanCorrTool = False from JetRecTools.JetRecToolsConf import TrackVertexAssociationTool from JetRec.JetRecConf import PseudoJetGetter from JetRecTools.JetRecToolsConf import TrackPseudoJetGetter from InDetTrackSelectionTool.InDetTrackSelectionToolConf import InDet__InDetTrackSelectionTool from JetRecTools.JetRecToolsConf import JetTrackSelectionTool from JetRecTools.JetRecToolsConf import SimpleJetTrackSelectionTool #-------------------------------------------------------------- # Non-substructure moment builders. #-------------------------------------------------------------- # Quality from clusters. jtm += JetCaloQualityTool( "caloqual_cluster", TimingCuts = [5, 10], Calculations = ["LArQuality", "N90Constituents", "FracSamplingMax", "NegativeE", "Timing", "HECQuality", "Centroid", "AverageLArQF", "BchCorrCell"], ) # Quality from cells. if jtm.haveJetCaloCellQualityTool: jtm += JetCaloCellQualityTool( "caloqual_cell", LArQualityCut = 4000, TileQualityCut = 254, TimingCuts = [5, 10], Calculations = ["LArQuality", "N90Cells", "FracSamplingMax", "NegativeE", "Timing", "HECQuality", "Centroid", "AverageLArQF"] ) # Jet width. jtm += JetWidthTool("width", WeightPFOToolEM=jtm.pflowweighter, WeightPFOToolLC=jtm.pflowweighterLC) # Calo layer energies. jtm += JetCaloEnergies("jetens") # Read in missing cell map (needed for the following) # commented out : incompatible with trigger : ATR-9696 ## if jtm.haveJetRecCalo: ## def missingCellFileReader(): ## import os ## dataPathList = os.environ[ 'DATAPATH' ].split(os.pathsep) ## dataPathList.insert(0, os.curdir) ## from AthenaCommon.Utils.unixtools import FindFile ## RefFileName = FindFile( "JetBadChanCorrTool.root" ,dataPathList, os.R_OK ) ## from AthenaCommon.AppMgr import ServiceMgr ## if not hasattr(ServiceMgr, 'THistSvc'): ## from GaudiSvc.GaudiSvcConf import THistSvc ## ServiceMgr += THistSvc() ## ServiceMgr.THistSvc.Input += ["JetBadChanCorrTool DATAFILE=\'%s\' OPT=\'READ\'" % RefFileName] ## missingCellFileReader.called = True ## missingCellFileReader() ## jtm += MissingCellListTool( ## "missingcells", ## AddCellList = [], ## RemoveCellList = [], ## AddBadCells = True, ## DeltaRmax = 1.0, ## AddCellFromTool = False, ## LArMaskBit = 608517, ## TileMaskBit = 1, ## MissingCellMapName = "MissingCaloCellsMap" ## ) ## # Bad channel corrections from cells ## if jtm.haveJetBadChanCorrTool: ## jtm += JetBadChanCorrTool( ## "bchcorrcell", ## NBadCellLimit = 10000, ## StreamName = "/JetBadChanCorrTool/", ## ProfileName = "JetBadChanCorrTool.root", ## ProfileTag = "", ## UseCone = True, ## UseCalibScale = False, ## MissingCellMap = "MissingCaloCellsMap", ## ForceMissingCellCheck = False, ## UseClusters = False, ## ) ## # Bad channel corrections from clusters ## jtm += JetBadChanCorrTool( ## "bchcorrclus", ## NBadCellLimit = 0, ## StreamName = "", ## ProfileName = "", ## ProfileTag = "", ## UseCone = True, ## UseCalibScale = False, ## MissingCellMap = "", ## ForceMissingCellCheck = False, ## UseClusters = True ## ) # Bad LAr fractions. jtm += JetECPSFractionTool( "ecpsfrac", ) #-------------------------------------------------------------- # Track-vertex association. #-------------------------------------------------------------- from TrackVertexAssociationTool.TrackVertexAssociationToolConf import CP__TightTrackVertexAssociationTool jtm += CP__TightTrackVertexAssociationTool("jetTighTVAtool", dzSinTheta_cut=3, doPV=True) jtm += TrackVertexAssociationTool( "tvassoc", TrackParticleContainer = jtm.trackContainer, TrackVertexAssociation = "JetTrackVtxAssoc", VertexContainer = jtm.vertexContainer, TrackVertexAssoTool = jtm.jetTighTVAtool, ) jtm += TrackVertexAssociationTool( "tvassoc_old", TrackParticleContainer = jtm.trackContainer, TrackVertexAssociation = "JetTrackVtxAssoc_old", VertexContainer = jtm.vertexContainer, MaxTransverseDistance = 1.5, MaxLongitudinalDistance = 1.0e7, MaxZ0SinTheta = 1.5 ) #-------------------------------------------------------------- # Track selection. #-------------------------------------------------------------- # This is the InDet loose selection from # https://twiki.cern.ch/twiki/bin/view/AtlasProtected/InDetTrackingPerformanceGuidelines # October 28, 2014 #jtm += InDet__InDetDetailedTrackSelectionTool( jtm += InDet__InDetTrackSelectionTool( "trk_trackselloose", CutLevel = "Loose" ) jtm += JetTrackSelectionTool( "trackselloose", InputContainer = jtm.trackContainer, OutputContainer = "JetSelectedTracks", Selector = jtm.trk_trackselloose ) jtm += InDet__InDetTrackSelectionTool( "trk_trackselloose_trackjets", CutLevel = "Loose" ) jtm += JetTrackSelectionTool( "trackselloose_trackjets", InputContainer = jtm.trackContainer, OutputContainer = "JetSelectedTracks_LooseTrackJets", Selector = jtm.trk_trackselloose_trackjets ) if jetFlags.useInDetTrackSelection(): jtm += JetTrackSelectionTool( "tracksel", InputContainer = jtm.trackContainer, OutputContainer = "JetSelectedTracks", Selector = jtm.trk_trackselloose ) else: jtm += SimpleJetTrackSelectionTool( "tracksel", PtMin = 500.0, InputContainer = jtm.trackContainer, OutputContainer = "JetSelectedTracks", ) # Tracks. jtm += TrackPseudoJetGetter( "trackget", InputContainer = jtm.trackselloose_trackjets.OutputContainer, Label = "Track", OutputContainer = "PseudoJetTracks", TrackVertexAssociation = jtm.tvassoc.TrackVertexAssociation, SkipNegativeEnergy = True, GhostScale = 0.0 ) # Ghost tracks. jtm += TrackPseudoJetGetter( "gtrackget", InputContainer = jtm.tracksel.OutputContainer, Label = "GhostTrack", OutputContainer = "PseudoJetGhostTracks", TrackVertexAssociation = jtm.tvassoc.TrackVertexAssociation, SkipNegativeEnergy = True, GhostScale = 1e-20 ) # Jet vertex fraction. jtm += JetVertexFractionTool( "jvfold", VertexContainer = jtm.vertexContainer, AssociatedTracks = "GhostTrack", TrackVertexAssociation = jtm.tvassoc.TrackVertexAssociation, JVFName = "JVFOld" ) # Jet vertex fraction with selection. jtm += JetVertexFractionTool( "jvf", VertexContainer = jtm.vertexContainer, AssociatedTracks = "GhostTrack", TrackVertexAssociation = jtm.tvassoc.TrackVertexAssociation, TrackSelector = jtm.trackselloose, JVFName = "JVF" ) # Jet vertex tagger. jtm += JetVertexTaggerTool( "jvt", VertexContainer = jtm.vertexContainer, TrackParticleContainer = jtm.trackContainer, AssociatedTracks = "GhostTrack", TrackVertexAssociation = jtm.tvassoc.TrackVertexAssociation, TrackSelector = jtm.trackselloose, JVTName = "Jvt", K_JVFCorrScale = 0.01, Z0Cut = 3.0, PUTrkPtCut = 30000.0 ) # Jet track info. jtm += JetTrackMomentsTool( "trkmoms", VertexContainer = jtm.vertexContainer, AssociatedTracks = "GhostTrack", TrackVertexAssociation = jtm.tvassoc.TrackVertexAssociation, TrackMinPtCuts = [500, 1000], TrackSelector = jtm.trackselloose ) # Jet track vector sum info jtm += JetTrackSumMomentsTool( "trksummoms", VertexContainer = jtm.vertexContainer, AssociatedTracks = "GhostTrack", TrackVertexAssociation = jtm.tvassoc.TrackVertexAssociation, RequireTrackPV = True, TrackSelector = jtm.trackselloose ) # Jet cluster info. jtm += JetClusterMomentsTool( "clsmoms", DoClsPt = True, DoClsSecondLambda = True, DoClsCenterLambda = True, DoClsSecondR = True ) jtm += JetVoronoiMomentsTool( "voromoms", AreaXmin= -5., AreaXmax= 5., AreaYmin= -3.141592, AreaYmax= 3.141592 ) # Isolations. # Note absence of PseudoJetGetter property means the jet inputs # are obtained according to the InputType property of the jet. jtm += JetIsolationTool( "jetisol", IsolationCalculations = ["IsoDelta:2:SumPt", "IsoDelta:3:SumPt"], ) jtm += JetIsolationTool( "run1jetisol", IsolationCalculations = ["IsoKR:11:Perp", "IsoKR:11:Par", "IsoFixedCone:6:SumPt",], ) # Bad LAr fractions. jtm += JetLArHVTool("larhvcorr") # Jet origin correction. jtm += JetOriginCorrectionTool( "jetorigincorr", VertexContainer = jtm.vertexContainer, OriginCorrectedName = "JetOriginConstitScaleMomentum" ) # Just set the PV without applying origin correction jtm += JetOriginCorrectionTool( "jetorigin_setpv", VertexContainer = jtm.vertexContainer, OriginCorrectedName = "", OnlyAssignPV = True, ) # Load the xAODCaloEvent dictionary for cluster scale enum import cppyy try: cppyy.loadDictionary('xAODCaloEventDict') except: pass from ROOT import xAOD # Touch an unrelated class so the dictionary is loaded # and therefore the CaloCluster version typedef is recognised xAOD.CaloVertexedTopoCluster
from RootUtils import PyROOTFixes import ROOT import glob import sys import os from PyUtils.Helpers import ROOT6Setup ROOT6Setup() # Turn off annoying dict auto-generation --- it doesn't work anyway. ROOT.gInterpreter.ProcessLine(".autodict") # Make sure the proper dictionaries are loaded. cppyy.loadDictionary('libAtlasSTLAddReflexDict') # Make sure abstract base classes have streaminfos built. # Otherwise, we can get crashes from TTree::Scan. # Prevent AthenaBarCodeImpl from trying to create JobIDSvc. import os import uuid os.environ['_ATHENABARCODEIMPL_JOBUUID'] = uuid.uuid1().hex # Bump up resource limits as much as possible. from AthenaCommon.ResourceLimits import SetMaxLimits SetMaxLimits() del SetMaxLimits
def _load_dict(lib): """Helper function to remember which libraries have been already loaded """ import cppyy return cppyy.loadDictionary(lib)
def _setup(): import cppyy # StoreGate bindings from dictionary cppyy.loadDictionary( "libAthenaPythonDict" ) # for clidsvc cppyy.loadDictionary( "libStoreGateBindingsDict" ) # for storegatesvc cppyy.loadDictionary( "libStoreGateBindings" ) # not linked from libStoreGateBindingsDict in ROOT6 # make sure the global C++ namespace has been created gbl = cppyy.makeNamespace('') _ath= cppyy.makeNamespace('AthenaInternal') # ROOT6 workaround, kick the loading of headers _ath.ROOT6_AthenaPython_WorkAround_Dummy _ath.ROOT6_StoreGateBindings_WorkAround_Dummy # end workaround global py_retrieve py_retrieve = cppyy.gbl.AthenaInternal.retrieveObjectFromStore global py_record py_record = cppyy.gbl.AthenaInternal.recordObjectToStore global py_sg_contains py_sg_contains = cppyy.gbl.AthenaInternal.py_sg_contains global py_sg_getitem py_sg_getitem = cppyy.gbl.AthenaInternal.py_sg_getitem # retrieve the StoreGateSvc class global StoreGate, StoreGateSvc StoreGateSvc = cppyy.gbl.StoreGateSvc StoreGate = cppyy.gbl.StoreGate # add specialized retrieve method def retrieve( self, klass, key = None ): ret = py_retrieve( self, klass, key ) if ret and hasattr(ret,'setStore') and not ret.hasStore(): if not hasattr(ret,'trackIndices') or ret.trackIndices(): if py_sg_contains (self, 'SG::IConstAuxStore', key + 'Aux.'): aux = py_retrieve (self, 'SG::IConstAuxStore', key + 'Aux.') ret.setStore (aux) return ret StoreGateSvc.retrieve = retrieve # add specialized record method def record( self, obj, key, allowMods=True, resetOnly=True, noHist=False ): return py_record( self, obj, key, allowMods, resetOnly, noHist ) StoreGateSvc.record = record # add specialized contains method def contains( self, klass_or_clid, key ): print "---- StoreGateSvc.contains() ", klass_or_clid, key if isinstance(klass_or_clid, str): try: clid = int(klass_or_clid) klass = self._pyclidsvc.typename(clid) except ValueError: klass = str(klass_or_clid) pass elif isinstance(klass_or_clid, (int, long)): klass = self._pyclidsvc.typename(klass_or_clid) elif isinstance(klass_or_clid, type): klass = klass_or_clid.__name__ else: raise TypeError( 'argument 2 must be a typename, a clid or a type (got %r)' % type(klass_or_clid)) return py_sg_contains( self, klass, key ) StoreGateSvc.contains = contains # dict-pythonization of storegate: __setitem__ def __setitem__ (self, key, obj): return py_record( self, obj, key, True, True, False ) StoreGateSvc.__setitem__ = __setitem__ # dict-pythonization of storegate: __getitem__ def __getitem__ (self, key): try: ret = py_sg_getitem(self, key) except LookupError,err: raise KeyError(str(err)) if ret and hasattr(ret,'setStore') and not ret.hasStore(): if not hasattr(ret,'trackIndices') or ret.trackIndices(): if py_sg_contains (self, 'SG::IConstAuxStore', key + 'Aux.'): aux = py_retrieve (self, 'SG::IConstAuxStore', key + 'Aux.') ret.setStore (aux) return ret
print " iovUntil ", iovUntil #=== values for the comment channel author = "gunal" comment = "Updated noise values" #================================================== #=== #=== Code starts below here #=== #================================================== #=== set shortcut #g = PyCintex.gbl #PyCintex.makeClass('std::vector<float>') #PyCintex.loadDict("STLAddRflx") cppyy.loadDictionary("STLAddRflx") #=== get a logger log = CaloCondLogger.getLogger("CaloNoiseWriter") #=== (re-)create the database #db = CaloCondTools.openDb('SQLITE', 'CONDBR2', 'UPDATE') dbSvc = cool.DatabaseSvcFactory.databaseService() try: db=dbSvc.openDatabase("sqlite://;schema="+filename+";dbname="+dbname, False) except: db=dbSvc.createDatabase("sqlite://;schema="+filename+";dbname="+dbname) try: #=== creating folder specifications spec = cool.RecordSpecification()
class ConstituentToolManager(object): """This class is modelled after JetToolManager. It is intended to be a central place where to * register constituent modifier tools * map them to shortcut * collect them in a mod sequencer tool This class is provided standalone, but could be merged with JetToolManager if needed. and example call could be : clustModSeq = ctm.buildConstitModifSequence( 'JetWeightedTopoClusters', inputName= 'CaloCalTopoClusters', modList = [ 'clust_weight'] ) """ # map of tool names or alias to tool instance # (there can be multiple entries pointing to the same instance) modifiersMap = dict() # map of named standard list of modifiers standardModifierLists = dict() import cppyy try: cppyy.loadDictionary('xAODBaseObjectTypeDict') except: pass from ROOT import xAODType xAODType.ObjectType # map of known input collections to their type inputContainerMap = dict(CaloCalTopoClusters=xAODType.CaloCluster, CaloTopoClusters=xAODType.CaloCluster, EMOriginTopoClusters=xAODType.CaloCluster, LCOriginTopoClusters=xAODType.CaloCluster, InDetTrackParticles=xAODType.TrackParticle, JetETMiss=xAODType.ParticleFlow) log = Logging.logging.getLogger("ConstituentToolManager") def add(self, tool, alias=None): """Register a tool in the manager. If alias is given, the tool is also registered under the alias key""" name = tool.name() if name in self.modifiersMap: self.log.warning("Tool named " + name + " already registered. Not adding a new one") return self.modifiersMap[name] if alias is not None and alias in self.modifiersMap: self.log.warning( "Tool named " + alias + " already registered. Not adding a new one under this alias. Was " + name) return self.modifiersMap[alias] from AthenaCommon.AppMgr import ToolSvc self.modifiersMap[name] = tool if alias: self.modifiersMap[alias] = tool return tool def __iadd__(self, tool): """Enables the += syntax to add tool """ self.add(tool) return self def buildConstitModifSequence(self, seqName, OutputContainer, InputContainer, modList, InputType=None): """Returns a configured JetConstituentModSequence instance. The tool is build according to seqName (str) : name of the JetConstituentModSequence tool OutputContainer (str) : name of desired output constituents container (property of JetConstituentModSequence) InputContainer (str) : name of input constituents container (property of JetConstituentModSequence) modList (str or list): if str, this is taken as a shortcut to a knonw, default list of modifier tools (from self.standardModifierLists) if list, entries are eihter configured modifier tools either strings in which case they are shortcut to known modifier tool (in self.modifiersMap). InputType : (int or None) the type of particles in the input container. If None attempt is made to guess it from InputContainer (from self.inputContainerMap). """ #seqName = OutputContainer+'_modSeq' # Deal with input ----------------- if InputType is None: # get it from the known inputs InputType = self.inputContainerMap[InputContainer] if InputType is None: self.log.error(seqName + '. Unknown input container : ' + InputContainer) return # deal with modifiers --------------- if isinstance(modList, str): modKey = modList # translate into a known list : modList = self.standardModifierLists.get(modKey, None) if modList is None: self.log.error( seqName + ". Unknown shortcut for constit modifier list : " + modKey) return None # loop over modList finalList = [] for t in modList: if isinstance(t, str): # translate into a real tool tool = self.modifiersMap.get(t, None) if tool is None: self.log.error( seqName + ". Unknown shortcut for constit modifier list : " + t) return None t = tool t.InputType = InputType # append to the final list finalList.append(t) constModSeq = CfgMgr.JetConstituentModSequence( seqName, # the name of the tool InputContainer=InputContainer, OutputContainer=OutputContainer, InputType=InputType, Modifiers=finalList, # pass the list of modifier we want ) self += constModSeq return constModSeq
from IsolationTool.IsolationToolConf import xAOD__CaloIsolationTool, xAOD__TrackIsolationTool CaloIsolationTool = ToolFactory(xAOD__CaloIsolationTool, name="CaloIsolationTool", CaloFillRectangularClusterTool=None, ClustersInConeTool=CaloClustersInConeTool, PFlowObjectsInConeTool=None, IsoLeakCorrectionTool=leakTool, saveOnlyRequestedCorrections=False, EMCaloNums=[], HadCaloNums=[], UseEMScale=True, addCaloExtensionDecoration=False) import ROOT, cppyy # Need to be sure base dict is loaded first. cppyy.loadDictionary('xAODCoreRflxDict') cppyy.loadDictionary('xAODPrimitivesDict') isoPar = ROOT.xAOD.Iso # The types to be computed # For this fix, we recompute topoetconeXX for El, Ph, Fwd... IsoTypesEG = [[isoPar.topoetcone20, isoPar.topoetcone30, isoPar.topoetcone40]] # ...but the corrections are different for El/Ph vs Fwd IsoCorEG = [[isoPar.core57cells, isoPar.ptCorrection, isoPar.pileupCorrection]] IsoCorFe = [[isoPar.coreCone, isoPar.pileupCorrection]] from IsolationAlgs.IsolationAlgsConf import IsolationBuilder isoAODFixBuilderElectron = AlgFactory( IsolationBuilder,
from PyKernel import PyKernel from PyKernel.PyKernel import plot,plot2,fill,fill2,dumpSG,book,bookProf from PyKernel.PyKernel import plotProf,fillProf,unregister,dumpHist,retrieveHist import cppyy cppyy.loadDictionary("libPyKernelDict") # Bind the C++ global namespace to the Python variable g g = cppyy.gbl ## temporary hack to 'fix' #58078 if 0: # set ROOT stream import re import ROOT rootStream=None from AthenaCommon.AppMgr import ServiceMgr as svcMgr EventSelector = svcMgr.EventSelector if hasattr(EventSelector,"CollectionType") and EventSelector.CollectionType == "ExplicitROOT": filename = EventSelector.InputCollections[0] if not re.search('\.root$',filename): filename = filename+'.root' file = ROOT.TFile(filename) rootStream=ROOT.gROOT.FindObject('CollectionTree') # this must be the last one PyKernel.init(theApp,rootStream) pass # temporary hack
###################################################################### # # Test for AlgTool # ###################################################################### # load dict for MyCutClass import cppyy cppyy.loadDictionary("PyAnalysisExamplesDict") ## get a handle to the default top-level algorithm sequence from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() # add my Algorithm from PyAnalysisExamples.PyAnalysisExamplesConf import AthPyEx__MySelectionAlg topSequence += AthPyEx__MySelectionAlg("MySelectionAlg") # add my Tool from PyAnalysisExamples.PyAnalysisExamplesConf import AthPyEx__MyTool from AthenaCommon.AppMgr import ToolSvc ToolSvc += AthPyEx__MyTool("MyTool") # init application mgr theApp.initialize() # retrieve AlgTool tool = theApp.toolsvc().retrieve(ToolSvc.MyTool.getFullJobOptName())._itool tool.setPython(tool) # set proxy
# This is needed to initialize the TrackIsolationTool properly. # Without this, there will be ERRORs! #include( "TrackIsolationTools/TrackIsolationTool_jobOptions.py" ) #---- Muon Isolation # This is needed to initialize the MuonIsolationTool properly. # Without this, there will be ERRORs! #include( "MuonIsolationTools/MuonIsolationTool_jobOptions.py" ) #---- Load the egammaPID and egammaParameters information # This is needed to always be up-to-date with the egamma # IsEM selections and also the author selections import PyUtils.RootUtils as ru ROOT = ru.import_root() import cppyy cppyy.loadDictionary('egammaEnumsDict') from ROOT import egammaPID from ROOT import egammaParameters #---- Load the TauJetParameters # This is needed to always be up-to-date with the tau # ID selections and also the author selections # This only works starting with tauEvent-00-05-21!!! #cppyy.loadDictionary('tauEventEnumsDict') #from ROOT import TauJetParameters # ==================================================================== # Test AODSelect # ==================================================================== #from AODSelect.AODSelectFlags import AODSelectFlags #AODSelectFlags.doAll = True