def generate_testfiles(): h = TH1D("gaussian_hist", "Gaussian histgram", 100, -3, 3) h.FillRandom("gaus", 1000) file = TFile( os.path.dirname(__file__) + ('/../testfiles/root_testfiles.root'), 'RECREATE') file.cd() h.Write() x = RooRealVar("D0_M", "m(K_{S}^{0}K^{+}K^{-})", 1860, 1800, 1930, "\\mathrm{MeV}/c^{2}") x.setBins(130) m1 = RooRealVar("m1", "mean 1", 1864, 1860, 1870) s1 = RooRealVar("s1", "sigma 1", 2, 0, 5) g1 = RooGaussian("g1", "Gaussian 1", x, m1, s1) m2 = RooRealVar("m2", "mean 2", 1864, 1860, 1870) s2 = RooRealVar("s2", "sigma 2", 4, 0, 5) g2 = RooGaussian("g2", "Gaussian 2", x, m2, s2) f1 = RooRealVar("f", "f", 0.5, 0, 1) m = RooAddPdf("model", "model", RooArgList(g1, g2), f1) data = m.generate(x, 1e6) x.Write("x") m.Write("model") data.Write("data") file.Close() return
def main1(): m = RooRealVar('evt.m', 'evt.m', 1.92, 2.02) mode = RooCategory('evt.mode', 'evt.mode') mode.defineType('phipi', 0) aset = RooArgSet('aset') aset.add(m) aset.add(mode) tuplist = tupleList('genmc', 7) dst, _, f = getTree('/'.join([tuplePath(), tuplist[-1]])) # dst.Print() # dst.Show(0) # for evt in dst: # print('Hello!') # print(evt.evt.m) # break ds = RooDataSet('ds', 'ds', dst, aset) print(ds.numEntries()) mean = RooRealVar('mean', 'mean', 1.96, 1.92, 2.0) width = RooRealVar('width', 'width', 0.006, 0.001, 0.010) pdf = RooGaussian('pdf', 'pdf', m, mean, width) pdf.fitTo(ds, Verbose(), Timer(True)) makePlot(m, ds, pdf) raw_input("Press Enter to continue...")
def __init__(self, super=False): DoubleGauss.__init__(self, super=super) sXY = ('x', 'y') s12 = ('1', '2') diffW = {name: RooRealVar(name, name, 0.01, 1.7) for name in \ [c+'WidthW'+i+'Diff' for c in sXY for i in s12]} widthW = {c+'WidthW'+i: RooFormulaVar(c+'WidthW'+i, c+'WidthN'+i+'+'+ \ c+'WidthM'+i+'Diff'+'+'+c+'WidthW'+i+'Diff', \ RooArgList(diffW[c+'WidthW'+i+'Diff'], \ self.Parameter[c+'WidthM'+i+'Diff'], self.Parameter[c+'WidthN'+i])) for c in sXY for i in s12} rhoW = {name: RooRealVar(name, name, -0.48, 0.48) for name in \ ['rhoW'+i for i in s12]} if super: self.super = True extra = {name: RooRealVar(name, name, 0.0, 1.0) for name in \ ['w'+i+'MFraction' for i in s12]} nf = [('M', lambda i: 'w'+i+'MFraction*(1.0-w'+i+'N)'), \ ('W', lambda i: '(1.0-w'+i+'MFraction)*(1.0-w'+i+'N)')] w = {'w'+i+n: RooFormulaVar('w'+i+n, f(i), \ RooArgList(extra['w'+i+'MFraction'], self.Parameter['w'+i+'N'])) \ for i in s12 for (n, f) in nf} else: extra = {name: RooRealVar(name, name, 0.0, 0.5*pi) for name in \ [a+i for a in ('theta', 'phi') for i in s12]} nf = [('N', lambda i: 'sin(theta'+i+')**2*cos(phi'+i+')**2'), \ ('M', lambda i: 'sin(theta'+i+')**2*sin(phi'+i+')**2'), \ ('W', lambda i: 'cos(theta'+i+')**2')] w = {'w'+i+n: RooFormulaVar('w'+i+n, f(i), \ RooArgList(extra['theta'+i], extra['phi'+i])) for i in s12 \ for (n, f) in nf} for d in (diffW, widthW, rhoW, extra, w): self.Parameter.update(d)
def predict(self, x, theta_true): """ Run the unbinned ML fit """ # Data roodata = RooDataSet('data', 'data', RooArgSet(self.phistar)) for xval in x: self.phistar.setVal(xval) roodata.add(RooArgSet(self.phistar)) theta = RooRealVar('theta', 'theta', 0.5, self.theta_min, self.theta_max) # The combined pdf model = RooAddPdf('model', 'model', RooArgList(self.pdfs['A'], self.pdfs['H']), RooArgList(theta)) with stdout_redirected_to('%s/minuit_output.log' % self.outdir): res = model.fitTo(roodata, Save(True)) nll = res.minNll() fitted_theta = theta.getValV() # Get Lambda(theta_true | theta_best) with stdout_redirected_to(): logl = model.createNLL(roodata) theta.setVal(theta_true) nll_theta_true = logl.getValV() nll_ratio = nll_theta_true - nll return fitted_theta, nll, nll_ratio
def tripleG(doublegaus, mean, sigma3_, f2_, tagged_mass, w): sigma3 = RooRealVar ("#sigma_{TG3}" , "sigmaTG3" , sigma3_ , 0, 0.2, "GeV") signalGauss3 = RooGaussian("thirdGauss" , "thirdGauss" , tagged_mass, mean, sigma3) f2 = RooRealVar ("f2" , "f2" , f2_ , 0., 1. ) triplegaus = RooAddPdf ("triplegaus" , "doublegaus+gaus3", RooArgList(doublegaus,signalGauss3), RooArgList(f2)) _import(w,triplegaus)
def crystalBall(mean, sigma_, alpha_, n_, tagged_mass, w, fn, bin, rangeAlpha): sigmaCB = RooRealVar ("#sigma_{%s}^{%s}"%(fn, bin) , "sigmaCB_%s"%fn , sigma_ , 0, 1 ) alpha = RooRealVar ("#alpha_{%s}^{%s}"%(fn, bin) , "#alpha_{%s}^{%s}"%(fn, bin) , alpha_ , rangeAlpha[0], rangeAlpha[1] ) # was 0 - 5 n = RooRealVar ("n_{%s}^{%s}"%(fn, bin) , "n_%s"%fn , n_ , 0.001, 100 ) cbshape = RooCBShape ("cbshape_%s_%s"%(fn,bin) , "cbshape_%s_%s"%(fn, bin) , tagged_mass, mean, sigmaCB, alpha, n) _import(w,cbshape)
class GaussianConstraint(object): def __init__(self, name, expr, deps, mean, sigma): self.name = name self.expr = expr self.deps = deps self.mean = mean self.sigma = sigma # pdf of yield vs coupling modificators dependentlist = RooArgList() for dep in deps: dependentlist.add(dep) self.pdf_yield = RooGenericPdf(name, name, expr, dependentlist) # observable (measurement) obsname = name + 'Obs' self.var_obs = RooRealVar(obsname, obsname, mean) # width of Gaussian pdf sname = name + 'Sigma' self.var_sigma = RooRealVar(sname, sname, sigma) # Gaussian pdf gname = name + "Constraint" self.pdf_constraint = RooGaussian(gname, gname, self.var_obs, self.pdf_yield, self.var_sigma) self.pulls = ROOT.TH1F('pulls_' + name, name, 1000, -10, 10) def fill_pull(self): pull = (self.pdf_yield.getVal() - 1) / self.var_sigma.getVal() self.pulls.Fill(pull) def info(self): print self.name self.pdf_yield.Print() self.var_obs.Print() self.var_sigma.Print() self.pdf_constraint.Print()
def main(): # independent variable x = RooRealVar("x", "x", -10, 10) # parameters width = RooRealVar("width", "gaussian width", 2., 0., 10.) mean = RooRealVar("mean", "gaussian mean", 0., -10., 10.) decay = RooRealVar("decay", "decay coeff", -0.5, -1.0, 0.) # instantiate the custom pdf pdf = RooExpAndGauss("pdf", "custom pdf", x, mean, width, decay) # generate random dataset toydata = pdf.generate(RooArgSet(x), 5000) # fit back to the dataset (I expect it will fit quite well!) pdf.fitTo(toydata, rf.Strategy(2)) # plot the thing canvas = TCanvas() plot = x.frame(50) toydata.plotOn(plot) pdf.plotOn(plot) plot.Draw() canvas.SaveAs("plots/fittedRooExpAndGauss_fromPython.pdf") return
def rooFit106(): print ">>> setup model..." x = RooRealVar("x", "x", -3, 3) mean = RooRealVar("mean", "mean of gaussian", 1, -10, 10) sigma = RooRealVar("sigma", "width of gaussian", 1, 0.1, 10) gauss = RooGaussian("gauss", "gauss", x, mean, sigma) data = gauss.generate(RooArgSet(x), 10000) # RooDataSet gauss.fitTo(data) print ">>> plot pdf and data..." frame = x.frame(Name("frame"), Title("RooPlot with decorations"), Bins(40)) # RooPlot data.plotOn(frame) gauss.plotOn(frame) print ">>> RooGaussian::paramOn - add box with pdf parameters..." # https://root.cern.ch/doc/master/classRooAbsPdf.html#aa43b2556a1b419bad2b020ba9b808c1b # Layout(Double_t xmin, Double_t xmax, Double_t ymax) # left edge of box starts at 20% of x-axis gauss.paramOn(frame, Layout(0.55)) print ">>> RooDataSet::statOn - add box with data statistics..." # https://root.cern.ch/doc/master/classRooAbsData.html#a538d58020b296a1623323a84d2bb8acb # x size of box is from 55% to 99% of x-axis range, top of box is at 80% of y-axis range) data.statOn(frame, Layout(0.20, 0.55, 0.8)) print ">>> add text and arrow..." text = TText(2, 100, "Signal") text.SetTextSize(0.04) text.SetTextColor(kRed) frame.addObject(text) arrow = TArrow(2, 100, -1, 50, 0.01, "|>") arrow.SetLineColor(kRed) arrow.SetFillColor(kRed) arrow.SetLineWidth(3) frame.addObject(arrow) print ">>> persist frame with all decorations in ROOT file..." file = TFile("rooFit106.root", "RECREATE") frame.Write() file.Close() # To read back and plot frame with all decorations in clean root session do # [0] TFile f("rooFit106.root") # [1] xframe->Draw() print ">>> draw functions and toy data on canvas..." canvas = TCanvas("canvas", "canvas", 100, 100, 800, 600) gPad.SetLeftMargin(0.15) gPad.SetRightMargin(0.05) frame.GetYaxis().SetTitleOffset(1.6) frame.GetYaxis().SetLabelOffset(0.010) frame.GetYaxis().SetTitleSize(0.045) frame.GetYaxis().SetLabelSize(0.042) frame.GetXaxis().SetTitleSize(0.045) frame.GetXaxis().SetLabelSize(0.042) frame.Draw() canvas.SaveAs("rooFit106.png")
def fitNBkg(ibdt, fullbkg): slope = RooRealVar("slope", "slope", 0.5, -10, 10) bkg_exp = RooExponential("bkg_exp", "exponential", slope, theBMass) cut = cut_base + '&& bdt_prob > %s' % (ibdt) theBMass.setRange('sigRangeMC', B0Mass_ - 3 * dict_sigma[ibdt], B0Mass_ + 3 * dict_sigma[ibdt]) databkg = fullbkg.reduce(RooArgSet(theBMass, mumuMass, mumuMassE), cut) r = bkg_exp.fitTo(databkg, RooFit.Save(), ROOT.RooFit.Range('left,right')) frame = theBMass.frame() databkg.plotOn(frame, RooFit.Binning(70), RooFit.MarkerSize(.7)) bkg_exp.plotOn(frame, ) # bkg_exp.fixCoefRange('left,right') nbkg = RooRealVar('nbkg', 'bkg n', 1000, 0, 550000) ebkg = RooExtendPdf('ebkg', 'ebkg', bkg_exp, nbkg, 'sigRangeMC') ebkg.fitTo(databkg, ROOT.RooFit.Range('left,right')) ebkg.plotOn(frame, RooFit.LineStyle(ROOT.kDashed), RooFit.LineColor(ROOT.kGreen + 1), RooFit.Range(4.9, 5.6)) frame.Draw() dict_b_v1[ibdt] = [nbkg.getVal(), nbkg.getError()]
def get_roofit_model( histograms, fit_boundaries, name = 'model' ): data_label = 'data' samples = sorted( histograms.keys() ) samples.remove( data_label ) roofit_histograms = {} roofit_pdfs = {} roofit_variables = {} variables = RooArgList() variable_set = RooArgSet() fit_variable = RooRealVar( name , name, fit_boundaries[0], fit_boundaries[1] ) variables.add( fit_variable ) variable_set.add( fit_variable ) roofit_histograms[data_label] = RooDataHist( data_label, data_label, variables, histograms[data_label] ) pdf_arglist = RooArgList() variable_arglist = RooArgList() N_total = histograms[data_label].Integral() * 2 N_min = 0 for sample in samples: roofit_histogram = RooDataHist( sample, sample, variables, histograms[sample] ) roofit_histograms[sample] = roofit_histogram roofit_pdf = RooHistPdf ( 'pdf' + sample, 'pdf' + sample, variable_set, roofit_histogram, 0 ) roofit_pdfs[sample] = roofit_pdf roofit_variable = RooRealVar( sample, "number of " + sample + " events", histograms[sample].Integral(), N_min, N_total, "event" ) roofit_variables[sample] = roofit_variable pdf_arglist.add( roofit_pdf ) variable_arglist.add( roofit_variable ) model = RooAddPdf( name, name, pdf_arglist, variable_arglist ) return model, roofit_histograms, fit_variable
def _make_underlying_model(self): self.pdfs = {} self.yields = {} # yields are plain floats self.ryields = {} # keep track of roofit objects for memory management nbins, xmin, xmax = self.plot.histos[0].GetBinning() self.xvar = RooRealVar("x", "x", xmin, xmax) self.xvar.setBins(nbins) self.pdfs = {} self.hists = [] pdfs = RooArgList() yields = RooArgList() for compname, comp in self.plot.histosDict.iteritems(): if comp.weighted.Integral() == 0: continue assert (isinstance(comp, Histogram)) hist = RooDataHist(compname, compname, RooArgList(self.xvar), comp.weighted) SetOwnership(hist, False) # self.hists.append(hist) pdf = RooHistPdf(compname, compname, RooArgSet(self.xvar), hist) self.pdfs[compname] = pdf # self.pdfs[compname].Print() pdfs.add(pdf) nevts = comp.Integral(xmin=xmin, xmax=xmax) nmin = min(0, nevts * (1 - comp.uncertainty)) nmax = nevts * (1 + comp.uncertainty) theyield = RooRealVar('n{}'.format(compname), 'n{}'.format(compname), nevts, nmin, nmax) self.ryields[compname] = theyield self.yields[compname] = nevts yields.add(theyield) self.underlying_model = RooAddPdf('model', 'model', pdfs, yields)
def NEvtsCalc( uPars, uEPars): Pars = {} Pars[0] = RooRealVar('c1', 'Exponential constant', -1, -10, 0) Pars[1] = RooRealVar('ExpY', 'Background Yield', 100, 0, 10000000) Pars[2] = RooRealVar('Mean', 'Voigtian Mean' , 90.0, 20, 180.0) Pars[3] = RooRealVar('Width', 'Voigtian Width' , 5.0, 0.5, 40.0) Pars[4] = RooRealVar('Sigma', 'Voigtian Sigma' , 5.0, 0.5, 40.0) Pars[5] = RooRealVar('VoY', 'Signal Yield', 100, 0, 10000000) if len(Pars) != len(uPars): print 'The input array has a weird number of entries...' return 0 if len(uPars) != len(uEPars): print 'The input arrays are of different sizes...' return 0 for x in xrange(0, 6): Pars[x].setVal(uPars[x]) Pars[x].setError(uEPars[x]) v = RooRealVar('v', 'Invariant Mass (GeV)', 60, 120) Voigt = RooVoigtian('Voigt', 'Voigtian - Signal', v, Pars[2], Pars[3], Pars[4]) ## Calculate integral from -2sigma to 2sigma VStDev_r = Voigt.sigma(v) VStDev = VStDev_r.getVal() v.setRange("sobRange", Pars[2].getVal() - 2.*VStDev, Pars[2].getVal() + 2.*VStDev) integralSig = Voigt.createIntegral(RooArgSet(v), RooFit.NormSet(RooArgSet(v)), RooFit.Range("sobRange")) FinalNumber = integralSig.getVal()*Pars[5].getVal() return FinalNumber
def test_2d(): obs_x = RooRealVar("obs_x", "obs_x", 0, 10) obs_y = RooRealVar("obs_y", "obs_y", 0, 10) obs_list = RooArgList(obs_x, obs_y) formular = "obs_x + obs_y*0.3" pdf_sum = ROOT.RooGenericPdf("pdf_sum", "sum pdf", formular, obs_list) f_up = "obs_x*1.8 + obs_y*0.3" f_down = "obs_x*0.2 + obs_y*0.3" pdf_up = ROOT.RooGenericPdf("pdf_up", "sum pdf", f_up, obs_list) pdf_down = ROOT.RooGenericPdf("pdf_down", "sum pdf", f_down, obs_list) nuis_var = RooRealVar('nuis_var', "nuis_var", 0., -5., 5.) morph = createMorph(obs_list, nuis_var, pdf_sum, pdf_up, pdf_down) morph.Print() th2f = pdf_sum.createHistogram("th2f", obs_x, ROOT.RooFit.YVar(obs_y)) th2f_morph = morph.createHistogram("th2f_morph", obs_x, ROOT.RooFit.YVar(obs_y)) canvas = ROOT.TCanvas("canvas", "canvas", 450, 450) th2f.Draw('colz') canvas.SaveAs("sum_hist.pdf") ##project to X th1_x = th2f.ProjectionX("th1_x", 1) th1_x.Draw() th1_x_morph = th2f_morph.ProjectionX("th1_x_morph", 1) th1_x_morph.Draw("same") canvas.SaveAs("sum_hist_x.pdf")
def _make_fit_model(self): p0 = RooRealVar("p0", "p0", 100, -10000, 10000) p1 = RooRealVar("p1", "p1", 100, -10000, 10000) p2 = RooRealVar("p2", "p2", 100, -10000, 10000) p3 = RooRealVar("p3", "p3", 100, -10000, 10000) bgd = RooPolynomial("bgd", "bgd", self.xvar, RooArgList(p0, p1, p2, p3))
def plotPDF(): gStyle.SetOptFit(1111) x_var = 'Tau_DTF_Phi_M' #'Phi_M' #x_var = 'Phi_M' x = RooRealVar(x_var, 'm_{#Phi}', 1008,1032, 'MeV') x = RooRealVar(x_var, 'm_{#Phi}', 0,10, 'MeV') # mean = RooRealVar("#mu","#mu",1020,1010,1025) mean = RooRealVar("#mu","#mu",5) gamma = RooRealVar("#Gamma_{0}","#Gamma",3,0.1,10) spin = RooRealVar("J","J",1) radius = RooRealVar("radius","radius",0.003)#, 0, 0.01) # m_K = RooRealVar("m_K","m_K", 493.677) m_K = RooRealVar("m_K","m_K", 0.5) NRBW = ROOT.RooBreitWigner('BW','BW',x,mean, gamma) RBW = ROOT.RooRelBreitWigner('BW','BW',x,mean, gamma,spin,radius,m_K,m_K) frame = x.frame(RooFit.Title('Breit Wigner')) NRBW.plotOn(frame, RooFit.LineWidth(2),RooFit.LineColor(ROOT.kRed), RooFit.LineStyle(1)) RBW.plotOn(frame, RooFit.LineWidth(2),RooFit.LineColor(ROOT.kBlue), RooFit.LineStyle(2)) c1 = TCanvas('c1', 'c1') frame.Draw() c1.Update() return c1
def fitNBkg(ibdt, fullbkg, isample): slope = RooRealVar("slope", "slope", 0.5, -10, 10) bkg_exp = RooExponential("bkg_exp", "exponential", slope, theBMass) cut = cut_base + '&& bdt_prob > %s' % (ibdt) theBMass.setRange('sigRangeMC', B0Mass_ - 3 * dict_sigma[ibdt], B0Mass_ + 3 * dict_sigma[ibdt]) databkg = fullbkg.reduce(RooArgSet(theBMass, mumuMass, mumuMassE), cut) r = bkg_exp.fitTo(databkg, RooFit.Save(), ROOT.RooFit.Range('left,right'), RooFit.PrintLevel(-1)) frame = theBMass.frame() databkg.plotOn(frame, RooFit.Binning(70), RooFit.MarkerSize(.7)) bkg_exp.plotOn(frame, ) canv = ROOT.TCanvas() frame.Draw() nbkg = RooRealVar('nbkg', 'bkg n', 1000, 0, 550000) ebkg = RooExtendPdf( 'ebkg', 'ebkg', bkg_exp, nbkg, 'sigRangeMC') ## here imposing the range to calculate bkg yield ebkg.fitTo(databkg, ROOT.RooFit.Range('left,right'), RooFit.PrintLevel(-1)) ebkg.plotOn(frame, RooFit.LineStyle(ROOT.kDashed), RooFit.LineColor(ROOT.kGreen + 1), RooFit.Range(4.9, 5.6)) frame.Draw() # canv.SaveAs('bkg_fit_bdt%f_sample%i.pdf'%(ibdt,isample)) dict_b_v1[ibdt] = [nbkg.getVal(), nbkg.getError()]
def main(): # setting for reduced DS to be used on the output of makeSubset.C inputfile_name = "small.root" tree_name = "upsTree" # settings for full dataset (long processing time for unbinned lh) #inputfile_name = "/data1/chibdata/collision/v2/2012_AllData_v2.root" #tree_name = "rootuple/upsTree" print "Opening file" inputfile = TFile.Open(inputfile_name, "READ") print "Importing tree" tree = TTree() inputfile.GetObject(tree_name, tree) mass = RooRealVar("ups_mass", "ups_mass", 7, 11) y = RooRealVar("ups_rapidity", "ups_rapidity", -3, 3) pt = RooRealVar("ups_pt", "ups_pt", 0, 100) print "Assigning dataset" dataArgSet = RooArgSet(mass, y, pt) dataSet = RooDataSet("yds", "Y data set", tree, dataArgSet) cuts= "abs(ups_rapidity) < 1.25"+\ "&& ups_pt>9.5"\ reduced_ds = dataSet.reduce(RooFit.Cut(cuts)) print "Performing likelihood analysis" dofit(reduced_ds, "Y3S")
def addConstraint(workspace,rrv_x, x_mean, x_sigma, ConstraintsList): rrv_x_mean = RooRealVar(rrv_x.GetName()+"_mean",rrv_x.GetName()+"_mean",x_mean ) rrv_x_sigma = RooRealVar(rrv_x.GetName()+"_sigma",rrv_x.GetName()+"_sigma",x_sigma ) constrainpdf_x = RooGaussian("constrainpdf_"+rrv_x.GetName(),"constrainpdf_"+rrv_x.GetName(),rrv_x, rrv_x_mean, rrv_x_sigma) ConstraintsList.append(constrainpdf_x.GetName()) getattr(workspace,"import")(constrainpdf_x) return constrainpdf_x
def buildPdf(ws, p): mass = RooRealVar("mass", "mass", p.minMass, p.maxMass) getattr(ws,'import')(mass) # Construct signal pdf mean = RooRealVar("mean", "mean", 90, 85, 95) width = RooRealVar("width", "width", 2.4952, 1, 3) width.setConstant(ROOT.kTRUE) sigma = RooRealVar("sigma", "sigma", 1.2, 0.2, 10) signalAll = RooVoigtian("signalAll", "signalAll", mass, mean, width, sigma) turnOnAll = RooRealVar("turnOnAll","turnOnAll", 80., 40., 150.) widthAll_bkg = RooRealVar("widthAll","widthAll", 2., 0., 50.) decayAll_bkg = RooRealVar("decayAll","decayAll", 80., 20., 150.) meanB = RooRealVar("meanB", "meanB", 90, 60, 130) sigmaB = RooRealVar("sigmaB", "sigmaB", 10, 1, 20) bkg_a1 = RooRealVar("bkg_a1", "bkg_a1", 0., -2., 2.) bkg_a2 = RooRealVar("bkg_a2", "bkg_a2", 0., -2., 2.) backgroundAll = RooGaussian("backgroundAll", "backgroundAll", mass, meanB, sigmaB) # Construct composite pdf sigAll = RooRealVar("sigAll", "sigAll", 2000, 0, 100000) bkgAll = RooRealVar("bkgAll", "bkgAll", 100, 0, 10000) modelAll = RooAddPdf("modelAll", "modelAll", RooArgList(signalAll, backgroundAll), RooArgList(sigAll, bkgAll)) if p.NoBkgd: modelAll = RooAddPdf("modelAll", "modelAll", RooArgList(signalAll), RooArgList(sigAll)) # Define pdf for all probes # Construct signal pdf. # NOTE that sigma is shared with the signal sample model signalPass = RooVoigtian("signalPass","signalPass",mass,mean,width,sigma) # Construct the background pdf backgroundPass = RooGaussian("backgroundPass", "backgroundPass", mass, meanB, sigmaB) # Construct the composite model efficiency = RooRealVar("efficiency","efficiency",0.9,0.3,1.) sigPass = RooFormulaVar("sigPass", "@0*@1", RooArgList(sigAll, efficiency)) bkgPass = RooRealVar("bkgPass", "bkgPass", 100, 0, 10000) modelPass = RooAddPdf("modelPass", "modelPass", RooArgList(signalPass, backgroundPass), RooArgList(sigPass, bkgPass)) if p.NoBkgd: modelPass = RooAddPdf("modelPass", "modelPass", RooArgList(signalPass), RooArgList(sigPass)) frac = RooRealVar("frac", "frac", 0.8, 0., 1.) # Define combined pdf for simultaneous fit # Define category to distinguish physics and control samples events sample = RooCategory("sample","sample") sample.defineType("all") sample.defineType("pass") simPdf = RooSimultaneous("simPdf","simultaneous pdf",sample) # Associate model with the physics state and model_ctl with the control state simPdf.addPdf(modelAll,"all") simPdf.addPdf(modelPass,"pass") # ws.import(simPdf) getattr(ws,'import')(simPdf)
def rooFitVar( self ): ## Get the corresponding RooRealVar used in RooFit # @return the RooRealVar if not self.__rooFitVar: from ROOT import RooRealVar self.__rooFitVar = RooRealVar( self.name, self.title, self.low, self.up, self.unit ) self.__rooFitVar.setBins( self.nBins ) return self.__rooFitVar
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.0 N_max = self.normalisation[self.data_label] * 2.0 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
def __init__(self, adc, name): #input ADC values self.adc = adc #1n Gaussian mean_nam = "mean_1n_" + name self.mean_1n = RooRealVar(mean_nam, mean_nam, 40., 120.) sigma_nam = "sigma_1n_" + name self.sigma_1n = RooRealVar(sigma_nam, sigma_nam, 0., 100.) gauss_nam = "gauss_1n_" + name self.gauss_1n = RooGaussian(gauss_nam, gauss_nam, self.adc, self.mean_1n, self.sigma_1n)
def doMCFit(dataSet, x_var, addTitlePlot=''): cuts_str = '' data = dataSet.reduce( RooFit.Cut(cuts_str) ) x=RooRealVar(x_var, 'm_{#tau}',1757,1797,'MeV') numBins = 100 # define here so that if I change it also the ndof change accordingly x.setBins(numBins) ###################################################### # DEFINE PDF ###################################################### w = RooWorkspace('w') getattr(w,'import')(x) w.factory('''RooDSCBShape::DSCB({0}, #mu[1777, 1760,1790], #sigma[5,0,10], #alpha[1.2], n[50, 1, 150], #alpha, n )'''.format(x_var)) #w.var('n').setConstant(False) signal = w.pdf('DSCB') # w.factory('''RooGaussian::GG({0}, # #mu, #sigma # )'''.format(x_var)) # signal = w.pdf('GG') # Fit fit_region = x.setRange('fit_region',1757,1797) result = signal.fitTo(dataSet, RooFit.Save(), RooFit.Range('fit_region')) # Frame frame = x.frame(RooFit.Title(' Combined mass KK#mu '+addTitlePlot)) dataSet.plotOn(frame) signal.plotOn(frame, RooFit.LineWidth(2)) # Legends signal.paramOn(frame, RooFit.Layout(0.6,0.9,0.9)) chi2 = round(frame.chiSquare(),2) leg = TLegend(0.3,0,.10,.10) leg.SetBorderSize(0) leg.SetFillStyle(0) leg.AddEntry(0,'#chi^{2} ='+str(chi2),'') frame.addObject(leg) c1 = TCanvas('c1', 'c1') frame.Draw() c1.Update() for prm in ('#mu', '#sigma', '#alpha', 'n'): # TODO: automatize finding of variables from the function w.var(prm).setConstant() return w, c1
def __init__(self, gauss_1n, cb_2xn, name): self.gauss_1n = gauss_1n self.cb_2xn = cb_2xn #number in the model n1n_nam = "num_1n_" + name self.num_1n = RooRealVar(n1n_nam, n1n_nam, 200, 0, 3000) # 1 n2n_nam = "num_2n_" + name self.num_2n = RooRealVar(n2n_nam, n2n_nam, 100, 0, 3000) # 0.5 #1D model Gauss + Crystal Ball model_nam = "model_" + name self.model = RooAddPdf(model_nam, model_nam, RooArgList(self.gauss_1n, self.cb_2xn), RooArgList(self.num_1n, self.num_2n))
def CBintialization(self): round_energy = round(float(self.energy),-1) if round_energy ==240 : round_energy = 250 self.x = RooRealVar("signal_%s_%dGeV"%(self.crystal,round_energy),"signal_%s_%dGeV"%(self.crystal,round_energy),max(0.,self.peak_position*(1-self.xaxis_scale)),self.peak_position*(1+self.xaxis_scale)) self.roohist = RooDataHist("roohist_fit_%s_%s"%(self.crystal,self.energy),"roohist_fit_%s_%s"%(self.crystal,self.energy),RooArgList(self.x),self.hist) self.m = RooRealVar("mean_%s_%s"%(self.crystal,self.energy),"mean_%s_%s"%(self.crystal,self.energy),self.peak_position,max(0.,self.peak_position*(1-self.xaxis_scale)),self.peak_position*(1+self.xaxis_scale)) self.s = RooRealVar("sigma_%s_%s"%(self.crystal,self.energy),"sigma_%s_%s"%(self.crystal,self.energy),self.s_initial,0.001,1.) #500. self.a = RooRealVar("alpha_%s_%s"%(self.crystal,self.energy),"alpha_%s_%s"%(self.crystal,self.energy),self.a_initial,-10.,10) self.n = RooRealVar("exp_%s_%s"%(self.crystal,self.energy),"exp_%s_%s"%(self.crystal,self.energy),self.n_initial,0.,30) self.sig = RooCBShape("signal_%s_%s"%(self.crystal,self.energy),"signal_%s_%s"%(self.crystal,self.energy),self.x,self.m,self.s,self.a,self.n)
def Fit(h, Lc_M): h_LcM = RooDataHist('h_LcM', 'h_LcM', RooArgList(Lc_M), h) #Create a workspace named 'w' with the model to fit the Lc_Mass peak nsig = RooRealVar("nsig", "N signal evts", 100000, 0, 5000000) nbkg = RooRealVar("nbkg", "N bkg evts", 400000, 0, 1E10) w = CreateMassFitModel(Lc_M, nsig, nbkg) model = w.pdf("model") model.fitTo(h_LcM, RF.Extended(True)) return model, w, h_LcM
def doubleG(mean_, sigma1_, sigma2_, f1_, tagged_mass, w, fn): mean = RooRealVar ("mean^{%s}"%fn , "massDG" , mean_ , 5, 6, "GeV") sigma1 = RooRealVar ("#sigma_{1}^{%s}"%fn , "sigmaDG1" , sigma1_ , 0, 1, "GeV") signalGauss1 = RooGaussian("dg_firstGauss_%s"%fn , "firstGauss" , tagged_mass, mean, sigma1) sigma2 = RooRealVar ("#sigma_{2}^{%s}"%fn , "sigmaDG2" , sigma2_ , 0, 0.12, "GeV") signalGauss2 = RooGaussian("dg_secondGauss_%s"%fn , "secondGauss" , tagged_mass, mean, sigma2) f1 = RooRealVar ("f^{%s}"%fn , "f1" , f1_ , 0., 1. ) doublegaus = RooAddPdf ("doublegaus_%s"%fn , "gaus1+gaus2" , RooArgList(signalGauss1,signalGauss2), RooArgList(f1)) _import(w,doublegaus)
def generateBkg(tagged_mass, ibin, n_bkg): slope = RooRealVar("slope", "slope", -4.2) bkg_exp = RooExponential("bkg_exp", "exponential", slope, tagged_mass) pol_c1 = RooRealVar("p1", "coeff x^0 term", -1.2) pol_c2 = RooRealVar("p2", "coeff x^1 term", 0.3) bkg_pol = RooChebychev("bkg_pol", "2nd order pol", tagged_mass, RooArgList(pol_c1, pol_c2)) n_togen = np.random.poisson(n_bin[ibin] * n_bkg, 1) toybkg = bkg_pol.generate(RooArgSet(tagged_mass), n_togen[0]) return toybkg
def __init__(self, mass_range=[0., 2000.]): self.data_histogram_ = None self.data_roohistogram_ = None self.luminosity_ = 0. self.collision_energy_ = 8000. self.signal_histograms_ = {} self.signal_roohistograms_ = {} self.signal_names_ = [] # Fit storage self.simple_fit_ = None self.mjj_ = RooRealVar('mjj','mjj',float(mass_range[0]),float(mass_range[1])) self.workspace_ = None
def __init__(self, name, lower, higher=None): """Initialize a variable. Takes a name (string) and one or two numbers (float) as arguments. One number: Initialize variable with a constant value. Two numbers: Initialize variable with a fixed range. """ if higher is None: RooRealVar.__init__(self, name, name, lower) else: RooRealVar.__init__(self, name, name, lower, higher) self._fixed_minimum = None self._fixed_maximum = None
class RealVar(): def __init__(self, *args): self.var = RooRealVar(args[0], args[0], *args[1:]) @property def min(self): return self.var.getMin() @min.setter def min(self, val): self.var.setMin(val) @property def val(self): return self.var.getVal() @property def max(self): return self.var.getMax() @max.setter def max(self, val): self.var.setMax(val) def __getattr__(self, name): return getattr(self.var, name) def __repr__(self): ret = f'RooRealVar {self.var.GetName()} = {self.var.getVal()}' if not self.var.isConstant(): ret += f' [{self.min}, {self.max}]' return ret
def performFitInLeptonAbsEta(data_histogram, signal_histogram, bkg1_histogram, bkg2_histogram): N_Data = data_histogram.Integral() N_signal = signal_histogram.Integral() N_bkg1 = bkg1_histogram.Integral() N_bkg2 = bkg2_histogram.Integral() leptonAbsEta = RooRealVar("leptonAbsEta", "leptonAbsEta", 0., 3.) variables = RooArgList() variables.add(leptonAbsEta) variable_set = RooArgSet() variable_set.add(leptonAbsEta) lowerBound = 0 upperBound = N_Data * 2 data_RooDataHist = RooDataHist("data", "dataset with leptonAbsEta", variables, data_histogram) signal_RooDataHist = RooDataHist("rh_signal", "signal", variables, signal_histogram) bkg1_RooDataHist = RooDataHist("rh_bkg1", "bkg1", variables, bkg1_histogram) bkg2_RooDataHist = RooDataHist("rh_bkg2", "bkg2", variables, bkg2_histogram) signal_RooHistPdf = RooHistPdf("pdf_signal", "Signal PDF", variable_set, signal_RooDataHist, 0) signal_RooHistPdf = RooHistPdf("pdf_signal", "Signal PDF", variable_set, signal_RooDataHist, 0)
def __init__(self,name,inhist,binning,constant=False,forcePositive=True): '''Represents a binned distribution as a group of RooRealVar parameters. If constant == False, each bin is considered an unconstrained parameter of the model. Args: name (str): Unique name for the new object. inhist (TH2): Input 2D histogram to build set of variables. binning (Binning): Binning object used to create LOW, SIG, HIGH regions along X axis. constant (bool, optional): If true, use RooConstVars for bins. Defaults to False and RooRealVars are used. forcePositive (bool, optional). Defaults to True in which case the bin values will be lower bound by 1e-9 and any shape templates will asymptotically approach zero as the associated nuisance increases/decreases. ''' super(BinnedDistribution,self).__init__(name,binning,forcePositive=forcePositive) for cat in _subspace: cat_name = name+'_'+cat cat_hist = copy_hist_with_new_bins(cat_name,'X',inhist,self.binning.xbinByCat[cat]) for ybin in range(1,cat_hist.GetNbinsY()+1): for xbin in range(1,cat_hist.GetNbinsX()+1): bin_name = '%s_bin_%s-%s'%(cat_name,xbin,ybin) if constant or self._nSurroundingZeros(cat_hist,xbin,ybin) > 7: self.binVars[bin_name] = RooConstVar(bin_name, bin_name, cat_hist.GetBinContent(xbin,ybin)) else: self.binVars[bin_name] = RooRealVar(bin_name, bin_name, max(5,cat_hist.GetBinContent(xbin,ybin)), 1e-6, 1e6) self.nuisances.append({'name':bin_name, 'constraint':'flatParam', 'obj': self.binVars[bin_name]}) self._varStorage.append(self.binVars[bin_name]) # For safety if we add shape templates
def _createFuncVars(self,constraints): '''Creates the nuisances list of the function variables (RooRealVars) and associated meta data (nuisance name, constraint). Args: constraints (dict): Information of which parameters to constrain differently from the default. By default, the constraint will be flat, the starting value of the parameter will be 0 with a step size of 0.1, and the range of the parameter will be [-1000,1000]. Returns: list: List of dictionaries with keys "name" (str), "obj" (RooRealVar), "constraint" (str). ''' out = [] for i in range(self.getNparams()): name = '%s_par%s'%(self.name,i) constraint = 'flatParam'; MIN = -1000; MAX = 1000; NOM = 0.1; ERROR = 0.1 if i in constraints: if 'constraint' in constraints[i]: constraint = constraints[i]['constraint'] if 'MIN' in constraints[i]: MIN = constraints[i]['MIN'] if 'MAX' in constraints[i]: MAX = constraints[i]['MAX'] if 'NOM' in constraints[i]: NOM = constraints[i]['NOM'] if 'ERROR' in constraints[i]: ERROR = constraints[i]['ERROR'] this_out = {'name':name, 'obj': RooRealVar(name,name,NOM,MIN,MAX), 'constraint': constraint} this_out['obj'].setError(ERROR) out.append(this_out) return out
def EfficiencySignal(fname, bdtcut): f = r.TFile(fname, 'read') t = f.Get('DecayTree') LcM_range = [2230, 2330] Lc_M = RooRealVar('Lc_M', '#Lambda_{c} mass', LcM_range[0], LcM_range[1]) h0 = r.TH1F('h0', '#Lambda_{c} mass peak', 200, 2230, 2330) t.Draw('Lc_M>>h0', 'Lc_BKGCAT<30.') h0 = r.gPad.GetPrimitive('h0') model, w, h_LcM = Fit(h0, Lc_M) nsig_nocut = w.var('nsig') nbkg_nocut = w.var('nbkg') h1 = r.TH1F('h1', '#Lambda_{c} mass peak with BDT cut', 200, 2230, 2330) t.Draw('Lc_M>>h1', 'Lc_BKGCAT<30.&&bdt>' + str(bdtcut)) h1 = r.gPad.GetPrimitive('h1') model1, w1, h_LcM1 = Fit(h1, Lc_M) nsig_cut = w1.var('nsig') nbkg_cut = w1.var('nbkg') return nsig_cut.getValV() / nsig_nocut.getValV() '''
def test_plottable(): # construct pdf and toy data following example at # http://root.cern.ch/drupal/content/roofit # Observable mes = RooRealVar("mes", "m_{ES} (GeV)", 5.20, 5.30) # Parameters sigmean = RooRealVar("sigmean", "B^{#pm} mass", 5.28, 5.20, 5.30) sigwidth = RooRealVar("sigwidth", "B^{#pm} width", 0.0027, 0.001, 1.) # Build Gaussian PDF signal = RooGaussian("signal", "signal PDF", mes, sigmean, sigwidth) # Build Argus background PDF argpar = RooRealVar("argpar", "argus shape parameter", -20.0, -100., -1.) background = RooArgusBG("background", "Argus PDF", mes, RooFit.RooConst(5.291), argpar) # Construct signal+background PDF nsig = RooRealVar("nsig", "#signal events", 200, 0., 10000) nbkg = RooRealVar("nbkg", "#background events", 800, 0., 10000) model = RooAddPdf("model", "g+a", RooArgList(signal, background), RooArgList(nsig, nbkg)) # Generate a toyMC sample from composite PDF data = model.generate(RooArgSet(mes), 2000) # Perform extended ML fit of composite PDF to toy data fitresult = model.fitTo(data, RooFit.Save(), RooFit.PrintLevel(-1)) # Plot toy data and composite PDF overlaid mesframe = asrootpy(mes.frame()) data.plotOn(mesframe) model.plotOn(mesframe) for obj in mesframe.objects: assert_true(obj) for curve in mesframe.curves: assert_true(curve) for hist in mesframe.data_hists: assert_true(hist) assert_true(mesframe.plotvar) with TemporaryFile(): mesframe.Write()
def fit(self, save_to, signal_name=None, fix_p3=False, fit_range=[300., 1200.], fit_strategy=1): # Run a RooFit fit # Create background PDF p1 = RooRealVar('p1','p1',args.p1,0.,100.) p2 = RooRealVar('p2','p2',args.p2,0.,60.) p3 = RooRealVar('p3','p3',args.p3,-10.,10.) if args.fix_p3: p3.setConstant() background_pdf = RooGenericPdf('background_pdf','(pow(1-@0/%.1f,@1)/pow(@0/%.1f,@2+@3*log(@0/%.1f)))'%(self.collision_energy,self.collision_energy,self.collision_energy),RooArgList(self.mjj_,p1,p2,p3)) background_pdf.Print() data_integral = data_histogram.Integral(data_histogram.GetXaxis().FindBin(float(fit_range[0])),data_histogram.GetXaxis().FindBin(float(fit_range[1]))) background_norm = RooRealVar('background_norm','background_norm',data_integral,0.,1e+08) background_norm.Print() # Create signal PDF and fit model if signal_name: signal_pdf = RooHistPdf('signal_pdf', 'signal_pdf', RooArgSet(self.mjj_), self.signal_roohistograms_[signal_name]) signal_pdf.Print() signal_norm = RooRealVar('signal_norm','signal_norm',0,-1e+05,1e+05) signal_norm.Print() model = RooAddPdf("model","s+b",RooArgList(background_pdf,signal_pdf),RooArgList(background_norm,signal_norm)) else: model = RooAddPdf("model","b",RooArgList(background_pdf),RooArgList(background_norm)) # Run fit res = model.fitTo(data_, RooFit.Save(kTRUE), RooFit.Strategy(fit_strategy)) # Save to workspace self.workspace_ = RooWorkspace('w','workspace') #getattr(w,'import')(background,ROOT.RooCmdArg()) getattr(self.workspace_,'import')(background_pdf,RooFit.Rename("background")) getattr(self.workspace_,'import')(background_norm,ROOT.RooCmdArg()) getattr(self.workspace_,'import')(self.data_roohistogram_,RooFit.Rename("data_obs")) getattr(self.workspace_, 'import')(model, RooFit.Rename("model")) if signal_name: getattr(self.workspace_,'import')(signal_roohistogram,RooFit.Rename("signal")) getattr(self.workspace_,'import')(signal_pdf,RooFit.Rename("signal_pdf")) getattr(self.workspace_,'import')(signal_norm,ROOT.RooCmdArg()) self.workspace_.Print() self.workspace_.writeToFile(save_to) if signal_name: roofit_results[signal_name] = save_to else: roofit_results["background"] = save_to
def main(): # Mjj0 of TT MC Bkg f1 = TFile("Merged_TT_TuneCUETP8M1_13TeV-powheg-pythia8-runallAnalysis.root") h_Mjj = f1.Get("histfacFatJet_ZLight/h_Mjj0") h_Mjj.GetXaxis().SetRangeUser(0,300) var_mean = h_Mjj.GetMean() # Build Gaussian PDF x = RooRealVar( 'x', 'x', 0, 300 ) mean = RooRealVar( 'mean', 'mean of gaussian', var_mean ) sigma = RooRealVar( 'sigma', 'width of gaussian', 5) gauss = RooGaussian( 'gauss', 'gaussian PDF', x, mean, sigma) data = RooDataHist("data","Mjj dataset",RooArgList(x), h_Mjj); # Plot PDF xframe = x.frame(RooFit.Title("Gaussian p.d.f.")) gauss.plotOn( xframe ) gauss.plotOn(xframe,RooFit.LineColor(2)) # Generate a toy MC set # data = gauss.generate( RooArgSet(x), 10000 ) # Plot PDF and toy data overlaid xframe2 = x.frame(RooFit.Title("Gaussian p.d.f. with Mjj")) # data.plotOn( xframe2, RooLinkedList() ) # data.plotOn( xframe2 ) data.plotOn( xframe2 ) gauss.plotOn( xframe2) # Fit PDF to toy mean.setConstant( kFALSE ) sigma.setConstant( kFALSE ) gauss.fitTo(data) c1 = TCanvas("c1","Example",800,400) c1.Divide(3) c1.cd(1) gPad.SetLeftMargin(0.15) xframe.GetYaxis().SetTitleOffset(1.6) xframe.Draw() c1.cd(2) gPad.SetLeftMargin(0.15) xframe2.GetYaxis().SetTitleOffset(1.6) xframe2.Draw() c1.SaveAs('testMjj0.png') # # Print final value of parameters fout = TFile("output.root","recreate") c1.Write() fout.Close()
def fitPed(hist, ws, name='x'): maxBin = hist.GetMaximumBin() x = ws.var(name) #rds = ds.reduce('{1}<{0:0.2f}'.format(hist.GetBinLowEdge(maxBin+2),name)) #rds.Print() x.setRange('ped_fit', x.getMin(), hist.GetBinLowEdge(maxBin+3)) pedMean = RooRealVar('pedMean', 'mean_{ped}', hist.GetBinCenter(maxBin), x.getMin(), x.getMax()) pedMean.Print() pedWidth = RooRealVar('pedWidth', 'sigma_{ped}', 1., 0., 10.) pedWidth.Print() ped = RooGaussian('ped', 'ped', x, pedMean, pedWidth) pedMean.setConstant(False) ped.fitTo(ws.data('ds'), RooFit.Minos(False), RooFit.Range('ped_fit'), RooFit.PrintLevel(0)) getattr(ws, 'import')(ped)
def saveLandauHistoSignalToNoise(histo,outfile,canvas,XaxisTitle="",YaxisTitle="",plotTitle="",stats=0): ex = "Null Fit" signal_to_noise = RooRealVar("signal_to_noise", "Signal to Noise", 0, 50) landau_data = RooDataHist("landau_data", "landau_data", RooArgList(signal_to_noise), histo) ml = RooRealVar("ml","mean landau",25, 20, 26) sl = RooRealVar("sl","sigma landau", 5, 2, 10) landau = RooLandau("lx","lx",signal_to_noise,ml,sl) mg = RooRealVar("mg","mg",0) ; sg = RooRealVar("sg","sg", 2, 1, 8) gauss = RooGaussian("gauss","gauss",signal_to_noise,mg,sg) lxg = RooNumConvPdf("lxg", "lxg", signal_to_noise, landau, gauss) result = lxg.fitTo(landau_data) frame = signal_to_noise.frame() landau_data.plotOn(frame) lxg.plotOn(frame) frame.Draw("") frame.SetTitle(plotTitle) frame.GetXaxis().SetTitle(XaxisTitle) frame.GetYaxis().SetTitle(YaxisTitle) frame.SetStats(stats) frame.Write(plotTitle) canvas.Print(outfile+".pdf") peak = [] try: mean = RooRealVar(result.floatParsFinal().find("landau_mean")) err = RooRealVar(mean.errorVar()) peak.append(mean.GetVal()) peak.append(err.GetVal()) except Exception as ex: print(ex) peak.append(0) peak.append(0) return peak
def get_num_sig_bkg(hist_DataTemplate, hist_SignalTemplate, hist_BackgdTemplate, fit_range_min, fit_range_max): '''Given 3 input histograms (TH1F), and a fit range, this function finds the amount of signal and background that sum up to the data histogram. It does histogram fits.''' # Find range of data template data_min = hist_DataTemplate.GetXaxis().GetXmin() data_max = hist_DataTemplate.GetXaxis().GetXmax() # Create basic variables x = RooRealVar("x","x",data_min,data_max) x.setBins(hist_DataTemplate.GetXaxis().GetNbins()) # Binned x values nsig = RooRealVar("nsig","number of signal events" , 0, hist_DataTemplate.Integral()) nbkg = RooRealVar("nbkg","number of background events", 0, hist_DataTemplate.Integral()) # Create RooDataHists from input TH1Fs dh = RooDataHist("dh","dh",RooArgList(x),hist_DataTemplate) ds = RooDataHist("ds","ds",RooArgList(x),hist_SignalTemplate) db = RooDataHist("db","db",RooArgList(x),hist_BackgdTemplate) # Create Probability Distribution Functions from Monte Carlo sigPDF = RooHistPdf("sigPDF", "sigPDF", RooArgSet(x), ds) bkgPDF = RooHistPdf("bkgPDF", "bkgPDF", RooArgSet(x), db) model = RooAddPdf("model","(g1+g2)+a",RooArgList(bkgPDF,sigPDF),RooArgList(nbkg,nsig)) # Find the edges of the bins that contain the fit range min/max data_min = hist_DataTemplate.GetXaxis().GetBinLowEdge(hist_DataTemplate.GetXaxis().FindFixBin(fit_range_min)) data_max = hist_DataTemplate.GetXaxis().GetBinUpEdge(hist_DataTemplate.GetXaxis().FindFixBin(fit_range_max)) r = model.fitTo(dh,RooFit.Save(),RooFit.Minos(0),RooFit.PrintEvalErrors(0), RooFit.Extended(),RooFit.Range(data_min,data_max)) r.Print("v") #print nsig.getVal(), nsig.getError(), nbkg.getVal(), nbkg.getError() # Create pull distribution #mcstudy = RooMCStudy(model, RooArgSet(x), RooFit.Binned(1), RooFit.Silence(), # RooFit.Extended(), # RooFit.FitOptions(RooFit.Save(1), # RooFit.PrintEvalErrors(0), # RooFit.Minos(0)) # ) #mcstudy.generateAndFit(500) # Generate and fit toy MC #pull_dist = mcstudy.plotPull(nsig, -3.0, 3.0, 30, 1) # make pull distribution pull_dist = None return [nsig.getVal(), nsig.getError(), nbkg.getVal(), nbkg.getError(), pull_dist]
def __init__( self, roovar, **kwargs ): ''' To build the class, the variable to be blinded must be provided. In < scale > one modifies the range of values for the blinded variable. Also the names for the constant variable and the generated formula can be modified. ''' name = roovar.GetName() print 'Defining a new blinded variable for <', name, '>' scale = kwargs.get( 'scale', 1000 ) eqname = kwargs.get( 'bvarname', name + '_BlindExpr' ) ''' The seed is different for each call, which guarantees the blinding procedure ''' print 'Generating new set of random bounds' rndm = TRandom3( 0 ) vmin = roovar.getMin() boundlo = rndm.Uniform( vmin, vmin*scale ) vmax = roovar.getMax() boundhi = rndm.Uniform( vmax, vmax*scale ) clonename = name + '_BLIND' blindVar = RooRealVar( clonename, clonename, roovar.getVal(), boundlo, boundhi ) print 'Created clone variable named <', clonename, '>' alpha = ( vmax - vmin )/( boundhi - boundlo ) beta = ( vmax*boundlo - vmin*boundhi )/( vmax - vmin ) blindVar.setVal( alpha*( roovar.getVal() - beta ) ) alpha = RooConstVar( 'alpha', 'alpha', alpha ) beta = RooConstVar( 'beta', 'beta', beta ) formula = 'alpha*( %s - beta)' % clonename varlist = RooArgList( blindVar, alpha, beta ) blindEq = RooFormulaVar( eqname, eqname, formula, varlist ) print 'The blinding formula is:', formula self.Alpha = alpha self.Beta = beta self.BlindEq = blindEq self.BlindVar = blindVar
def test_plot(): c = TCanvas('c', 'canvas', 300, 300) x = RooRealVar("x","x",-10,10) mean = RooRealVar("mean","mean of gaussian",1,-10,10) sigma = RooRealVar("sigma","width of gaussian",1,0.1,10) gauss = RooGaussian("gauss","gaussian PDF",x,mean,sigma) xframe = x.frame(RooFit.Title("Gaussian p.d.f.")) #gauss.plotOn(xframe) sigma.setVal(3) as_x = RooArgSet(x) data = gauss.generate(as_x,10000) data.plotOn(xframe, RooFit.MarkerSize(0.6), RooFit.MarkerStyle(20)) xframe.Draw() pdffile = 'test.pdf' c.SaveAs(pdffile)
def __init__(self, file_names, br_name="mass"): self.file_names = file_names self.br_name = br_name min_x = 8 max_x = 12 self.obs = RooRealVar("obs", "m4l", min_x, max_x) self.nbins = int((max_x - min_x) * 20) self.obs.setBin(self.nbins) # self.ws = ROOT.RooWorkspace("combined", "combined") self.obs.setRange("fit", 8.5, 11.5) self.dummy_hists = [] self.chi2_cut = 10000
def dump_simple(): # try poisson roo_lam = RooRealVar("lambda", ".", lam, 0.0, 1.5) roo_x = RooRealVar('x', 'x range', 0, bins) model = RooPoisson("poisson", "Poisson Model", roo_x, roo_lam) #data = model.generate(RooArgSet(roo_x), n_events) data = RooDataSet('data', 'Data', RooArgSet(roo_x)) for val in unbinned_from_binned(xdata, ydata): roo_x.setVal(val) data.add(RooArgSet(roo_x)) #// --- Perform extended ML fit of composite PDF to toy data --- fitresult = model.fitTo(data, RooFit.Save(), RooFit.PrintLevel(-1)) ; #// --- Plot toy data and composite PDF overlaid --- mesframe = roo_x.frame(bins) ; data.plotOn(mesframe) ; model.plotOn(mesframe) ; mesframe.Draw()
def getTrueOmegasPerCat(config, mistagobs, mistag, mistagpdf): """ estimate the per-category mistag (omega_i) as starting value for the fit calculate true per-category omegas based on the mistagpdf and the calibration that goes into the generation pdf config -- config dictionary mistagobs -- mistag observable (eta) mistag -- calibrated mistag (omega(eta)) mistagpdf -- mistag pdf (P(eta)) returns a pair of average mistag omega, list of per-category mistag (omega) averages relevant config dictionary keys: 'MistagCategoryBinBounds': list of mistag category bin bounds (one more entry than mistag categories) """ from ROOT import RooRealVar, RooCustomizer, RooProduct, RooArgList, RooArgSet eta1 = RooRealVar('eta1', 'eta1', mistagobs.getMin(), mistagobs.getMin(), mistagobs.getMax()) eta2 = RooRealVar('eta2', 'eta2', mistagobs.getMax(), mistagobs.getMin(), mistagobs.getMax()) prod = RooProduct('prod', 'prod', RooArgList(mistag, mistagpdf)) oldmistagobs = mistagobs mistagobs = mistagobs.clone(mistagobs.GetName() + '_catclone') ROOT.SetOwnership(mistagobs, True) mistagobs.setRange(eta1, eta2) c = RooCustomizer(prod, 'cust') c.replaceArg(oldmistagobs, mistagobs) prod = c.build() ROOT.SetOwnership(prod, True) c = RooCustomizer(mistagpdf, 'cust2') c.replaceArg(oldmistagobs, mistagobs) pdf = c.build() ROOT.SetOwnership(pdf, True) if pdf.InheritsFrom('RooHistPdf'): pdf.forceNumInt() evnumer = prod.createIntegral(RooArgSet(mistagobs)) evdenom = pdf.createIntegral(RooArgSet(mistagobs)) totevdenom = evdenom.getVal() avomega = evnumer.getVal() / totevdenom omegas = [ ] for i in xrange(0, len(config['MistagCategoryBinBounds']) - 1): eta1.setVal(config['MistagCategoryBinBounds'][i]) eta2.setVal(config['MistagCategoryBinBounds'][i + 1]) omegas.append(evnumer.getVal() / evdenom.getVal()) print 'INFO: Mistag calibration %s:' % mistag.GetName() print 'INFO: Average omega (PDF): %g' % avomega print 'INFO: Per category average omegas (PDF): %s' % str(omegas) return avomega, omegas
def roofit_poisson_unbinned(data): """returns lambda, error of lambda""" x = RooRealVar('x', 'x', 0, max(data) * 10) lam = RooRealVar('lambda', 'lambda', 0.1, 0.000001, max(data)) model = RooPoisson('model', 'model', x, lam) dataset = RooDataSet('data', 'data', RooArgSet(x)) for val in data: x.setVal(val) dataset.add(RooArgSet(x)) model.fitTo(dataset, RooFit.Save(), RooFit.PrintLevel(-1)) return lam.getVal(), lam.getError()
def __init__(self, file_name, br_name="mass"): self.file_name = file_name self.br_name = br_name min_x = 8 max_x = 12 self.obs = RooRealVar("obs", "m4l", min_x, max_x) self.nbins = int((max_x - min_x) * 20) self.obs.setBin(self.nbins) #self.ws = ROOT.RooWorkspace("combined", "combined") self.dummy_hists = [] self.chi2_cut = 10000 # dionia selection or onia selection self.dionia_selection = False # with 3mu4 trigger or not self.with_3mu4 = True # only unprescaled runs self.only_unprescaled = True # different onia_pt cuts, 0:noCut, 1:<5, 2:5-10, 3:10,20, 4:>20 self.onia_pt_cut = 0 self.onia_pt_cuts = [0, 5, 10, 20] #self.onia_pt_cuts = [0, 10, 20] # different muon pT cuts # suggested by Terry to look at onia mass that have one muon with pT (3, 4) GeV. self.use_low_pt_muon = False # it is found that these low pT muons contributes a lot the background 40% # while only gain 15% signal self.no_low_pt = False # if build new model self.new_model = False self.model_name = "model" # workspace components self.data = None self.model = None
RooMsgService.instance().setSilentMode(ROOT.kTRUE) RooMsgService.instance().setStreamStatus(0,ROOT.kFALSE) RooMsgService.instance().setStreamStatus(1,ROOT.kFALSE) filename = [ 'Histo_TT.root', 'Histo_JetHT.root' ] norm = [] nevents = [] histo = [] roohisto = [] histoCtl = [] roohistoCtl = [] # define observable x = RooRealVar('mTop','mTop',xmin,xmax) for ff in filename: inf = TFile.Open(ff) h = inf.Get('hadtopBoost/h_jetMassSoftDrop0_Cut_sig') norm.append((inf.Get('hadtopBoost/TriggerPass')).GetBinContent(1)) nevents.append(h.Integral()) print h.GetName() h.Rebin(rebin) hCtl = inf.Get('hadtopBoost/h_jetMassSoftDrop0_Cut_ctl') print hCtl.GetName() hCtl.Rebin(rebin) histo.append(h) histoCtl.append(hCtl) rooh = RooDataHist('roohist','roohist',RooArgList(x),h) roohisto.append(rooh)
def studyVqqResolution(rootFile): #get all from file histos={} inF=TFile.Open(rootFile) keys=inF.GetListOfKeys() for k in keys: obj=inF.Get(k.GetName()) obj.SetDirectory(0) histos[k.GetName()]=obj inF.Close() #plot gROOT.SetBatch() gROOT.SetStyle('Plain') gStyle.SetOptStat(0) gStyle.SetOptFit(1111) gStyle.SetOptTitle(0) gStyle.SetStatFont(42) kin=['','30to40','40to50','50to75','75to100','100toInf'] for k in kin: c=TCanvas('c','c',600,600) c.cd() c.SetCanvasSize(1000,500) c.SetWindowSize(1000,500) c.Divide(2,1) c.cd(1) histos['deta'+k+'barrel'].SetLineWidth(2) histos['deta'+k+'barrel'].SetTitle('barrel') histos['deta'+k+'barrel'].Draw('hist') histos['deta'+k+'endcap'].SetLineWidth(2) histos['deta'+k+'endcap'].SetLineStyle(7) histos['deta'+k+'endcap'].SetTitle('endcap') histos['deta'+k+'endcap'].Draw('histsame') leg=TLegend(0.6,0.92,0.9,0.98) leg.SetFillStyle(0) leg.SetBorderSize(0) leg.SetTextFont(42) leg.AddEntry(histos['deta'+k+'barrel'],'barrel','f') leg.AddEntry(histos['deta'+k+'endcap'],'endcap','f') leg.SetNColumns(2) leg.Draw() drawHeader() c.cd(2) histos['dphi'+k+'barrel'].SetLineWidth(2) histos['dphi'+k+'barrel'].SetTitle('barrel') histos['dphi'+k+'barrel'].Draw('hist') histos['dphi'+k+'endcap'].SetLineWidth(2) histos['dphi'+k+'endcap'].SetLineStyle(7) histos['dphi'+k+'endcap'].SetTitle('endcap') histos['dphi'+k+'endcap'].Draw('histsame') c.Modified() c.Update() c.SaveAs('dr_%s.png'%k) labels=[] responseVars=['dpt','den','dphi','deta','dr'] for r in responseVars: barrelResponse=TGraphErrors() barrelResponse.SetName(r+'barrelresponse') barrelResponse.SetLineWidth(2) barrelResponse.SetFillStyle(0) barrelResponse.SetMarkerStyle(20) barrelCoreResponse=barrelResponse.Clone(r+'barrelcoreresponse') endcapResponse=TGraphErrors() endcapResponse.SetName(r+'endcapresponse') endcapResponse.SetLineWidth(2) endcapResponse.SetFillStyle(0) endcapResponse.SetMarkerStyle(24) endcapCoreResponse=endcapResponse.Clone(r+'endcapresponse') for k in kin: c.cd() c.Clear() c.SetWindowSize(1000,500) c.Divide(2,1) for i in [1,2] : c.cd(i) reg='barrel' if i==2: reg='endcap' h=histos[r+k+reg] x=RooRealVar("x", h.GetXaxis().GetTitle(), h.GetXaxis().GetXmin(), h.GetXaxis().GetXmax()) data=RooDataHist("data", "dataset with x", RooArgList(x), h) frame=x.frame() RooAbsData.plotOn( data, frame, RooFit.DataError(RooAbsData.SumW2) ) mean1=RooRealVar("mean1","mean1",0,-0.5,0.5); sigma1=RooRealVar("sigma1","sigma1",0.1,0.01,1.0); gauss1=RooGaussian("g1","g",x,mean1,sigma1) if r=='dpt' or r=='den' : mean2=RooRealVar("mean2","mean2",0,-0.5,0.5); sigma2=RooRealVar("sigma2","sigma2",0.1,0.01,1.0); alphacb=RooRealVar("alphacb","alphacb",1,0.1,3); ncb=RooRealVar("ncb","ncb",4,1,100) gauss2 = RooCBShape("cb2","cb",x,mean2,sigma2,alphacb,ncb); else: mean1.setRange(0,0.5) mean2=RooRealVar("mean2","mean",0,0,1); sigma2=RooRealVar("sigma2","sigma",0.1,0.01,1.0); gauss2=RooGaussian("g2","g",x,mean2,sigma2) ; frac = RooRealVar("frac","fraction",0.9,0.0,1.0) if data.sumEntries()<100 : frac.setVal(1.0) frac.setConstant(True) model = RooAddPdf("sum","g1+g2",RooArgList(gauss1,gauss2), RooArgList(frac)) status=model.fitTo(data,RooFit.Save()).status() if status!=0 : continue model_cdf=model.createCdf(RooArgSet(x)) ; cl=0.90 ul=0.5*(1.0+cl) closestToCL=1.0 closestToUL=-1 closestToMedianCL=1.0 closestToMedian=-1 for ibin in xrange(1,h.GetXaxis().GetNbins()*10): xval=h.GetXaxis().GetXmin()+(ibin-1)*h.GetXaxis().GetBinWidth(ibin)/10. x.setVal(xval) cdfValToCL=math.fabs(model_cdf.getVal()-ul) if cdfValToCL<closestToCL: closestToCL=cdfValToCL closestToUL=xval cdfValToCL=math.fabs(model_cdf.getVal()-0.5) if cdfValToCL<closestToMedianCL: closestToMedianCL=cdfValToCL closestToMedian=xval RooAbsPdf.plotOn(model,frame) frame.Draw() if i==1: drawHeader() labels.append( TPaveText(0.6,0.92,0.9,0.98,'brNDC') ) ilab=len(labels)-1 labels[ilab].SetName(r+k+'txt') labels[ilab].SetBorderSize(0) labels[ilab].SetFillStyle(0) labels[ilab].SetTextFont(42) labels[ilab].SetTextAlign(12) kinReg=k.replace('to','-') kinReg=kinReg.replace('Inf','#infty') labels[ilab].AddText('['+reg+'] '+kinReg) labels[ilab].Draw() resolutionVal=math.fabs(closestToUL-closestToMedian) responseGr=barrelResponse responseCoreGr=barrelCoreResponse coreResolutionVal=sigma1.getVal() coreResolutionErr=sigma1.getError() if frac.getVal()<0.7 and (sigma2.getVal()<sigma1.getVal()) : coreResolutionVal=sigma2.getVal() coreResolutionErr=sigma2.getError() if i==2 : responseGr=endcapResponse responseCoreGr=endcapCoreResponse if k!='' : nrespPts=responseGr.GetN() kinAvg=150 kinWidth=50 if k=='30to40' : kinAvg=35 kinWidth=5 if k=='40to50' : kinAvg=45 kinWidth=5 if k=='50to75' : kinAvg=62.5 kinWidth=12.5 elif k=='75to100' : kinAvg=87.5 kinWidth=12.5 responseGr.SetPoint(nrespPts,kinAvg,resolutionVal) responseCoreGr.SetPoint(nrespPts,kinAvg,coreResolutionVal) responseCoreGr.SetPointError(nrespPts,kinWidth,coreResolutionErr) labels.append( TPaveText(0.15,0.7,0.4,0.9,'brNDC') ) ilab=len(labels)-1 labels[ilab].SetName(r+k+'fitrestxt') labels[ilab].SetBorderSize(0) labels[ilab].SetFillStyle(0) labels[ilab].SetTextFont(42) labels[ilab].SetTextAlign(12) labels[ilab].AddText('Gaussian #1 (f=%3.3f)'%frac.getVal()) labels[ilab].AddText('#mu=%3.3f#pm%3.3f'%(mean1.getVal(),mean1.getError())) labels[ilab].AddText('#sigma=%3.3f#pm%3.3f'%(sigma1.getVal(),sigma1.getError())) labels[ilab].AddText('Gaussian #2 (f=%3.3f)'%(1-frac.getVal())) labels[ilab].AddText('#mu=%3.3f#pm%3.3f'%(mean2.getVal(),mean2.getError())) labels[ilab].AddText('#sigma=%3.3f#pm%3.3f'%(sigma2.getVal(),sigma2.getError())) labels[ilab].Draw() c.Modified() c.Update() c.SaveAs(r+'res_'+k+'.png') frame=TGraphErrors() frame.SetPoint(0,0,0) frame.SetPoint(1,200,0.3) frame.SetMarkerStyle(1) frame.SetFillStyle(0) frame.SetName('frame') cresp=TCanvas('cresp','cresp',500,500) cresp.cd() frame.Draw('ap') barrelResponse.Draw('pl') endcapResponse.Draw('pl') frame.GetXaxis().SetTitle("Quark transverse momentum [GeV]") frame.GetYaxis().SetTitle("Resolution %3.2f C.L."%cl ) frame.GetYaxis().SetTitleOffset(1.4) frame.GetYaxis().SetNdivisions(10) drawHeader() leg=TLegend(0.6,0.92,0.9,0.98) leg.SetFillStyle(0) leg.SetBorderSize(0) leg.SetTextFont(42) leg.AddEntry(barrelResponse,'barrel','fp') leg.AddEntry(endcapResponse,'endcap','fp') leg.SetNColumns(2) leg.Draw() cresp.Modified() cresp.Update() cresp.SaveAs(r+'res_evol.png') frameCore=frame.Clone('framecore') cresp.Clear() frameCore.Draw('ap') barrelCoreResponse.Draw('pl') endcapCoreResponse.Draw('pl') frameCore.GetXaxis().SetTitle("Quark transverse momentum [GeV]") frameCore.GetYaxis().SetTitle("Core resolution") frameCore.GetYaxis().SetTitleOffset(1.4) frameCore.GetYaxis().SetNdivisions(10) frameCore.GetYaxis().SetRangeUser(0,0.2) drawHeader() leg=TLegend(0.6,0.92,0.9,0.98) leg.SetFillStyle(0) leg.SetBorderSize(0) leg.SetTextFont(42) leg.AddEntry(barrelCoreResponse,'barrel','fp') leg.AddEntry(endcapCoreResponse,'endcap','fp') leg.SetNColumns(2) leg.Draw() cresp.Modified() cresp.Update() cresp.SaveAs(r+'rescore_evol.png') bosons=['h','z','w'] kin=['','50','100'] region=['','bb','eb','ee'] for k in kin: for r in region: c=TCanvas('c','c',600,600) c.cd() histos['mjj'+k+r].Rebin() histos['mjj'+k+r].Draw() ic=1 leg=TLegend(0.6,0.92,0.9,0.98) leg.SetFillStyle(0) leg.SetBorderSize(0) leg.SetTextFont(42) leg.AddEntry(histos['mjj'+k+r],'inclusive','f') for b in bosons: if histos[b+'mjj'+k+r].Integral()<=0 : continue ic=ic+1 histos[b+'mjj'+k+r].Rebin() histos[b+'mjj'+k+r].SetLineColor(ic) histos[b+'mjj'+k+r].SetLineWidth(2) histos[b+'mjj'+k+r].SetMarkerColor(ic) histos[b+'mjj'+k+r].SetMarkerStyle(1) histos[b+'mjj'+k+r].SetFillStyle(3000+ic) histos[b+'mjj'+k+r].SetFillColor(ic) histos[b+'mjj'+k+r].Draw('histsame') leg.AddEntry(histos[b+'mjj'+k+r],b,"f") leg.SetNColumns(ic) leg.Draw() drawHeader() labels.append( TPaveText(0.65,0.8,0.9,0.9,'brNDC') ) ilab=len(labels)-1 labels[ilab].SetName(k+r+'mjj') labels[ilab].SetBorderSize(0) labels[ilab].SetFillStyle(0) labels[ilab].SetTextFont(42) labels[ilab].SetTextAlign(12) regionTitle="inclusive" if r == 'bb' : regionTitle='barrel-barrel' if r == 'eb' : regionTitle='endcap-barrel' if r == 'ee' : regionTitle='endcap-endcap' labels[ilab].AddText(regionTitle) ptthreshold=30 if k!='' : ptthreshold=float(k) labels[ilab].AddText('p_{T}>%3.0f GeV'%ptthreshold) labels[ilab].Draw() c.Modified() c.Update() c.SaveAs('mjj'+k+r+'.png') massResolutionGrs=[] for r in region: massResolution=TGraphErrors() massResolution.SetName(r+'dm') massResolution.SetLineWidth(2) massResolution.SetFillStyle(0) massResolution.SetMarkerStyle(20+len(massResolutionGrs)) massResolution.SetMarkerColor(1+len(massResolutionGrs)) massResolution.SetLineColor(1+len(massResolutionGrs)) massResolution.SetFillColor(1+len(massResolutionGrs)) massResolutionGrs.append(massResolution) for k in kin: c=TCanvas('c','c',600,600) c.cd() h=histos['dmjj'+k+r] x=RooRealVar("x", h.GetXaxis().GetTitle(), h.GetXaxis().GetXmin(), h.GetXaxis().GetXmax()) data=RooDataHist("data", "dataset with x", RooArgList(x), h) frame=x.frame() RooAbsData.plotOn( data, frame, RooFit.DataError(RooAbsData.SumW2) ) mean1=RooRealVar("mean1","mean1",0,-0.5,0.5); sigma1=RooRealVar("sigma1","sigma1",0.1,0.01,1.0); gauss1=RooGaussian("g1","g",x,mean1,sigma1) mean2=RooRealVar("mean2","mean2",0,-0.5,0.5); sigma2=RooRealVar("sigma2","sigma2",0.1,0.01,1.0); alphacb=RooRealVar("alphacb","alphacb",1,0.1,3); ncb=RooRealVar("ncb","ncb",4,1,100) gauss2 = RooCBShape("cb2","cb",x,mean2,sigma2,alphacb,ncb); frac = RooRealVar("frac","fraction",0.9,0.0,1.0) model = RooAddPdf("sum","g1+g2",RooArgList(gauss1,gauss2), RooArgList(frac)) status=model.fitTo(data,RooFit.Save()).status() if status!=0 : continue RooAbsPdf.plotOn(model,frame) frame.Draw() labels.append( TPaveText(0.6,0.65,0.85,0.9,'brNDC') ) ilab=len(labels)-1 labels[ilab].SetName(r+k+'dmfitrestxt') labels[ilab].SetBorderSize(0) labels[ilab].SetFillStyle(0) labels[ilab].SetTextFont(42) labels[ilab].SetTextAlign(12) labels[ilab].AddText('Gaussian #1 (f=%3.3f)'%frac.getVal()) labels[ilab].AddText('#mu=%3.3f#pm%3.3f'%(mean1.getVal(),mean1.getError())) labels[ilab].AddText('#sigma=%3.3f#pm%3.3f'%(sigma1.getVal(),sigma1.getError())) labels[ilab].AddText('Gaussian #2 (f=%3.3f)'%(1-frac.getVal())) labels[ilab].AddText('#mu=%3.3f#pm%3.3f'%(mean2.getVal(),mean2.getError())) labels[ilab].AddText('#sigma=%3.3f#pm%3.3f'%(sigma2.getVal(),sigma2.getError())) labels[ilab].Draw() drawHeader() labels.append( TPaveText(0.15,0.8,0.4,0.9,'brNDC') ) ilab=len(labels)-1 labels[ilab].SetName(k+r+'dmjj') labels[ilab].SetBorderSize(0) labels[ilab].SetFillStyle(0) labels[ilab].SetTextFont(42) labels[ilab].SetTextAlign(12) regionTitle="inclusive" if r == 'bb' : regionTitle='barrel-barrel' if r == 'eb' : regionTitle='endcap-barrel' if r == 'ee' : regionTitle='endcap-endcap' labels[ilab].AddText(regionTitle) ptthreshold=30 if k!='' : ptthreshold=float(k) labels[ilab].AddText('p_{T}>%3.0f GeV'%ptthreshold) labels[ilab].Draw() c.Modified() c.Update() c.SaveAs('dmjj'+k+r+'.png') massResolution.SetTitle(regionTitle) ip=massResolution.GetN() x=40 xerr=10 if k=='50' : x=75 xerr=25 elif k=='100': x=150 xerr=50 y=sigma1.getVal() yerr=sigma1.getError() if frac.getVal()<0.8: if sigma2.getVal()<sigma1.getVal(): y=sigma2.getVal() ey=sigma2.getError() massResolution.SetPoint(ip,x,y) massResolution.SetPointError(ip,xerr,yerr) frame=TGraphErrors() frame.SetPoint(0,0,0) frame.SetPoint(1,200,0.2) frame.SetMarkerStyle(1) frame.SetFillStyle(0) frame.SetName('dmframe') cdmevol=TCanvas('cdmevol','cdmevol',500,500) cdmevol.cd() frame.Draw('ap') leg=TLegend(0.6,0.92,0.9,0.98) leg.SetFillStyle(0) leg.SetBorderSize(0) leg.SetTextFont(42) for dmGr in massResolutionGrs : dmGr.Draw('pl') leg.AddEntry(dmGr,dmGr.GetTitle(),'fp') frame.GetXaxis().SetTitle("Leading quark transverse momentum [GeV]") frame.GetYaxis().SetTitle("Core resolution") frame.GetYaxis().SetTitleOffset(1.4) frame.GetYaxis().SetNdivisions(10) drawHeader() leg.SetNColumns(2) leg.Draw() cdmevol.Modified() cdmevol.Update() cdmevol.SaveAs('dm_evol.png') c=TCanvas('c','c',600,600) c.cd() histos['sel'].Draw('histtext') drawHeader() c.Modified() c.Update() c.SaveAs('selection.png') return
) sig_par = sig_parameters.createIterator() sig_par.Reset() sig_param = sig_par.Next() while sig_param: sig_param.Print() if TString(sig_param.GetName()).Contains( "rrv_mean_CB_ggH" ): ## copy the mean value for the DoubleCB and BW rrv_mean_CB = sig_param elif TString(sig_param.GetName()).Contains("rrv_sigma_CB_ggH"): rrv_sigma_CB = RooRealVar( "rrv_sigma_CB_ggH%s_signal_region_em_mlvj" % (mass), "rrv_sigma_CB_ggH%s_signal_region_em_mlvj" % (mass), sig_param.getVal() * options.narrow_factor, ) rrv_sigma_CB.setError(sig_param.getError() * options.narrow_factor) # rrv_sigma_CB = sig_param; # rrv_sigma_CB.setVal(sig_param.getVal()*options.narrow_factor); elif TString(sig_param.GetName()).Contains("rrv_alpha_CB_ggH"): rrv_alpha_CB = sig_param elif TString(sig_param.GetName()).Contains("rrv_n_CB_ggH"): rrv_n_CB = sig_param sig_param = sig_par.Next() ## cycle on DoubleCB parameters -> copy them in a new set sig_parameters2 = RooDoubleCrystalBall2.getParameters( old_workspace.data(datasetname + "_" + options.channel)
#from ROOT import * import optparse usage = "usage: %prog [options]" parser = optparse.OptionParser(usage) parser.add_option("-b", "--bash", action="store_true", default=False, dest="bash") (options, args) = parser.parse_args() if options.bash: gROOT.SetBatch(True) # ------------------------------------------- # 1. gau1 generate toy MC, use gau2 to fit x = RooRealVar("x","x",-10,10) xframe1 = x.frame(RooFit.Title("1. use gauss1 generate toy MC, use gauss2 to fit")) # ------------------------------------------- # 10. use Gaussian to test RooMCStudy # -------------------- def RooMCStudy_box( mgr1 , list_par ): print "" print "RooMCStudy_box" print ""
sys.exit(-2) elif args[0] not in input_data: print parser.print_usage() sys.exit(-2) from P2VV.Load import LHCbStyle from P2VV.RooFitWrappers import * from ROOT import RooRealVar from ROOT import RooDataSet from ROOT import RooArgSet from ROOT import RooCategory input_data = input_data[args[0]] weight = RooRealVar('sWeights_ipatia', 'sWeights_ipatia', -1e3, 1e3) momentum = RooRealVar('B_P', 'B_P', 0, 1e6, 'MeV') runPeriod = RooCategory('runPeriod', 'runPeriod') runPeriod.defineType('p2011', 2011) runPeriod.defineType('p2012', 2012) from ROOT import TFile if args[0].startswith('MC'): from ROOT import TFile sig_file = TFile(input_data['sig_cache']) sig_data = sig_file.Get(input_data['sig_dataset']) prompt_file = TFile(input_data['prompt_cache']) prompt_data = prompt_file.Get(input_data['prompt_dataset']) else: sig_file = TFile("/project/bfys/jleerdam/data/Bs2Jpsiphi/Reco14/fitNTuple_peakBkg_2011_2012_Reco14_TOS_HLT2B_20140415.root") sig_tree = sig_file.Get("DecayTree") period = 'p' + args[0][:4]
pi0mass = 134.9766 jpsimass = 3096.916 f = TFile.Open("root://hepgrid11.ph.liv.ac.uk///dpm/ph.liv.ac.uk/home/lhcb/eflow/Pi0Efficiency.CL16.MD.Turbo03LEPTONS.0.170412.00.root") t = f.Get("data") g = TFile.Open("root://hepgrid11.ph.liv.ac.uk///dpm/ph.liv.ac.uk/home/lhcb/eflow/Pi0Efficiency.CL16.MU.Turbo03LEPTONS.0.170412.00.root") u = g.Get("data") t.SetBranchStatus("ez*",0) hist = TH1F("h", "h", 100, 5200, 5400) hist2 = TH1F("h2", "h2", 100, 5000, 5700) kstmass = TH1F("kst", "kst", 100, 700, 1100) gamma_pt = TH1F("gamma_pt", "gamma_pt", 100, 0, 2000) m = RooRealVar("m", "m", 5200, 5400) argset = RooArgSet(m) m2 = RooRealVar("m2", "m2", 5000, 5600) g1pt = RooRealVar("gamma1_pt", "gamma1_pt", 0, 20000) g2pt = RooRealVar("gamma2_pt", "gamma2_pt", 0, 20000) argset2 = RooArgSet(m2, g1pt, g2pt) ds = RooDataSet("ds", "ds", argset) ds2 = RooDataSet("ds2", "ds2", argset2) counters = [0, 0, 0, 0, 0, 0] counters2 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] for aa in [t,u]: aa.SetBranchStatus("bp1*",0)
#! /bin/env python import os import sys import ROOT from ROOT import RooRealVar, RooGaussian, RooArgList from ROOT import RooVoigtian, RooCBShape, RooArgusBG, RooDecay from ROOT import RooGaussModel, RooFormulaVar, TCanvas from ROOT import RooFFTConvPdf, RooNumConvPdf, gPad, RooBreitWigner from ROOT import RooGenericPdf, TChain, RooDataSet, RooArgSet, RooFit, RooHistPdf # Measured variable x = RooRealVar( 'mass', 'mass', 4000, 7000 ) # Parameters mean = RooRealVar( 'mean', 'mean of gaussian', 0.0 ) sigma = RooRealVar( 'sigma', 'width of gaussian', 5.0 ) # Load reference ROOT tree full_ch = TChain("DecayTree") full_ch.Add("/mnt/home/kklimaszewski/LHCb/Bs2JpsieePhi/M_Bs_Fits/mc/DVNtuples_Bs2JpsieePhi_13154001_MCfull_R14ac_TupleBsDetached_PIDCorr_S21_NewSel_tupleB.root") # Run selection ch = full_ch.CopyTree("sigmam>0. && sigmam<250. && time>0.3 && time<14. && sigmat<0.12 && BDT_response_NewSel>0.2 && eminus_bremmult==0 && eplus_bremmult==0") #fit.mass.setBins(_comp['config']['bins']) # Create hist PDF data = RooDataSet( 'data_set', '', RooArgSet(x),
def buildDataAndCategories(ws,options,args): #Get the input data inputData = TChain(options.treeName,'The input data') for arg in args: print 'Adding data from: ',arg inputData.Add(arg) foldname = '' phirange = [0,90] if not options.folded: foldname='' phirange = [-180,180] #variables necessary for j/psi mass,lifetime,polarization fit jPsiMass = RooRealVar('JpsiMass','M [GeV]',2.7,3.5) jPsiRap = RooRealVar('JpsiRap','#nu',-2.3,2.3) jPsiPt = RooRealVar("JpsiPt","pT [GeV]",0,40); jPsicTau = RooRealVar('Jpsict','l_{J/#psi} [mm]',-1,2.5) jPsicTauError = RooRealVar('JpsictErr','Error on l_{J/#psi} [mm]',0,2) jPsiVprob = RooRealVar('JpsiVprob','',.01,1) jPsiHXcosth = None jPsiHXphi = None jPsicTau.setBins(10000,"cache") if options.fitFrame is not None: jPsiHXcosth = RooRealVar('costh_'+options.fitFrame+foldname,'cos(#theta)_{'+options.fitFrame+'}',-1,1) jPsiHXphi = RooRealVar('phi_'+options.fitFrame+foldname,'#phi_{'+options.fitFrame+'}',phirange[0],phirange[1]) else: jPsiHXcosth = RooRealVar('costh_CS'+foldname,'cos(#theta)_{CS}',-1,1) jPsiHXphi = RooRealVar('phi_CS'+foldname,'#phi_{CS}',phirange[0],phirange[1]) #vars needed for on the fly calc of polarization variables jPsimuPosPx = RooRealVar('muPosPx','+ Muon P_{x} [GeV]',0) jPsimuPosPy = RooRealVar('muPosPy','+ Muon P_{y} [GeV]',0) jPsimuPosPz = RooRealVar('muPosPz','+ Muon P_{z} [GeV]',0) jPsimuNegPx = RooRealVar('muNegPx','- Muon P_{x} [GeV]',0) jPsimuNegPy = RooRealVar('muNegPy','- Muon P_{y} [GeV]',0) jPsimuNegPz = RooRealVar('muNegPz','- Muon P_{z} [GeV]',0) #create RooArgSet for eventual dataset creation dataVars = RooArgSet(jPsiMass,jPsiRap,jPsiPt, jPsicTau,jPsicTauError, jPsimuPosPx,jPsimuPosPy,jPsimuPosPz) #add trigger requirement if specified if options.triggerName: trigger = RooRealVar(options.triggerName,'Passes Trigger',0.5,1.5) dataVars.add(trigger) dataVars.add(jPsiVprob) dataVars.add(jPsimuNegPx) dataVars.add(jPsimuNegPy) dataVars.add(jPsimuNegPz) dataVars.add(jPsiHXcosth) dataVars.add(jPsiHXphi) redVars = RooArgSet(jPsiMass,jPsiRap,jPsiPt, jPsicTau,jPsicTauError) redVars.add(jPsiHXcosth) redVars.add(jPsiHXphi) fitVars = redVars.Clone() ### HERE IS WHERE THE BIT FOR CALCULATING POLARIZATION VARS GOES ctauStates = RooCategory('ctauRegion','Cut Region in lifetime') ctauStates.defineType('prompt',0) ctauStates.defineType('nonPrompt',1) massStates = RooCategory('massRegion','Cut Region in mass') massStates.defineType('signal',1) massStates.defineType('separation',0) massStates.defineType('leftMassSideBand',-2) massStates.defineType('rightMassSideBand',-1) states = RooCategory('mlRegion','Cut Region in mass') states.defineType('nonPromptSignal',2) states.defineType('promptSignal',1) states.defineType('separation',0) states.defineType('leftMassSideBand',-2) states.defineType('rightMassSideBand',-1) #define corresponding ranges in roorealvars #mass is a little tricky since the sidebands change definitions in each rap bin #define the names here and change as we do the fits #jPsiMass.setRange('NormalizationRangeFormlfit_promptSignal',2.7,3.5) #jPsiMass.setRange('NormalizationRangeFormlfit_nonPromptSignal',2.7,3.5) #jPsiMass.setRange('NormalizationRangeFormlfit_leftMassSideBand',2.7,3.1) #jPsiMass.setRange('NormalizationRangeFormlfit_rightMassSideBand',3.1,3.5) #want the prompt fit only done in prompt region #non-prompt only in non-prompt region #background over entire cTau range #jPsicTau.setRange('NormalizationRangeFormlfit_promptSignal',-1,.1) #jPsicTau.setRange('NormalizationRangeFormlfit_nonPromptSignal',.1,2.5) #jPsicTau.setRange('NormalizationRangeFormlfit_leftMassSideBand',-1,2.5) #jPsicTau.setRange('NormalizationRangeFormlfit_rightMassSideBand',-1,2.5) #redVars.add(ctauStates) #redVars.add(massStates) #redVars.add(states) fitVars.add(ctauStates) fitVars.add(massStates) fitVars.add(states) fullData = RooDataSet('fullData','The Full Data From the Input ROOT Trees', dataVars, ROOT.RooFit.Import(inputData)) for rap_bin in range(1,len(jpsi.pTRange)): yMin = jpsi.rapForPTRange[rap_bin-1][0] yMax = jpsi.rapForPTRange[rap_bin-1][-1] for pt_bin in range(len(jpsi.pTRange[rap_bin])): ptMin = jpsi.pTRange[rap_bin][pt_bin][0] ptMax = jpsi.pTRange[rap_bin][pt_bin][-1] sigMaxMass = jpsi.polMassJpsi[rap_bin] + jpsi.nSigMass*jpsi.sigmaMassJpsi[rap_bin] sigMinMass = jpsi.polMassJpsi[rap_bin] - jpsi.nSigMass*jpsi.sigmaMassJpsi[rap_bin] sbHighMass = jpsi.polMassJpsi[rap_bin] + jpsi.nSigBkgHigh*jpsi.sigmaMassJpsi[rap_bin] sbLowMass = jpsi.polMassJpsi[rap_bin] - jpsi.nSigBkgLow*jpsi.sigmaMassJpsi[rap_bin] ctauNonPrompt = .1 massFun = RooFormulaVar('massRegion','Function that returns the mass state.', '('+jPsiMass.GetName()+' < '+str(sigMaxMass)+' && '+jPsiMass.GetName()+' > '+str(sigMinMass)+ ') - ('+jPsiMass.GetName()+' > '+str(sbHighMass)+')'+ '-2*('+jPsiMass.GetName()+' < '+str(sbLowMass)+')', RooArgList(jPsiMass,jPsicTau)) ctauFun = RooFormulaVar('ctauRegion','Function that returns the ctau state.', '('+jPsicTau.GetName()+' > '+str(ctauNonPrompt)+')', RooArgList(jPsiMass,jPsicTau)) mlFun = RooFormulaVar('mlRegion','Function that returns the mass and lifetime state.', '('+jPsiMass.GetName()+' < '+str(sigMaxMass)+' && '+jPsiMass.GetName()+' > '+str(sigMinMass)+ ') + ('+jPsiMass.GetName()+' < '+str(sigMaxMass)+' && '+jPsiMass.GetName()+' > '+ str(sigMinMass)+' && '+jPsicTau.GetName()+' > '+str(ctauNonPrompt)+ ') - ('+jPsiMass.GetName()+' > '+str(sbHighMass)+')'+ '-2*('+jPsiMass.GetName()+' < '+str(sbLowMass)+')', RooArgList(jPsiMass,jPsicTau)) cutStringPt = '('+jPsiPt.GetName()+' > '+str(ptMin)+' && '+jPsiPt.GetName()+' < '+str(ptMax)+')' cutStringY = '( abs('+jPsiRap.GetName()+') > '+str(yMin)+' && abs('+jPsiRap.GetName()+') < '+str(yMax)+')' #cutStringM1 = '('+jPsiMass.GetName()+' < '+str(sigMinMass)+' && '+jPsiMass.GetName()+' > '+str(sbLowMass)+')' #cutStringM2 = '('+jPsiMass.GetName()+' < '+str(sbHighMass)+' && '+jPsiMass.GetName()+' > '+str(sigMaxMass)+')' #cutStringMT = '!('+cutStringM1+' || '+cutStringM2+')' cutString = cutStringPt+' && '+cutStringY #+' && '+cutStringMT print cutString #get the reduced dataset we'll do the fit on binData = fullData.reduce(ROOT.RooFit.SelectVars(redVars), ROOT.RooFit.Cut(cutString), ROOT.RooFit.Name('data_rap'+str(rap_bin)+'_pt'+str(pt_bin+1)), ROOT.RooFit.Title('Data For Fitting')) binDataWithCategory = RooDataSet('data_rap'+str(rap_bin)+'_pt'+str(pt_bin+1), 'Data For Fitting', fitVars) #categorize binData.addColumn(ctauStates) binData.addColumn(massStates) binData.addColumn(states) for ev in range(binData.numEntries()): args = binData.get(ev) jPsiMass.setVal(args.find(jPsiMass.GetName()).getVal()) jPsiRap.setVal(args.find(jPsiRap.GetName()).getVal()) jPsiPt.setVal(args.find(jPsiPt.GetName()).getVal()) jPsicTau.setVal(args.find(jPsicTau.GetName()).getVal()) jPsicTauError.setVal(args.find(jPsicTauError.GetName()).getVal()) jPsiHXcosth.setVal(args.find(jPsiHXcosth.GetName()).getVal()) jPsiHXphi.setVal(args.find(jPsiHXphi.GetName()).getVal()) massStates.setIndex(int(massFun.getVal())) ctauStates.setIndex(int(ctauFun.getVal())) states.setIndex(int(mlFun.getVal())) binDataWithCategory.add(fitVars) getattr(ws,'import')(binDataWithCategory)
print '>> Extracting histograms from input root files...' file = aux_shapes + 'datacard.root' #file = aux_shapes + 'datacard_combine_1p.root' cb.cp().backgrounds().ExtractShapes( file, '$BIN/$PROCESS', '$BIN/$PROCESS_$SYSTEMATIC') cb.cp().signals().ExtractShapes( file, '$BIN/$PROCESS$MASS', '$BIN/$PROCESS$MASS_$SYSTEMATIC') tes = RooRealVar('tes', 'tes', 0.97, 1.03); tes.setConstant(True) f_debug = TFile('morph_debug.root', 'RECREATE') ws = RooWorkspace('htt', 'htt') bins = cb.bin_set() for bin in bins: for proc in procs['sig']: BuildRooMorphing(ws, cb, bin, proc, tes, "norm", True, True, False, f_debug) f_debug.Close() cb.AddWorkspace(ws, False) cb.cp().process(procs['sig']).ExtractPdfs(cb, "htt", "$BIN_$PROCESS_morph", "")
def doDataFit(Chib1_parameters,Chib2_parameters, cuts, inputfile_name = None, RooDataSet = None, ptBin_label='', plotTitle = "#chi_{b}",fittedVariable='qValue', printSigReso = False, noPlots = False, useOtherSignalParametrization = False, useOtherBackgroundParametrization = False, massFreeToChange = False, sigmaFreeToChange = False, legendOnPlot=True, drawPulls=False, titleOnPlot=False, cmsOnPlot=True, printLegend=True): if RooDataSet != None: dataSet = RooDataSet elif inputfile_name != None: print "Creating DataSet from file "+str(inputfile_name) dataSet = makeRooDataset(inputfile_name) else: raise ValueError('No dataset and no inputfile passed to function doDataFit') if(fittedVariable == 'refittedMass'): x_var = 'rf1S_chib_mass' output_suffix = '_refit' x_axis_label= 'm_{#mu^{+} #mu^{-} #gamma} [GeV]' else: x_var = 'invm1S' output_suffix = '_qValue' x_axis_label = 'm_{#gamma #mu^{+} #mu^{-}} - m_{#mu^{+} #mu^{-}} + m^{PDG}_{#Upsilon} [GeV]' cuts_str = str(cuts) #cuts_str = quality_cut + "photon_pt > 0.5 && abs(photon_eta) < 1.0 && ctpv < 0.01 && abs(dimuon_rapidity) < 1.3 && pi0_abs_mass > 0.025 && abs(dz) < 0.5" data = dataSet.reduce( RooFit.Cut(cuts_str) ) print 'Creating pdf' x=RooRealVar(x_var, 'm(#mu #mu #gamma) - m(#mu #mu) + m_{#Upsilon}',9.7,10.1,'GeV') numBins = 80 # define here so that if I change it also the ndof change accordingly x.setBins(numBins) # cristal balls mean_1 = RooRealVar("mean_1","mean ChiB1",Chib1_parameters.mean,"GeV") sigma_1 = RooRealVar("sigma_1","sigma ChiB1",Chib1_parameters.sigma,'GeV') a1_1 = RooRealVar('#alpha1_1', '#alpha1_1', Chib1_parameters.a1) n1_1 = RooRealVar('n1_1', 'n1_1', Chib1_parameters.n1) a2_1 = RooRealVar('#alpha2_1', '#alpha2_1',Chib1_parameters.a2) n2_1 = RooRealVar('n2_1', 'n2_1', Chib1_parameters.n2) parameters = RooArgSet(a1_1, a2_1, n1_1, n2_1) mean_2 = RooRealVar("mean_2","mean ChiB2",Chib2_parameters.mean,"GeV") sigma_2 = RooRealVar("sigma_2","sigma ChiB2",Chib2_parameters.sigma,'GeV') a1_2 = RooRealVar('#alpha1_2', '#alpha1_2', Chib2_parameters.a1) n1_2 = RooRealVar('n1_2', 'n1_2', Chib2_parameters.n1) a2_2 = RooRealVar('#alpha2_2', '#alpha2_2', Chib2_parameters.a2) n2_2 = RooRealVar('n2_2', 'n2_2', Chib2_parameters.n2) parameters.add(RooArgSet( a1_2, a2_2, n1_2, n2_2)) if massFreeToChange: # scale_mean = RooRealVar('scale_mean', 'Scale that multiplies masses found with MC', 0.8,1.2) # mean_1_fixed = RooRealVar("mean_1_fixed","mean ChiB1",Chib1_parameters.mean,"GeV") # mean_2_fixed = RooRealVar("mean_2_fixed","mean ChiB2",Chib2_parameters.mean,"GeV") # mean_1 = RooFormulaVar("mean_1",'@0*@1', RooArgList(scale_mean, mean_1_fixed)) # mean_2 = RooFormulaVar("mean_2",'@0*@1', RooArgList(scale_mean, mean_2_fixed)) variazione_m = 0.05 # 50 MeV diff_m_12 = RooRealVar('diff_m_12', 'Difference between masses chib1 and chib2',0.0194,'GeV') # 19.4 MeV from PDG mean_1=RooRealVar("mean_1","mean ChiB1",Chib1_parameters.mean,Chib1_parameters.mean-variazione_m,Chib1_parameters.mean+variazione_m ,"GeV") mean_2=RooFormulaVar('mean_2', '@0+@1',RooArgList(mean_1, diff_m_12)) # mean_2=RooRealVar("mean_2","mean ChiB2",Chib2_parameters.mean,Chib2_parameters.mean-variazione_m,Chib2_parameters.mean+variazione_m ,"GeV") parameters.add(mean_1) else: parameters.add(RooArgSet(mean_1, mean_2)) chib1_pdf = My_double_CB('chib1', 'chib1', x, mean_1, sigma_1, a1_1, n1_1, a2_1, n2_1) chib2_pdf = My_double_CB('chib2', 'chib2', x, mean_2, sigma_2, a1_2, n1_2, a2_2, n2_2) if sigmaFreeToChange: scale_sigma = RooRealVar('scale_sigma', 'Scale that multiplies sigmases found with MC', 1, 1.1)#1.01 sigma_1_fixed = RooRealVar("sigma_1","sigma ChiB1",Chib1_parameters.sigma,'GeV') sigma_2_fixed = RooRealVar("sigma_2","sigma ChiB2",Chib2_parameters.sigma,'GeV') sigma_1 = RooFormulaVar("sigma_1",'@0*@1', RooArgList(scale_sigma, sigma_1_fixed)) sigma_2 = RooFormulaVar("sigma_2",'@0*@1', RooArgList(scale_sigma, sigma_2_fixed)) parameters.add(scale_sigma) else: parameters.add(RooArgSet(sigma_1, sigma_2)) chib1_pdf = My_double_CB('chib1', 'chib1', x, mean_1, sigma_1, a1_1, n1_1, a2_1, n2_1) chib2_pdf = My_double_CB('chib2', 'chib2', x, mean_2, sigma_2, a1_2, n1_2, a2_2, n2_2) if useOtherSignalParametrization: # In this case I redefine cb_pdf cb1 = RooCBShape('cb1', 'cb1', x, mean_1, sigma_1, a1_1, n1_1) cb2 = RooCBShape('cb2', 'cb2', x, mean_2, sigma_2, a1_2, n1_2) # I use a2 as the sigma of my gaussian gauss1 = RooCBShape('gauss1', 'gauss1',x, mean_1, a2_1, a1_1, n1_1) gauss2 = RooCBShape('gauss2', 'gauss2',x, mean_2, a2_2, a1_2, n1_2) # I use n2 as the ratio of cb with respect to gauss chib1_pdf = RooAddPdf('chib1','chib1',RooArgList(cb1, gauss1),RooArgList(n2_1)) chib2_pdf = RooAddPdf('chib2','chib2',RooArgList(cb2, gauss2),RooArgList(n2_2)) #background q01S_Start = 9.5 alpha = RooRealVar("#alpha","#alpha",1.5,-1,3.5)#0.2 anziche' 1 beta = RooRealVar("#beta","#beta",-2.5,-7.,0.) q0 = RooRealVar("q0","q0",q01S_Start)#,9.5,9.7) delta = RooFormulaVar("delta","TMath::Abs(@0-@1)",RooArgList(x,q0)) b1 = RooFormulaVar("b1","@0*(@1-@2)",RooArgList(beta,x,q0)) signum1 = RooFormulaVar( "signum1","( TMath::Sign( -1.,@0-@1 )+1 )/2.", RooArgList(x,q0) ) background = RooGenericPdf("background","Background", "signum1*pow(delta,#alpha)*exp(b1)", RooArgList(signum1,delta,alpha,b1) ) if useOtherBackgroundParametrization: # in thies case I redefine background a0 = RooRealVar('a0','a0',1.,-1.,1.) #,0.5,0.,1.) a1 = RooRealVar('a1','a1',0.1,-1.,1.) #-0.2,0.,1.) #a2 = RooRealVar('a2','a2',-0.1,1.,-1.) background = RooChebychev('background','Background',x,RooArgList(a0,a1)) parameters.add(RooArgSet(a0, a1)) else: parameters.add(RooArgSet(alpha, beta, q0)) #together chibs = RooArgList(chib1_pdf,chib2_pdf,background) # ndof floatPars = parameters.selectByAttrib("Constant",ROOT.kFALSE) ndof = numBins - floatPars.getSize() - 1 # # Here I have as parameters N1, N2, and N_background # n_chib1 = RooRealVar("n_chib1","n_chib1",1250, 0, 50000) # n_chib2 = RooRealVar("n_chib2","n_chib2",825, 0, 50000) # n_background = RooRealVar('n_background','n_background',4550, 0, 50000) # ratio_list = RooArgList(n_chib1, n_chib2, n_background) # modelPdf = RooAddPdf('ModelPdf', 'ModelPdf', chibs, ratio_list) # Here I have as parameters N_12, ratio_12, N_background n_chib = RooRealVar("n_chib","n_chib",2075, 0, 100000) ratio_21 = RooRealVar("ratio_21","ratio_21",0.6, 0, 1) n_chib1 = RooFormulaVar("n_chib1","@0/(1+@1)",RooArgList(n_chib, ratio_21)) n_chib2 = RooFormulaVar("n_chib2","@0/(1+1/@1)",RooArgList(n_chib, ratio_21)) n_background = RooRealVar('n_background','n_background',4550, 0, 50000) ratio_list = RooArgList(n_chib1, n_chib2, n_background) parameters.add(RooArgSet(n_chib1, n_chib2, n_background)) modelPdf = RooAddPdf('ModelPdf', 'ModelPdf', chibs, ratio_list) print 'Fitting to data' fit_region = x.setRange("fit_region",9.7,10.1) result=modelPdf.fitTo(data,RooFit.Save(), RooFit.Range("fit_region")) # define frame frame = x.frame() frame.SetNameTitle("fit_resonance","Fit Resonanace") frame.GetXaxis().SetTitle(x_axis_label ) frame.GetYaxis().SetTitle( "Events/5 MeV " ) frame.GetXaxis().SetTitleSize(0.04) frame.GetYaxis().SetTitleSize(0.04) frame.GetXaxis().SetTitleOffset(1.1) frame.GetXaxis().SetLabelSize(0.04) frame.GetYaxis().SetLabelSize(0.04) frame.SetLineWidth(1) frame.SetTitle(plotTitle) # plot things on frame data.plotOn(frame, RooFit.MarkerSize(0.7)) chib1P_set = RooArgSet(chib1_pdf) modelPdf.plotOn(frame,RooFit.Components(chib1P_set), RooFit.LineColor(ROOT.kGreen+2), RooFit.LineStyle(2), RooFit.LineWidth(1)) chib2P_set = RooArgSet(chib2_pdf) modelPdf.plotOn(frame, RooFit.Components(chib2P_set),RooFit.LineColor(ROOT.kRed), RooFit.LineStyle(2), RooFit.LineWidth(1)) background_set = RooArgSet(background) modelPdf.plotOn(frame,RooFit.Components(background_set), RooFit.LineColor(ROOT.kBlack), RooFit.LineStyle(2), RooFit.LineWidth(1)) modelPdf.plotOn(frame, RooFit.LineWidth(2)) frame.SetName("fit_resonance") # Make numChib object numChib = NumChib(numChib=n_chib.getVal(), s_numChib=n_chib.getError(), ratio_21=ratio_21.getVal(), s_ratio_21=ratio_21.getError(), numBkg=n_background.getVal(), s_numBkg=n_background.getError(), corr_NB=result.correlation(n_chib, n_background),corr_NR=result.correlation(n_chib, ratio_21) , name='numChib'+output_suffix+ptBin_label,q0=q0.getVal(),s_q0=q0.getError(),alpha=alpha.getVal(),s_alpha=alpha.getError(), beta=beta.getVal(), s_beta=beta.getError(), chiSquare=frame.chiSquare()) #numChib.saveToFile('numChib'+output_suffix+'.txt') if noPlots: chi2 = frame.chiSquare() del frame return numChib, chi2 # Legend parameters_on_legend = RooArgSet()#n_chib, ratio_21, n_background) if massFreeToChange: #parameters_on_legend.add(scale_mean) parameters_on_legend.add(mean_1) #parameters_on_legend.add(mean_2) if sigmaFreeToChange: parameters_on_legend.add(scale_sigma) if massFreeToChange or sigmaFreeToChange: modelPdf.paramOn(frame, RooFit.Layout(0.1,0.6,0.2),RooFit.Parameters(parameters_on_legend)) if printLegend: #chiquadro, prob, numchib... leg = TLegend(0.48,0.75,0.97,0.95) leg.SetBorderSize(0) #leg.SetTextSize(0.04) leg.SetFillStyle(0) chi2 = frame.chiSquare() probChi2 = TMath.Prob(chi2*ndof, ndof) chi2 = round(chi2,2) probChi2 = round(probChi2,2) leg.AddEntry(0,'#chi^{2} = '+str(chi2),'') leg.AddEntry(0,'Prob #chi^{2} = '+str(probChi2),'') N_bkg, s_N_bkg = roundPair(numChib.numBkg, numChib.s_numBkg) leg.AddEntry(0,'N_{bkg} = '+str(N_bkg)+' #pm '+str(s_N_bkg),'') N_chib12, s_N_chib12 = roundPair(numChib.numChib, numChib.s_numChib) leg.AddEntry(0,'N_{#chi_{b}} = '+str(N_chib12)+' #pm '+str(s_N_chib12),'') Ratio = numChib.calcRatio() s_Ratio = numChib.calcRatioError() Ratio, s_Ratio = roundPair(Ratio, s_Ratio) leg.AddEntry(0,'N_{2}/N_{1} = '+str(Ratio)+' #pm '+str(s_Ratio),'') if printSigReso: # Add Significance Sig = numChib.calcSignificance() s_Sig = numChib.calcSignificanceError() Sig, s_Sig = roundPair(Sig, s_Sig) leg.AddEntry(0,'Sig = '+str(Sig)+' #pm '+str(s_Sig),'') if(Chib1_parameters.sigma>Chib2_parameters.sigma): Reso = Chib1_parameters.sigma * 1000 # So it's in MeV and not in GeV s_Reso = Chib1_parameters.s_sigma * 1000 # So it's in MeV and not in GeV else: Reso = Chib2_parameters.sigma * 1000 # So it's in MeV and not in GeV s_Reso = Chib2_parameters.s_sigma * 1000 # So it's in MeV and not in GeV Reso, s_Reso =roundPair(Reso, s_Reso) leg.AddEntry(0,'Reso = '+str(Reso)+' #pm '+str(s_Reso)+' MeV','') #N1 = numChib.numChib1 #s_N1 = numChib.s_numChib1 #N1, s_N1 = roundPair(N1, s_N1) #leg.AddEntry(0,'N_{1} = '+str(N1)+' #pm '+str(s_N1),'') #N2 = numChib.numChib2 #s_N2 = numChib.s_numChib2 #N2, s_N2 = roundPair(N2, s_N2) #leg.AddEntry(0,'N_{2} = '+str(N2)+' #pm '+str(s_N2),'') frame.addObject(leg) if legendOnPlot: # < pT < legend = TLegend(.06,.75,.53,.93) legend.SetFillStyle(0) legend.SetBorderSize(0) #legend.AddEntry(0,'CMS','') legend.AddEntry(0,str(cuts.upsilon_pt_lcut)+' GeV < p_{T}(#Upsilon) < '+str(cuts.upsilon_pt_hcut)+' GeV','') #legend.AddEntry(0,'p_{T}(#Upsilon)<'+str(cuts.upsilon_pt_hcut),'') frame.addObject(legend) if titleOnPlot: titleLegend = TLegend(.06,.4,.55,.73) #titleLegend.SetTextSize(0.03) titleLegend.SetFillStyle(0) titleLegend.SetBorderSize(0) titleLegend.AddEntry(0,plotTitle,'') frame.addObject(titleLegend) if cmsOnPlot: if printLegend: pvtxt = TPaveText(.1,.55,.55,.73,"NDC") else: pvtxt = TPaveText(0.5,0.75,0.97,0.9,"NDC") #(.06,.4,.55,.73) pvtxt.AddText('CMS Preliminary') pvtxt.AddText('pp, #sqrt{s} = 8 TeV') pvtxt.AddText('L = 20.7 fb^{-1}') pvtxt.SetFillStyle(0) pvtxt.SetBorderSize(0) pvtxt.SetTextSize(0.04) frame.addObject(pvtxt) # Canvas c1=TCanvas('Chib12_1P'+output_suffix+ptBin_label,'Chib12_1P'+output_suffix+ptBin_label) frame.Draw() if drawPulls: #c1=TCanvas(output_name+output_suffix,output_name+output_suffix,700, 625) hpull = frame.pullHist() framePulls = x.frame() framePulls.SetTitle(';;Pulls') framePulls.GetYaxis().SetLabelSize(0.18) framePulls.GetYaxis().SetTitle('Pulls') framePulls.GetYaxis().SetTitleSize(0.18) framePulls.GetYaxis().SetTitleOffset(0.15) framePulls.GetYaxis().SetNdivisions(005) framePulls.GetXaxis().SetLabelSize(0.16) framePulls.GetXaxis().SetTitle('') line0 = TLine(9.7, 0, 10.1, 0) line0.SetLineColor(ROOT.kBlue) line0.SetLineWidth(2) framePulls.addObject(line0) framePulls.addPlotable(hpull,"P") framePulls.SetMaximum(5) framePulls.SetMinimum(-5) pad1 = TPad("pad1", "The pad 80% of the height",0.0,0.2,1.0,1.0) pad1.cd() frame.Draw() pad2 = TPad("pad2", "The pad 20% of the height",0.0,0.01,1.0,0.2) pad2.cd() framePulls.Draw() c1.cd() pad1.Draw() pad2.Draw() #c1.SaveAs('Chib12_1P'+output_suffix+'.png') print 'Chi2 = '+str(frame.chiSquare()) # print ratio background/all in the signal refion signal_region = x.setRange("signal_region",9.87,9.92) pdf_integral = modelPdf.createIntegral(RooArgSet(x), RooFit.Range('signal_region')).getVal() * (n_chib.getVal() + n_background.getVal()) bkg_integral = background.createIntegral(RooArgSet(x), RooFit.Range('signal_region')).getVal() * n_background.getVal() print 'Ratio bkg/all in signal region = '+str(bkg_integral/pdf_integral) return numChib, c1