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 __init__(self, name, expr, deps): self.name = name self.expr = expr self.deps = deps dependentlist = RooArgList() for dep in deps: dependentlist.add(dep) self.pdf_yield = RooGenericPdf(name, name, expr, dependentlist) pname = name + "Constraint" self.pdf_constraint = RooUniform(pname, pname, RooArgSet(self.pdf_yield)) self.pulls = ROOT.TH1F('pulls_' + name, name, 1000, -10, 10)
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 main(): # usage description usage = "Example: ./scripts/createDatacards.py --inputData inputs/rawhistV7_Run2015D_scoutingPFHT_UNBLINDED_649_838_JEC_HLTplusV7_Mjj_cor_smooth.root --dataHistname mjj_mjjcor_gev --inputSig inputs/ResonanceShapes_gg_13TeV_Scouting_Spring15.root -f gg -o datacards -l 1866 --lumiUnc 0.027 --massrange 1000 1500 50 --runFit --p1 5 --p2 7 --p3 0.4 --massMin 838 --massMax 2037 --fitStrategy 2" # input parameters parser = ArgumentParser( description= 'Script that creates combine datacards and corresponding RooFit workspaces', epilog=usage) parser.add_argument("--inputData", dest="inputData", required=True, help="Input data spectrum", metavar="INPUT_DATA") parser.add_argument("--dataHistname", dest="dataHistname", required=True, help="Data histogram name", metavar="DATA_HISTNAME") parser.add_argument("--inputSig", dest="inputSig", required=True, help="Input signal shapes", metavar="INPUT_SIGNAL") parser.add_argument("-f", "--final_state", dest="final_state", required=True, help="Final state (e.g. qq, qg, gg)", metavar="FINAL_STATE") parser.add_argument("-f2", "--type", dest="atype", required=True, help="Type (e.g. hG, lG, hR, lR)") parser.add_argument( "-o", "--output_path", dest="output_path", required=True, help="Output path where datacards and workspaces will be stored", metavar="OUTPUT_PATH") parser.add_argument( "-l", "--lumi", dest="lumi", required=True, default=1000., type=float, help="Integrated luminosity in pb-1 (default: %(default).1f)", metavar="LUMI") parser.add_argument( "--massMin", dest="massMin", default=500, type=int, help= "Lower bound of the mass range used for fitting (default: %(default)s)", metavar="MASS_MIN") parser.add_argument( "--massMax", dest="massMax", default=1200, type=int, help= "Upper bound of the mass range used for fitting (default: %(default)s)", metavar="MASS_MAX") parser.add_argument( "--p1", dest="p1", default=5.0000e-03, type=float, help="Fit function p1 parameter (default: %(default)e)", metavar="P1") parser.add_argument( "--p2", dest="p2", default=9.1000e+00, type=float, help="Fit function p2 parameter (default: %(default)e)", metavar="P2") parser.add_argument( "--p3", dest="p3", default=5.0000e-01, type=float, help="Fit function p3 parameter (default: %(default)e)", metavar="P3") parser.add_argument( "--lumiUnc", dest="lumiUnc", required=True, type=float, help="Relative uncertainty in the integrated luminosity", metavar="LUMI_UNC") parser.add_argument("--jesUnc", dest="jesUnc", type=float, help="Relative uncertainty in the jet energy scale", metavar="JES_UNC") parser.add_argument( "--jerUnc", dest="jerUnc", type=float, help="Relative uncertainty in the jet energy resolution", metavar="JER_UNC") parser.add_argument( "--sqrtS", dest="sqrtS", default=13000., type=float, help="Collision center-of-mass energy (default: %(default).1f)", metavar="SQRTS") parser.add_argument("--fixP3", dest="fixP3", default=False, action="store_true", help="Fix the fit function p3 parameter") parser.add_argument("--runFit", dest="runFit", default=False, action="store_true", help="Run the fit") parser.add_argument("--fitBonly", dest="fitBonly", default=False, action="store_true", help="Run B-only fit") parser.add_argument("--fixBkg", dest="fixBkg", default=False, action="store_true", help="Fix all background parameters") parser.add_argument("--decoBkg", dest="decoBkg", default=False, action="store_true", help="Decorrelate background parameters") parser.add_argument("--fitStrategy", dest="fitStrategy", type=int, default=1, help="Fit strategy (default: %(default).1f)") parser.add_argument("--debug", dest="debug", default=False, action="store_true", help="Debug printout") parser.add_argument( "--postfix", dest="postfix", default='', help="Postfix for the output file names (default: %(default)s)") parser.add_argument("--pyes", dest="pyes", default=False, action="store_true", help="Make files for plots") parser.add_argument("--jyes", dest="jyes", default=False, action="store_true", help="Make files for JES/JER plots") parser.add_argument( "--pdir", dest="pdir", default='testarea', help="Name a directory for the plots (default: %(default)s)") parser.add_argument("--chi2", dest="chi2", default=False, action="store_true", help="Compute chi squared") parser.add_argument("--widefit", dest="widefit", default=False, action="store_true", help="Fit with wide bin hist") mass_group = parser.add_mutually_exclusive_group(required=True) mass_group.add_argument( "--mass", type=int, nargs='*', default=1000, help= "Mass can be specified as a single value or a whitespace separated list (default: %(default)i)" ) mass_group.add_argument( "--massrange", type=int, nargs=3, help="Define a range of masses to be produced. Format: min max step", metavar=('MIN', 'MAX', 'STEP')) mass_group.add_argument("--masslist", help="List containing mass information") args = parser.parse_args() if args.atype == 'hG': fstr = "bbhGGBB" in2 = 'bcorrbin/binmodh.root' elif args.atype == 'hR': fstr = "bbhRS" in2 = 'bcorrbin/binmodh.root' elif args.atype == 'lG': fstr = "bblGGBB" in2 = 'bcorrbin/binmodl.root' else: fstr = "bblRS" in2 = 'bcorrbin/binmodl.root' # check if the output directory exists if not os.path.isdir(os.path.join(os.getcwd(), args.output_path)): os.mkdir(os.path.join(os.getcwd(), args.output_path)) # mass points for which resonance shapes will be produced masses = [] if args.massrange != None: MIN, MAX, STEP = args.massrange masses = range(MIN, MAX + STEP, STEP) elif args.masslist != None: # A mass list was provided print "Will create mass list according to", args.masslist masslist = __import__(args.masslist.replace(".py", "")) masses = masslist.masses else: masses = args.mass # sort masses masses.sort() # import ROOT stuff from ROOT import gStyle, TFile, TH1F, TH1D, TGraph, kTRUE, kFALSE, TCanvas, TLegend, TPad, TLine from ROOT import RooHist, RooRealVar, RooDataHist, RooArgList, RooArgSet, RooAddPdf, RooFit, RooGenericPdf, RooWorkspace, RooMsgService, RooHistPdf, RooExtendPdf if not args.debug: RooMsgService.instance().setSilentMode(kTRUE) RooMsgService.instance().setStreamStatus(0, kFALSE) RooMsgService.instance().setStreamStatus(1, kFALSE) # input data file inputData = TFile(args.inputData) # input data histogram hData = inputData.Get(args.dataHistname) inData2 = TFile(in2) hData2 = inData2.Get('h_data') # input sig file inputSig = TFile(args.inputSig) sqrtS = args.sqrtS # mass variable mjj = RooRealVar('mjj', 'mjj', float(args.massMin), float(args.massMax)) # integrated luminosity and signal cross section lumi = args.lumi signalCrossSection = 1. # set to 1. so that the limit on r can be interpreted as a limit on the signal cross section for mass in masses: print ">> Creating datacard and workspace for %s resonance with m = %i GeV..." % ( args.final_state, int(mass)) # get signal shape hSig = inputSig.Get("h_" + args.final_state + "_" + str(int(mass))) # normalize signal shape to the expected event yield (works even if input shapes are not normalized to unity) hSig.Scale( signalCrossSection * lumi / hSig.Integral() ) # divide by a number that provides roughly an r value of 1-10 rooSigHist = RooDataHist('rooSigHist', 'rooSigHist', RooArgList(mjj), hSig) print 'Signal acceptance:', (rooSigHist.sumEntries() / hSig.Integral()) signal = RooHistPdf('signal', 'signal', RooArgSet(mjj), rooSigHist) signal_norm = RooRealVar('signal_norm', 'signal_norm', 0, -1e+05, 1e+05) signal_norm2 = RooRealVar('signal_norm2', 'signal_norm2', 0, -1e+05, 1e+05) signal_norm3 = RooRealVar('signal_norm3', 'signal_norm3', 0, -1e+05, 1e+05) signal_norm4 = RooRealVar('signal_norm4', 'signal_norm4', 0, -1e+05, 1e+05) signal_norm5 = RooRealVar('signal_norm5', 'signal_norm5', 0, -1e+05, 1e+05) if args.fitBonly: signal_norm.setConstant() signal_norm2.setConstant() signal_norm3.setConstant() signal_norm4.setConstant() signal_norm5.setConstant() p1 = RooRealVar('p1', 'p1', args.p1, 0., 100.) p2 = RooRealVar('p2', 'p2', args.p2, 0., 60.) p3 = RooRealVar('p3', 'p3', args.p3, -10., 10.) p4 = RooRealVar('p4', 'p4', 5.6, -50., 50.) p5 = RooRealVar('p5', 'p5', 10., -50., 50.) p6 = RooRealVar('p6', 'p6', .016, -50., 50.) p7 = RooRealVar('p7', 'p7', 8., -50., 50.) p8 = RooRealVar('p8', 'p8', .22, -50., 50.) p9 = RooRealVar('p9', 'p9', 14.1, -50., 50.) p10 = RooRealVar('p10', 'p10', 8., -50., 50.) p11 = RooRealVar('p11', 'p11', 4.8, -50., 50.) p12 = RooRealVar('p12', 'p12', 7., -50., 50.) p13 = RooRealVar('p13', 'p13', 7., -50., 50.) p14 = RooRealVar('p14', 'p14', 7., -50., 50.) p15 = RooRealVar('p15', 'p15', 1., -50., 50.) p16 = RooRealVar('p16', 'p16', 9., -50., 50.) p17 = RooRealVar('p17', 'p17', 0.6, -50., 50.) if args.fixP3: p3.setConstant() background = RooGenericPdf( 'background', '(pow(1-@0/%.1f,@1)/pow(@0/%.1f,@2+@3*log(@0/%.1f)))' % (sqrtS, sqrtS, sqrtS), RooArgList(mjj, p1, p2, p3)) dataInt = hData.Integral(hData.GetXaxis().FindBin(float(args.massMin)), hData.GetXaxis().FindBin(float(args.massMax))) background_norm = RooRealVar('background_norm', 'background_norm', dataInt, 0., 1e+08) background2 = RooGenericPdf( 'background2', '(pow(@0/%.1f,-@1)*pow(1-@0/%.1f,@2))' % (sqrtS, sqrtS), RooArgList(mjj, p4, p5)) dataInt2 = hData.Integral( hData.GetXaxis().FindBin(float(args.massMin)), hData.GetXaxis().FindBin(float(args.massMax))) background2_norm = RooRealVar('background2_norm', 'background2_norm', dataInt2, 0., 1e+08) background3 = RooGenericPdf('background3', '(1/pow(@1+@0/%.1f,@2))' % (sqrtS), RooArgList(mjj, p6, p7)) dataInt3 = hData.Integral( hData.GetXaxis().FindBin(float(args.massMin)), hData.GetXaxis().FindBin(float(args.massMax))) background3_norm = RooRealVar('background3_norm', 'background3_norm', dataInt3, 0., 1e+08) background4 = RooGenericPdf( 'background4', '(1/pow(@1+@2*@0/%.1f+pow(@0/%.1f,2),@3))' % (sqrtS, sqrtS), RooArgList(mjj, p8, p9, p10)) dataInt4 = hData.Integral( hData.GetXaxis().FindBin(float(args.massMin)), hData.GetXaxis().FindBin(float(args.massMax))) background4_norm = RooRealVar('background4_norm', 'background4_norm', dataInt4, 0., 1e+08) background5 = RooGenericPdf( 'background5', '(pow(@0/%.1f,-@1)*pow(1-pow(@0/%.1f,1/3),@2))' % (sqrtS, sqrtS), RooArgList(mjj, p11, p12)) dataInt5 = hData.Integral( hData.GetXaxis().FindBin(float(args.massMin)), hData.GetXaxis().FindBin(float(args.massMax))) background5_norm = RooRealVar('background5_norm', 'background5_norm', dataInt5, 0., 1e+08) background6 = RooGenericPdf( 'background6', '(pow(@0/%.1f,2)+@1*@0/%.1f+@2)' % (sqrtS, sqrtS), RooArgList(mjj, p13, p14)) dataInt6 = hData.Integral( hData.GetXaxis().FindBin(float(args.massMin)), hData.GetXaxis().FindBin(float(args.massMax))) background_norm6 = RooRealVar('background_norm6', 'background_norm6', dataInt6, 0., 1e+08) background7 = RooGenericPdf( 'background7', '((-1+@1*@0/%.1f)*pow(@0/%.1f,@2+@3*log(@0/%.1f)))' % (sqrtS, sqrtS, sqrtS), RooArgList(mjj, p15, p16, p17)) dataInt7 = hData.Integral( hData.GetXaxis().FindBin(float(args.massMin)), hData.GetXaxis().FindBin(float(args.massMax))) background_norm7 = RooRealVar('background_norm7', 'background_norm7', dataInt7, 0., 1e+08) #Extend PDFs exts = RooExtendPdf('extsignal', 'Extended Signal Pdf', signal, signal_norm) extb = RooExtendPdf('extbackground', 'Extended Background Pdf', background, background_norm) exts2 = RooExtendPdf('extsignal2', 'Extended Signal Pdf2', signal, signal_norm2) extb2 = RooExtendPdf('extbackground2', 'Extended Background Pdf2', background2, background2_norm) exts3 = RooExtendPdf('extsignal3', 'Extended Signal Pdf3', signal, signal_norm3) extb3 = RooExtendPdf('extbackground3', 'Extended Background Pdf3', background3, background3_norm) exts4 = RooExtendPdf('extsignal4', 'Extended Signal Pdf4', signal, signal_norm4) extb4 = RooExtendPdf('extbackground4', 'Extended Background Pdf4', background4, background4_norm) exts5 = RooExtendPdf('extsignal5', 'Extended Signal Pdf5', signal, signal_norm5) extb5 = RooExtendPdf('extbackground5', 'Extended Background Pdf5', background5, background5_norm) # S+B model model = RooAddPdf("model", "s+b", RooArgList(extb, exts)) model2 = RooAddPdf("model2", "s+b2", RooArgList(extb2, exts2)) model3 = RooAddPdf("model3", "s+b3", RooArgList(extb3, exts3)) model4 = RooAddPdf("model4", "s+b4", RooArgList(extb4, exts4)) model5 = RooAddPdf("model5", "s+b5", RooArgList(extb5, exts5)) #model6 = RooAddPdf("model6","s+b6",RooArgList(background6,signal),RooArgList(background_norm6,signal_norm)) #model7 = RooAddPdf("model7","s+b7",RooArgList(background7,signal),RooArgList(background_norm7,signal_norm)) rooDataHist = RooDataHist('rooDatahist', 'rooDathist', RooArgList(mjj), hData) if args.runFit: mframe = mjj.frame() rooDataHist.plotOn(mframe, ROOT.RooFit.Name("setonedata")) res = model.fitTo(rooDataHist, RooFit.Save(kTRUE), RooFit.Extended(kTRUE), RooFit.Strategy(args.fitStrategy)) model.plotOn(mframe, ROOT.RooFit.Name("model1"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kRed)) res2 = model2.fitTo(rooDataHist, RooFit.Save(kTRUE), RooFit.Extended(kTRUE), RooFit.Strategy(args.fitStrategy)) # model2.plotOn(mframe, ROOT.RooFit.Name("model2"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kOrange)) res3 = model3.fitTo(rooDataHist, RooFit.Save(kTRUE), RooFit.Extended(kTRUE), RooFit.Strategy(args.fitStrategy)) # model3.plotOn(mframe, ROOT.RooFit.Name("model3"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kGreen)) res4 = model4.fitTo(rooDataHist, RooFit.Save(kTRUE), RooFit.Extended(kTRUE), RooFit.Strategy(args.fitStrategy)) # model4.plotOn(mframe, ROOT.RooFit.Name("model4"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kBlue)) res5 = model5.fitTo(rooDataHist, RooFit.Save(kTRUE), RooFit.Extended(kTRUE), RooFit.Strategy(args.fitStrategy)) # model5.plotOn(mframe, ROOT.RooFit.Name("model5"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kViolet)) # res6 = model6.fitTo(rooDataHist, RooFit.Save(kTRUE), RooFit.Strategy(args.fitStrategy)) # model6.plotOn(mframe, ROOT.RooFit.Name("model6"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kPink)) # res7 = model7.fitTo(rooDataHist, RooFit.Save(kTRUE), RooFit.Strategy(args.fitStrategy)) # model7.plotOn(mframe, ROOT.RooFit.Name("model7"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kAzure)) rooDataHist2 = RooDataHist('rooDatahist2', 'rooDathist2', RooArgList(mjj), hData2) # rooDataHist2.plotOn(mframe, ROOT.RooFit.Name("data")) if args.pyes: c = TCanvas("c", "c", 800, 800) mframe.SetAxisRange(300., 1300.) c.SetLogy() # mframe.SetMaximum(10) # mframe.SetMinimum(1) mframe.Draw() fitname = args.pdir + '/5funcfit_m' + str(mass) + fstr + '.pdf' c.SaveAs(fitname) # cpull = TCanvas("cpull","cpull",800,800) # pulls = mframe.pullHist("data","model1") # pulls.Draw("ABX") # pullname = args.pdir+'/pull_m'+str(mass)+fstr+'.pdf' # cpull.SaveAs(pullname) # cpull2 = TCanvas("cpull2","cpull2",800,800) # pulls2 = mframe.pullHist("setonedata","model1") # pulls2.Draw("ABX") # pull2name = args.pdir+'/pull2_m'+str(mass)+fstr+'.pdf' # cpull2.SaveAs(pull2name) if args.widefit: mframew = mjj.frame() rooDataHist2.plotOn(mframew, ROOT.RooFit.Name("data")) res6 = model.fitTo(rooDataHist2, RooFit.Save(kTRUE), RooFit.Strategy(args.fitStrategy)) model.plotOn(mframew, ROOT.RooFit.Name("model1"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kRed)) res7 = model2.fitTo(rooDataHist2, RooFit.Save(kTRUE), RooFit.Strategy(args.fitStrategy)) model2.plotOn(mframew, ROOT.RooFit.Name("model2"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kOrange)) res8 = model3.fitTo(rooDataHist2, RooFit.Save(kTRUE), RooFit.Strategy(args.fitStrategy)) model3.plotOn(mframew, ROOT.RooFit.Name("model3"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kGreen)) res9 = model4.fitTo(rooDataHist2, RooFit.Save(kTRUE), RooFit.Strategy(args.fitStrategy)) model4.plotOn(mframew, ROOT.RooFit.Name("model4"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kBlue)) res10 = model5.fitTo(rooDataHist2, RooFit.Save(kTRUE), RooFit.Strategy(args.fitStrategy)) model5.plotOn(mframew, ROOT.RooFit.Name("model5"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.LineWidth(1), ROOT.RooFit.LineColor(ROOT.EColor.kViolet)) if args.pyes: c = TCanvas("c", "c", 800, 800) mframew.SetAxisRange(300., 1300.) c.SetLogy() # mframew.SetMaximum(10) # mframew.SetMinimum(1) mframew.Draw() fitname = args.pdir + '/5funcfittowide_m' + str( mass) + fstr + '.pdf' c.SaveAs(fitname) cpull = TCanvas("cpull", "cpull", 800, 800) pulls = mframew.pullHist("data", "model1") pulls.Draw("ABX") pullname = args.pdir + '/pullwidefit_m' + str( mass) + fstr + '.pdf' cpull.SaveAs(pullname) if args.chi2: fullInt = model.createIntegral(RooArgSet(mjj)) norm = dataInt / fullInt.getVal() chi1 = 0. fullInt2 = model2.createIntegral(RooArgSet(mjj)) norm2 = dataInt2 / fullInt2.getVal() chi2 = 0. fullInt3 = model3.createIntegral(RooArgSet(mjj)) norm3 = dataInt3 / fullInt3.getVal() chi3 = 0. fullInt4 = model4.createIntegral(RooArgSet(mjj)) norm4 = dataInt4 / fullInt4.getVal() chi4 = 0. fullInt5 = model5.createIntegral(RooArgSet(mjj)) norm5 = dataInt5 / fullInt5.getVal() chi5 = 0. for i in range(args.massMin, args.massMax): new = 0 new2 = 0 new3 = 0 new4 = 0 new5 = 0 height = hData.GetBinContent(i) xLow = hData.GetXaxis().GetBinLowEdge(i) xUp = hData.GetXaxis().GetBinLowEdge(i + 1) obs = height * (xUp - xLow) mjj.setRange("intrange", xLow, xUp) integ = model.createIntegral( RooArgSet(mjj), ROOT.RooFit.NormSet(RooArgSet(mjj)), ROOT.RooFit.Range("intrange")) exp = integ.getVal() * norm new = pow(exp - obs, 2) / exp chi1 = chi1 + new integ2 = model2.createIntegral( RooArgSet(mjj), ROOT.RooFit.NormSet(RooArgSet(mjj)), ROOT.RooFit.Range("intrange")) exp2 = integ2.getVal() * norm2 new2 = pow(exp2 - obs, 2) / exp2 chi2 = chi2 + new2 integ3 = model3.createIntegral( RooArgSet(mjj), ROOT.RooFit.NormSet(RooArgSet(mjj)), ROOT.RooFit.Range("intrange")) exp3 = integ3.getVal() * norm3 new3 = pow(exp3 - obs, 2) / exp3 chi3 = chi3 + new3 integ4 = model4.createIntegral( RooArgSet(mjj), ROOT.RooFit.NormSet(RooArgSet(mjj)), ROOT.RooFit.Range("intrange")) exp4 = integ4.getVal() * norm4 if exp4 != 0: new4 = pow(exp4 - obs, 2) / exp4 else: new4 = 0 chi4 = chi4 + new4 integ5 = model5.createIntegral( RooArgSet(mjj), ROOT.RooFit.NormSet(RooArgSet(mjj)), ROOT.RooFit.Range("intrange")) exp5 = integ5.getVal() * norm5 new5 = pow(exp5 - obs, 2) / exp5 chi5 = chi5 + new5 print "chi1 %d " % (chi1) print "chi2 %d " % (chi2) print "chi3 %d " % (chi3) print "chi4 %d " % (chi4) print "chi5 %d " % (chi5) if not args.decoBkg: print " " res.Print() res2.Print() res3.Print() res4.Print() res5.Print() # res6.Print() # res7.Print() # decorrelated background parameters for Bayesian limits if args.decoBkg: signal_norm.setConstant() res = model.fitTo(rooDataHist, RooFit.Save(kTRUE), RooFit.Strategy(args.fitStrategy)) res.Print() ## temp workspace for the PDF diagonalizer w_tmp = RooWorkspace("w_tmp") deco = PdfDiagonalizer("deco", w_tmp, res) # here diagonalizing only the shape parameters since the overall normalization is already decorrelated background_deco = deco.diagonalize(background) print "##################### workspace for decorrelation" w_tmp.Print("v") print "##################### original parameters" background.getParameters(rooDataHist).Print("v") print "##################### decorrelated parameters" # needed if want to evaluate limits without background systematics if args.fixBkg: w_tmp.var("deco_eig1").setConstant() w_tmp.var("deco_eig2").setConstant() if not args.fixP3: w_tmp.var("deco_eig3").setConstant() background_deco.getParameters(rooDataHist).Print("v") print "##################### original pdf" background.Print() print "##################### decorrelated pdf" background_deco.Print() # release signal normalization signal_norm.setConstant(kFALSE) # set the background normalization range to +/- 5 sigma bkg_val = background_norm.getVal() bkg_error = background_norm.getError() background_norm.setMin(bkg_val - 5 * bkg_error) background_norm.setMax(bkg_val + 5 * bkg_error) background_norm.Print() # change background PDF names background.SetName("background_old") background_deco.SetName("background") # needed if want to evaluate limits without background systematics if args.fixBkg: background_norm.setConstant() p1.setConstant() p2.setConstant() p3.setConstant() # ----------------------------------------- # dictionaries holding systematic variations of the signal shape hSig_Syst = {} hSig_Syst_DataHist = {} sigCDF = TGraph(hSig.GetNbinsX() + 1) # JES and JER uncertainties if args.jesUnc != None or args.jerUnc != None: sigCDF.SetPoint(0, 0., 0.) integral = 0. for i in range(1, hSig.GetNbinsX() + 1): x = hSig.GetXaxis().GetBinLowEdge(i + 1) integral = integral + hSig.GetBinContent(i) sigCDF.SetPoint(i, x, integral) if args.jesUnc != None: hSig_Syst['JESUp'] = copy.deepcopy(hSig) hSig_Syst['JESDown'] = copy.deepcopy(hSig) if args.jerUnc != None: hSig_Syst['JERUp'] = copy.deepcopy(hSig) hSig_Syst['JERDown'] = copy.deepcopy(hSig) # reset signal histograms for key in hSig_Syst.keys(): hSig_Syst[key].Reset() hSig_Syst[key].SetName(hSig_Syst[key].GetName() + '_' + key) # produce JES signal shapes if args.jesUnc != None: for i in range(1, hSig.GetNbinsX() + 1): xLow = hSig.GetXaxis().GetBinLowEdge(i) xUp = hSig.GetXaxis().GetBinLowEdge(i + 1) jes = 1. - args.jesUnc xLowPrime = jes * xLow xUpPrime = jes * xUp hSig_Syst['JESUp'].SetBinContent( i, sigCDF.Eval(xUpPrime) - sigCDF.Eval(xLowPrime)) jes = 1. + args.jesUnc xLowPrime = jes * xLow xUpPrime = jes * xUp hSig_Syst['JESDown'].SetBinContent( i, sigCDF.Eval(xUpPrime) - sigCDF.Eval(xLowPrime)) hSig_Syst_DataHist['JESUp'] = RooDataHist('hSig_JESUp', 'hSig_JESUp', RooArgList(mjj), hSig_Syst['JESUp']) hSig_Syst_DataHist['JESDown'] = RooDataHist( 'hSig_JESDown', 'hSig_JESDown', RooArgList(mjj), hSig_Syst['JESDown']) if args.jyes: c2 = TCanvas("c2", "c2", 800, 800) mframe2 = mjj.frame(ROOT.RooFit.Title("JES One Sigma Shifts")) mframe2.SetAxisRange(args.massMin, args.massMax) hSig_Syst_DataHist['JESUp'].plotOn( mframe2, ROOT.RooFit.Name("JESUP"), ROOT.RooFit.DrawOption("L"), ROOT.RooFit.DataError(2), ROOT.RooFit.LineStyle(1), ROOT.RooFit.MarkerColor(ROOT.EColor.kRed), ROOT.RooFit.LineColor(ROOT.EColor.kRed)) hSig_Syst_DataHist['JESDown'].plotOn( mframe2, ROOT.RooFit.Name("JESDOWN"), ROOT.RooFit.DrawOption("L"), ROOT.RooFit.DataError(2), ROOT.RooFit.LineStyle(1), ROOT.RooFit.MarkerColor(ROOT.EColor.kBlue), ROOT.RooFit.LineColor(ROOT.EColor.kBlue)) rooSigHist.plotOn(mframe2, ROOT.RooFit.DataError(2), ROOT.RooFit.Name("SIG"), ROOT.RooFit.DrawOption("L"), ROOT.RooFit.LineStyle(1), ROOT.RooFit.MarkerColor(ROOT.EColor.kGreen), ROOT.RooFit.LineColor(ROOT.EColor.kGreen)) mframe2.Draw() mframe2.GetXaxis().SetTitle("Dijet Mass (GeV)") leg = TLegend(0.7, 0.8, 0.9, 0.9) leg.SetFillColor(0) leg.AddEntry(mframe2.findObject("SIG"), "Signal Model", "l") leg.AddEntry(mframe2.findObject("JESUP"), "+1 Sigma", "l") leg.AddEntry(mframe2.findObject("JESDOWN"), "-1 Sigma", "l") leg.Draw() jesname = args.pdir + '/jes_m' + str(mass) + fstr + '.pdf' c2.SaveAs(jesname) # produce JER signal shapes if args.jesUnc != None: for i in range(1, hSig.GetNbinsX() + 1): xLow = hSig.GetXaxis().GetBinLowEdge(i) xUp = hSig.GetXaxis().GetBinLowEdge(i + 1) jer = 1. - args.jerUnc xLowPrime = jer * (xLow - float(mass)) + float(mass) xUpPrime = jer * (xUp - float(mass)) + float(mass) hSig_Syst['JERUp'].SetBinContent( i, sigCDF.Eval(xUpPrime) - sigCDF.Eval(xLowPrime)) jer = 1. + args.jerUnc xLowPrime = jer * (xLow - float(mass)) + float(mass) xUpPrime = jer * (xUp - float(mass)) + float(mass) hSig_Syst['JERDown'].SetBinContent( i, sigCDF.Eval(xUpPrime) - sigCDF.Eval(xLowPrime)) hSig_Syst_DataHist['JERUp'] = RooDataHist('hSig_JERUp', 'hSig_JERUp', RooArgList(mjj), hSig_Syst['JERUp']) hSig_Syst_DataHist['JERDown'] = RooDataHist( 'hSig_JERDown', 'hSig_JERDown', RooArgList(mjj), hSig_Syst['JERDown']) if args.jyes: c3 = TCanvas("c3", "c3", 800, 800) mframe3 = mjj.frame(ROOT.RooFit.Title("JER One Sigma Shifts")) mframe3.SetAxisRange(args.massMin, args.massMax) hSig_Syst_DataHist['JERUp'].plotOn( mframe3, ROOT.RooFit.Name("JERUP"), ROOT.RooFit.DrawOption("L"), ROOT.RooFit.DataError(2), ROOT.RooFit.LineStyle(1), ROOT.RooFit.MarkerColor(ROOT.EColor.kRed), ROOT.RooFit.LineColor(ROOT.EColor.kRed)) hSig_Syst_DataHist['JERDown'].plotOn( mframe3, ROOT.RooFit.Name("JERDOWN"), ROOT.RooFit.DrawOption("L"), ROOT.RooFit.DataError(2), ROOT.RooFit.LineStyle(1), ROOT.RooFit.MarkerColor(ROOT.EColor.kBlue), ROOT.RooFit.LineColor(ROOT.EColor.kBlue)) rooSigHist.plotOn(mframe3, ROOT.RooFit.DrawOption("L"), ROOT.RooFit.Name("SIG"), ROOT.RooFit.DataError(2), ROOT.RooFit.LineStyle(1), ROOT.RooFit.MarkerColor(ROOT.EColor.kGreen), ROOT.RooFit.LineColor(ROOT.EColor.kGreen)) mframe3.Draw() mframe3.GetXaxis().SetTitle("Dijet Mass (GeV)") leg = TLegend(0.7, 0.8, 0.9, 0.9) leg.SetFillColor(0) leg.AddEntry(mframe3.findObject("SIG"), "Signal Model", "l") leg.AddEntry(mframe3.findObject("JERUP"), "+1 Sigma", "l") leg.AddEntry(mframe3.findObject("JERDOWN"), "-1 Sigma", "l") leg.Draw() jername = args.pdir + '/jer_m' + str(mass) + fstr + '.pdf' c3.SaveAs(jername) # ----------------------------------------- # create a datacard and corresponding workspace postfix = (('_' + args.postfix) if args.postfix != '' else '') dcName = 'datacard_' + args.final_state + '_m' + str( mass) + postfix + '.txt' wsName = 'workspace_' + args.final_state + '_m' + str( mass) + postfix + '.root' w = RooWorkspace('w', 'workspace') getattr(w, 'import')(rooSigHist, RooFit.Rename("signal")) if args.jesUnc != None: getattr(w, 'import')(hSig_Syst_DataHist['JESUp'], RooFit.Rename("signal__JESUp")) getattr(w, 'import')(hSig_Syst_DataHist['JESDown'], RooFit.Rename("signal__JESDown")) if args.jerUnc != None: getattr(w, 'import')(hSig_Syst_DataHist['JERUp'], RooFit.Rename("signal__JERUp")) getattr(w, 'import')(hSig_Syst_DataHist['JERDown'], RooFit.Rename("signal__JERDown")) if args.decoBkg: getattr(w, 'import')(background_deco, ROOT.RooCmdArg()) else: getattr(w, 'import')(background, ROOT.RooCmdArg(), RooFit.Rename("background")) getattr(w, 'import')(background2, ROOT.RooCmdArg(), RooFit.Rename("background2")) getattr(w, 'import')(background3, ROOT.RooCmdArg(), RooFit.Rename("background3")) getattr(w, 'import')(background4, ROOT.RooCmdArg(), RooFit.Rename("background4")) getattr(w, 'import')(background5, ROOT.RooCmdArg(), RooFit.Rename("background5")) getattr(w, 'import')(background_norm, ROOT.RooCmdArg(), RooFit.Rename("background_norm")) getattr(w, 'import')(background2_norm, ROOT.RooCmdArg(), RooFit.Rename("background2_norm")) getattr(w, 'import')(background3_norm, ROOT.RooCmdArg(), RooFit.Rename("background3_norm")) getattr(w, 'import')(background4_norm, ROOT.RooCmdArg(), RooFit.Rename("background4_norm")) getattr(w, 'import')(background5_norm, ROOT.RooCmdArg(), RooFit.Rename("background5_norm")) getattr(w, 'import')(res) getattr(w, 'import')(res2) getattr(w, 'import')(res3) getattr(w, 'import')(res4) getattr(w, 'import')(res5) getattr(w, 'import')(background_norm, ROOT.RooCmdArg()) getattr(w, 'import')(signal_norm, ROOT.RooCmdArg()) getattr(w, 'import')(rooDataHist, RooFit.Rename("data_obs")) w.Print() w.writeToFile(os.path.join(args.output_path, wsName)) beffUnc = 0.3 boffUnc = 0.06 datacard = open(os.path.join(args.output_path, dcName), 'w') datacard.write('imax 1\n') datacard.write('jmax 1\n') datacard.write('kmax *\n') datacard.write('---------------\n') if args.jesUnc != None or args.jerUnc != None: datacard.write('shapes * * ' + wsName + ' w:$PROCESS w:$PROCESS__$SYSTEMATIC\n') else: datacard.write('shapes * * ' + wsName + ' w:$PROCESS\n') datacard.write('---------------\n') datacard.write('bin 1\n') datacard.write('observation -1\n') datacard.write('------------------------------\n') datacard.write('bin 1 1\n') datacard.write('process signal background\n') datacard.write('process 0 1\n') datacard.write('rate -1 1\n') datacard.write('------------------------------\n') datacard.write('lumi lnN %f -\n' % (1. + args.lumiUnc)) datacard.write('beff lnN %f -\n' % (1. + beffUnc)) datacard.write('boff lnN %f -\n' % (1. + boffUnc)) datacard.write('bkg lnN - 1.03\n') if args.jesUnc != None: datacard.write('JES shape 1 -\n') if args.jerUnc != None: datacard.write('JER shape 1 -\n') # flat parameters --- flat prior datacard.write('background_norm flatParam\n') if args.decoBkg: datacard.write('deco_eig1 flatParam\n') datacard.write('deco_eig2 flatParam\n') if not args.fixP3: datacard.write('deco_eig3 flatParam\n') else: datacard.write('p1 flatParam\n') datacard.write('p2 flatParam\n') if not args.fixP3: datacard.write('p3 flatParam\n') datacard.close() print '>> Datacards and workspaces created and stored in %s/' % ( os.path.join(os.getcwd(), args.output_path))
def fit(): #fit to log_10(pT^2) with components and plot of plain pT^2 #range in log_10(pT^2) ptbin = 0.12 ptmin = -5. ptmax = 0.99 # 1.01 #range in pT^2 ptsq_bin = 0.03 ptsq_min = 1e-5 ptsq_max = 1 mmin = 2.8 mmax = 3.2 #range for incoherent fit fitran = [-0.9, 0.1] #number of gamma-gamma events ngg = 131 #number of psi' events npsiP = 20 #input data pT = RooRealVar("jRecPt", "pT", 0, 10) m = RooRealVar("jRecM", "mass", 0, 10) data_all = RooDataSet("data", "data", tree, RooArgSet(pT, m)) #select for mass range strsel = "jRecM>{0:.3f} && jRecM<{1:.3f}".format(mmin, mmax) data = data_all.reduce(strsel) #create log(pT^2) from pT ptsq_draw = "jRecPt*jRecPt" # will be used for pT^2 logPtSq_draw = "TMath::Log10(" + ptsq_draw + ")" logPtSq_form = RooFormulaVar("logPtSq", "logPtSq", logPtSq_draw, RooArgList(pT)) logPtSq = data.addColumn(logPtSq_form) logPtSq.setRange("fitran", fitran[0], fitran[1]) #bins and range for the plot nbins, ptmax = ut.get_nbins(ptbin, ptmin, ptmax) logPtSq.setMin(ptmin) logPtSq.setMax(ptmax) logPtSq.setRange("plotran", ptmin, ptmax) #range for pT^2 ptsq_nbins, ptsq_max = ut.get_nbins(ptsq_bin, ptsq_min, ptsq_max) #incoherent parametrization bval = RooRealVar("bval", "bval", 3.3, 0, 10) inc_form = "log(10.)*pow(10.,logPtSq)*exp(-bval*pow(10.,logPtSq))" incpdf = RooGenericPdf("incpdf", inc_form, RooArgList(logPtSq, bval)) #make the incoherent fit res = incpdf.fitTo(data, rf.Range("fitran"), rf.Save()) #get incoherent norm to the number of events lset = RooArgSet(logPtSq) iinc = incpdf.createIntegral(lset, rf.NormSet(lset), rf.Range("fitran")) inc_nevt = data.sumEntries("logPtSq", "fitran") incpdf.setNormRange("fitran") aval = RooRealVar("aval", "aval", inc_nevt / incpdf.getNorm(lset)) #print "A =", aval.getVal() #print "b =", bval.getVal() #incoherent distribution from log_10(pT^2) function for the sum with gamma-gamma hIncPdf = ut.prepare_TH1D_n("hGG", nbins, ptmin, ptmax) func_incoh_logPt2 = TF1("func_incoh_logPt2", "[0]*log(10.)*pow(10.,x)*exp(-[1]*pow(10.,x))", -10., 10.) func_incoh_logPt2.SetNpx(1000) func_incoh_logPt2.SetLineColor(rt.kMagenta) func_incoh_logPt2.SetParameters( aval.getVal(), bval.getVal()) # 4.9 from incoherent mc, 3.3 from data fit ut.fill_h1_tf(hIncPdf, func_incoh_logPt2, rt.kMagenta) #gamma-gamma contribution hGG = ut.prepare_TH1D_n("hGG", nbins, ptmin, ptmax) tree_gg.Draw(logPtSq_draw + " >> hGG", strsel) ut.norm_to_num(hGG, ngg, rt.kGreen + 1) #sum of incoherent distribution and gamma-gamma hSumIncGG = ut.prepare_TH1D_n("hSumIncGG", nbins, ptmin, ptmax) hSumIncGG.Add(hIncPdf) hSumIncGG.Add(hGG) ut.line_h1(hSumIncGG, rt.kMagenta) #gamma-gamma in pT^2 hGG_ptsq = ut.prepare_TH1D_n("hGG_ptsq", ptsq_nbins, ptsq_min, ptsq_max) tree_gg.Draw(ptsq_draw + " >> hGG_ptsq", strsel) ut.norm_to_num(hGG_ptsq, ngg, rt.kGreen + 1) #psi' contribution psiP_file = TFile.Open(basedir_mc + "/ana_slight14e4x1_s6_sel5z.root") psiP_tree = psiP_file.Get("jRecTree") hPsiP = ut.prepare_TH1D_n("hPsiP", nbins, ptmin, ptmax) psiP_tree.Draw(logPtSq_draw + " >> hPsiP", strsel) ut.norm_to_num(hPsiP, npsiP, rt.kViolet) #psi' in pT^2 hPsiP_ptsq = ut.prepare_TH1D_n("hPsiP_ptsq", ptsq_nbins, ptsq_min, ptsq_max) psiP_tree.Draw(ptsq_draw + " >> hPsiP_ptsq", strsel) ut.norm_to_num(hPsiP_ptsq, npsiP, rt.kViolet) #create canvas frame gStyle.SetPadTickY(1) can = ut.box_canvas(1086, 543) # square area is still 768^2 can.SetMargin(0, 0, 0, 0) can.Divide(2, 1, 0, 0) gStyle.SetLineWidth(1) can.cd(1) ut.set_margin_lbtr(gPad, 0.11, 0.1, 0.01, 0) frame = logPtSq.frame(rf.Bins(nbins)) frame.SetTitle("") frame.SetMaximum(80) frame.SetYTitle("Events / ({0:.3f}".format(ptbin) + " GeV^{2})") frame.SetXTitle("log_{10}( #it{p}_{T}^{2} ) (GeV^{2})") frame.GetXaxis().SetTitleOffset(1.2) frame.GetYaxis().SetTitleOffset(1.6) #plot the data data.plotOn(frame, rf.Name("data"), rf.LineWidth(2)) #incoherent parametrization incpdf.plotOn(frame, rf.Range("fitran"), rf.LineColor(rt.kRed), rf.Name("incpdf"), rf.LineWidth(2)) incpdf.plotOn(frame, rf.Range("plotran"), rf.LineColor(rt.kRed), rf.Name("incpdf_full"), rf.LineStyle(rt.kDashed), rf.LineWidth(2)) frame.Draw() #add gamma-gamma contribution hGG.Draw("same") #sum of incoherent distribution and gamma-gamma #hSumIncGG.Draw("same") #add psi' #hPsiP.Draw("same") #legend for log_10(pT^2) leg = ut.prepare_leg(0.15, 0.77, 0.28, 0.19, 0.035) hxl = ut.prepare_TH1D("hxl", 1, 0, 1) hxl.Draw("same") ilin = ut.col_lin(rt.kRed, 2) ilin2 = ut.col_lin(rt.kRed, 2) ilin2.SetLineStyle(rt.kDashed) leg.AddEntry(ilin, "Incoherent parametrization, fit region", "l") leg.AddEntry(ilin2, "Incoherent parametrization, extrapolation region", "l") leg.AddEntry(hGG, "#gamma#gamma#rightarrow e^{+}e^{-}", "l") #leg.AddEntry(hxl, "Data", "lp") leg.AddEntry(hxl, "Data, log_{10}( #it{p}_{T}^{2} )", "lp") leg.Draw("same") #----- plot pT^2 on the right ----- #pT^2 variable from pT ptsq_form = RooFormulaVar("ptsq", "ptsq", ptsq_draw, RooArgList(pT)) ptsq = data.addColumn(ptsq_form) #range for pT^2 plot ptsq.setMin(ptsq_min) ptsq.setMax(ptsq_max) #make the pT^2 plot can.cd(2) gPad.SetLogy() #gPad.SetLineWidth(3) #gPad.SetFrameLineWidth(1) ut.set_margin_lbtr(gPad, 0, 0.1, 0.01, 0.15) ptsq_frame = ptsq.frame(rf.Bins(ptsq_nbins), rf.Title("")) #print type(ptsq_frame), type(ptsq) ptsq_frame.SetTitle("") ptsq_frame.SetXTitle("#it{p}_{T}^{2} (GeV^{2})") ptsq_frame.GetXaxis().SetTitleOffset(1.2) data.plotOn(ptsq_frame, rf.Name("data"), rf.LineWidth(2)) ptsq_frame.SetMaximum(9e2) ptsq_frame.SetMinimum(0.8) # 0.101 ptsq_frame.Draw() #incoherent parametrization in pT^2 over the fit region, scaled to the plot inc_ptsq = TF1("inc_ptsq", "[0]*exp(-[1]*x)", 10**fitran[0], 10**fitran[1]) inc_ptsq.SetParameters(aval.getVal() * ptsq_bin, bval.getVal()) #incoherent parametrization in the extrapolation region, below and above the fit region inc_ptsq_ext1 = TF1("inc_ptsq_ext1", "[0]*exp(-[1]*x)", 0., 10**fitran[0]) inc_ptsq_ext2 = TF1("inc_ptsq_ext2", "[0]*exp(-[1]*x)", 10**fitran[1], 10) inc_ptsq_ext1.SetParameters(aval.getVal() * ptsq_bin, bval.getVal()) inc_ptsq_ext1.SetLineStyle(rt.kDashed) inc_ptsq_ext2.SetParameters(aval.getVal() * ptsq_bin, bval.getVal()) inc_ptsq_ext2.SetLineStyle(rt.kDashed) inc_ptsq.Draw("same") inc_ptsq_ext1.Draw("same") inc_ptsq_ext2.Draw("same") #add gamma-gamma in pT^2 hGG_ptsq.Draw("same") #add psi' in pT^2 #hPsiP_ptsq.Draw("same") #redraw the frame #ptsq_frame.Draw("same") ptsq_frame.GetXaxis().SetLimits(-9e-3, ptsq_frame.GetXaxis().GetXmax()) #vertical axis for pT^2 plot xpos = ptsq_frame.GetXaxis().GetXmax() ypos = ptsq_frame.GetMaximum() ymin = ptsq_frame.GetMinimum() ptsq_axis = TGaxis(xpos, 0, xpos, ypos, ymin, ypos, 510, "+GL") ut.set_axis(ptsq_axis) ptsq_axis.SetMoreLogLabels() ptsq_axis.SetTitle("Events / ({0:.3f}".format(ptsq_bin) + " GeV^{2})") ptsq_axis.SetTitleOffset(2.2) ptsq_axis.Draw() #legend for input data #dleg = ut.prepare_leg(0.4, 0.77, 0.14, 0.18, 0.035) dleg = ut.prepare_leg(0.4, 0.71, 0.16, 0.24, 0.035) dleg.AddEntry(None, "#bf{|#kern[0.3]{#it{y}}| < 1}", "") ut.add_leg_mass(dleg, mmin, mmax) dleg.AddEntry(None, "AuAu@200 GeV", "") dleg.AddEntry(None, "UPC sample", "") dleg.AddEntry(hxl, "Data, #it{p}_{T}^{2}", "lp") dleg.Draw("same") #ut.invert_col_can(can) can.SaveAs("01fig.pdf")
# J/psi PDF mass for m0 taken as TDatabasePDG::Instance()->GetParticle( 443 )->Mass() m0 = RooRealVar("m0", "mass", 3.09692, 3., 3.15) n = RooRealVar("n", "n", 2, 0., 20.) sig = RooRealVar("sig", "resolution", 0.1, 0.001, 0.2) alpha = RooRealVar("alpha", "alpha", 0.3, 0.1, 4.1) cb = RooCBShape("cb", "Crystal Ball PDF", m, m0, sig, alpha, n) #_____________________________________________________________________________ #Background function lam = RooRealVar("lambda", "Exponent", -0.6, -10., 0.) c1 = RooRealVar("c1", "c1", 1.5, 0.5, 2.5) c2 = RooRealVar("c2", "c2", 0.04, -1., 1.) bkg_func = "TMath::Abs(jRecM-c1)*TMath::Exp(lambda*(jRecM-c1)*(jRecM-c1)+c2*(jRecM-c1)*(jRecM-c1)*(jRecM-c1))" #bkg_func = "TMath::Abs(jRecM-c1)*TMath::Exp(lambda*(jRecM-c1)*(jRecM-c1)+c2*jRecM*jRecM*jRecM)" #abs() is to prevent error messages about negative values below the fit range bkgd = RooGenericPdf("Background", bkg_func, RooArgList(m, lam, c1, c2)) #version for plotting with fixed parameters lamF = RooRealVar("lambdaF", "lambdaF", -2.422) c1f = RooRealVar("c1f", "c1f", 1.227) c2f = RooRealVar("c2f", "c2f", 0.240) bkg_func_f = "TMath::Abs(jRecM-c1f)*TMath::Exp(lambdaF*(jRecM-c1f)*(jRecM-c1f)+c2f*(jRecM-c1f)*(jRecM-c1f)*(jRecM-c1f))" #bkg_func_f = "TMath::Abs(jRecM-c1f)*TMath::Exp(lambdaF*(jRecM-c1f)*(jRecM-c1f)+c2f*jRecM*jRecM*jRecM)" bkgd_f = RooGenericPdf("Background_f", bkg_func_f, RooArgList(m, lamF, c1f, c2f))
#background parameters q01S_Start = 9.62 alphabkg1S = RooRealVar("#alpha1S","#alpha1S",1.5,0.2,10) beta = RooRealVar("#beta1S","#beta1S",-2.5,-7.,0.) q01S = RooRealVar("q01S","q01S",q01S_Start) delta1S = RooFormulaVar("delta1S","TMath::Abs(@0-@1)",RooArgList(x,q01S)) b11S = RooFormulaVar("b11S","@0*(@1-@2)",RooArgList(beta,x,q01S)) signum11S = RooFormulaVar( "signum11S","( TMath::Sign( -1.,@0-@1 )+1 )/2.", RooArgList(x,q01S) ) background1S = RooGenericPdf("background","Background", "signum11S*pow(delta1S,#alpha1S)*exp(b11S)", RooArgList(signum11S,delta1S,alphabkg1S,b11S) ) q02S_Start = 10.0 alphabkg2S = RooRealVar("#alpha2S","#alpha2S",1.5,0.2,3.5) beta2S = RooRealVar("#beta2S","#beta2S",-2.5,-7.,0.) q02S = RooRealVar("q02S","q02S",q02S_Start,q02S_Start-0.05,q02S_Start+0.05) delta2S = RooFormulaVar("delta2S","TMath::Abs(@0-@1)",RooArgList(x,q02S)) b12S = RooFormulaVar("b12S","@0*(@1-@2)",RooArgList(beta2S,x,q02S)) signum12S = RooFormulaVar( "signum12S","( TMath::Sign( -1.,@0-@1 )+1 )/2.", RooArgList(x,q02S) ) background2S = RooGenericPdf("background","Background", "signum12S*pow(delta2S,#alpha2S)*exp(b12S)", RooArgList(signum12S,delta2S,alphabkg2S,b12S) ) # define background
def dijet(category): channel = 'bb' stype = channel isSB = True # relict from using Alberto's more complex script isData = not ISMC nTupleDir = NTUPLEDIR samples = data if isData else back pd = [] for sample_name in samples: if YEAR == 'run2': pd += sample[sample_name]['files'] else: pd += [x for x in sample[sample_name]['files'] if YEAR in x] print "datasets:", pd if not os.path.exists(PLOTDIR): os.makedirs(PLOTDIR) if BIAS: print "Running in BIAS mode" order = 0 RSS = {} X_mass = RooRealVar("jj_mass_widejet", "m_{jj}", X_min, X_max, "GeV") weight = RooRealVar("MANtag_weight", "", -1.e9, 1.e9) variables = RooArgSet(X_mass) variables.add(RooArgSet(weight)) if VARBINS: binsXmass = RooBinning(len(abins) - 1, abins) X_mass.setBinning(RooBinning(len(abins_narrow) - 1, abins_narrow)) plot_binning = RooBinning( int((X_mass.getMax() - X_mass.getMin()) / 100), X_mass.getMin(), X_mass.getMax()) else: X_mass.setBins(int((X_mass.getMax() - X_mass.getMin()) / 10)) binsXmass = RooBinning(int((X_mass.getMax() - X_mass.getMin()) / 100), X_mass.getMin(), X_mass.getMax()) plot_binning = binsXmass baseCut = "" print stype, "|", baseCut print " - Reading from Tree" treeBkg = TChain("tree") for ss in pd: if os.path.exists(nTupleDir + ss + "_" + BTAGGING + ".root"): treeBkg.Add(nTupleDir + ss + "_" + BTAGGING + ".root") else: print "found no file for sample:", ss setData = RooDataSet("setData", "Data (QCD+TTbar MC)", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeBkg)) nevents = setData.sumEntries() dataMin, dataMax = array('d', [0.]), array('d', [0.]) setData.getRange(X_mass, dataMin, dataMax) xmin, xmax = dataMin[0], dataMax[0] lastBin = X_mass.getMax() if VARBINS: for b in narrow_bins: if b > xmax: lastBin = b break print "Imported", ( "data" if isData else "MC" ), "RooDataSet with", nevents, "events between [%.1f, %.1f]" % (xmin, xmax) #xmax = xmax+binsXmass.averageBinWidth() # start form next bin # 1 parameter print "fitting 1 parameter model" p1_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p1_1", "p1", 7.0, 0., 2000.) modelBkg1 = RooGenericPdf("Bkg1", "Bkg. fit (2 par.)", "1./pow(@0/13000, @1)", RooArgList(X_mass, p1_1)) normzBkg1 = RooRealVar( modelBkg1.GetName() + "_norm", "Number of background events", nevents, 0., 5. * nevents) #range dependent of actual number of events! modelExt1 = RooExtendPdf(modelBkg1.GetName() + "_ext", modelBkg1.GetTitle(), modelBkg1, normzBkg1) fitRes1 = modelExt1.fitTo(setData, RooFit.Extended(True), RooFit.Save(1), RooFit.SumW2Error(not isData), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.PrintLevel(1 if VERBOSE else -1)) fitRes1.Print() RSS[1] = drawFit("Bkg1", category, X_mass, modelBkg1, setData, binsXmass, [fitRes1], normzBkg1.getVal()) # 2 parameters print "fitting 2 parameter model" p2_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p2_1", "p1", 0., -100., 1000.) p2_2 = RooRealVar("CMS" + YEAR + "_" + category + "_p2_2", "p2", p1_1.getVal(), -100., 600.) modelBkg2 = RooGenericPdf("Bkg2", "Bkg. fit (3 par.)", "pow(1-@0/13000, @1) / pow(@0/13000, @2)", RooArgList(X_mass, p2_1, p2_2)) normzBkg2 = RooRealVar(modelBkg2.GetName() + "_norm", "Number of background events", nevents, 0., 5. * nevents) modelExt2 = RooExtendPdf(modelBkg2.GetName() + "_ext", modelBkg2.GetTitle(), modelBkg2, normzBkg2) fitRes2 = modelExt2.fitTo(setData, RooFit.Extended(True), RooFit.Save(1), RooFit.SumW2Error(not isData), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.PrintLevel(1 if VERBOSE else -1)) fitRes2.Print() RSS[2] = drawFit("Bkg2", category, X_mass, modelBkg2, setData, binsXmass, [fitRes2], normzBkg2.getVal()) # 3 parameters print "fitting 3 parameter model" p3_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p3_1", "p1", p2_1.getVal(), -2000., 2000.) p3_2 = RooRealVar("CMS" + YEAR + "_" + category + "_p3_2", "p2", p2_2.getVal(), -400., 2000.) p3_3 = RooRealVar("CMS" + YEAR + "_" + category + "_p3_3", "p3", -2.5, -500., 500.) modelBkg3 = RooGenericPdf( "Bkg3", "Bkg. fit (4 par.)", "pow(1-@0/13000, @1) / pow(@0/13000, @2+@3*log(@0/13000))", RooArgList(X_mass, p3_1, p3_2, p3_3)) normzBkg3 = RooRealVar(modelBkg3.GetName() + "_norm", "Number of background events", nevents, 0., 5. * nevents) modelExt3 = RooExtendPdf(modelBkg3.GetName() + "_ext", modelBkg3.GetTitle(), modelBkg3, normzBkg3) fitRes3 = modelExt3.fitTo(setData, RooFit.Extended(True), RooFit.Save(1), RooFit.SumW2Error(not isData), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.PrintLevel(1 if VERBOSE else -1)) fitRes3.Print() RSS[3] = drawFit("Bkg3", category, X_mass, modelBkg3, setData, binsXmass, [fitRes3], normzBkg3.getVal()) # 4 parameters print "fitting 4 parameter model" p4_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_1", "p1", p3_1.getVal(), -2000., 2000.) p4_2 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_2", "p2", p3_2.getVal(), -2000., 2000.) p4_3 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_3", "p3", p3_3.getVal(), -50., 50.) p4_4 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_4", "p4", 0.1, -50., 50.) modelBkg4 = RooGenericPdf( "Bkg4", "Bkg. fit (5 par.)", "pow(1 - @0/13000, @1) / pow(@0/13000, @2+@3*log(@0/13000)+@4*pow(log(@0/13000), 2))", RooArgList(X_mass, p4_1, p4_2, p4_3, p4_4)) normzBkg4 = RooRealVar(modelBkg4.GetName() + "_norm", "Number of background events", nevents, 0., 5. * nevents) modelExt4 = RooExtendPdf(modelBkg4.GetName() + "_ext", modelBkg4.GetTitle(), modelBkg4, normzBkg4) fitRes4 = modelExt4.fitTo(setData, RooFit.Extended(True), RooFit.Save(1), RooFit.SumW2Error(not isData), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.PrintLevel(1 if VERBOSE else -1)) fitRes4.Print() RSS[4] = drawFit("Bkg4", category, X_mass, modelBkg4, setData, binsXmass, [fitRes4], normzBkg4.getVal()) # Normalization parameters are should be set constant, but shape ones should not # if BIAS: # p1_1.setConstant(True) # p2_1.setConstant(True) # p2_2.setConstant(True) # p3_1.setConstant(True) # p3_2.setConstant(True) # p3_3.setConstant(True) # p4_1.setConstant(True) # p4_2.setConstant(True) # p4_3.setConstant(True) # p4_4.setConstant(True) normzBkg1.setConstant(True) normzBkg2.setConstant(True) normzBkg3.setConstant(True) normzBkg4.setConstant(True) #*******************************************************# # # # Fisher # # # #*******************************************************# # Fisher test with open(PLOTDIR + "/Fisher_" + category + ".tex", 'w') as fout: fout.write(r"\begin{tabular}{c|c|c|c|c}") fout.write("\n") fout.write(r"function & $\chi^2$ & RSS & ndof & F-test \\") fout.write("\n") fout.write("\hline") fout.write("\n") CL_high = False for o1 in range(1, 5): o2 = min(o1 + 1, 5) fout.write("%d par & %.2f & %.2f & %d & " % (o1 + 1, RSS[o1]["chi2"], RSS[o1]["rss"], RSS[o1]["nbins"] - RSS[o1]["npar"])) if o2 > len(RSS): fout.write(r"\\") fout.write("\n") continue #order==0 and CL = fisherTest(RSS[o1]['rss'], RSS[o2]['rss'], o1 + 1., o2 + 1., RSS[o1]["nbins"]) fout.write("CL=%.3f " % (CL)) if CL > 0.10: # The function with less parameters is enough if not CL_high: order = o1 #fout.write( "%d par are sufficient " % (o1+1)) CL_high = True else: #fout.write( "%d par are needed " % (o2+1)) if not CL_high: order = o2 fout.write(r"\\") fout.write("\n") fout.write("\hline") fout.write("\n") fout.write(r"\end{tabular}") print "saved F-test table as", PLOTDIR + "/Fisher_" + category + ".tex" #print "-"*25 #print "function & $\\chi^2$ & RSS & ndof & F-test & result \\\\" #print "\\multicolumn{6}{c}{", "Zprime_to_bb", "} \\\\" #print "\\hline" #CL_high = False #for o1 in range(1, 5): # o2 = min(o1 + 1, 5) # print "%d par & %.2f & %.2f & %d & " % (o1+1, RSS[o1]["chi2"], RSS[o1]["rss"], RSS[o1]["nbins"]-RSS[o1]["npar"]), # if o2 > len(RSS): # print "\\\\" # continue #order==0 and # CL = fisherTest(RSS[o1]['rss'], RSS[o2]['rss'], o1+1., o2+1., RSS[o1]["nbins"]) # print "%d par vs %d par CL=%f & " % (o1+1, o2+1, CL), # if CL > 0.10: # The function with less parameters is enough # if not CL_high: # order = o1 # print "%d par are sufficient" % (o1+1), # CL_high=True # else: # print "%d par are needed" % (o2+1), # if not CL_high: # order = o2 # print "\\\\" #print "\\hline" #print "-"*25 #print "@ Order is", order, "("+category+")" #order = min(3, order) #order = 2 if order == 1: modelBkg = modelBkg1 #.Clone("Bkg") modelAlt = modelBkg2 #.Clone("BkgAlt") normzBkg = normzBkg1 #.Clone("Bkg_norm") fitRes = fitRes1 elif order == 2: modelBkg = modelBkg2 #.Clone("Bkg") modelAlt = modelBkg3 #.Clone("BkgAlt") normzBkg = normzBkg2 #.Clone("Bkg_norm") fitRes = fitRes2 elif order == 3: modelBkg = modelBkg3 #.Clone("Bkg") modelAlt = modelBkg4 #.Clone("BkgAlt") normzBkg = normzBkg3 #.Clone("Bkg_norm") fitRes = fitRes3 elif order == 4: modelBkg = modelBkg4 #.Clone("Bkg") modelAlt = modelBkg3 #.Clone("BkgAlt") normzBkg = normzBkg4 #.Clone("Bkg_norm") fitRes = fitRes4 else: print "Functions with", order + 1, "or more parameters are needed to fit the background" exit() modelBkg.SetName("Bkg_" + YEAR + "_" + category) modelAlt.SetName("Alt_" + YEAR + "_" + category) normzBkg.SetName("Bkg_" + YEAR + "_" + category + "_norm") print "-" * 25 # Generate pseudo data setToys = RooDataSet() setToys.SetName("data_toys") setToys.SetTitle("Data (toys)") if not isData: print " - Generating", nevents, "events for toy data" setToys = modelBkg.generate(RooArgSet(X_mass), nevents) #setToys = modelAlt.generate(RooArgSet(X_mass), nevents) print "toy data generated" if VERBOSE: raw_input("Press Enter to continue...") #*******************************************************# # # # Plot # # # #*******************************************************# print "starting to plot" c = TCanvas("c_" + category, category, 800, 800) c.Divide(1, 2) setTopPad(c.GetPad(1), RATIO) setBotPad(c.GetPad(2), RATIO) c.cd(1) frame = X_mass.frame() setPadStyle(frame, 1.25, True) if VARBINS: frame.GetXaxis().SetRangeUser(X_mass.getMin(), lastBin) signal = getSignal( category, stype, 2000) #replacing Alberto's getSignal by own dummy function graphData = setData.plotOn(frame, RooFit.Binning(plot_binning), RooFit.Scaling(False), RooFit.Invisible()) modelBkg.plotOn(frame, RooFit.VisualizeError(fitRes, 1, False), RooFit.LineColor(602), RooFit.FillColor(590), RooFit.FillStyle(1001), RooFit.DrawOption("FL"), RooFit.Name("1sigma")) modelBkg.plotOn(frame, RooFit.LineColor(602), RooFit.FillColor(590), RooFit.FillStyle(1001), RooFit.DrawOption("L"), RooFit.Name(modelBkg.GetName())) modelAlt.plotOn(frame, RooFit.LineStyle(7), RooFit.LineColor(613), RooFit.FillColor(609), RooFit.FillStyle(1001), RooFit.DrawOption("L"), RooFit.Name(modelAlt.GetName())) if not isSB and signal[0] is not None: # FIXME remove /(2./3.) signal[0].plotOn( frame, RooFit.Normalization(signal[1] * signal[2], RooAbsReal.NumEvent), RooFit.LineStyle(3), RooFit.LineWidth(6), RooFit.LineColor(629), RooFit.DrawOption("L"), RooFit.Name("Signal")) graphData = setData.plotOn( frame, RooFit.Binning(plot_binning), RooFit.Scaling(False), RooFit.XErrorSize(0 if not VARBINS else 1), RooFit.DataError(RooAbsData.Poisson if isData else RooAbsData.SumW2), RooFit.DrawOption("PE0"), RooFit.Name(setData.GetName())) fixData(graphData.getHist(), True, True, not isData) pulls = frame.pullHist(setData.GetName(), modelBkg.GetName(), True) chi = frame.chiSquare(setData.GetName(), modelBkg.GetName(), True) #setToys.plotOn(frame, RooFit.DataError(RooAbsData.Poisson), RooFit.DrawOption("PE0"), RooFit.MarkerColor(2)) frame.GetYaxis().SetTitle("Events / ( 100 GeV )") frame.GetYaxis().SetTitleOffset(1.05) frame.Draw() #print "frame drawn" # Get Chi2 # chi2[1] = frame.chiSquare(modelBkg1.GetName(), setData.GetName()) # chi2[2] = frame.chiSquare(modelBkg2.GetName(), setData.GetName()) # chi2[3] = frame.chiSquare(modelBkg3.GetName(), setData.GetName()) # chi2[4] = frame.chiSquare(modelBkg4.GetName(), setData.GetName()) frame.SetMaximum(frame.GetMaximum() * 10) frame.SetMinimum(max(frame.GetMinimum(), 1.e-1)) c.GetPad(1).SetLogy() drawAnalysis(category) drawRegion(category, True) #drawCMS(LUMI, "Simulation Preliminary") drawCMS(LUMI, "Work in Progress", suppressCMS=True) leg = TLegend(0.575, 0.6, 0.95, 0.9) leg.SetBorderSize(0) leg.SetFillStyle(0) #1001 leg.SetFillColor(0) leg.AddEntry(setData.GetName(), setData.GetTitle() + " (%d events)" % nevents, "PEL") leg.AddEntry(modelBkg.GetName(), modelBkg.GetTitle(), "FL") #.SetTextColor(629) leg.AddEntry(modelAlt.GetName(), modelAlt.GetTitle(), "L") if not isSB and signal[0] is not None: leg.AddEntry("Signal", signal[0].GetTitle(), "L") leg.SetY1(0.9 - leg.GetNRows() * 0.05) leg.Draw() latex = TLatex() latex.SetNDC() latex.SetTextSize(0.04) latex.SetTextFont(42) if not isSB: latex.DrawLatex(leg.GetX1() * 1.16, leg.GetY1() - 0.04, "HVT model B (g_{V}=3)") # latex.DrawLatex(0.67, leg.GetY1()-0.045, "#sigma_{X} = 1.0 pb") c.cd(2) frame_res = X_mass.frame() setPadStyle(frame_res, 1.25) frame_res.addPlotable(pulls, "P") setBotStyle(frame_res, RATIO, False) if VARBINS: frame_res.GetXaxis().SetRangeUser(X_mass.getMin(), lastBin) frame_res.GetYaxis().SetRangeUser(-5, 5) frame_res.GetYaxis().SetTitle("pulls(#sigma)") frame_res.GetYaxis().SetTitleOffset(0.3) frame_res.Draw() fixData(pulls, False, True, False) drawChi2(RSS[order]["chi2"], RSS[order]["nbins"] - (order + 1), True) line = drawLine(X_mass.getMin(), 0, lastBin, 0) if VARBINS: c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".pdf") c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".png") else: c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".pdf") c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".png") #*******************************************************# # # # Generate workspace # # # #*******************************************************# if BIAS: gSystem.Load("libHiggsAnalysisCombinedLimit.so") from ROOT import RooMultiPdf cat = RooCategory("pdf_index", "Index of Pdf which is active") pdfs = RooArgList(modelBkg, modelAlt) roomultipdf = RooMultiPdf("roomultipdf", "All Pdfs", cat, pdfs) normulti = RooRealVar("roomultipdf_norm", "Number of background events", nevents, 0., 1.e6) normzBkg.setConstant( False ) ## newly put here to ensure it's freely floating in the combine fit # create workspace w = RooWorkspace("Zprime_" + YEAR, "workspace") # Dataset if isData: getattr(w, "import")(setData, RooFit.Rename("data_obs")) else: getattr(w, "import")(setToys, RooFit.Rename("data_obs")) #getattr(w, "import")(setData, RooFit.Rename("data_obs")) if BIAS: getattr(w, "import")(cat, RooFit.Rename(cat.GetName())) getattr(w, "import")(normulti, RooFit.Rename(normulti.GetName())) getattr(w, "import")(roomultipdf, RooFit.Rename(roomultipdf.GetName())) getattr(w, "import")(modelBkg, RooFit.Rename(modelBkg.GetName())) getattr(w, "import")(modelAlt, RooFit.Rename(modelAlt.GetName())) getattr(w, "import")(normzBkg, RooFit.Rename(normzBkg.GetName())) w.writeToFile(WORKDIR + "%s_%s.root" % (DATA_TYPE + "_" + YEAR, category), True) print "Workspace", WORKDIR + "%s_%s.root" % ( DATA_TYPE + "_" + YEAR, category), "saved successfully" if VERBOSE: raw_input("Press Enter to continue...")
bin_cut = "((Lb_M23*Lb_M23 > {}) && (Lb_M23*Lb_M23 < {}))".format( qsq_bin_min, qsq_bin_max) pt_cut = "((mum_PT > {}) && (mup_PT > {}) && (pplus_PT > {}) && (Kminus_PT > {}))".format( cut_mum_PT, cut_mup_PT, cut_pplus_PT, cut_Kminus_PT) tot_cut = "{} && {}".format(bin_cut, pt_cut) data_selected = data_all.reduce(tot_cut) data_all.Print() data_selected.Print() data_selected.get(49).Print("cosTheta_lepton") # ---------------------------------------------- # define the PDFs # ---------------------------------------------- Legendre_Lep = RooGenericPdf ("Legendre_Lep", Legendre_Lep_even,\ RooArgList (cosTheta_lepton, cLep2, cLep4,cLep6)) Legendre_Lambda = RooGenericPdf ("Legendre_Lambda", Legendre_Lambda_all, \ RooArgList (cosTheta_Lst,cLambda1, cLambda2,cLambda3, cLambda4, cLambda5)) # ---------------------------------------------- # Make the fit # ---------------------------------------------- fit_results_RooFit_Lep = Legendre_Lep.fitTo(data_selected, ROOT.RooFit.Save()) fit_results_RooFit_Lambda = Legendre_Lambda.fitTo( data_selected, ROOT.RooFit.Save()) #write the the numbers that we need in a text file for the toys later results.write("----\n") results.write("----\n") results.write(
def shapeCards(datahistosFile, histosFile, signalFile, signalSample, hist, signalMass, minMass, maxMass, outputName, outputFileTheta): """function to run Roofit and save workspace for RooStats""" warnings.filterwarnings( action='ignore', category=RuntimeWarning, message='.*class stack<RooAbsArg\*,deque<RooAbsArg\*> >') ############################################################# DATA #hData = histosFile.Get('massAve_deltaEtaDijet_QCDPtAll') #hData = datahistosFile.Get('massAve_prunedMassAsymVsdeltaEtaDijet_DATA_ABCDProj') dataFile = TFile(datahistosFile) hData = dataFile.Get(hist + '_DATA') hData.Rebin(args.reBin) #hData = hData.Rebin( len( boostedMassAveBins )-1, hData.GetName(), boostedMassAveBins ) #hData = histosFile.Get(hist+'_QCDPtAll_A') #hData.Add(htmpSignal) #hData.Scale(1/hData.Integral()) #maxMass = boostedMassAveBins[ hData.FindLastBinAbove( 0, 1) ] #minMass = signalMass-30 #maxMass = signalMass+30 massAve = RooRealVar('massAve', 'massAve', minMass, maxMass) #massAveData = RooRealVar( 'massAveData', 'massAveData', minMass, maxMass ) rooDataHist = RooDataHist('rooDatahist', 'rooDatahist', RooArgList(massAve), hData) # if isData else hPseudo ) rooDataHist.Print() ############################################################################################ ####################### Signal if 'gaus' in args.job: hSignal = TH1F('massAve_RPVStop', 'massAve_RPVStop', maxMass / args.reBin, minMass, maxMass) for q in range(hSignal.GetNbinsX() + 1): gausEval = signalFile.Eval(hSignal.GetXaxis().GetBinCenter(q)) hSignal.SetBinContent(q, gausEval) #meanSig = RooRealVar( 'meanSig', 'mean of signal', sigGaus.GetParameter( 1 ) ) #sigmaSig = RooRealVar( 'sigmaSig', 'sigma of signal', sigGaus.GetParameter( 2 ) ) #signalPdf = RooGaussian( 'signal', 'signal', massAve, meanSig, sigmaSig ) #signalPdf.Print() else: signalHistosFile = TFile(signalFile) hSignal = signalHistosFile.Get(hist + '_' + signalSample) hSignal.Rebin(args.reBin) hSignal.Scale(twoProngSF) signalXS = search(dictXS, 'RPVStopStopToJets_UDD312_M-' + str(signalMass)) rooSigHist = RooDataHist('rooSigHist', 'rooSigHist', RooArgList(massAve), hSignal) sigAcc = rooSigHist.sumEntries( ) #round(hSignal.Integral( hSignal.GetXaxis().FindBin( minMass ), hSignal.GetXaxis().FindBin( maxMass )), 2) rooSigHist.Print() #signal = RooHistPdf('signal','signal',RooArgSet(massAve),rooSigHist) #signal.Print() #signal_norm = RooRealVar('signal_norm','signal_norm',0,-1e+04,1e+04) #if args.fitBonly: signal_norm.setConstant() #signal_norm.Print() ##################################################################### hSigSyst = signalUnc(hSignal, signalMass) hSigSystDataHist = {} if args.jesUnc: hSigSystDataHist['JESUp'] = RooDataHist('hSignalJESUp', 'hSignalJESUp', RooArgList(massAve), hSigSyst['JESUp']) hSigSystDataHist['JESDown'] = RooDataHist('hSignalJESDown', 'hSignalJESDown', RooArgList(massAve), hSigSyst['JESDown']) if args.jerUnc: hSigSystDataHist['JERUp'] = RooDataHist('hSignalJERUp', 'hSignalJERUp', RooArgList(massAve), hSigSyst['JERUp']) hSigSystDataHist['JERDown'] = RooDataHist('hSignalJERDown', 'hSignalJERDown', RooArgList(massAve), hSigSyst['JERDown']) #################################### Background if args.altBkg: newBkgHistoFile = datahistosFile.replace('DATA', 'DATA_ABCDBkg') newBkgFile = TFile(newBkgHistoFile) htmpBkg = newBkgFile.Get( 'massAve_prunedMassAsymVsdeltaEtaDijet_DATA_ABCDProj') if (htmpBkg.GetBinWidth(1) != args.reBin): print '|----- Bin size in DATA_C histogram is different than rest.' sys.exit(0) else: htmpBkg = dataFile.Get( 'massAve_prunedMassAsymVsdeltaEtaDijet_DATA_ABCDProj') htmpBkg.Rebin(args.reBin) #hBkg = histosFile.Get('massAve_prunedMassAsymVsdeltaEtaDijet_QCDPtAll_ABCDProj') #hBkg = histosFile.Get(hist+'_QCDPtAll_BCD') #htmpBkg = htmpBkg.Rebin( len( boostedMassAveBins )-1, htmpBkg.GetName(), boostedMassAveBins ) hBkg = htmpBkg.Clone() hBkg.Reset() for ibin in range(htmpBkg.GetNbinsX()): binCont = htmpBkg.GetBinContent(ibin) binErr = htmpBkg.GetBinError(ibin) if binCont == 0: hBkg.SetBinContent(ibin, 0) hBkg.SetBinError(ibin, 1.8) else: hBkg.SetBinContent(ibin, binCont) hBkg.SetBinError(ibin, binErr) #hBkg.Scale(1/hBkg.Integral()) hPseudo = createPseudoExperiment(hBkg, bkgAcc) ###### Adding statistical uncertanty hBkgStatUncUp = hBkg.Clone() hBkgStatUncUp.Reset() hBkgStatUncDown = hBkg.Clone() hBkgStatUncDown.Reset() for i in range(hBkg.GetNbinsX() + 1): cont = hBkg.GetBinContent(i) contErr = hBkg.GetBinError(i) hBkgStatUncUp.SetBinContent(i, cont + (1 * contErr)) hBkgStatUncDown.SetBinContent(i, cont - (1 * contErr)) hBkgStatUncUpDataHist = RooDataHist('hBkgStatUncUp', 'hBkgStatUncUp', RooArgList(massAve), hBkgStatUncUp) hBkgStatUncDownDataHist = RooDataHist('hBkgStatUncDown', 'hBkgStatUncDown', RooArgList(massAve), hBkgStatUncDown) if 'template' in args.job: rooBkgHist = RooDataHist('rooBkgHist', 'rooBkgHist', RooArgList(massAve), hBkg) bkgAcc = rooBkgHist.sumEntries() rooBkgHist.Print() background = RooHistPdf('background', 'background', RooArgSet(massAve), rooBkgHist) background.Print() else: massAveBkg = RooRealVar('massAveBkg', 'massAveBkg', minMass, maxMass) p1 = RooRealVar('p1', 'p1', 1, 0., 100.) p2 = RooRealVar('p2', 'p2', 1, 0., 60.) p3 = RooRealVar('p3', 'p3', 1, -10., 10.) bkgAcc = round( hBkg.Integral(hBkg.GetXaxis().FindBin(minMass), hBkg.GetXaxis().FindBin(maxMass)), 2) background = RooGenericPdf( 'background', '(pow(1-@0/%.1f,@1)/pow(@0/%.1f,@2+@3*log(@0/%.1f)))' % (1300, 1300, 1300), RooArgList(massAveBkg, p1, p2, p3)) background.Print() hBkgSyst = {} hBkgSystDataHist = {} if args.bkgUnc: print ' |---> Adding bkg unc' hBkgSyst['BkgUncUp'] = hBkg.Clone() hBkgSyst['BkgUncDown'] = hBkg.Clone() for key in hBkgSyst: hBkgSyst[key].Reset() hBkgSyst[key].SetName(hBkgSyst[key].GetName() + '_' + key) for q in range(0, hBkg.GetNbinsX()): binCont = hBkg.GetBinContent(q) bkgUncUp = 1. + (args.bkgUncValue / 100.) hBkgSyst['BkgUncUp'].SetBinContent(q, binCont * bkgUncUp) bkgUncDown = 1. - (args.bkgUncValue / 100.) hBkgSyst['BkgUncDown'].SetBinContent(q, binCont * bkgUncDown) hBkgSystDataHist['BkgUncUp'] = RooDataHist('hBkgBkgUncUp', 'hBkgBkgUncUp', RooArgList(massAve), hBkgSyst['BkgUncUp']) hBkgSystDataHist['BkgUncDown'] = RooDataHist('hBkgBkgUncDown', 'hBkgBkgUncDown', RooArgList(massAve), hBkgSyst['BkgUncDown']) ############################################################################################ #model = RooAddPdf("model","s+b",RooArgList(background,signal),RooArgList(background_norm,signal_norm)) #res = model.fitTo(rooDataHist, RooFit.Save(kTRUE), RooFit.Strategy(0)) #res.Print() ############################ Create Workspace myWS = RooWorkspace("myWS") getattr(myWS, 'import')(rooBkgHist, RooFit.Rename("background")) #getattr(myWS,'import')(background,RooFit.Rename("background")) #getattr(myWS,'import')(signal_norm) #getattr(myWS,'import')(background_norm) ''' if 'gaus' in args.job: getattr(myWS,'import')(signalPdf,RooFit.Rename("signal")) if args.jesUnc: getattr(myWS,'import')(signalPdfJESUp,RooFit.Rename("signal__JESUp")) getattr(myWS,'import')(signalPdfJESDown,RooFit.Rename("signal__JESDown")) else: ''' getattr(myWS, 'import')(rooSigHist, RooFit.Rename("signal")) if args.jesUnc: getattr(myWS, 'import')(hSigSystDataHist['JESUp'], RooFit.Rename("signal__JESUp")) getattr(myWS, 'import')(hSigSystDataHist['JESDown'], RooFit.Rename("signal__JESDown")) if args.jerUnc: getattr(myWS, 'import')(hSigSystDataHist['JERUp'], RooFit.Rename("signal__JERUp")) getattr(myWS, 'import')(hSigSystDataHist['JERDown'], RooFit.Rename("signal__JERDown")) if args.bkgUnc: getattr(myWS, 'import')(hBkgSystDataHist['BkgUncUp'], RooFit.Rename("background__BkgUncUp")) getattr(myWS, 'import')(hBkgSystDataHist['BkgUncDown'], RooFit.Rename("background__BkgUncDown")) getattr(myWS, 'import')(hBkgStatUncUpDataHist, RooFit.Rename("background__BkgStatUncUp")) getattr(myWS, 'import')(hBkgStatUncDownDataHist, RooFit.Rename("background__BkgStatUncDown")) getattr(myWS, 'import')(rooDataHist, RooFit.Rename("data_obs")) myWS.Print() outputRootFile = currentDir + '/Rootfiles/workspace_' + outputName + '.root' myWS.writeToFile(outputRootFile, True) print ' |----> Workspace created in root file:\n', outputRootFile ''' c1 = TCanvas('c1', 'c1', 10, 10, 750, 500 ) # c1.SetLogy() xframe = myWS.var("massAve").frame() signalPdf.plotOn( xframe ) xframe.Draw() c1.SaveAs('test.png') del c1 ''' ############################################################################################ ######################### write a datacard dataCardName = currentDir + '/Datacards/datacard_' + outputName + '.txt' datacard = open(dataCardName, 'w') datacard.write('imax 1\n') datacard.write('jmax 1\n') datacard.write('kmax *\n') datacard.write('---------------\n') if args.jesUnc or args.jerUnc or args.lumiUnc or args.bkgUnc or args.unc: datacard.write('shapes * * ' + outputRootFile + ' myWS:$PROCESS myWS:$PROCESS__$SYSTEMATIC\n') else: datacard.write("shapes * * " + outputRootFile + " myWS:$PROCESS \n") datacard.write('---------------\n') datacard.write('bin ' + signalSample + '\n') datacard.write('observation -1\n') datacard.write('------------------------------\n') datacard.write('bin ' + signalSample + ' ' + signalSample + '\n') datacard.write('process signal background\n') datacard.write('process 0 1\n') #datacard.write('rate -1 -1\n') datacard.write('rate ' + str(sigAcc) + ' ' + str(bkgAcc) + '\n') datacard.write('------------------------------\n') if args.lumiUnc: datacard.write('lumi lnN %f -\n' % (lumiValue)) if args.puUnc: datacard.write('pu lnN %f -\n' % (puValue)) if args.jesUnc: datacard.write('JES shape 1 -\n') if args.jerUnc: datacard.write('JER shape 1 -\n') #flat parameters --- flat prior #if args.bkgUnc: datacard.write('BkgUnc shape - '+str( round( 1/ (args.bkgUncValue/34.1), 2 ) )+'\n') if args.bkgUnc: datacard.write('BkgUnc shape - 1 \n') #NcombineUnc = ( 1 / TMath.Sqrt( args.bkgUncValue / 100. ) ) - 1 #datacard.write('background_norm gmN '+str(int(round(NcombineUnc)))+' - '+str( round(bkgAcc/NcombineUnc,2) )+'\n') #datacard.write('p1 flatParam\n') datacard.write('BkgStatUnc shape - 1 \n') datacard.close() print ' |----> Datacard created:\n', dataCardName ############################################################################################ ########## Theta if args.theta: print ' |----> Creating Theta file\n', outputFileTheta outFile = TFile(outputFileTheta, 'update') tmpName = 'rpvstopjj' + str(signalMass) hSignal.SetName('massAve__' + tmpName) hSignal.Write() hSigSyst['JESDown'].SetName('massAve__' + tmpName + '__jes__down') hSigSyst['JESDown'].Write() hSigSyst['JESUp'].SetName('massAve__' + tmpName + '__jes__up') hSigSyst['JESUp'].Write() hSigSyst['JERDown'].SetName('massAve__' + tmpName + '__jer__down') hSigSyst['JERDown'].Write() hSigSyst['JERUp'].SetName('massAve__' + tmpName + '__jer__up') hSigSyst['JERUp'].Write() if (signalMass == 100): #or (signalMass == 170): hBkg.SetName('massAve__background') hBkg.Write() hBkgSyst['BkgUncDown'].SetName('massAve__background__unc__down') hBkgSyst['BkgUncDown'].Write() hBkgSyst['BkgUncUp'].SetName('massAve__background__unc__up') hBkgSyst['BkgUncUp'].Write() hData.SetName('massAve__DATA') hData.Write() outFile.Close()
def dofit(roodataset, hname): mass_chib = 10.5103 # from PES uncorrected mass measurement deltaM = 0.0105 # MeV theoretical expectations ratio21 = 0.45 # same as chic2/chic1 and chib2/chib1 # the following numbers are from an old 3P gun simulation # that needs to be re-done sigma1 = 0.003 #0.0031 sigma2 = 0.003 #0.0035 alpha1 = 0.95 alpha2 = 1.12 n = 2.5 mass1_v = RooRealVar('mchi1', 'm_{#chi1}', mass_chib) deltaM_v = RooRealVar('deltaM', '#Delta_{m}', deltaM, 0.005, 0.015) mass2_v = RooFormulaVar('mchi2', '@0+@1', RooArgList(mass1_v, deltaM_v)) sigma1_v = RooRealVar('sigma1', '#sigma_1', sigma1) sigma2_v = RooRealVar('sigma2', '#sigma_2', sigma2) alpha1_v = RooRealVar('alpha1', '#alpha_1', alpha1) alpha2_v = RooRealVar('alpha2', '#alpha_2', alpha2) n_v = RooRealVar('n', 'n', n) ratio21_v = RooRealVar('ratio21', 'r_{21}', ratio21) x = RooRealVar("invm3S", "#chi_{b} Data", 10.4, 10.7) # choose here binning of mass plot x.setBins(150) #signal pdf chib1 = RooCBShape('chib1', 'chib1', x, mass1_v, sigma1_v, alpha1_v, n_v) chib2 = RooCBShape('chib2', 'chib2', x, mass2_v, sigma2_v, alpha2_v, n_v) # define background q01S_Start = 10.4 alpha = RooRealVar("#alpha", "#alpha", 1.5, 0.2, 3.5) beta = RooRealVar("#beta", "#beta", -2.5, -7., 0.) #q0 = RooRealVar("q0","q0",q01S_Start,q01S_Start-0.05,q01S_Start+0.05) q0 = RooRealVar("q0", "q0", q01S_Start) 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)) n_evts_1 = RooRealVar('N_{3P_{1}}', 'N_{3P_{1}}', 50, 30, 1000) n_evts_2 = RooFormulaVar('N_{3P_{2}}', '@0*@1', RooArgList(n_evts_1, ratio21_v)) n_bck = RooRealVar('nbkg', 'n_{bkg}', 500, 0, 100000) #build final pdf modelPdf = RooAddPdf('ModelPdf', 'ModelPdf', RooArgList(chib1, chib2, background), RooArgList(n_evts_1, n_evts_2, n_bck)) # fit low_cut = x.setRange("low_cut", 10.4, 10.7) result = modelPdf.fitTo(roodataset, RooFit.Save(), RooFit.Range("low_cut")) frame = x.frame(RooFit.Title("m(#chi_{b}(3P))")) roodataset.plotOn(frame, RooFit.MarkerSize(0.7)) modelPdf.plotOn(frame, RooFit.LineWidth(1)) modelPdf.plotOn(frame, RooFit.LineWidth(2)) frame.GetXaxis().SetTitle( 'm_{#gamma #mu^{+} #mu^{-}} - m_{#mu^{+} #mu^{-}} + m^{PDG}_{#Upsilon(3S)} [GeV/c^{2}]' ) #frame.GetYaxis().SetTitle( "Events/15.0 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.SetName("fit_resonance") chi2 = frame.chiSquare() chi2 = round(chi2, 2) leg = TLegend(0.50, 0.7, 0.60, 0.8) leg.AddEntry(0, '#chi^{2} =' + str(chi2), '') leg.SetBorderSize(0) leg.SetFillColor(0) leg.SetTextSize(0.06) gROOT.SetStyle("Plain") frame.SaveAs(str(hname) + '.root') # param_set = RooArgSet(n_evts_Roo4, m_chib[1][3],alpha, beta, q0) canvas = TCanvas('fit', "", 1400, 700) canvas.Divide(1) canvas.cd(1) gPad.SetRightMargin(0.3) gPad.SetFillColor(10) # modelPdf.paramOn(frame, RooFit.Layout(0.725,0.9875,0.9), RooFit.Parameters(param_set)) modelPdf.paramOn(frame, RooFit.Layout(0.725, 0.9875, 0.9)) frame.Draw() leg.Draw("same") canvas.SaveAs(str(hname) + '.png')
fit_max = 1.04 #First Gaussian PDF Mkk = RooRealVar("Mkk", "Mkk", fit_min, fit_max) mean1 = RooRealVar("mean1", "Mean of Gaussian 1", 1.01944, 1.01, 1.03) sigma1 = RooRealVar("sigma1", "Width of Gaussian 1", 0.00222, 0.0001, 0.01) gauss1 = RooGaussian("gauss1", "gauss1(Mkk,mean1,sigma1)", Mkk, mean1, sigma1) # Second Gaussian PDF mean2 = RooRealVar("mean2", "Mean of Gaussian 2", 1.02052, 1.0, 1.1) sigma2 = RooRealVar("sigma2", "Width of Gaussian 2", 0.0072, 0.001, 1) gauss2 = RooGaussian("gauss2", "gauss1(Mkk,mean2,sigma2)", Mkk, mean2, sigma2) r2 = RooRealVar("r2", "ratio of width of gaussian 2", 3.2, 0, 10) customGaussR = RooGenericPdf( "customGaussR", "custom PDF build", "1/(sigma1*r2) * exp(- (Mkk - mean2)**2 / (2 * (sigma1*r2) ** 2))", RooArgList(Mkk, mean2, sigma1, r2)) # faster method: r_sigma2 = RooFormulaVar("r_sigma2", "sigma1 * r2", RooArgList(sigma1, r2)) gauss2R = RooGaussian("gauss2R", "gauss1(Mkk,mean2,sigma2)", Mkk, mean2, r_sigma2) toyDataCustom = customGaussR.generate(RooArgSet(Mkk), 100000) toyData = gauss2.generate(RooArgSet(Mkk), 100000) toyDataR = gauss2R.generate(RooArgSet(Mkk), 100000) c = TCanvas("c", "c", 800, 800) frame1 = Mkk.frame(RooFit.Bins(50), RooFit.Title("Comparison of PDFs")) # Plot all data tagged as passed sample
##p2mod = 4.99989 +/- 3.9569 (limited) ##p3mod = 11.9997 +/- 0.529866 (limited) ##p4mod = 2.02636 +/- 0.360492 (limited) ##p5mod = 0.220746 +/- 0.0842075 (limited) ## dijet mass function f_var = RooFormulaVar('f_var', 'f_var', '@0/13000.', RooArgList(J_Mass)) p1mod = RooRealVar('p1mod', 'p1mod', 0., 4000) p2mod = RooRealVar('p2mod', 'p2mod', -2000., 2000.) p3mod = RooRealVar('p3mod', 'p3mod', -1000, 1000.) p4mod = RooRealVar('p4mod', 'p4mod', -100., 100.) p5mod = RooRealVar('p5mod', 'p5mod', -200., 200.) p6mod = RooRealVar('p6mod', 'p6mod', -10, 10.) diJetMass = RooGenericPdf('diJetMass', "pow(1-@0,@2)/pow(@0, @1+@3*log(@0))", RooArgList(f_var, p4mod, p2mod, p3mod)) diJetMass_2 = RooGenericPdf('diJetMass_2', "1.0/pow(@0,@1)", RooArgList(f_var, p3mod)) diJetMass_3 = RooGenericPdf('diJetMass_3', "pow(1-@0,@1)/pow(@0,@2)", RooArgList(f_var, p2mod, p3mod)) diJetMass_4 = RooGenericPdf('diJetMass_4', "pow(1-@0,@1)/pow(@0, @2+@3*log(@0))", RooArgList(f_var, p2mod, p3mod, p4mod)) diJetMass_5 = RooGenericPdf( 'diJetMass_5', "pow(1-@0,@1)/pow(@0, @2+@3*log(@0)+@4*pow(log(@0),2))", RooArgList(J_Mass, p2mod, p3mod, p4mod, p5mod)) ##polynomial of order 5 #diJetMass_5 = RooGenericPdf('diJetMass_5', "@1+@2*pow(@0,1)+@3*pow(@0,2)+@4*pow(@0,3)+@5*pow(@0,4)+@6*pow(@0,5)",RooArgList(J_Mass,p1mod,p2mod,p3mod,p4mod,p5mod,p6mod)) #diJetMass_5 = RooGenericPdf('diJetMass_5', "@1*pow(@0,1)+@2*pow(@0,2)+@3*pow(@0,3)+@4*pow(@0,4)+@5*pow(@0,5)",RooArgList(J_Mass,p2mod,p3mod,p4mod,p5mod,p6mod)) #x= RooRealVar("x","x", 500,1500)
# 3. How to get variable binning (wider bins for longer lifetimes)? ## Acceptance # Note: Using a PDF to represent an acceptance is not rigorously # correct, but it is acceptable in this context since we only want to # determine the shape, which is to be later included in the PDF for # the fit as a function. if accfn == 'powerlaw': # Condition to ensure acceptance function is always +ve definite. # The first condition protects against the undefined nature of the # function for times less than 0. Whereas the second condition # ensures the 0.2 ps selection cut present in the sample is # incorporated into the model. acc_cond = '((@1-@2)<0 || @1<0.0002)' expr = '(1.-1./(1.+(@0*(@1-@2))**3))' PDF = RooGenericPdf('PDF', '%s ? 0 : %s' % (acc_cond, expr), RooArgList(turnon, time, offset)) elif accfn == 'arctan': acc_cond = '(@0<0.0002)' expr = '(atan(@0*exp(@1*@0-@2)))' PDF = RooGenericPdf('PDF', '%s ? 0 : %s' % (acc_cond, expr), RooArgList(time, turnon, offset)) elif accfn == 'erf': acc_cond = '(@1<0.0002)' expr = '(0.5*(TMath::Erf((@1-@2)/@0)+1))' PDF = RooGenericPdf('PDF', '%s ? 0 : %s' % (acc_cond, expr), RooArgList(turnon, time, offset)) else: print 'Unknown acceptance type. Aborting' assert(False) # Dataset to fit to
class fitFunc(object): pass fitParam = {} mT = RooRealVar( "m_T", "m_{T}", 1500., 3900., "GeV") fitBDT0_2016 = fitFunc() fitBDT0_2016.p1 = RooRealVar("CMS2016_BDT0_p1", "p1", -18.0947, -1000., 1000.) fitBDT0_2016.p2 = RooRealVar("CMS2016_BDT0_p2", "p2", 22.8504, -10., 10.) fitBDT0_2016.p3 = RooRealVar("CMS2016_BDT0_p3", "p3", 3.72973, -10., 10.) fitBDT0_2016.modelBkg = RooGenericPdf("Bkg", "Bkg. fit (3 par.)", "pow(1 - @0/13000, @1) / pow(@0/13000, @2+@3*log(@0/13000))", RooArgList(mT, fitBDT0_2016.p1, fitBDT0_2016.p2, fitBDT0_2016.p3)) fitParam["BDT0_2016"] = fitBDT0_2016 fitBDT1_2016 = fitFunc() fitBDT1_2016.p1 = RooRealVar("CMS2016_BDT1_p1", "p1",-13.1451, -1000., 1000.) fitBDT1_2016.p2 = RooRealVar("CMS2016_BDT1_p2", "p2", 13.1451, -10., 10.) fitBDT1_2016.p3 = RooRealVar("CMS2016_BDT1_p3", "p3", 2.91787, -10., 10.) fitBDT1_2016.modelBkg = RooGenericPdf("Bkg", "Bkg. fit (3 par.)", "pow(1 - @0/13000, @1) / pow(@0/13000, @2+@3*log(@0/13000))", RooArgList(mT, fitBDT1_2016.p1, fitBDT1_2016.p2, fitBDT1_2016.p3)) fitParam["BDT1_2016"] = fitBDT1_2016 fitBDT2_2016 = fitFunc() fitBDT2_2016.p1 = RooRealVar("CMS2016_BDT2_p1", "p1", 12.5899, -1000., 1000.) fitBDT2_2016.p2 = RooRealVar("CMS2016_BDT2_p2", "p2", 6.71091, -10., 10.) fitBDT2_2016.p3 = RooRealVar("CMS2016_BDT2_p3", "p3", 0.265957, -10., 10.)
class fitFunc(object): pass fitParam = {} mT = RooRealVar("m_T", "m_{T}", 1500., 3900., "GeV") fitBDT0_2016 = fitFunc() fitBDT0_2016.p1 = RooRealVar("CMS2016_BDT0_p1", "p1", -18.0947, -1000., 1000.) fitBDT0_2016.p2 = RooRealVar("CMS2016_BDT0_p2", "p2", 22.8504, -10., 10.) fitBDT0_2016.p3 = RooRealVar("CMS2016_BDT0_p3", "p3", 3.72973, -10., 10.) fitBDT0_2016.p4 = RooRealVar("CMS2016_BDT0_p3", "p4", 0, -1000., 1000.) fitBDT0_2016.modelBkg = RooGenericPdf( "BkgOrg", "Bkg. fit (3 par.)", "pow(1 - @0/13000, @1) / pow(@0/13000, @2+@3*log(@0/13000))", RooArgList(mT, fitBDT0_2016.p1, fitBDT0_2016.p2, fitBDT0_2016.p3)) fitBDT0_2016.modelBkg2 = RooGenericPdf( "Bkg2", "Bkg. fit (2 par.)", "pow(1 - @0/13000, @1) / pow(@0/13000, @2)", RooArgList(mT, fitBDT0_2016.p1, fitBDT0_2016.p2)) fitBDT0_2016.modelBkg3 = RooGenericPdf( "Bkg3", "Bkg. fit (3 par.)", "pow(1 - @0/13000, @1) / pow(@0/13000, @2+@3*log(@0/13000))", RooArgList(mT, fitBDT0_2016.p1, fitBDT0_2016.p2, fitBDT0_2016.p3)) fitBDT0_2016.modelBkg4 = RooGenericPdf( "Bkg", "Bkg. fit (4 par.)", "pow(1 - @0/13000, @1) / pow(@0/13000, @2+@3*log(@0/13000)+@4*pow(log(@0/13000),2))", RooArgList(mT, fitBDT0_2016.p1, fitBDT0_2016.p2, fitBDT0_2016.p3, fitBDT0_2016.p4)) fitParam["BDT0_2016"] = fitBDT0_2016
# define observable x = RooRealVar('mjj','mjj',900,4500) if fitSig: # define parameters for signal fit m = RooRealVar('mean','mean',float(mass),float(mass)-200,float(mass)+200) s = RooRealVar('sigma','sigma',0.1*float(mass),0,10000) a = RooRealVar('alpha','alpha',1,-10,10) n = RooRealVar('n','n',1,0,100) sig = RooCBShape('sig','sig',x,m,s,a,n) p = RooRealVar('p','p',1,0,5) x0 = RooRealVar('x0','x0',1000,100,5000) bkg = RooGenericPdf('bkg','1/(exp(pow(@0/@1,@2))+1)',RooArgList(x,x0,p)) fsig= RooRealVar('fsig','fsig',0.5,0.,1.) signal = RooAddPdf('signal','signal',sig,bkg,fsig) # ----------------------------------------- # fit signal canSname = 'can_Mjj'+str(mass) if useSub: canSname = 'can_Sub_Mjj'+str(mass) canS = TCanvas(canSname,canSname,900,600) #gPad.SetLogy() roohistSig = RooDataHist('roohist','roohist',RooArgList(x),hSig) signal.fitTo(roohistSig)
def buildPdf(ws, p): mass = RooRealVar("mass", "mass", p.minMass, p.maxMass) # ws.import(mass) getattr(ws,'import')(mass) # Construct signal pdf mean = RooRealVar("mean", "mean", 60, 0, 130) width = RooRealVar("width", "width", 10, 1, 40) # alpha = RooRealVar("alpha", "#alpha", -0.1, -10.0, -0.1) # npow = RooRealVar("npow", "n_{CB}", 2.3, 0.1, 10.) # width.setConstant(ROOT.kTRUE) sigma = RooRealVar("sigma", "sigma", 1.2, 0.2, 40) # minusMass = RooFormulaVar("minusMass", "@0*-1", RooArgList(mass)) # signalAll = RooCBShape("signalAll", "signalAll", mass, mean, width, alpha, npow); signalAll = RooVoigtian("signalAll", "signalAll", mass, mean, width, sigma) # Construct background pdf # a0_all = RooRealVar("a0_all","a0_all",-0.1,-1,1) # a1_all = RooRealVar("a1_all","a1_all",0.004,-1,1) # backgroundAll = RooChebychev("backgroundAll","backgroundAll",mass,RooArgList(a0_all,a1_all)) 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 = RooChebychev("backgroundAll", "backgroundAll", mass, RooArgList(bkg_a1, bkg_a2)) #backgroundAll = RooGenericPdf("backgroundAll","backgroundAll", "exp(-@0/@3)*(TMath::Erf((@0-@1)/@2)+1)", RooArgList(mass, turnOnAll, widthAll_bkg, decayAll_bkg)) backgroundAll = RooGenericPdf("backgroundAll","backgroundAll","exp(-@0/@1)",RooArgList(mass, decayAll_bkg)) #backgroundAll = RooGaussian("backgroundAll", "backgroundAll", mass, meanB, sigmaB) # Construct composite pdf sigAll = RooRealVar("sigAll", "sigAll", 2000, 0, 10000000) bkgAll = RooRealVar("bkgAll", "bkgAll", 100, 0, 1000000) 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) # signalPass = RooCBShape("signalPass", "signalPass", mass, mean, width, alpha, npow); # Construct the background pdf # a0_pass = RooRealVar("a0_pass","a0_pass",-0.1,-1,1) # a1_pass = RooRealVar("a1_pass","a1_pass",0.5,-0.1,1) # backgroundPass = RooChebychev("backgroundPass","backgroundPass",mass,RooArgList(a0_pass,a1_pass)) # turnOnPass = RooRealVar("turnOnPass","turnOnPass", 80., 50., 150.) # widthPass_bkg = RooRealVar("widthPass","widthPass", 2., 0., 50.) decayPass_bkg = RooRealVar("decayPass","decayPass", 80., 20., 150.) #backgroundPass = RooChebychev("backgroundPass", "backgroundPass", mass, RooArgList(bkg_a1, bkg_a2)) #backgroundPass = RooGenericPdf("backgroundPass","backgroundPass", "exp(-@0/@3)*(TMath::Erf((@0-@1)/@2)+1)", RooArgList(mass, turnOnPass, widthPass_bkg, decayPass_bkg)); #backgroundPass = RooGenericPdf("backgroundPass","backgroundPass", "exp(-@0/@3)*(TMath::Erf((@0-@1)/@2)+1)", RooArgList(mass, turnOnAll, widthAll_bkg, decayAll_bkg)); backgroundPass = RooGenericPdf("backgroundPass","backgroundPass","exp(-@0/@1)",RooArgList(mass, decayPass_bkg)) #backgroundPass = RooGaussian("backgroundPass", "backgroundPass", mass, meanB, sigmaB) # Construct the composite model efficiency = RooRealVar("efficiency","efficiency",0.9,0.1,1.) # Use it only analyzing the data prescaling value set to be 20 sigPass = RooFormulaVar("sigPass", "@0*@1*"+str(p.scaleFactor), RooArgList(sigAll, efficiency)) bkgPass = RooRealVar("bkgPass", "bkgPass", 100, 0, 1000000) # bkgPass = RooFormulaVar("bkgPass", "@0*@1", RooArgList(bkgAll, efficiency)) 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 fitChicSpectrum(dataset, binname): """ Fit chic spectrum""" x = RooRealVar('s', 's', -2, 2) x.setBins(200) #signal model q_chi1 = RooRealVar('qchi1', 'q_{#chi 1}', 0.414, 0.2, 0.6) q_chi2 = RooRealVar('qchi2', 'q_{#chi 2}', 0.430, 0.2, 0.6) delta_chi10 = RooRealVar('delta_chi10', 'delta_chi10', 0.09591) q_chi0 = RooFormulaVar('q_chi0', '@0 - @1', RooArgList(q_chi1, delta_chi10)) alphacb_chi1 = RooRealVar('alphacb_chi1', '#alpha^{CB}_{#chi 1}', 0.6, 0, 2) alphacb_chi2 = RooRealVar('alphacb_chi2', '#alpha^{CB}_{#chi 2}', 0.4, 0, 2) sigmacb_chi1 = RooRealVar('sigmacb_chi1', '#sigma^{CB}_{#chi 1}', 0.005, 0, 1) sigmacb_chi2 = RooRealVar('sigmacb_chi2', '#sigma^{CB}_{#chi 2}', 0.005, 0, 1) n_cb = RooRealVar('ncb', 'n^{CB}', 3.0, 0., 5.) gamma_chi0 = RooRealVar('gamma_chi0', 'gamma_chi0', 0.0104) sigmacb_chi0 = RooRealVar('sigmacb_chi0', '#sigma^{CB}_{#chi 0}', 0.005) chi0_sig = RooVoigtian('chi0sig', 'chi0sig,', x, q_chi0, sigmacb_chi0, gamma_chi0) chi1_sig = RooCBShape('chi1sig', 'chi1sig', x, q_chi1, sigmacb_chi1, alphacb_chi1, n_cb) chi2_sig = RooCBShape('chi2sig', 'chi2sig', x, q_chi2, sigmacb_chi2, alphacb_chi2, n_cb) fchi0 = RooRealVar('fchi0', 'f_{#chi 0}', 0.01, 0, 1) fchi1 = RooRealVar('fchi1', 'f_{#chi 1}', 0.5, 0, 1) fchi2 = RooFormulaVar('fchi2', '1-@0-@1', RooArgList(fchi0, fchi1)) fbck = RooRealVar('fbck', 'f_{bck}', 0.2, 0, 1) sigmodel = RooAddPdf('sigm', 'sigm', RooArgList(chi0_sig, chi1_sig, chi2_sig), RooArgList(fchi0, fchi1, fchi2)) #background model q0Start = 0.0 a_bck = RooRealVar('a_bck', 'a_{bck}', 0.5, -5, 5) b_bck = RooRealVar('b_bck', 'b_{bck}', -2.5, -7., 0.) q0 = RooRealVar('q0', 'q0', q0Start) delta = RooFormulaVar('delta', 'TMath::Abs(@0-@1)', RooArgList(x, q0)) bfun = RooFormulaVar('bfun', '@0*(@1-@2)', RooArgList(b_bck, x, q0)) signum = RooFormulaVar('signum', '( TMath::Sign( -1.,@0-@1 )+1 )/2.', RooArgList(x, q0)) background = RooGenericPdf('background', 'Background', 'signum*pow(delta,a_bck)*exp(bfun)', RooArgList(signum, delta, a_bck, bfun)) modelPdf = RooAddPdf('chicmodel', 'chicmodel', RooArgList(sigmodel, background), RooArgList(fbck)) frame = x.frame(RooFit.Title('Q')) range = x.setRange('range', 0, 2) # result = modelPdf.fitTo(dataset,RooFit.Save(),RooFit.Range('range')) dataset.plotOn(frame, RooFit.MarkerSize(0.7)) modelPdf.plotOn(frame, RooFit.LineWidth(2)) #plotting canvas = TCanvas('fit', "", 1400, 700) canvas.Divide(1) canvas.cd(1) gPad.SetRightMargin(0.3) gPad.SetFillColor(10) modelPdf.paramOn(frame, RooFit.Layout(0.725, 0.9875, 0.9)) frame.Draw() canvas.SaveAs('out-' + binname + '.png') canvas.SaveAs('out-' + binname + '.root')
def shapeCards( process, isData, datahistosFile, histosFile, signalHistosFile, signalSample, hist, signalMass, minMass, maxMass, jesValue, jerValue, lumiUnc, outputName ): """function to run Roofit and save workspace for RooStats""" warnings.filterwarnings( action='ignore', category=RuntimeWarning, message='.*class stack<RooAbsArg\*,deque<RooAbsArg\*> >' ) hSignal = signalHistosFile.Get(hist+'_'+signalSample) hSignal.Rebin(10) htmpSignal = hSignal.Clone() #htmpSignal.Scale(100) signalXS = search(dictXS, 'RPVStopStopToJets_UDD312_M-'+str(signalMass) ) #hSignal.Scale( lumi*signalXS / hSignal.Integral()) massAve = RooRealVar( 'massAve', 'massAve', minMass, maxMass ) rooSigHist = RooDataHist( 'rooSigHist', 'rooSigHist', RooArgList(massAve), hSignal ) rooSigHist.Print() signal = RooHistPdf('signal','signal',RooArgSet(massAve),rooSigHist) signal.Print() signal_norm = RooRealVar('signal_norm','signal_norm',0,-1e+04,1e+04) #if args.fitBonly: signal_norm.setConstant() signal_norm.Print() hBkg = datahistosFile.Get('massAve_prunedMassAsymVsdeltaEtaDijet_DATA_ABCDProj') #hBkg = histosFile.Get(hist+'_QCDPtAll_BCD') bkgAcc = round(hBkg.Integral( hBkg.GetXaxis().FindBin( minMass ), hBkg.GetXaxis().FindBin( maxMass ))) #hBkg.Scale(1/hBkg.Integral()) hPseudo = hBkg.Clone() hPseudo.Reset() #background_norm = RooRealVar('background_norm','background_norm',bkgAcc,0.,1e+07) background_norm = RooRealVar('background_norm','background_norm',1.,0.,1e+07) background_norm.Print() if 'template' in process: rooBkgHist = RooDataHist( 'rooBkgHist', 'rooBkgHist', RooArgList(massAve), hBkg ) rooBkgHist.Print() background = RooHistPdf('background','background',RooArgSet(massAve),rooBkgHist) background.Print() else: p1 = RooRealVar('p1','p1', 1 ,0.,100.) p2 = RooRealVar('p2','p2', 1 ,0.,60.) p3 = RooRealVar('p3','p3', 1 , -10.,10.) background = RooGenericPdf('background','(pow(1-@0/%.1f,@1)/pow(@0/%.1f,@2+@3*log(@0/%.1f)))'%(1300,1300,1300),RooArgList(massAve,p1,p2,p3)) background.Print() ### S+B model if not isData: newNumEvents = random.randint( bkgAcc-round(TMath.Sqrt(bkgAcc)), bkgAcc+round(TMath.Sqrt(bkgAcc)) ) print 'Events in MC:', bkgAcc, ', in PseudoExperiment:', newNumEvents hPseudo.FillRandom( hBkg, newNumEvents ) #hPseudo.Scale(1/hPseudo.Integral()) #hData = histosFile.Get('massAve_prunedMassAsymVsdeltaEtaDijet_ABCDProj') hData = datahistosFile.Get('massAve_prunedMassAsymVsdeltaEtaDijet_DATA_ABCDProj') #hData = histosFile.Get(hist+'_QCDPtAll_A') #hData.Add(htmpSignal) #hData.Scale(1/hData.Integral()) rooDataHist = RooDataHist('rooDatahist','rooDatahist',RooArgList(massAve), hData if isData else hPseudo ) rooDataHist.Print() #model = RooAddPdf("model","s+b",RooArgList(background,signal),RooArgList(background_norm,signal_norm)) #res = model.fitTo(rooDataHist, RooFit.Save(kTRUE), RooFit.Strategy(0)) #res.Print() ############# JES and JER uncertainties hSigSyst = {} hSigSystDataHist = {} signalCDF = TGraph(hSignal.GetNbinsX()+1) # JES and JER uncertainties if args.jesUnc or args.jerUnc: signalCDF.SetPoint(0,0.,0.) integral = 0. for i in range(1, hSignal.GetNbinsX()+1): x = hSignal.GetXaxis().GetBinLowEdge(i+1) integral = integral + hSignal.GetBinContent(i) signalCDF.SetPoint(i,x,integral) if args.jesUnc: print ' |---> Adding JES' hSigSyst['JESUp'] = hSignal.Clone() hSigSyst['JESDown'] = hSignal.Clone() if args.jerUnc: print ' |---> Adding JER' hSigSyst['JERUp'] = hSignal.Clone() hSigSyst['JERDown'] = hSignal.Clone() # reset signal histograms for key in hSigSyst: hSigSyst[key].Reset() hSigSyst[key].SetName(hSigSyst[key].GetName() + '_' + key) # produce JES signal shapes if args.jesUnc: for q in range(1, hSignal.GetNbinsX()+1): xLow = hSignal.GetXaxis().GetBinLowEdge(q) xUp = hSignal.GetXaxis().GetBinLowEdge(q+1) jes = 1. - jesValue xLowPrime = jes*xLow xUpPrime = jes*xUp hSigSyst['JESUp'].SetBinContent(q, signalCDF.Eval(xUpPrime) - signalCDF.Eval(xLowPrime)) jes = 1. + jesValue xLowPrime = jes*xLow xUpPrime = jes*xUp hSigSyst['JESDown'].SetBinContent(q, signalCDF.Eval(xUpPrime) - signalCDF.Eval(xLowPrime)) hSigSystDataHist['JESUp'] = RooDataHist('hSignalJESUp','hSignalJESUp',RooArgList(massAve),hSigSyst['JESUp']) hSigSystDataHist['JESDown'] = RooDataHist('hSignalJESDown','hSignalJESDown',RooArgList(massAve),hSigSyst['JESDown']) # produce JER signal shapes if args.jerUnc: for i in range(1, hSignal.GetNbinsX()+1): xLow = hSignal.GetXaxis().GetBinLowEdge(i) xUp = hSignal.GetXaxis().GetBinLowEdge(i+1) jer = 1. - jerValue xLowPrime = jer*(xLow-float(signalMass))+float(signalMass) xUpPrime = jer*(xUp-float(signalMass))+float(signalMass) hSigSyst['JERUp'].SetBinContent(i, signalCDF.Eval(xUpPrime) - signalCDF.Eval(xLowPrime)) jer = 1. + jerValue xLowPrime = jer*(xLow-float(signalMass))+float(signalMass) xUpPrime = jer*(xUp-float(signalMass))+float(signalMass) hSigSyst['JERDown'].SetBinContent(i, signalCDF.Eval(xUpPrime) - signalCDF.Eval(xLowPrime)) hSigSystDataHist['JERUp'] = RooDataHist('hSignalJERUp','hSignalJERUp',RooArgList(massAve),hSigSyst['JERUp']) hSigSystDataHist['JERDown'] = RooDataHist('hSignalJERDown','hSignalJERDown',RooArgList(massAve),hSigSyst['JERDown']) myWS = RooWorkspace("myWS") getattr(myWS,'import')(rooSigHist,RooFit.Rename("signal")) getattr(myWS,'import')(rooBkgHist,RooFit.Rename("background")) #getattr(myWS,'import')(signal_norm) getattr(myWS,'import')(background_norm) if args.jesUnc: getattr(myWS,'import')(hSigSystDataHist['JESUp'],RooFit.Rename("signal__JESUp")) getattr(myWS,'import')(hSigSystDataHist['JESDown'],RooFit.Rename("signal__JESDown")) if args.jerUnc: getattr(myWS,'import')(hSigSystDataHist['JERUp'],RooFit.Rename("signal__JERUp")) getattr(myWS,'import')(hSigSystDataHist['JERDown'],RooFit.Rename("signal__JERDown")) getattr(myWS,'import')(rooDataHist,RooFit.Rename("data_obs")) myWS.Print() outputRootFile = currentDir+'/Rootfiles/workspace_'+outputName+'.root' myWS.writeToFile(outputRootFile, True) print ' |----> Workspace created in root file:\n', outputRootFile # ----------------------------------------- # write a datacard dataCardName = currentDir+'/Datacards/datacard_'+outputName+'.txt' datacard = open( dataCardName ,'w') datacard.write('imax 1\n') datacard.write('jmax 1\n') datacard.write('kmax *\n') datacard.write('---------------\n') if args.jesUnc or args.jerUnc or args.lumiUnc or args.normUnc or args.unc: datacard.write('shapes * * '+outputRootFile+' myWS:$PROCESS myWS:$PROCESS__$SYSTEMATIC\n') else: datacard.write("shapes * * "+outputRootFile+" myWS:$PROCESS \n") datacard.write('---------------\n') datacard.write('bin 1\n') datacard.write('observation -1\n') datacard.write('------------------------------\n') datacard.write('bin 1 1\n') datacard.write('process signal background\n') datacard.write('process 0 1\n') datacard.write('rate -1 -1\n') datacard.write('------------------------------\n') if args.lumiUnc: datacard.write('lumi lnN %f -\n'%(lumiUnc)) if args.jesUnc: datacard.write('JES shape 1 -\n') if args.jerUnc: datacard.write('JER shape 1 -\n') #flat parameters --- flat prior if args.normUnc: datacard.write('background_norm flatParam\n') #datacard.write('p1 flatParam\n') datacard.close() print ' |----> Datacard created:\n', dataCardName
def create_pdfs(self, paths_to_data, save=True): """ Fit amplitude and offset of sinusoidal pdfs """ if not isinstance(paths_to_data, list): paths_to_data = [paths_to_data] files_H = [] files_A = [] for path in paths_to_data: # These are merged, so only one of each if not path.endswith('/'): path += '/' files_H.append(path+'model_H_merged.h5') files_A.append(path+'model_A_merged.h5') # TODO: Background samples: uniform pdf self.phistar = RooRealVar('phistar', 'phistar', 0, 2*pi) self.ampl = RooRealVar('ampl', 'ampl', 1, 0, 10) # Must remain in scope self.offset = RooRealVar('offset', 'offset', 1, 0, 10) # - " - # Read in the data # Need only to fit pdf parameters for H, since the pdf for A is # equal but with a 180 deg phase shift. starttime = time.time() dataH_X, _, feats = self.read_array_from_files(files_H) dataH_X = self.select_features(dataH_X, feats) print 'Limiting events for pdf creation to 1e6' dataH_X = dataH_X[:1000000] templatedataH = RooDataSet('templatedataH', 'templatedataH', RooArgSet(self.phistar)) for phi in dataH_X: self.phistar.setVal(phi) templatedataH.add(RooArgSet(self.phistar)) # Reset parameters self.ampl = RooRealVar('ampl', 'ampl', 1, 0, 10) self.offset = RooRealVar('offset', 'offset', 1, 0, 10) # Pdf for scalar decay scalar_pdf = RooGenericPdf('scalar_pdf', 'scalar_pdf', 'ampl*sin(phistar-1.570796) + offset', RooArgList(self.ampl, self.phistar, self.offset)) scalar_pdf.fitTo(templatedataH) self.ampl.setConstant() self.offset.setConstant() # Fitting only the scalar pdf is enough to get the pseudoscalar parameters too pseudoscalar_pdf = RooGenericPdf('pseudoscalar_pdf', 'pseudoscalar_pdf', 'ampl*sin(phistar+1.570796) + offset', RooArgList(self.ampl, self.phistar, self.offset)) self.pdfs['H'] = scalar_pdf self.pdfs['A'] = pseudoscalar_pdf print 'Creating phistar pdf took %s' % time.strftime("%H:%M:%S", time.gmtime(time.time()-starttime)) if save: ws = RooWorkspace('ws', 'ws') getattr(ws, 'import')(self.phistar) getattr(ws, 'import')(self.ampl) getattr(ws, 'import')(self.offset) getattr(ws, 'import')(self.pdfs['H']) getattr(ws, 'import')(self.pdfs['A']) ws.writeToFile('%s/pdfs_%s.root' % (self.outdir, self.title))
jpsik = RooRealVar("jpsik_m_ref","jpsik_m",0.0,1000.0) theSet = RooArgSet(mass_ref_c_kkk,dimuonditrk_m_rf_c,dimuonditrk_charge,kkk,jpsik) #RooArgSet(RooArgSet(mass_ref_c_kkk,dimuonditrk_m_rf_c,dimuonditrk_ctauPV,dimuonditrk_ctauErrPV,dimuon_pt),RooArgSet(ditrak_pt,mass_ref_c_kkk,dimuonditrk_charge,ditrak_m,dimuon_m)) DATA = RooDataSet("alldata","alldata",xTuple,theSet) splotData = RooDataSet("alldata_sig","alldata_sig",DATA,theSet,"dimuonditrk_charge==0") #splotBkgData = RooDataSet("alldata_bkg","alldata_bkg",DATA,theSet,"dimuonditrk_charge!=0 && dimuonditrk_m_rf_c<5.0 && dimuonditrk_m_rf_c>4.0") print "Tree entries %d"%(splotData.numEntries()) print "PHSP fit" BkgTotalMPdf = RooGenericPdf("BkgPdf","BkgPdf","sqrt( pow(dimuonditrk_m_rf_c,4) + pow(3.0967,4) + pow(1.01946,4) - 2*pow(dimuonditrk_m_rf_c,2)*pow(3.0967,2) - 2*pow(3.0967,2)*pow(1.01946,2) - 2*pow(dimuonditrk_m_rf_c,2)*pow(1.01946,2) ) * sqrt( pow(5.279,4) + pow(dimuonditrk_m_rf_c,4) + pow(0.493677,4) - 2*pow(5.279,2)*pow(dimuonditrk_m_rf_c,2) - 2*pow(5.279,2)*pow(0.493677,2) - 2*pow(dimuonditrk_m_rf_c,2)*pow(0.493677,2) ) / (dimuonditrk_m_rf_c)", RooArgList(dimuonditrk_m_rf_c)); dimuonditrk_m_rf_c.setBins(80) dimuonditrk_m_rf_c.setRange("baserange",4.0,5.0) s = BkgTotalMPdf.createIntegral(RooArgSet(dimuonditrk_m_rf_c),"baserange").getVal() #bkgFit = BkgTotalMPdf.fitTo(splotBkgData,Range(4.0,5.0),RooFit.NumCPU(args.ncpu),RooFit.Verbose(False)) cb = TCanvas("canvas_b","canvas_b",1200,800) print s mumukkFrame = dimuonditrk_m_rf_c.frame(Title("Phase Space Fit"),Range(4.0,5.0),Normalization(1.0)) splotData.plotOn(mumukkFrame) BkgTotalMPdf.plotOn(mumukkFrame,Normalization(1.65)) mumukkFrame.Draw()