Пример #1
0
def DoRooFit(histo, title):
    can = makeCMSCanvas(str(random.random()),"Fit result ",900,700)
    
    #Varible
    if "ele" in title:
      x1 = RooRealVar("x1","m_{e^{+}e^{-}}",80,100)
    if "mu" in title:
      x1 = RooRealVar("x1","m_{#mu^{+}#mu^{-}}",80,100)

    #Define CB function
    m = RooRealVar("mean_{CB}","mean of gaussian",60,120)
    s = RooRealVar("#sigma_{CB}","width of gaussian",0,3)
    a = RooRealVar("#alpha_{CB}","mean of gaussian",0,100)
    n = RooRealVar("n_{CB}","width of gaussian",0,5)
    CB = RooCBShape("CB","CB PDF",x1, m, s, a, n)
    
    m.setConstant(kFALSE)
    s.setConstant(kFALSE)
    a.setConstant(kFALSE)
    n.setConstant(kFALSE)
    
    
    #Define Gaussian function
    mean1 = RooRealVar("mean_{G}","mean of gaussian",-60,60)
    sigma1 = RooRealVar("#sigma_{G}","width of gaussian",0,10)
    gauss1 = RooGaussian("gauss1","gaussian PDF",x1,mean1,sigma1)
    
    mean1.setConstant(kFALSE)
    sigma1.setConstant(kFALSE)
    
    #Starting values of the parameters
    mean1.setVal(1.0)
    sigma1.setVal(1.0)
    m.setVal(90.0)
    s.setVal(1.0)
    a.setVal(10.0)
    n.setVal(2.0)

    # Construct CB (x) gauss
    x1.setBins(10000, "cache")
    CBxG = RooFFTConvPdf("CBxG", "CB (X) gauss", x1, CB, gauss1)
    
    can.cd()
    d = RooDataHist("d","d",RooArgList(x1),RooFit.Import(histo))
    CBxG.fitTo(d, RooLinkedList())
   
    # Plot PDF and toy data overlaid
    xframe2 = x1.frame(RooFit.Name("xframe"),RooFit.Title("")) # RooPlot
    d.plotOn(xframe2, RooLinkedList() )
    CBxG.paramOn(xframe2, RooFit.Layout(0.65,0.99,0.9))
    xframe2.getAttText().SetTextSize(0.03)
    CBxG.plotOn(xframe2)
    xframe2.Draw()
    can.SaveAs("DataVsMC/FitResults/"+title+"_Roofit.pdf")
    can.SaveAs("DataVsMC/FitResults/"+title+"_Roofit.png")
    
    return;
Пример #2
0
    def fit(self):
        sim_pdf = RooSimultaneous("simPdf", "simultaneous pdf", self.sample)
        self.individual_results = {}
        for name, model in self.models.iteritems():
            fit_input = self.fit_data[name]
            model.fitTo(fit_input.real_data_roofit_histogram())
            self.individual_results[name] = fit_input.get_results()
            sim_pdf.addPdf(model, name)

        argument_list = RooLinkedList()
        argument_list.Add(RooFit.Minimizer("Minuit2", "Migrad"))
        argument_list.Add(RooFit.NumCPU(1))
        argument_list.Add(RooFit.Extended())
        argument_list.Add(RooFit.Save())

        sim_pdf.fitTo(self.comb_data,
                      #                        argument_list
                      )

        #         sim_pdf.fitTo( self.combined_data,
        #                        RooFit.Minimizer( "Minuit2", "Migrad" ) )

        #         sim_pdf.fitTo( data = self.combined_data,
        #                        arg1 = RooFit.Minimizer( "Minuit2", "Migrad" ),
        #                        arg2 = RooFit.NumCPU( 1 ),
        #                        arg3 = RooFit.Extended(),
        #                        arg4 = RooFit.Save() )
        #         sim_pdf.fitTo( self.combined_data,
        #                        argument_list )

        # get fit results
        results = {}
        for variable, fit_input in self.fit_data.iteritems():
            results[variable] = fit_input.get_results()
        self.results = results
        return results
Пример #3
0
        RooFit.Timer(),
        RooFit.Save(),
        RooFit.Strategy(config['FitConfig']['Strategy']),
        RooFit.Optimize(config['FitConfig']['Optimize']),
        RooFit.Offset(config['FitConfig']['Offset']),
        RooFit.NumCPU(config['FitConfig']['NumCPU'])
    ]

    # set up blinding for data
    fitopts.append(
        RooFit.Verbose(not (config['IsData'] and config['Blinding'])))
    if config['IsData'] and config['Blinding']:
        from ROOT import RooMsgService
        RooMsgService.instance().setGlobalKillBelow(RooFit.WARNING)
        fitopts.append(RooFit.PrintLevel(-1))
    fitOpts = RooLinkedList()
    for o in fitopts:
        fitOpts.Add(o)

    # fit
    rawfitresult = fitpdf['pdf'].fitTo(tupleDataSet, fitOpts)

    # pretty-print the result
    from B2DXFitters.FitResult import getDsHBlindFitResult
    result = getDsHBlindFitResult(config['IsData'], config['Blinding'],
                                  rawfitresult)
    print result
    '''
    doubleCanvas = TCanvas();
        
    frameList = []
Пример #4
0
    setConstantIfSoConfigured(fitconfig, fitpdf['pdf'])

    # set up fitting options
    fitopts = [ RooFit.Timer(), RooFit.Save(),
                RooFit.Strategy(fitconfig['FitConfig']['Strategy']),
                RooFit.Optimize(fitconfig['FitConfig']['Optimize']),
                RooFit.Offset(fitconfig['FitConfig']['Offset']),
                RooFit.NumCPU(fitconfig['FitConfig']['NumCPU']) ]

    # set up blinding for data
    fitopts.append(RooFit.Verbose(not (fitconfig['IsData'] and fitconfig['Blinding'])))
    if fitconfig['IsData'] and fitconfig['Blinding']:
        from ROOT import RooMsgService
        RooMsgService.instance().setGlobalKillBelow(RooFit.WARNING)                                                                                                                             
        fitopts.append(RooFit.PrintLevel(-1))
    fitOpts = RooLinkedList()
    for o in fitopts: fitOpts.Add(o)
    
    # fit
    rawfitresult = fitpdf['pdf'].fitTo(ds1, fitOpts)
    #p0End = rawfitresult.floatParsFinal().find('Bs2DsPi_mistagcalib_p0');
    #p1End = rawfitresult.floatParsFinal().find('Bs2DsPi_mistagcalib_p1');
    genEtaList.AddLast(rawfitresult.floatParsFinal().find('eta'));
    '''print "\n\n\nbleah\n",rawfitresult.floatParsFinal().Print(),"\n\nboh\n\n\n\n";
    '''
    # pretty-print the result
    from B2DXFitters.FitResult import getDsHBlindFitResult
    result = getDsHBlindFitResult(fitconfig['IsData'], fitconfig['Blinding'],
        rawfitresult)
    print 'RESULT',result
    rawfitresult.floatParsFinal().Print()
Пример #5
0
def plot(pad,
         w,
         pdfname,
         dsetname,
         resid=False,
         cat=None,
         popts=None,
         dopts=None):

    if cat:
        if cat.startswith('b0_'): cat = cat.replace('b0_', '')
        if cat.startswith('bs_'): cat = cat.replace('bs_', '')

    xtitle = {
        'b0g': '#it{m}(' + rt.Dzb + rt.g + rt.Kp + rt.pim + ') [MeV/c^{2}]',
        'b0pi0':
        '#it{m}(' + rt.Dzb + rt.piz + rt.Kp + rt.pim + ') [MeV/c^{2}]',
        'bsg': '#it{m}(' + rt.Dzb + rt.g + rt.Km + rt.pip + ') [MeV/c^{2}]',
        'bspi0': '#it{m}(' + rt.Dzb + rt.piz + rt.Km + rt.pip + ') [MeV/c^{2}]'
    }
    leg = {
        'b0g':
        '#it{B}^{0} #rightarrow #bar{#it{D}}^{0}#it{#gamma}#it{K}^{+}#it{#pi}^{-}',
        'b0pi0':
        '#it{B}^{0} #rightarrow #bar{#it{D}}^{0}#it{#pi}^{0}#it{K}^{+}#it{#pi}^{-}',
        'bsg':
        '#it{B_{s}}^{#kern[-0.2]{0}} #rightarrow #bar{#it{D}}^{0}#it{#gamma}#it{K}^{-}#it{#pi}^{+}',
        'bspi0':
        '#it{B_{s}}^{#kern[-0.2]{0}} #rightarrow #bar{#it{D}}^{0}#it{#pi}^{0}#it{K}^{-}#it{#pi}^{+}'
    }

    if not popts: popts = RooLinkedList()
    if not dopts: dopts = RooLinkedList()

    pl = w.var('B_DTFDict_D0_B_M').frame()
    if cat: pl.GetXaxis().SetTitle(xtitle[cat])
    if w.data(dsetname): w.data(dsetname).plotOn(pl, dopts)
    if w.pdf(pdfname): w.pdf(pdfname).plotOn(pl, popts)
    if resid and w.data(dsetname) and w.pdf(pdfname):
        pu = TPad(pad.GetName() + '_pu', '', 0., 0.33, 1., 1.)
        pd = TPad(pad.GetName() + '_pd', '', 0., 0., 1., 0.33)
        pu.SetBottomMargin(0.03)
        pd.SetTopMargin(0.03)
        pd.SetBottomMargin(0.35)
        pad.cd()
        pu.Draw()
        pd.Draw()
        pu.cd()
        pl.GetYaxis().SetTitleOffset(1.1)
        pl.GetXaxis().SetLabelSize(0.)
        pl.Draw()
        pd.cd()
        pull = pl.pullHist()
        # roofit does something funny with pull hist range so need a dummy hist for it
        pull.Draw()
        ymax = max(abs(pull.GetYaxis().GetXmin()), pull.GetYaxis().GetXmax())
        pulld = TH1F(pull.GetName() + '_pd', '', pl.GetNbinsX(),
                     pl.GetXaxis().GetXmin(),
                     pl.GetXaxis().GetXmax())
        pulld.GetYaxis().SetRangeUser(-ymax, ymax)
        pulld.GetXaxis().SetTitle(pl.GetXaxis().GetTitle())
        pulld.GetYaxis().SetTitle("Pull")
        pl.GetXaxis().SetTitle("")
        pulld.GetXaxis().SetTitleSize(0.13)
        pulld.GetYaxis().SetTitleSize(0.13)
        pulld.GetXaxis().SetLabelSize(0.13)
        pulld.GetYaxis().SetLabelSize(0.13)
        pulld.GetXaxis().SetTitleOffset(1.1)
        pulld.GetYaxis().SetTitleOffset(0.6)
        pulld.GetYaxis().SetNdivisions(505)
        pulld.GetXaxis().SetTickLength(0.06)
        ll = TLine()
        ll.SetLineWidth(4)
        ll.SetLineColor(4)
        pd.cd()
        pd.Clear()
        pulld.Draw("HIST")
        pull.Draw("EPsame")
        ll.DrawLine(pulld.GetXaxis().GetXmin(), 0.,
                    pulld.GetXaxis().GetXmax(), 0.)
        pulld.Draw("AXISsame")
        gROOT.Append(pulld)
    else:
        pad.cd()
        pl.Draw()

    pad.cd()
    if cat:
        lat = TLatex()
        lat.SetTextSize(0.05)
        lat.SetNDC()
        lat.DrawLatex(0.6, 0.8, leg[cat])
        gROOT.Append(lat)
    pad.Update()
    pad.Modified()
Пример #6
0
    def fit(self):
        fit_variable = RooRealVar("fit_variable", "fit_variable",
                                  self.fit_boundaries[0],
                                  self.fit_boundaries[1])
        fit_variable.setBins(self.histograms[self.data_label].nbins())
        variables = RooArgList()
        variables.add(fit_variable)
        variable_set = RooArgSet()
        variable_set.add(fit_variable)

        roofit_histograms = {}
        roofit_pdfs = {}
        roofit_variables = {}

        N_min = 0.
        N_max = self.normalisation[self.data_label] * 2.
        pdf_arglist = RooArgList()
        variable_arglist = RooArgList()

        roofit_histograms[self.data_label] = RooDataHist(
            self.data_label, self.data_label, variables,
            self.histograms[self.data_label])
        for sample in self.samples:
            roofit_histogram = RooDataHist(sample, sample, variables,
                                           self.histograms[sample])
            roofit_histograms[sample] = roofit_histogram
            roofit_pdf = RooHistPdf('pdf' + sample, 'pdf' + sample,
                                    variable_set, roofit_histogram)
            roofit_pdfs[sample] = roofit_pdf
            roofit_variable = RooRealVar(sample, sample + " events",
                                         self.normalisation[sample], N_min,
                                         N_max)
            roofit_variables[sample] = roofit_variable
            pdf_arglist.add(roofit_pdf)
            variable_arglist.add(roofit_variable)

        model = RooAddPdf('model', 'sum of all known', pdf_arglist,
                          variable_arglist)
        use_model = model
        if self.constraints:
            arg_set = RooArgSet(model)
            constraints = self.get_fit_normalisation_constraints(
                model, roofit_variables)
            for constraint in constraints:
                arg_set.add(constraint)
            model_with_constraints = RooProdPdf(
                "model_with_constraints", "model  with gaussian constraints",
                arg_set, RooLinkedList())
            use_model = model_with_constraints

        if self.method == 'TMinuit':
            #WARNING: number of cores changes the results!!!
            self.saved_result = use_model.fitTo(
                roofit_histograms[self.data_label],
                RooFit.Minimizer("Minuit2", "Migrad"),
                RooFit.NumCPU(1),
                RooFit.Extended(),
                RooFit.Save(),
            )

        results = {}
        for sample in self.samples:
            results[sample] = (roofit_variables[sample].getVal(),
                               roofit_variables[sample].getError())
        self.results = results
Пример #7
0
tot = RooAddPdf("tot", "g+cheb", RooArgList(signal, bkg),
                RooArgList(nSig, nBkg))

mean.setVal(phimean)
gamma.setConstant(ROOT.kTRUE)
mean.setConstant(ROOT.kTRUE)

rfit = tot.fitTo(b0dataNonPrompt, Range(massmin, massmax), RooFit.NumCPU(8))
mean.setConstant(ROOT.kFALSE)
rfit = tot.fitTo(b0dataNonPrompt, Range(massmin, massmax), RooFit.NumCPU(8))
gamma.setConstant(ROOT.kFALSE)
rfit = tot.fitTo(b0dataNonPrompt, Range(phimean - 0.025, phimean + 0.025),
                 RooFit.NumCPU(8))

masskkFrame = masskk.frame(Range(phimean - 0.025, phimean + 0.025))
b0dataNonPrompt.plotOn(massFrame, RooLinkedList())
tot.plotOn(masskkFrame)

massFrame.Draw()
c.SaveAs("testmassFit.png")

cD = TCanvas("cD", "cD", 750, 600)
cD.cd()
splot = RooStats.SPlot("sPlot", "sPlot", b0dataNonPrompt, tot,
                       RooArgList(nSig, nBkg))

# In[18]:

dstree = b0dataNonPrompt.store().tree()

# In[19]:
Пример #8
0

# In[10]:


alldata.numEntries()
c = TCanvas("canvas","canvas",1200,800)

massFrame = mass.frame()
alldata.plotOn(massFrame)

massFrame.Draw()
c.SaveAs("plots/testmass.png")

massKKFrame = masskk.frame(Range(phimin,phimax))
alldata.plotOn(massKKFrame,RooLinkedList())

massKKFrame.Draw()
c.SaveAs("plots/testmasskk.png")


# In[11]:


#b0dataNonPromptMass = b0dataNonPrompt.reduce(SelectVars(RooArgSet(mass)))


# In[12]:


sigma1 = RooRealVar("sigma1","width of gaussian1",0.002,0.0005,0.05);
def get_fitted_normalisation_from_ROOT(channel, input_files, variable,
                                       met_type, b_tag_bin):
    results = {}
    initial_values = {}
    templates = {}

    for variable_bin in variable_bins_ROOT[variable]:
        histograms = get_histograms(channel,
                                    input_files,
                                    variable=variable,
                                    met_type=met_type,
                                    variable_bin=variable_bin,
                                    b_tag_bin=b_tag_bin,
                                    rebin=measurement_config.rebin)
        # create signal histograms
        h_eta_signal = histograms['TTJet'] + histograms['SingleTop']

        N_ttbar_before_fit = histograms['TTJet'].Integral()
        N_SingleTop_before_fit = histograms['SingleTop'].Integral()
        N_vjets_before_fit = histograms['V+Jets'].Integral()
        N_qcd_before_fit = histograms['QCD'].Integral()
        N_signal_before_fit = N_ttbar_before_fit + N_SingleTop_before_fit

        N_ttbar_error_before_fit = sum(histograms['TTJet'].errors())
        N_SingleTop_error_before_fit = sum(histograms['SingleTop'].errors())
        N_vjets_error_before_fit = sum(histograms['V+Jets'].errors())
        N_QCD_error_before_fit = sum(histograms['QCD'].errors())

        if (N_SingleTop_before_fit != 0):
            TTJet_SingleTop_ratio = N_ttbar_before_fit / N_SingleTop_before_fit
        else:
            print 'Bin ', variable_bin, ': ttbar/singleTop ratio undefined for %s channel! Setting to 0.' % channel
            TTJet_SingleTop_ratio = 0

        leptonAbsEta = RooRealVar("leptonAbsEta", "leptonAbsEta", 0., 2.4)
        # this has to move to dps.utils.Fitting.py
        vars = RooArgList()
        vars.add(leptonAbsEta)
        vars_set = RooArgSet()
        vars_set.add(leptonAbsEta)
        n_event_obs = histograms['data'].Integral()

        lowerBound = 0.
        upperBound = n_event_obs + 10 * sqrt(n_event_obs)
        n_init = n_event_obs / 2.

        data = RooDataHist("data", "dataset with leptonAbsEta", vars,
                           histograms['data'])
        rh_vj = RooDataHist("rh_vj", "vj", vars, histograms['V+Jets'])
        rh_qcd = RooDataHist("rh_qcd", "qcd", vars, histograms['QCD'])
        rh_signal = RooDataHist("rh_signal", "signal", vars, h_eta_signal)

        pdf_vj = RooHistPdf("pdf_vj", "V+Jets pdf", vars_set, rh_vj, 0)
        pdf_qcd = RooHistPdf("pdf_qcd", "QCD pdf ", vars_set, rh_qcd, 0)
        pdf_signal = RooHistPdf("pdf_signal", "single top pdf", vars_set,
                                rh_signal, 0)

        # RooRealVar(const char *name, const char *title, Double_t value, Double_t minValue, Double_t maxValue, const char *unit) :
        nSignal = RooRealVar("nSignal", "number of single top + ttbar events",
                             N_signal_before_fit, lowerBound, upperBound,
                             "event")
        nvj = RooRealVar("nvj", "number of V+Jets bgnd events",
                         N_vjets_before_fit, lowerBound, upperBound, "event")
        nqcd = RooRealVar("nqcd", "number of QCD bgnd events",
                          N_QCD_error_before_fit, lowerBound, upperBound,
                          "event")

        model = RooAddPdf("model", "sig+vj+qcd",
                          RooArgList(pdf_signal, pdf_vj, pdf_qcd),
                          RooArgList(nSignal, nvj, nqcd))
        vj_constraint = RooGaussian("nvj_constraint", "nvj_constraint", nvj,
                                    RooFit.RooConst(N_vjets_before_fit),
                                    RooFit.RooConst(0.5 * N_vjets_before_fit))
        qcd_constraint = RooGaussian("nqcd_constraint", "nqcd_constraint",
                                     nqcd, RooFit.RooConst(N_qcd_before_fit),
                                     RooFit.RooConst(2 * N_qcd_before_fit))
        model_with_constraints = RooProdPdf(
            "model_with_constraints", "model with gaussian constraints",
            RooArgSet(model, vj_constraint, qcd_constraint), RooLinkedList())
        model_with_constraints.fitTo(data, RooFit.Minimizer(
            "Minuit2",
            "Migrad"))  #WARNING: number of cores changes the results!!!
        #         nll = model.createNLL(data, RooFit.NumCPU(2))
        #         RooMinuit(nll).migrad()
        #         frame1 = nSignal.frame(RooFit.Bins(100), RooFit.Range(lowerBound, n_event_obs), RooFit.Title("LL and profileLL in nSignal"))
        #         nll.plotOn(frame1, RooFit.ShiftToZero())
        #         frame2 = nvj.frame(RooFit.Bins(100), RooFit.Range(lowerBound, n_event_obs), RooFit.Title("LL and profileLL in nvj"))
        #         nll.plotOn(frame2, RooFit.ShiftToZero())
        #         frame3 = nqcd.frame(RooFit.Bins(100), RooFit.Range(lowerBound, n_event_obs), RooFit.Title("LL and profileLL in nqcd"))
        #         nll.plotOn(frame3, RooFit.ShiftToZero())
        #
        #         pll_nSignal = nll.createProfile(nSignal)
        #         pll_nSignal.plotOn(frame1, RooFit.LineColor(2))
        #         frame1.SetMinimum(0)
        #         frame1.SetMaximum(3)
        #
        #         pll_nvj = nll.createProfile(nvj)
        #         pll_nvj.plotOn(frame2, RooFit.LineColor(2))
        #         frame2.SetMinimum(0)
        #         frame2.SetMaximum(3)
        #
        #         pll_nqcd = nll.createProfile(nqcd)
        #         pll_nqcd.plotOn(frame3, RooFit.LineColor(2))
        #         frame3.SetMinimum(0)
        #         frame3.SetMaximum(3)
        #         c = TCanvas("profilell","profilell",1200, 400)
        #         c.Divide(3)
        #         c.cd(1)
        #         frame1.Draw()
        #         c.cd(2)
        #         frame2.Draw()
        #         c.cd(3)
        #         frame3.Draw()
        #         c.SaveAs('profileLL.png')
        #         model.fitTo(data, RooFit.Minimizer("Minuit2", "Migrad"), RooFit.NumCPU(1))#WARNING: number of cores changes the results!!!
        fit_results = {}
        fit_results['signal'] = (nSignal.getVal(), nSignal.getError())
        fit_results['QCD'] = ufloat(nqcd.getVal(), nqcd.getError())
        fit_results['V+Jets'] = ufloat(nvj.getVal(), nvj.getError())

        N_ttbar, N_SingleTop = decombine_result(fit_results['signal'],
                                                TTJet_SingleTop_ratio)
        fit_results['signal'] = ufloat(nSignal.getVal(), nSignal.getError())
        fit_results['TTJet'] = ufloat(N_ttbar)
        fit_results['SingleTop'] = ufloat(N_SingleTop)

        if results == {}:  # empty
            for sample in fit_results.keys():
                results[sample] = [fit_results[sample]]
        else:
            for sample in fit_results.keys():
                results[sample].append(fit_results[sample])

    return results, None, None
Пример #10
0
#mean.setValV(phimean)
gamma.setConstant(ROOT.kTRUE)
mean.setConstant(ROOT.kTRUE)

# In[ ]:

rfit = tot.fitTo(alldata, Range(phimin, phimax), RooFit.NumCPU(8))
mean.setConstant(ROOT.kFALSE)
rfit = tot.fitTo(alldata, Range(phimin, phimax), RooFit.NumCPU(8))
gamma.setConstant(ROOT.kFALSE)
rfit = tot.fitTo(alldata, Range(phimin, phimax), RooFit.NumCPU(8))

# In[ ]:

kkFrame = masskk.frame(Range(phimin, phimax))
alldata.plotOn(kkFrame, RooLinkedList())
tot.plotOn(kkFrame, RooFit.Normalization((nSig.getValV() + nBkg.getValV())))

kkFrame.Draw()
c.SaveAs("testmassPhiFit.png")

cD = TCanvas("cD", "cD", 750, 600)
cD.cd()
splot = RooStats.SPlot("sPlot", "sPlot", alldata, tot, RooArgList(nSig, nBkg))

# In[ ]:

dstree = alldata.store().tree()
dstree.GetEntryNumber(88)

# In[ ]:
Пример #11
0
event = 2

xTuple.SetBranchAddress("event", AddressOf(milk, 'price5'))
newfile = TFile("small.root", "recreate")
newtree = xTuple.CloneTree()
newtree.CopyEntries(xTuple)

newtree.Write()

sys.exit()

# In[16]:

file = TFile("newFile.root", "RECREATE")
canvas = TCanvas("canvas", "canvas", 1200, 1000)
mass = RooRealVar("xM", "M(#mu#mu#mu#mu)[GeV]", 5.15, 5.55)
trigger = RooRealVar("trigger", "trigger", 0.0, 10000)
vProb = RooRealVar("vProb", "vProb", -1.0, 1.0)
alldata = RooDataSet("alldata", "alldata", xTuple, RooArgSet(mass),
                     RooFormulaVar("vProb", "vProb", "vProb>0.01",
                                   RooArgList(vProb)))  #,cutFormula)
frame = mass.frame(Range(5.15, 5.55))
alldata.plotOn(frame, RooLinkedList())
alldata.Write()
frame.Draw()

# In[ ]:

canvas.SaveAs("testCanvas.eps")