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 makeTTbarModel(workspace,label, model,channel, wtagger, constraint=[],peak="W", spectrum="_mj"): info ="" if label.find("_ttbar_data")!=-1 and label.find("fail")==-1: rrv_number_total = RooRealVar("rrv_number_total_ttbar_data"+info+"_"+channel,"rrv_number_total_ttbar_data"+info+"_"+channel,500,0.,1e10) eff_ttbar = RooRealVar("eff_ttbar_data"+info+"_"+channel,"eff_ttbar_data"+info+"_"+channel,0.7,0.2,1.0) if peak == "Wt":eff_ttbar = RooRealVar("eff_ttbar_data"+info+"_"+channel,"eff_ttbar_data"+info+"_"+channel,0.7,0.0,1.0) rrv_number = RooFormulaVar("rrv_number"+label+"_"+channel+spectrum, "@0*@1", RooArgList(eff_ttbar,rrv_number_total)) elif label.find("_ttbar_data")!=-1 and label.find("fail")!=-1: rrv_number_total = workspace.var("rrv_number_total_ttbar_data"+info+"_"+channel) eff_ttbar = workspace.var("eff_ttbar_data"+info+"_"+channel) rrv_number = RooFormulaVar("rrv_number"+label+"_"+channel+spectrum, "(1-@0)*@1", RooArgList(eff_ttbar,rrv_number_total)) elif label.find("_ttbar_TotalMC")!=-1 and label.find("fail")==-1: rrv_number_total = RooRealVar("rrv_number_total_ttbar_TotalMC"+info+"_"+channel,"rrv_number_total_ttbar_TotalMC"+info+"_"+channel,500,0.,1e10) eff_ttbar = RooRealVar("eff_ttbar_TotalMC"+info+"_"+channel,"eff_ttbar_TotalMC"+info+"_"+channel,0.7,0.2,1.0) if peak == "Wt": eff_ttbar = RooRealVar("eff_ttbar_TotalMC"+info+"_"+channel,"eff_ttbar_TotalMC"+info+"_"+channel,0.7,0.0,1.0) rrv_number = RooFormulaVar("rrv_number"+label+"_"+channel+spectrum, "@0*@1", RooArgList(eff_ttbar,rrv_number_total)) elif label.find("_ttbar_TotalMC")!=-1 and label.find("fail")!=-1: rrv_number_total = workspace.var("rrv_number_total_ttbar_TotalMC"+info+"_"+channel) eff_ttbar = workspace.var("eff_ttbar_TotalMC"+info+"_"+channel) rrv_number = RooFormulaVar("rrv_number"+label+"_"+channel+spectrum, "(1-@0)*@1", RooArgList(eff_ttbar,rrv_number_total)) model_pdf = MakeGeneralPdf(workspace,label,model,spectrum,wtagger,channel,constraint,peak) model = RooExtendPdf("model"+label+"_"+channel+spectrum,"model"+label+"_"+channel+spectrum, model_pdf, rrv_number) getattr(workspace,"import")(model) return workspace.pdf("model"+label+"_"+channel+spectrum)
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 fit(model, hists, fitmethod, eps=1.0e-7): """Fit beam shapes to Beam Imaging data. model: Beam shape model (derived from BeamShapeCore). hists: List of four TH2F with BI data. fitmethod: Function(pdf, data) that fits pdf to data. eps: Value of convergence criteria. """ RooAbsReal.defaultIntegratorConfig().setEpsAbs(eps) RooAbsReal.defaultIntegratorConfig().setEpsRel(eps) modfuncs = model.model_functions() datahist = [ RooDataHist('scan{0}Beam{1}RestDataHist'.format(c, i), 'scan{0}Beam{1}RestDataHist'.format(c, i), RooArgList(model.xvar(), model.yvar()), hists[j]) for j, (i, c) in enumerate(ic) ] sample = RooCategory('sample', 'sample') for (i, c) in ic: sample.defineType('{0}_ScanData_Beam{1}Rest'.format(c, i)) combdata = RooDataHist('combdata', 'combined data', RooArgList(model.xvar(), model.yvar()), RooFit.Index(sample), RooFit.Import('X_ScanData_Beam1Rest', datahist[0]), RooFit.Import('Y_ScanData_Beam1Rest', datahist[1]), RooFit.Import('X_ScanData_Beam2Rest', datahist[2]), RooFit.Import('Y_ScanData_Beam2Rest', datahist[3])) simpdf = RooSimultaneous('simpdf', 'simultaneous pdf', sample) for j, (i, c) in enumerate(ic): simpdf.addPdf(modfuncs[j], '{0}_ScanData_Beam{1}Rest'.format(c, i)) result = fitmethod(simpdf, combdata) return result, modfuncs, datahist
def makePlot(s): if (type(s) == TH1D): s.SetStats(0) x = RooRealVar("x", "x", 0, 3) l = RooArgList(x) dh = RooDataHist("dh", "dh", l, s) frame = x.frame() dh.plotOn(frame) #frame.SetTitle(name) #frame.GetXaxis().SetTitle(s.GetXaxis().GetTitle()) frame.GetYaxis().SetTitle(s.GetYaxis().GetTitle()) # frame.GetYaxis().SetTopMargin(0.15) #frame.Draw(draw) return frame elif (type(s) == TH2D): s.SetStats(0) x = RooRealVar("x", "x", 0, 3) y = RooRealVar("y", "y", 0, 3) l = RooArgList(x, y) dh = RooDataHist("dh", "dh", l, s) t = TGraph2D(s) s.SetMarkerSize(1.0) s.SetMarkerStyle(1) #t.GetXaxis().SetTitle(s.GetXaxis().GetTitle()) return s elif (type(s) == TGraph2D): s.SetMarkerSize(1.0) s.SetMarkerStyle(1) return s
def RooFitSig(mbbarray, bdtarray, weightarray, TC_mass, binstart, binend): fitstart = 40 fitend = 150 mbbarray = range(200) bdtarray = range(200) weightarray = range(200) mass = RooRealVar("X", "m(bb)[GeV]", fitstart, fitend) BDT = RooRealVar("BDT", "BDT", -1, 100) weight = RooRealVar("weight", "weight", -100, 200) branchnames = ["X", "BDT", "weight"] dtype = np.dtype([(branchnames[idx], np.float64) for idx in range(len(branchnames))]) treearray = np.array([(mbbarray[idx], bdtarray[idx], weightarray[idx]) for idx in range(len(mbbarray))], dtype) tree = rnp.array2tree(treearray) m0 = RooRealVar("m0", "m0", TC_mass * 1., TC_mass * 1. - 60., TC_mass * 1. + 60.) m02 = RooRealVar("m02", "m02", TC_mass * 1., TC_mass * 1. - 60., TC_mass * 1. + 60.) alpha = RooRealVar("alpha", "alpha", 1.295, 1.0, 1.6) sigma2 = RooRealVar("sigma2", "sigma2", 35, 8., 100) n = RooRealVar("n", "n", 5, 1, 35) mean = RooRealVar("mean", "mean of gaussian", 750, 0, 6000) sigma = RooRealVar("sigma", "width of gaussian", 90, 38, 300) gauss = RooGaussian("gauss", "gaussian PDF", mass, m0, sigma) gauss2 = RooGaussian("gauss2", "gaussian PDF", mass, m02, sigma2) CBshape = RooCBShape("CBshape", "Crystal Ball PDF", mass, m0, sigma2, alpha, n) ##PDF normalization num1 = RooRealVar("num1", "number of events", 400, 0, 5000) ##relative weight of 2 PDFs f = RooRealVar("f", "f", 0.95, 0.6, 1) sigPdf = RooAddPdf("sigPdf", "Signal PDF", RooArgList(CBshape, gauss), RooArgList(f)) extPdf = RooExtendPdf("extPdf", "extPdf", sigPdf, num1) data = RooDataSet("data", "data", tree, RooArgSet(mass, BDT, weight), "BDT>0", "weight") xframe = mass.frame() mass.setBins(20) data.plotOn(xframe) extPdf.plotOn( xframe) #,Normalization(1.0,RooAbsReal.RelativeExpected),LineColor(1)) hist = extPdf.createHistogram("X", fitend - fitstart) hist.SetAxisRange(binstart, binend) return deepcopy(hist)
def rooFit203(): print ">>> setup model..." x = RooRealVar("x", "x", -10, 10) mean = RooRealVar("mean", "mean of gaussian", 0, -10, 10) gauss = RooGaussian("gauss", "gaussian PDF", x, mean, RooConst(1)) # Construct px = 1 (flat in x) px = RooPolynomial("px", "px", x) # Construct model = f*gx + (1-f)px f = RooRealVar("f", "f", 0., 1.) model = RooAddPdf("model", "model", RooArgList(gauss, px), RooArgList(f)) data = model.generate(RooArgSet(x), 10000) # RooDataSet print ">>> fit to full data range..." result_full = model.fitTo(data, Save(kTRUE)) # RooFitResult print "\n>>> fit \"signal\" range..." # Define "signal" range in x as [-3,3] x.setRange("signal", -3, 3) result_sig = model.fitTo(data, Save(kTRUE), Range("signal")) # RooFitResult print "\n>>> plot and print results..." # Make plot frame in x and add data and fitted model frame1 = x.frame(Title("Fitting a sub range")) # RooPlot data.plotOn(frame1, Name("data")) model.plotOn(frame1, Range("Full"), LineColor(kBlue), Name("model")) # Add shape in full ranged dashed model.plotOn(frame1, LineStyle(kDashed), LineColor(kRed), Name("model2")) # By default only fitted range is shown print "\n>>> result of fit on all data:" result_full.Print() print "\n>>> result of fit in in signal region (note increased error on signal fraction):" result_sig.Print() print ">>> draw on canvas..." canvas = TCanvas("canvas", "canvas", 100, 100, 800, 600) legend = TLegend(0.2, 0.85, 0.4, 0.65) legend.SetTextSize(0.032) legend.SetBorderSize(0) legend.SetFillStyle(0) gPad.SetLeftMargin(0.14) gPad.SetRightMargin(0.02) frame1.GetYaxis().SetLabelOffset(0.008) frame1.GetYaxis().SetTitleOffset(1.4) frame1.GetYaxis().SetTitleSize(0.045) frame1.GetXaxis().SetTitleSize(0.045) frame1.Draw() legend.AddEntry("data", "data", 'LEP') legend.AddEntry("model", "fit (full range)", 'L') legend.AddEntry("model2", "fit (signal range)", 'L') legend.Draw() canvas.SaveAs("rooFit203.png")
def fitNSig(ibdt, fulldata, isample): mean = RooRealVar("mass", "mean", B0Mass_, 3, 7, "GeV") sigma = RooRealVar("#sigma_{1}", "sigma", 0.028, 0, 10, "GeV") signalGauss = RooGaussian("signalGauss", "signal gauss", theBMass, mean, sigma) sigma2 = RooRealVar("#sigma_{2}", "sigma2", 0.048, 0, 0.09, "GeV") signalGauss2 = RooGaussian("signalGauss2", "signal gauss2", theBMass, mean, sigma2) f1 = RooRealVar("f1", "f1", 0.8, 0., 1.) gaus = RooAddPdf("gaus", "gaus1+gaus2", RooArgList(signalGauss, signalGauss2), RooArgList(f1)) pol_c1 = RooRealVar("p1", "coeff x^0 term", 0.5, -10, 10) pol_c2 = RooRealVar("p2", "coeff x^1 term", 0.5, -10, 10) # pol_c3 = RooRealVar ("p3" , "coeff x^2 term", 0.5, -10, 10); # slope = RooRealVar ("slope" , "slope" , 0.5, -10, 10); # bkg_exp = RooExponential("bkg_exp" , "exponential" , slope, theBMass ); bkg_pol = RooChebychev("bkg_pol", "2nd order pol", theBMass, RooArgList(pol_c1)) nsig = RooRealVar("Yield", "signal frac", 40000, 0, 1000000) nbkg = RooRealVar("nbkg", "bkg fraction", 1000, 0, 550000) cut = cut_base + '&& bdt_prob > %s' % (ibdt) data = fulldata.reduce(RooArgSet(theBMass, mumuMass, mumuMassE), cut) fitFunction = RooAddPdf("fitfunction", "fit function", RooArgList(gaus, bkg_pol), RooArgList(nsig, nbkg)) r = fitFunction.fitTo(data, RooFit.Extended(True), RooFit.Save(), RooFit.Range(4.9, 5.6), RooFit.PrintLevel(-1)) frame = theBMass.frame() data.plotOn(frame, RooFit.Binning(70), RooFit.MarkerSize(.7)) fitFunction.plotOn(frame, ) fitFunction.plotOn(frame, RooFit.Components("bkg_pol"), RooFit.LineStyle(ROOT.kDashed)) fitFunction.plotOn(frame, RooFit.Components("signalGauss"), RooFit.LineStyle(ROOT.kDashed), RooFit.LineColor(ROOT.kGreen + 1)) fitFunction.plotOn(frame, RooFit.Components("signalGauss2"), RooFit.LineStyle(ROOT.kDashed), RooFit.LineColor(ROOT.kOrange + 1)) parList = RooArgSet(nsig, sigma, sigma2, mean) ###### fitFunction.plotOn(frame, RooFit.Components("signalGauss2"), RooFit.LineStyle(ROOT.kDashed), RooFit.LineColor(ROOT.kGreen+2)); fitFunction.paramOn(frame, RooFit.Parameters(parList), RooFit.Layout(0.62, 0.86, 0.88)) canv = ROOT.TCanvas() frame.Draw() # canv.SaveAs('sig_fit_bdt%f_sample%i.pdf'%(ibdt,isample)) dict_s_v1[ibdt] = [nsig.getVal(), nsig.getError()] dict_sigma[ibdt] = math.sqrt(f1.getVal() * (sigma.getVal()**2) + (1 - f1.getVal()) * (sigma2.getVal()**2))
def rooFit103(): print ">>> construct generic pdf from interpreted expression..." # To construct a proper p.d.f, the formula expression is explicitly normalized internally # by dividing it by a numeric integral of the expresssion over x in the range [-20,20] x = RooRealVar("x", "x", -20, 20) alpha = RooRealVar("alpha", "alpha", 5, 0.1, 10) genpdf = RooGenericPdf("genpdf", "genpdf", "(1+0.1*abs(x)+sin(sqrt(abs(x*alpha+0.1))))", RooArgList(x, alpha)) print ">>> generate and fit toy data...\n" data = genpdf.generate(RooArgSet(x), 10000) # RooDataSet genpdf.fitTo(data) frame1 = x.frame(Title("Interpreted expression pdf")) # RooPlot data.plotOn(frame1, Binning(40)) genpdf.plotOn(frame1) print "\n>>> construct standard pdf with formula replacing parameter..." mean2 = RooRealVar("mean2", "mean^2", 10, 0, 200) sigma = RooRealVar("sigma", "sigma", 3, 0.1, 10) mean = RooFormulaVar("mean", "mean", "sqrt(mean2)", RooArgList(mean2)) gaus2 = RooGaussian("gaus2", "gaus2", x, mean, sigma) print ">>> generate and fit toy data...\n" gaus1 = RooGaussian("gaus1", "gaus1", x, RooConst(10), RooConst(3)) data2 = gaus1.generate(RooArgSet(x), 1000) # RooDataSet result = gaus2.fitTo(data2, Save()) # RooFitResult result.Print() frame2 = x.frame(Title("Tailored Gaussian pdf")) # RooPlot data2.plotOn(frame2, Binning(40)) gaus2.plotOn(frame2) print "\n>>> draw pfds and fits on canvas..." canvas = TCanvas("canvas", "canvas", 100, 100, 1400, 600) canvas.Divide(2) canvas.cd(1) gPad.SetLeftMargin(0.15) gPad.SetRightMargin(0.02) frame1.GetYaxis().SetLabelOffset(0.008) frame1.GetYaxis().SetTitleOffset(1.6) frame1.GetYaxis().SetTitleSize(0.045) frame1.GetXaxis().SetTitleSize(0.045) frame1.Draw() canvas.cd(2) gPad.SetLeftMargin(0.15) gPad.SetRightMargin(0.02) frame2.GetYaxis().SetLabelOffset(0.008) frame2.GetYaxis().SetTitleOffset(1.6) frame2.GetYaxis().SetTitleSize(0.045) frame2.GetXaxis().SetTitleSize(0.045) frame2.Draw() canvas.SaveAs("rooFit103.png")
def test_correlated_values(): try: import uncertainties except ImportError: raise SkipTest("uncertainties package is not installed") from rootpy.stats.correlated_values import correlated_values # 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)) nsig, nbkg = correlated_values(["nsig", "nbkg"], fitresult) # Arbitrary math expression according to what the `uncertainties` # package supports, automatically computes correct error propagation sum_value = nsig + nbkg value, error = sum_value.nominal_value, sum_value.std_dev workspace = Workspace(name='workspace') # import the data assert_false(workspace(data)) with TemporaryFile(): workspace.Write()
def toy_run(nevents): lower = -1 upper = 1 # create observables obs = RooRealVar("obs", "obs1", lower, upper) # create parameters mean1 = RooRealVar("mean1", "mean of gaussian", 0, -1, 1) sigma1 = RooRealVar("sigma1", "sigma of gaussian", 0.1, -1, 1) gauss1 = RooGaussian("gauss1", "gaussian PDF", obs, mean1, sigma1) mean2 = RooRealVar("mean2", "mean of gaussian", 0.5, -1, 1) sigma2 = RooRealVar("sigma2", "sigma of gaussian", 0.2, -1, 1) gauss2 = RooGaussian("gauss2", "gaussian PDF", obs, mean2, sigma2) frac = RooRealVar("frac", "Fraction of a gauss", 0.5, 0, 1) arg_list = RooArgList( gauss1, gauss2, gauss2, gauss2, gauss2, # gauss2, gauss2, gauss2, gauss1) arg_list.addOwned(gauss2) pdf = RooAddPdf( "sum_pdf", "sum of pdfs", arg_list, RooArgList( frac, frac, frac, # frac, # frac, frac, frac, frac, frac, frac)) # obs, pdf = build_pdf() timer = zfit_benchmark.timer.Timer(f"Toys {nevents}") with timer: data = pdf.generate(RooArgSet(obs), nevents) pdf.fitTo(data) # mgr.generateAndFit(n_toys, nevents) return float(timer.elapsed)
def addAsciiData(self, ws, ds_name, item_title, var_set_name, var_set_type, ds_file_name, weight_var_name=None, debug=0, sets=None): legend = '[exostConfig::addAsciiData]:' arg_set = RooArgSet() if (var_set_type == 'set'): #_var_set = ws.set(var_set_name) _var_set = sets[var_set_name] arg_set.add(_var_set) if _var_set.getSize() != 1: print legend, 'Error: too many or too few columns in the input ASCII file' print legend, 'Error: Smart program as I am, I can only handle ASCII files' print legend, 'Error: with exactly one column at the moment.' print legend, 'Error: Support for multiple columns will be implemented' print legend, 'Error: eventually, contact the developers.' print legend, 'Error: Better yet, switch to ROOT input files,' print legend, 'Error: all the cool kids are doing that!' return -1 elif (var_set_type == 'var'): arg_set.add(ws.var(var_set_name)) else: print legend, 'error: unknown var_set_type, cannot create dataset', ds_name return -1 #create the dataset if weight_var_name == None: #no weight if (debug > 0): print legend, 'no weight variable given' _arglist = RooArgList(arg_set) #ds = RooDataSet()ds_name, item_title) ds = RooDataSet.read(ds_file_name, _arglist) ds.SetName(ds_name) ds.SetTitle(item_title) else: if (debug > 0): print legend, 'using variable', weight_var_name, 'as weight' print legend, 'Error: Smart program as I am, I cannot handle' print legend, 'Error: weights when loading from ASCII files yet.' print legend, 'Error: Support for weights from ASCII files will' print legend, 'Error: be implemented eventually, contact the developers.' print legend, 'Error: Better yet, switch to ROOT input files,' print legend, 'Error: all the cool kids are doing that!' return -1 # import the datahist. Note workaround 'import' being a reserved word getattr(ws, 'import')(ds)
def get_dataset(varargset, ftree, cut='', wt='', scale=1): """Return a dataset. Return a dataset from the ntuple `ftree'. Apply a selection cut using the `cutVar' variable and the selection `cut'. """ from rplot.fixes import ROOT from rplot.tselect import Tsplice splice = Tsplice(ftree) splice.make_splice('sel', cut) from ROOT import RooDataSet, RooFit, RooFormulaVar, RooArgList tmpdst = RooDataSet('tmpdataset', '', varargset, RooFit.Import(ftree)) if wt: wtvar = RooFormulaVar('wt', '{}*@0'.format(scale), RooArgList(varargset[wt])) wtvar = tmpdst.addColumn(wtvar) varargset.remove(varargset[wt]) varargset.add(wtvar) dst = RooDataSet('dataset', 'Dataset', varargset, RooFit.Import(tmpdst), RooFit.WeightVar(wtvar)) varargset.remove(wtvar) dst = dst.reduce(varargset) return dst
def makeHistPdf(hist, ws, x): theVars = RooArgList(x) v = RooArgSet(x) dataHist = RooDataHist(hist.GetName() + '_dh', 'dataHist', theVars, hist) hpdf = RooHistPdf(hist.GetName() + '_pdf', 'hist pdf', v, dataHist) getattr(ws, 'import')(hpdf) return hpdf
def RooParametricHist(self,name=''): '''Produce a RooParametricHist2D filled with this object's binVars. Returns: RooParametricHist2D: Output RooFit object to pass to Combine. ''' out_rph = {} out_add = {} for cat in _subspace: cat_name = self.name+'_'+cat cat_hist = self.binning.CreateHist(cat_name+'_temp',cat) obj_name = '%s_%s'%(name if name != '' else self.name, cat) self.binArgLists[cat] = RooArgList() for ybin in range(1,len(self.binning.ybinList)): for xbin in range(1,len(self.binning.xbinByCat[cat])): bin_name = '%s_bin_%s-%s'%(cat_name,xbin,ybin) self.binArgLists[cat].add(self.binVars[bin_name]) out_rph[cat] = RooParametricHist2D( obj_name, obj_name, self.binning.xVars[cat], self.binning.yVar, self.binArgLists[cat], cat_hist ) out_add[cat] = RooAddition(obj_name+'_norm',obj_name+'_norm',self.binArgLists[cat]) return out_rph, out_add
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 getInitialFitRes(cfg, ws): """ Create a prefit RooExpandedFitResult for this workspace """ mc = ws.obj("ModelConfig") force_mu, mu_val = cfg.force_mu_value() if force_mu: mc.GetParametersOfInterest().first().setVal(mu_val) np = RooArgList(mc.GetNuisanceParameters()) np.add(mc.GetParametersOfInterest()) ws.loadSnapshot("snapshot_paramsVals_initial") #removeGamma(np) it = np.createIterator() n = it.Next() while n: if "alpha" in n.GetName(): n.setError(1) else: n.setError(1.e-4) #if "alpha_SysJetEResol" in n.GetName(): #n.setVal(-1) n = it.Next() ws.saveSnapshot("vars_initial", RooArgSet(np)) re = ROOT.RooExpandedFitResult(np) cfg._muhat = mc.GetParametersOfInterest().first().getVal() if logging.getLogger().isEnabledFor(logging.DEBUG): logging.debug("Expanded RooFit results") re.Print("v") return re
def doFit(hist,output,rap="BB",flavour="DATA",trackType="TunePNew",funct="doubleCB"): sig = [] sige = [] meanList = [] meanListe = [] nChi2 = [] gSystem.Load("./RooCruijff_cxx.so") gSystem.Load("./RooDCBShape_cxx.so") for i,h in enumerate(hist): ws = RooWorkspace("tempWS") mass = RooRealVar('mass','mass',91, xLow, xHigh ) getattr(ws,'import')(mass,RooCmdArg()) dataHist = RooDataHist("hist","hist",RooArgList(ws.var("mass")),h) getattr(ws,'import')(dataHist,RooCmdArg()) ws.writeToFile("tmpWorkspace.root") subprocess.call(["python","fitCapsule.py",output,rap,flavour,trackType,funct,"%d"%xLow,"%d"%xHigh,"%d"%rebinFactor,"%d"%i]) returnFile = TFile("tmpWorkspaceReturn.root","OPEN") wsReturn = returnFile.Get("tempWS") sig.append(wsReturn.var("Sig").getVal()) sige.append(wsReturn.var("Sige").getVal()) meanList.append(wsReturn.var("Mean").getVal()) meanListe.append(wsReturn.var("Meane").getVal()) nChi2.append(wsReturn.var("chi2").getVal()/wsReturn.var("nDOF").getVal()) return meanList,meanListe,sig,sige, nChi2
def make_weighted_dataset(subproc,ws,tree,mc_events): data = RooDataSet('%s_shape_data'%subproc, 'M_{ll#gamma} Shape Data for %s'%subproc, tree, ws.set('vars_with_weights') ) mc_yield_var = RooConstVar('temp','temp',mc_events) weighter = RooFormulaVar('weight','weight','@0*@1/@2', RooArgList( ws.var('procWeight'), ws.var('puWeight'), mc_yield_var ) ) data.addColumn(weighter) data_total_weight = RooDataSet('%s_shape_data'%subproc, 'M_{ll#gamma} Shape Data for %s'%subproc, data, ws.set('vars_with_weights_final'), '','weight') data_pu_weight = RooDataSet('%s_shape_data_puonly'%subproc, 'M_{ll#gamma} Shape Data for %s'%subproc, data, ws.set('vars_with_weights_final'), '','puWeight') return data_total_weight, data_pu_weight
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 add_data(self, data_histogram): print "[MjFit.add_data] INFO : Adding data histogram" # Add a data histogram self.data_histogram_ = data_histogram.Clone() self.data_histogram_.SetDirectory(0) self.data_roohistogram_ = RooDataHist('data_roohistogram','data_roohistogram',RooArgList(self.mjj_),self.data_histogram_) self.data_roohistogram_.Print()
def addHistData(self, ws, ds_name, item_title, var_set_name, var_set_type, ds_object, sets=None): legend = '[exostConfig::addHistData]:' arg_list = RooArgList() if (var_set_type == 'set'): #arg_list.add(ws.set(var_set_name)) arg_list.add(sets[var_set_name]) elif (var_set_type == 'var'): arg_list.add(ws.var(var_set_name)) else: print legend, 'error: unknown var_set_type, cannot create dataset', ds_name return -1 #create the hist dataset ds = RooDataHist(ds_name, item_title, arg_list, ds_object, 1) # import the datahist. Note workaround 'import' being a reserved word getattr(ws, 'import')(ds)
def createWidthDeviation(self): '''Compute the width deviation (denoted \kappa_H^2 by M.Peskin in arxiv 1312.4974). Note that we fit an additive modification of the coupling: (1 + dx) is therefore equal to kappa_x ''' expr = '0' sumBR = sum(self.BR.values()) pwidths = [] for dcoupling, br in self.BR.iteritems(): pwidth = None if dcoupling in self.poi: pwidth = str( br / sumBR) + "*(1+" + dcoupling + ")*(1+" + dcoupling + ")" else: # using sm partial width pwidth = str(br / sumBR) pwidths.append(pwidth) expr = '+'.join(pwidths) if 'inv' in self.poi: expr = '(' + expr + ')/(1.0-inv)' else: # setting invisible width to 0. expr = '(' + expr + ')' dependentlist = RooArgList() for dep in self.poi.values(): dependentlist.add(dep) self.width = RooGenericPdf('width', 'width', expr, dependentlist)
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 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 _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 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