Viewer.py

Go to the documentation of this file.

#!/usr/bin/env python


from GaudiPython.GaudiAlgs import GaudiAlgo
from GaudiPython import SUCCESS, FAILURE
from GaudiPython import gbl
from array import array

TH1F = gbl.TH1F
TGraph = gbl.TGraph
TCanvas = gbl.TCanvas
TFile = gbl.TFile
DayaBay = gbl.DayaBay
gStyle = gbl.gStyle
gStyle.SetPalette(1)
gStyle.SetMarkerStyle(8)
gStyle.SetMarkerColor(4)

class EsViewerAlg(GaudiAlgo):
    "An algorithm for generating figures of ElecSim Data Objects"
    def __init__(self,name):
        GaudiAlgo.__init__(self,name)
        print "Making EsViewerAlg",name
        self.plot = {}

    def initialize(self):
        status = GaudiAlgo.initialize(self)
        print "Init EsViewerAlg",self.name()
        if status.isFailure(): return status
        return SUCCESS

    def execute(self):
        print "Executing EsViewerAlg",self.name()
        evt = self.evtSvc()
        hdr = evt["/Event/Elec/ElecHeader"]
        crateHdr = hdr.crateHeader()
        crates = crateHdr.crates()
        crate = crates[DayaBay.Detector(0x01,1)]
        # Signal clock ticks [ns]
        hitDt = 12.5
        energyDt = 1.5625
        esumDt = 6.25
        adcDt = 25
        tdcDt = 25./16.
         #Draw entire crate nhit signal
        nhitBoard = crate.nhit()
        nhitSignal = None
        for board in range(6,17):
            boardId = DayaBay.FeeChannelId(board,0,0x01,1)
            boardNhit = nhitBoard[boardId]
            #print "init size: ",boardNhit.size()
            if nhitSignal == None:
                nhitSignal = [0] * boardNhit.size()
            for cycle in range(boardNhit.size()):
                nhitSignal[cycle] += boardNhit[cycle]
        nhitClock = [tick*hitDt for tick in range(boardNhit.size())]
        self.plot["nhit"] = TGraph(boardNhit.size(),
                                   array('f',nhitClock),
                                   array('f',nhitSignal))
                                   
        # Plot energy sum
        energySum = None 
        energySize = None
        for connector in range(1,17):
            for board in range(1,24):
                channelId = DayaBay.FeeChannelId(board,connector,0x01,1)
                channel = crate.channel(channelId)
                energyChannel = channel.energy()
                if energyChannel.size() == 0:
                    continue
                if energySum == None:
                    energySum = [0] * energyChannel.size()
                    energySize = energyChannel.size()
                for cycle in range(energyChannel.size()):
                    energySum[cycle] += energyChannel[cycle]
        energyClock = [tick*energyDt for tick in range(energySize)]
        self.plot["energySum"] = TGraph(energySize,
                                   array('f',energyClock),
                                   array('f',energySum))
        # Draw an example channel
        tdc = None
        flag = 0
        channel = None
        for connector in range(1,17):
          if flag == 1: 
              break
          for board in range(1,24):
              # Look for a channel with hits
              channelId = DayaBay.FeeChannelId(board,connector,0x01,1)
              channel = crate.channel(channelId)
              tdc = channel.tdc()
              if tdc.size() > 0:
                  print "Found a hit channel"
                  flag = 1
                  break
        if flag == 0:
            print "No hit channel found"
        if flag == 1:
            energy = channel.energy()
            energyClock = [tick*energyDt for tick in range(energy.size())]
            self.plot["energy"] = TGraph(energy.size(),
                                         array('f',energyClock),
                                         array('f',energy))
            hit = channel.hit()
            hitClock = [tick*hitDt for tick in range(hit.size())]
            self.plot["hit"] = TGraph(hit.size(),
                                      array('f',hitClock),
                                      array('f',hit))
            adcLow = channel.adcLow()
            adcLowClock = [tick*adcDt for tick in range(adcLow.size())]
            self.plot["adcLow"] = TGraph(adcLow.size(),
                                         array('f',adcLowClock),
                                         array('f',adcLow))
            adcHigh = channel.adcHigh()
            adcHighClock = [tick*adcDt for tick in range(adcHigh.size())]
            self.plot["adcHigh"] = TGraph(adcHigh.size(),
                                          array('f',adcHighClock),
                                          array('f',adcHigh))
            esumTotal = crate.esumTotal()
            energyClock = [tick*esumDt for tick in range(esumTotal.size())]
            self.plot["esumTotal"] = TGraph(esumTotal.size(),
                                          array('f',energyClock),
                                          array('f',esumTotal))
            esumLower = crate.esumLower()
            energyClock = [tick*esumDt for tick in range(esumLower.size())]
            self.plot["esumLower"] = TGraph(esumLower.size(),
                                          array('f',energyClock),
                                          array('f',esumLower))
            esumUpper = crate.esumUpper()
            energyClock = [tick*esumDt for tick in range(esumUpper.size())]
            self.plot["esumUpper"] = TGraph(esumUpper.size(),
                                          array('f',energyClock),
                                          array('f',esumUpper))
        return SUCCESS

    def finalize(self):
        print "Finalizing EsViewerAlg",self.name()
        outFile = TFile("elecSimPlots.root","RECREATE")
        for key in self.plot.keys():
            self.plot[key].SetTitle(key)
            self.plot[key].SetName(key)
            self.plot[key].GetXaxis().SetTitle("time [ns]")
            self.plot[key].Write()
        status = GaudiAlgo.finalize(self)
        return status

def configure():
    return

def run(app):
    viewer = EsViewerAlg("EsViewer")
    app.addAlgorithm(viewer)
    pass