In This Package:

OnlineOfflineTest.py

Go to the documentation of this file.

#!/usr/bin/env python
#
# Module which makes Online/Offline Test Histograms
#
#  Usage:
#   nuwa.py -n -1 DataQuality.OnlineOfflineTest 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)

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

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

        self.lastReadoutTime = None
        self.activeChannelIds = []
        self.activeDetectors = []

        return SUCCESS

    def execute(self):
        self.info("executing")
        
        # 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()
        if self.isNewDetector( detector ):
            self.prepareDetectorHistograms( detector )
        detectorName = readout.detector().detName()
        detectorPath = "/file1/" + detectorName
        # Loop over channel data
        nChannels = 0
        for channelPair in readout.channelReadout():
            channel = channelPair.second
            channelId = channel.channelId()
            if self.isNewChannel( channelId ):
                self.prepareChannelHistograms( channelId )

            # Make path for histograms
            path = "%s/board_%d_connector_%d" % (detectorPath,
                                                 channelId.board(),
                                                 channelId.connector())
            self.debug("Processing channel with path: "+path)
            # TDC data by channel
            for tdc in channel.tdc():
                self.debug("Type of tdc hist: "+str(type( self.stats[path + "/tdc"] )))
                self.stats[path + "/tdc"].Fill( tdc )
                self.debug("Filled path with tdc: "+str(tdc))
            # ADC data by channel
            self.debug("Processing adc data with path: "+path)
            for adcPair in channel.adc():
                adcClock = adcPair.first
                adc = adcPair.second
                self.stats[path + "/adc"].Fill( adc )
            # Hit Rate
            channelIndex = channelId.board()*16 + channelId.connector()
            self.stats[detectorPath + "/hitRate"].Fill( channelIndex )
            nChannels += 1

        # Readout histograms
        self.debug("Processing readout with path: "+detectorPath)
        # Number of hit channels
        self.stats[detectorPath + "/nChannels"].Fill( nChannels )
        # Number of Triggers by type
        self.stats[detectorPath + "/triggerType"].Fill( readout.triggerType() )
        # Time Between Triggered Readout
        if self.lastReadoutTime != None:
            # Skip first readout
            dT_trigger = TimeStamp( readout.triggerTime() )
            dT_trigger.Subtract( self.lastReadoutTime )
            self.debug("Dt Readout: "+str(dT_trigger.GetSeconds()))
            self.stats[detectorPath + "/dT_trigger"].Fill(
                                                       dT_trigger.GetSeconds() )

        # Set time of last readout
        self.lastReadoutTime = TimeStamp(readout.triggerTime())
        self.debug("done execute")
        return SUCCESS
        
    def finalize(self):
        self.info("finalizing")
        # Fill summary histograms
        for channelInt in self.activeChannelIds:
            channelId = FeeChannelId( channelInt )
            detectorPath = "/file1/" + channelId.detName()
            path = "%s/board_%d_connector_%d" % (detectorPath,
                                                 channelId.board(),
                                                 channelId.connector())
            channelIndex = channelId.board()*16 + channelId.connector()
            # ADC summary
            meanAdc = self.stats[path + "/adc"].GetMean()
            rmsAdc = self.stats[path + "/adc"].GetRMS()
            self.stats[detectorPath + "/meanAdc"].Fill(channelIndex, meanAdc)
            self.stats[detectorPath + "/rmsAdc"].Fill(channelIndex, rmsAdc)
        for detectorInt in self.activeDetectors:
            # Hit Rate summary
            detector = Detector( detectorInt )
            detectorPath = "/file1/" + detector.detName()
            nReadouts = self.stats[detectorPath + "/nChannels"].GetEntries()
            self.stats[detectorPath + "/hitRate"].Scale( 1 / nReadouts )

        status = DybPythonAlg.finalize(self)
        return status

    def isNewChannel(self, channelId):
        # Check if this channel has been seen
        if channelId.fullPackedData() in self.activeChannelIds:
            return False
        return True

    def isNewDetector(self, detector):
        # Check if this detector has been seen
        if detector.fullPackedData() in self.activeDetectors:
            return False
        return True

    def prepareDetectorHistograms(self, detector):
        # Prepare the empty histograms for this detector
        path = "/file1/" + detector.detName()
        self.debug("Making histograms at path: "+path)
        # Number of hit channels in each readout
        self.stats[path + "/nChannels"] = TH1F("nChannels",
                                               "Number of Hit Channels",
                                               250,0,250)
        hist = self.stats[path + "/nChannels"]
        hist.GetXaxis().SetTitle("Number of Hit Channels")
        hist.GetYaxis().SetTitle("Number of Triggered Readouts")
        # Number of Triggers by type
        self.stats[path + "/triggerType"] = TH1F("triggerType",
                                                 "Trigger Type",
                                                 4096,0,4096)
        hist = self.stats[path + "/triggerType"]
        hist.GetXaxis().SetTitle("Trigger Type")
        hist.GetYaxis().SetTitle("Number of Triggered Readouts")
        # Time Between Triggered Readout
        self.stats[path + "/dT_trigger"] = TH1F("dT_trigger",
                                                "Time between triggers [s]",
                                                1000,0,1)
        hist = self.stats[path + "/dT_trigger"]
        hist.GetXaxis().SetTitle("Time Between Triggered Readouts [s]")
        hist.GetYaxis().SetTitle("Number of Triggered Readouts / 1 ms")
        # Summary Histograms
        # Mean ADC by channel
        self.stats[path + "/meanAdc"] = TH1F("meanAdc",
                                   "Mean ADC by channel",
                                   300,0,300)
        hist = self.stats[path + "/meanAdc"]
        hist.GetXaxis().SetTitle("Channel Index (Board*16 + Connector)")
        hist.GetYaxis().SetTitle("Mean ADC value")
        # RMS ADC by channel
        self.stats[path + "/rmsAdc"] = TH1F("rmsAdc",
                                   "RMS ADC by channel (board*16 + connector)",
                                   300,0,300)
        hist = self.stats[path + "/rmsAdc"]
        hist.GetXaxis().SetTitle("Channel Index (Board*16 + Connector)")
        hist.GetYaxis().SetTitle("RMS of ADC values")
        # Hit Rate by channel
        self.stats[path + "/hitRate"] = TH1F("hitRate",
                                   "Hit Rate by channel",
                                   300,0,300)
        hist = self.stats[path + "/hitRate"]
        hist.GetXaxis().SetTitle("Channel Index (Board*16 + Connector)")
        hist.GetYaxis().SetTitle("Number of Hits / Number of Triggered Readouts")
        self.activeDetectors.append( detector.fullPackedData() )
        return

    def prepareChannelHistograms(self, channelId):
        # Prepare the empty histograms for this channel
        path = "/file1/%s/board_%d_connector_%d" % (channelId.detName(),
                                                    channelId.board(),
                                                    channelId.connector())
        self.debug("Making histograms at path: "+path)
        # TDC data by channel
        self.stats[path + "/tdc"] = TH1F("tdc",
                                         "TDC Values",
                                         4096,0,4096)
        hist = self.stats[path + "/tdc"]
        hist.GetXaxis().SetTitle("TDC value")
        hist.GetYaxis().SetTitle("Number of TDCs")
        # ADC data by channel
        self.stats[path + "/adc"] = TH1F("adc",
                                         "ADC Values",
                                         4096,0,4096)
        hist = self.stats[path + "/adc"]
        hist.GetXaxis().SetTitle("ADC value")
        hist.GetYaxis().SetTitle("Number of ADCs")
        self.activeChannelIds.append( channelId.fullPackedData() )
        return

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

def configure():
    from StatisticsSvc.StatisticsSvcConf import StatisticsSvc
    statsSvc = StatisticsSvc()
    statsSvc.Output ={"file1":"onlineOfflineResult.root"}
    return

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

---