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):
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
