In This Package:

ADChannelData.py

Go to the documentation of this file.

#!/usr/bin/env python
'''
Usage:
'''

from UserTagging.UserTaggingAlg import UserTaggingAlg
from UserTagging.Models import Tag, Data, Int, Float, IntArray, FloatArray
from GaudiPython import SUCCESS, FAILURE
from GaudiPython import gbl

class ADChannelData(UserTaggingAlg):
    '''Add AD Channel Stats to UserData'''
    
    # ----------------------------------------    
    def initTagList(self):
        
        # Chao recommends method chaning since it's less typing and he is lazy.
        # A tag with no path (default to '') means no tag HeaderObject will be created
        # but this dummy tag is still need in order to manage the UserData 
        #
        self.addTag('Dummy', ''
            ).addData('ADChannelData', '/Event/UserData/AD/ADChannelData'
            ).addIntArray('board', 'connector', 'ring', 'column', 'hitCount'
            ).addFloatArray('adc0', 'preAdc0', 'charge0', 'tdc0', 'adcMax', 'charge')

        # or use Brett's preferred pythonic syntax:
        #
        # dummyTag = self.tagSet.Dummy = Tag()
        # myData = dummyTag.dataSet.ADChannelData = Data('/Event/UserData/AD/ADChannelData')
        #        
        # myData.paraSet.board     = IntArray()
        # myData.paraSet.connector = IntArray()
        # myData.paraSet.ring      = IntArray()
        # myData.paraSet.column    = IntArray()
        # myData.paraSet.hitCount  = IntArray()
        # 
        # myData.paraSet.adc0    = FloatArray()
        # myData.paraSet.preAdc0 = FloatArray()
        # myData.paraSet.charge0 = FloatArray()
        # myData.paraSet.tdc0    = FloatArray()
        # myData.paraSet.adcMax  = FloatArray()
        # myData.paraSet.charge  = FloatArray()
                
        self.cableSvc = self.svc('ICableSvc','StaticCableSvc')
        if self.cableSvc == None:
            self.error("Failed to get StaticCableSvc")
            return FAILURE    


    # ----------------------------------------
    def check(self, evt):
        ADTag = evt['/Event/UserTag/Detector/AD']
        if not ADTag:
            return
        
        readoutHdr = evt['/Event/Readout/ReadoutHeader']
        if not readoutHdr:
            self.warning('cannot find readoutHdr')
            return
        self.SaveReadoutData(readoutHdr)        
        
        self.tagIt('Dummy')
                    
    # ----------------------------------------
    def SaveReadoutData(self, readoutHdr):
        
        myData = self.getTag('Dummy').getData('ADChannelData')
                
        svcMode = gbl.ServiceMode(readoutHdr.context(), 0)     
        daqCrate = readoutHdr.daqCrate()
        pmtCrate = daqCrate.asPmtCrate();
                
        nChannels = 0
        for channel in pmtCrate.channelReadouts():
            nChannels += 1
            channelId = channel.channelId()
            board     = channelId.board()
            connector = channelId.connector()
            pmtId     = self.cableSvc.adPmtSensor(channelId, svcMode)
            ring      = pmtId.ring()
            column    = pmtId.column()
            
            myData.append('board', board
                ).append('connector', connector
                ).append('ring', ring
                ).append('column', column
                ).append('hitCount', channel.hitCount())
                
            # or use Brett's preferred pythonic syntax:
            # myData.paraSet.board.append(board)
            # myData.paraSet.connector.append(connector)
            # myData.paraSet.ring.append(ring)
            # myData.paraSet.column.append(column)
            # myData.paraSet.hitCount.append(channel.hitCount())
                
            adc0 = channel.adc(0)
            preAdc0 = channel.preAdcAvg(0)
            if channel.isHighGainAdc(0):
                charge0 = adc0 - preAdc0
            else:
                charge0 = (adc0 - preAdc0) * 20
            tdc0 = channel.tdc(0)
            
            myData.append('adc0', adc0
                ).append('preAdc0', preAdc0
                ).append('charge0', charge0
                ).append('tdc0', tdc0)
                     
            adcMax = adc0
            charge = charge0
            for i in range(1, channel.hitCount()):
                adc = channel.adc(i)
                preAdc = channel.preAdcAvg(i)

                if channel.isHighGainAdc(i):
                    if (adc > adcMax): adcMax = adc 
                    charge += (adc - preAdc)
                else:
                    if (adc*20 > adcMax): adcMax = adc*20
                    charge += (adc - preAdc) * 20
                    
            myData.append('adcMax', adcMax
                ).append('charge', charge)
        
        # you can print all branches of UserData    
        # myData.dump()
        # or an individual branch
        # print 'charge: ', myData.get('charge')
            
                
#####  Job Configuration for nuwa.py ########################################

def configure(argv=[]):
    pass

def run(app):
    app.ExtSvc += ["StaticCableSvc"]
    myAlg = ADChannelData("UserData::ADChannelData")
    app.addAlgorithm(myAlg)
    pass

---