In This Package:

Tester.py

Go to the documentation of this file.

#!/usr/bin/env python
#
# Module for Testing Run Diagnostics system
#
#  Usage:
#   nuwa.py -n -1 --stats-output="{'file1':'test_run_X_seq_X.root'}" --raw-load=both -m"RunDiagnostics.Tester" daq_run_X_seq_X.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
TH1 = gbl.TH1
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 TesterAlg(DybPythonAlg):
    "Tester 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.runNumber=None
        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

        if not self.runNumber:
            # Initialize run number from raw data block
            self.runNumber = readout.rawEvent().runNumber()

        detector = readout.detector()
        if self.isNewDetector( detector ):
            self.prepareDetectorHistograms( detector )
        runPath = "/file1/diagnostics/run_%06d" % self.runNumber
        detectorName = readout.detector().detName()
        detectorPath = runPath + "/detector_" + 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/channel_board%02d_connector%02d" % (detectorPath,
                                                         channelId.board(),
                                                         channelId.connector())
            self.debug("Processing channel with path: "+path)
            # TDC data by channel
            for hitIdx in range(channel.size()):
                self.stats[path + "/tdc"].Fill( channel.tdc(hitIdx) )
                self.stats[path + "/adc"].Fill( channel.adc(hitIdx) )
            # Hit Rate
            channelIndex = channelId.board()*16 + channelId.connector()
            self.stats[detectorPath + "/hitRate"].Fill( channelIndex )
            nChannels += 1

        # Readout histograms
        # 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 )
            runPath = "/file1/diagnostics/run_%06d" % self.runNumber
            detectorName = channelId.detName()
            detectorPath = runPath + "/detector_" + detectorName
            path = "%s/channel_board%02d_connector%02d" % (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 )
            runPath = "/file1/diagnostics/run_%06d" % self.runNumber
            detectorPath = runPath + "/detector_" + detector.detName()
            nReadouts = self.stats[detectorPath + "/nChannels"].GetEntries()
            self.stats[detectorPath + "/hitRate"].Scale( 1 / nReadouts )
            self.stats[detectorPath + "/hitRate"].SetBit( TH1.kIsAverage )

        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 = self.runPath() + "/detector_" + 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 = "%s/detector_%s/channel_board%02d_connector%02d" % (
                                                        self.runPath(),
                                                        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

    def runPath(self):
        # Return standard run path
        return "/file1/diagnostics/run_%06d" % self.runNumber
    
#####  Job Configuration for nuwa.py ########################################

def configure(argv=[]):
    return

def run(app):
    '''
    Generate test output for run diagnostics
    '''
    myAlg = TesterAlg("MyTesterAlg")
    app.addAlgorithm(myAlg)
    pass

---