Exemple #1
0
    def draw_nse_mean(self):
        cent_bin1 = [0, 4, 7]
        cent_bin2 = [3, 6, 8]
        p_bin1 = [
            0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.2, 1.5, 2.0, 2.5,
            3.0, 3.5, 4.0, 4.5
        ]
        p_bin2 = [
            0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.2, 1.5, 2.0, 2.5, 3.0,
            3.5, 4.0, 4.5, 5.0
        ]
        gr_mean = TGraphErrors()
        gr_width = TGraphErrors()
        gr_eff = TGraphErrors()
        for i in range(0, len(p_bin1)):
            f_gaus = self.draw_nse(cent_bin1[1], cent_bin2[1], p_bin1[i],
                                   p_bin2[i], -1, 2)
            mean = f_gaus.GetParameter(1)
            mean_err = f_gaus.GetParError(1)
            width = f_gaus.GetParameter(2)
            width_err = f_gaus.GetParError(2)
            gr_mean.SetPoint(i, (p_bin1[i] + p_bin2[i]) * 0.5, mean)
            gr_mean.SetPointError(i, (p_bin2[i] - p_bin1[i]) * 0.5, mean_err)
            gr_width.SetPoint(i, (p_bin1[i] + p_bin2[i]) * 0.5, width)
            gr_width.SetPointError(i, (p_bin2[i] - p_bin1[i]) * 0.5, width_err)
            p = 0.5 * (p_bin1[i] + p_bin2[i])
            if p < 1:
                nse_low = 0.5 * p - 1.5
            else:
                nse_low = -1
            m = f_gaus.Integral(nse_low, 2.0)
            N = f_gaus.Integral(-10.0, 10.0)
            gr_eff.SetPoint(i, p, m / N)
            gr_eff.SetPointError(i, (p_bin2[i] - p_bin1[i]) * 0.5,
                                 eff_err(m, N))
        gr_mean.SetMarkerStyle(20)

        gr_mean.SetMarkerSize(1.5)
        gr_mean.SetMarkerColor(632)
        gr_width.SetMarkerStyle(20)
        gr_width.SetMarkerSize(1.5)
        gr_width.SetMarkerColor(600)
        gr_eff.SetMarkerStyle(20)
        gr_eff.SetMarkerSize(1.5)
        gr_eff.SetMarkerColor(600)
        hx = histo(0, 10, -0.2, 1.2, "p_{T}(GeV/c)", "Mean/Width")
        canvas_file = self.__canvas__
        canvas_file.cd()
        c1 = TCanvas("c1", "c1", 1000, 800)
        hx.Draw()
        gr_width.Draw("psame")
        gr_mean.Draw("psame")
        c1.Write("nse")
        c1.SaveAs("nse.png")
        c2 = TCanvas("c2", "c2", 1000, 800)
        hx.GetYaxis().SetTitle("n#sigma_{e} cut efficiency")
        hx.Draw()
        gr_eff.Draw("psame")
        c2.Write("nse_eff")
        c2.SaveAs("nse_eff.png")
Exemple #2
0
def testIthr():
    lines = get_lines('DAC_scan_ithr_0x40to0xf0.dat')

    gr1 = TGraphErrors()
    gr2 = TGraphErrors()

    fUnit = 1000. / 0.7
    yUnit = 'e^{-}'

    for line in lines:
        if len(line) == 0: continue
        if line[0] in ['#', '\n']: continue
        fs = line.rstrip().split()

        ix = int(fs[0])
        gr1.SetPoint(ix, float(fs[1]), float(fs[2]) * fUnit)
        gr1.SetPointError(ix, 0, float(fs[3]) * fUnit)
        gr2.SetPoint(ix, float(fs[1]), float(fs[4]) * fUnit)
        gr2.SetPointError(ix, 0, float(fs[5]) * fUnit)

    useAtlasStyle()
    gStyle.SetMarkerStyle(20)

    gr1.SetMarkerStyle(20)
    gr1.Draw('AP')
    h1 = gr1.GetHistogram()
    h1.GetYaxis().SetTitle("Threshold [" + yUnit + "]")
    h1.GetXaxis().SetTitle("I_{Thre} code")
    # h1.GetYaxis().SetRangeUser(0,0.2)

    gPad.SetTicks(1, 0)
    gPad.SetRightMargin(0.16)

    y1b = 0
    y2b = 15
    x1 = h1.GetXaxis().GetXmax()
    y1 = h1.GetYaxis().GetXmin()
    y2 = h1.GetYaxis().GetXmax()
    raxis = TGaxis(x1, y1, x1, y2, y1b, y2b, 506, "+L")
    raxis.SetLineColor(2)
    raxis.SetLabelColor(2)
    raxis.SetTitleColor(2)
    raxis.SetTitle("ENC [" + yUnit + "]")
    raxis.Draw()

    nP = gr2.GetN()
    Ys = gr2.GetY()
    EYs = gr2.GetEY()
    Y = array(
        'd', [y1 + (y2 - y1) / (y2b - y1b) * (Ys[i] - y1b) for i in range(nP)])
    EY = array('d', [(y2 - y1) / (y2b - y1b) * EYs[i] for i in range(nP)])
    gr2x = TGraphErrors(nP, gr2.GetX(), Y, gr2.GetEX(), EY)
    gr2x.SetMarkerStyle(24)
    gr2x.SetLineColor(2)
    gr2x.SetMarkerColor(2)

    gr2x.Draw('Psame')

    waitRootCmdX()
Exemple #3
0
 def draw_tof_cut_eff(self, cent_low, cent_high):
     cent_bin1 = [0, 4, 7]
     cent_bin2 = [3, 6, 8]
     p_bin1 = [
         0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.2, 1.5, 2.0, 2.5,
         3.0, 3.5, 4.0, 4.5
     ]
     p_bin2 = [
         0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.2, 1.5, 2.0, 2.5, 3.0,
         3.5, 4.0, 4.5, 5.0
     ]
     gr_mean = TGraphErrors()
     gr_width = TGraphErrors()
     gr_eff = TGraphErrors()
     for i in range(0, len(p_bin1)):
         f_gaus = self.draw_tof_cut(cent_bin1[1], cent_bin2[1], p_bin1[i],
                                    p_bin2[i])
         mean = f_gaus.GetParameter(1)
         mean_err = f_gaus.GetParError(1)
         width = f_gaus.GetParameter(2)
         width_err = f_gaus.GetParError(2)
         gr_mean.SetPoint(i, (p_bin1[i] + p_bin2[i]) * 0.5, mean)
         gr_mean.SetPointError(i, (p_bin2[i] - p_bin1[i]) * 0.5, mean_err)
         gr_width.SetPoint(i, (p_bin1[i] + p_bin2[i]) * 0.5, width)
         gr_width.SetPointError(i, (p_bin2[i] - p_bin1[i]) * 0.5, width_err)
         m = f_gaus.Integral(0.97, 1.03)
         N = f_gaus.GetParameter(0) * math.sqrt(
             2 * math.pi) * f_gaus.GetParameter(2)
         print m, N
         gr_eff.SetPoint(i, (p_bin1[i] + p_bin2[i]) * 0.5, m / N)
         gr_eff.SetPointError(i, (p_bin2[i] - p_bin1[i]) * 0.5,
                              eff_err(m, N))
     gr_mean.SetMarkerStyle(20)
     gr_mean.SetMarkerSize(1.5)
     gr_mean.SetMarkerColor(632)
     gr_width.SetMarkerStyle(20)
     gr_width.SetMarkerSize(1.5)
     gr_width.SetMarkerColor(600)
     gr_eff.SetMarkerStyle(20)
     gr_eff.SetMarkerSize(1.5)
     gr_eff.SetMarkerColor(600)
     hx = histo(0, 10, -0.2, 1.2, "p_{T}(GeV/c)", "Mean/Width")
     canvas_file = self.__canvas__
     canvas_file.cd()
     c1 = TCanvas("c1", "c1", 1000, 800)
     hx.GetYaxis().SetTitle("1/#beta cut efficency")
     hx.Draw()
     gr_width.Draw("psame")
     gr_mean.Draw("psame")
     c1.Write("tof")
     c1.SaveAs("tof.png")
     c2 = TCanvas("c2", "c2", 1000, 800)
     hx.Draw()
     gr_eff.Draw("psame")
     c2.Write("tof_cut_eff")
     c2.SaveAs("tof_cut.png")
Exemple #4
0
def rescaleJetPlot(plot):

    #loop on all data points
    nPoints = plot.GetN()
    #    print "old:",plot.GetName(), nPoints
    #create another TGraph
    newPlot = TGraphErrors()

    for i in xrange(0, nPoints):

        dataPointX = Double(0)
        dataPointY = Double(0)
        error = Double(0)
        plot.GetPoint(i, dataPointX, dataPointY)
        #if numpy.isnan(dataPointY) : dataPointY = 0.000001
        if dataPointY < 0.000001: dataPointY = 0.000001
        errorX = plot.GetErrorX(i)
        errorY = plot.GetErrorY(i)
        newPlot.SetPoint(i, dataPointX / 1000., dataPointY)
        newPlot.SetPointError(i, errorX / 1000., errorY)


#    print "new:", newPlot.GetName(), newPlot.GetN()

    return newPlot
Exemple #5
0
def test1a(fname='data/fpgaLin/dp02a_Mar04C1a_data_0.root'):
    add_fit_menu()

    t1 = TChain('reco')
    t1.Add(fname)

    t1.Show(0)
    V = 200
    gr1 = TGraphErrors()

    for i in range(19):
        c1.cd(i+1)
        lt.DrawLatexNDC(0.2,0.4,'Ch={0:d}'.format(i))
        t1.Draw('Q[{0:d}]>>hx{0:d}'.format(i),'tID!=7')
        hx = gPad.GetPrimitive('hx{0:d}'.format(i))
        hx.Fit('gaus')
        fun1 = hx.GetFunction('gaus')
        encN = 7.40*V*fun1.GetParameter(2)/fun1.GetParameter(1)
        encE = 7.40*V*fun1.GetParError(2)/fun1.GetParameter(1)

        gr1.SetPoint(i,i,encN)
        gr1.SetPointError(i,0,encE)

    c1.cd(20)
    gr1.Draw('AP')

    c1.cd()
    waitRootCmdX()
  def write(self, setup):

    #Rescaling to efficiency
    normalisation = 1/self.histogram.GetBinContent(1)
    #Rescaling everything to have rates
    self.histogram.Scale(normalisation)

    efficiencyPlot = TGraphErrors(self.histogram)
    efficiencyPlot.SetName(self.cfg_ana.plot_name+"_errors")
    efficiencyPlot.SetTitle(self.cfg_ana.plot_title)

    for index in xrange(0, len(efficiencyPlot.GetX())):
      efficiencyPlot.SetPointError(index, 
                                   efficiencyPlot.GetEX()[index], 
                                   sqrt(efficiencyPlot.GetY()[index] * normalisation)
                                  )
    
    c1 = TCanvas ("canvas_" + self.cfg_ana.plot_name, self.cfg_ana.plot_title, 600, 600)
    c1.SetGridx()
    c1.SetGridy()
    efficiencyPlot.Draw("AP")
    c1.Update()
    c1.Write()
    c1.Print(self.cfg_ana.plot_name + ".svg", "svg")
    efficiencyPlot.Write()
def DivideTGraphErrors(num, denom, name):
    nPoints = num.GetN()
    nSkipPoints = 0  # count of when we can't divide
    newTGraph = TGraphErrors(nPoints)
    newTGraph.SetName(name)
    for i in range(nPoints):
        x = num.GetX()[i]
        x_err = num.GetEX()[i]
        y1 = num.GetY()[i]
        y2 = denom.GetY()[i]
        y = 0.0
        y_err = 0.0
        if ((y1 != 0) and (y2 != 0)):
            # technically could make this work for y1 = 0
            y = y1 / y2
            y1_err = num.GetEY()[i]
            y2_err = denom.GetEY()[i]
            y_err = y * math.sqrt(
                math.pow(y1_err / y1, 2) + math.pow(y2_err / y2, 2))
            newTGraph.SetPoint(i - nSkipPoints, x, y)
            newTGraph.SetPointError(i - nSkipPoints, x_err, y_err)
        else:
            newTGraph.RemovePoint(i - nSkipPoints)
            nSkipPoints += 1
    newTGraph.SetLineColor(num.GetLineColor())
    newTGraph.SetMarkerColor(num.GetMarkerColor())
    newTGraph.SetMarkerStyle(num.GetMarkerStyle())

    return newTGraph
Exemple #8
0
def sub2pull(dataHist, pdfwErrs):
    from ROOT import TGraphErrors
    from math import sqrt

    ThePull = TGraphErrors(dataHist.GetN())

    pdfi = 0
    for i in range(0, ThePull.GetN()):
        while (dataHist.GetX()[i] > pdfwErrs.GetX()[pdfi]):
            pdfi += 1
        #print 'pull point:',i,'pdfi:',pdfi
        diff = dataHist.GetY()[i] - pdfwErrs.GetY()[pdfi]
        if (diff < 0):
            err2 = pdfwErrs.GetErrorY(pdfi)**2 + dataHist.GetErrorYhigh(i)**2
        else:
            err2 = pdfwErrs.GetErrorY(pdfi)**2 + dataHist.GetErrorYlow(i)**2
        if (err2>0):
            pull = diff/(sqrt(err2)*1.2)
        else:
            pull = 0

        ThePull.SetPoint(i, dataHist.GetX()[i], pull)
        ThePull.SetPointError(i, 0., 1.)

    ThePull.SetName(dataHist.GetName() + "_pull")
    ThePull.SetTitle("data")

    return ThePull
Exemple #9
0
 def draw_neta_cut_eff(self, cent_low, cent_high):
     cent_bin1 = [0, 4, 7]
     cent_bin2 = [3, 6, 8]
     p_bin1 = [
         0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.2, 1.5, 2.0, 2.5,
         3.0, 3.5, 4.0, 4.5
     ]
     p_bin2 = [
         0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.2, 1.5, 2.0, 2.5, 3.0,
         3.5, 4.0, 4.5, 5.0
     ]
     gr_eff = TGraphErrors()
     for i in range(0, len(p_bin1)):
         mn = self.draw_neta_cut(cent_low, cent_high, p_bin1[i], p_bin2[i])
         m = mn[0]
         N = mn[1]
         gr_eff.SetPoint(i, (p_bin1[i] + p_bin2[i]) * 0.5, m / N)
         gr_eff.SetPointError(i, (p_bin2[i] - p_bin1[i]) * 0.5,
                              eff_err(m, N))
     gr_eff.SetMarkerStyle(20)
     gr_eff.SetMarkerSize(1.5)
     gr_eff.SetMarkerColor(600)
     hx = histo(0, 8, -0.2, 1.2, "p_{T}(GeV/c)", "n#eta cut efficiency")
     canvas_file = self.__canvas__
     canvas_file.cd()
     c2 = TCanvas("c2", "c2", 1000, 800)
     hx.Draw()
     gr_eff.Draw("psame")
     c2.Write("neta_cut_eff")
     c2.SaveAs("neta_cut.png")
    def plotGainSummary(self, strDetName):
        #Create the Plot - Average
        gDet_AvgEffGain = TGraphErrors(len(self.GAIN_AVG_POINTS))
        gDet_AvgEffGain.SetName("g_{0}_EffGainAvg".format(strDetName))

        #Create the Plot - Max Gain
        gDet_MaxEffGain = TGraphErrors(len(self.GAIN_MAX_POINTS))
        gDet_MaxEffGain.SetName("g_{0}_EffGainMax".format(strDetName))

        #Create the Plot - Min Gain
        gDet_MinEffGain = TGraphErrors(len(self.GAIN_MIN_POINTS))
        gDet_MinEffGain.SetName("g_{0}_EffGainMin".format(strDetName))

        #Set and print the points
        #print "===============Printing Gain Data==============="
        #print "[BEGIN_DATA]"
        #print "\tVAR_INDEP,VAR_DEP,VAR_DEP_ERR"
        for i in range(0, len(self.GAIN_AVG_POINTS)):
            #Average
            gDet_AvgEffGain.SetPoint(i, self.DET_IMON_POINTS[i],
                                     self.GAIN_AVG_POINTS[i])
            gDet_AvgEffGain.SetPointError(i, 0, self.GAIN_STDDEV_POINTS[i])
            #print "\t%f,%f,%f"%(self.DET_IMON_POINTS[i],self.GAIN_AVG_POINTS[i],self.GAIN_STDDEV_POINTS[i])

            #Max
            gDet_MaxEffGain.SetPoint(i, self.DET_IMON_POINTS[i],
                                     self.GAIN_MAX_POINTS[i])

            #Min
            gDet_MinEffGain.SetPoint(i, self.DET_IMON_POINTS[i],
                                     self.GAIN_MIN_POINTS[i])
            pass
        #print "[END_DATA]"
        #print ""

        #Draw
        canv_AvgEffGain = TCanvas(
            "canv_{0}_EffGainAvg".format(strDetName),
            "{0} Average Effective Gain".format(strDetName), 600, 600)
        canv_AvgEffGain.cd()
        canv_AvgEffGain.cd().SetLogy()
        gDet_AvgEffGain.GetXaxis().SetTitle("HV")
        gDet_AvgEffGain.GetYaxis().SetTitle("#LT Effective Gain #GT")
        gDet_AvgEffGain.GetYaxis().SetRangeUser(1e2, 1e6)
        gDet_AvgEffGain.SetMarkerStyle(21)
        gDet_AvgEffGain.Draw("AP")
        gDet_MaxEffGain.Draw("sameL")
        gDet_MinEffGain.Draw("sameL")

        #Write
        dir_Summary = self.FILE_OUT.mkdir("Summary")
        dir_Summary.cd()
        canv_AvgEffGain.Write()
        gDet_AvgEffGain.Write()
        gDet_MaxEffGain.Write()
        gDet_MinEffGain.Write()

        return
class GraphicsObject:
    def __init__(self, data, name):
        self._data = data
        self._graphics = None
        self._style = Style(kBlack, 20)
        self._plotrange = {"Min": None, "Max": None}
        self._name = name

    def SetPlotRange(self, min, max):
        self._plotrange[min] = min
        self._plotrange[max] = max

    def SetStyle(self, style):
        self._style = style

    def SetName(self, name):
        self._name = name

    def GetData(self):
        return self._data

    def GetGraphics(self):
        return self._graphics

    def GetStyle(self):
        return self._style

    def Draw(self):
        if not self._graphics:
            self._graphics = TGraphErrors()
            np = 0
            for bin in range(1, self._data.GetXaxis().GetNbins() + 1):
                if self._plotrange["Min"] and self._data.GetXaxis(
                ).GetBinLowEdge(bin) < self._plotrange["Min"]:
                    continue
                if self._plotrange["Max"] and self._data.GetXaxis(
                ).GetBinUpEdge(bin) > self._plotrange["Max"]:
                    break
                self._graphics.SetPoint(
                    np,
                    self._data.GetXaxis().GetBinCenter(bin),
                    self._data.GetBinContent(bin))
                self._graphics.SetPointError(
                    np,
                    self._data.GetXaxis().GetBinWidth(bin) / 2.,
                    self._data.GetBinError(bin))
                np = np + 1
        self._graphics.SetMarkerColor(self._style.GetColor())
        self._graphics.SetLineColor(self._style.GetColor())
        self._graphics.SetMarkerStyle(self._style.GetMarker())
        self._graphics.Draw("epsame")

    def AddToLegend(self, legend, title=None):
        if self._graphics:
            tit = self._name
            if title:
                tit = title
            legend.AddEntry(self._graphics, tit, "lep")
Exemple #12
0
def get_data_graph(hx, centers):

    #make graph erros from input distribution and bin centers
    gr = TGraphErrors(hx.GetNbinsX())

    for i in xrange(hx.GetNbinsX()):
        gr.SetPoint(i, centers[i]["val"], hx.GetBinContent(i + 1))
        gr.SetPointError(i, centers[i]["err"], hx.GetBinError(i + 1))

    return gr
Exemple #13
0
def getGraph(data, name='graph', offset=0):
    from ROOT import TGraphErrors
    g = TGraphErrors(len(data))
    for n, (_, throughput, throughputE) in enumerate(data):
        g.SetPoint(n, offset + n, throughput)
        g.SetPointError(n, 0., throughputE)
    g.SetName(name)
    g.SetLineWidth(2)
    g.SetMarkerSize(1.7)
    return g
    def plotPDSummary(self, strDetName):
        #Create the Plot - Average
        gDet_AvgPD = TGraphErrors(len(self.PD_AVG_POINTS))
        gDet_AvgPD.SetName("g_{0}_PDAvg".format(strDetName))

        #Create the Plot - Max Gain
        gDet_MaxPD = TGraphErrors(len(self.PD_MAX_POINTS))
        gDet_MaxPD.SetName("g_{0}_PDMax".format(strDetName))

        #Create the Plot - Min Gain
        gDet_MinPD = TGraphErrors(len(self.PD_MIN_POINTS))
        gDet_MinPD.SetName("g_" + strDetName + "_PDMin")
        gDet_MinPD.SetName("g_{0}_PDMin".format(strDetName))

        #Set the points
        for i in range(0, len(self.PD_AVG_POINTS)):
            #Average
            gDet_AvgPD.SetPoint(i, self.GAIN_AVG_POINTS[i],
                                self.PD_AVG_POINTS[i])
            gDet_AvgPD.SetPointError(i, self.GAIN_STDDEV_POINTS[i],
                                     self.PD_STDDEV_POINTS[i])

            #Max
            gDet_MaxPD.SetPoint(i, self.GAIN_AVG_POINTS[i],
                                self.PD_MAX_POINTS[i])

            #Min
            gDet_MinPD.SetPoint(i, self.GAIN_AVG_POINTS[i],
                                self.PD_MIN_POINTS[i])

        #Draw
        canv_AvgPD = TCanvas("canv_{0}_PDAvg".format(strDetName),
                             "{0} Discharge Probability".format(strDetName),
                             600, 600)
        canv_AvgPD.cd()
        canv_AvgPD.cd().SetLogx()
        canv_AvgPD.cd().SetLogy()
        gDet_AvgPD.GetXaxis().SetTitle("#LT Effective Gain #GT")
        gDet_AvgPD.GetYaxis().SetTitle("Discharge Probability P_{D}")
        gDet_AvgPD.GetYaxis().SetRangeUser(1e-11, 1e-6)
        gDet_AvgPD.SetMarkerStyle(21)
        gDet_AvgPD.Draw("AP")
        gDet_MaxPD.Draw("sameL")
        gDet_MinPD.Draw("sameL")

        #Write
        dir_Summary = self.FILE_OUT.GetDirectory("Summary")
        dir_Summary.cd()
        canv_AvgPD.Write()
        gDet_AvgPD.Write()
        gDet_MaxPD.Write()
        gDet_MinPD.Write()

        return
Exemple #15
0
  def plotGraph(self, x='vv', y='acc'): 
    '''
    Plot a graph with specified quantities on x and y axes , and saves the graph
    '''

    if (x not in self.quantities.keys()) or (y not in self.quantities.keys()):
      raise RuntimeError('selected quantities not available, available quantities are: \n{}'.format(self.quantities.keys()))

    xq = self.quantities[x]
    yq = self.quantities[y]

    #graph = TGraphAsymmErrors()
    #graph = TGraph()
    graph = TGraphErrors()
    for i,s in enumerate(self.samples):
      graph.SetPoint(i,getattr(s, xq.name), getattr(s, yq.name) )
      #if xq.err: 
      #  graph.SetPointEXhigh(i, getattr(s, xq.name+'_errup'))   # errup errdn
      #  graph.SetPointEXlow (i, getattr(s, xq.name+'_errdn'))
      if yq.err: 
        graph.SetPointError(i, 0, getattr(s, yq.name+'_errup'))
      #  graph.SetPointEYhigh(i, getattr(s, yq.name+'_errup'))  
      #  graph.SetPointEYlow (i, getattr(s, yq.name+'_errdn'))

    c = TCanvas()
    graph.SetLineWidth(2)
    graph.SetMarkerStyle(22)
    graph.SetTitle(';{x};{y}'.format(y=yq.title,x=xq.title))
    graph.Draw('APLE')

    if yq.forceRange:
      graph.SetMinimum(yq.Range[0])
      graph.SetMaximum(yq.Range[1])

    gPad.Modified()
    gPad.Update()
    if yq.name=='expNevts':
      line = TLine(gPad.GetUxmin(),3,gPad.GetUxmax(),3)
      line.SetLineColor(ROOT.kBlue)
      line.Draw('same')
      #graph.SetMinimum(0.01)
      #graph.SetMaximum(1E06)

    if xq.log: c.SetLogx()
    if yq.log: c.SetLogy()
    c.SetGridx()
    c.SetGridy()
    c.SaveAs('./plots/{}{}/{}_{}VS{}.pdf'.format(self.label,suffix,self.name,yq.name,xq.name))
    c.SaveAs('./plots/{}{}/{}_{}VS{}.C'.format(self.label,suffix,self.name,yq.name,xq.name))
    c.SaveAs('./plots/{}{}/{}_{}VS{}.png'.format(self.label,suffix,self.name,yq.name,xq.name))

    self.graphs['{}VS{}'.format(yq.name,xq.name)] = graph
    # add the graph container for memory?
    graph_saver.append(graph)
Exemple #16
0
def addErrors(err1, err2):
    from ROOT import TGraphErrors
    from math import sqrt

    newErrs = TGraphErrors(err1)

    for i in range(0, newErrs.GetN()):
        newErrs.SetPoint(i, newErrs.GetX()[i], err1.GetY()[i] + err2.GetY()[i])
        newErrs.SetPointError(i, err1.GetErrorX(i),
                              sqrt(err1.GetErrorY(i)**2 + \
                                   err2.GetErrorY(i)**2)
                              )
    return newErrs
    def plotGainSummary(self, strDetName):
        #Create the Plot - Average
        gDet_AvgEffGain = TGraphErrors( len(self.GAIN_AVG_POINTS) )
        #gDet_AvgEffGain.SetName("g_" + strDetName + "_EffGainAvg")
        gDet_AvgEffGain.SetName("g_{0}_EffGainAvg".format(strDetName))
        
        #Create the Plot - Max Gain
        gDet_MaxEffGain = TGraphErrors( len(self.GAIN_MAX_POINTS) )
        #gDet_MaxEffGain.SetName("g_" + strDetName + "_EffGainMax")
        gDet_MaxEffGain.SetName("g_{0}_EffGainMax".format(strDetName))

        #Create the Plot - Min Gain
        gDet_MinEffGain = TGraphErrors( len(self.GAIN_MIN_POINTS) )
        #gDet_MinEffGain.SetName("g_" + strDetName + "_EffGainMin")
        gDet_MinEffGain.SetName("g_{0}_EffGainMin".format(strDetName))

        #Set the points
        for i in range(0, len(self.GAIN_AVG_POINTS) ):
            #Average
            gDet_AvgEffGain.SetPoint(i,self.DET_IMON_POINTS[i],self.GAIN_AVG_POINTS[i])
            gDet_AvgEffGain.SetPointError(i,0,self.GAIN_STDDEV_POINTS[i])

            #Max
            gDet_MaxEffGain.SetPoint(i,self.DET_IMON_POINTS[i],self.GAIN_MAX_POINTS[i])

            #Min
            gDet_MinEffGain.SetPoint(i,self.DET_IMON_POINTS[i],self.GAIN_MIN_POINTS[i])
        
        #Draw
        #canv_AvgEffGain = TCanvas("canv_" + strDetName + "_EffGainAvg",strDetName + " Average Effective Gain",600,600)
        canv_AvgEffGain = TCanvas("canv_{0}_EffGainAvg".format(strDetName),"{0} Average Effective Gain".format(strDetName),600,600)
        canv_AvgEffGain.cd()
        canv_AvgEffGain.cd().SetLogy()
        gDet_AvgEffGain.GetXaxis().SetTitle("HV")
        gDet_AvgEffGain.GetYaxis().SetTitle("#LT Effective Gain #GT")
        gDet_AvgEffGain.GetYaxis().SetRangeUser(1e2,1e6)
        gDet_AvgEffGain.SetMarkerStyle(21)
        gDet_AvgEffGain.Draw("AP")
        gDet_MaxEffGain.Draw("sameL")
        gDet_MinEffGain.Draw("sameL")

        #Write
        dir_Summary = self.FILE_OUT.mkdir("Summary")
        dir_Summary.cd()
        canv_AvgEffGain.Write()
        gDet_AvgEffGain.Write()
        gDet_MaxEffGain.Write()
        gDet_MinEffGain.Write()
        
    	return
Exemple #18
0
    def Read1DGraphErrors(self, iline):
        """
        Read 1D graph section
        """
        ngraphs = self.GetNhist(
            self.lines[iline])  # graph and hist format is the same
        xarray = []
        data = {}
        errors = {}

        for igraph in range(ngraphs):
            data[igraph] = []
            errors[igraph] = []

        for line in self.lines[iline + 1:]:
            line = line.strip()
            if line == '': break
            elif re.search("^#", line): continue
            words = line.split()
            xarray.append(float(words[0]))
            for igraph in range(ngraphs):
                data[igraph].append(float(words[(igraph + 1) * 2 - 1]))
                errors[igraph].append(float(words[(igraph + 1) * 2]))

        npoints = len(xarray)

        for igraph in range(ngraphs):
            if self.subtitles[igraph]:
                subtitle = ' - ' + self.subtitles[igraph]
            else:
                subtitle = ''
            self.FixTitles()
            g = TGraphErrors(npoints)
            # self.ihist+1 - start from ONE as in Angel - easy to compare
            g.SetNameTitle(
                "g%d" % (self.ihist + 1), "%s%s;%s;%s" %
                (self.title, subtitle, self.xtitle, self.ytitle))
            self.ihist += 1
            for i in range(npoints):
                x = xarray[i]
                y = data[igraph][i]
                ey = errors[igraph][i]
                g.SetPoint(i, x, y)
                g.SetPointError(i, 0, ey * y)

            self.histos.Add(g)
        del self.subtitles[:]
Exemple #19
0
def getGraph(Ts, filename):
    lines = None
    with open(filename) as f1:
        lines = f1.readlines()

    Tx = None
    for line in lines:
        ### find the associated tamperature
        line = line.rstrip()
        if len(line) == 0:
            Tx = None
            continue

        if line[0] == '#':
            fs = line.split()
            data = fs[1] + ' ' + fs[2]
            b = parse(data)
            if b is None: continue

            for x in Ts:
                for y in x.Times:
                    if b > y[0] and b < y[1]:
                        Tx = x
                        print b, Tx.T
                        break
                if Tx is not None: break
            continue

        if Tx is None: continue
        ### Add the samples to it
        fs = line.split(',')
        if len(fs) < 3:
            continue
        Tx.data.append(float(fs[2]))

    gr1 = TGraphErrors()
    for t in Ts:

        if len(t.data) == 0: continue
        ### calculate the mean and err
        ### Fill in the tgraph
        print t.T, len(t.data), nm.mean(t.data), nm.std(t.data)
        i = gr1.GetN()
        gr1.SetPoint(i, t.T, nm.mean(t.data))
        gr1.SetPointError(i, 0, nm.std(t.data))

    return gr1
Exemple #20
0
 def tgraphNormError(self):
     """ returns a TGraphErrors object normalized to value=1.0 at the first data point"""
     if (len(self._data) == 0):
         print "***** Dataset.tgraphNormError(): ERROR: no data available for", self._algo + '_' + self._impl
         return TGraphErrors()
     result = TGraphErrors(len(self._data))
     normFactor = 1. / self._data[0]._y
     i = 0
     for k in self._data:
         normValue = k._y * normFactor
         if normValue < self._minvalue: self._minvalue = normValue
         if normValue > self._maxvalue: self._maxvalue = normValue
         #print "Normalizing %s: i=%d days=%d val=%f normFactor=%f stored=%f minVal=%f maxVal=%f" % (self._name, i, k, self.serie[k], normFactor, normValue, self._minvalue, self._maxvalue)
         result.SetPoint(i, k._x, normValue)
         result.SetPointError(i, 0, k._dy * normFactor)
         i = i + 1
     return result
Exemple #21
0
def createPull(theData, curve, curveUp=None, curveDown=None):
    from ROOT import TGraphErrors, TMath

    pullGraph = TGraphErrors(theData.GetN())

    for datapt in range(0, theData.GetN()):
        binmin = theData.GetX()[datapt] - theData.GetEXlow()[datapt]
        binmax = theData.GetX()[datapt] + theData.GetEXhigh()[datapt]

        binN = theData.GetY()[datapt] * (binmax - binmin)

        curveN = curve.average(binmin, binmax) * (binmax - binmin)

        diffUp = 0.
        diffDown = 0.
        if curveUp and curveDown:
            diffUp = curveUp.average(binmin,
                                     binmax) * (binmax - binmin) - curveN
            diffDown = curveN - curveDown.average(binmin,
                                                  binmax) * (binmax - binmin)

            if diffUp < 0:
                #print diffUp
                hold = diffDown
                diffDown = -1. * diffUp
                diffUp = -1. * diffDown

        if (binN > curveN):
            errN = TMath.Sqrt((theData.GetEYlow()[datapt]*(binmax-binmin))**2 \
                                  + diffUp**2)
        else:
            errN = TMath.Sqrt((theData.GetEYhigh()[datapt]*(binmax-binmin))**2 \
                                  + diffDown**2)

        pull = 0.
        if errN > 0:
            pull = (binN - curveN) / errN

        # print 'bin: (', binmin, ',', binmax, ') N:', binN, '+/-', errN,
        # print 'curve N:', curveN

        pullGraph.SetPoint(datapt, theData.GetX()[datapt], pull)
        pullGraph.SetPointError(datapt, 0., 1.)

    return pullGraph
Exemple #22
0
	def getGraph(self, filename):
		data = self.getData(filename)

		from ROOT import TFile, TTree, gDirectory, TGraphErrors, TCanvas
		from array import array

		nsteps = len(data)
		g = TGraphErrors(nsteps)

		## Loop on the data
		for	n,(fragsize,tp,tpE) in enumerate(data):
			g.SetPoint(      n, fragsize, tp)
			g.SetPointError( n,       0., tpE)

		g.SetLineWidth(2)
		g.SetMarkerSize(1.7)

		return g
Exemple #23
0
 def tgraph(self):
     """ returns data points in a TGraphErrors object."""
     if (len(self._data) == 0):
         print "***** Dataset.tgraph(): ERROR: no data available for", self._algo + '_' + self._impl
         return TGraphErrors()
     result = TGraphErrors(len(self._data))
     i = 0
     #for k in sorted(self._data.iterkeys()):
     for k in self._data:
         x = k._x
         y = k._y
         #if y < self._minvalue : self._minvalue = y
         #if y > self._maxvalue : self._maxvalue = y
         #print "raw %s %s %s: i=%d value=%f minVal=%f maxVal=%f" % (self._shape, self._algo, self._impl, i, k, self._minvalue, self._maxvalue)
         result.SetPoint(i, x, y)
         result.SetPointError(i, 0, k._dy)
         i = i + 1
     return result
Exemple #24
0
def main():
    from optparse import OptionParser
    parser = OptionParser()
    parser.add_option("-i", "--inputfile", dest="inputfile")
    parser.add_option("",
                      "--spline3",
                      action="store_true",
                      dest="spline3",
                      default=False)
    (options, args) = parser.parse_args()

    from ROOT import TFile, TGraph, TGraphErrors, NULL
    import csv

    with open(options.inputfile) as f:
        reader = csv.reader(f, delimiter=" ", skipinitialspace=True)
        rows = list(reader)
        outfile = TFile("%s.root" % options.inputfile, "RECREATE")
        g = TGraphErrors(len(rows))

        for i, row in enumerate(rows):
            g.SetPoint(i, float(row[1]) / 1000., float(row[2]))
            g.SetPointError(i, 0.0, float(row[3]))

        if options.spline3:
            g_spline3 = TGraph(10 * (g.GetN() - 1))
            x = g.GetX()
            y = g.GetY()
            for i in range(g.GetN() - 1):
                step = (x[i + 1] - x[i]) / 10
                for j in range(10):
                    index = 10 * i + j
                    x_ = x[i] + j * step
                    y_ = g.Eval(x_, NULL, "S")
                    g_spline3.SetPoint(index, x_, y_)
            g_spline3.SetName(options.inputfile)
            g_spline3.Write()
        else:
            g.SetName(options.inputfile)
            g.Write()

        outfile.Close()
def getRatio(result, result2, label):

    masses = result["mass"]
    massErr = result["massErr"]
    sigma = result["sigma"]
    sigmaErr = result["sigmaErr"]
    masses2 = result2["mass"]
    massErr2 = result2["massErr"]
    sigma2 = result2["sigma"]
    sigmaErr2 = result2["sigmaErr"]

    ratio = TGraphErrors(len(masses))
    ratio.SetName(label)
    for i, mass in enumerate(masses):
        ratio.SetPoint(i, mass, sigma[i] / sigma2[i])
        ratio.SetPointError(i, massErr[i], (sigma[i] / sigma2[i]) *
                            math.sqrt((sigmaErr[i] / sigma[i])**2 +
                                      (sigmaErr2[i] / sigma2[i])**2))

    return ratio
Exemple #26
0
def getResponseGraph(file):
    print "Read=", file
    i = 0
    g1 = TGraphErrors()
    for line in open(file, "r"):
        columns = line.split(',')
        pt = float(columns[0])
        pt_err = float(columns[1])
        sigma = float(columns[2])
        err = float(columns[3])
        g1.SetPoint(i, pt, sigma)
        ex = pt_err
        ey = err
        g1.SetPointError(i, ex, ey)
        i = i + 1

    g1.SetMarkerColor(1)
    g1.SetMarkerStyle(20)
    g1.SetMarkerSize(0.5)

    # g1->Print();
    return g1
Exemple #27
0
def getDeltaVarGraph(graph):

    #get number of points for the graph
    nPoints = graph.GetN()

    #prepare the final graph
    deltaVarGraph = TGraphErrors()
    deltaVarGraph.SetName(graph.GetName())

    #loop on points of the graphs
    for iPoint in xrange(0, nPoints):

        #retrieve the point
        dataPointX = Double(0)
        dataPointY = Double(0)
        errorX = graph.GetErrorX(iPoint)
        errorY = graph.GetErrorY(iPoint)
        graph.GetPoint(iPoint, dataPointX, dataPointY)

        #subtract unity and do the absolute value
        dataPointXDeltaVar = dataPointX
        dataPointYDeltaVar = abs(1 - dataPointY)
        errorXDeltaVar = errorX

        deltaVarGraph.SetPoint(iPoint, dataPointXDeltaVar, dataPointYDeltaVar)

        #being lazy (we will truncate the error if it goes below zero anyways)
        errorYDeltaVar = errorY

        #to calculate the error correctly
        #if dataPointY != 0 and (dataPointY-1) > 0 :
        #errorYDeltaVar = sqrt((dataPointY-1)/abs(dataPointY-1) * errorY) #this guarantees one does not go negative spitting an exception
        #else
        #one here would need to do a TGraphAsymmErrors with only the positive error in full

        deltaVarGraph.SetPointError(iPoint, errorXDeltaVar, errorYDeltaVar)

    return deltaVarGraph
Exemple #28
0
def HistToGraph(hist, xmin=None, xmax=None):
    """
    Build a graph from a histogram. Optionally one can set the bin ranges
    @param hist: Histogram to build the graph from
    @param xmin: Minimum x for the x-range of the points
    @param xmax: Maximum x for the x-range of the points  
    @return: A TGraphErrors created from the histogram
    """
    output = TGraphErrors()
    npoints = 0
    for mybin in range(1, hist.GetXaxis().GetNbins() + 1):
        if xmin and hist.GetXaxis().GetBinLowEdge(mybin) < xmin:
            continue
        if xmax and hist.GetXaxis().GetBinLowEdge(mybin) > xmax:
            break
        output.SetPoint(npoints,
                        hist.GetXaxis().GetBinCenter(mybin),
                        hist.GetBinContent(mybin))
        output.SetPointError(npoints,
                             hist.GetXaxis().GetBinWidth(mybin) / 2.,
                             hist.GetBinError(mybin))
        npoints = npoints + 1
    return output
Exemple #29
0
def GetData(file, scale=1., sed=True, title='SED', barUL=True):
    GetData.Ng += 1
    g = TGraphErrors(file)
    gUL = TGraphErrors()

    if sed:
        for i in range(g.GetN()):
            g.GetY()[i] = pow(g.GetX()[i], 2) * g.GetY()[i] * 1e-6 / scale
            g.GetEY()[i] = pow(g.GetX()[i], 2) * g.GetEY()[i] * 1e-6 / scale
            g.GetX()[i] *= 1e-3

    idel = 0
    nUL = 0
    while idel < g.GetN():
        if g.GetEY()[idel] < 0:
            gUL.SetPoint(nUL, g.GetX()[idel], g.GetY()[idel])
            if barUL:
                gUL.SetPointError(nUL, 0, g.GetY()[idel] * 1e-5)
            nUL += 1
            g.RemovePoint(idel)
        else:
            idel += 1

    if sed:
        g.SetTitle(title + ";Energy [GeV];E^{2}dN/dE [TeV cm^{-2} s^{-1}]")
    else:
        g.SetTitle(title + ";Energy [MeV];dN/dE [cm^{-2} s^{-1} MeV^{-1}]")

    g.SetLineColor(kRed)
    g.SetMarkerColor(kRed)
    g.SetMarkerStyle(20)
    g.SetName("g%d" % GetData.Ng)
    gUL.SetLineColor(g.GetLineColor())
    gUL.SetName("gUL%d" % GetData.Ng)

    return g, gUL
Exemple #30
0
 def _FitKuriePlot(self, centralList, kurieList, errorList):
     logger.debug("Fitter private method")
     kurieGraph = TGraphErrors()
     for i, KE in enumerate(centralList):
         kurieGraph.SetPoint(i, KE, kurieList[i])
         kurieGraph.SetPointError(i, 0, errorList[i])
     self.fitFunction = TF1("kurieFit", "[0]*([1]-x)*(x<[1]) + [2]",
                            centralList[0], centralList[-1], 3)
     self.fitFunction.SetParameters(kurieList[0] / (18600 - centralList[0]),
                                    18600, kurieList[-1])
     rootResults = kurieGraph.Fit(self.fitFunction, 'MERS')
     resultsDict = {
         "amplitude": rootResults.Parameter(0),
         "err_amplitude": rootResults.ParError(0),
         "endpoint": rootResults.Parameter(1),
         "err_endpoint": rootResults.ParError(1),
         "background": rootResults.Parameter(2),
         "err_background": rootResults.ParError(2),
         "chi2": rootResults.Chi2(),
         "ndf": rootResults.Ndf(),
         "p-value": rootResults.Prob()
     }
     logger.debug("Fit done")
     return resultsDict