In This Package:

UserTaggingAlg.py

Go to the documentation of this file.

#!/usr/bin/env python
# zhang@caltech.edu 2011-03-01

from DybPython.DybPythonAlg import DybPythonAlg
from GaudiPython import SUCCESS, FAILURE
from GaudiPython import gbl
import ROOT
from UserTagging.Models import TagSet, Tag, Data, Int, Float, IntArray, FloatArray

class UserTaggingAlg(DybPythonAlg):
    '''
    Abstract Class for Saving UserTag and UserData
    
    The following demostrate the layout of UserTaggingAlg:
    
                                UserTaggingAlg
                                      |
                                      |
                               ----------------
                               |              |
                               |              |
                             tagSet      'other members ...'
                               |
                               |
                          -------------
                          |     |     |
                          |     |     |
                         Tag1  Tag2  ...
                          |
                          |
                      ----------------------------------
                      |         |      |      |        |
                      |         |      |      |        |
                    dataSet    path  header isTagged   ...
                      |
                      |
                -------------
                |     |     |
                |     |     |
               Data1 Data2  ...
                |
                |           
           ---------------------------
           |           |      |      |
           |           |      |      |
         paraSet      path  header   ...
           |
           |
     -------------
     |     |     |
     |     |     |
    Para1 Para2  ...
    '''
    
    def __init__(self,name):
        DybPythonAlg.__init__(self,name)
        
        # avoid a 'bug?' of UserDataHeader
        # gbl.std.vector('float')() has to be called at least once 
        # before instantiate UserDataHeader 
        tmp = gbl.std.vector('float')();
        return
      
    # ---------------------------------------
    def initialize(self):

        '''
        User need not implement, but if so, you must call this method on the
        super-class'''

        status = DybPythonAlg.initialize(self)
        if status.isFailure(): return status
                
        # self.tagSet = {}
        self.tagSet = TagSet()
        
        status = self.initTagList()
        if status == FAILURE: 
            self.error('error in initTagList() function')
            return FAILURE
        
        self.execNumber = 1
        
        return SUCCESS  
    
    # ---------------------------------------    
    def initTagList(self):
        '''
        Child Class should overwrite this function.
        Child Class should initialize UserTag and UserData here
        
        example adding Tag:
        self.addTag('AD' , '/Event/UserTag/Detector/AD')
        
        or alternative (pythonic) syntax:
        self.tagSet.AD  = Tag('/Event/UserTag/Detector/AD')
        
        example adding a Dummy Tag and UserData:
        self.addTag('Dummy', ''
            ).addData('ADReadoutData', '/Event/UserData/AD/ADReadoutData'
            ).addInt('nChannels', 'nHits'
            ).addFloat('chargeSum')
        
        or alternative (pythonic) syntax:
        self.tagSet.Dummy = Tag()
        self.tagSet.Dummy.dataSet.ADReadoutData = Data('/Event/UserData/AD/ADReadoutData')
        paraSet = self.tagSet.Dummy.dataSet.ADReadoutData.paraSet
        paraSet.nChannels = Int()
        paraSet.nHits = Int()
        paraSet.chargeSum = Float()
        '''

    # ---------------------------------------
    def addTag(self, name, path=''):
        """
        Add one UserTag by name, provide a path to cause the tag
        object to be sent through I/O.

        Can also do:

          self.tagSet.<name> = Models.Tag([path])
        """
        return self.tagSet.addTag(name, path)

    # ---------------------------------------
    def getTag(self, name):
        """
        Look the UserTagHeader a tag by name.

        Can also do:

          mytag = self.tagSet.<name>
        """
        return self.tagSet.get(name)
    
    # --------------------------------------
    def tagIt(self, name):
        """
        Tag the named UserTag.

        Can also do:
        
          self.tagSet.<name>.tagIt()
        """
        return self.tagSet.get(name).tagIt()
            
    # --------------------------------------
    def reset(self):
        '''Reset the Tag States'''
        
        for tag in self.tagSet.all():
            if tag.isTagged:
                if tag.path:
                    tag.header = gbl.DayaBay.HeaderObject()
                    ROOT.SetOwnership(tag.header,False)
                for data in tag.dataSet.all():
                    data.header = gbl.DayaBay.UserDataHeader()
                    ROOT.SetOwnership(data.header,False)
                tag.isTagged = False
                    
    # --------------------------------------
    def check(self, evt):
        '''Child Class should overwrie this function'''
        # all the real logics/algorithms happen here:
        # - check the properties of the event headers, run some algorithms.
        # - decide if this event should be tagged.
        # - if shoud be tagged, call tagIt(tagName) function to trigger the I/O
        # - save some calculated variables to the UserData
        # - the tags and user data will then be automatically saved 
        #   to the output (root) file at the paths defined in the tags
        #   at this exec cycle.
        #
        # If GaudiKernel.FAILURE is returned the execute() method will
        # immediately return this value.
        pass
            
    # --------------------------------------
    def config(self, evt):
        '''
        Configure the UserTagHeader and UserDataHeader object
        Child class can overwrite depends on the situation.

        The "evt" is the transient event store object.
        '''
        
        for tag in self.tagSet.all():
            if tag.isTagged:
                baseHeader = evt[tag.baseHeader]
                if not baseHeader:
                    self.error(tag.baseHeader + ' does not exist')
                    return FAILURE
                if tag.path:
                    tagHeader = tag.header    
                    tagHeader.setExecNumber(baseHeader.execNumber())
                    tagHeader.setContext(baseHeader.context())
                    tagHeader.setEarliest(baseHeader.earliest())
                    tagHeader.setLatest(baseHeader.latest())
                    
                for data in tag.dataSet.all():
                    dataHeader = data.header
                    dataHeader.setExecNumber(baseHeader.execNumber())
                    dataHeader.setContext(baseHeader.context())
                    dataHeader.setEarliest(baseHeader.earliest())
                    dataHeader.setLatest(baseHeader.latest())

    # --------------------------------------
    def save(self, evt):
        '''
        Save the UserTag and UserData objects

        Most subclass should not override.
        '''
        
        for tag in self.tagSet.all():
            if tag.isTagged:
                tag.nTagged += 1
                if tag.path:
                    evt[tag.path] = tag.header
                    del tag.header
                for data in tag.dataSet.all():
                    data.save()
                    evt[data.path] = data.header
                    del data.header
                            
        # --------------------------------------
    def execute(self):
        'Subclass should not override'
                    
        evt = self.evtSvc()
        
        status = self.reset()  
        if status == FAILURE: 
            self.error('error in reset() function')
            return FAILURE
        
        status = self.check(evt)
        if status == FAILURE: 
            self.error('error in check() function')
            return FAILURE
        
        status = self.config(evt)
        if status == FAILURE: 
            self.error('error in config() function')
            return FAILURE
        
        status = self.save(evt)
        if status == FAILURE: 
            self.error('error in save() function')
            return FAILURE
        
        self.execNumber += 1
        return SUCCESS

    # --------------------------------------
    def finalPrint(self):
        '''Print how many tagged events'''
        
        for name, tag in self.tagSet.all_dict().items():
            self.info( 'Summary: UserTag %s : %d events tagged at %s' % (name, tag.nTagged, tag.path) )
            for dataName, data in tag.dataSet.all_dict().items():
                self.info( "\tUserData %s saved at %s" % (dataName, data.path) )
                
    # -------------------------------------- 
    def finalize(self):     
        'Subclass may override, but it must called this method on the super-class'
        self.finalPrint()   
        status = DybPythonAlg.finalize(self)
        return status

---