In This Package:

OnlineOfflineTestRefactored.py

Go to the documentation of this file.

#!/usr/bin/env python

# Plot some stuff with MDR data - This is a refactoring of Dan's
# DataQuality.OnlineOfflineTest.  Here, we make some "Histograms"
# objects which handle booking and filling certain types of histograms
# (per readout, per channel, channel summary).  Then the algorithm
# code calls their one or more of their fill*() methods at the
# appropriate time.  Each histogram object saves itself into a lookup
# table held by the class in order to facilitate doing post
# processing.  Instead of using the statistics service store as a
# lookup for histograms by name, each Histograms object makes its
# histograms available directly as data members.  This better
# decouples I/O and memory.

# This could be further refined to make a set of Histograms subclasses
# that have well defined fill() semantics.  Then the user would not
# have to look at so much code and just focus on implementing book()
# and fill().

# Module which makes Online/Offline Test Histograms
#
#  Usage:
#   nuwa.py -n -1 OnlineOfflineTestRefactored daq_spliced.data

# Load DybPython
from DybPython.DybPythonAlg import DybPythonAlg
from GaudiPython import SUCCESS, FAILURE
from GaudiPython import gbl
from DybPython.Util import irange
import GaudiKernel.SystemOfUnits as units

# Make shortcuts to any ROOT classes you want to use
TH1F = gbl.TH1F
TimeStamp = gbl.TimeStamp
FeeChannelId = gbl.DayaBay.FeeChannelId
Detector = gbl.DayaBay.Detector

#change default ROOT style
gbl.gStyle.SetHistLineColor(4)
gbl.gStyle.SetHistLineWidth(2)
gbl.gStyle.SetMarkerColor(4)
gbl.gStyle.SetMarkerStyle(8)
gbl.gStyle.SetPalette(1)

def channel_index(chid):
    return chid.board()*16 + chid.connector()

class Histograms(object):
    def __init__(self,alg,detector):
        self.alg = alg
        self.detector = Detector(detector.fullPackedData())
        return

    def _make_hist(self, name, title, nbins, vmin, vmax,xtitle=None,ytitle=None):
        'Make and return TH1F with given parameters'
        hist = TH1F(name,title,nbins,vmin,vmax)
        if xtitle: hist.GetXaxis().SetTitle(xtitle)
        if ytitle: hist.GetYaxis().SetTitle(ytitle)
        return hist

    def _place_hist(self, hist, path, member):
        '''Place hist in file and as data member.
        path is relative to /file1/detName/
        member is name to use for member
        '''
        path = "/file1/" + self.detector.detName() + "/" + path
        self.alg.stats[path] = hist
        self.__dict__[member] = hist
        return hist

    def hist(self, name, title, nbins, vmin, vmax,xtitle=None,ytitle=None):
        'Make and register a simple, top level, uniquely named histogram'
        hist = self._make_hist(name, title, nbins, vmin, vmax,xtitle,ytitle)
        return self._place_hist(hist,name,name)

    def container_hist(self, container, name, title, nbins, vmin, vmax,xtitle=None,ytitle=None):
        'Make and register a non-uniquely named histogram that lives in a container'
        hist = self._make_hist(name, title, nbins, vmin, vmax,xtitle,ytitle)
        return self._place_hist(hist,container+'/'+name,name,container)

    pass

class PerChannelHistograms(Histograms):

    hists = {}

    def __init__(self,alg,detector,channelId):
        super(PerChannelHistograms,self).__init__(alg,detector)
        chanint = channelId.fullPackedData()
        self.chanint = chanint
        self.name = "board_%d_connector_%d" % (channelId.board(),
                                               channelId.connector())
        self._book()
        PerChannelHistograms.hists[chanint] = self
        alg.info('Making a PerChannelHistograms: %x'%chanint)
        return

    def hist(self, name, title, nbins, vmin, vmax,xtitle=None,ytitle=None):
        'Override to place at unique subdirectory in file'
        hist = self._make_hist(name, title, nbins, vmin, vmax,xtitle,ytitle)
        return self._place_hist(hist,self.name+'/'+name,name)

    def _book(self):
        # Prepare the empty histograms for this channel

        self.hist('tdc', "TDC Values", 4096,0,4096,
                  "TDC value","Number of TDCs")
        
        # ADC data by channel
        self.hist('adc', "ADC Values", 4096,0,4096,
                  "ADC value","Number of ADCs")

        return

    def fill(self,channel):
        for tdc in channel.tdc():
            self.tdc.Fill(tdc)
        for adcPair in channel.adc():
            #adcClock = adcPair.first
            adc = adcPair.second
            self.adc.Fill(adc)
        return

class ChannelSummaryHistograms(Histograms):

    hists = {}

    def __init__(self,alg,detector):
        super(ChannelSummaryHistograms,self).__init__(alg,detector)
        self._book()
        ChannelSummaryHistograms.hists[detector.fullPackedData()] = self
        return

    def _book(self):
        # Summary Histograms
        # Mean ADC by channel
        self.hist("meanAdc", "Mean ADC by channel", 300,0,300,
                   "Channel Index (Board*16 + Connector)","Mean ADC value")
        
        # RMS ADC by channel
        self.hist("rmsAdc", "RMS ADC by channel (board*16 + connector)", 300,0,300,
                   "Channel Index (Board*16 + Connector)","RMS of ADC values")
        return

    def fill(self,chanint,adc):
        ci = float(channel_index(FeeChannelId(chanint)))
        self.alg.info('ChannelSummary: %f %f %f'%(ci,adc.GetMean(),adc.GetRMS()))
        self.meanAdc.Fill(ci,adc.GetMean())
        self.rmsAdc.Fill(ci,adc.GetRMS())
        return
    
    pass

class PerReadoutHistograms(Histograms):

    hists = {}

    def __init__(self,alg,detector):
        super(PerReadoutHistograms,self).__init__(alg,detector)
        self.lastReadoutTime = None
        self._book()
        PerReadoutHistograms.hists[detector.fullPackedData()] = self
        return

    def _book(self):
        'Internal: book all histograms'

        # Number of hit channels in each readout
        self.hist("nChannels", "Number of Hit Channels", 250,0,250,
                   "Number of Hit Channels","Number of Triggered Readouts")

        # Number of Triggers by type
        self.hist("triggerType", "Trigger Type", 4096,0,4096,
                   "Trigger Type","Number of Triggered Readouts")

        # Time Between Triggered Readout
        self.hist("dT_trigger", "Time between triggers [s]", 1000,0,1,
                   "Time Between Triggered Readouts [s]","Number of Triggered Readouts / 1 ms")
        
        # Hit Rate by channel
        self.hist("hitRate", "Hit Rate by channel", 300,0,300,
                   "Channel Index (Board*16 + Connector)", "Number of Hits / Number of Triggered Readouts")
        return

    def fill_channelId(self,channelId):
        ci = channel_index(channelId)
        self.hitRate.Fill(ci)

    def fill_readout(self,readout):
        self.nChannels.Fill(len(readout.channelReadout()))
        self.triggerType.Fill(readout.triggerType())

        triggerTime = readout.triggerTime()
        if self.lastReadoutTime != None:
            dt = TimeStamp(triggerTime)
            dt.Subtract( self.lastReadoutTime )
            self.dT_trigger.Fill(dt.GetSeconds())
            pass
        self.lastReadoutTime = TimeStamp(triggerTime)
        return

    def norm(self):
        self.hitRate.Scale(1.0 / self.nChannels.GetEntries())

    pass

                            


# Make your algorithm
class OnlineOfflineAlg(DybPythonAlg):
    "Online/Offline Test Algorithm"
    def __init__(self,name):
        DybPythonAlg.__init__(self,name)
        self.eventnum = 0
        return

    def initialize(self):
        status = DybPythonAlg.initialize(self)
        if status.isFailure(): return status
        self.info("initializing")
        return SUCCESS

    def execute(self):
        self.eventnum += 1              # for debuggin
        self.debug("executing event %d"%self.eventnum)
        
        # Access current data
        evt = self.evtSvc()
        readoutHdr = evt["/Event/Readout/ReadoutHeader"]
        if readoutHdr == None:
            self.error("Failed to get current readout header")
            return FAILURE

        readout = readoutHdr.readout()
        if readout == None:
            self.error("Failed to get readout from header")
            return FAILURE

        detector = readout.detector()
        detint = detector.fullPackedData()

        # Fill per-detector hists
        try:
            prh = PerReadoutHistograms.hists[detint]
        except KeyError:
            prh = PerReadoutHistograms(self,detector)
        prh.fill_readout(readout)


        # Loop over channel data
        self.verbose('Event %d with %d channels'%(self.eventnum,len(readout.channelReadout())))
        for channelPair in readout.channelReadout():
            channel = channelPair.second
            channelId = channel.channelId()
            chanint = channelId.fullPackedData()
            try:
                pch = PerChannelHistograms.hists[chanint]
            except KeyError:
                pch = PerChannelHistograms(self,detector,channelId)
            pch.fill(channel)
            prh.fill_channelId(channelId)
            continue

        return SUCCESS
        
    def finalize(self):
        self.info("finalizing")
        # Fill summary histograms
        for id,pch in PerChannelHistograms.hists.iteritems():
            detint = pch.detector.fullPackedData()
            try:
                csh = ChannelSummaryHistograms.hists[detint]
            except KeyError:
                csh = ChannelSummaryHistograms(self,pch.detector)

            csh.fill(pch.chanint,pch.adc)
            continue

        for prh in PerReadoutHistograms.hists.itervalues():
            prh.norm()
            continue

        status = DybPythonAlg.finalize(self)
        return status


#####  Job Configuration for nuwa.py ########################################

def configure(argv=None):
    from StatisticsSvc.StatisticsSvcConf import StatisticsSvc
    statsSvc = StatisticsSvc()
    histfile = "onlineOfflineResult.root"
    if argv: histfile = argv[0]
    statsSvc.Output ={"file1":histfile}
    return

def run(app):
    '''
    Configure and add an algorithm to job
    '''
    app.ExtSvc += ["StaticCableSvc", "StatisticsSvc"]
    myAlg = OnlineOfflineAlg("OnlineOfflineTestRefactored")
    app.addAlgorithm(myAlg)
    pass

---