dqm.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
 
from array import array
from ROOT import TCanvas, TF1, TFile
from ROOT import TGraph, TH2D, TLine
from ROOT import kFullCircle
import argparse
 
nWires = [160, 160, 160, 160, 160, 160, 160, 160,
          160, 160, 160, 160, 160, 160,
          192, 192, 192, 192, 192, 192,
          224, 224, 224, 224, 224, 224,
          256, 256, 256, 256, 256, 256,
          288, 288, 288, 288, 288, 288,
          320, 320, 320, 320, 320, 320,
          352, 352, 352, 352, 352, 352,
          384, 384, 384, 384, 384, 384]
 
nWiresSum = []
sum = 0
for w in nWires:
    sum = sum + w
    nWiresSum.append(sum)
 
nWiresSL = [160 * 8, 160 * 6, 192 * 6, 224 * 6, 256 * 6, 288 * 6,
            320 * 6, 352 * 6, 384 * 6]
 
rfClock = 1.017774
refT0 = 4905.0 * rfClock
refMPV = 80
 
 
class DQM():
 
    """
    DQM class.
    """
 
    def __init__(self, fname='output.root'):
        """
        call constructor of base class, required.
        """
 
        super(DQM, self).__init__()
 
        
        self.ff = TFile(fname)
        
        self.typetype = 'adc'
        
        self.histADChistADC = [self.ff.Get('h' + str(100000 + i))
                        for i in range(14336)]
        
        self.histTDChistTDC = [self.ff.Get('h' + str(200000 + i))
                        for i in range(14336)]
        
        self.histHithistHit = [self.ff.Get('h' + str(400000 + i))
                        for i in range(56)]
        
        self.lineslines = []
        for h in self.histTDChistTDC:
            y = h.GetMaximum()
            line = TLine(refT0, 0, refT0, y)
            line.SetLineColor(2)
            self.lineslines.append(line)
 
        
        self.lineMPVslineMPVs = []
        for h in self.histADChistADC:
            y = h.GetMaximum()
            line = TLine(refMPV, 0, refMPV, y)
            line.SetLineColor(2)
            self.lineMPVslineMPVs.append(line)
        #        self.histADCinLayer = [self.f.Get('h' + str(500000 + i))
        #                               for i in range(56)]
 
        
        self.sigsig = TF1("sig", "landau", 0, 200)
        #        self.sig = TF1("sig", "landau+expo(3)", 0, 200)
        #        self.sig.SetParameters(300.0,60.0,20.0,1000,-1.0)
        
        self.ft0ft0 = TF1("ft0", "[0]+[1]*(exp([2]*([3]-x))/(1+exp(-([4]-x)/[5])))", 2000, 4000)
        self.ft0ft0.SetParameters(0, 10, 0, 0, 3800, 3.)
        self.ft0ft0.FixParameter(0, 0.)
        
        self.m_fitStatusm_fitStatus = False
        
        self.canvascanvas = TCanvas("canvas", "canvas", 800, 800)
        
        self.hidhid = 0
        
        self.ndivndiv = 1
        
        self.parpar = [-1.0 for i in range(14336)]
        
        self.parADCinLayerparADCinLayer = [-1.0 for i in range(56)]
        
        self.parT0parT0 = [0.0 for i in range(14336)]
        
        self.h2h2 = TH2D("h2d", "MPV of all ADCs", 15000,
                       -500, 14500, 100, 0, 200)
        
        self.h2h2.SetStats(0)
        
        self.h2h2.GetXaxis().SetTitle('Cell ID')
        
        self.h2h2.GetYaxis().SetTitle('MPV')
        
        self.h2ADCvsLayerh2ADCvsLayer = TH2D("h2dl", "MPV for every Layer", 56,
                                 0, 56, 100, 0, 200)
        
        self.h2ADCvsLayerh2ADCvsLayer.SetStats(0)
        
        self.h2ADCvsLayerh2ADCvsLayer.GetXaxis().SetTitle('Layer')
        
        self.h2ADCvsLayerh2ADCvsLayer.GetYaxis().SetTitle('MPV (adc count)')
        
        self.xx = array("d", [i for i in range(14336)])
        
        self.l_arrayl_array = array("d", [i for i in range(56)])
        
        self.graphgraph = TGraph(len(self.xx))
        
        self.graphgraph.SetMarkerStyle(kFullCircle)
        
        self.graphgraph.SetMarkerSize(0.3)
 
        
        self.graph2graph2 = TGraph(len(self.l_arrayl_array))
        
        self.graph2graph2.SetMarkerStyle(kFullCircle)
        
        self.graph2graph2.SetMarkerSize(1.0)
        
        self.lineline = [TLine(0, 0, 0, 200)]
 
        x0 = 0
        for i in range(9):
            x0 = x0 + nWiresSL[i]
            line = TLine(x0, 0, x0, 200)
            self.lineline.append(line)
        for l_i in self.lineline:
            l_i.SetLineColorAlpha(8, 0.5)
            l_i.SetLineStyle(2)
 
    def fitADC(self, xmin=8, xmax=200):
        """
        Fit all ADC histgrams.
        """
        if self.m_fitStatusm_fitStatus is True:
            print("Fitting for ADC has been already applied.")
        else:
 
            for (i, h) in enumerate(self.histADChistADC):
                if h.GetEntries() > 0:
                    h.Fit(self.sigsig, "Q", "", xmin, xmax)
                    self.parpar[i] = self.sigsig.GetParameter(1)
            self.m_fitStatusm_fitStatus = True
 
    def getHistID(self, lay=0, wire=0):
        """
        Get Hist ID from (layer, wire) ID.
        Return values : hist ID (cell ID)
        """
        hid = nWiresSum[lay - 1] + wire if lay > 0 else wire
        return hid
 
    def getLayerWireID(self, hid=0):
        """
        Get (layer, wire) ID from cell ID.
        Return values : [layer, wire]
        """
        if hid < nWiresSum[0]:
            return [0, hid]
        else:
            layer = 0
            wire = 0
            for (i, wsum) in enumerate(nWiresSum):
                diff = hid - wsum
                if diff > 0 and diff < nWires[i]:
                    layer = i + 1
                    wire = diff
                    break
            return [layer, wire]
 
    def drawADC(self, lay=0, w=0):
        """
        Draw ADC histgrams w.r.t (lay,wire).
        """
        i = self.getHistIDgetHistID(lay, w)
        for j in range(self.ndivndiv):
            self.hidhid = i + j
            self.canvascanvas.cd(j + 1)
            self.histADChistADC[self.hidhid].Draw()
            self.lineMPVslineMPVs[self.hidhid].Draw()
 
        self.typetype = 'adc'
        self.canvascanvas.Update()
 
    def drawTDC(self, lay=0, w=0):
        """
        Draw TDC histgrams w.r.t (lay,wire).
        """
        i = self.getHistIDgetHistID(lay, w)
        for j in range(self.ndivndiv):
            self.hidhid = i + j
            self.canvascanvas.cd(j + 1)
            self.histTDChistTDC[self.hidhid].Draw()
            self.lineslines[self.hidhid].Draw()
 
        self.canvascanvas.Update()
        self.typetype = 'tdc'
 
    def drawHit(self, lay=0):
        """
        Draw Hit histgrams w.r.t layer ID.
        """
        for j in range(self.ndivndiv):
            self.hidhid = lay + j
            if self.hidhid > 55:
                break
            self.canvascanvas.cd(j + 1)
            self.histHithistHit[self.hidhid].Draw()
        self.canvascanvas.Update()
        self.typetype = 'hit'
 
    def drawTDCByCell(self, i):
        """
        Draw TDC histgrams w.r.t cell ID (0-14336).
        """
        for j in range(self.ndivndiv):
            self.hidhid = i + j
            self.canvascanvas.cd(j + 1)
            self.histTDChistTDC[self.hidhid].Draw()
            self.lineslines[self.hidhid].Draw()
 
        self.typetype = 'tdc'
        self.canvascanvas.Update()
 
    def drawADCByCell(self, i):
        """
        Draw ADC histgrams w.r.t cell ID (0-14336).
        """
        for j in range(self.ndivndiv):
            self.hidhid = i + j
            self.canvascanvas.cd(j + 1)
            self.histADChistADC[self.hidhid].Draw()
            self.lineMPVslineMPVs[self.hidhid].Draw()
 
        self.typetype = 'adc'
        self.canvascanvas.Update()
 
    def next(self):
        """
        Show next plots.
        """
        self.hidhid = self.hidhid + 1
        if self.typetype == 'adc':
            self.canvascanvas.Clear('d')
            self.drawADCByCelldrawADCByCell(self.hidhid)
        elif self.typetype == 'tdc':
            self.canvascanvas.Clear('d')
            self.drawTDCByCelldrawTDCByCell(self.hidhid)
        elif self.typetype == 'hit':
            self.canvascanvas.Clear('d')
            self.drawHitdrawHit(self.hidhid)
        else:
            print('Undefined type: ' + type)
 
    def div(self, i=1, j=1):
        """
        Divide Tcanvas by (i,j).
        """
        self.canvascanvas.Clear()
        self.canvascanvas.Divide(i, j)
        self.ndivndiv = i * j
 
    def mpv(self):
        """
        Show the MPV of ADC distribution
        for all wires.
        """
        self.canvascanvas.Clear()
 
        for (i, p) in enumerate(self.parpar):
            self.graphgraph.SetPoint(i, self.xx[i], p)
 
        self.h2h2.Draw()
        for line in self.lineline:
            line.Draw()
        self.graphgraph.Draw("P")
        self.canvascanvas.Update()
 
    def xrange(self, xmin=-500, xmax=14500):
        """
        Set x range of MPV plot.
        """
        self.h2h2.GetXaxis().SetRangeUser(xmin, xmax)
 
    def xrangeHit(self, xmin=0, xmax=350):
        """
        Set x range of Hit distributions.
        """
        for h in self.histHithistHit:
            h.GetXaxis().SetRangeUser(xmin, xmax)
 
    def xrangeTDC(self, xmin=0, xmax=4000):
        """
        Set x range of TDC distributions.
        """
        for h in self.histTDChistTDC:
            h.GetXaxis().SetRangeUser(xmin, xmax)
 
    def xrangeADC(self, xmin=0, xmax=200):
        """
        Set x range of ADC distributions.
        """
        for h in self.histADChistADC:
            h.GetXaxis().SetRangeUser(xmin, xmax)
 
    def print(self, fname='test.png'):
        """
        Print the current plot.
        """
        self.canvascanvas.Print(fname)
 
    def ne(self):
        """
        Alias to next()
        """
        self.nextnext()
 
    def dh(self, lay):
        """
        Alias to drawHit()
        """
        self.drawHitdrawHit(lay)
 
    def da(self, lay, w):
        """
        Alias to drawADC()
        """
        self.drawADCdrawADC(lay, w)
 
    def dt(self, lay, w):
        """
        Alias to drawTDC()
        """
        self.drawTDCdrawTDC(lay, w)
 
 
if __name__ == "__main__":
    # Make the parameters accessible form the outside.
 
    parser = argparse.ArgumentParser()
    parser.add_argument('input', help='Input file to be processed (unpacked CDC data).')
    args = parser.parse_args()
    dqm = DQM(args.input)