Esempio n. 1
0
    def __draw(self):
        from ROOT import kDashed, kRed, kGreen, kBlue, kBlack
        from ROOT import TCanvas
        from ROOT import TPaveText
        self.__year_label = TPaveText(0.71, 0.72, 0.89, 0.85, "NDC")
        self.__year_label.SetFillColor(0)
        self.__year_label.AddText(self.__year)
        self.__year_label.SetBorderSize(0)

        obs = self.__masses.values()
        self.__canvas = TCanvas('wpv_canvas', 'wpv_canvas', len(obs) * 600, 533)
        for (p,o) in zip(self.__canvas.pads(len(obs)), obs):
            from P2VV.Utilities.Plotting import plot
            plot(p, o, pdf = self.__pdf, data = self._data
                 , dataOpts = dict(MarkerSize = 0.8, MarkerColor = kBlack, Binning = 50)
                 , pdfOpts  = dict(LineWidth = 2)
                 , plotResidHist = 'BX'
                 , xTitle = 'M_{#mu^{+}#mu^{-}} [MeV/c^{2}]'
                 , yTitle = 'Candidates / (%2.1f MeV/c^{2})' % ((o.getMax() - o.getMin()) / float(50))
                 , components = { 'wpv_bkg_*'   : dict( LineColor = kRed,   LineStyle = kDashed )
                                  , 'wpv_psi_*' : dict( LineColor = kGreen, LineStyle = kDashed )
                                  , 'wpv_sig_*' : dict( LineColor = kBlue,  LineStyle = kDashed )
                                  }
                 )
            self.__canvas.cd(1)
            self.__year_label.Draw()
            self.__canvas.Update()
        self.__draw_time()

        if self.__t_diff:
            self.__draw_t_diff()
Esempio n. 2
0
def splot( pdf, sdata ) :
    # switch off all yields, except current one
    from contextlib import contextmanager
    @contextmanager
    def __select_component( i, yields ):
        orig = dict( (j,j.getVal()) for j in yields )
        [ j.setVal(0) for j in orig.iterkeys() if j!=i ]
        try     : yield
        finally : [ j.setVal(v) for (j,v) in orig.iteritems() ]
    from ROOT import TCanvas, kDashed, kRed, kGreen, kBlue, kBlack
    canvas = TCanvas(pdf.GetName() + '_splot')
    obs = [ o for o in pdf.Observables() if hasattr(o,'frame') and o not in sdata.usedObservables() ]
    for (p,o) in zip( canvas.pads(len(obs)), obs ) :
        # select yields
        _yields = [ y for y in pdf.Parameters() if y.getAttribute('Yield') ]
        # loop over components
        for (pp,i) in zip( p.pads(1,len(_yields)), _yields ) :
            # switch off all yields, except current one
            with __select_component( i, _yields ) :
                # plot both weighed data and PDF
                # TODO: add the same color coding as above...
                c_name = i.GetName()[2:]
                c_opts = { 'signal'             : dict( LineColor = kGreen )
                         , 'psi_background'     : dict( LineColor = kRed )
                         , 'cmb_background'     : dict( LineColor = kBlue )
                         }
                from P2VV.Utilities.Plotting import plot
                plot( pp, o, sdata.data( c_name ), pdf, pdfOpts = c_opts[c_name] if c_name in c_opts else {})
    return canvas
Esempio n. 3
0
 def __draw_time(self):
     from ROOT import kDashed, kRed, kGreen, kBlue, kBlack
     from ROOT import TCanvas
     from itertools import product
     self.__time_canvases = []
     t = self.__time
     from P2VV.Utilities.Plotting import plot
     from ROOT import RooArgSet
     for logy, (c, shape) in product((True, False), self.__shapes.items()):
         cn = 'wpv_time_%s' % c.GetName()
         if logy: cn += '_log'
         p = TCanvas(cn, cn, 600, 400)
         self.__time_canvases.append(p)
         nBins = 80
         frame = plot(p, t, pdf = shape, data = self.__sdatas[c]
                      , frameOpts = dict(Title = c.GetName())
                      , dataOpts = dict(MarkerSize = 0.8, Binning = nBins, MarkerColor = kBlack)
                      , pdfOpts  = dict(LineWidth = 2)
                      , logy = logy, yScale = (1 if logy else 0, None)
                      , plotResidHist = False)[0]
         frame.GetXaxis().SetTitle('t [ps]')
         if logy:
             frame.GetYaxis().SetRangeUser(1, 7000 if self.__year == '2012' else 5000)
         frame.GetYaxis().SetTitle('Candidates / (%3.2f ps)' % ((t.getMax() - t.getMin()) / float(nBins)))
         self.__year_label.Draw()
         from P2VV.Utilities.Resolution import plot_dir
         p.Print(os.path.join(plot_dir, 'wpv_time_%s_%s_%s.pdf' % (c.GetName()[4:], self.__year, 'log' if logy else 'linear')), EmbedFonts = True)
Esempio n. 4
0
def Oldsplot( canv, sdata, pdf, frameOpts = dict(), dataOpts = dict() , pdfOpts = dict() ) :
    obs = [ o for o in pdf.Observables() if hasattr(o,'frame') and o not in sdata.usedObservables() ]
    for (p,o) in zip( canv.pads(len(obs)), obs ) :
        # snapshot yeilds
        _yields = dict( (p,p.getVal()) for p in pdf.Parameters() if p.getAttribute('Yield')  )
        # loop over components
        for (pp,i) in zip( p.pads(1,len(_yields)), _yields.iterkeys() ) :
            # switch off all yields, except current one
            for j in filter( lambda x: x!=i, _yields.iterkeys() ) : j.setVal(0)
            # and plot both weighed data and PDF
            from P2VV.Utilities.Plotting import plot
            c_name = i.GetName()[2:]
            if 'Title' not in frameOpts : frameOpts['Title'] =  '%s : %s' % ( c_name , o.GetTitle() )
            plot( pp, o, sdata.data( c_name ), pdf
                , pdfOpts = pdfOpts[c_name] if c_name in pdfOpts else {}
                , frameOpts = frameOpts
                , dataOpts = dataOpts
                )
            # and put back the original value!
            for (i,v) in _yields.iteritems() : i.setVal(v)
Esempio n. 5
0
 def __draw_t_diff(self):
     from ROOT import kDashed, kRed, kGreen, kBlue, kBlack
     from ROOT import TCanvas
     self.__diff_canvases = []
     t_diff = self.__t_diff
     from ROOT import RooArgSet
     for c, shape in self.__diff_shapes.iteritems():
         name = 'wpv_diff_%s' % c.GetName()
         canvas = TCanvas(name, name, 600, 400)
         p = canvas.cd()
         self.__diff_canvases.append(canvas)
         from P2VV.Utilities.Plotting import plot
         plot(p, t_diff, pdf = shape, data = self.__sdatas[c]
              , dataOpts = dict(MarkerSize = 0.8, Binning = 80, MarkerColor = kBlack)
              , pdfOpts  = dict(LineWidth = 2)
              , xTitle = 't_{rec} - t_{true} [ps]'
              , yTitle = 'Candidates / (12.5 fs)'
              , logy = False
              , plotResidHist = False)
         self.__year_label.Draw()
         from P2VV.Utilities.Resolution import plot_dir
         canvas.Print(os.path.join(plot_dir, 'wpv_tdiff_%s_%s_linear.pdf' % (c.GetName()[4:], self.__year)), EmbedFonts = True)
Esempio n. 6
0
def plot_mass(data, prefix = ''):
    nBins = 100
    from ROOT import kDashed, kRed, kGreen, kBlue, kBlack
    from ROOT import TCanvas
    mass_canvas = TCanvas('%smass_canvas' % prefix, '%smass_canvas' % prefix, 600, 530)
    __canvases.append(mass_canvas)
    from P2VV.Utilities.Plotting import plot
    frames = plot(mass_canvas, m, pdf = mass_pdf, data = data
                  , dataOpts = dict(MarkerSize = 0.8, MarkerColor = kBlack, Binning = nBins)
                  , pdfOpts  = dict(LineWidth = 2)
                  , frameOpts = dict(Title = dataSample)
                  , plotResidHist = True
                  , components = { 'bkg_*'     : dict( LineColor = kRed,   LineStyle = kDashed )
                                   , 'psi_*'  : dict( LineColor = kGreen, LineStyle = kDashed )
                                   , 'sig_*'     : dict( LineColor = kBlue,  LineStyle = kDashed )
                                   })
    
    frames[1].GetXaxis().SetTitle('M_{J/#psi K^{+}K^{-}} [MeV/c^2]')
    frames[0].GetYaxis().SetTitle('Candidates / (%3.2f MeV/c^2)' % ((m.getMax() - m.getMin()) / float(nBins)))
Esempio n. 7
0
canv = TCanvas( '%sCanv' % plotVar )
canv.SetLeftMargin(0.18)
canv.SetRightMargin(0.05)
canv.SetBottomMargin(0.18)
canv.SetTopMargin(0.05)

print 'makeProjectionPlot: plotting variable "%s" for component "%s"' % ( plotVar, plotComp )
binWidth = ( xMax - xMin ) / float( numBins[plotVar] ) / ( pi if plotVar == 'phi' else 1. )
from P2VV.Utilities.Plotting import plot
#redDataSet = dataSet.reduce( ArgSet = [ ws['time'], ws['helcosthetaK'], ws['helcosthetaL'], ws['helphi'] ] )
#plots = plot(  canv, obs, redDataSet, plotPdf
plots = plot(  canv, obs, dataSet, plotPdf
             , xTitle       = obsXTitles[plotVar]
             , yTitle       = obsYTitles[plotVar] % binWidth, logy = True if plotVar == 'timeLog' else False
             , xTitleOffset = xTitleOffset
             , yTitleOffset = yTitleOffsets[plotVar]
             , frameOpts    = dict( Range = rangeName, Bins = numBins[plotVar], Title = '' )
             , dataOpts     = dict( MarkerStyle = markStyle, MarkerSize = markSize, LineWidth = markLineWidth )
             , pdfOpts      = dict( LineColor = lineColor, LineWidth = lineWidth, LineStyle = lineStyle )
            )

from ROOT import TLatex
label = TLatex()
label.SetTextAlign(32)
label.SetTextSize(0.072)
drawLabel = label.DrawLatexNDC( LHCbCoords[plotVar][0], LHCbCoords[plotVar][1], LHCbLabel )
plotsFile.Add(drawLabel)

canv.Print(plotsFilePath)
from ROOT import TObject
plotsFile.Write( ROOTFilePath, TObject.kOverwrite )
         print '\n\nP2VV - INFO: Plotting decay time and angular distributions of ' + bin
         dataSlice = sigData.reduce('KKMassCat==KKMassCat::' + bin)
         pdfSlice  = pdfsDict[bin]['total']
         binIdx = binNames.index(bin)
         for ( pad, obs, nBins, xTitle, yScaleRel, logY )\
                 in zip(  [ TCanvas(o.GetName()+bin) for o in observables ]
                        , observables
                        , numBins
                        , ( observables[0].GetTitle()+' [ps]', angleNames[0][1], angleNames[1][1], angleNames[2][1] )
                        , 2 *(( 1., 1.2 ),) + 2 *(( 1. , 1.2 ),) 
                        , ( True, ) + 3 * ( False, )
                       ) :           
             plot(  pad, obs, dataSlice, pdfSlice, xTitle=xTitle, yScaleRel=yScaleRel, logy=logY
                  , frameOpts   = dict( Bins = nBins, Name = bin + obs.GetName() + 'Histo'      )
                  , dataOpts    = dict( MarkerStyle = markStyle, MarkerSize = markSize          )
                  , pdfOpts     = PDFoptsNOBin[bin] if obs==observables[0] else PDFoptsBin[bin]
                  , addPDFs     = [ pdfsDict[bin][c] for c in CPcomps ]
                  , addPDFsOpts = [addPDFotpsNOBin[binIdx][c] for c in CPcomps ] if obs==observables[0]\
                            else  [addPDFotpsBin[binIdx][c] for c in CPcomps ]
                   )
             lhcbName.Draw()
        ## print canvas to file
             fName =  bin + '_' + obs.GetName() + '_sFit.ps'
             pad.Print(fName)
                      
# Save all the plots in a root file as RooPlot objects.
from P2VV.Utilities.Plotting import _P2VVPlotStash as rooplots
from ROOT import TFile
plotsFile = TFile('RooPlots6x4.root','recreate')
for plot in rooplots: plot.Write()
plotsFile.Close()
Esempio n. 9
0
    from P2VV.Load import LHCbStyle
    from P2VV.Utilities.Plotting import plot
    from ROOT import TCanvas, kBlue, kRed, kGreen

    # plot efficiency
    effCanv = TCanvas( 'effCanv', 'Efficiency' )
    for ( pad, obs, func, norm, xTitle )\
            in zip(  effCanv.pads( 2, 2 )
                   , obsSet[ 1 : 4 ]
                   , [ effFuncCtk, effFuncCtl, effFuncPhi ]
                   , [ 1. / 4. / pi, 1. / 4. / pi, 1. / 4. ]
                   , angleNames
                  ) :
        plot(  pad, obs, None, func, addPDFs = [ effFunc ]
             , yScale      = ( 0.85, 1.15 )
             , pdfOpts     = dict( LineColor = kBlue, LineWidth = 2, Normalization = norm )
             , addPDFsOpts = [ dict( LineColor = kRed,  LineWidth = 2 ) ]
            )

    # plot lifetime and angles
    timeAnglesCanv = TCanvas( 'timeAnglesCanv', 'Lifetime and Decay Angles' )
    for ( pad, obs, nBins, plotTitle, xTitle )\
            in zip(  timeAnglesCanv.pads( 2, 2 )
                   , obsSet[ 1 : 4 ]
                   , numBins
                   , [ var.GetTitle() for var in obsSet[ 1 : 4 ] ]
                   , angleNames
                  ) :
        plot(  pad, obs, data, pdf, xTitle = xTitle
             , frameOpts   = dict( Bins = nBins, Title = plotTitle                )
             , dataOpts    = dict( MarkerStyle = markStyle, MarkerSize = markSize )
Esempio n. 10
0
    from ROOT import kDashed, kRed, kGreen, kBlue, kBlack, kOrange
    from ROOT import TCanvas

    if options.plot:
        mass_canvas = TCanvas('mass_canvas', 'mass_canvas', 600, 530)
        from P2VV.Utilities.Plotting import plot
        pdfOpts  = dict()
        if signal_MC:
            mass_obs = m
        else:
            mass_obs = mpsi
        
        ps = plot(mass_canvas.cd(), mass_obs, pdf = mass_pdf, data = data,
                  dataOpts = dict(MarkerSize = 0.8, MarkerColor = kBlack, Binning = 50),
                  pdfOpts  = dict(LineWidth = 2, **pdfOpts),
                  plotResidHist = 'BX',
                  xTitle = 'M_{#mu^{+}#mu^{-}} [MeV/c^{2}]',
                  yTitle = 'Candidates / (%3.2f MeV/c^{2})' % ((mass_obs.getMax() - mass_obs.getMin()) / 50),
                  yTitleOffset = 1 / 0.7)
        plots[''].append(ps)
        from P2VV.Utilities.Resolution import plot_dir
        if signal_MC:
            plot_name = 'prescaled_%s_B_mass.pdf'
        else:
            plot_name = 'prescaled_%s_Jpsi_mass.pdf'
        
        mass_canvas.Print(os.path.join(plot_dir, plot_name % args[0]), EmbedFonts = True)
        
    from P2VV.Utilities.SWeights import SData
    from P2VV.Utilities.DataHandling import correctWeights
    data_clone = data.Clone(data.GetName())
Esempio n. 11
0
    from P2VV.Load import LHCbStyle
    from P2VV.Utilities.Plotting import plot
    from ROOT import TCanvas

    # plot lifetime and angles
    timeAnglesCanv = TCanvas( 'timeAnglesCanv', 'Lifetime and Decay Angles' )
    for ( pad, obs, nBins, plotTitle, xTitle )\
            in zip(  timeAnglesCanv.pads( 2, 2 )
                   , observables[ : -1 ]
                   , numBins
                   , [ var.GetTitle() for var in observables[ : -1 ] ]
                   , ( '', ) + angleNames
                  ) :
        plot(  pad, obs, data, pdf, xTitle = xTitle
             , frameOpts = { 'Bins' : nBins, 'Title' : plotTitle }
             , dataOpts  = { 'MarkerStyle' : markStyle, 'MarkerSize' : markSize, 'XErrorSize' : 0 }
             , pdfOpts   = { 'LineWidth' : lineWidth }
            )

    # plot lifetime
    timePlotTitles = tuple( [ time.GetTitle() + str for str in (  ' - B (linear)'
                                                                , ' - B (logarithmic)'
                                                                , ' - #bar{B} (linear)'
                                                                , ' - #bar{B} (logarithmic)'
                                                               )
                            ] )
    timeCanv = TCanvas( 'timeCanv', 'Lifetime' )
    for ( pad, nBins, plotTitle, dataCuts, pdfCuts, logY )\
            in zip(  timeCanv.pads( 2, 2 )
                   , 2 * numTimeBins
                   , timePlotTitles
Esempio n. 12
0
    directory = '1bin_%4.2ffs_simple/%s' % (1000 * (t.getMax() - t.getMin()), hd)
    cache = Cache(input_data[years]['cache'].rsplit('/', 1), directory)
    data, sdatas = cache.read_data()
    if component == 'signal':
        data = single_bin_sig_sdata = sdatas['sig_sdata']
    else:
        data = single_bin_bkg_sdata = sdatas['bkg_sdata']

## Fit options
fitOpts = dict(NumCPU = 4, Timer = 1, Save = True,
               Verbose = False, Optimize = 2, Minimizer = 'Minuit2')

from P2VV.Parameterizations.SigmatPDFs import DoubleLogNormal
dln = DoubleLogNormal(st)
ln = dln.pdf()

# Fit
result = ln.fitTo(data, **fitOpts)

# Plot
from ROOT import TCanvas
canvas = TCanvas('canvas', 'canvas', 600, 400)
p = canvas.cd(1)
from P2VV.Utilities.Plotting import plot
from ROOT import kBlack, kBlue
plot(p, st, pdf = ln, data = data,
     dataOpts = dict(MarkerSize = 0.8, MarkerColor = kBlack, Binning = 60),
     pdfOpts  = dict(LineWidth = 3),
    xTitle = 'estimated decay-time error [ps]',
    yTitle = 'Candidates / (0.002 ps)')
Esempio n. 13
0
    for ( pad, func, angle, xTitle, yTitle, yScale, norm, nBins )\
        in zip(  canvs[ : 3 ]
               , effInts
               , angles
               , angleNames
               , effLabels
               , [ ( 0.88, 1.12 ), ( 0.9328, 1.1872 ), ( 0.88, 1.12 ) ]
               , [ 1. / 4. / pi, 1. / 4. / pi, 1. / 4. ]
               , numEffBins
              ) :
        pad.SetLeftMargin(0.28)
        plot(  pad, angle, weightedData, func
             , xTitle       = xTitle
             , yTitle       = yTitle
             , yScale       = yScale
             , yTitleOffset = 1.0
             , frameOpts    = dict( Title = angle.GetTitle(), Bins = nBins )
             , dataOpts     = dict( MarkerStyle = kFullDotLarge, MarkerSize = 0.9, LineWidth = 3
                                   , Rescale = norm * float(nBins) / ( angle.getMax() - angle.getMin() ) )
             , pdfOpts      = dict( LineColor = kBlue, LineWidth = 4, Normalization = norm )
            )
        LHCbText.Draw()

    if physPdf :
        # plot lifetime and angles
        canvs.append( TCanvas( 'ctkCanv',  'cos(theta_K)' ) )
        canvs.append( TCanvas( 'ctlCanv',  'cos(theta_l)' ) )
        canvs.append( TCanvas( 'phiCanv',  'phi'          ) )
        for ( pad, obs, nBins, plotTitle, xTitle )\
                in zip(  canvs[ -3 : ]
                       , obsSet[ 1 : 5 ]
                       , numDistrBins
Esempio n. 14
0
##Plot and Save
for ( pad, obs, nBins, xTitle, yTitle, yScale, logY )\
        in zip(  [ TCanvas(o.GetName()) for o in observables ]
               , observables
               , numBins
               , ( angleNames[0][1], angleNames[1][1], angleNames[2][1], 'B_{s}^{0} decay time [ps]' )
               , yTitles
               , 3 * ( ( None, 1400 ), ) + ( ( 0.1, 10e4 ), )
               , 3 * ( False, ) + ( True, )
                ) :
    print '\n\n\n Ploting Observable ' + obs.GetName() +  ' {0}/{1} '.format(observables.index(obs)+1, len(observables)) + '\n\n\n'
    plot(  pad, obs, sigData, pdf, xTitle=xTitle, yTitle=yTitle, yScale=yScale, logy=logY
           , frameOpts   = dict( Bins = nBins, Name = obs.GetName() + 'Histo'   )
           , dataOpts    = dict( MarkerStyle = markStyle, MarkerSize = markSize )
           , pdfOpts     = CpPlotsKit.getPdfOpts(BinData=False) if 'time' in obs.GetName()\
                      else CpPlotsKit.getPdfOpts(BinData=True )
           , addPDFs     = CpPlotsKit.getAddPdfs()
           , addPDFsOpts = CpPlotsKit.getAddPdfsOpts(BinData=False) if 'time' in obs.GetName()\
                      else CpPlotsKit.getAddPdfsOpts(BinData=True )
           )
    lhcbName.Draw()
    filename = obs.GetName() + '_sFit.ps'
    pad.Print(filename)

#Save all the plots in a root file as RooPlot objects.
from P2VV.Utilities.Plotting import _P2VVPlotStash as rooplots
from ROOT import TFile
plotsFile = TFile('RooPlotsFinal.root','recreate')
for plot in rooplots: plot.Write()
plotsFile.Close()
Esempio n. 15
0
           , angles
           , xLabels
           , yLabels[0]
           , [ ( 0.84, 1.08 ), ( 0.96, 1.20 ), ( 0.86, 1.10 ) ] if not transAngles\
             else [ ( 1.01, 1.25 ), ( 0.96, 1.20 ), ( 0.97, 1.21 ) ]
          ) :
    pad.SetLeftMargin(0.28)
    pad.SetRightMargin(0.05)
    pad.SetBottomMargin(0.18)
    pad.SetTopMargin(0.05)
    plot(  pad, angle, None, momFunc
         #, addPDFs      = [ momFunc1, momFunc2 ]
         , xTitle       = xTitle
         , yTitle       = yTitle
         , yScale       = yScale
         , xTitleOffset = 1.1
         , yTitleOffset = 1.0
         , frameOpts    = dict( Title = angle.GetTitle() )
         , pdfOpts      = dict( LineColor = kBlue, LineWidth = 3 )
         #, addPDFsOpts  = [ dict( LineColor = kRed, LineWidth = 3 ), dict( LineColor = kGreen + 2, LineWidth = 3 ) ]
        )
    if LHCbLabel : LHCbText.Draw()

# plot efficiency function integrals
from ROOT import RooArgSet
canvs += [  TCanvas( 'cpsiIntCanv',   'Angular Efficiency' )
          , TCanvas( 'cthetaIntCanv', 'Angular Efficiency' )
          , TCanvas( 'phiIntCanv',    'Angular Efficiency' )
         ]
integrals = [  momFunc.createIntegral( RooArgSet( angles[1]._var, angles[2]._var ) )
             , momFunc.createIntegral( RooArgSet( angles[0]._var, angles[2]._var ) )
Esempio n. 16
0
    g.GetYaxis().SetRangeUser(-0.12, 0)
    
    from ROOT import kBlue
    l.SetLineColor(kBlue)
    l.Draw('same')
    year_label.Draw()

    plot_name = 'mean_res_st_ttrue_' + args[0][pos : -5] + '.pdf'
    canvas.Print(os.path.join(plot_dir, plot_name), EmbedFonts = True)
else:
    from ROOT import kGreen, kDashed
    from P2VV.Utilities.Plotting import plot
    from ROOT import TCanvas

    for i in range(3):
        result = model.fitTo(sdata, SumW2Error = False, **fitOpts)
        if result.status() == 0 and abs(result.minNll()) < 5e5:
            break

    canvas = TCanvas("canvas", "canvas", 600, 400)
    plot(canvas, t_diff_st, pdf = model, data = sdata, logy = True,
         frameOpts = dict(Range = (-20, 20)),     
         yTitle = 'Candidates / (0.5)', dataOpts = dict(Binning = 80),
         xTitle = '(t - t_{true}) / #sigma_{t}',
         yScale = (1, 400000),
         pdfOpts = dict(ProjWData = (RooArgSet(st), sdata, True)),
         components = {'gexps' : dict(LineColor = kGreen, LineStyle = kDashed)})
    year_label.Draw()
    plot_name = 'tdiff_sigmat_' + args[0][pos : -5] + '.pdf'
    canvas.Print(os.path.join(plot_dir, plot_name), EmbedFonts = True)
Esempio n. 17
0
if makePlots :
    # import ROOT plot style
    from P2VV.Load import LHCbStyle

    # create canvas
    from ROOT import TCanvas
    anglesCanv = TCanvas( 'anglesCanv', 'Angles' )

    # make plots
    from P2VV.Utilities.Plotting import plot
    from ROOT import RooFit, RooCmdArg
    for ( pad, obs, nBins, plotTitle, xTitle ) in zip(  anglesCanv.pads(2, 2)
                                                      , angles
                                                      , numBins
                                                      , tuple( [ angle.GetTitle() for angle in angles ] )
                                                      , angleTitles
                                                     ) :
        plot(  pad, obs, data, momPDF0, xTitle = xTitle, addPDFs = [ momPDF1, momPDF, coefPDF, pdf ]
             , frameOpts   = dict( Bins = nBins, Title = plotTitle )
             , dataOpts    = dict( MarkerStyle = markStyle, MarkerSize = markSize )
             , pdfOpts     = dict( LineWidth = lineWidth, LineColor = RooFit.kBlack )
             , addPDFsOpts = [  dict( LineWidth = lineWidth, LineColor = RooFit.kGreen + 2 )
                              , dict( LineWidth = lineWidth, LineColor = RooFit.kMagenta   )
                              , dict( LineWidth = lineWidth, LineColor = RooFit.kRed       )
                              , dict( LineWidth = lineWidth, LineColor = RooFit.kBlue      )
                             ]
            )

    anglesCanv.Print(plotsFile)
Esempio n. 18
0
from ROOT import TCanvas
canvs = [  TCanvas( 'bkgAngles1D_ctk' )
         , TCanvas( 'bkgAngles1D_ctl' )
         , TCanvas( 'bkgAngles1D_phi' )
         , TCanvas( 'bkgAngles2D_ctk_ctl' )
         , TCanvas( 'bkgAngles2D_ctk_phi' )
         , TCanvas( 'bkgAngles2D_phi_ctl' )
        ]

# plot background angles
from P2VV.Utilities.Plotting import plot
from ROOT import kBlue
for ( name, canv ) in zip( [ 'cpsi', 'ctheta', 'phi' ], canvs[ : 3 ] ) :
    plot(  canv, observables[name], cbkgData, cbkgAnglePDF, xTitle = angleTitles[name], yTitleOffset = 1.5
         , frameOpts  = dict( Bins = nBins[name], Title = observables[name].GetTitle() )
         , dataOpts   = dict( MarkerStyle = 8, MarkerSize = 0.4 )
         , pdfOpts    = dict( LineColor = kBlue, LineWidth = 3  )
        )

# plot 2-D angular distributions
from P2VV.Utilities.Plotting import _P2VVPlotStash
for angle0, angle1, canv in [ ( 'ctheta', 'cpsi', canvs[3] ), ( 'phi', 'cpsi', canvs[4] ), ( 'ctheta', 'phi', canvs[5] ) ] :
    bkgAngHist = cbkgData.createHistogram( observables[angle0]._var, observables[angle1]._var, nBins[angle0], nBins[angle1] )
    _P2VVPlotStash.append(bkgAngHist)
    bkgAngHist.SetStats(False)
    bkgAngHist.SetTitle( '%s vs. %s' % ( angleTitles[angle0], angleTitles[angle1] ) )
    bkgAngHist.SetMinimum(0.)
    bkgAngHist.GetXaxis().SetTitle( angleTitles[angle0] )
    bkgAngHist.GetYaxis().SetTitle( angleTitles[angle1] )
    bkgAngHist.GetXaxis().SetLabelOffset(0.01)
    bkgAngHist.GetYaxis().SetLabelOffset(0.008)
Esempio n. 19
0
canvsOS = [ TCanvas( 'estWTagCanvOS%d' % it ) for it in range(3) ]
for ( canv, data, nBins, norm ) in zip(  canvsOS
                                      , [ fullData, sigData, cbkgData ]
                                      , 3 * [ numEstWTagBins ]
                                      , [ 1. - untagFracOS, 1. - untagFracSigOS, 1. - untagFracBkgOS ]
                                     ) :
    canv.SetLeftMargin(0.18)
    canv.SetRightMargin(0.05)
    canv.SetBottomMargin(0.18)
    canv.SetTopMargin(0.05)
                                                                                                                     
    #plot(  canv, estWTagOS, data, tagPdfOS
    plot(  canv, estWTagOS,  data, yScale = ( 0., None ), xTitleOffset = 1.10, yTitleOffset = 1.15
         , xTitle     = '#eta^{OS}'
         , yTitle     = 'Candidates / %.2f' % ( 0.499999 / float(nBins) )
         , frameOpts  = dict( Bins = nBins, Range = ( 0., 0.499999 ), Name = estWTagOS.GetName() )
         , dataOpts   = dict( MarkerStyle = kFullDotLarge, MarkerSize = 0.7, LineWidth = 3 )
         #, pdfOpts    = dict( LineColor = kBlue, LineWidth = 3, Normalization = norm )
        )

canvsSS = [ TCanvas( 'estWTagCanvSS%d' % it ) for it in range(3) ]
for ( canv, data, nBins, norm ) in zip(  canvsSS
                                      , [ fullData, sigData, cbkgData ]
                                      , 3 * [ numEstWTagBins ]
                                      , [ 1. - untagFracSS, 1. - untagFracSigSS, 1. - untagFracBkgSS ]
                                     ) :
    canv.SetLeftMargin(0.18)
    canv.SetRightMargin(0.05)
    canv.SetBottomMargin(0.18)
    canv.SetTopMargin(0.05)
                                                                                                                     
Esempio n. 20
0
                break
        assert(mass_result.status() == 0)

        # Plot mass pdf
        from ROOT import kDashed, kRed, kGreen, kBlue, kBlack
        from ROOT import TCanvas
        canvas = TCanvas('mass_canvas', 'mass_canvas', 600, 530)
        obs = [m]
        for (p,o) in zip(canvas.pads(len(obs)), obs):
            from P2VV.Utilities.Plotting import plot
            pdfOpts  = dict()
            plot(p, o, pdf = mass_pdf, data = data
                 , dataOpts = dict(MarkerSize = 0.8, MarkerColor = kBlack)
                 , pdfOpts  = dict(LineWidth = 2, **pdfOpts)
                 , plotResidHist = True
                 , components = { 'bkg_*'     : dict( LineColor = kRed,   LineStyle = kDashed ),
                                  ## 'psi_*'  : dict( LineColor = kGreen, LineStyle = kDashed ),
                                  'sig_*'     : dict( LineColor = kBlue,  LineStyle = kDashed )
                                  }
                 )
        # Do the sWeights
        # make sweighted dataset. TODO: use mumu mass as well...
        from P2VV.Utilities.SWeights import SData

        for p in mass_pdf.Parameters() : p.setConstant( not p.getAttribute('Yield') )
        splot = SData(Pdf = mass_pdf, Data = data, Name = 'MassSplot')
        data = splot.data('signal')
        ## psi_sdata = splot.data('psi_background')
        bkg_sdata = splot.data('background')

        if 'MC' in args[0]: