def getJobOptions(self): self.StreamToFileTool = PyAthena.py_tool('JiveXML::StreamToFileTool', iface='IProperty') self.StreamToServerTool = PyAthena.py_tool( 'JiveXML::StreamToServerTool', iface='IProperty') # Some casting magic is needed to access algorithm properties from GaudiPython.Bindings import gbl, InterfaceCast vp1alg = PyAthena.py_alg('VP1EventProd') self.VP1EventProducer = InterfaceCast(gbl.IProperty).cast(vp1alg) self.msg.info("StreamToFileTool: %s" % self.StreamToFileTool) self.msg.info("StreamToServerTool: %s" % self.StreamToServerTool) self.msg.info("VP1EventProducer: %s" % self.VP1EventProducer)
def initialize(self): self.msg.info('************************************') self.msg.info('==> initialize %s...', self.name()) self.msg.info('Will apply the following cuts:') self.msg.info(' trigger = %r', self.trigger) self.msg.info(' passAll = %r', self.passAll) self.msg.info('************************************') ## Import needed modules import PyUtils.RootUtils as ru ROOT = ru.import_root() ## Get the TrigDecisionTool tool self.tdt = PyAthena.py_tool('Trig::TrigDecisionTool/TrigDecisionTool', iface='Trig::TrigDecisionTool') if not self.tdt: self.msg.warning('Could not retrieve TrigDecisionTool pointer!') return StatusCode.Success # Set description variable in cut flow branch (default is trigger name, but can override in JO) self.setFilterDescription(self.trigger) ## Initialize event pass counters self.nProcessed = 0 self.nEventPassTrigger = 0 return StatusCode.Success
def initialize(self): self.msg.info('==> initialize...') self.trigDec = PyAthena.py_tool('Trig::TrigDecisionTool') if not self.trigDec: self.msg.error('could not retrieve TrigDecisionTool !') return StatusCode.Failure ## fix-up HLT::Chain def _str_hlt_chain(c): """helper function to make a HLT::Chain printable""" return "Counter = %r success (raw) = %r pass-through = %r "\ "prescaled = %r lastActiveStep = %r \tname = %r" % \ (c.getChainCounter(), bool(c.chainPassedRaw()), bool(c.isPassedThrough()), bool(c.isPrescaled()), c.getChainStep(), c.getChainName()) PyAthena.HLT.Chain.__str__ = _str_hlt_chain del _str_hlt_chain self.sg = PyAthena.py_svc('StoreGateSvc') if not self.sg: self.msg.error('could not retrieve event store !') return StatusCode.Failure self._passed_evts = open(self.filename, 'w') return StatusCode.Success
def initialize(self): self.msg.info('initializing [%s]...', self.name()) self.sg = PyAthena.py_svc('StoreGateSvc') self.hsvc = PyAthena.py_svc('THistSvc') self.trigDec = PyAthena.py_tool( 'Trig::TrigDecisionTool/TrigDecisionTool') # # TTree # self.DATA = {} self.BRANCHES = {} self.hsvc['/turnontree/dijets'] = TTree("dijets", "dijets") self.tree = self.hsvc['/turnontree/dijets'] # for i in ['event_number', 'run_number', 'lumi_block']: self.treewrap(i, 0) for i in [ '%s%d' % (i, j) for i in ['px', 'py', 'pz', 'e', 'rapidity', 'pt'] for j in [0, 1] ]: self.treewrap(i, 0.0) for i in ['roi_%s%d' % (i, j) for i in ['eta', 'phi'] for j in [0, 1]]: self.treewrap(i, 0.0) return StatusCode.Success
def init(self): if self.tool is not None: return ds = PyAthena.py_svc('DetectorStore') self.calocell_helper = ds['CaloCell_ID'] self.calosc_helper = ds['CaloCell_SuperCell_ID'] self.tool = PyAthena.py_tool('CaloSuperCellIDTool', iface='ICaloSuperCellIDTool') return
def initialize(self): sg = PyAthena.py_svc('StoreGateSvc') ds = PyAthena.py_svc('DetectorStore') self.idol_helper = ds['CaloCell_ID'] self.idsc_helper = ds['CaloCell_SuperCell_ID'] self.tool = PyAthena.py_tool('CaloSuperCellIDTool', iface='ICaloSuperCellIDTool') self.mgrol = ds['CaloMgr'] self.mgrsc = ds['CaloSuperCellMgr'] return 1
def initialize(self): self.msg.info("initializing [%s]", self.name()) self.vertexTool = PyAthena.py_tool( self.PhotonVertexSelectionTool.getFullName(), iface='CP::IPhotonVertexSelectionTool') if not self.vertexTool: self.msg.error( "Problem retrieving PhotonVertexSelectionTool !!") return PyAthena.StatusCode.Failure return StatusCode.Success
def initialize(self): self.msg.info("initializing [%s]", self.name()) self.storeGateSvc = PyAthena.py_svc('StoreGateSvc') if self.storeGateSvc is None: self.msg.error("Problem retrieving storegate !!") return PyAthena.StatusCode.Failure self.tool = PyAthena.py_tool('EGammaAmbiguityTool', iface='IEGammaAmbiguityTool') if not self.tool: self.msg.error("Problem retrieving EgammaAmbiguityTool !!") return PyAthena.StatusCode.Failure return StatusCode.Success
def initialize(self): # Check the validitly of self.cutDict if len(self.cutDict["pTCuts"])!=self.nObj: self.msg.fatal("Lengths of pTCuts and types are different!!") return StatusCode.Failure if len(self.cutDict["qualityCuts"])!=self.nObj: self.msg.fatal("Lengths of qualityCuts and types are different!!") return StatusCode.Failure if len(self.cutDict["collections"])!=self.nObj: self.msg.fatal("Lengths of collections and types are different!!") return StatusCode.Failure ## Get the StoreGate service self.storeGateSvc = PyAthena.py_svc('StoreGateSvc') if self.storeGateSvc is None: self.msg.fatal("Problem retrieving StoreGateSvc pointer !!") return StatusCode.Failure # AthElectronLikelihoodTool_VeryLoose self.electronLikelihoodTool_VeryLoose = PyAthena.py_tool('AthElectronLikelihoodTool/AthElectronLikelihoodTool_VeryLoose') if self.electronLikelihoodTool_VeryLoose is None: self.msg.error("Problem retrieving AthElectronLikelihoodTool/AthElectronLikelihoodTool_VeryLoose pointer !!") return StatusCode.Recoverable self.msg.info("AthElectronLikelihoodTool/AthElectronLikelihoodTool_VeryLoose retrieved.") # AthElectronLikelihoodTool_Loose self.electronLikelihoodTool_Loose = PyAthena.py_tool('AthElectronLikelihoodTool/AthElectronLikelihoodTool_Loose') if self.electronLikelihoodTool_Loose is None: self.msg.error("Problem retrieving AthElectronLikelihoodTool/AthElectronLikelihoodTool_Loose pointer !!") return StatusCode.Recoverable self.msg.info("AthElectronLikelihoodTool/AthElectronLikelihoodTool_Loose retrieved.") # AthElectronLikelihoodTool_Medium self.electronLikelihoodTool_Medium = PyAthena.py_tool('AthElectronLikelihoodTool/AthElectronLikelihoodTool_Medium') if self.electronLikelihoodTool_Medium is None: self.msg.error("Problem retrieving AthElectronLikelihoodTool/AthElectronLikelihoodTool_Medium pointer !!") return StatusCode.Recoverable self.msg.info("AthElectronLikelihoodTool/AthElectronLikelihoodTool_Medium retrieved.") return StatusCode.Success
def initialize(self): ## Get the StoreGate service self.storeGateSvc = PyAthena.py_svc('StoreGateSvc') if self.storeGateSvc is None: self.msg.error("Problem retrieving StoreGateSvc pointer !!") return StatusCode.Failure self.trackToVertexTool = PyAthena.py_tool('Reco::TrackToVertex', iface='Reco::ITrackToVertex') if self.trackToVertexTool is None: self.msg.error("Problem retrieving Reco::TrackToVertex pointer !!") return StatusCode.Failure if not os.path.exists("./ElectronLikelihoodPdfs.root"): os.system("get_files -data ElectronLikelihoodPdfs.root") self.electronLikelihoodTool = ElectronLikelihoodTool( "./ElectronLikelihoodPdfs.root") self.multiLeptonMenu = MultiLeptonMenu() return StatusCode.Success
def initialize(self): ## note that we are using the python logging service ## and that the PyAthena.Alg base class has already initialized ## it for us # ----------------------------------------------------------- # Store gate service self.msg.info('initializing [%s]...', self.name()) self.msg.debug('retrieve StoreGateSvc pointer...') self.sg = PyAthena.py_svc('StoreGateSvc') if self.sg is None: self.msg.error('Problem retrieving StoreGateSvc pointer !') return StatusCode.Failure else: self.msg.info('retrieved [%s]', self.sg.name()) # ----------------------------------------------------------- # Detector store service self.msg.debug('retrieve DetectorStoreSvc pointer...') self.det = PyAthena.py_svc('DetDescrCnvSvc') if self.det is None: self.msg.error('Problem retrieving DetectorStoreSvc pointer !') return StatusCode.Failure else: self.msg.info('retrieved [%s]', self.det.name()) # ----------------------------------------------------------- # Message service self.msg.info('initializing [%s]...', self.name()) self.msg.debug('retrieve MessageSvc pointer...') self.msgSvc = PyAthena.py_svc('MessageSvc') if self.msgSvc is None: self.msg.error('Problem retrieving MessageSvc pointer !') return StatusCode.Failure else: self.msg.info('retrieved [%s]', self.msgSvc.name()) # ----------------------------------------------------------- # get database service and open database self.msg.debug('retrieve database service...') self.dbSvc = cool.DatabaseSvcFactory.databaseService() # ----------------------------------------------------------- # Read local copy of condb => LarBadChannel folder # dbstring="sqlite://;schema=./myCondLArDB.db;dbname=CONDBR2" dbstring = "COOLONL_LAR/CONDBR2" try: self.db = self.dbSvc.openDatabase(dbstring, True) except Exception as e: print('Problem opening database', e) sys.exit(-1) print("Opened database", dbstring) # ----------------------------------------------------------- # Initialize onlineID from detector store self.msg.info('inlineID initialization...') from StoreGateBindings.Bindings import StoreGate detStore = StoreGate.pointer("DetectorStore") self.onlineID = detStore.retrieve("LArOnlineID", "LArOnlineID") # ----------------------------------------------------------- # Initialize LArCabling service self.larCablingSvc = PyAthena.py_tool("LArCablingService") if self.larCablingSvc is None: self.msg.error('Problem retrieving LArCablingService pointer !') return StatusCode.Failure else: self.msg.info('retrieved [%s]', self.larCablingSvc.name()) return StatusCode.Success
def initialize(self): print "==> initializing ", self.name print "MinDigitADC: ", self.MinDigitADC print "MaxDeltaT: ", self.MaxDeltaT print "NtupleFileName: ", self.NtupleFileName print "TriggerLines: ", self.TriggerLines # self.sg = PyAthena.py_svc("StoreGateSvc") self.det = PyAthena.StoreGate.pointer("DetectorStore") self.LArOID = self.det.retrieve("LArOnlineID", "LArOnlineID") self.lcs = PyAthena.py_tool('LArCablingService') self.cdd = PyAthena.CaloDetDescrManager.instance() self.cid = self.cdd.getCaloCell_ID() self.tdt = PyAthena.py_tool('Trig::TrigDecisionTool/TrigDecisionTool') self.ntfile = TFile(self.NtupleFileName, "RECREATE") self.hectree = TTree("HECNoise", "HECNoise") self.iRun = array('i', [0]) self.iEvent = array('L', [0]) self.iEventCount = array('i', [0]) self.fPrescale = {} self.iTrigger = {} for tl in self.TriggerLines: self.fPrescale[tl] = array('f', [0.0]) self.iTrigger[tl] = array('i', [0]) pass self.iTime = array('i', [0]) self.iLB = array('i', [0]) self.iBCID = array('i', [0]) self.avgMu = array('f', [0.0]) self.actMu = array('f', [0.0]) self.iGain = array('i', [0]) self.iOID = array('L', [0]) self.iSide = array('i', [0]) self.iSamp = array('i', [0]) self.iReg = array('i', [0]) self.iEta = array('i', [0]) self.iPhi = array('i', [0]) self.iQuality = array('i', [0]) self.e = array('f', [0.0]) self.t = array('f', [0.0]) self.eta = array('f', [0.0]) self.phi = array('f', [0.0]) self.z = array('f', [0.0]) self.r = array('f', [0.0]) self.Ped = array('f', [0.0]) self.PedRMS = array('f', [0.0]) self.iDigi = array('i', 32 * [0]) self.iMax = array('i', [0]) self.iMin = array('i', [0]) # self.hectree.Branch("iRun", self.iRun, "iRun/I") self.hectree.Branch("iEvent", self.iEvent, "iEvent/I") self.hectree.Branch("iEventCount", self.iEventCount, "iEventCount/I") for tl in self.TriggerLines: self.hectree.Branch(tl + "_Prescale", self.fPrescale[tl], tl + "_Prescale/F") self.hectree.Branch(tl + "_Trigger", self.iTrigger[tl], tl + "_Trigger/I") pass self.hectree.Branch("iTime", self.iTime, "iTime/I") self.hectree.Branch("iLB", self.iLB, "iLB/I") self.hectree.Branch("iBCID", self.iBCID, "iBCID/I") self.hectree.Branch("avgMu", self.avgMu, "avgMu/F") self.hectree.Branch("actMu", self.actMu, "actMu/F") self.hectree.Branch("iGain", self.iGain, "iGain/I") self.hectree.Branch("iOID", self.iOID, "iOID/l") self.hectree.Branch("iSide", self.iSide, "iSide/I") self.hectree.Branch("iSamp", self.iSamp, "iSamp/I") self.hectree.Branch("iReg", self.iReg, "iReg/I") self.hectree.Branch("iEta", self.iEta, "iEta/I") self.hectree.Branch("iPhi", self.iPhi, "iPhi/I") self.hectree.Branch("iQuality", self.iQuality, "iQuality/I") self.hectree.Branch("e", self.e, "e/F") self.hectree.Branch("t", self.t, "t/F") self.hectree.Branch("eta", self.eta, "eta/F") self.hectree.Branch("phi", self.phi, "phi/F") self.hectree.Branch("z", self.z, "z/F") self.hectree.Branch("r", self.r, "r/F") self.hectree.Branch("Ped", self.Ped, "Ped/F") self.hectree.Branch("PedRMS", self.PedRMS, "PedRMS/F") self.hectree.Branch("iDigi", self.iDigi, "iDigi[32]/I") self.hectree.Branch("iMax", self.iMax, "iMax/I") self.hectree.Branch("iMin", self.iMin, "iMin/I") # return True
def initialize(self): ## note that we are using the python logging service ## and that the PyAthena.Alg base class has already initialized ## it for us # Get DetectorStore... from StoreGateBindings.Bindings import StoreGate self._detStore = StoreGate.pointer("DetectorStore") if self._detStore is None: self.msg.error("Failed to get DetectorStore") return StatusCode.Failure # Get LArOnlineID helper class self.onlineID = self._detStore.retrieve("LArOnlineID", "LArOnlineID") if self.onlineID is None: self.msg.error("Failed to get LArOnlineID") return StatusCode.Failure # Get CaloCell_ID self.offlineID = self._detStore.retrieve("CaloCell_ID", "CaloCell_ID") if self.offlineID is None: self.msg.error("Failed to get CaloCell_ID") return StatusCode.Failure # ----------------------------------------------------------- # Initialize LArCabling service self.larCablingSvc = PyAthena.py_tool("LArCablingService") if self.larCablingSvc is None: self.msg.error('Problem retrieving LArCablingService pointer !') return StatusCode.Failure else: self.msg.info('retrieved [%s]', self.larCablingSvc.name()) self.badChannelTool = PyAthena.py_tool("LArBadChanTool", iface="ILArBadChanTool") if self.badChannelTool is None: self.msg.error('Problem retrieving LArBadChanTool pointer !') return StatusCode.Failure else: self.msg.info('retrieved [%s]', self.badChannelTool.name()) self.class_larBCBitPacking = cppyy.makeClass("LArBadChanBitPacking") self.bc_packing = self.class_larBCBitPacking() self.noisepattern = 0L for n in ("lowNoiseHG", "highNoiseHG", "unstableNoiseHG", "lowNoiseMG", "highNoiseMG", "unstableNoiseMG", "lowNoiseLG", "highNoiseLG", "unstableNoiseLG", "sporadicBurstNoise"): stat = self.bc_packing.enumName(n) if stat[0]: self.noisepattern |= 1 << stat[1] self.deadpattern = 0L for n in ("deadReadout", "deadPhys", "almostDead"): stat = self.bc_packing.enumName(n) if stat[0]: self.deadpattern |= 1 << stat[1] self.noid = Identifier() if self.includeLocation: try: self.caloDDM = CaloDetDescrManager.instance() except: print "Failed to retrieve CaloDDM" return StatusCode.Failure self.larPedestal = None self.larMphysOverMcal = None self.larRamp = None self.larDAC2uA = None self.laruA2MeV = None self.larhvScaleCorr = None self.larDSPThr = None return StatusCode.Success
#-------------------------------------------------------------- # initialize Athena, then go to first event #-------------------------------------------------------------- theApp.initialize() theApp.nextEvent() Identifier = PyLCGDict.makeClass('Identifier') HWIdentifier = PyLCGDict.makeClass('HWIdentifier') onlineID = PyKernel.retrieveDet(g.LArOnlineID, "LArOnlineID") # emID = PyKernel.retrieveDet(g.LArEM_ID,"LArEM_ID") # Create a dumper object with output level for printout import AthenaPython.PyAthena as PyAthena larCablingSvc = PyAthena.py_tool("LArCablingService") if doMC: ramps = PyKernel.retrieveDet(g.LArRampMC, "LArRamp") else: ramps = PyKernel.retrieveDet(g.LArRampComplete, "LArRamp") LArConditionsContainer("LArRampComplete") print " created ramps" uA2MeVs = PyKernel.retrieveDet(g.LAruA2MeVMC, "LAruA2MeV") print " created us2MeVs" DAC2uAs = PyKernel.retrieveDet(g.LArDAC2uAMC, "LArDAC2uA") print " created DAC2uAs" # adc2MeV = theApp.toolsvc().create("LArADC2MeVTool","LArADC2MeVTool",interface=g.ILArADC2MeVTool)
def initialize(self): import AthenaPython.PyAthena as PyAthena _info = self.msg.info _info("POOL2EI::initialize") _info("## DoProvenanceRef: {}".format(self.DoProvenanceRef)) _info("## DoTriggerInfo: {}".format(self.DoTriggerInfo)) _info("## HaveHlt: {}".format(self.HaveHlt)) _info("## HaveXHlt: {}".format(self.HaveXHlt)) _info("## RUN1: {}".format(self.RUN1)) _info("## SendToBroker: {}".format(self.SendToBroker)) self._dsname = "Unknown.Input.Dataset.Name" # default fake value if self.EiDsName is not None: _info("## EiDsName: {}".format(self.EiDsName)) self._dsname = self.EiDsName else: # try to get dataset name from pathena INDS environment variable import os inds = os.getenv('INDS') if inds is not None: _info("## INDS: {}".format(inds)) self._dsname = inds else: # else, try to use job definition try: import newJobDef processingType = newJobDef.job['processingType'] transformation = newJobDef.job['transformation'] dsSource = 'realDatasetsIn' # take dataset name from input if processingType == 'merge' and transformation != 'POOLtoEI_tf.py': dsSource = 'realDatasets' # take dataset name from output datasets = newJobDef.job[dsSource].split(',') _info("## {}[0]: {}".format(dsSource, datasets[0])) self._dsname = datasets[0] # remove _tid and _sub parts from dsname import re self._dsname = re.sub('_tid[0-9]{8}_[0-9]{2}', '', self._dsname) self._dsname = re.sub('_sub[0-9]{10}', '', self._dsname) self._dsname = re.sub('\\/$', '', self._dsname) except: _info( '## Unable to get dataset name from realDatasetsIn or realDatasets' ) # token match regex import re self._re_pool_token = re.compile(r'[[]DB=(?P<db>.*?)[]]' \ r'[[]CNT=(?P<cnt>.*?)[]]' \ r'[[]CLID=(?P<clid>.*?)[]]' \ r'[[]TECH=(?P<tech>.*?)[]]' \ r'[[]OID=(?P<oid>.*?)[]]').match # load our pythonizations: for cls_name in ('EventStreamInfo', 'EventType', 'PyEventType'): cls = getattr(PyAthena, cls_name) _info("retrieving various stores...") for store_name in ('evtStore', 'inputStore', 'detStore', 'tagStore', 'metaStore'): _info("retrieving [{}]...".format(store_name)) o = getattr(self, store_name) _info("retrieving [{}]... [done]".format(store_name)) _info("retrieving various stores... [done]") if self.HaveHlt: # load trigger decision tool from TriggerJobOpts.TriggerFlags import TriggerFlags TriggerFlags.configurationSourceList = ['ds'] import AthenaPython.PyAthena as PyAthena self.trigDec = PyAthena.py_tool( 'Trig::TrigDecisionTool/TrigDecisionTool') self.trigDec.ExperimentalAndExpertMethods().enable() if self.HaveXHlt: self.trigDec.setProperty("ConfigTool", "TrigConf::xAODConfigTool") self.trigDec.setProperty("TrigDecisionKey", "xTrigDecision") else: self.trigDec.setProperty("ConfigTool", "TrigConf::AODConfigTool") self.trigDec.setProperty("TrigDecisionKey", "TrigDecision") ## open output pkl file import os if self.Out is not None: oname = self.Out else: oname = "output.ei.pkl" oname = os.path.expanduser(os.path.expandvars(oname)) self._eifname = oname _info('Opening EI file [{}]...'.format(oname)) if os.path.exists(oname): os.remove(oname) import PyUtils.dbsqlite as dbsqlite try: self._eif = dbsqlite.open(oname, flags='w') except: pass if self._eif is None: self.msg.fatal( "Unable to open EI output file {} exapnded as {}".format( self.Out, oname)) raise RuntimeError("Unable to open EI output file") # get taskid and jobid if hasattr(self, 'TaskID') and hasattr( self, 'JobID' ) and self.TaskID is not None and self.JobID is not None: self._eif['TaskID'] = "{}.T".format(self.TaskID) if hasattr(self, 'AttemptNumber') and self.AttemptNumber is not None: self._eif['JobID'] = "{}.{}".format(self.JobID, self.AttemptNumber) else: self._eif['JobID'] = "{}.0".format(self.JobID) else: # get them from job info try: import newJobDef self._eif['TaskID'] = "{}.G".format(newJobDef.job['taskID']) self._eif['JobID'] = "{}.{}".format(newJobDef.job['PandaID'], newJobDef.job['attemptNr']) except: self._eif['TaskID'] = "{}.G".format( os.getenv('PanDA_TaskID', 0)) self._eif['JobID'] = "{}.0".format(os.getenv('PandaID', 0)) # initial information self._eif['StartProcTime'] = int(time.time() * 1000) self._eif['Schema'] = EIrecord().getRecSchema() self._eif['Version'] = EIrecord().getVersion() self._eif['InputDsName'] = self._dsname #processing options self._eif['ProvenanceRef'] = self.DoProvenanceRef self._eif['TriggerInfo'] = self.DoTriggerInfo return StatusCode.Success
def initialize(self): self.msg.info('==> initialize...') self.ctptool = PyAthena.py_tool(self.ctptool.getFullName(), iface="CopyTruthParticles") return StatusCode.Success