python.FilePeekerLib.FilePeeker Class Reference

Inheritance diagram for python.FilePeekerLib.FilePeeker:

Collaboration diagram for python.FilePeekerLib.FilePeeker:

Public Member Functions
def	__init__ (self, name='FilePeeker', **kw)
def	initialize (self)
def	start (self)
def	stop (self)
def	evtStore (self)
def	metaStore (self)
def	tagStore (self)
def	inputStore (self)
def	execute (self)
def	process_metadata (self, store, metadata_name)
def	finalize (self)
def	print_summary (self, data=None)
virtual StatusCode	initialize () override
virtual StatusCode	reinitialize () override
virtual StatusCode	start () override
virtual StatusCode	execute () override
virtual StatusCode	stop () override
virtual StatusCode	finalize () override
virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...
virtual const char *	typeName () const override
	return the std::type_info name of the underlying py-component This is used by concrete implementations to connect a python component to its C++ counter-part More...
virtual PyObject *	self () override
	return associated python object. More...
	DeclareInterfaceID (IPyComponent, 1, 0)
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Public Attributes
	infname
	init base class More...
	outfname
	peeked_data

Protected Member Functions
virtual bool	setPyAttr (PyObject *pyobj) override
	attach the C++ component to its python cousin More...
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Protected Attributes
PyObject *	m_self
	Pointer to self (from the python world) More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
def	_do_peeking (self, peek_evt_data=False)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
	_old_file_flag
	input-store self.inputStore.dump() More...
	_begin_run_flag
	_peeked_events
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

utility algorithm to inspect a file's content

Definition at line 66 of file FilePeekerLib.py.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

__init__()

def python.FilePeekerLib.FilePeeker.__init__	(		self,
			name = 'FilePeeker',
		**	kw
	)

Definition at line 69 of file FilePeekerLib.py.

    def __init__(self, name='FilePeeker', **kw):
        
        super(FilePeeker, self).__init__(name, **kw)
        self.infname = kw.get('infname', 'not-there.pool')
        self.outfname= kw.get('outfname', None)
 
        # flag to enable the bwd compat fallback mechanism...
        self._old_file_flag = False
        
        # flag to enable event less files without beginRun...
        self._begin_run_flag = False
 
        # all data, collected over the events analyzed
        self._peeked_events = []
        

Member Function Documentation

_do_peeking()

def python.FilePeekerLib.FilePeeker._do_peeking (   self,   peek_evt_data = False  )

private

the real function doing all the work of peeking at the input file
@return a dict of peeked-at data

Definition at line 314 of file FilePeekerLib.py.

    def _do_peeking(self, peek_evt_data=False):
        """ the real function doing all the work of peeking at the input file
        @return a dict of peeked-at data
        """
        peeked_data = {}
        import AthenaPython.PyAthena as PyAthena
        _info = self.msg.info
        _error= self.msg.error
        
        def _get_detdescr_tags(evt_type):
            ddt = evt_type.get_detdescr_tags().split()
            # det_descr_tags is of the form:
            # [ 'key1', 'val1', 'key2', 'val2', ... ]
            ddt = dict(zip(ddt[0::2],  # select 'key?'
                           ddt[1::2])) # select 'val?'
            return ddt
        
        
        store = self.inputStore
        esi_keys = store.keys('EventStreamInfo')
        nentries = None
        ddt = None
        if len(esi_keys) >= 1:
            sg_key = esi_keys[-1]
            nentries = 0
            stream_names = esi_keys[:]
            for sg_key in esi_keys:
                esi = store.retrieve('EventStreamInfo', sg_key)
                _info('=== [EventStreamInfo#%s] ===', sg_key)
                nentries += esi.getNumberOfEvents()
 
            evt_types = PyAthena.EventStreamInfo.evt_types(esi)
            if len(evt_types) > 0:
                evt_type = evt_types[0]
                peeked_data['evt_type'] = evt_type.bit_mask
                ddt = _get_detdescr_tags(evt_type)
                peeked_data['det_descr_tags'] = ddt
                from past.builtins import long
                peeked_data['mc_channel_number'] = [long(evt_type.mc_channel_number())]
                
            def _make_item_list(item):
                sgkey= item[1]
                clid = item[0]
                _typename = store._pyclidsvc.typename
                return (_typename(clid) or str(clid), # str or keep the int?
                        sgkey)
            item_list = esi.item_list()
            item_list = list(map(_make_item_list, item_list))
            peeked_data['eventdata_items'] = item_list
            # print ("======",len(item_list))
            peeked_data['lumi_block'] = esi.lumi_blocks()
            peeked_data['run_number'] = esi.run_numbers()
            #peeked_data['evt_number'] = esi.event_number()
            peeked_data['stream_names'] = esi.processing_tags()
            # handle event-less files
            if not peeked_data['stream_names']:
                stream_names = [sg_versioned_key(s).key for s in stream_names]
                peeked_data['stream_names'] = list(set(stream_names))
                pass
            # more event-less files handling - POOL-from-BS-event-less files
            # see bug#98568
            if len(esi.run_numbers()) == 0:
                bsmd_keys = store.keys("ByteStreamMetadataContainer")
                if len(bsmd_keys) == 1:
                    bsmd = store[bsmd_keys[0]][0]
                    peeked_data['lumi_block'] = [bsmd.getLumiBlock()]
                    peeked_data['run_number'] = [bsmd.getRunNumber()]
                    bs_metadata = {}
                    for md in bsmd.getFreeMetaDataStrings():
                        if md.startswith('Event type:'):
                            k = 'evt_type'
                            v = []
                            if 'is sim' in md:   v.append('IS_SIMULATION')
                            else:                v.append('IS_DATA')
                            if 'is atlas' in md: v.append('IS_ATLAS')
                            else:                v.append('IS_TESTBEAM')
                            if 'is physics' in md: v.append('IS_PHYSICS')
                            else:                  v.append('IS_CALIBRATION')
                            bs_metadata[k] = tuple(v)
                        elif md.startswith('GeoAtlas:'):
                            k = 'geometry'
                            v = md.split('GeoAtlas:')[1].strip()
                            bs_metadata[k] = v
                        elif md.startswith('IOVDbGlobalTag:'):
                            k = 'conditions_tag'
                            v = md.split('IOVDbGlobalTag:')[1].strip()
                            bs_metadata[k] = v
                        elif '=' in md:
                            k,v = md.split('=')
                            bs_metadata[k] = v
                        pass
                    peeked_data['evt_type']  = bs_metadata.get('evt_type', [])
                    peeked_data['geometry']  = bs_metadata.get('geometry', None)
                    peeked_data['conditions_tag'] = bs_metadata.get('conditions_tag', None)
                    peeked_data['bs_metadata'] = bs_metadata
                    pass
                pass
            
        # hack to retrieve the number of events if no EventStreamInfo
        # was present in the input file
        if nentries is None:
            ROOT = _import_ROOT()
            root_files = list(ROOT.gROOT.GetListOfFiles())
            root_files = [root_file for root_file in root_files
                          if root_file.GetName().count(self.infname)]
            if len(root_files)==1:
                root_file = root_files[0]
                data_hdr = root_file.Get("POOLContainer")
                if not data_hdr:
                    data_hdr = root_file.Get("POOLContainer_DataHeader")                
                nentries = data_hdr.GetEntriesFast() if bool(data_hdr) \
                           else None
            else:
                _info('could not find correct ROOT file (looking for [%s])',
                      self.infname)
                nentries = None
            del root_files
            del data_hdr
        peeked_data['nentries'] = nentries
 
        # retrieve the GUID
        def _get_guid():
            guid = None
            ROOT = _import_ROOT()
            root_files = list(ROOT.gROOT.GetListOfFiles())
            root_files = [root_file for root_file in root_files
                          if root_file.GetName().count(self.infname)]
            if len(root_files)==0:
                _info('could not find correct ROOT file (looking for [%s])',
                      self.infname)
                return
            
            root_file = root_files[0]
            pool = root_file.Get("##Params")
            import re
            # Pool parameters are of the form:
            # '[NAME=somevalue][VALUE=thevalue]'
            pool_token = re.compile(r'[\[]NAME=(?P<name>.*?)[\]]'
                                    r'[\[]VALUE=(?P<value>.*?)[\]]').match
            params = []
            for i in range(pool.GetEntries()):
                if pool.GetEntry(i)>0:
                    match = pool_token(pool.db_string)
                    if not match:
                        continue
                    d = match.groupdict()
                    params.append((d['name'], d['value']))
                    if d['name'].lower() == 'fid':
                        guid = d['value']
            return guid
        guid = _get_guid()
        if guid:
            peeked_data['file_guid'] = guid
        
        
        metadata_items = [(self.inputStore._pyclidsvc.typename(p.clID()),
                           p.name())
                          for p in self.inputStore.proxies()]
        peeked_data['metadata_items'] = metadata_items
        metadata = {}
        def maybe_get(o, idx, default=None):
            try:
                return o[idx]
            except IndexError:
                return default
        def maybe_float(o):
            try:
                return float(o)
            except ValueError:
                return o
 
        def mergeMultipleDict(inDicts):
            outDict={}
            for d in inDicts:
                for k,o in six.iteritems(d):
                    if k not in outDict:
                        outDict[k]=o
            if len(outDict)==0:
                return None
            else:
                return outDict
                          
 
            
        for k in self.inputStore.keys('IOVMetaDataContainer'):
            v = self.process_metadata(self.inputStore, k)
            metadata[k] = maybe_get(v, -1)
        peeked_data['metadata'] = metadata
 
        
        taginfo = {}
        if self.metaStore.contains('IOVMetaDataContainer','/TagInfo'):
            v = self.process_metadata(self.metaStore, '/TagInfo')
            taginfo = mergeMultipleDict(v)
        else:
            if '/TagInfo' in metadata:
                taginfo = metadata['/TagInfo'].copy()
            else:
                self._old_file_flag = True
                # no tag info whatsoever...
                # try detdescr_tags ?
        if ddt:
            peeked_data['det_descr_tags'] = ddt
            peeked_data['geometry'] = ddt.get('GeoAtlas', None)
            peeked_data['conditions_tag'] = ddt.get('IOVDbGlobalTag', None)
        peeked_data['tag_info'] = taginfo
        if taginfo:
            peeked_data['det_descr_tags'] = taginfo
            peeked_data['geometry'] = taginfo.get('GeoAtlas', None)
            peeked_data['conditions_tag'] = taginfo.get('IOVDbGlobalTag', None)
            peeked_data['beam_type'] = [taginfo.get('beam_type','N/A')]
            peeked_data['beam_energy']= [maybe_float(taginfo.get('beam_energy',
                                                                 'N/A'))]
 
        if 'geometry' not in peeked_data:
            peeked_data['geometry'] = None
        if 'conditions_tag' not in peeked_data:
            peeked_data['conditions_tag'] = None
        if 'det_descr_tags' not in peeked_data:
            peeked_data['det_descr_tags'] = {}
            
        # eventless simulated DAOD files
        if not self._begin_run_flag:
            if taginfo and taginfo.get('project_name',None) == 'IS_SIMULATION':
                peeked_data['evt_type'] = ('IS_SIMULATION', 'IS_ATLAS', 'IS_PHYSICS')
            if '/Simulation/Parameters' in metadata:
                peeked_data['run_number'] = [metadata.get('/Simulation/Parameters').get('RunNumber',None)]
        
        if peek_evt_data is False:
            return peeked_data
        
 
        
        # access directly the EventInfo
        store = self.evtStore
        evt_info_keys = store.keys('EventInfo')
        if len(evt_info_keys) != 1:
            _info('more than one EventInfo: %s', evt_info_keys)
            _info(' ==> we\'ll use [%s]', evt_info_keys[0])
        sg_key = evt_info_keys[0]
        ei = store.retrieve('EventInfo', sg_key)
        _info('=== [EventInfo#%s] ===', sg_key)
        eid = ei.event_ID()
 
        dh_keys = [k for k in store.keys('DataHeader')
                   # remove DH-keys for backnavigation
                   if not k.startswith('[DB=')]
        if len(dh_keys) != 1:
            _error('more than 1 DataHeader key after filtering: %s', dh_keys)
            _error('content of store: %s', store.keys('DataHeader'))
            raise RuntimeError('more than one DataHeader key')
 
        sg_key = dh_keys[0]
        _info('=== [DataHeader#%s] ===', sg_key)
        dh = store.retrieve('DataHeader', sg_key)
 
        def _make_item_list(dhe):
            sgkey= dhe.getKey()
            clid = dhe.getPrimaryClassID()
            _typename = store._pyclidsvc.typename
            return (_typename(clid) or str(clid), # str or keep the int?
                    sgkey)
        dhes = []
        if hasattr(dh, 'at'):
            # HACK for bug #77976
            for ii in range(len(dh)):
                dhes.append(dh.at(ii))
            pass
        else:
            dhes = list(dh.elements())
        #item_list = map(_make_item_list, dh)
        item_list = []
        for i,dhe in enumerate(dhes):
            sgkey = dhe.getKey()
            clid =  dhe.getPrimaryClassID()
            _typename = store._pyclidsvc.typename
            try:
                clid_name = _typename(clid)
                if clid_name:
                    clid = clid_name
            except Exception as err:
                self.msg.info("no typename for clid [%s] (%s)", clid, err)
            item_list.append((str(clid), sgkey))
 
        # -- event-type
        evt_type = ei.event_type()
        det_descr_tags = _get_detdescr_tags(evt_type)
 
        peeked_data.update({
            'run_number':      [eid.run_number()],
            'evt_number':      [eid.event_number()],
            'run_type':        ['N/A'],
            'evt_type':        evt_type.bit_mask,
            'det_descr_tags':  det_descr_tags,
            'geometry':        det_descr_tags.get('GeoAtlas', None),
            'conditions_tag':  det_descr_tags.get('IOVDbGlobalTag', None),
            'lumi_block':      [eid.lumi_block()],
            'stream_names':    [dh.getProcessTag()],
            'eventdata_items': item_list,
            'beam_type':       [det_descr_tags.get('beam_type','N/A')],
            'beam_energy':     [maybe_float(det_descr_tags.get('beam_energy',
                                                               'N/A'))],
            })
        
        trigger_info= ei.trigger_info()
        stream_tags = trigger_info.streamTags() if trigger_info else []
        stags = []
        for st in stream_tags: # don't use list-comprehensions b/c of ROOT bugs
            st_type = st.type()
            st_name = st.name()
            obeys_lbk=bool(st.obeysLumiblock())
            stags.append(dict(stream_type=st_type,
                              stream_name=st_name,
                              obeys_lbk=obeys_lbk))
        peeked_data['stream_tags'] = stags
 
        # -- old files compat
        if self._old_file_flag or 1:
 
            
            metadata_items = [(self.inputStore._pyclidsvc.typename(p.clID()),
                               p.name())
                              for p in self.inputStore.proxies()]
            peeked_data['metadata_items'] = metadata_items
            metadata = {}
            for k in self.inputStore.keys('IOVMetaDataContainer'):
                v = self.process_metadata(self.inputStore, k)
                metadata[k] = maybe_get(v, -1)
            peeked_data['metadata'] = metadata
 
            
            taginfo = {}
            if self.metaStore.contains('IOVMetaDataContainer','/TagInfo'):
                v = self.process_metadata(self.metaStore, '/TagInfo')
                taginfo = mergeMultipleDict(v)
            if taginfo:
                # we want to keep the AtlasRelease from when the file was produced
                atlas_release = metadata.get('/TagInfo', taginfo)
                atlas_release = atlas_release.get('AtlasRelease',
                                                  taginfo['AtlasRelease'])
                taginfo['AtlasRelease'] = atlas_release
                peeked_data['det_descr_tags'] = taginfo
            peeked_data['tag_info'] = taginfo
 
            
            ddt = peeked_data['det_descr_tags']
            peeked_data['geometry'] = ddt.get('GeoAtlas', None)
            peeked_data['conditions_tag'] = ddt.get('IOVDbGlobalTag', None)
 
            
            peeked_data['beam_type']= [ddt.get('beam_type','N/A')]
            beam_ene = maybe_float(ddt.get('beam_energy','N/A'))
            peeked_data['beam_energy']=[beam_ene]
            
            pass # old files compat
 
        return peeked_data
        

declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyArrayType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
  }

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

DeclareInterfaceID()

IPyComponent::DeclareInterfaceID ( IPyComponent  , 1  , 0    )

inherited

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > &  t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                 {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

evtStore() [2/2]

def python.FilePeekerLib.FilePeeker.evtStore

(

self

)

Definition at line 133 of file FilePeekerLib.py.

    def evtStore(self):
        import AthenaPython.PyAthena as PyAthena
        return PyAthena.py_svc('StoreGateSvc/StoreGateSvc')
    

execute() [1/2]

StatusCode PyAthena::Alg::execute ( )

overridevirtualinherited

Definition at line 93 of file PyAthenaAlg.cxx.

{  
//   ATH_MSG_DEBUG("Executing " << name() << "...");
  RootUtils::PyGILStateEnsure ensure;
  PyObject* pycontext = PyCapsule_New ( const_cast<EventContext*>(&getContext()), nullptr, nullptr);
 
  StatusCode sc = PyAthena::callPyMethod( m_self, "sysExecute", pycontext );
  Py_DECREF (pycontext);
  return sc;
}

execute() [2/2]

def python.FilePeekerLib.FilePeeker.execute

(

self

)

Definition at line 152 of file FilePeekerLib.py.

    def execute(self):
        self.peeked_data.update(self._do_peeking(peek_evt_data=True))
        self.print_summary()
        self._peeked_events.append(dict(self.peeked_data))
        return StatusCode.Success
 

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

finalize() [1/2]

StatusCode PyAthena::Alg::finalize ( )

overridevirtualinherited

Definition at line 86 of file PyAthenaAlg.cxx.

{
  ATH_MSG_INFO("Finalizing " << name() << "...");
  return PyAthena::callPyMethod( m_self, "sysFinalize" );
}

finalize() [2/2]

def python.FilePeekerLib.FilePeeker.finalize

(

self

)

Definition at line 256 of file FilePeekerLib.py.

    def finalize(self):
        _info = self.msg.info
        peeked_data = dict(self.peeked_data)
        if self.outfname:
            oname = self.outfname
            import os
            oname = os.path.expanduser(os.path.expandvars(oname))
            _info('storing peeked file infos into [%s]...', oname)
            if os.path.exists(oname):
                os.remove(oname)
 
            import PyUtils.dbsqlite as dbsqlite
            db = dbsqlite.open(oname,flags='w')
            
            # merge and collect data from all processed events (if any)
            if self._peeked_events:
                peeked_data = self._peeked_events.pop(0)
                for d in self._peeked_events:
                    for k in ('run_number',
                              'evt_number',
                              'lumi_block',
                              'run_type',
                              'beam_type',
                              'beam_energy',
                              'stream_tags',):
                        v = d[k]
                        if isinstance(v, list) and len(v)>0:
                            v = v[0]
                            peeked_data[k].append(v)
            #_info('peeked_data:')
            #_info(str(peeked_data))
            db['fileinfos'] = peeked_data
            db.close()
            _info('storing peeked file infos into [%s]... [done]', oname)
        self.print_summary(peeked_data)
        return StatusCode.Success
 

initialize() [1/2]

StatusCode PyAthena::Alg::initialize ( )

overridevirtualinherited

Definition at line 60 of file PyAthenaAlg.cxx.

{
  ATH_MSG_INFO("Initializing " << name() << "...");
  return PyAthena::callPyMethod( m_self, "sysInitialize" );
}

initialize() [2/2]

def python.FilePeekerLib.FilePeeker.initialize

(

self

)

Definition at line 84 of file FilePeekerLib.py.

    def initialize(self):
 
        import AthenaPython.PyAthena as PyAthena
        self.peeked_data = _create_file_infos()
        
        # load our pythonizations:
        for cls_name in ('EventStreamInfo',
                         'EventType',
                         'PyEventType',
                         ):
            cls = getattr(PyAthena, cls_name)  # noqa: F841
 
        _info = self.msg.info
        _info("retrieving various stores...")
        for store_name in ('evtStore', 'inputStore',
                           'tagStore', 'metaStore',):
            _info('retrieving [%s]...', store_name)
            o = getattr(self, store_name)  # noqa: F841
            _info('retrieving [%s]... [done]', store_name)
            
            
        _info("retrieving various stores... [done]")
 
        import os
        self.infname = os.path.basename(self.infname)
 
        import AthenaPython.PyAthena as PyAthena
        _info = self.msg.info
        return StatusCode.Success
        

inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

inputStore()

def python.FilePeekerLib.FilePeeker.inputStore

(

self

)

Definition at line 148 of file FilePeekerLib.py.

    def inputStore(self):
        import AthenaPython.PyAthena as PyAthena
        return PyAthena.py_svc('StoreGateSvc/InputMetaDataStore')
    

metaStore()

def python.FilePeekerLib.FilePeeker.metaStore

(

self

)

Definition at line 138 of file FilePeekerLib.py.

    def metaStore(self):
        import AthenaPython.PyAthena as PyAthena
        return PyAthena.py_svc('StoreGateSvc/MetaDataStore')
    

msg() [1/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

print_summary()

def python.FilePeekerLib.FilePeeker.print_summary	(		self,
			data = None
	)

Definition at line 293 of file FilePeekerLib.py.

    def print_summary(self, data=None):
        if data is None:
            data = self.peeked_data
        _info = self.msg.info
 
        
        _info(':::::: summary ::::::')
        _info(' - nbr events:  %s', data['nentries'])
        _info(' - run numbers: %s', data['run_number'])
        _info(' - evt numbers: %s', data['evt_number'])
        _info(' - lumiblocks: %s', data['lumi_block'])
        _info(' - evt types: %s', data['evt_type'])
        _info(' - item list: %s', len(data['eventdata_items']))
        _info(' - stream names: %s', data['stream_names'])
        _info(' - stream tags: %s', data['stream_tags'])
        _info(' - geometry: %s', data['geometry'])
        _info(' - conditions tag: %s', data['conditions_tag'])
        _info(' - metadata items: %s', len(data['metadata_items']))
        _info(' - tag-info: %s', data['tag_info'].keys())
        return
    

process_metadata()

def python.FilePeekerLib.FilePeeker.process_metadata	(		self,
			store,
			metadata_name
	)

Definition at line 158 of file FilePeekerLib.py.

    def process_metadata(self, store, metadata_name):
        msg = self.msg
        try:
            obj = store[metadata_name]
        except KeyError:
            msg.warning('could not retrieve [%s]', metadata_name)
            return
        if str(obj).find('MetaCont') >= 0:
            obj = obj.get (obj.sources()[0])
        msg.info('processing container [%s]', obj.folderName())
        data = []
        payloads = obj.payloadContainer()
        payloads_sz = payloads.size()
        if hasattr(payloads, 'at'):
            # HACK for bug #77976
            _tmp = payloads
            payloads = []
            for ii in range(payloads_sz):
                payloads.append(_tmp.at(ii))
            pass
        for ii,payload in zip(range(payloads_sz), payloads):
            # print ("-->",ii,payload,type(payload),'\n' )
            if not payload:
                msg.info ("**error** null-pointer ?")
                continue
            # names
            chan_names = []
            sz = payload.name_size()
            msg.info('==names== (sz: %s)', sz)
            for idx in range(sz):
                chan = payload.chanNum(idx)
                chan_name = payload.chanName(chan)
                #msg.info( '--> (%s, %s)', idx, chan_name)
                chan_names.append(chan_name)
                
            if 1: # we don't really care about those...
                # iovs
                sz = payload.iov_size()
                msg.info('==iovs== (sz: %s)',sz)
                for idx in range(sz):
                    chan = payload.chanNum(idx)
                    iov_range = payload.iovRange(chan)
                    iov_start = iov_range.start()
                    iov_stop  = iov_range.stop()
                    if 0:
                        msg.info( '(%s, %s) => (%s, %s) valid=%s runEvt=%s',
                                  iov_start.run(),
                                  iov_start.event(),
                                  iov_stop.run(),
                                  iov_stop.event(),
                                  iov_start.isValid(),
                                  iov_start.isRunEvent())
        
            # attrs
            attrs = [] # can't use a dict as spec.name() isn't unique
            sz = payload.size()
            msg.info('==attrs== (sz: %s)', sz)
            for idx in range(sz):
                chan = payload.chanNum(idx)
                #msg.info("idx: %i chan: %s", idx, chan)
                attr_list = payload.attributeList(chan)
                attr_data = []
                for a in list(toiter(attr_list.begin(), attr_list.end())):
                    #msg.info((a,dir(a),type(a)))
                    spec   = a.specification()
                    a_type = spec.typeName()
                    if a_type.find('string') >= 0:
                        a_data = a.data['string']()
                        try:
                            a_data = eval(a_data,{},{})
                        except Exception:
                            # swallow and keep as a string
                            pass
                    else:
                        a_data = a.data[a_type]()
                    #msg.info("%s: %s  %s", spec.name(), a_data, type(a_data) )
                    attr_data.append( (spec.name(), a_data) )
                attrs.append(dict(attr_data))
                # msg.info(attrs[-1])
            if len(attrs) == len(chan_names):
                data.append(dict(zip(chan_names,attrs)))
            else:
                if len(attrs):
                    if len(attrs) == 1:
                        data.append(attrs[0])
                    else:
                        data.append(attrs)
                else:
                    data.append(chan_names)
            pass # loop over payloads...
        
        #payload.dump()
        
        return data
 

reinitialize()

StatusCode PyAthena::Alg::reinitialize ( )

overridevirtualinherited

Definition at line 67 of file PyAthenaAlg.cxx.

{
  ATH_MSG_INFO("Re-Initializing " << name() << "...");
  return PyAthena::callPyMethod( m_self, "sysReinitialize" );
}

renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T &  h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

self()

virtual PyObject* PyAthena::Alg::self ( )

inlineoverridevirtualinherited

return associated python object.

BORROWED reference.

Implements IPyComponent.

Definition at line 71 of file PyAthenaAlg.h.

{ return m_self; }

setPyAttr()

bool PyAthena::Alg::setPyAttr ( PyObject *  pyobj )

overrideprotectedvirtualinherited

attach the C++ component to its python cousin

Implements IPyComponent.

Definition at line 143 of file PyAthenaAlg.cxx.

{
  // now we tell the PyObject which C++ object it is the cousin of.
  RootUtils::PyGILStateEnsure ensure;
  PyObject* pyobj = TPython::CPPInstance_FromVoidPtr
    ( (void*)this, this->typeName() );
  if ( !pyobj ) {
    PyErr_Clear();
    // try PyAthena::Alg
    pyobj = TPython::CPPInstance_FromVoidPtr ((void*)this, "PyAthena::Alg");
    ATH_MSG_INFO
      ("could not dyncast component [" << name() << "] to a python "
       << "object of type [" << this->typeName() << "] (probably a missing "
       << "dictionary)" << endmsg
       << "fallback to [PyAthena::Alg]...");
  }
  if ( !pyobj ) {
    PyErr_Clear();
    ATH_MSG_WARNING("Could not dyncast component ["
                    << name() << "] to a pyobject of type [" 
                    << this->typeName() << "]");
  } else {
    if ( -1 == PyObject_SetAttrString(o, "_cppHandle", pyobj) ) {
      PyErr_Clear();
      ATH_MSG_WARNING
        ("Could not attach C++ handle [" << name() << "] to its python "
         << "cousin !");
      if ( -1 == PyObject_SetAttrString(o, "_cppHandle", Py_None) ) {
        PyErr_Clear();
        ATH_MSG_WARNING
          ("could not attach a dummy C++ handle [" << name() << "] to its "
           "python cousin !");
      }
    } else {
      return true;
    }
  }
  return false;
}

start() [1/2]

StatusCode PyAthena::Alg::start ( )

overridevirtualinherited

Definition at line 74 of file PyAthenaAlg.cxx.

{ 
  return PyAthena::callPyMethod( m_self, "sysStart" );
}

start() [2/2]

def python.FilePeekerLib.FilePeeker.start

(

self

)

Definition at line 117 of file FilePeekerLib.py.

    def start(self):
        self._begin_run_flag = True
        # retrieving data available at start...
        self.peeked_data.update(self._do_peeking(peek_evt_data=False))
        self.print_summary()
        return StatusCode.Success
 

stop() [1/2]

StatusCode PyAthena::Alg::stop ( )

overridevirtualinherited

Definition at line 80 of file PyAthenaAlg.cxx.

{
  return PyAthena::callPyMethod( m_self, "sysStop" );
}

stop() [2/2]

def python.FilePeekerLib.FilePeeker.stop

(

self

)

Definition at line 124 of file FilePeekerLib.py.

    def stop(self):
        if not self._begin_run_flag:
            # retrieving data for event less jobs, where no beginRun is called
            self.peeked_data.update(self._do_peeking(peek_evt_data=False))
            self.print_summary()
 
        return StatusCode.Success
 

sysInitialize()

StatusCode PyAthena::Alg::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthAlgorithm.

Definition at line 105 of file PyAthenaAlg.cxx.

{
  ServiceHandle<IPyComponentMgr> pyMgr
    ( "PyAthena::PyComponentMgr/PyComponentMgr", name() );
  if ( !pyMgr.retrieve().isSuccess() ) {
    ATH_MSG_ERROR("Could not retrieve service [" << pyMgr.typeAndName()
                  << "] !!");
    return StatusCode::FAILURE;
  }
 
  // first retrieve our python object cousin...
  m_self = pyMgr->pyObject( this );
 
  if ( m_self == Py_None ) {
    ATH_MSG_ERROR("Wrapped PyObject is NONE !");
    return StatusCode::FAILURE;
  }
 
  // re-route to usual sysInit...
  return AlgBase_t::sysInitialize();
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

tagStore()

def python.FilePeekerLib.FilePeeker.tagStore

(

self

)

Definition at line 143 of file FilePeekerLib.py.

    def tagStore(self):
        import AthenaPython.PyAthena as PyAthena
        return PyAthena.py_svc('StoreGateSvc/TagMetaDataStore')
    

typeName()

const char * PyAthena::Alg::typeName ( ) const

overridevirtualinherited

return the std::type_info name of the underlying py-component This is used by concrete implementations to connect a python component to its C++ counter-part

Implements IPyComponent.

Definition at line 132 of file PyAthenaAlg.cxx.

{ 
  static const std::string tname = System::typeinfoName(typeid(*this));
  return tname.c_str();
}

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase &  )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

_begin_run_flag

python.FilePeekerLib.FilePeeker._begin_run_flag

private

Definition at line 79 of file FilePeekerLib.py.

_old_file_flag

python.FilePeekerLib.FilePeeker._old_file_flag

private

input-store self.inputStore.dump()

– metadata – taginfo

Definition at line 76 of file FilePeekerLib.py.

_peeked_events

python.FilePeekerLib.FilePeeker._peeked_events

private

Definition at line 82 of file FilePeekerLib.py.

infname

python.FilePeekerLib.FilePeeker.infname

init base class

if store_name not in ('evtStore',): _info('loading event proxies for [s]...', store_name) status = 'ok' if o.loadEventProxies().isSuccess() else 'err' _info('loading event proxies for [s]...

(s)', store_name, status)

Definition at line 72 of file FilePeekerLib.py.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

m_self

PyObject* PyAthena::Alg::m_self

protectedinherited

Pointer to self (from the python world)

Definition at line 96 of file PyAthenaAlg.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

outfname

python.FilePeekerLib.FilePeeker.outfname

Definition at line 73 of file FilePeekerLib.py.

peeked_data

python.FilePeekerLib.FilePeeker.peeked_data

Definition at line 87 of file FilePeekerLib.py.

---

The documentation for this class was generated from the following file:

• FilePeekerLib.py