def addHistData(self, ws, ds_name, item_title, var_set_name, var_set_type, ds_object, sets=None): legend = '[exostConfig::addHistData]:' arg_list = RooArgList() if (var_set_type == 'set'): #arg_list.add(ws.set(var_set_name)) arg_list.add(sets[var_set_name]) elif (var_set_type == 'var'): arg_list.add(ws.var(var_set_name)) else: print legend, 'error: unknown var_set_type, cannot create dataset', ds_name return -1 #create the hist dataset ds = RooDataHist(ds_name, item_title, arg_list, ds_object, 1) # import the datahist. Note workaround 'import' being a reserved word getattr(ws, 'import')(ds)
def performFitInLeptonAbsEta(data_histogram, signal_histogram, bkg1_histogram, bkg2_histogram): N_Data = data_histogram.Integral() N_signal = signal_histogram.Integral() N_bkg1 = bkg1_histogram.Integral() N_bkg2 = bkg2_histogram.Integral() leptonAbsEta = RooRealVar("leptonAbsEta", "leptonAbsEta", 0., 3.) variables = RooArgList() variables.add(leptonAbsEta) variable_set = RooArgSet() variable_set.add(leptonAbsEta) lowerBound = 0 upperBound = N_Data * 2 data_RooDataHist = RooDataHist("data", "dataset with leptonAbsEta", variables, data_histogram) signal_RooDataHist = RooDataHist("rh_signal", "signal", variables, signal_histogram) bkg1_RooDataHist = RooDataHist("rh_bkg1", "bkg1", variables, bkg1_histogram) bkg2_RooDataHist = RooDataHist("rh_bkg2", "bkg2", variables, bkg2_histogram) signal_RooHistPdf = RooHistPdf("pdf_signal", "Signal PDF", variable_set, signal_RooDataHist, 0) signal_RooHistPdf = RooHistPdf("pdf_signal", "Signal PDF", variable_set, signal_RooDataHist, 0)
def get_arglist(args): """Return and arglist of the RooFit objects.""" arglist = RooArgList() for arg in args: if arg.InheritsFrom(RooAbsArg.Class()): arglist.add(arg) else: TypeError('%s should inherit from RooAbsArg' % arg.GetName()) return arglist
def _make_underlying_model(self): self.pdfs = {} self.yields = {} # yields are plain floats self.ryields = {} # keep track of roofit objects for memory management nbins, xmin, xmax = self.plot.histos[0].GetBinning() self.xvar = RooRealVar("x", "x", xmin, xmax) self.xvar.setBins(nbins) self.pdfs = {} self.hists = [] pdfs = RooArgList() yields = RooArgList() for compname, comp in self.plot.histosDict.iteritems(): if comp.weighted.Integral() == 0: continue assert (isinstance(comp, Histogram)) hist = RooDataHist(compname, compname, RooArgList(self.xvar), comp.weighted) SetOwnership(hist, False) # self.hists.append(hist) pdf = RooHistPdf(compname, compname, RooArgSet(self.xvar), hist) self.pdfs[compname] = pdf # self.pdfs[compname].Print() pdfs.add(pdf) nevts = comp.Integral(xmin=xmin, xmax=xmax) nmin = min(0, nevts * (1 - comp.uncertainty)) nmax = nevts * (1 + comp.uncertainty) theyield = RooRealVar('n{}'.format(compname), 'n{}'.format(compname), nevts, nmin, nmax) self.ryields[compname] = theyield self.yields[compname] = nevts yields.add(theyield) self.underlying_model = RooAddPdf('model', 'model', pdfs, yields)
def getInitialFitRes(cfg, ws): """ Create a prefit RooExpandedFitResult for this workspace """ mc = ws.obj("ModelConfig") force_mu, mu_val = cfg.force_mu_value() if force_mu: mc.GetParametersOfInterest().first().setVal(mu_val) np = RooArgList(mc.GetNuisanceParameters()) np.add(mc.GetParametersOfInterest()) ws.loadSnapshot("snapshot_paramsVals_initial") #removeGamma(np) it = np.createIterator() n = it.Next() while n: if "alpha" in n.GetName(): n.setError(1) else: n.setError(1.e-4) #if "alpha_SysJetEResol" in n.GetName(): #n.setVal(-1) n = it.Next() ws.saveSnapshot("vars_initial", RooArgSet(np)) re = ROOT.RooExpandedFitResult(np) cfg._muhat = mc.GetParametersOfInterest().first().getVal() if logging.getLogger().isEnabledFor(logging.DEBUG): logging.debug("Expanded RooFit results") re.Print("v") return re
def 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 main (): N_bkg1 = 9000 N_signal = 1000 N_bkg1_obs = 10000 N_signal_obs = 2000 N_data = N_bkg1_obs + N_signal_obs mu1, mu2, sigma1, sigma2 = 100, 140, 15, 5 x1 = mu1 + sigma1 * np.random.randn( N_bkg1 ) x2 = mu2 + sigma2 * np.random.randn( N_signal ) x1_obs = mu1 + sigma1 * np.random.randn( N_bkg1_obs ) x2_obs = mu2 + sigma2 * np.random.randn( N_signal_obs ) h1 = Hist( 100, 40, 200, title = 'Background' ) h2 = h1.Clone( title = 'Signal' ) h3 = h1.Clone( title = 'Data' ) h3.markersize = 1.2 # fill the histograms with our distributions map( h1.Fill, x1 ) map( h2.Fill, x2 ) map( h3.Fill, x1_obs ) map( h3.Fill, x2_obs ) histograms_1 = {'signal': h2, 'bkg1': h1, 'data': h3} histograms_2 = {'signal': h2, 'bkg1': h1, 'data': h3} # roofit_histograms contains RooDataHist # model = RooAddPdf model1, roofit_histograms_1,fit_variable_1 = get_roofit_model( histograms_1, fit_boundaries = ( 40, 200 ), name = 'm1' ) model2, roofit_histograms_2, fit_variable_2 = get_roofit_model( histograms_2, fit_boundaries = ( 40, 200 ), name = 'm2' ) sample = RooCategory( 'sample', 'sample' ) sample.defineType( 'm1', 1 ) sample.defineType( 'm2', 2 ) combined_data = deepcopy( roofit_histograms_1['data'] ) combined_data.add( roofit_histograms_2['data'] ) # RooDataHist(const char* name, const char* title, const RooArgList& vars, RooCategory& indexCat, map<std::string,TH1*> histMap, Double_t initWgt = 1.0) sim_pdf = RooSimultaneous( "simPdf", "simultaneous pdf", sample ) sim_pdf.addPdf( model1, 'm1' ) sim_pdf.addPdf( model2, 'm2' ) variables = RooArgList() variables.add(fit_variable_1) variables.add(fit_variable_2) # combined_data = RooDataHist('combined_data', 'combined_data', # variables, RooFit.Index(sample), # RooFit.Import('m1', roofit_histograms_1['data']), # RooFit.Import('m2', roofit_histograms_2['data'])) fitResult = sim_pdf.fitTo( combined_data, # RooFit.Minimizer( "Minuit2", "Migrad" ), # RooFit.NumCPU( 1 ), # RooFit.Extended(), RooFit.Save(), )
def removeGamma(arglist): to_remove = RooArgList() it = arglist.createIterator() n = it.Next() while n: if n.GetName().startswith("gamma"): to_remove.add(n) n = it.Next() print("Will remove") to_remove.Print() arglist.remove(to_remove)
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 getPdfInRegions(w,sample,region): if isinstance(sample,list): sampleArgList = RooArgList() sample_str="group" for s in sample: componentTmp = Util.GetComponent(w,s,region,True) sample_str=sample_str+"_"+s sampleArgList.add(componentTmp) pass pdfInRegion = RooAddition(sample_str,sample_str,sampleArgList) else: pdfInRegion = Util.GetComponent(w,sample,region) pass return pdfInRegion
def PlotSignalShapes(Selection): f__ = TFile.Open( "datacards/22June/2dPlots.root") signal_fname_1 = ("signals/22June/out_{sample:s}_syst.root", "cms_hgg_13TeV" ) signal_fname_2 = ("signals/22June/out_ctcv_{sample:s}_syst.root" , "ctcv" ) samples = {"thw":signal_fname_2, "thq":signal_fname_2, "tth":signal_fname_1 , "vh":signal_fname_1 } purity_h_name = "{sample:s}/"+Selection+"/h{sample:s}_"+Selection+"_purity_CtCv" purities = RooArgList() signalshapes = RooArgList() ctOverCvs = [] mVar = None ctovercv_vals = None for sample in samples : purity = CtCvCpInfo("purity_" + sample) ctovercv_vals = sorted(purity.AllCtOverCVs.keys()) purity.FillFrom2DHisto( f__.Get( purity_h_name.format( sample=sample ) ) ) purity.GetCtOverCv() purities.add( purity.CtOverCvDataHistFunc ) objsToKeep.append( purity ) sFile = TFile.Open( samples[sample][0].format( sample=sample ) ) ws = sFile.Get( samples[sample][1] ) pdf = ws.pdf("RV{sample:s}_mh125".format( sample=sample) ) objsToKeep.append(sFile) objsToKeep.append(ws) objsToKeep.append(pdf) signalshapes.add( pdf ) ctOverCvs.append( ws.var( "CtOverCv" ) ) mVar = ws.var("CMS_hgg_mass") ret = RooAddPdf("signal" , "signal" , signalshapes , purities ) objsToKeep.append( ret ) plot = mVar.frame() options = "" for ctovercv in ctovercv_vals : for var in ctOverCvs: var.setVal( ctovercv ) name = "name%g" % ctovercv ret.plotOn( plot , RooFit.DrawOption(options) , RooFit.Name(name) ) c = TCanvas() plot.Draw() c.SaveAs("a.gif+") if not "same" in options : options += " same" return c
def addTrackMomenta( dataSet ): """ add K+, K-, mu+ and mu- momentum magnitudes to data set """ # get observables from data set from ROOT import RooArgList, RooFormulaVar KplusList = RooArgList('KplusList') KminusList = RooArgList('KminusList') muplusList = RooArgList('muplusList') muminusList = RooArgList('muminusList') for suf in [ 'X','Y','Z' ] : KplusList.add( dataSet.get().find('Kplus_P' + suf) ) KminusList.add( dataSet.get().find('Kminus_P' + suf) ) muplusList.add( dataSet.get().find('muplus_P' + suf) ) muminusList.add( dataSet.get().find('muminus_P' + suf) ) # create formulas KplusMomFunc = RooFormulaVar( 'Kplus_P', 'Kplus_P', 'TMath::Sqrt(Kplus_PX**2 + Kplus_PY**2 + Kplus_PZ**2)', KplusList ) KminusMomFunc = RooFormulaVar( 'Kminus_P', 'Kminus_P', 'TMath::Sqrt(Kminus_PX**2 + Kminus_PY**2 + Kminus_PZ**2)', KminusList ) muplusMomFunc = RooFormulaVar( 'muplus_P', 'muplus_P', 'TMath::Sqrt(muplus_PX**2 + muplus_PY**2 + muplus_PZ**2)', muplusList ) muminusMomFunc = RooFormulaVar( 'muminus_P','muminus_P', 'TMath::Sqrt(muminus_PX**2 + muminus_PY**2 + muminus_PZ**2)', muminusList ) # create new columns in data set dataSet.addColumn(KplusMomFunc) dataSet.addColumn(KminusMomFunc) dataSet.addColumn(muplusMomFunc) dataSet.addColumn(muminusMomFunc)
def getPdfInRegionsWithRangeName(w,sample,region,rangeName): """ Should be moved to $HF/src/Utils.h -- FIXME """ if isinstance(sample,list): sampleArgList = RooArgList() sample_str="group" for s in sample: componentTmp = Util.GetComponent(w,s,region,True,rangeName) sample_str=sample_str+"_"+s sampleArgList.add(componentTmp) pass pdfInRegion = RooAddition(sample_str,sample_str,sampleArgList) else: pdfInRegion = Util.GetComponent(w,sample,region,False,rangeName) pass return pdfInRegion
def addHistData(self, ws, ds_name, item_title, var_set_name, var_set_type, ds_object, sets = None): legend = '[exostConfig::addHistData]:' arg_list = RooArgList() if (var_set_type == 'set'): #arg_list.add(ws.set(var_set_name)) arg_list.add(sets[var_set_name]) elif (var_set_type == 'var'): arg_list.add(ws.var(var_set_name)) else: print legend, 'error: unknown var_set_type, cannot create dataset', ds_name return -1 #create the hist dataset ds = RooDataHist(ds_name, item_title, arg_list, ds_object, 1) # import the datahist. Note workaround 'import' being a reserved word getattr(ws, 'import')(ds)
def fit(self): pdfs = RooArgList() obsvars = RooArgSet('set') for constraint in self.constraint.values(): pdfs.add(constraint.pdf_constraint) if hasattr(constraint, 'var_obs'): obsvars.add(constraint.var_obs) self.model = RooProdPdf('model', 'model', pdfs) self.data = RooDataSet('data', 'data', obsvars) self.data.add(obsvars) self.data.Print() self.fit_result = self.model.fitTo(self.data, ROOT.RooFit.PrintLevel(3), ROOT.RooFit.Optimize(1), ROOT.RooFit.Hesse(1), ROOT.RooFit.Minos(1), ROOT.RooFit.Strategy(2), ROOT.RooFit.Save(1))
def Hist2Pdf(self, hist, pdfName, ws, order = 0): if ws.pdf(pdfName): return ws.pdf(pdfName) try: obs = [ self.pars.varNames[x] for x in self.pars.var ] except AttributeError: obs = self.pars.var varList = RooArgList() for v in obs: varList.add(ws.var(v)) newHist = RooDataHist(pdfName + '_hist', pdfName + '_hist', varList, hist) thePdf = RooHistPdf(pdfName, pdfName, RooArgSet(varList), newHist, order) getattr(ws, 'import')(thePdf) return ws.pdf(pdfName)
def Hist2Pdf(self, hist, pdfName, ws, order=0): if ws.pdf(pdfName): return ws.pdf(pdfName) try: obs = [self.pars.varNames[x] for x in self.pars.var] except AttributeError: obs = self.pars.var varList = RooArgList() for v in obs: varList.add(ws.var(v)) newHist = RooDataHist(pdfName + '_hist', pdfName + '_hist', varList, hist) thePdf = RooHistPdf(pdfName, pdfName, RooArgSet(varList), newHist, order) getattr(ws, 'import')(thePdf) return ws.pdf(pdfName)
def getPdfInRegions(w,sample,region): """ Return the PDF in a region for a sample Should be moved to $HF/src/Utils.h -- FIXME @param sample The sample to find @param region The region to use """ if isinstance(sample,list): sampleArgList = RooArgList() sample_str="group" for s in sample: componentTmp = Util.GetComponent(w,s,region,True) sample_str=sample_str+"_"+s sampleArgList.add(componentTmp) pass pdfInRegion = RooAddition(sample_str,sample_str,sampleArgList) else: pdfInRegion = Util.GetComponent(w,sample,region) pass return pdfInRegion
def getSumAndError(list_comps, rfr, window=None): """ list_comps: list of tuples (obs, bwidth, comp) """ complist = RooArgList() widthlist = RooArgList() logging.debug("{}".format(list_comps)) for l in list_comps: if window: l[0].setRange("myrange", window[0], window[1]) inte = l[2].createIntegral(RooArgSet(l[0]), RF.Range("myrange")) else: inte = l[2].createIntegral(RooArgSet(l[0])) complist.add(inte) widthlist.add(RF.RooConst(l[1])) roosum = RooAddition("sum", "sum", complist, widthlist) val = roosum.getVal() if rfr is not None: error = ROOT.RU.getPropagatedError(roosum, rfr) else: error = -1 return [val, error]
def performFitInLeptonAbsEta(data_histogram, signal_histogram, bkg1_histogram, bkg2_histogram): N_Data = data_histogram.Integral() N_signal = signal_histogram.Integral() N_bkg1 = bkg1_histogram.Integral() N_bkg2 = bkg2_histogram.Integral() leptonAbsEta = RooRealVar("leptonAbsEta", "leptonAbsEta", 0., 3.) variables = RooArgList() variables.add(leptonAbsEta) variable_set = RooArgSet() variable_set.add(leptonAbsEta) lowerBound = 0 upperBound = N_Data*2 data_RooDataHist = RooDataHist("data", "dataset with leptonAbsEta", variables, data_histogram) signal_RooDataHist = RooDataHist("rh_signal", "signal", variables, signal_histogram); bkg1_RooDataHist = RooDataHist("rh_bkg1", "bkg1", variables, bkg1_histogram); bkg2_RooDataHist = RooDataHist("rh_bkg2", "bkg2", variables, bkg2_histogram); signal_RooHistPdf = RooHistPdf("pdf_signal", "Signal PDF", variable_set, signal_RooDataHist, 0) signal_RooHistPdf = RooHistPdf("pdf_signal", "Signal PDF", variable_set, signal_RooDataHist, 0)
def get_roofit_model( histograms, fit_boundaries, name = 'model' ): data_label = 'data' samples = sorted( histograms.keys() ) samples.remove( data_label ) roofit_histograms = {} roofit_pdfs = {} roofit_variables = {} variables = RooArgList() variable_set = RooArgSet() fit_variable = RooRealVar( name , name, fit_boundaries[0], fit_boundaries[1] ) variables.add( fit_variable ) variable_set.add( fit_variable ) roofit_histograms[data_label] = RooDataHist( data_label, data_label, variables, histograms[data_label] ) pdf_arglist = RooArgList() variable_arglist = RooArgList() N_total = histograms[data_label].Integral() * 2 N_min = 0 for sample in samples: roofit_histogram = RooDataHist( sample, sample, variables, histograms[sample] ) roofit_histograms[sample] = roofit_histogram roofit_pdf = RooHistPdf ( 'pdf' + sample, 'pdf' + sample, variable_set, roofit_histogram, 0 ) roofit_pdfs[sample] = roofit_pdf roofit_variable = RooRealVar( sample, "number of " + sample + " events", histograms[sample].Integral(), N_min, N_total, "event" ) roofit_variables[sample] = roofit_variable pdf_arglist.add( roofit_pdf ) variable_arglist.add( roofit_variable ) model = RooAddPdf( name, name, pdf_arglist, variable_arglist ) return model, roofit_histograms, fit_variable
def __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 _make_underlying_model(self): self.pdfs = {} self.yields = {} # yields are plain floats self.ryields = {} # keep track of roofit objects for memory management h = self._histos[0] nbins = h.GetXaxis().GetNbins() xmin = h.GetXaxis().GetXmin() xmax = h.GetXaxis().GetXmax() self.xvar = RooRealVar("x", "x", xmin, xmax) self.xvar.setBins(nbins) self.pdfs = {} self.hists = [] pdfs = RooArgList() yields = RooArgList() for histo in self._histos: if histo.Integral() == 0: continue compname = histo.GetName() hist = RooDataHist(compname, compname, RooArgList(self.xvar), histo) SetOwnership(hist, False) # self.hists.append(hist) pdf = RooHistPdf(compname, compname, RooArgSet(self.xvar), hist) self.pdfs[compname] = pdf # self.pdfs[compname].Print() pdfs.add(pdf) nevts = histo.Integral() uncertainty = self._uncertainty nmin = min(0, nevts * (1 - uncertainty)) nmax = nevts * (1 + uncertainty) theyield = RooRealVar('n{}'.format(compname), 'n{}'.format(compname), nevts, nmin, nmax) self.ryields[compname] = theyield self.yields[compname] = nevts yields.add(theyield) self.underlying_model = RooAddPdf('model', 'model', pdfs, yields)
def plotFitModel(model, frame, wksp, myconfigfile, log) : if debug : model.Print('t') frame.Print('v') dataset = w.data(dataSetToPlot) # plot model itself fr = model.plotOn(frame, RooFit.LineColor(kBlue+3),RooFit.Name("FullPdf")) var = [] tacc_list = RooArgList() numKnots = myconfigfile["Acceptance"]["knots"].__len__() for i in range(0,numKnots+1): varName = "var%d"%(int(i+1)) var.append(wksp.var(varName)) print "[INFO] Load %s with value %0.3lf"%(var[i].GetName(),var[i].getValV()) tacc_list.add(var[i]) varAdd = RooAddition(wksp.obj("var%d"%(numKnots+2))) #varAdd = RooRealVar(wksp.obj("var%d"%(numKnots+2))) print "[INFO] Load %s with value %0.3lf"%(varAdd.GetName(),varAdd.getValV()) tacc_list.add(varAdd) #len = var.__len__() #tacc_list.add(var[len]) spl = RooCubicSplineFun("splinePdf", "splinePdf", time, "splineBinning", tacc_list) if log: rel = 200 else: rel = 1000 rel = 40 fr = spl.plotOn(frame, RooFit.LineColor(kRed), RooFit.Normalization(rel, RooAbsReal.Relative),RooFit.Name("sPline")) fr = model.plotOn(frame, RooFit.LineColor(kBlue+3), RooFit.Name("FullPdf"))
def fit(self): fit_variable = RooRealVar("fit_variable", "fit_variable", self.fit_boundaries[0], self.fit_boundaries[1]) fit_variable.setBins(self.histograms[self.data_label].nbins()) variables = RooArgList() variables.add(fit_variable) variable_set = RooArgSet() variable_set.add(fit_variable) roofit_histograms = {} roofit_pdfs = {} roofit_variables = {} N_min = 0.0 N_max = self.normalisation[self.data_label] * 2.0 pdf_arglist = RooArgList() variable_arglist = RooArgList() roofit_histograms[self.data_label] = RooDataHist( self.data_label, self.data_label, variables, self.histograms[self.data_label] ) for sample in self.samples: roofit_histogram = RooDataHist(sample, sample, variables, self.histograms[sample]) roofit_histograms[sample] = roofit_histogram roofit_pdf = RooHistPdf("pdf" + sample, "pdf" + sample, variable_set, roofit_histogram) roofit_pdfs[sample] = roofit_pdf roofit_variable = RooRealVar(sample, sample + " events", self.normalisation[sample], N_min, N_max) roofit_variables[sample] = roofit_variable pdf_arglist.add(roofit_pdf) variable_arglist.add(roofit_variable) model = RooAddPdf("model", "sum of all known", pdf_arglist, variable_arglist) use_model = model if self.constraints: arg_set = RooArgSet(model) constraints = self.get_fit_normalisation_constraints(model, roofit_variables) for constraint in constraints: arg_set.add(constraint) model_with_constraints = RooProdPdf( "model_with_constraints", "model with gaussian constraints", arg_set, RooLinkedList() ) use_model = model_with_constraints if self.method == "TMinuit": # WARNING: number of cores changes the results!!! self.saved_result = use_model.fitTo( roofit_histograms[self.data_label], RooFit.Minimizer("Minuit2", "Migrad"), RooFit.NumCPU(1), RooFit.Extended(), RooFit.Save(), ) results = {} for sample in self.samples: results[sample] = (roofit_variables[sample].getVal(), roofit_variables[sample].getError()) self.results = results
def createMorph(obs, nuis_var, norm, up, down): pdf_list = RooArgList() pdf_list.add(down) pdf_list.add(up) pdf_list.add(norm) # nominal pdf nref_points = std.vector('double')() nref_points.push_back(-1) nref_points.push_back(1) nnuis_points = std.vector('int')() nnuis_points.push_back(2) par_list = RooArgList() par_list.add(nuis_var) morph = ROOT.RooStarMomentMorph("morph", "morph", par_list, obs, pdf_list, nnuis_points, nref_points, ROOT.RooStarMomentMorph.Linear) return morph
def getBinByBinErrorBand(mc_comps, observables, binWidths, rfr, weights=None): if rfr is None: return None bins = [] binning = observables[0].getBinning() stepsize = binning.averageBinWidth() low = binning.lowBound() high = binning.highBound() real_weights = RooArgList() if weights is not None: for bw, w in zip(binWidths, weights): real_weights.add(RF.RooConst(bw.getVal() * w)) else: for bw in binWidths: real_weights.add(RF.RooConst(bw.getVal())) m = low while m < high - 1e-6: rname = "bin" + str(m) intes = RooArgList() for obs, mc in zip(observables, mc_comps): intes.add(mc.createIntegral(RooArgSet(obs), RF.Range(rname))) totbin = RooAddition("sumbin", "sumbin", intes, real_weights) val = totbin.getVal() err = ROOT.RU.getPropagatedError(totbin, rfr) bins.append((val, err)) logging.debug("Found error of {}".format(err)) m += stepsize yvals = [] xvals = [] for i, b in enumerate(bins): yvals.extend([b[0] + b[1], b[0] + b[1]]) xvals.extend([binning.binLow(i), binning.binLow(i)]) xvals.append(high) xvals = xvals[1:] xvals.extend(reversed(xvals)) for b in reversed(bins): yvals.extend([b[0] - b[1], b[0] - b[1]]) # # FIXME JWH # for x,y in zip(xvals,yvals): # print "(x,y) = ({},{})".format(x,y) yvals_a = array('d', yvals) xvals_a = array('d', xvals) curve = TGraph(len(xvals), xvals_a, yvals_a) return curve
pyroot_logon.cmsPrelim(c4, fitterPars.intLumi/1000) c4.Print('H{2}_Mjj_{0}_{1}jets_Pull.pdf'.format(modeString, opts.Nj, opts.mH)) c4.Print('H{2}_Mjj_{0}_{1}jets_Pull.png'.format(modeString, opts.Nj, opts.mH)) if (TMath.Prob(chi2Raw, ndf2) < 0.05): print '**DANGER** The fit probability is low **DANGER**' if opts.debug: assert(False) #assert(False) mass.setRange('signal', fitterPars.minTrunc, fitterPars.maxTrunc) #yields = theFitter.makeFitter().coefList() finalPars = fr.floatParsFinal() yields = RooArgList(finalPars) yields.add(fr.constPars()) sigInt = theFitter.makeFitter().createIntegral(iset,iset,'signal') sigFullInt = theFitter.makeFitter().createIntegral(iset,iset) print "allBkg","sigInt",sigInt.getVal(),"fullInt",sigFullInt.getVal(),\ "ratio",sigInt.getVal()/sigFullInt.getVal() dibosonInt = theFitter.makeDibosonPdf().createIntegral(iset,iset,'signal') dibosonFullInt = theFitter.makeDibosonPdf().createIntegral(iset,iset) WpJPdf = theFitter.makeWpJPdf() WpJInt = WpJPdf.createIntegral(iset, iset, 'signal') WpJFullInt = WpJPdf.createIntegral(iset, iset) #WpJPdf.Print("v") print "WpJ","sigInt",WpJInt.getVal(),"fullInt",WpJFullInt.getVal(),\ "ratio",WpJInt.getVal()/WpJFullInt.getVal() ttbarInt = theFitter.makettbarPdf().createIntegral(iset, iset, 'signal') ttbarFullInt = theFitter.makettbarPdf().createIntegral(iset, iset) SingleTopInt = theFitter.makeSingleTopPdf().createIntegral(iset, iset, 'signal')
def fit_gau2_che(var, dataset, title='', print_pars=False, test=False, mean_=None, sigma_=None, sigma1_=None, sigmaFraction_=None): # define background c0 = RooRealVar('c0', 'constant', 0.1, -1, 1) c1 = RooRealVar('c1', 'linear', 0.6, -1, 1) c2 = RooRealVar('c2', 'quadratic', 0.1, -1, 1) c3 = RooRealVar('c3', 'c3', 0.1, -1, 1) bkg = RooChebychev('bkg', 'background pdf', var, RooArgList(c0, c1, c2, c3)) # define signal val = 5.28 dmean = 0.05 valL = val - dmean valR = val + dmean if mean_ is None: mean = RooRealVar("mean", "mean", val, valL, valR) else: mean = RooRealVar("mean", "mean", mean_) val = 0.05 dmean = 0.02 valL = val - dmean valR = val + dmean if sigma_ is None: sigma = RooRealVar('sigma', 'sigma', val, valL, valR) else: sigma = RooRealVar('sigma', 'sigma', sigma_) if sigma1_ is None: sigma1 = RooRealVar('sigma1', 'sigma1', val, valL, valR) else: sigma1 = RooRealVar('sigma1', 'sigma1', sigma1_) peakGaus = RooGaussian("peakGaus", "peakGaus", var, mean, sigma) peakGaus1 = RooGaussian("peakGaus1", "peakGaus1", var, mean, sigma1) if sigmaFraction_ is None: sigmaFraction = RooRealVar("sigmaFraction", "Sigma Fraction", 0.5, 0., 1.) else: sigmaFraction = RooRealVar("sigmaFraction", "Sigma Fraction", sigmaFraction_) glist = RooArgList(peakGaus, peakGaus1) peakG = RooAddPdf("peakG", "peakG", glist, RooArgList(sigmaFraction)) listPeak = RooArgList("listPeak") listPeak.add(peakG) listPeak.add(bkg) fbkg = 0.45 nEntries = dataset.numEntries() val = (1 - fbkg) * nEntries listArea = RooArgList("listArea") areaPeak = RooRealVar("areaPeak", "areaPeak", val, 0., nEntries) listArea.add(areaPeak) nBkg = fbkg * nEntries areaBkg = RooRealVar("areaBkg", "areaBkg", nBkg, 0., nEntries) listArea.add(areaBkg) model = RooAddPdf("model", "fit model", listPeak, listArea) if not test: fitres = model.fitTo(dataset, RooFit.Extended(kTRUE), RooFit.Minos(kTRUE), RooFit.Save(kTRUE)) nbins = 35 frame = var.frame(nbins) frame.GetXaxis().SetTitle("B^{0} mass (GeV/c^{2})") frame.GetXaxis().CenterTitle() frame.GetYaxis().CenterTitle() frame.SetTitle(title) mk_size = RooFit.MarkerSize(0.3) mk_style = RooFit.MarkerStyle(kFullCircle) dataset.plotOn(frame, mk_size, mk_style) model.plotOn(frame) as_bkg = RooArgSet(bkg) cp_bkg = RooFit.Components(as_bkg) line_style = RooFit.LineStyle(kDashed) model.plotOn(frame, cp_bkg, line_style) if print_pars: fmt = RooFit.Format('NEU') lyt = RooFit.Layout(0.65, 0.95, 0.92) param = model.paramOn(frame, fmt, lyt) param.getAttText().SetTextSize(0.02) param.getAttText().SetTextFont(60) frame.Draw() pars = [ areaBkg, areaPeak, c0, c1, c2, c3, mean, sigma, sigma1, sigmaFraction ] return pars
acceptance.SetMinimum(0.5) acceptance.SetMaximum(1.5) # (1) DsK, (2) DsPi accfns = [] accfnerrs = [] xbincs = numpy.linspace(tfloor + 0.05, tceil - 0.05, nbins) for mode, fitresult in enumerate(fitresults): parlist = fitresult.floatParsFinal() cmatrix = fitresult.covarianceMatrix() veclist = RooArgList() for i in range(parlist.getSize()): name = "%s_%d" % (parlist[i].GetName(), i) veclist.add(parlist[i].clone(name)) multigauss = RooMultiVarGaussian("multigauss", "multigauss", veclist, parlist, cmatrix) dset = multigauss.generate(RooArgSet(veclist), 1000) fns = [] for entry in range(dset.numEntries()): vecset = dset.get(entry) veclist = RooArgList(vecset) for pars in range(veclist.getSize()): acceptance.SetParameter(pars, veclist[pars].getVal()) fns += [acceptance.Clone("%s_%d" % (acceptance.GetName(), entry))] avgfn = BinnedAvgFunction(fns, xbincs) avgfn.calculate() accfns += [avgfn.get_avg_fn()]
def getComponents(cfg, w): """ Fetch all components (data, MC pdfs...) for a given workspace Organize all of this in a map """ iscomb = cfg.dataname == 'combData' # SKC mc = w.obj("ModelConfig") data = w.data(cfg.dataname) simPdf = w.pdf('combPdf' if iscomb else "simPdf") channelCat = simPdf.indexCat() chanName = channelCat.GetName() comps = {} for tt in categories(channelCat): ttname = tt.GetName() pdftmp = simPdf.getPdf(ttname) datatmp = data.reduce("{0}=={1}::{2}".format(chanName, chanName, ttname)) obs = pdftmp.getObservables(mc.GetObservables()).first() obs_set = RooArgSet(obs) sure, yup = ttname_mod(cfg, ttname) binWidth = pdftmp.getVariables().find("binWidth_obs_x_{0}_0{1}".format( ttname, sure + yup)) if not binWidth: it = pdftmp.getVariables().createIterator() print('---------ttname is-------{}'.format(ttname)) var = it.Next() while var: if 'binWidth' in var.GetName(): print(var.GetName()) var = it.Next() logging.debug(" Bin Width : {}".format(binWidth.getVal())) comps[ttname] = [obs, binWidth, datatmp, {}, pdftmp] binning = obs.getBinning() stepsize = binning.averageBinWidth() low = binning.lowBound() high = binning.highBound() m = low while m < (high - 1e-6): obs.setRange("bin" + str(m), m, m + stepsize) m += stepsize bkgList = RooArgList() sigList = RooArgList() totList = RooArgList() for c in components(pdftmp, ttname, iscomb): compname = c.GetName() has_mass, res = cfg.is_signal(compname) if has_mass: sigList.add(c) else: bkgList.add(c) totList.add(c) comps[ttname][3][compname] = c sigSum = RooAddition("Signal", "sig_Sum", sigList) comps[ttname][3]["Signal"] = sigSum bkgSum = RooAddition("Bkg", "bkg_Sum", bkgList) comps[ttname][3]["Bkg"] = bkgSum totSum = RooAddition("MC", "tot_Sum", totList) comps[ttname][3]["MC"] = totSum try: cfg.combineComps(comps) except AttributeError: continue return comps
def getFrame(cat, obsData, simPdf, mc, fit_res, error_band_strategy=1, compute_yields=False): """ Build a frame with the different fit components and their uncertainties Parameters ---------- cat : RooCategory Category of the simultaneous PDF we are interested in obsData: RooDataHist object (either real data or asimov or PE) simPdf : RooSimultaneous PDF mc : ModelConfig object fit_res: RooFitResult Result of the fit (covariance matrix, NLL value, ...) error_band_strategy : True/False True: Use the linear approximation to extract the error band False: Use a sampling method See http://root.cern.ch/root/html/RooAbsReal.html#RooAbsReal:plotOnWithErrorBand verbose: True/False TODO: implement a more generic way to retrieve the binning. Currently it has to be put in the workspace with the name binWidth_obs_x_{channel}_0 """ hlist = [] if compute_yields: yields = {} # --> Get the total (signal+bkg) model pdf pdftmp = simPdf.getPdf(cat.GetName()) if not pdftmp: raise RuntimeError('Could not retrieve the total pdf ') # --> Get the list of observables obstmp = pdftmp.getObservables(mc.GetObservables()) if not obstmp: raise RuntimeError('Could not retrieve the list of observable') # --> Get the first (and only) observable (mmc mass for cut based) obs = obstmp.first() log.info('Observable: {0}'.format(obs.GetName())) # --> Get the RooDataHist of the given category datatmp = obsData.reduce("{0}=={1}::{2}".format( simPdf.indexCat().GetName(), simPdf.indexCat().GetName(), cat.GetName())) datatmp.__class__ = ROOT.RooAbsData # --> Ugly fix !!! # --> Get the binning width of the category (stored as a workspace variable) binWidth = pdftmp.getVariables().find('binWidth_obs_x_{0}_0'.format( cat.GetName())) if not binWidth: raise RuntimeError('Could not retrieve the binWidth') # --> parameter of interest (mu=sigma/sigma_sm) poi = mc.GetParametersOfInterest().first() poi_fitted_val = poi.getVal() log.info('POI: {0} = {1} +/- {2}'.format(poi.GetName(), poi.getVal(), poi.getError())) # --> Create the data histogram hist_data = asrootpy(datatmp.createHistogram("hdata_" + cat.GetName(), obs)) hist_data.name = "hdata_{0}".format(cat.GetName()) hist_data.title = "" hlist.append(hist_data) #--> compute the data yields if compute_yields: Yield_data = hist_data.Integral() yields['Data'] = (Yield_data, 0) # --> Create the frame structure from the observable frame = obs.frame() frame.SetName(cat.GetName()) datatmp.plotOn(frame, ROOT.RooFit.DataError(ROOT.RooAbsData.Poisson), ROOT.RooFit.Name("Data"), ROOT.RooFit.MarkerSize(1)) # --> Create the signal histogram template hist_sig = hist_data.Clone('h_TotalSignal_{0}'.format(cat.GetName())) hist_sig.Reset() signal_comps = RooArgList() bkg_comps = RooArgList() # --> get the list of components (hadhad HSG4: QCD,Other,Ztautau, Signal_Z, Signal_W, Signal_gg, Signal_VBF) # --> and iterate over pdfmodel = pdftmp.getComponents().find(cat.GetName() + '_model') funcListIter = pdfmodel.funcList().iterator() while True: comp = funcListIter.Next() if not comp: break name = comp.GetName().replace('L_x_', '').split('_')[0] log.info('Scan component {0}'.format(comp.GetName())) hist_comp = asrootpy( comp.createHistogram(cat.GetName() + "_" + comp.GetName(), obs, ROOT.RooFit.Extended(False))) hist_comp.name = 'h_{0}_{1}'.format(name, cat.GetName()) hist_comp.title = '' hlist.append(hist_comp) if 'Signal' in comp.GetName(): signal_comps.add(comp) hist_sig.Add(hist_comp) else: bkg_comps.add(comp) Integral_comp = comp.createIntegral(RooArgSet(obs)) Yield_comp = Integral_comp.getVal() * binWidth.getVal() log.info('Integral = {0}'.format(Yield_comp)) # if Yield_comp==0: # raise RuntimeError('Yield integral is wrong !!') # --> Add the components to the frame but in an invisible way pdfmodel.plotOn( frame, ROOT.RooFit.Components(comp.GetName()), ROOT.RooFit.Normalization(Yield_comp, ROOT.RooAbsReal.NumEvent), ROOT.RooFit.Name("NoStacked_" + comp.GetName()), ROOT.RooFit.Invisible()) if fit_res: # --> Add the components uncertainty band comp.plotOn( frame, ROOT.RooFit.Normalization(1, ROOT.RooAbsReal.RelativeExpected), ROOT.RooFit.VisualizeError(fit_res, 1, error_band_strategy), ROOT.RooFit.Name("FitError_AfterFit_" + comp.GetName()), ROOT.RooFit.Invisible()) if compute_yields: if Yield_comp == 0: Yield_comp_err = 0. else: Yield_comp_err = Integral_comp.getPropagatedError( fit_res) * binWidth.getVal() yields[comp.GetName()] = (Yield_comp, Yield_comp_err) hlist.append(hist_sig) # --> total signal yields if compute_yields: signal_tot_comp = RooAddition('pdf_sum_sig', 'pdf_sum_sig', signal_comps) Integral_signal = signal_tot_comp.createIntegral(RooArgSet(obs)) yields_sig_tot = Integral_signal.getVal() * binWidth.getVal() yields_sig_tot_err = Integral_signal.getPropagatedError( fit_res) * binWidth.getVal() yields['TotalSignal'] = (yields_sig_tot, yields_sig_tot_err) bkg_tot_comp = RooAddition('pdf_sum_bkg', 'pdf_sum_bkg', bkg_comps) Integral_bkg = bkg_tot_comp.createIntegral(RooArgSet(obs)) yields_bkg_tot = Integral_bkg.getVal() * binWidth.getVal() yields_bkg_tot_err = Integral_bkg.getPropagatedError( fit_res) * binWidth.getVal() yields['bkg'] = (yields_bkg_tot, yields_bkg_tot_err) log.info('Bkg Total Yield: {0}'.format(yields_bkg_tot)) # --> bkg+signal PDF central value and error Integral_total = pdfmodel.createIntegral(RooArgSet(obs)) Yield_total = Integral_total.getVal() * binWidth.getVal() log.info('Postfit Total Yield: {0}'.format(Yield_total)) hist_bkg_plus_sig = asrootpy( pdfmodel.createHistogram("hbkg_plus_sig_" + cat.GetName(), obs, ROOT.RooFit.Extended(False))) hist_bkg_plus_sig.name = 'hbkg_plus_sig_' + cat.GetName() hist_bkg_plus_sig.title = '' hist_bkg_plus_sig.Scale(Yield_total) hlist.append(hist_bkg_plus_sig) # --> Add the components to the frame but in an invisible way pdftmp.plotOn( frame, ROOT.RooFit.Normalization(Yield_total, ROOT.RooAbsReal.NumEvent), ROOT.RooFit.Name("Bkg_plus_sig")) if fit_res: pdftmp.plotOn( frame, ROOT.RooFit.VisualizeError(fit_res, 1, error_band_strategy), ROOT.RooFit.Normalization(1, ROOT.RooAbsReal.RelativeExpected), ROOT.RooFit.Name("FitError_AfterFit"), ROOT.RooFit.FillColor(ROOT.kOrange), ROOT.RooFit.LineWidth(2), ROOT.RooFit.LineColor(ROOT.kBlue)) # --> bkg only PDF central value and error poi.setVal(0.) Integral_bkg_total = pdfmodel.createIntegral(RooArgSet(obs)) Yield_bkg_total = Integral_bkg_total.getVal() * binWidth.getVal() hist_bkg = pdfmodel.createHistogram("hbkg_" + cat.GetName(), obs, ROOT.RooFit.Extended(False)) hist_bkg.Scale(Yield_bkg_total) hist_bkg.SetName("hbkg_" + cat.GetName()) hist_bkg.SetTitle("") hlist.append(hist_bkg) pdftmp.plotOn( frame, ROOT.RooFit.Normalization(Yield_bkg_total, ROOT.RooAbsReal.NumEvent), ROOT.RooFit.Name("Bkg"), ROOT.RooFit.LineStyle(ROOT.kDashed)) if fit_res: pdftmp.plotOn( frame, ROOT.RooFit.VisualizeError(fit_res, 1, error_band_strategy), ROOT.RooFit.Normalization(1, ROOT.RooAbsReal.RelativeExpected), ROOT.RooFit.Name("FitError_AfterFit_Mu0"), ROOT.RooFit.FillColor(ROOT.kOrange), ROOT.RooFit.LineWidth(2), ROOT.RooFit.LineColor(ROOT.kBlue)) #if compute_yields: # Yield_bkg_total_err = Integral_bkg_total.getPropagatedError(fit_res)*binWidth.getVal() # yields['bkg'] = (Yield_bkg_total, Yield_bkg_total_err) poi.setVal(poi_fitted_val) if compute_yields: return frame, hlist, yields else: return frame, hlist
def buildMassAndLifetimePDF(ws): #define mass shape ws.factory('RooCBShape::massCBShape(JpsiMass,CBmass[3.1,3.05,3.15],CBsigma[0.02,0.0001,1],CBalpha[1,.0001,5],CBn[10,.0001,50])') #ws.factory('RooGaussian::massCBShape(JpsiMass,CBmass[3.1,3.05,3.15],CBsigma[0.02,0.0001,1])') ws.factory('RooExponential::bkgMassShape(JpsiMass,bkgLambda[0,-5,5])') #ws.factory('RooChebychev::bkgMassShape(JpsiMass,{p0[1,-10,10],p1[1,-10,10],p2[1,-10,10]})') #lifetime ws.factory('RooGaussModel::promptLifetimeRaw(Jpsict,promptMean[0,-1,1],ctResolution[1,.001,5],1,JpsictErr)') ws.pdf('promptLifetimeRaw').advertiseFlatScaleFactorIntegral(True) ws.factory('RooDecay::nonPromptSSDRaw(Jpsict,nonPromptTau[.3,.01,3],promptLifetimeRaw,RooDecay::SingleSided)') ws.factory('RooDecay::backgroundSSDRawL(Jpsict,bkgTauSSDL[.3,0,3],promptLifetimeRaw,RooDecay::SingleSided)') #ws.factory('RooDecay::backgroundFDRaw(Jpsict,bkgTauFD[.3,.0001,3],promptLifetimeRaw,RooDecay::Flipped)') ws.factory('RooDecay::backgroundDSDRawL(Jpsict,bkgTauDSDL[.3,0,3],promptLifetimeRaw,RooDecay::DoubleSided)') ws.factory('SUM::backgroundRawL(fBkgSSDL[.5,0,1]*backgroundSSDRawL,backgroundDSDRawL)') ws.factory('RooDecay::backgroundSSDRawR(Jpsict,bkgTauSSDR[.3,0,3],promptLifetimeRaw,RooDecay::SingleSided)') #ws.factory('RooDecay::backgroundFDRaw(Jpsict,bkgTauFD[.3,.0001,3],promptLifetimeRaw,RooDecay::Flipped)') ws.factory('RooDecay::backgroundDSDRawR(Jpsict,bkgTauDSDR[.3,0,3],promptLifetimeRaw,RooDecay::DoubleSided)') ws.factory('SUM::backgroundRawR(fBkgSSDR[.5,0,1]*backgroundSSDRawR,backgroundDSDRawR)') ws.factory('SUM::backgroundRaw(fBkgLR[.5]*backgroundRawL,backgroundDSDRawR)') ws.factory('PROD::promptRawMass(massCBShape)') #,promptLifetimeRaw|JpsictErr ws.factory('PROD::nonpromptRawMass(massCBShape)') #,nonPromptSSDRaw|JpsictErr ws.factory('PROD::backgroundRawMass(bkgMassShape)') #,backgroundDSDRaw|JpsictErr ws.factory('PROD::promptRawCTau(promptLifetimeRaw|JpsictErr)') ws.factory('PROD::nonpromptRawCTau(nonPromptSSDRaw|JpsictErr)') ws.factory('PROD::backgroundRawCTauL(backgroundRawL|JpsictErr)') ws.factory('PROD::backgroundRawCTauR(backgroundRawR|JpsictErr)') ws.factory('PROD::backgroundRawCTau(backgroundRaw|JpsictErr)') #extended pdfs ws.factory('RooExtendPdf::promptExtMass(promptRawMass,sum::nPrompt(nPromptSignal[1000,0,1000000]))') #,nPromptL[1000,0,1000000],nPromptR[1000,0,1000000] ws.factory('RooExtendPdf::nonpromptExtMass(nonpromptRawMass,sum::nNonPrompt(nNonPromptSignal[500,0,1000000]))') #[500,0,1000000],,nNonPromptL[500,0,1000000],nNonPromptR[500,0,1000000] ws.factory('RooExtendPdf::backgroundExtMass(backgroundRawMass,sum::nBackground(nBackgroundSignal[100,0,1000000],nBackgroundL[100,0,1000000],nBackgroundR[100,0,1000000]))') # ws.factory('RooExtendPdf::promptExtCTauL(promptRawCTau,0)') #nPromptL[1,0,1000000] ws.factory('RooExtendPdf::promptExtCTauR(promptRawCTau,0)')#nPromptR[1,0,1000000] ws.factory('RooExtendPdf::nonpromptExtCTauL(nonpromptRawCTau,0)') #nNonPromptL[1,0,1000000] ws.factory('RooExtendPdf::nonpromptExtCTauR(nonpromptRawCTau,0)') #nNonPromptR[1,0,1000000] ws.factory('RooExtendPdf::backgroundExtCTauL(backgroundRawCTauL,nBackgroundL)') ws.factory('RooExtendPdf::backgroundExtCTauR(backgroundRawCTauR,nBackgroundR)') ws.factory('RooExtendPdf::promptExtCTau(promptRawCTau,nPromptSignal)') ws.factory('RooExtendPdf::nonpromptExtCTau(nonpromptRawCTau,nNonPromptSignal)') ws.factory('RooExtendPdf::backgroundExtCTau(backgroundRawCTau,nBackgroundSignal)') #final AddPdfs promptMArgList = RooArgList(ws.pdf('promptExtMass')) nonPromptMArgList = RooArgList(ws.pdf('promptExtMass'), ws.pdf('nonpromptExtMass')) if options.doNonPrompt: promptMArgList.add(ws.pdf('nonpromptExtMass')) if options.doBackground: promptMArgList.add(ws.pdf('backgroundExtMass')) nonPromptMArgList.add(ws.pdf('backgroundExtMass')) promptM = RooAddPdf('promptMass','prompt',promptMArgList) nonpromptM = RooAddPdf('nonpromptMass','nonprompt',nonPromptMArgList) backgroundM = RooAddPdf('backgroundMass','background',RooArgList(ws.pdf('promptExtMass'), ws.pdf('nonpromptExtMass'), ws.pdf('backgroundExtMass'))) promptCTArgList = RooArgList(ws.pdf('promptExtCTau')) nonPromptCTArgList = RooArgList(ws.pdf('promptExtCTau'), ws.pdf('nonpromptExtCTau')) if options.doNonPrompt: promptCTArgList.add(ws.pdf('nonpromptExtCTau')) if options.doBackground: promptCTArgList.add(ws.pdf('backgroundExtCTau')) nonPromptCTArgList.add(ws.pdf('backgroundExtCTau')) promptCT = RooAddPdf('promptCTau','prompt',promptCTArgList) nonpromptCT = RooAddPdf('nonpromptCTau','nonprompt',nonPromptCTArgList) backgroundCT = RooAddPdf('backgroundCTau','background',RooArgList(ws.pdf('promptExtCTau'), ws.pdf('nonpromptExtCTau'), ws.pdf('backgroundExtCTau'))) #playing around with signal in left sideband backgroundCTL = RooAddPdf('backgroundCTauL','background',RooArgList(ws.pdf('promptExtCTauL'), ws.pdf('nonpromptExtCTauL'), ws.pdf('backgroundExtCTauL'))) backgroundCTR = RooAddPdf('backgroundCTauR','background',RooArgList(ws.pdf('promptExtCTauR'), ws.pdf('nonpromptExtCTauR'), ws.pdf('backgroundExtCTauR'))) getattr(ws,'import')(promptM) getattr(ws,'import')(nonpromptM) getattr(ws,'import')(backgroundM) getattr(ws,'import')(promptCT) getattr(ws,'import')(nonpromptCT) getattr(ws,'import')(backgroundCT) getattr(ws,'import')(backgroundCTL) getattr(ws,'import')(backgroundCTR) massConfig = 'SIMUL::MPdf(ctauRegion,' ctConfig = 'SIMUL::LPdf(massRegion,' if options.doPrompt: massConfig += 'prompt=promptMass,' ctConfig += 'signal=promptCTau,' if options.doNonPrompt: massConfig += 'nonPrompt=promptMass' if options.doBackground: ctConfig += 'leftMassSideBand=backgroundCTauL,rightMassSideBand=backgroundCTauR' massConfig += ')' ctConfig += ')' #simultaneous ws.factory(massConfig) ws.factory(ctConfig)
def findOnePe(hist, ws, name='x', Npe = 1): fitPed(hist, ws, name) x = ws.var(name) ped = ws.pdf('ped') pedWidth = ws.var('pedWidth') pdfs = RooArgList(ped) pdfList = [] fped = RooRealVar('fped', 'f_{ped}', 0.8, 0., 1.) fractions = RooArgList(fped) fList = [] peList = [] peMean = RooRealVar('peMean', 'mean_{pe}', 6., 0., 20.) peWidth = RooRealVar('peWidth', 'width_{pe}', pedWidth.getVal(), 0., 10.) for i in range(0, Npe): pem = RooFormulaVar('pem{0}'.format(i+1), '@0+{0}*@1'.format(i+1), RooArgList(ws.var('pedMean'), peMean)) peList.append(pem) npepdf = RooGaussian('pe{0}pdf'.format(i+1), 'pe{0}pdf'.format(i+1), x, pem, pedWidth) pdfs.add(npepdf) pdfList.append(npepdf) fnpe = RooRealVar('fpe{0}'.format(i+1), 'fpe{0}'.format(i+1), 0.5, -0.1, 1.0) fractions.add(fnpe) fList.append(fnpe) #bgMean = RooRealVar("bgMean", "bgMean", 6.0, x.getMin(), x.getMax()) bgScale = RooRealVar("bgScale", "bgScale", 0.5, -1.0, Npe + 1.0) bgMean = RooFormulaVar("bgMean", "@1+@0*@2", RooArgList(peMean, ws.var('pedMean'), bgScale)) bgWidthL = RooRealVar("bgWidthL", "bgWidthL", pedWidth.getVal()*2, 0., 25.) bgWidthR = RooRealVar("bgWidthR", "bgWidthR", pedWidth.getVal()*7, 0., 25.) bgGauss = RooBifurGauss("bgGauss", "bgGauss", x, bgMean, bgWidthR, bgWidthR) if (Npe > 1): pdfs.add(bgGauss) else: fractions.remove(fractions.at(fractions.getSize()-1)) ## pem = RooFormulaVar('pem', '@0+@1', RooArgList(peMean, ws.var('pedMean'))) ## firstPe = RooGaussian('firstPe', 'firstPe', x, pem, peWidth) ## pdfs.Print("v") ## fractions.Print("v") pedPlusOne = RooAddPdf('pedPlusOne', 'pedPlusOne', pdfs, fractions, True) ## pedWidth = ped.GetParameter(2) ## pedMean = ped.GetParameter(1) ## pedA = ped.GetParameter(0) secondMax = hist.GetMaximumBin() + 1 goingDown = True maxVal = hist.GetBinContent(secondMax) foundMax = False while (not foundMax) and (secondMax < hist.GetNbinsX()): tmpVal = hist.GetBinContent(secondMax+1) if (tmpVal < maxVal): if not goingDown: foundMax = True else: goingDown = True maxVal = tmpVal secondMax += 1 elif (tmpVal > maxVal): goingDown = False maxVal = tmpVal secondMax += 1 else: maxVal = tmpVal secondMax += 1 secondMaxx = hist.GetBinCenter(secondMax) print 'found 2nd maximum in bin',secondMax,'value',secondMaxx ## peMean.setVal(secondMaxx) ## bgMean.setVal(secondMaxx*0.6) x.setRange('pedPlus_fit', x.getMin(), ws.var('pedMean').getVal()+pedWidth.getVal()*6.*(Npe+0)) pedPlusOne.fitTo(ws.data('ds'), RooFit.Minos(False), RooFit.Range('pedPlus_fit'), RooFit.PrintLevel(1)) getattr(ws, 'import')(pedPlusOne)
temp_tt.Rebin(20) temp_wj.Rebin(20) temp_zj.Rebin(20) temp_stop.Rebin(20) temp_qcd.Rebin(20) temp_qcd.Scale(800/temp_qcd.Integral()) temp_signal = temp_tt.Clone('signal') temp_signal.Add(temp_stop) #temp_tt.Scale(1/temp_tt.Integral()) #temp_wj.Scale(1/temp_wj.Integral()) #temp_zj.Scale(1/temp_zj.Integral()) #temp_stop.Scale(1/temp_stop.Integral()) #temp_qcd.Scale(1/temp_qcd.Integral()) leptonAbsEta = RooRealVar("leptonAbsEta", "leptonAbsEta", 0., 3.) vars = RooArgList() vars.add(leptonAbsEta) vars_set = RooArgSet() vars_set.add(leptonAbsEta) n_event_obs = h_m3_data.GetEntries(); lowerBound = -10 * sqrt(n_event_obs); upperBound = n_event_obs + 10 * sqrt(n_event_obs); n_init = n_event_obs / 2.; data = RooDataHist("data", "dataset with leptonAbsEta", vars, h_m3_data) rh_tt = RooDataHist("rh_tt", "tt", vars, temp_tt); rh_wj = RooDataHist("rh_wj", "wj", vars, temp_wj); rh_zj = RooDataHist("rh_zj", "zj", vars, temp_zj); rh_qcd = RooDataHist("rh_qcd", "qcd", vars, temp_qcd); rh_stop = RooDataHist("rh_stop", "singletop", vars, temp_stop); rh_signal = RooDataHist("rh_signal", "signal", vars, temp_signal); pdf_tt = RooHistPdf("pdf_tt", "Signal pdf", vars_set, rh_tt, 0);
def buildMassAndLifetimePDF(ws): #define mass shape ws.factory( 'RooCBShape::massCBShape(JpsiMass,CBmass[3.1,3.05,3.15],CBsigma[0.02,0.0001,1],CBalpha[1,.0001,5],CBn[10,.0001,50])' ) #ws.factory('RooGaussian::massCBShape(JpsiMass,CBmass[3.1,3.05,3.15],CBsigma[0.02,0.0001,1])') ws.factory('RooExponential::bkgMassShape(JpsiMass,bkgLambda[0,-5,5])') #ws.factory('RooChebychev::bkgMassShape(JpsiMass,{p0[1,-10,10],p1[1,-10,10],p2[1,-10,10]})') #lifetime ws.factory( 'RooGaussModel::promptLifetimeRaw(Jpsict,promptMean[0,-1,1],ctResolution[1,.001,5],1,JpsictErr)' ) ws.pdf('promptLifetimeRaw').advertiseFlatScaleFactorIntegral(True) ws.factory( 'RooDecay::nonPromptSSDRaw(Jpsict,nonPromptTau[.3,.01,3],promptLifetimeRaw,RooDecay::SingleSided)' ) ws.factory( 'RooDecay::backgroundSSDRawL(Jpsict,bkgTauSSDL[.3,0,3],promptLifetimeRaw,RooDecay::SingleSided)' ) #ws.factory('RooDecay::backgroundFDRaw(Jpsict,bkgTauFD[.3,.0001,3],promptLifetimeRaw,RooDecay::Flipped)') ws.factory( 'RooDecay::backgroundDSDRawL(Jpsict,bkgTauDSDL[.3,0,3],promptLifetimeRaw,RooDecay::DoubleSided)' ) ws.factory( 'SUM::backgroundRawL(fBkgSSDL[.5,0,1]*backgroundSSDRawL,backgroundDSDRawL)' ) ws.factory( 'RooDecay::backgroundSSDRawR(Jpsict,bkgTauSSDR[.3,0,3],promptLifetimeRaw,RooDecay::SingleSided)' ) #ws.factory('RooDecay::backgroundFDRaw(Jpsict,bkgTauFD[.3,.0001,3],promptLifetimeRaw,RooDecay::Flipped)') ws.factory( 'RooDecay::backgroundDSDRawR(Jpsict,bkgTauDSDR[.3,0,3],promptLifetimeRaw,RooDecay::DoubleSided)' ) ws.factory( 'SUM::backgroundRawR(fBkgSSDR[.5,0,1]*backgroundSSDRawR,backgroundDSDRawR)' ) ws.factory( 'SUM::backgroundRaw(fBkgLR[.5]*backgroundRawL,backgroundDSDRawR)') ws.factory( 'PROD::promptRawMass(massCBShape)') #,promptLifetimeRaw|JpsictErr ws.factory( 'PROD::nonpromptRawMass(massCBShape)') #,nonPromptSSDRaw|JpsictErr ws.factory( 'PROD::backgroundRawMass(bkgMassShape)') #,backgroundDSDRaw|JpsictErr ws.factory('PROD::promptRawCTau(promptLifetimeRaw|JpsictErr)') ws.factory('PROD::nonpromptRawCTau(nonPromptSSDRaw|JpsictErr)') ws.factory('PROD::backgroundRawCTauL(backgroundRawL|JpsictErr)') ws.factory('PROD::backgroundRawCTauR(backgroundRawR|JpsictErr)') ws.factory('PROD::backgroundRawCTau(backgroundRaw|JpsictErr)') #extended pdfs ws.factory( 'RooExtendPdf::promptExtMass(promptRawMass,sum::nPrompt(nPromptSignal[1000,0,1000000]))' ) #,nPromptL[1000,0,1000000],nPromptR[1000,0,1000000] ws.factory( 'RooExtendPdf::nonpromptExtMass(nonpromptRawMass,sum::nNonPrompt(nNonPromptSignal[500,0,1000000]))' ) #[500,0,1000000],,nNonPromptL[500,0,1000000],nNonPromptR[500,0,1000000] ws.factory( 'RooExtendPdf::backgroundExtMass(backgroundRawMass,sum::nBackground(nBackgroundSignal[100,0,1000000],nBackgroundL[100,0,1000000],nBackgroundR[100,0,1000000]))' ) # ws.factory('RooExtendPdf::promptExtCTauL(promptRawCTau,0)' ) #nPromptL[1,0,1000000] ws.factory('RooExtendPdf::promptExtCTauR(promptRawCTau,0)' ) #nPromptR[1,0,1000000] ws.factory('RooExtendPdf::nonpromptExtCTauL(nonpromptRawCTau,0)' ) #nNonPromptL[1,0,1000000] ws.factory('RooExtendPdf::nonpromptExtCTauR(nonpromptRawCTau,0)' ) #nNonPromptR[1,0,1000000] ws.factory( 'RooExtendPdf::backgroundExtCTauL(backgroundRawCTauL,nBackgroundL)') ws.factory( 'RooExtendPdf::backgroundExtCTauR(backgroundRawCTauR,nBackgroundR)') ws.factory('RooExtendPdf::promptExtCTau(promptRawCTau,nPromptSignal)') ws.factory( 'RooExtendPdf::nonpromptExtCTau(nonpromptRawCTau,nNonPromptSignal)') ws.factory( 'RooExtendPdf::backgroundExtCTau(backgroundRawCTau,nBackgroundSignal)') #final AddPdfs promptMArgList = RooArgList(ws.pdf('promptExtMass')) nonPromptMArgList = RooArgList(ws.pdf('promptExtMass'), ws.pdf('nonpromptExtMass')) if options.doNonPrompt: promptMArgList.add(ws.pdf('nonpromptExtMass')) if options.doBackground: promptMArgList.add(ws.pdf('backgroundExtMass')) nonPromptMArgList.add(ws.pdf('backgroundExtMass')) promptM = RooAddPdf('promptMass', 'prompt', promptMArgList) nonpromptM = RooAddPdf('nonpromptMass', 'nonprompt', nonPromptMArgList) backgroundM = RooAddPdf( 'backgroundMass', 'background', RooArgList(ws.pdf('promptExtMass'), ws.pdf('nonpromptExtMass'), ws.pdf('backgroundExtMass'))) promptCTArgList = RooArgList(ws.pdf('promptExtCTau')) nonPromptCTArgList = RooArgList(ws.pdf('promptExtCTau'), ws.pdf('nonpromptExtCTau')) if options.doNonPrompt: promptCTArgList.add(ws.pdf('nonpromptExtCTau')) if options.doBackground: promptCTArgList.add(ws.pdf('backgroundExtCTau')) nonPromptCTArgList.add(ws.pdf('backgroundExtCTau')) promptCT = RooAddPdf('promptCTau', 'prompt', promptCTArgList) nonpromptCT = RooAddPdf('nonpromptCTau', 'nonprompt', nonPromptCTArgList) backgroundCT = RooAddPdf( 'backgroundCTau', 'background', RooArgList(ws.pdf('promptExtCTau'), ws.pdf('nonpromptExtCTau'), ws.pdf('backgroundExtCTau'))) #playing around with signal in left sideband backgroundCTL = RooAddPdf( 'backgroundCTauL', 'background', RooArgList(ws.pdf('promptExtCTauL'), ws.pdf('nonpromptExtCTauL'), ws.pdf('backgroundExtCTauL'))) backgroundCTR = RooAddPdf( 'backgroundCTauR', 'background', RooArgList(ws.pdf('promptExtCTauR'), ws.pdf('nonpromptExtCTauR'), ws.pdf('backgroundExtCTauR'))) getattr(ws, 'import')(promptM) getattr(ws, 'import')(nonpromptM) getattr(ws, 'import')(backgroundM) getattr(ws, 'import')(promptCT) getattr(ws, 'import')(nonpromptCT) getattr(ws, 'import')(backgroundCT) getattr(ws, 'import')(backgroundCTL) getattr(ws, 'import')(backgroundCTR) massConfig = 'SIMUL::MPdf(ctauRegion,' ctConfig = 'SIMUL::LPdf(massRegion,' if options.doPrompt: massConfig += 'prompt=promptMass,' ctConfig += 'signal=promptCTau,' if options.doNonPrompt: massConfig += 'nonPrompt=promptMass' if options.doBackground: ctConfig += 'leftMassSideBand=backgroundCTauL,rightMassSideBand=backgroundCTauR' massConfig += ')' ctConfig += ')' #simultaneous ws.factory(massConfig) ws.factory(ctConfig)
RooFit.Normalization(hist1_events)) # Z = 175 GeV data_hist2 = RooDataHist('dhist2', 'dhist2', RooArgList(x), hist2) pdf2 = RooHistPdf('phist2', 'phist2', RooArgSet(x), data_hist2) pdf2.plotOn(frame, RooFit.LineColor(R.kGreen), RooFit.Normalization(hist2_events)) # Not to be included in the Moment Morphing (just a check) data_hist3 = RooDataHist('dhist3', 'dhist3', RooArgList(x), hist3) pdf3 = RooHistPdf('phist3', 'phist3', RooArgSet(x), data_hist3) pdf3.plotOn(frame, RooFit.LineColor(R.kBlue), RooFit.Normalization(hist3_events)) data_hist3.plotOn(frame) # Create a RooArgList to store pdfs and fill it pdfs = RooArgList() pdfs.add(pdf1) pdfs.add(pdf2) # Create a TVector and store model mass values in it masses = [125, 175] paramVec = R.TVectorD(len(masses)) paramVec[0] = masses[0] paramVec[1] = masses[1] # Set up morphing m = w.factory('m[70,230]') setting = R.RooMomentMorph.Linear morph = R.RooMomentMorph('morph', 'morph', m, RooArgList(x), pdfs, paramVec, setting) getattr(w, 'import')(morph)
def accbuilder(time, knots, coeffs): # build acceptance function from copy import deepcopy myknots = deepcopy(knots) mycoeffs = deepcopy(coeffs) from ROOT import (RooBinning, RooArgList, RooPolyVar, RooCubicSplineFun) if (len(myknots) != len(mycoeffs) or 0 >= min(len(myknots), len(mycoeffs))): raise ValueError('ERROR: Spline knot position list and/or coefficient' 'list mismatch') # create the knot binning knotbinning = WS(ws, RooBinning(time.getMin(), time.getMax(), 'knotbinning')) for v in myknots: knotbinning.addBoundary(v) knotbinning.removeBoundary(time.getMin()) knotbinning.removeBoundary(time.getMax()) knotbinning.removeBoundary(time.getMin()) knotbinning.removeBoundary(time.getMax()) oldbinning, lo, hi = time.getBinning(), time.getMin(), time.getMax() time.setBinning(knotbinning, 'knotbinning') time.setBinning(oldbinning) time.setRange(lo, hi) del knotbinning del oldbinning del lo del hi # create the knot coefficients coefflist = RooArgList() i = 0 for v in mycoeffs: coefflist.add(WS(ws, RooRealVar('SplineAccCoeff%u' % i, 'SplineAccCoeff%u' % i, v))) i = i + 1 del mycoeffs coefflist.add(one) i = i + 1 myknots.append(time.getMax()) myknots.reverse() fudge = (myknots[0] - myknots[1]) / (myknots[2] - myknots[1]) lastmycoeffs = RooArgList( WS(ws, RooConstVar('SplineAccCoeff%u_coeff0' % i, 'SplineAccCoeff%u_coeff0' % i, 1. - fudge)), WS(ws, RooConstVar('SplineAccCoeff%u_coeff1' % i, 'SplineAccCoeff%u_coeff1' % i, fudge))) del myknots coefflist.add(WS(ws, RooPolyVar( 'SplineAccCoeff%u' % i, 'SplineAccCoeff%u' % i, coefflist.at(coefflist.getSize() - 2), lastmycoeffs))) del i # create the spline itself tacc = WS(ws, RooCubicSplineFun('SplineAcceptance', 'SplineAcceptance', time, 'knotbinning', coefflist)) del lastmycoeffs # make sure the acceptance is <= 1 for generation m = max([coefflist.at(j).getVal() for j in xrange(0, coefflist.getSize())]) from ROOT import RooProduct c = WS(ws, RooConstVar('SplineAccNormCoeff', 'SplineAccNormCoeff', 0.99 / m)) tacc_norm = WS(ws, RooProduct('SplineAcceptanceNormalised', 'SplineAcceptanceNormalised', RooArgList(tacc, c))) del c del m del coefflist return tacc, tacc_norm
var = iter.Next() data = ws.allData() for var in data: # iter = data.createIterator() # var = iter.Next() # while var : getattr( newws , "import")( var.Clone() , RooFit.RecycleConflictNodes()) var = iter.Next() a = RooArgList("pdfs") cat = RooCategory("pdfindex_THQLeptonicTag_inverted_13TeV" , "title") cat.Print() pdfs = ws.allPdfs() iter = pdfs.createIterator() var = iter.Next() while var : getattr( newws , "import")( var.Clone() , RooFit.RecycleConflictNodes()) if var.GetName() in ["env_pdf_0_13TeV_bern1","env_pdf_0_13TeV_exp1","env_pdf_0_13TeV_pow1","env_pdf_0_13TeV_lau1"]: a.add( var ) var = iter.Next() multipdf = RooMultiPdf("CMS_hgg_THQLeptonicTag_inverted_13TeV_bkgshape" , "title" , cat , a ) getattr( newws , "import")( multipdf, RooFit.RecycleConflictNodes() ) f.Close() fnew = TFile.Open("new.root" , "recreate") newws.Write() fnew.Close() print "done"
varList = r.floatParsFinal() it = varList.createIterator() setconst=[] while True: var = it.Next() if not var: break if var.isConstant(): continue setconst.append(var.GetName()) var.setConstant(True) splot_vars = RooArgList() for v in config["splot_vars"]: splot_vars.add(w.obj(v)) #normTree sData = RooStats.SPlot("sData","An SPlot", fullUnbDataSet, Final_PDF, splot_vars ) sData.Print() for v in config["splot_vars"]: print v,"Fitted value: %.2f sPlot value: %.2f"%(w.obj(v).getVal(), sData.GetYieldFromSWeight(v)) for v in setconst: w.obj(v).setConstant(False) fullUnbDataSet.Print("v") save_file = TFile.Open(config['outFileName'],"RECREATE")
def fitData(fulldata, ibin, w): cut = cut_base + '&& (mumuMass*mumuMass > %s && mumuMass*mumuMass < %s)'%(q2binning[ibin], q2binning[ibin+1]) data = fulldata.reduce(RooArgSet(tagged_mass,mumuMass,mumuMassE), cut) nrt_mc = _getFittedVar("nRT_%s"%ibin, w) nwt_mc = _getFittedVar("nWT_%s"%ibin, w) fraction = nrt_mc / (nrt_mc + nwt_mc) print 'mistag fraction on MC for bin ', ibin , ' : ' , fraction.n , '+/-', fraction.s ### creating RT component w.loadSnapshot("reference_fit_RT_%s"%ibin) mean_rt = w.var("mean^{RT%s}"%ibin) sigma_rt1 = w.var("#sigma_{RT1}^{%s}"%ibin) sigma_rt2 = RooRealVar() alpha_rt1 = RooRealVar() alpha_rt2 = RooRealVar() n_rt1 = RooRealVar() n_rt2 = RooRealVar() f1rt = RooRealVar() ## double cb fast if ibin < 4: alpha_rt1 = w.var("#alpha_{RT1}^{%s}"%ibin) alpha_rt2 = w.var("#alpha_{RT2}^{%s}"%ibin) n_rt1 = w.var("n_{RT1}^{%s}"%ibin) n_rt2 = w.var("n_{RT2}^{%s}"%ibin) ## double cb old else: sigma_rt2 = w.var("#sigma_{RT2}^{%s}"%ibin) alpha_rt1 = w.var("#alpha_{RT1}^{%s}"%ibin) alpha_rt2 = w.var("#alpha_{RT2}^{%s}"%ibin) n_rt1 = w.var("n_{RT1}^{%s}"%ibin) n_rt2 = w.var("n_{RT2}^{%s}"%ibin) f1rt = w.var("f^{RT%s}"%ibin) theRTgauss = w.pdf("doublecb_RT%s"%ibin) ### creating WT component w.loadSnapshot("reference_fit_WT_%s"%ibin) mean_wt = w.var("mean_{WT}^{%s}"%ibin) sigma_wt = w.var("#sigma_{WT1}^{%s}"%ibin) alpha_wt1 = w.var("#alpha_{WT1}^{%s}"%ibin) alpha_wt2 = w.var("#alpha_{WT2}^{%s}"%ibin) n_wt1 = w.var("n_{WT1}^{%s}"%ibin) n_wt2 = w.var("n_{WT2}^{%s}"%ibin) theWTgauss = w.pdf("doublecb_%s"%ibin) ### creating variable for the difference between the two peaks deltaPeaks = RooFormulaVar("deltaPeaks%s"%ibin, "@0 - @1", RooArgList(mean_rt, mean_wt)) frt = RooRealVar ("F_{RT}%s"%ibin , "frt" , fraction.n , 0, 1) signalFunction = RooAddPdf ("sumgaus%s"%ibin , "rt+wt" , RooArgList(theRTgauss,theWTgauss), RooArgList(frt)) ### now create background parametrization slope = RooRealVar ("slope_%s"%ibin , "slope" , 0.5, -10, 10); bkg_exp = RooExponential("bkg_exp%s"%ibin , "exponential" , slope, tagged_mass ); pol_c1 = RooRealVar ("p1_%s"%ibin , "coeff x^0 term" , 0.5, -10, 10); pol_c2 = RooRealVar ("p2_%s"%ibin , "coeff x^1 term" , 0.5, -10, 10); bkg_pol = RooPolynomial ("bkg_pol%s"%ibin , "2nd order pol" , tagged_mass, RooArgList(pol_c1, pol_c2)); fsig = RooRealVar("fsig%s"%ibin , "fsig" , 0.9, 0, 1); # nsig = RooRealVar("Yield%s"%ibin , "signal frac" , 1000, 0, 10000); # nbkg = RooRealVar("nbkg%s"%ibin , "bkg fraction" , 1000, 0, 500000); nsig = RooRealVar("Yield" , "signal frac" , 600000, 0, 5000000); nbkg = RooRealVar("nbkg" , "bkg fraction" , 100000, 0, 2000000); # if ibin==4: # nsig.setRange(500000,1500000) # nsig.setVal(900000) # nbkg.setRange(80000,1000000) # nbkg.setVal(100000) ### creating constraints c_vars = RooArgSet() c_pdfs = RooArgSet() c_sigma_rt1 = _constrainVar(sigma_rt1, 1) c_alpha_rt1 = _constrainVar(alpha_rt1, 1) c_alpha_rt2 = _constrainVar(alpha_rt2, 1) c_n_rt1 = _constrainVar(n_rt1, 1) c_n_rt2 = _constrainVar(n_rt2, 1) c_sigma_wt = _constrainVar(sigma_wt, 1) c_alpha_wt1 = _constrainVar(alpha_wt1, 1) c_alpha_wt2 = _constrainVar(alpha_wt2, 1) c_n_wt1 = _constrainVar(n_wt1, 1) c_n_wt2 = _constrainVar(n_wt2, 1) if ibin < 4: c_pdfs = RooArgSet(c_sigma_rt1, c_alpha_rt1, c_alpha_rt2, c_n_rt1, c_n_rt2) c_vars = RooArgSet(sigma_rt1, alpha_rt1, alpha_rt2, n_rt1, n_rt2) else: c_sigma_rt2 = _constrainVar(sigma_rt2, 1) c_pdfs = RooArgSet(c_sigma_rt1, c_sigma_rt2, c_alpha_rt1, c_alpha_rt2, c_n_rt1, c_n_rt2) c_vars = RooArgSet( sigma_rt1, sigma_rt2, alpha_rt1, alpha_rt2, n_rt1, n_rt2) c_pdfs.add(c_sigma_wt); c_vars.add(sigma_wt) c_pdfs.add(c_alpha_wt1); c_vars.add(alpha_wt1) c_pdfs.add(c_alpha_wt2); c_vars.add(alpha_wt2) c_pdfs.add(c_n_wt1); c_vars.add(n_wt1) c_pdfs.add(c_n_wt2); c_vars.add(n_wt2) c_deltaPeaks = RooGaussian("c_deltaPeaks%s"%ibin , "c_deltaPeaks", deltaPeaks, ROOT.RooFit.RooConst( deltaPeaks.getVal() ), ROOT.RooFit.RooConst( 0.0005 ) ## value to be checked ) c_pdfs.add(c_deltaPeaks) c_vars.add(deltaPeaks) c_frt = RooGaussian("c_frt%s"%ibin , "c_frt" , frt, ROOT.RooFit.RooConst(fraction.n) , ROOT.RooFit.RooConst(frt_sigma[ibin]) ) c_pdfs.add(c_frt) c_vars.add(frt) constr_list = RooArgList(c_pdfs) constr_list.add(signalFunction) c_signalFunction = RooProdPdf ("c_signalFunction", "c_signalFunction", constr_list) # mean = RooRealVar ("mass" , "mean" , B0Mass_, 3, 7, "GeV") # sigma = RooRealVar ("#sigma_{1}" , "sigma" , 0.028, 0, 10, "GeV") # signalGauss = RooGaussian("signalGauss" , "signal gauss" , tagged_mass, mean,sigma) # # sigma2 = RooRealVar ("#sigma_{2}" , "sigma2" , 0.048, 0, 0.07, "GeV") # signalGauss2 = RooGaussian("signalGauss2" , "signal gauss2" , tagged_mass, mean,sigma2) # f1 = RooRealVar ("f1" , "f1" , 0.8 , 0., 1.) # gaus = RooAddPdf ("gaus" , "gaus1+gaus2" , RooArgList(signalGauss,signalGauss2), RooArgList(f1)) # pol_c1 = RooRealVar ("p1" , "coeff x^0 term", 0.5, -10, 10); # pol_c2 = RooRealVar ("p2" , "coeff x^1 term", 0.5, -10, 10); # pol_c3 = RooRealVar ("p3" , "coeff x^2 term", 0.5, -10, 10); # slope = RooRealVar ("slope" , "slope" , 0.5, -10, 10); # bkg_exp = RooExponential("bkg_exp" , "exponential" , slope, tagged_mass ); # bkg_pol = RooChebychev("bkg_pol" , "2nd order pol" , tagged_mass, RooArgList(pol_c1,pol_c2)); fitFunction = RooAddPdf ("fitfunction%s"%ibin , "fit function" , RooArgList(c_signalFunction, bkg_exp), RooArgList(nsig, nbkg)) # r = fitFunction.fitTo(data, # # RooFit.Extended(True), # RooFit.Range("full"), # ROOT.RooFit.Constrain(c_vars), # ROOT.RooFit.Minimizer("Minuit2","migrad"), # ROOT.RooFit.Hesse(True), # ROOT.RooFit.Strategy(2), # ROOT.RooFit.Minos(False), # ) print 'fit with Hesse strategy 2 done, now Minos' r = fitFunction.fitTo(data, RooFit.Extended(True), RooFit.Save(), RooFit.Range("full"), RooFit.Verbose(False), ROOT.RooFit.Constrain(c_vars), # ROOT.RooFit.Minimizer("Minuit2","migrad"), # ROOT.RooFit.Hesse(True), # ROOT.RooFit.Strategy(2), # ROOT.RooFit.Minos(False), ) r.Print() r.correlationMatrix().Print() fitStats['data%s'%(ibin)] = r.status() covStats['data%s'%(ibin)] = r.covQual() frame = tagged_mass.frame( RooFit.Range("full") ) data.plotOn(frame, RooFit.Binning(nbins), RooFit.MarkerSize(.7)) fitFunction.plotOn(frame, RooFit.NormRange("full"), RooFit.Range("full")) ## evaluate sort of chi2 and save number of RT/WT events observables = RooArgSet(tagged_mass) flparams = fitFunction.getParameters(observables) nparam = int(flparams.selectByAttrib("Constant",ROOT.kFALSE).getSize()) pdfstring = "fitfunction%s_Norm[tagged_mass]_Range[full]_NormRange[full]"%ibin chi2s['data%s'%ibin] = frame.chiSquare(pdfstring, "h_fulldata", nparam) frame. addObject(_writeChi2( chi2s['data%s'%ibin] )) drawPdfComponents(fitFunction, frame, ROOT.kAzure, RooFit.NormRange("full"), RooFit.Range("full"), isData = True) # fitFunction.paramOn(frame, RooFit.Layout(0.62,0.86,0.89)) parList = RooArgSet (nsig, mean_rt, sigma_rt, alpha_rt1, alpha_rt2, n_rt1, n_rt2, mean_wt, sigma_wt) # parList.add(alphawt1) # parList.add(alphawt2) # parList.add(nwt1) # parList.add(nwt2) parList.add(frt) fitFunction.paramOn(frame, RooFit.Parameters(parList), RooFit.Layout(0.62,0.86,0.89)) frame.Draw() niceFrame(frame, '') frame. addObject(_writeFitStatus(r)) c1 = ROOT.TCanvas() upperPad = ROOT.TPad('upperPad' , 'upperPad' , 0., 0.35 , 1., 1. ) lowerPad = ROOT.TPad('lowerPad' , 'lowerPad' , 0., 0.0 , 1., 0.345 ) upperPad.SetBottomMargin(0.012) lowerPad.SetTopMargin(0) lowerPad.SetBottomMargin(0.2) upperPad.Draw(); lowerPad.Draw() upperPad.cd() frame.Draw() if not args.year=='test': writeCMS(frame, args.year, [ q2binning[ibin], q2binning[ibin+1] ], 0) frame.Draw() ## add plot of pulls lowerPad.cd() hpull = frame.pullHist("h_fulldata", pdfstring) frame2 = tagged_mass.frame(RooFit.Range("full"), RooFit.Title('')) frame2.addPlotable(hpull,"P") niceFrameLowerPad(frame2, 'pull') frame2.Draw() line = ROOT.TLine(5.0,1,5.6,1) line.SetLineColor(ROOT.kGreen+3) line.Draw() for ilog in [True,False]: upperPad.SetLogy(ilog) c1.SaveAs('fit_results_mass/save_fit_data_%s_%s_LMNR_Update%s_newSigmaFRT_pars_Jpsi.pdf'%(ibin, args.year, '_logScale'*ilog)) out_f.cd() r.Write('results_data_%s'%(ibin)) params = fitFunction.getParameters(RooArgSet(tagged_mass)) out_w.saveSnapshot("reference_fit_data_%s"%(ibin),params,ROOT.kTRUE) getattr(out_w, 'import')(fitFunction)
def plotFitModel(model, frame, wksp, myconfigfile, log, debug) : if debug : model.Print('t') frame.Print('v') fr = model.plotOn(frame, RooFit.LineColor(kBlue+3),RooFit.Name("FullPdf")) if "Acceptance" in myconfigfile.keys(): var = [] tacc_list = RooArgList() numKnots = myconfigfile["Acceptance"]["knots"].__len__() for i in range(0,numKnots+1): varName = "var%d"%(int(i+1)) var.append(wksp.var(varName)) print "[INFO] Load %s with value %0.3lf"%(var[i].GetName(),var[i].getValV()) tacc_list.add(var[i]) varAdd = RooAddition(wksp.obj("var%d"%(numKnots+2))) print "[INFO] Load %s with value %0.3lf"%(varAdd.GetName(),varAdd.getValV()) tacc_list.add(varAdd) elif "ResolutionAcceptance" in myconfigfile.keys(): #Create acceptance var = [] tacc_list = RooArgList() numKnots = myconfigfile["ResolutionAcceptance"]["Signal"]["Acceptance"]["KnotPositions"].__len__() print "[INFO] Number of knots: "+str(numKnots) for i in range(0,numKnots+1): if i!=6: varName = "Acceptance_SplineAccCoeff%d"%(int(i)) var.append(wksp.obj(varName)) print "[INFO] Load %s with value %0.3lf"%(var[i].GetName(),var[i].getValV()) else: var.append( RooConstVar("one","one",1.0) ) print "[INFO] Load one as coefficient no. 6" tacc_list.add(var[i]) varName = "Acceptance_SplineAccCoeff%d"%(int(numKnots+1)) var.append(wksp.obj(varName)) print "[INFO] Load %s with value %0.3lf"%(var[numKnots+1].GetName(),var[numKnots+1].getValV()) tacc_list.add(var[numKnots+1]) #Create binning binning = RooBinning(time.getMin(), time.getMax(), 'splineBinning') for kn in myconfigfile["ResolutionAcceptance"]["Signal"]["Acceptance"]["KnotPositions"]: binning.addBoundary(kn) binning.removeBoundary(time.getMin()) binning.removeBoundary(time.getMax()) binning.removeBoundary(time.getMin()) binning.removeBoundary(time.getMax()) oldBinning, lo, hi = time.getBinning(), time.getMin(), time.getMax() time.setBinning(binning, 'splineBinning') time.setBinning(oldBinning) time.setRange(lo, hi) spl = RooCubicSplineFun("splinePdf", "splinePdf", time, "splineBinning", tacc_list) if log: rel = 200 else: #rel = 1000 rel = 2000 fr = spl.plotOn(frame, RooFit.LineColor(kRed), RooFit.Normalization(rel, RooAbsReal.Relative),RooFit.Name("sPline")) fr = model.plotOn(frame, RooFit.LineColor(kBlue+3), RooFit.Name("FullPdf"))
def buildPolarizationPDF(ws, options): foldname = '' if not options.folded: foldname = '' accMaps = TFile.Open(options.acceptanceMap) #effMaps = TFile.Open(options.efficiencyMap) ws.factory('lambda_theta_' + options.fitFrame + '_p[0,-1,1]') ws.factory('lambda_phi_' + options.fitFrame + '_p[0,-1,1]') ws.factory('lambda_thetaphi_' + options.fitFrame + '_p[0,-1,1]') ws.factory('lambda_theta_' + options.fitFrame + '_np[0,-1,1]') ws.factory('lambda_phi_' + options.fitFrame + '_np[0,-1,1]') ws.factory('lambda_thetaphi_' + options.fitFrame + '_np[0,-1,1]') ws.factory('nPromptinP[500,0,1000000]') ws.factory('sum::nPromptinNP(1*nPromptSignal,-1*nPromptinP)') ws.factory('nNonPromptinNP[100,0,1000000]') ws.factory('sum::nNonPromptinP(1*nNonPromptSignal,-1*nNonPromptinNP)') ws.factory('nBackgroundinP[50,0,1000000]') ws.factory('sum::nBackgroundinNP(1*nBackgroundSignal,-1*nBackgroundinP)') ws.factory('RooPolarizationConstraint::promptConstr(' + 'lambda_theta_' + options.fitFrame + '_p,' + 'lambda_phi_' + options.fitFrame + '_p,' + 'lambda_thetaphi_' + options.fitFrame + '_p)') ws.factory('RooPolarizationConstraint::nonPromptConstr(' + 'lambda_theta_' + options.fitFrame + '_np,' + 'lambda_phi_' + options.fitFrame + '_np,' + 'lambda_thetaphi_' + options.fitFrame + '_np)') #for each rap/pt cell make a unique simultaneous fit of prompt,non-prompt, background for rap_bin in range(1, len(jpsi.pTRange)): for pt_bin in range(len(jpsi.pTRange[rap_bin])): accMapHist = accMaps.Get('hAcc2D_' + options.fitFrame + '_pT' + str(pt_bin + 1) + '_rap' + str(rap_bin)) for effMap in options.efficiencyMap.split(','): effMaps = TFile.Open(effMap) effMapHist = effMaps.Get('hAcc2D_' + options.fitFrame + '_pT' + str(pt_bin + 1) + '_rap' + str(rap_bin)) accMapHist.Multiply(effMapHist) effMaps.Close() getattr(ws, 'import')(accMapHist) accMap = RooDataHist( 'accMap' + options.fitFrame + 'Data_' + str(rap_bin) + '_' + str(pt_bin + 1), 'acceptance map', RooArgList(ws.var('costh_' + options.fitFrame + foldname), ws.var('phi_' + options.fitFrame + foldname)), ROOT.RooFit.Import(accMapHist, False)) getattr(ws, 'import')(accMap) accMapFunc = RooHistFunc( 'accMapFunc' + options.fitFrame + '_' + str(rap_bin) + '_' + str(pt_bin + 1), 'acceptance map', RooArgSet(ws.var('costh_' + options.fitFrame + foldname), ws.var('phi_' + options.fitFrame + foldname)), ws.data('accMap' + options.fitFrame + 'Data_' + str(rap_bin) + '_' + str(pt_bin + 1)), 1) getattr(ws, 'import')(accMapFunc) #make a *real* hist pdf :-) ws.factory('RooGenericPdf::accMap' + options.fitFrame + '_' + str(rap_bin) + '_' + str(pt_bin + 1) + '("@0",{accMapFunc' + options.fitFrame + '_' + str(rap_bin) + '_' + str(pt_bin + 1) + '})') #create datahist for L and R sidebands getattr(ws, 'import')( accMap.Clone('bkgShape' + options.fitFrame + 'DataL_' + str(rap_bin) + '_' + str(pt_bin + 1))) getattr(ws, 'import')( accMap.Clone('bkgShape' + options.fitFrame + 'DataR_' + str(rap_bin) + '_' + str(pt_bin + 1))) ws.data('bkgShape' + options.fitFrame + 'DataL_' + str(rap_bin) + '_' + str(pt_bin + 1)).reset() ws.data('bkgShape' + options.fitFrame + 'DataR_' + str(rap_bin) + '_' + str(pt_bin + 1)).reset() #fill them ws.data('bkgShape' + options.fitFrame + 'DataL_' + str(rap_bin) + '_' + str(pt_bin + 1)).add( ws.data('data_rap' + str(rap_bin) + '_pt' + str(pt_bin + 1)), 'massRegion == massRegion::leftMassSideBand') ws.data('bkgShape' + options.fitFrame + 'DataR_' + str(rap_bin) + '_' + str(pt_bin + 1)).add( ws.data('data_rap' + str(rap_bin) + '_pt' + str(pt_bin + 1)), 'massRegion == massRegion::rightMassSideBand') #make histpdfs and combination ws.factory('RooHistPdf::bkgShape' + options.fitFrame + 'L_' + str(rap_bin) + '_' + str(pt_bin + 1) + '({costh_' + options.fitFrame + foldname + ',phi_' + options.fitFrame + foldname + '},' + 'bkgShape' + options.fitFrame + 'DataL_' + str(rap_bin) + '_' + str(pt_bin + 1) + ')') ws.factory('RooHistPdf::bkgShape' + options.fitFrame + 'R_' + str(rap_bin) + '_' + str(pt_bin + 1) + '({costh_' + options.fitFrame + foldname + ',phi_' + options.fitFrame + foldname + '},' + 'bkgShape' + options.fitFrame + 'DataR_' + str(rap_bin) + '_' + str(pt_bin + 1) + ')') ws.factory('SUM::bkgShape' + options.fitFrame + '_' + str(rap_bin) + '_' + str(pt_bin + 1) + '(fBkgLR*bkgShape' + options.fitFrame + 'L_' + str(rap_bin) + '_' + str(pt_bin + 1) + ',bkgShape' + options.fitFrame + 'R_' + str(rap_bin) + '_' + str(pt_bin + 1) + ')') #test new polarization pdf ws.factory('RooPolarizationPdf::basePolPdf' + options.fitFrame + 'Prompt_' + str(rap_bin) + '_' + str(pt_bin + 1) + '(costh_' + options.fitFrame + foldname + ',phi_' + options.fitFrame + foldname + ',lambda_theta_' + options.fitFrame + '_p,lambda_phi_' + options.fitFrame + '_p,lambda_thetaphi_' + options.fitFrame + '_p)') ws.factory('RooPolarizationPdf::basePolPdf' + options.fitFrame + 'NonPrompt_' + str(rap_bin) + '_' + str(pt_bin + 1) + '(costh_' + options.fitFrame + foldname + ',phi_' + options.fitFrame + foldname + ',lambda_theta_' + options.fitFrame + '_np,lambda_phi_' + options.fitFrame + '_np,lambda_thetaphi_' + options.fitFrame + '_np)') #should add back *(3+@2) ? #sin(2theta) = 2sin(theta)cos(theta) = 2*sqrt(1 - cos(theta)*cos(theta))*cos(theta) #ws.factory('RooGenericPdf::basePolPdf'+options.fitFrame+'Prompt_'+str(rap_bin)+'_'+str(pt_bin+1)+ # '("1+@2*pow(@0,2.)+@3*(1-pow(@0,2.))*cos(2*@1*pi/180)+@4*sin(2*acos(@0))*cos(@1*pi/180)"'+ # ',{costh_'+options.fitFrame+foldname+',phi_'+options.fitFrame+foldname+',lambda_theta_'+options.fitFrame+ # '_p,lambda_phi_'+options.fitFrame+'_p,lambda_thetaphi_'+options.fitFrame+'_p})') #ws.factory('RooGenericPdf::basePolPdf'+options.fitFrame+'NonPrompt_'+str(rap_bin)+'_'+str(pt_bin+1)+ # '("1+@2*@0*@0+@3*(1-@0*@0)*cos(2*@1*pi/180)+@4*sin(2*acos(@0))*cos(@1*pi/180)"'+ # ',{costh_'+options.fitFrame+foldname+',phi_'+options.fitFrame+foldname+',lambda_theta_'+options.fitFrame+ # '_np,lambda_phi_'+options.fitFrame+'_np,lambda_thetaphi_'+options.fitFrame+'_np})') ws.factory('PROD::polPdf' + options.fitFrame + 'Prompt_' + str(rap_bin) + '_' + str(pt_bin + 1) + '(basePolPdf' + options.fitFrame + 'Prompt_' + str(rap_bin) + '_' + str(pt_bin + 1) + ',accMap' + options.fitFrame + '_' + str(rap_bin) + '_' + str(pt_bin + 1) + ')') ws.factory('PROD::polPdf' + options.fitFrame + 'NonPrompt_' + str(rap_bin) + '_' + str(pt_bin + 1) + '(basePolPdf' + options.fitFrame + 'NonPrompt_' + str(rap_bin) + '_' + str(pt_bin + 1) + ',accMap' + options.fitFrame + '_' + str(rap_bin) + '_' + str(pt_bin + 1) + ')') ws.factory('RooExtendPdf::promptPolExtinP' + options.fitFrame + '_' + str(rap_bin) + '_' + str(pt_bin + 1) + '(polPdf' + options.fitFrame + 'Prompt_' + str(rap_bin) + '_' + str(pt_bin + 1) + ',nPromptinP)') ws.factory('RooExtendPdf::promptPolExtinNP' + options.fitFrame + '_' + str(rap_bin) + '_' + str(pt_bin + 1) + '(polPdf' + options.fitFrame + 'Prompt_' + str(rap_bin) + '_' + str(pt_bin + 1) + ',nPromptinNP)') ws.factory('RooExtendPdf::nonPromptPolExtinNP' + options.fitFrame + '_' + str(rap_bin) + '_' + str(pt_bin + 1) + '(polPdf' + options.fitFrame + 'NonPrompt_' + str(rap_bin) + '_' + str(pt_bin + 1) + ',nNonPromptinNP)') ws.factory('RooExtendPdf::nonPromptPolExtinP' + options.fitFrame + '_' + str(rap_bin) + '_' + str(pt_bin + 1) + '(polPdf' + options.fitFrame + 'NonPrompt_' + str(rap_bin) + '_' + str(pt_bin + 1) + ',nNonPromptinP)') ws.factory('RooExtendPdf::bkgPolExtinP' + options.fitFrame + '_' + str(rap_bin) + '_' + str(pt_bin + 1) + '(bkgShape' + options.fitFrame + '_' + str(rap_bin) + '_' + str(pt_bin + 1) + ',nBackgroundinP)') ws.factory('RooExtendPdf::bkgPolExtinNP' + options.fitFrame + '_' + str(rap_bin) + '_' + str(pt_bin + 1) + '(bkgShape' + options.fitFrame + '_' + str(rap_bin) + '_' + str(pt_bin + 1) + ',nBackgroundinNP)') promptPOLArgList = RooArgList( ws.pdf('promptPolExtinP' + options.fitFrame + '_' + str(rap_bin) + '_' + str(pt_bin + 1))) nonPromptPOLArgList = RooArgList( ws.pdf('promptPolExtinNP' + options.fitFrame + '_' + str(rap_bin) + '_' + str(pt_bin + 1)), ws.pdf('nonPromptPolExtinNP' + options.fitFrame + '_' + str(rap_bin) + '_' + str(pt_bin + 1))) if options.doNonPrompt: promptPOLArgList.add( ws.pdf('nonPromptPolExtinP' + options.fitFrame + '_' + str(rap_bin) + '_' + str(pt_bin + 1))) if options.doBackground: promptPOLArgList.add( ws.pdf('bkgPolExtinP' + options.fitFrame + '_' + str(rap_bin) + '_' + str(pt_bin + 1))) nonPromptPOLArgList.add( ws.pdf('bkgPolExtinNP' + options.fitFrame + '_' + str(rap_bin) + '_' + str(pt_bin + 1))) promptP = RooAddPdf( 'promptPol' + options.fitFrame + '_' + str(rap_bin) + '_' + str(pt_bin + 1), 'prompt', promptPOLArgList) nonpromptP = RooAddPdf( 'nonpromptPol' + options.fitFrame + '_' + str(rap_bin) + '_' + str(pt_bin + 1), 'nonprompt', nonPromptPOLArgList) getattr(ws, 'import')(promptP) getattr(ws, 'import')(nonpromptP) polConfig = 'SIMUL::PPdf' + options.fitFrame + '_' + str( rap_bin) + '_' + str(pt_bin + 1) + '(mlRegion,' if options.doPrompt: polConfig += 'promptSignal=promptPol' + options.fitFrame + '_' + str( rap_bin) + '_' + str(pt_bin + 1) + ',' if options.doNonPrompt: polConfig += 'nonPromptSignal=nonpromptPol' + options.fitFrame + '_' + str( rap_bin) + '_' + str(pt_bin + 1) + ',' #if options.doBackground: # polConfig += ('prompt;leftMassSideBand=bkgPolExtL'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+',' # 'prompt;rightMassSideBand=bkgPolExtR'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)) # polConfig += ('nonPrompt;leftMassSideBand=bkgPolExtL'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+',' # 'nonPrompt;rightMassSideBand=bkgPolExtR'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)) polConfig += ')' #simultaneous ws.factory(polConfig) accMaps.Close()
def fit_gau2_che(var, dataset, title='', print_pars=False, test=False, mean_=None, sigma_=None, sigma1_=None, sigmaFraction_=None): # define background c0 = RooRealVar('c0', 'constant', 0.1, -1, 1) c1 = RooRealVar('c1', 'linear', 0.6, -1, 1) c2 = RooRealVar('c2', 'quadratic', 0.1, -1, 1) c3 = RooRealVar('c3', 'c3', 0.1, -1, 1) bkg = RooChebychev('bkg', 'background pdf', var, RooArgList(c0, c1, c2, c3)) # define signal val = 5.28 dmean = 0.05 valL = val - dmean valR = val + dmean if mean_ is None: mean = RooRealVar("mean", "mean", val, valL, valR) else: mean = RooRealVar("mean", "mean", mean_) val = 0.05 dmean = 0.02 valL = val - dmean valR = val + dmean if sigma_ is None: sigma = RooRealVar('sigma', 'sigma', val, valL, valR) else: sigma = RooRealVar('sigma', 'sigma', sigma_) if sigma1_ is None: sigma1 = RooRealVar('sigma1', 'sigma1', val, valL, valR) else: sigma1 = RooRealVar('sigma1', 'sigma1', sigma1_) peakGaus = RooGaussian("peakGaus", "peakGaus", var, mean, sigma) peakGaus1 = RooGaussian("peakGaus1", "peakGaus1", var, mean, sigma1) if sigmaFraction_ is None: sigmaFraction = RooRealVar("sigmaFraction", "Sigma Fraction", 0.5, 0., 1.) else: sigmaFraction = RooRealVar("sigmaFraction", "Sigma Fraction", sigmaFraction_) glist = RooArgList(peakGaus, peakGaus1) peakG = RooAddPdf("peakG","peakG", glist, RooArgList(sigmaFraction)) listPeak = RooArgList("listPeak") listPeak.add(peakG) listPeak.add(bkg) fbkg = 0.45 nEntries = dataset.numEntries() val=(1-fbkg)* nEntries listArea = RooArgList("listArea") areaPeak = RooRealVar("areaPeak", "areaPeak", val, 0.,nEntries) listArea.add(areaPeak) nBkg = fbkg*nEntries areaBkg = RooRealVar("areaBkg","areaBkg", nBkg, 0.,nEntries) listArea.add(areaBkg) model = RooAddPdf("model", "fit model", listPeak, listArea) if not test: fitres = model.fitTo(dataset, RooFit.Extended(kTRUE), RooFit.Minos(kTRUE),RooFit.Save(kTRUE)) nbins = 35 frame = var.frame(nbins) frame.GetXaxis().SetTitle("B^{0} mass (GeV/c^{2})") frame.GetXaxis().CenterTitle() frame.GetYaxis().CenterTitle() frame.SetTitle(title) mk_size = RooFit.MarkerSize(0.3) mk_style = RooFit.MarkerStyle(kFullCircle) dataset.plotOn(frame, mk_size, mk_style) model.plotOn(frame) as_bkg = RooArgSet(bkg) cp_bkg = RooFit.Components(as_bkg) line_style = RooFit.LineStyle(kDashed) model.plotOn(frame, cp_bkg, line_style) if print_pars: fmt = RooFit.Format('NEU') lyt = RooFit.Layout(0.65, 0.95, 0.92) param = model.paramOn(frame, fmt, lyt) param.getAttText().SetTextSize(0.02) param.getAttText().SetTextFont(60) frame.Draw() pars = [areaBkg, areaPeak, c0, c1, c2, c3, mean, sigma, sigma1, sigmaFraction] return pars
n_signal = n_ttbar + n_stop temp_VPlusJets.Rebin(REBIN) temp_tt.Rebin(REBIN) temp_wj.Rebin(REBIN) temp_zj.Rebin(REBIN) temp_stop.Rebin(REBIN) temp_qcd.Rebin(REBIN) temp_qcd2.Rebin(REBIN) temp_qcd.Scale(n_qcd / temp_qcd.Integral()) temp_qcd2.Scale(n_qcd/temp_qcd2.Integral()) temp_signal = temp_tt.Clone('signal') temp_signal.Add(temp_stop) leptonAbsEta = RooRealVar("leptonAbsEta", "leptonAbsEta", 0., 3.) variables = RooArgList() variables.add(leptonAbsEta) vars_set = RooArgSet() vars_set.add(leptonAbsEta) n_event_obs = h_data.Integral(); lowerBound = -10 * sqrt(n_event_obs); lowerBound = 0 upperBound = n_event_obs + 10 * sqrt(n_event_obs); upperBound = n_event_obs n_init = n_event_obs / 2.; data = RooDataHist("data", "dataset with leptonAbsEta", variables, h_data) rh_tt = RooDataHist("rh_tt", "tt", variables, temp_tt); rh_wj = RooDataHist("rh_wj", "wj", variables, temp_wj); rh_zj = RooDataHist("rh_zj", "zj", variables, temp_zj); rh_VJ = RooDataHist("rh_VJ", "VJ", variables, temp_VPlusJets); rh_qcd = RooDataHist("rh_qcd", "qcd", variables, temp_qcd); rh_qcd2 = RooDataHist("rh_qcd", "qcd", variables, temp_qcd2);
fOut = TFile.Open("out.root" , "recreate") for kvkt in AllCtOverCVs: infile = TFile.Open( "ctcv%g/input.root" % (kvkt) ) ws = infile.Get( "WS%s" % (BinToPlot) ) mass = ws.var( "CMS_hgg_mass" ) allPdfs = RooArgList() allNorms = RooArgList() finalNorm = 0. norms_ = {} for signal in signals : pdf = ws.pdf( "RV%s_mh125" % (signal) ) norm = ws.var( "RV%s_mh125_norm" % (signal) ) allPdfs.add( pdf ) allNorms.add( norm ) signals[signal]["pdf%g" % kvkt ] = pdf signals[signal]["norm%g" % kvkt ] = norm signals[signal]["extendedpdf%g" % kvkt ] = RooExtendPdf( "extended_%s_%g" % ( signal, kvkt ) , "extended_%s_%g" % ( signal, kvkt ) , pdf , norm ) finalNorm += norm.getValV() norms_[signal] = norm.getValV() signal = RooAddPdf("signal_%g" % (kvkt) , "signal_%g" % (kvkt) , allPdfs , allNorms ) AllCtOverCVs[ kvkt ]["norm"] = RooRealVar( "norm%g" % (kvkt) , "norm%g" % (kvkt) , finalNorm ) AllCtOverCVs[ kvkt ]["signalnormed"] = signal AllCtOverCVs[ kvkt ]["signal"] = RooExtendPdf( "signal_%g_extended" % (kvkt) , "" , signal , AllCtOverCVs[ kvkt ]["norm"] ) #AllCtOverCVs[ kvkt ]["hist_norm"] = TH1D("hist_norm%g" % (kvkt) , "" , 1000 , 115 , 135 )
def fit(self): fit_variable = RooRealVar("fit_variable", "fit_variable", self.fit_boundaries[0], self.fit_boundaries[1]) fit_variable.setBins(self.histograms[self.data_label].nbins()) variables = RooArgList() variables.add(fit_variable) variable_set = RooArgSet() variable_set.add(fit_variable) roofit_histograms = {} roofit_pdfs = {} roofit_variables = {} N_min = 0. N_max = self.normalisation[self.data_label] * 2. pdf_arglist = RooArgList() variable_arglist = RooArgList() roofit_histograms[self.data_label] = RooDataHist( self.data_label, self.data_label, variables, self.histograms[self.data_label]) for sample in self.samples: roofit_histogram = RooDataHist(sample, sample, variables, self.histograms[sample]) roofit_histograms[sample] = roofit_histogram roofit_pdf = RooHistPdf('pdf' + sample, 'pdf' + sample, variable_set, roofit_histogram) roofit_pdfs[sample] = roofit_pdf roofit_variable = RooRealVar(sample, sample + " events", self.normalisation[sample], N_min, N_max) roofit_variables[sample] = roofit_variable pdf_arglist.add(roofit_pdf) variable_arglist.add(roofit_variable) model = RooAddPdf('model', 'sum of all known', pdf_arglist, variable_arglist) use_model = model if self.constraints: arg_set = RooArgSet(model) constraints = self.get_fit_normalisation_constraints( model, roofit_variables) for constraint in constraints: arg_set.add(constraint) model_with_constraints = RooProdPdf( "model_with_constraints", "model with gaussian constraints", arg_set, RooLinkedList()) use_model = model_with_constraints if self.method == 'TMinuit': #WARNING: number of cores changes the results!!! self.saved_result = use_model.fitTo( roofit_histograms[self.data_label], RooFit.Minimizer("Minuit2", "Migrad"), RooFit.NumCPU(1), RooFit.Extended(), RooFit.Save(), ) results = {} for sample in self.samples: results[sample] = (roofit_variables[sample].getVal(), roofit_variables[sample].getError()) self.results = results
def mbc_single_3s(evtfile, mc, setMres, setGamma, setR, sp1, sp2, sp3, fa, fb, setmd, setp, setxi, setN1, setN2, setNbkgd1, setNbkgd2, title1, title2, epsfile, txtfile, ymin=0.5, cuts=None, err_type='SYMM', test=False): from ROOT import (gROOT, RooRealVar, RooCategory, RooArgSet, RooDataSet, RooFit, RooGaussian, RooArgList, RooAddPdf, RooSimultaneous, RooArgusBG, RooFormulaVar, RooDLineShape, RooAbsData, RooDataHist, TCanvas, kRed, kBlue, kGreen, kMagenta, TPaveText) set_root_style(stat=1, grid=0) # // sp1 = sigma of signal # // sp2 = ratio of sigmas betwwen sigma2 sigma 1 # // sp3 = ratio of sigmas betwwen sigma3 sigma 2 # // fa, fb, - fractions # // xi_side - slope of argus # // p_side - power of argus # mc = 1 Monte Carlo Model: EvtGenModels/Class/EvtVPHOtoVISR.cc # mc = 3 Data Model: with BES 2007 paper (BES2006 lineshape hepex/0612056) mbc = RooRealVar('mbc', 'Beam constrained mass', 1.83, 1.89, 'GeV') ebeam = RooRealVar('ebeam', 'Ebeam', 1.8815, 1.892, 'GeV') dflav = RooCategory('dflav', 'D flavor') dflav.defineType('dflav', 1) dflav.defineType('dbarflav', -1) if cuts != None: if 'kkmass' in cuts: kkmass = RooRealVar('kkmass', 'KK invariant mass', 0.97, 1.90, 'GeV') ras = RooArgSet(mbc, ebeam, kkmass, dflav) dataset = RooDataSet.read(evtfile, ras) elif 'kpimass' in cuts: kpimass = RooRealVar('kpimass', 'Kpi invariant mass', 0.6, 1.4, 'GeV') ras = RooArgSet(mbc, ebeam, kpimass, dflav) dataset = RooDataSet.read(evtfile, ras) else: raise NameError(cuts) sys.stdout.write('Using cuts: %s...' % cuts) dataset = dataset.reduce(cuts) sys.stdout.write(' selected %s events.\n' % dataset.numEntries()) else: ras = RooArgSet(mbc, ebeam, dflav) dataset = RooDataSet.read(evtfile, ras) res = RooRealVar("datares", "datares", mc) mres = RooRealVar("mres", "mres", setMres) gamma = RooRealVar('gamma', 'gamma', setGamma) r = RooRealVar('r', 'r', setR) sigmaE = RooRealVar("sigmaE", "sigmaE", 0.0021) sigmap1 = RooRealVar("sigmap1", "sigmap1", sp1, 0.002, 0.040) scalep2 = RooRealVar("scalep2", "scalep2", 2.00, 1.500, 5.500) scalep3 = RooRealVar("scalep3", "scalep3", 5.00, 3.00, 10.000) scalep2.setVal(sp2) scalep2.setConstant(1) scalep3.setVal(sp3) scalep3.setConstant(1) as12 = RooArgList(sigmap1, scalep2) sigmap2 = RooFormulaVar("sigmap2", "sigma2", "sigmap1*scalep2", as12) as123 = RooArgList(sigmap1, scalep2, scalep3) sigmap3 = RooFormulaVar("sigmap3", "sigma3", "sigmap1*scalep2*scalep3", as123) md = RooRealVar("md", "md", setmd, 1.863, 1.875) f2 = RooRealVar("f2", "f2", fa) f3 = RooRealVar("f3", "f3", fb) al23 = RooArgList(f2, f3) f1 = RooFormulaVar("f1", "f1", "1.0-f2-f3", al23) # Construct signal shape fcn1_1 = RooDLineShape("DLineshape1_1", "DLineShape1_1", 4, mbc, ebeam, mres, gamma, r, sigmaE, sigmap1, md, res) fcn1_2 = RooDLineShape("DLineshape1_2", "DLineShape1_2", 4, mbc, ebeam, mres, gamma, r, sigmaE, sigmap2, md, res) fcn1_3 = RooDLineShape("DLineshape1_3", "DLineShape1_3", 4, mbc, ebeam, mres, gamma, r, sigmaE, sigmap3, md, res) fcn2_1 = RooDLineShape("DLineshape2_1", "DLineShape2_1", 4, mbc, ebeam, mres, gamma, r, sigmaE, sigmap1, md, res) fcn2_2 = RooDLineShape("DLineshape2_2", "DLineShape2_2", 4, mbc, ebeam, mres, gamma, r, sigmaE, sigmap2, md, res) fcn2_3 = RooDLineShape("DLineshape2_3", "DLineShape2_3", 4, mbc, ebeam, mres, gamma, r, sigmaE, sigmap3, md, res) alf1_123 = RooArgList(fcn1_1, fcn1_2, fcn1_3) af12 = RooArgList(f1, f2) signal1_3 = RooAddPdf("signal1_3", "signal1_3", alf1_123, af12) alf2_123 = RooArgList(fcn2_1, fcn2_2, fcn2_3) signal2_3 = RooAddPdf("signal2_3", "signal2_3", alf2_123, af12) p = RooRealVar("p", "p", setp, 0.1, 1.5) xi = RooRealVar("xi", "xi", setxi, -100.0, -0.1) Bkgd1 = RooArgusBG("argus1", "argus1", mbc, ebeam, xi, p) Bkgd2 = RooArgusBG("argus2", "argus2", mbc, ebeam, xi, p) shapes1 = RooArgList(signal1_3) shapes1.add(signal1_3) shapes1.add(Bkgd1) shapes2 = RooArgList(signal2_3) shapes2.add(signal2_3) shapes2.add(Bkgd2) N1 = RooRealVar("N1", "N1", setN1, 0.0, 200000000.0) N2 = RooRealVar("N2", "N2", setN2, 0.0, 200000000.0) Nbkgd1 = RooRealVar("Nbkgd1", "Nbkgd1", setNbkgd1, 0.0, 200000000.0) Nbkgd2 = RooRealVar("Nbkgd2", "Nbkgd2", setNbkgd2, 0.0, 200000000.0) yields1 = RooArgList(N1) yields1.add(N1) yields1.add(Nbkgd1) yields2 = RooArgList(N2) yields2.add(N2) yields2.add(Nbkgd2) totalPdf1 = RooAddPdf("totalPdf1", "totalPdf1", shapes1, yields1) totalPdf2 = RooAddPdf("totalPdf2", "totalPdf2", shapes2, yields2) totalPdf = RooSimultaneous("totalPdf", "totalPdf", dflav) totalPdf.addPdf(totalPdf1, "dflav") totalPdf.addPdf(totalPdf2, "dbarflav") # Check fitTo options at: # http://root.cern.ch/root/html512/RooAbsPdf.html#RooAbsPdf:fitTo # # Available fit options: # "m" = MIGRAD only, i.e. no MINOS # "s" = estimate step size with HESSE before starting MIGRAD # "h" = run HESSE after MIGRAD # "e" = Perform extended MLL fit # "0" = Run MIGRAD with strategy MINUIT 0 # (no correlation matrix calculation at end) # Does not apply to HESSE or MINOS, if run afterwards. # "q" = Switch off verbose mode # "l" = Save log file with parameter values at each MINUIT step # "v" = Show changed parameters at each MINUIT step # "t" = Time fit # "r" = Save fit output in RooFitResult object # Available optimizer options # "c" = Cache and precalculate components of PDF that exclusively # depend on constant parameters # "2" = Do NLL calculation in multi-processor mode on 2 processors # "3" = Do NLL calculation in multi-processor mode on 3 processors # "4" = Do NLL calculation in multi-processor mode on 4 processors MINUIT = 'ermh4' if err_type == 'ASYM': MINUIT = 'erh4' if test: sys.stdout.write('Will save epsfile as: %s \n' % epsfile) sys.stdout.write('Will save txtfile as: %s \n' % txtfile) return if dataset.numEntries() == 0: N1.setVal(0) N2.setVal(0) else: # Start Fitting fitres = totalPdf.fitTo(dataset, MINUIT) fitres.Print('v') # Save plots canvas = TCanvas('canvas', 'mbc', 1200, 400) canvas.Divide(3, 1) canvas_1 = canvas.GetListOfPrimitives().FindObject('canvas_1') canvas_2 = canvas.GetListOfPrimitives().FindObject('canvas_2') canvas_1.SetLogy(1) canvas_2.SetLogy(1) LineColorRed = RooFit.LineColor(kRed) LineColorBlue = RooFit.LineColor(kBlue) LineWidth = RooFit.LineWidth(1) #0.6) # Plot the D canvas.cd(1) mbcFrame = mbc.frame() mbcFrame = mbc.frame(60) dflav.setLabel('dflav') ebas = RooArgSet(ebeam, dflav) ebeamdata = RooDataHist("ebeamdata", "ebeamdata", ebas, dataset) dataset.plotOn(mbcFrame, RooFit.Cut("dflav==dflav::dflav")) mbcFrame.getAttMarker().SetMarkerSize(0.6) mbcFrame.Draw() Slice = RooFit.Slice(dflav) ProjWData = RooFit.ProjWData(ebas, ebeamdata) totalPdf.plotOn(mbcFrame, LineColorRed, LineWidth, Slice, ProjWData) chisq1 = mbcFrame.chiSquare() * mbcFrame.GetNbinsX() mbcFrame.Draw() as_bkg1 = RooArgSet(Bkgd1) cp_bkg1 = RooFit.Components(as_bkg1) totalPdf.plotOn(mbcFrame, cp_bkg1, Slice, LineColorBlue, LineWidth, ProjWData) mbcFrame.SetTitle(title1) mbcFrame.SetMinimum(ymin) mbcFrame.Draw() # Plot the D bar canvas.cd(2) mbcFrame = mbc.frame() mbcFrame = mbc.frame(60) dflav.setLabel('dbarflav') ebas = RooArgSet(ebeam, dflav) ebeamdata = RooDataHist("ebeamdata", "ebeamdata", ebas, dataset) dataset.plotOn(mbcFrame, RooFit.Cut("dflav==dflav::dbarflav")) mbcFrame.getAttMarker().SetMarkerSize(0.6) mbcFrame.Draw() Slice = RooFit.Slice(dflav) ProjWData = RooFit.ProjWData(ebas, ebeamdata) totalPdf.plotOn(mbcFrame, LineColorRed, LineWidth, Slice, ProjWData) chisq2 = mbcFrame.chiSquare() * mbcFrame.GetNbinsX() mbcFrame.Draw() as_bkg2 = RooArgSet(Bkgd2) cp_bkg2 = RooFit.Components(as_bkg2) totalPdf.plotOn(mbcFrame, cp_bkg2, Slice, LineColorBlue, LineWidth, ProjWData) mbcFrame.SetTitle(title2) mbcFrame.SetMinimum(ymin) mbcFrame.Draw() # Plot Statistics Box canvas.cd(3) mbcFrame = mbc.frame() paramWin1 = totalPdf.paramOn(mbcFrame, dataset, "", 2, "NELU", 0.1, 0.9, 0.9) mbcFrame.GetXaxis().SetLabelSize(0) mbcFrame.GetXaxis().SetTickLength(0) mbcFrame.GetXaxis().SetLabelSize(0) mbcFrame.GetXaxis().SetTitle("") mbcFrame.GetXaxis().CenterTitle() mbcFrame.GetYaxis().SetLabelSize(0) mbcFrame.GetYaxis().SetTitleSize(0.03) mbcFrame.GetYaxis().SetTickLength(0) paramWin1.getAttText().SetTextSize(0.06) mbcFrame.Draw() mbcFrame.SetTitle("Fit Parameters") ATextBox = TPaveText(.1, .1, .8, .2, "BRNDC") tempString = "#chi^{2}_{1} = %.1f, #chi^{2}_{2} = %.1f" % (chisq1, chisq2) ATextBox.AddText(tempString) ATextBox.SetFillColor(0) ATextBox.SetBorderSize(1) mbcFrame.addObject(ATextBox) mbcFrame.Draw() canvas.Print(epsfile) rootfile = epsfile.replace('.eps', '.root') canvas.Print(rootfile) # Save fitting parameters pars = [N1, N2, Nbkgd1, Nbkgd2, md, p, sigmap1, xi] save_fit_result(pars, txtfile, err_type=err_type, verbose=1)
] if pdfConfig['parameterizeKKMass'] : numKKMassBins = pdfBuild['KKMassBinning'].numBins() if pdfConfig['parameterizeKKMass'] == 'functions'\ else pdfBuild['KKMassCat'].numTypes() for bin in range( numKKMassBins ) : ampPhys += [ RooRealVar( 'f_S_phys_bin%d' % bin, 'f_S_phys_bin%d' % bin, f_S, 0., 1. ) # 4 + 2*bin , RooRealVar( 'ASPhase_phys_bin%d' % bin, 'ASPhase_phys_bin%d' % bin, deltaS, -2. * pi, 2. * pi ) # 5 + 2*bin ] else : ampPhys += [ RooRealVar( 'f_S_phys', 'f_S_phys', f_S, 0., 1. ) # 4 , RooRealVar( 'ASPhase_phys', 'ASPhase_phys', deltaS, -2. * pi, 2. * pi ) # 5 ] ampPhysList = RooArgList() for amp in ampPhys : ampPhysList.add(amp) # names of parameters in likelihood fit ampMeasNames = [ 'AparMag2' # 0 , 'ReApar' # 1 , 'ImApar' # 2 , 'AperpMag2' # 3 , 'AperpPhase' # 4 ] if pdfConfig['parameterizeKKMass'] : for bin in range( numKKMassBins ) : ampMeasNames += [ 'ASOddMag2_bin%d' % bin # 5 + 2 * bin , 'ASOddPhase_bin%d' % bin # 6 + 2 * bin ] else :
def mbc_single_3s(evtfile, mc, setMres, setGamma, setR, sp1, sp2, sp3, fa, fb, setmd, setp, setxi, setN1, setN2, setNbkgd1, setNbkgd2, title1, title2, epsfile, txtfile, ymin=0.5, cuts=None, err_type='SYMM', test=False): from ROOT import (gROOT, RooRealVar, RooCategory, RooArgSet, RooDataSet, RooFit, RooGaussian, RooArgList, RooAddPdf, RooSimultaneous, RooArgusBG, RooFormulaVar, RooDLineShape, RooAbsData, RooDataHist, TCanvas, kRed, kBlue, kGreen, kMagenta, TPaveText) set_root_style(stat=1, grid=0) # // sp1 = sigma of signal # // sp2 = ratio of sigmas betwwen sigma2 sigma 1 # // sp3 = ratio of sigmas betwwen sigma3 sigma 2 # // fa, fb, - fractions # // xi_side - slope of argus # // p_side - power of argus # mc = 1 Monte Carlo Model: EvtGenModels/Class/EvtVPHOtoVISR.cc # mc = 3 Data Model: with BES 2007 paper (BES2006 lineshape hepex/0612056) mbc = RooRealVar('mbc', 'Beam constrained mass', 1.83, 1.89, 'GeV') ebeam = RooRealVar('ebeam', 'Ebeam', 1.8815, 1.892, 'GeV') dflav = RooCategory('dflav','D flavor') dflav.defineType('dflav', 1) dflav.defineType('dbarflav', -1) if cuts != None: if 'kkmass' in cuts: kkmass = RooRealVar('kkmass', 'KK invariant mass', 0.97, 1.90, 'GeV') ras = RooArgSet(mbc, ebeam, kkmass, dflav) dataset = RooDataSet.read(evtfile, ras) elif 'kpimass' in cuts: kpimass = RooRealVar('kpimass', 'Kpi invariant mass', 0.6, 1.4, 'GeV') ras = RooArgSet(mbc, ebeam, kpimass, dflav) dataset = RooDataSet.read(evtfile, ras) else: raise NameError(cuts) sys.stdout.write('Using cuts: %s...' %cuts) dataset = dataset.reduce(cuts) sys.stdout.write(' selected %s events.\n' % dataset.numEntries()) else: ras = RooArgSet(mbc, ebeam, dflav) dataset = RooDataSet.read(evtfile, ras) res = RooRealVar("datares", "datares", mc) mres = RooRealVar("mres","mres", setMres) gamma = RooRealVar('gamma', 'gamma', setGamma) r = RooRealVar('r', 'r', setR) sigmaE = RooRealVar("sigmaE","sigmaE", 0.0021) sigmap1 = RooRealVar("sigmap1","sigmap1", sp1, 0.002, 0.040) scalep2 = RooRealVar("scalep2","scalep2",2.00,1.500,5.500) scalep3 = RooRealVar("scalep3","scalep3",5.00,3.00,10.000) scalep2.setVal(sp2) scalep2.setConstant(1) scalep3.setVal(sp3) scalep3.setConstant(1) as12 = RooArgList(sigmap1,scalep2) sigmap2 = RooFormulaVar("sigmap2","sigma2","sigmap1*scalep2", as12) as123 = RooArgList(sigmap1,scalep2,scalep3) sigmap3 = RooFormulaVar("sigmap3","sigma3","sigmap1*scalep2*scalep3", as123) md = RooRealVar("md","md", setmd,1.863,1.875) f2 = RooRealVar("f2","f2", fa) f3 = RooRealVar("f3","f3", fb) al23 = RooArgList(f2,f3) f1 = RooFormulaVar("f1","f1","1.0-f2-f3", al23) # Construct signal shape fcn1_1 = RooDLineShape("DLineshape1_1","DLineShape1_1",4,mbc,ebeam, mres,gamma,r,sigmaE,sigmap1,md,res) fcn1_2 = RooDLineShape("DLineshape1_2","DLineShape1_2",4,mbc,ebeam, mres,gamma,r,sigmaE,sigmap2,md,res) fcn1_3 = RooDLineShape("DLineshape1_3","DLineShape1_3",4,mbc,ebeam, mres,gamma,r,sigmaE,sigmap3,md,res) fcn2_1 = RooDLineShape("DLineshape2_1","DLineShape2_1",4,mbc,ebeam, mres,gamma,r,sigmaE,sigmap1,md,res) fcn2_2 = RooDLineShape("DLineshape2_2","DLineShape2_2",4,mbc,ebeam, mres,gamma,r,sigmaE,sigmap2,md,res) fcn2_3 = RooDLineShape("DLineshape2_3","DLineShape2_3",4,mbc,ebeam, mres,gamma,r,sigmaE,sigmap3,md,res) alf1_123 = RooArgList(fcn1_1,fcn1_2,fcn1_3) af12 = RooArgList(f1,f2) signal1_3 = RooAddPdf("signal1_3","signal1_3", alf1_123, af12) alf2_123 = RooArgList(fcn2_1,fcn2_2,fcn2_3) signal2_3 = RooAddPdf("signal2_3","signal2_3", alf2_123, af12) p = RooRealVar("p","p", setp, 0.1, 1.5) xi= RooRealVar("xi","xi",setxi,-100.0,-0.1) Bkgd1 = RooArgusBG("argus1","argus1",mbc,ebeam,xi,p) Bkgd2 = RooArgusBG("argus2","argus2",mbc,ebeam,xi,p) shapes1 = RooArgList(signal1_3) shapes1.add(signal1_3) shapes1.add(Bkgd1) shapes2 = RooArgList(signal2_3) shapes2.add(signal2_3) shapes2.add(Bkgd2) N1 = RooRealVar("N1","N1",setN1,0.0,200000000.0) N2 = RooRealVar("N2","N2",setN2,0.0,200000000.0) Nbkgd1 = RooRealVar("Nbkgd1","Nbkgd1",setNbkgd1, 0.0, 200000000.0) Nbkgd2 = RooRealVar("Nbkgd2","Nbkgd2",setNbkgd2, 0.0, 200000000.0) yields1 = RooArgList(N1) yields1.add(N1) yields1.add(Nbkgd1) yields2 = RooArgList(N2) yields2.add(N2) yields2.add(Nbkgd2) totalPdf1 = RooAddPdf("totalPdf1","totalPdf1", shapes1,yields1) totalPdf2 = RooAddPdf("totalPdf2","totalPdf2", shapes2,yields2) totalPdf = RooSimultaneous("totalPdf","totalPdf",dflav) totalPdf.addPdf(totalPdf1,"dflav") totalPdf.addPdf(totalPdf2,"dbarflav") # Check fitTo options at: # http://root.cern.ch/root/html512/RooAbsPdf.html#RooAbsPdf:fitTo # # Available fit options: # "m" = MIGRAD only, i.e. no MINOS # "s" = estimate step size with HESSE before starting MIGRAD # "h" = run HESSE after MIGRAD # "e" = Perform extended MLL fit # "0" = Run MIGRAD with strategy MINUIT 0 # (no correlation matrix calculation at end) # Does not apply to HESSE or MINOS, if run afterwards. # "q" = Switch off verbose mode # "l" = Save log file with parameter values at each MINUIT step # "v" = Show changed parameters at each MINUIT step # "t" = Time fit # "r" = Save fit output in RooFitResult object # Available optimizer options # "c" = Cache and precalculate components of PDF that exclusively # depend on constant parameters # "2" = Do NLL calculation in multi-processor mode on 2 processors # "3" = Do NLL calculation in multi-processor mode on 3 processors # "4" = Do NLL calculation in multi-processor mode on 4 processors MINUIT = 'ermh4' if err_type == 'ASYM': MINUIT = 'erh4' if test: sys.stdout.write('Will save epsfile as: %s \n' %epsfile) sys.stdout.write('Will save txtfile as: %s \n' %txtfile) return if dataset.numEntries() == 0: N1.setVal(0) N2.setVal(0) else: # Start Fitting fitres = totalPdf.fitTo(dataset, MINUIT) fitres.Print('v') # Save plots canvas = TCanvas('canvas','mbc', 1200, 400); canvas.Divide(3,1) canvas_1 = canvas.GetListOfPrimitives().FindObject('canvas_1') canvas_2 = canvas.GetListOfPrimitives().FindObject('canvas_2') canvas_1.SetLogy(1) canvas_2.SetLogy(1) LineColorRed = RooFit.LineColor(kRed) LineColorBlue = RooFit.LineColor(kBlue) LineWidth = RooFit.LineWidth(1) #0.6) # Plot the D canvas.cd(1) mbcFrame=mbc.frame() mbcFrame=mbc.frame(60) dflav.setLabel('dflav') ebas = RooArgSet(ebeam, dflav) ebeamdata = RooDataHist("ebeamdata", "ebeamdata", ebas, dataset) dataset.plotOn(mbcFrame, RooFit.Cut("dflav==dflav::dflav")) mbcFrame.getAttMarker().SetMarkerSize(0.6) mbcFrame.Draw() Slice = RooFit.Slice(dflav) ProjWData = RooFit.ProjWData(ebas, ebeamdata) totalPdf.plotOn(mbcFrame, LineColorRed, LineWidth, Slice, ProjWData) chisq1 = mbcFrame.chiSquare()*mbcFrame.GetNbinsX() mbcFrame.Draw() as_bkg1 = RooArgSet(Bkgd1) cp_bkg1 = RooFit.Components(as_bkg1) totalPdf.plotOn(mbcFrame, cp_bkg1, Slice, LineColorBlue, LineWidth, ProjWData) mbcFrame.SetTitle(title1) mbcFrame.SetMinimum(ymin) mbcFrame.Draw() # Plot the D bar canvas.cd(2) mbcFrame=mbc.frame() mbcFrame=mbc.frame(60) dflav.setLabel('dbarflav') ebas = RooArgSet(ebeam, dflav) ebeamdata = RooDataHist("ebeamdata", "ebeamdata", ebas, dataset) dataset.plotOn(mbcFrame, RooFit.Cut("dflav==dflav::dbarflav")) mbcFrame.getAttMarker().SetMarkerSize(0.6) mbcFrame.Draw() Slice = RooFit.Slice(dflav) ProjWData = RooFit.ProjWData(ebas, ebeamdata) totalPdf.plotOn(mbcFrame, LineColorRed, LineWidth, Slice, ProjWData) chisq2 = mbcFrame.chiSquare()*mbcFrame.GetNbinsX() mbcFrame.Draw() as_bkg2 = RooArgSet(Bkgd2) cp_bkg2 = RooFit.Components(as_bkg2) totalPdf.plotOn(mbcFrame, cp_bkg2, Slice, LineColorBlue, LineWidth, ProjWData) mbcFrame.SetTitle(title2) mbcFrame.SetMinimum(ymin) mbcFrame.Draw() # Plot Statistics Box canvas.cd(3) mbcFrame = mbc.frame() paramWin1 = totalPdf.paramOn(mbcFrame,dataset, "",2,"NELU",0.1,0.9,0.9) mbcFrame.GetXaxis().SetLabelSize(0) mbcFrame.GetXaxis().SetTickLength(0) mbcFrame.GetXaxis().SetLabelSize(0) mbcFrame.GetXaxis().SetTitle("") mbcFrame.GetXaxis().CenterTitle() mbcFrame.GetYaxis().SetLabelSize(0) mbcFrame.GetYaxis().SetTitleSize(0.03) mbcFrame.GetYaxis().SetTickLength(0) paramWin1.getAttText().SetTextSize(0.06) mbcFrame.Draw() mbcFrame.SetTitle("Fit Parameters") ATextBox = TPaveText(.1, .1, .8, .2,"BRNDC") tempString = "#chi^{2}_{1} = %.1f, #chi^{2}_{2} = %.1f" % (chisq1,chisq2) ATextBox.AddText(tempString) ATextBox.SetFillColor(0) ATextBox.SetBorderSize(1) mbcFrame.addObject(ATextBox) mbcFrame.Draw() canvas.Print(epsfile) rootfile = epsfile.replace('.eps', '.root') canvas.Print(rootfile) # Save fitting parameters pars = [N1, N2, Nbkgd1, Nbkgd2, md, p, sigmap1, xi] save_fit_result(pars, txtfile, err_type=err_type, verbose=1)
knotbinning = RooBinning(time.getMin(), time.getMax(), '{}_knotbinning'.format(mode)) for v in spline_knots: knotbinning.addBoundary(v) knotbinning.removeBoundary(time.getMin()) knotbinning.removeBoundary(time.getMax()) oldbinning, lo, hi = time.getBinning(), time.getMin(), time.getMax() time.setBinning(knotbinning, '{}_knotbinning'.format(mode)) time.setBinning(oldbinning) time.setRange(lo, hi) del knotbinning, oldbinning, lo, hi # knot coefficients coefflist = RooArgList() for i, v in enumerate(spline_coeffs): coefflist.add(const(v)) i = len(spline_coeffs) coefflist.add(one) spline_knots.append(time.getMax()) spline_knots.reverse() fudge = (spline_knots[0] - spline_knots[1]) / (spline_knots[2] - spline_knots[1]) lastmycoeffs = RooArgList() lastmycoeffs.add(const(1. - fudge)) lastmycoeffs.add(const(fudge)) polyvar = RooPolyVar('{}_SplineAccCoeff{}'.format(mode, i), '', coefflist.at(coefflist.getSize() - 2), lastmycoeffs) coefflist.add(polyvar) del i # create the spline itself tacc = RooCubicSplineFun('{}_SplineAcceptance'.format(mode), '', time,
def buildPolarizationPDF(ws,options): foldname = '' if not options.folded: foldname='' accMaps = TFile.Open(options.acceptanceMap) #effMaps = TFile.Open(options.efficiencyMap) ws.factory('lambda_theta_'+options.fitFrame+'_p[0,-1,1]') ws.factory('lambda_phi_'+options.fitFrame+'_p[0,-1,1]') ws.factory('lambda_thetaphi_'+options.fitFrame+'_p[0,-1,1]') ws.factory('lambda_theta_'+options.fitFrame+'_np[0,-1,1]') ws.factory('lambda_phi_'+options.fitFrame+'_np[0,-1,1]') ws.factory('lambda_thetaphi_'+options.fitFrame+'_np[0,-1,1]') ws.factory('nPromptinP[500,0,1000000]') ws.factory('sum::nPromptinNP(1*nPromptSignal,-1*nPromptinP)') ws.factory('nNonPromptinNP[100,0,1000000]') ws.factory('sum::nNonPromptinP(1*nNonPromptSignal,-1*nNonPromptinNP)') ws.factory('nBackgroundinP[50,0,1000000]') ws.factory('sum::nBackgroundinNP(1*nBackgroundSignal,-1*nBackgroundinP)') ws.factory('RooPolarizationConstraint::promptConstr('+ 'lambda_theta_'+options.fitFrame+'_p,'+ 'lambda_phi_'+options.fitFrame+'_p,'+ 'lambda_thetaphi_'+options.fitFrame+'_p)') ws.factory('RooPolarizationConstraint::nonPromptConstr('+ 'lambda_theta_'+options.fitFrame+'_np,'+ 'lambda_phi_'+options.fitFrame+'_np,'+ 'lambda_thetaphi_'+options.fitFrame+'_np)') #for each rap/pt cell make a unique simultaneous fit of prompt,non-prompt, background for rap_bin in range(1,len(jpsi.pTRange)): for pt_bin in range(len(jpsi.pTRange[rap_bin])): accMapHist = accMaps.Get('hAcc2D_'+options.fitFrame+'_pT'+str(pt_bin+1)+'_rap'+str(rap_bin)) for effMap in options.efficiencyMap.split(','): effMaps = TFile.Open(effMap) effMapHist = effMaps.Get('hAcc2D_'+options.fitFrame+'_pT'+str(pt_bin+1)+'_rap'+str(rap_bin)) accMapHist.Multiply(effMapHist) effMaps.Close() getattr(ws,'import')(accMapHist) accMap = RooDataHist('accMap'+options.fitFrame+'Data_'+str(rap_bin)+'_'+str(pt_bin+1), 'acceptance map', RooArgList(ws.var('costh_'+options.fitFrame+foldname),ws.var('phi_'+options.fitFrame+foldname)), ROOT.RooFit.Import(accMapHist,False)) getattr(ws,'import')(accMap) accMapFunc = RooHistFunc('accMapFunc'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1), 'acceptance map', RooArgSet(ws.var('costh_'+options.fitFrame+foldname),ws.var('phi_'+options.fitFrame+foldname)), ws.data('accMap'+options.fitFrame+'Data_'+str(rap_bin)+'_'+str(pt_bin+1)),1) getattr(ws,'import')(accMapFunc) #make a *real* hist pdf :-) ws.factory('RooGenericPdf::accMap'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+ '("@0",{accMapFunc'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+'})') #create datahist for L and R sidebands getattr(ws,'import')(accMap.Clone('bkgShape'+options.fitFrame+'DataL_'+str(rap_bin)+'_'+str(pt_bin+1))) getattr(ws,'import')(accMap.Clone('bkgShape'+options.fitFrame+'DataR_'+str(rap_bin)+'_'+str(pt_bin+1))) ws.data('bkgShape'+options.fitFrame+'DataL_'+str(rap_bin)+'_'+str(pt_bin+1)).reset() ws.data('bkgShape'+options.fitFrame+'DataR_'+str(rap_bin)+'_'+str(pt_bin+1)).reset() #fill them ws.data('bkgShape'+options.fitFrame+'DataL_'+str(rap_bin)+'_'+str(pt_bin+1)).add(ws.data('data_rap'+str(rap_bin)+'_pt'+str(pt_bin+1)), 'massRegion == massRegion::leftMassSideBand') ws.data('bkgShape'+options.fitFrame+'DataR_'+str(rap_bin)+'_'+str(pt_bin+1)).add(ws.data('data_rap'+str(rap_bin)+'_pt'+str(pt_bin+1)), 'massRegion == massRegion::rightMassSideBand') #make histpdfs and combination ws.factory('RooHistPdf::bkgShape'+options.fitFrame+'L_'+str(rap_bin)+'_'+str(pt_bin+1)+ '({costh_'+options.fitFrame+foldname+',phi_'+options.fitFrame+foldname+'},'+ 'bkgShape'+options.fitFrame+'DataL_'+str(rap_bin)+'_'+str(pt_bin+1)+')') ws.factory('RooHistPdf::bkgShape'+options.fitFrame+'R_'+str(rap_bin)+'_'+str(pt_bin+1)+ '({costh_'+options.fitFrame+foldname+',phi_'+options.fitFrame+foldname+'},'+ 'bkgShape'+options.fitFrame+'DataR_'+str(rap_bin)+'_'+str(pt_bin+1)+')') ws.factory('SUM::bkgShape'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+ '(fBkgLR*bkgShape'+options.fitFrame+'L_'+str(rap_bin)+'_'+str(pt_bin+1)+ ',bkgShape'+options.fitFrame+'R_'+str(rap_bin)+'_'+str(pt_bin+1)+')') #test new polarization pdf ws.factory('RooPolarizationPdf::basePolPdf'+options.fitFrame+'Prompt_'+str(rap_bin)+'_'+str(pt_bin+1)+ '(costh_'+options.fitFrame+foldname+',phi_'+options.fitFrame+foldname+ ',lambda_theta_'+options.fitFrame+'_p,lambda_phi_'+options.fitFrame+'_p,lambda_thetaphi_'+options.fitFrame+'_p)') ws.factory('RooPolarizationPdf::basePolPdf'+options.fitFrame+'NonPrompt_'+str(rap_bin)+'_'+str(pt_bin+1)+ '(costh_'+options.fitFrame+foldname+',phi_'+options.fitFrame+foldname+ ',lambda_theta_'+options.fitFrame+'_np,lambda_phi_'+options.fitFrame+'_np,lambda_thetaphi_'+options.fitFrame+'_np)') #should add back *(3+@2) ? #sin(2theta) = 2sin(theta)cos(theta) = 2*sqrt(1 - cos(theta)*cos(theta))*cos(theta) #ws.factory('RooGenericPdf::basePolPdf'+options.fitFrame+'Prompt_'+str(rap_bin)+'_'+str(pt_bin+1)+ # '("1+@2*pow(@0,2.)+@3*(1-pow(@0,2.))*cos(2*@1*pi/180)+@4*sin(2*acos(@0))*cos(@1*pi/180)"'+ # ',{costh_'+options.fitFrame+foldname+',phi_'+options.fitFrame+foldname+',lambda_theta_'+options.fitFrame+ # '_p,lambda_phi_'+options.fitFrame+'_p,lambda_thetaphi_'+options.fitFrame+'_p})') #ws.factory('RooGenericPdf::basePolPdf'+options.fitFrame+'NonPrompt_'+str(rap_bin)+'_'+str(pt_bin+1)+ # '("1+@2*@0*@0+@3*(1-@0*@0)*cos(2*@1*pi/180)+@4*sin(2*acos(@0))*cos(@1*pi/180)"'+ # ',{costh_'+options.fitFrame+foldname+',phi_'+options.fitFrame+foldname+',lambda_theta_'+options.fitFrame+ # '_np,lambda_phi_'+options.fitFrame+'_np,lambda_thetaphi_'+options.fitFrame+'_np})') ws.factory('PROD::polPdf'+options.fitFrame+'Prompt_'+str(rap_bin)+'_'+str(pt_bin+1) +'(basePolPdf'+options.fitFrame+'Prompt_'+str(rap_bin)+'_'+str(pt_bin+1) +',accMap'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+')') ws.factory('PROD::polPdf'+options.fitFrame+'NonPrompt_'+str(rap_bin)+'_'+str(pt_bin+1) +'(basePolPdf'+options.fitFrame+'NonPrompt_'+str(rap_bin)+'_'+str(pt_bin+1) +',accMap'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+')') ws.factory('RooExtendPdf::promptPolExtinP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+ '(polPdf'+options.fitFrame+'Prompt_'+str(rap_bin)+'_'+str(pt_bin+1)+',nPromptinP)') ws.factory('RooExtendPdf::promptPolExtinNP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+ '(polPdf'+options.fitFrame+'Prompt_'+str(rap_bin)+'_'+str(pt_bin+1)+',nPromptinNP)') ws.factory('RooExtendPdf::nonPromptPolExtinNP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+ '(polPdf'+options.fitFrame+'NonPrompt_'+str(rap_bin)+'_'+str(pt_bin+1)+',nNonPromptinNP)') ws.factory('RooExtendPdf::nonPromptPolExtinP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+ '(polPdf'+options.fitFrame+'NonPrompt_'+str(rap_bin)+'_'+str(pt_bin+1)+',nNonPromptinP)') ws.factory('RooExtendPdf::bkgPolExtinP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+ '(bkgShape'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+',nBackgroundinP)') ws.factory('RooExtendPdf::bkgPolExtinNP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+ '(bkgShape'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+',nBackgroundinNP)') promptPOLArgList = RooArgList(ws.pdf('promptPolExtinP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1))) nonPromptPOLArgList = RooArgList(ws.pdf('promptPolExtinNP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)), ws.pdf('nonPromptPolExtinNP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)) ) if options.doNonPrompt: promptPOLArgList.add(ws.pdf('nonPromptPolExtinP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1))) if options.doBackground: promptPOLArgList.add(ws.pdf('bkgPolExtinP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1))) nonPromptPOLArgList.add(ws.pdf('bkgPolExtinNP'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1))) promptP = RooAddPdf('promptPol'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1), 'prompt', promptPOLArgList ) nonpromptP = RooAddPdf('nonpromptPol'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1), 'nonprompt', nonPromptPOLArgList ) getattr(ws,'import')(promptP) getattr(ws,'import')(nonpromptP) polConfig = 'SIMUL::PPdf'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+'(mlRegion,' if options.doPrompt: polConfig += 'promptSignal=promptPol'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+',' if options.doNonPrompt: polConfig += 'nonPromptSignal=nonpromptPol'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+',' #if options.doBackground: # polConfig += ('prompt;leftMassSideBand=bkgPolExtL'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+',' # 'prompt;rightMassSideBand=bkgPolExtR'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)) # polConfig += ('nonPrompt;leftMassSideBand=bkgPolExtL'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)+',' # 'nonPrompt;rightMassSideBand=bkgPolExtR'+options.fitFrame+'_'+str(rap_bin)+'_'+str(pt_bin+1)) polConfig += ')' #simultaneous ws.factory(polConfig) accMaps.Close()
def findOnePe(hist, ws, name='x', Npe=1): fitPed(hist, ws, name) x = ws.var(name) ped = ws.pdf('ped') pedWidth = ws.var('pedWidth') pdfs = RooArgList(ped) pdfList = [] fped = RooRealVar('fped', 'f_{ped}', 0.8, 0., 1.) fractions = RooArgList(fped) fList = [] peList = [] peMean = RooRealVar('peMean', 'mean_{pe}', 6., 0., 20.) peWidth = RooRealVar('peWidth', 'width_{pe}', pedWidth.getVal(), 0., 10.) for i in range(0, Npe): pem = RooFormulaVar('pem{0}'.format(i + 1), '@0+{0}*@1'.format(i + 1), RooArgList(ws.var('pedMean'), peMean)) peList.append(pem) npepdf = RooGaussian('pe{0}pdf'.format(i + 1), 'pe{0}pdf'.format(i + 1), x, pem, pedWidth) pdfs.add(npepdf) pdfList.append(npepdf) fnpe = RooRealVar('fpe{0}'.format(i + 1), 'fpe{0}'.format(i + 1), 0.5, -0.1, 1.0) fractions.add(fnpe) fList.append(fnpe) #bgMean = RooRealVar("bgMean", "bgMean", 6.0, x.getMin(), x.getMax()) bgScale = RooRealVar("bgScale", "bgScale", 0.5, -1.0, Npe + 1.0) bgMean = RooFormulaVar("bgMean", "@1+@0*@2", RooArgList(peMean, ws.var('pedMean'), bgScale)) bgWidthL = RooRealVar("bgWidthL", "bgWidthL", pedWidth.getVal() * 2, 0., 25.) bgWidthR = RooRealVar("bgWidthR", "bgWidthR", pedWidth.getVal() * 7, 0., 25.) bgGauss = RooBifurGauss("bgGauss", "bgGauss", x, bgMean, bgWidthR, bgWidthR) if (Npe > 1): pdfs.add(bgGauss) else: fractions.remove(fractions.at(fractions.getSize() - 1)) ## pem = RooFormulaVar('pem', '@0+@1', RooArgList(peMean, ws.var('pedMean'))) ## firstPe = RooGaussian('firstPe', 'firstPe', x, pem, peWidth) ## pdfs.Print("v") ## fractions.Print("v") pedPlusOne = RooAddPdf('pedPlusOne', 'pedPlusOne', pdfs, fractions, True) ## pedWidth = ped.GetParameter(2) ## pedMean = ped.GetParameter(1) ## pedA = ped.GetParameter(0) secondMax = hist.GetMaximumBin() + 1 goingDown = True maxVal = hist.GetBinContent(secondMax) foundMax = False while (not foundMax) and (secondMax < hist.GetNbinsX()): tmpVal = hist.GetBinContent(secondMax + 1) if (tmpVal < maxVal): if not goingDown: foundMax = True else: goingDown = True maxVal = tmpVal secondMax += 1 elif (tmpVal > maxVal): goingDown = False maxVal = tmpVal secondMax += 1 else: maxVal = tmpVal secondMax += 1 secondMaxx = hist.GetBinCenter(secondMax) print 'found 2nd maximum in bin', secondMax, 'value', secondMaxx ## peMean.setVal(secondMaxx) ## bgMean.setVal(secondMaxx*0.6) x.setRange('pedPlus_fit', x.getMin(), ws.var('pedMean').getVal() + pedWidth.getVal() * 6. * (Npe + 0)) pedPlusOne.fitTo(ws.data('ds'), RooFit.Minos(False), RooFit.Range('pedPlus_fit'), RooFit.PrintLevel(1)) getattr(ws, 'import')(pedPlusOne)
def signal(channel, stype): if 'VBF' in channel: stype = 'XZHVBF' else: stype = 'XZH' # HVT model if stype.startswith('X'): signalType = 'HVT' genPoints = [800, 1000, 1200, 1400, 1600, 1800, 2000, 2500, 3000, 3500, 4000, 4500, 5000] massPoints = [x for x in range(800, 5000+1, 100)] interPar = True else: print "Signal type", stype, "not recognized" return n = len(genPoints) category = channel cColor = color[category] if category in color else 1 nElec = channel.count('e') nMuon = channel.count('m') nLept = nElec + nMuon nBtag = channel.count('b') if '0b' in channel: nBtag = 0 X_name = "VH_mass" if not os.path.exists(PLOTDIR+stype+category): os.makedirs(PLOTDIR+stype+category) #*******************************************************# # # # Variables and selections # # # #*******************************************************# X_mass = RooRealVar( "X_mass", "m_{ZH}", XBINMIN, XBINMAX, "GeV") J_mass = RooRealVar( "H_mass", "jet mass", LOWMIN, HIGMAX, "GeV") V_mass = RooRealVar( "V_mass", "V jet mass", -9., 1.e6, "GeV") CSV1 = RooRealVar( "H_csv1", "", -999., 2. ) CSV2 = RooRealVar( "H_csv2", "", -999., 2. ) DeepCSV1= RooRealVar( "H_deepcsv1", "", -999., 2. ) DeepCSV2= RooRealVar( "H_deepcsv2", "", -999., 2. ) H_ntag = RooRealVar( "H_ntag", "", -9., 9. ) H_dbt = RooRealVar( "H_dbt", "", -2., 2. ) H_tau21 = RooRealVar( "H_tau21", "", -9., 2. ) H_eta = RooRealVar( "H_eta", "", -9., 9. ) H_tau21_ddt = RooRealVar( "H_ddt", "", -9., 2. ) MaxBTag = RooRealVar( "MaxBTag", "", -10., 2. ) H_chf = RooRealVar( "H_chf", "", -1., 2. ) MinDPhi = RooRealVar( "MinDPhi", "", -1., 99. ) DPhi = RooRealVar( "DPhi", "", -1., 99. ) DEta = RooRealVar( "DEta", "", -1., 99. ) Mu1_relIso = RooRealVar( "Mu1_relIso", "", -1., 99. ) Mu2_relIso = RooRealVar( "Mu2_relIso", "", -1., 99. ) nTaus = RooRealVar( "nTaus", "", -1., 99. ) Vpt = RooRealVar( "V.Pt()", "", -1., 1.e6 ) V_pt = RooRealVar( "V_pt", "", -1., 1.e6 ) H_pt = RooRealVar( "H_pt", "", -1., 1.e6 ) VH_deltaR=RooRealVar( "VH_deltaR", "", -1., 99. ) isZtoNN = RooRealVar( "isZtoNN", "", 0., 2. ) isZtoEE = RooRealVar( "isZtoEE", "", 0., 2. ) isZtoMM = RooRealVar( "isZtoMM", "", 0., 2. ) isHtobb = RooRealVar( "isHtobb", "", 0., 2. ) isVBF = RooRealVar( "isVBF", "", 0., 2. ) isMaxBTag_loose = RooRealVar( "isMaxBTag_loose", "", 0., 2. ) weight = RooRealVar( "eventWeightLumi", "", -1.e9, 1.e9 ) Xmin = XBINMIN Xmax = XBINMAX # Define the RooArgSet which will include all the variables defined before # there is a maximum of 9 variables in the declaration, so the others need to be added with 'add' variables = RooArgSet(X_mass, J_mass, V_mass, CSV1, CSV2, H_ntag, H_dbt, H_tau21) variables.add(RooArgSet(DEta, DPhi, MaxBTag, MinDPhi, nTaus, Vpt)) variables.add(RooArgSet(DeepCSV1, DeepCSV2,VH_deltaR, H_tau21_ddt)) variables.add(RooArgSet(isZtoNN, isZtoEE, isZtoMM, isHtobb, isMaxBTag_loose, weight)) variables.add(RooArgSet(isVBF, Mu1_relIso, Mu2_relIso, H_chf, H_pt, V_pt,H_eta)) #X_mass.setRange("X_extended_range", X_mass.getMin(), X_mass.getMax()) X_mass.setRange("X_reasonable_range", X_mass.getMin(), X_mass.getMax()) X_mass.setRange("X_integration_range", Xmin, Xmax) X_mass.setBins(int((X_mass.getMax() - X_mass.getMin())/100)) binsXmass = RooBinning(int((X_mass.getMax() - X_mass.getMin())/100), X_mass.getMin(), X_mass.getMax()) X_mass.setBinning(binsXmass, "PLOT") massArg = RooArgSet(X_mass) # Cuts SRcut = selection[category]+selection['SR'] print " Cut:\t", SRcut #*******************************************************# # # # Signal fits # # # #*******************************************************# treeSign = {} setSignal = {} vmean = {} vsigma = {} valpha1 = {} vslope1 = {} smean = {} ssigma = {} salpha1 = {} sslope1 = {} salpha2 = {} sslope2 = {} a1 = {} a2 = {} sbrwig = {} signal = {} signalExt = {} signalYield = {} signalIntegral = {} signalNorm = {} signalXS = {} frSignal = {} frSignal1 = {} frSignal2 = {} frSignal3 = {} # Signal shape uncertainties (common amongst all mass points) xmean_fit = RooRealVar("sig_p1_fit", "Variation of the resonance position with the fit uncertainty", 0.005, -1., 1.) smean_fit = RooRealVar("CMSRunII_sig_p1_fit", "Change of the resonance position with the fit uncertainty", 0., -10, 10) xmean_jes = RooRealVar("sig_p1_scale_jes", "Variation of the resonance position with the jet energy scale", 0.010, -1., 1.) #0.001 smean_jes = RooRealVar("CMSRunII_sig_p1_jes", "Change of the resonance position with the jet energy scale", 0., -10, 10) xmean_e = RooRealVar("sig_p1_scale_e", "Variation of the resonance position with the electron energy scale", 0.001, -1., 1.) smean_e = RooRealVar("CMSRunII_sig_p1_scale_e", "Change of the resonance position with the electron energy scale", 0., -10, 10) xmean_m = RooRealVar("sig_p1_scale_m", "Variation of the resonance position with the muon energy scale", 0.001, -1., 1.) smean_m = RooRealVar("CMSRunII_sig_p1_scale_m", "Change of the resonance position with the muon energy scale", 0., -10, 10) xsigma_fit = RooRealVar("sig_p2_fit", "Variation of the resonance width with the fit uncertainty", 0.02, -1., 1.) ssigma_fit = RooRealVar("CMSRunII_sig_p2_fit", "Change of the resonance width with the fit uncertainty", 0., -10, 10) xsigma_jes = RooRealVar("sig_p2_scale_jes", "Variation of the resonance width with the jet energy scale", 0.010, -1., 1.) #0.001 ssigma_jes = RooRealVar("CMSRunII_sig_p2_jes", "Change of the resonance width with the jet energy scale", 0., -10, 10) xsigma_jer = RooRealVar("sig_p2_scale_jer", "Variation of the resonance width with the jet energy resolution", 0.020, -1., 1.) ssigma_jer = RooRealVar("CMSRunII_sig_p2_jer", "Change of the resonance width with the jet energy resolution", 0., -10, 10) xsigma_e = RooRealVar("sig_p2_scale_e", "Variation of the resonance width with the electron energy scale", 0.001, -1., 1.) ssigma_e = RooRealVar("CMSRunII_sig_p2_scale_e", "Change of the resonance width with the electron energy scale", 0., -10, 10) xsigma_m = RooRealVar("sig_p2_scale_m", "Variation of the resonance width with the muon energy scale", 0.040, -1., 1.) ssigma_m = RooRealVar("CMSRunII_sig_p2_scale_m", "Change of the resonance width with the muon energy scale", 0., -10, 10) xalpha1_fit = RooRealVar("sig_p3_fit", "Variation of the resonance alpha with the fit uncertainty", 0.03, -1., 1.) salpha1_fit = RooRealVar("CMSRunII_sig_p3_fit", "Change of the resonance alpha with the fit uncertainty", 0., -10, 10) xslope1_fit = RooRealVar("sig_p4_fit", "Variation of the resonance slope with the fit uncertainty", 0.10, -1., 1.) sslope1_fit = RooRealVar("CMSRunII_sig_p4_fit", "Change of the resonance slope with the fit uncertainty", 0., -10, 10) xmean_fit.setConstant(True) smean_fit.setConstant(True) xmean_jes.setConstant(True) smean_jes.setConstant(True) xmean_e.setConstant(True) smean_e.setConstant(True) xmean_m.setConstant(True) smean_m.setConstant(True) xsigma_fit.setConstant(True) ssigma_fit.setConstant(True) xsigma_jes.setConstant(True) ssigma_jes.setConstant(True) xsigma_jer.setConstant(True) ssigma_jer.setConstant(True) xsigma_e.setConstant(True) ssigma_e.setConstant(True) xsigma_m.setConstant(True) ssigma_m.setConstant(True) xalpha1_fit.setConstant(True) salpha1_fit.setConstant(True) xslope1_fit.setConstant(True) sslope1_fit.setConstant(True) # the alpha method is now done. for m in massPoints: signalString = "M%d" % m signalMass = "%s_M%d" % (stype, m) signalName = "%s%s_M%d" % (stype, category, m) signalColor = sample[signalMass]['linecolor'] if signalName in sample else 1 # define the signal PDF vmean[m] = RooRealVar(signalName + "_vmean", "Crystal Ball mean", m, m*0.5, m*1.25) smean[m] = RooFormulaVar(signalName + "_mean", "@0*(1+@1*@2)*(1+@3*@4)*(1+@5*@6)*(1+@7*@8)", RooArgList(vmean[m], xmean_e, smean_e, xmean_m, smean_m, xmean_jes, smean_jes, xmean_fit, smean_fit)) vsigma[m] = RooRealVar(signalName + "_vsigma", "Crystal Ball sigma", m*0.035, m*0.01, m*0.4) sigmaList = RooArgList(vsigma[m], xsigma_e, ssigma_e, xsigma_m, ssigma_m, xsigma_jes, ssigma_jes, xsigma_jer, ssigma_jer) sigmaList.add(RooArgList(xsigma_fit, ssigma_fit)) ssigma[m] = RooFormulaVar(signalName + "_sigma", "@0*(1+@1*@2)*(1+@3*@4)*(1+@5*@6)*(1+@7*@8)*(1+@9*@10)", sigmaList) valpha1[m] = RooRealVar(signalName + "_valpha1", "Crystal Ball alpha", 1., 0., 5.) # number of sigmas where the exp is attached to the gaussian core. >0 left, <0 right salpha1[m] = RooFormulaVar(signalName + "_alpha1", "@0*(1+@1*@2)", RooArgList(valpha1[m], xalpha1_fit, salpha1_fit)) vslope1[m] = RooRealVar(signalName + "_vslope1", "Crystal Ball slope", 10., 1., 60.) # slope of the power tail #10 1 60 sslope1[m] = RooFormulaVar(signalName + "_slope1", "@0*(1+@1*@2)", RooArgList(vslope1[m], xslope1_fit, sslope1_fit)) salpha2[m] = RooRealVar(signalName + "_alpha2", "Crystal Ball alpha", 2, 1., 5.) # number of sigmas where the exp is attached to the gaussian core. >0 left, <0 right sslope2[m] = RooRealVar(signalName + "_slope2", "Crystal Ball slope", 10, 1.e-1, 115.) # slope of the power tail #define polynomial #a1[m] = RooRealVar(signalName + "_a1", "par 1 for polynomial", m, 0.5*m, 2*m) a1[m] = RooRealVar(signalName + "_a1", "par 1 for polynomial", 0.001*m, 0.0005*m, 0.01*m) a2[m] = RooRealVar(signalName + "_a2", "par 2 for polynomial", 0.05, -1.,1.) #if channel=='nnbbVBF' or channel=='nn0bVBF': # signal[m] = RooPolynomial(signalName,"m_{%s'} = %d GeV" % (stype[1], m) , X_mass, RooArgList(a1[m],a2[m])) #else: # signal[m] = RooCBShape(signalName, "m_{%s'} = %d GeV" % (stype[1], m), X_mass, smean[m], ssigma[m], salpha1[m], sslope1[m]) # Signal name does not have the channel signal[m] = RooCBShape(signalName, "m_{%s'} = %d GeV" % (stype[1], m), X_mass, smean[m], ssigma[m], salpha1[m], sslope1[m]) # Signal name does not have the channel # extend the PDF with the yield to perform an extended likelihood fit signalYield[m] = RooRealVar(signalName+"_yield", "signalYield", 100, 0., 1.e6) signalNorm[m] = RooRealVar(signalName+"_norm", "signalNorm", 1., 0., 1.e6) signalXS[m] = RooRealVar(signalName+"_xs", "signalXS", 1., 0., 1.e6) signalExt[m] = RooExtendPdf(signalName+"_ext", "extended p.d.f", signal[m], signalYield[m]) vslope1[m].setMax(50.) vslope1[m].setVal(20.) #valpha1[m].setVal(1.0) #valpha1[m].setConstant(True) if 'bb' in channel and 'VBF' not in channel: if 'nn' in channel: valpha1[m].setVal(0.5) elif '0b' in channel and 'VBF' not in channel: if 'nn' in channel: if m==800: valpha1[m].setVal(2.) vsigma[m].setVal(m*0.04) elif 'ee' in channel: valpha1[m].setVal(0.8) if m==800: #valpha1[m].setVal(1.2) valpha1[m].setVal(2.5) vslope1[m].setVal(50.) elif 'mm' in channel: if m==800: valpha1[m].setVal(2.) vsigma[m].setVal(m*0.03) else: vmean[m].setVal(m*0.9) vsigma[m].setVal(m*0.08) elif 'bb' in channel and 'VBF' in channel: if 'nn' in channel: if m!=1800: vmean[m].setVal(m*0.8) vsigma[m].setVal(m*0.08) valpha1[m].setMin(1.) elif 'ee' in channel: valpha1[m].setVal(0.7) elif 'mm' in channel: if m==800: vslope1[m].setVal(50.) valpha1[m].setVal(0.7) elif '0b' in channel and 'VBF' in channel: if 'nn' in channel: valpha1[m].setVal(3.) vmean[m].setVal(m*0.8) vsigma[m].setVal(m*0.08) valpha1[m].setMin(1.) elif 'ee' in channel: if m<2500: valpha1[m].setVal(2.) if m==800: vsigma[m].setVal(m*0.05) elif m==1000: vsigma[m].setVal(m*0.03) elif m>1000 and m<1800: vsigma[m].setVal(m*0.04) elif 'mm' in channel: if m<2000: valpha1[m].setVal(2.) if m==1000 or m==1800: vsigma[m].setVal(m*0.03) elif m==1200 or m==1600: vsigma[m].setVal(m*0.04) #if m < 1000: vsigma[m].setVal(m*0.06) # If it's not the proper channel, make it a gaussian #if nLept==0 and 'VBF' in channel: # valpha1[m].setVal(5) # valpha1[m].setConstant(True) # vslope1[m].setConstant(True) # salpha2[m].setConstant(True) # sslope2[m].setConstant(True) # ---------- if there is no simulated signal, skip this mass point ---------- if m in genPoints: if VERBOSE: print " - Mass point", m # define the dataset for the signal applying the SR cuts treeSign[m] = TChain("tree") for j, ss in enumerate(sample[signalMass]['files']): treeSign[m].Add(NTUPLEDIR + ss + ".root") if treeSign[m].GetEntries() <= 0.: if VERBOSE: print " - 0 events available for mass", m, "skipping mass point..." signalNorm[m].setVal(-1) vmean[m].setConstant(True) vsigma[m].setConstant(True) salpha1[m].setConstant(True) sslope1[m].setConstant(True) salpha2[m].setConstant(True) sslope2[m].setConstant(True) signalNorm[m].setConstant(True) signalXS[m].setConstant(True) continue setSignal[m] = RooDataSet("setSignal_"+signalName, "setSignal", variables, RooFit.Cut(SRcut), RooFit.WeightVar(weight), RooFit.Import(treeSign[m])) if VERBOSE: print " - Dataset with", setSignal[m].sumEntries(), "events loaded" # FIT signalYield[m].setVal(setSignal[m].sumEntries()) if treeSign[m].GetEntries(SRcut) > 5: if VERBOSE: print " - Running fit" frSignal[m] = signalExt[m].fitTo(setSignal[m], RooFit.Save(1), RooFit.Extended(True), RooFit.SumW2Error(True), RooFit.PrintLevel(-1)) if VERBOSE: print "********** Fit result [", m, "] **", category, "*"*40, "\n", frSignal[m].Print(), "\n", "*"*80 if VERBOSE: frSignal[m].correlationMatrix().Print() drawPlot(signalMass, stype+channel, X_mass, signal[m], setSignal[m], frSignal[m]) else: print " WARNING: signal", stype, "and mass point", m, "in channel", channel, "has 0 entries or does not exist" # Remove HVT cross section (which is the same for Zlep and Zinv) if stype == "XZHVBF": sample_name = 'Zprime_VBF_Zh_Zlephinc_narrow_M-%d' % m else: sample_name = 'ZprimeToZHToZlepHinc_narrow_M%d' % m xs = xsection[sample_name]['xsec'] signalXS[m].setVal(xs * 1000.) signalIntegral[m] = signalExt[m].createIntegral(massArg, RooFit.NormSet(massArg), RooFit.Range("X_integration_range")) boundaryFactor = signalIntegral[m].getVal() if VERBOSE: print " - Fit normalization vs integral:", signalYield[m].getVal(), "/", boundaryFactor, "events" if channel=='nnbb' and m==5000: signalNorm[m].setVal(2.5) elif channel=='nn0b' and m==5000: signalNorm[m].setVal(6.7) else: signalNorm[m].setVal( boundaryFactor * signalYield[m].getVal() / signalXS[m].getVal()) # here normalize to sigma(X) x Br(X->VH) = 1 [fb] a1[m].setConstant(True) a2[m].setConstant(True) vmean[m].setConstant(True) vsigma[m].setConstant(True) valpha1[m].setConstant(True) vslope1[m].setConstant(True) salpha2[m].setConstant(True) sslope2[m].setConstant(True) signalNorm[m].setConstant(True) signalXS[m].setConstant(True) #*******************************************************# # # # Signal interpolation # # # #*******************************************************# # ====== CONTROL PLOT ====== c_signal = TCanvas("c_signal", "c_signal", 800, 600) c_signal.cd() frame_signal = X_mass.frame() for m in genPoints[:-2]: if m in signalExt.keys(): signal[m].plotOn(frame_signal, RooFit.LineColor(sample["%s_M%d" % (stype, m)]['linecolor']), RooFit.Normalization(signalNorm[m].getVal(), RooAbsReal.NumEvent), RooFit.Range("X_reasonable_range")) frame_signal.GetXaxis().SetRangeUser(0, 6500) frame_signal.Draw() drawCMS(-1, YEAR, "Simulation") drawAnalysis(channel) drawRegion(channel) c_signal.SaveAs(PLOTDIR+"/"+stype+category+"/"+stype+"_Signal.pdf") c_signal.SaveAs(PLOTDIR+"/"+stype+category+"/"+stype+"_Signal.png") #if VERBOSE: raw_input("Press Enter to continue...") # ====== CONTROL PLOT ====== # Normalization gnorm = TGraphErrors() gnorm.SetTitle(";m_{X} (GeV);integral (GeV)") gnorm.SetMarkerStyle(20) gnorm.SetMarkerColor(1) gnorm.SetMaximum(0) inorm = TGraphErrors() inorm.SetMarkerStyle(24) fnorm = TF1("fnorm", "pol9", 800, 5000) #"pol5" if not channel=="XZHnnbb" else "pol6" #pol5*TMath::Floor(x-1800) + ([5]*x + [6]*x*x)*(1-TMath::Floor(x-1800)) fnorm.SetLineColor(920) fnorm.SetLineStyle(7) fnorm.SetFillColor(2) fnorm.SetLineColor(cColor) # Mean gmean = TGraphErrors() gmean.SetTitle(";m_{X} (GeV);gaussian mean (GeV)") gmean.SetMarkerStyle(20) gmean.SetMarkerColor(cColor) gmean.SetLineColor(cColor) imean = TGraphErrors() imean.SetMarkerStyle(24) fmean = TF1("fmean", "pol1", 0, 5000) fmean.SetLineColor(2) fmean.SetFillColor(2) # Width gsigma = TGraphErrors() gsigma.SetTitle(";m_{X} (GeV);gaussian width (GeV)") gsigma.SetMarkerStyle(20) gsigma.SetMarkerColor(cColor) gsigma.SetLineColor(cColor) isigma = TGraphErrors() isigma.SetMarkerStyle(24) fsigma = TF1("fsigma", "pol1", 0, 5000) fsigma.SetLineColor(2) fsigma.SetFillColor(2) # Alpha1 galpha1 = TGraphErrors() galpha1.SetTitle(";m_{X} (GeV);crystal ball lower alpha") galpha1.SetMarkerStyle(20) galpha1.SetMarkerColor(cColor) galpha1.SetLineColor(cColor) ialpha1 = TGraphErrors() ialpha1.SetMarkerStyle(24) falpha1 = TF1("falpha", "pol0", 0, 5000) falpha1.SetLineColor(2) falpha1.SetFillColor(2) # Slope1 gslope1 = TGraphErrors() gslope1.SetTitle(";m_{X} (GeV);exponential lower slope (1/Gev)") gslope1.SetMarkerStyle(20) gslope1.SetMarkerColor(cColor) gslope1.SetLineColor(cColor) islope1 = TGraphErrors() islope1.SetMarkerStyle(24) fslope1 = TF1("fslope", "pol0", 0, 5000) fslope1.SetLineColor(2) fslope1.SetFillColor(2) # Alpha2 galpha2 = TGraphErrors() galpha2.SetTitle(";m_{X} (GeV);crystal ball upper alpha") galpha2.SetMarkerStyle(20) galpha2.SetMarkerColor(cColor) galpha2.SetLineColor(cColor) ialpha2 = TGraphErrors() ialpha2.SetMarkerStyle(24) falpha2 = TF1("falpha", "pol0", 0, 5000) falpha2.SetLineColor(2) falpha2.SetFillColor(2) # Slope2 gslope2 = TGraphErrors() gslope2.SetTitle(";m_{X} (GeV);exponential upper slope (1/Gev)") gslope2.SetMarkerStyle(20) gslope2.SetMarkerColor(cColor) gslope2.SetLineColor(cColor) islope2 = TGraphErrors() islope2.SetMarkerStyle(24) fslope2 = TF1("fslope", "pol0", 0, 5000) fslope2.SetLineColor(2) fslope2.SetFillColor(2) n = 0 for i, m in enumerate(genPoints): if not m in signalNorm.keys(): continue if signalNorm[m].getVal() < 1.e-6: continue signalString = "M%d" % m signalName = "%s_M%d" % (stype, m) if gnorm.GetMaximum() < signalNorm[m].getVal(): gnorm.SetMaximum(signalNorm[m].getVal()) gnorm.SetPoint(n, m, signalNorm[m].getVal()) gmean.SetPoint(n, m, vmean[m].getVal()) gmean.SetPointError(n, 0, min(vmean[m].getError(), vmean[m].getVal()*0.02)) gsigma.SetPoint(n, m, vsigma[m].getVal()) gsigma.SetPointError(n, 0, min(vsigma[m].getError(), vsigma[m].getVal()*0.05)) galpha1.SetPoint(n, m, valpha1[m].getVal()) galpha1.SetPointError(n, 0, min(valpha1[m].getError(), valpha1[m].getVal()*0.10)) gslope1.SetPoint(n, m, vslope1[m].getVal()) gslope1.SetPointError(n, 0, min(vslope1[m].getError(), vslope1[m].getVal()*0.10)) galpha2.SetPoint(n, m, salpha2[m].getVal()) galpha2.SetPointError(n, 0, min(salpha2[m].getError(), salpha2[m].getVal()*0.10)) gslope2.SetPoint(n, m, sslope2[m].getVal()) gslope2.SetPointError(n, 0, min(sslope2[m].getError(), sslope2[m].getVal()*0.10)) n = n + 1 print "fit on gmean:" gmean.Fit(fmean, "Q0", "SAME") print "fit on gsigma:" gsigma.Fit(fsigma, "Q0", "SAME") print "fit on galpha:" galpha1.Fit(falpha1, "Q0", "SAME") print "fit on gslope:" gslope1.Fit(fslope1, "Q0", "SAME") galpha2.Fit(falpha2, "Q0", "SAME") gslope2.Fit(fslope2, "Q0", "SAME") #for m in [5000, 5500]: gnorm.SetPoint(gnorm.GetN(), m, gnorm.Eval(m, 0, "S")) gnorm.Fit(fnorm, "Q", "SAME", 700, 5000) for m in massPoints: signalName = "%s_M%d" % (stype, m) if vsigma[m].getVal() < 10.: vsigma[m].setVal(10.) # Interpolation method syield = gnorm.Eval(m) spline = gnorm.Eval(m, 0, "S") sfunct = fnorm.Eval(m) #delta = min(abs(1.-spline/sfunct), abs(1.-spline/syield)) delta = abs(1.-spline/sfunct) if sfunct > 0 else 0 syield = spline if interPar: jmean = gmean.Eval(m) jsigma = gsigma.Eval(m) jalpha1 = galpha1.Eval(m) jslope1 = gslope1.Eval(m) else: jmean = fmean.GetParameter(0) + fmean.GetParameter(1)*m + fmean.GetParameter(2)*m*m jsigma = fsigma.GetParameter(0) + fsigma.GetParameter(1)*m + fsigma.GetParameter(2)*m*m jalpha1 = falpha1.GetParameter(0) + falpha1.GetParameter(1)*m + falpha1.GetParameter(2)*m*m jslope1 = fslope1.GetParameter(0) + fslope1.GetParameter(1)*m + fslope1.GetParameter(2)*m*m inorm.SetPoint(inorm.GetN(), m, syield) signalNorm[m].setVal(syield) imean.SetPoint(imean.GetN(), m, jmean) if jmean > 0: vmean[m].setVal(jmean) isigma.SetPoint(isigma.GetN(), m, jsigma) if jsigma > 0: vsigma[m].setVal(jsigma) ialpha1.SetPoint(ialpha1.GetN(), m, jalpha1) if not jalpha1==0: valpha1[m].setVal(jalpha1) islope1.SetPoint(islope1.GetN(), m, jslope1) if jslope1 > 0: vslope1[m].setVal(jslope1) c1 = TCanvas("c1", "Crystal Ball", 1200, 800) c1.Divide(2, 2) c1.cd(1) gmean.SetMinimum(0.) gmean.Draw("APL") imean.Draw("P, SAME") drawRegion(channel) c1.cd(2) gsigma.SetMinimum(0.) gsigma.Draw("APL") isigma.Draw("P, SAME") drawRegion(channel) c1.cd(3) galpha1.Draw("APL") ialpha1.Draw("P, SAME") drawRegion(channel) galpha1.GetYaxis().SetRangeUser(0., 5.) c1.cd(4) gslope1.Draw("APL") islope1.Draw("P, SAME") drawRegion(channel) gslope1.GetYaxis().SetRangeUser(0., 125.) if False: c1.cd(5) galpha2.Draw("APL") ialpha2.Draw("P, SAME") drawRegion(channel) c1.cd(6) gslope2.Draw("APL") islope2.Draw("P, SAME") drawRegion(channel) gslope2.GetYaxis().SetRangeUser(0., 10.) c1.Print(PLOTDIR+stype+category+"/"+stype+"_SignalShape.pdf") c1.Print(PLOTDIR+stype+category+"/"+stype+"_SignalShape.png") c2 = TCanvas("c2", "Signal Efficiency", 800, 600) c2.cd(1) gnorm.SetMarkerColor(cColor) gnorm.SetMarkerStyle(20) gnorm.SetLineColor(cColor) gnorm.SetLineWidth(2) gnorm.Draw("APL") inorm.Draw("P, SAME") gnorm.GetXaxis().SetRangeUser(genPoints[0]-100, genPoints[-1]+100) gnorm.GetYaxis().SetRangeUser(0., gnorm.GetMaximum()*1.25) drawCMS(-1,YEAR , "Simulation") drawAnalysis(channel) drawRegion(channel) c2.Print(PLOTDIR+stype+category+"/"+stype+"_SignalNorm.pdf") c2.Print(PLOTDIR+stype+category+"/"+stype+"_SignalNorm.png") #*******************************************************# # # # Generate workspace # # # #*******************************************************# # create workspace w = RooWorkspace("ZH_RunII", "workspace") for m in massPoints: getattr(w, "import")(signal[m], RooFit.Rename(signal[m].GetName())) getattr(w, "import")(signalNorm[m], RooFit.Rename(signalNorm[m].GetName())) getattr(w, "import")(signalXS[m], RooFit.Rename(signalXS[m].GetName())) w.writeToFile("%s%s.root" % (WORKDIR, stype+channel), True) print "Workspace", "%s%s.root" % (WORKDIR, stype+channel), "saved successfully" sys.exit()
def getFrame(cat, obsData, simPdf, mc, fit_res, error_band_strategy=1, compute_yields=False): """ Build a frame with the different fit components and their uncertainties Parameters ---------- cat : RooCategory Category of the simultaneous PDF we are interested in obsData: RooDataHist object (either real data or asimov or PE) simPdf : RooSimultaneous PDF mc : ModelConfig object fit_res: RooFitResult Result of the fit (covariance matrix, NLL value, ...) error_band_strategy : True/False True: Use the linear approximation to extract the error band False: Use a sampling method See http://root.cern.ch/root/html/RooAbsReal.html#RooAbsReal:plotOnWithErrorBand verbose: True/False TODO: implement a more generic way to retrieve the binning. Currently it has to be put in the workspace with the name binWidth_obs_x_{channel}_0 """ hlist = [] if compute_yields: yields = {} # --> Get the total (signal+bkg) model pdf pdftmp = simPdf.getPdf(cat.GetName()) if not pdftmp: raise RuntimeError('Could not retrieve the total pdf ') # --> Get the list of observables obstmp = pdftmp.getObservables(mc.GetObservables()) if not obstmp: raise RuntimeError('Could not retrieve the list of observable') # --> Get the first (and only) observable (mmc mass for cut based) obs = obstmp.first() log.info('Observable: {0}'.format(obs.GetName())) # --> Get the RooDataHist of the given category datatmp = obsData.reduce("{0}=={1}::{2}".format(simPdf.indexCat().GetName(), simPdf.indexCat().GetName(), cat.GetName())) datatmp.__class__=ROOT.RooAbsData # --> Ugly fix !!! # --> Get the binning width of the category (stored as a workspace variable) binWidth = pdftmp.getVariables().find('binWidth_obs_x_{0}_0'.format(cat.GetName())) if not binWidth: raise RuntimeError('Could not retrieve the binWidth') # --> parameter of interest (mu=sigma/sigma_sm) poi = mc.GetParametersOfInterest().first() poi_fitted_val = poi.getVal() log.info('POI: {0} = {1} +/- {2}'.format(poi.GetName(), poi.getVal(), poi.getError())) # --> Create the data histogram hist_data = asrootpy(datatmp.createHistogram("hdata_"+cat.GetName(), obs)) hist_data.name = "hdata_{0}".format(cat.GetName()) hist_data.title = "" hlist.append(hist_data) #--> compute the data yields if compute_yields: Yield_data = hist_data.Integral() yields['Data'] = (Yield_data, 0) # --> Create the frame structure from the observable frame = obs.frame() frame.SetName(cat.GetName()) datatmp.plotOn(frame, ROOT.RooFit.DataError(ROOT.RooAbsData.Poisson), ROOT.RooFit.Name("Data"), ROOT.RooFit.MarkerSize(1)) # --> Create the signal histogram template hist_sig = hist_data.Clone('h_TotalSignal_{0}'.format(cat.GetName())) hist_sig.Reset() signal_comps = RooArgList() bkg_comps = RooArgList() # --> get the list of components (hadhad HSG4: QCD,Other,Ztautau, Signal_Z, Signal_W, Signal_gg, Signal_VBF) # --> and iterate over pdfmodel = pdftmp.getComponents().find(cat.GetName()+'_model') funcListIter = pdfmodel.funcList().iterator() while True: comp = funcListIter.Next() if not comp: break name = comp.GetName().replace('L_x_', '').split('_')[0] log.info('Scan component {0}'.format(comp.GetName())) hist_comp = asrootpy(comp.createHistogram(cat.GetName()+"_"+comp.GetName(), obs, ROOT.RooFit.Extended(False))) hist_comp.name = 'h_{0}_{1}'.format(name, cat.GetName()) hist_comp.title = '' hlist.append(hist_comp) if 'Signal' in comp.GetName(): signal_comps.add(comp) hist_sig.Add(hist_comp) else: bkg_comps.add(comp) Integral_comp = comp.createIntegral(RooArgSet(obs)) Yield_comp = Integral_comp.getVal() * binWidth.getVal() log.info('Integral = {0}'.format(Yield_comp)) # if Yield_comp==0: # raise RuntimeError('Yield integral is wrong !!') # --> Add the components to the frame but in an invisible way pdfmodel.plotOn(frame, ROOT.RooFit.Components(comp.GetName()), ROOT.RooFit.Normalization(Yield_comp, ROOT.RooAbsReal.NumEvent), ROOT.RooFit.Name("NoStacked_"+comp.GetName()), ROOT.RooFit.Invisible()) if fit_res: # --> Add the components uncertainty band comp.plotOn(frame, ROOT.RooFit.Normalization(1, ROOT.RooAbsReal.RelativeExpected), ROOT.RooFit.VisualizeError(fit_res, 1, error_band_strategy), ROOT.RooFit.Name("FitError_AfterFit_"+comp.GetName()), ROOT.RooFit.Invisible()) if compute_yields: if Yield_comp==0: Yield_comp_err=0. else: Yield_comp_err = Integral_comp.getPropagatedError(fit_res)* binWidth.getVal() yields[comp.GetName()] = (Yield_comp, Yield_comp_err) hlist.append(hist_sig) # --> total signal yields if compute_yields: signal_tot_comp = RooAddition('pdf_sum_sig', 'pdf_sum_sig', signal_comps) Integral_signal = signal_tot_comp.createIntegral(RooArgSet(obs)) yields_sig_tot = Integral_signal.getVal()*binWidth.getVal() yields_sig_tot_err = Integral_signal.getPropagatedError(fit_res)* binWidth.getVal() yields['TotalSignal'] = (yields_sig_tot, yields_sig_tot_err) bkg_tot_comp = RooAddition('pdf_sum_bkg', 'pdf_sum_bkg', bkg_comps) Integral_bkg = bkg_tot_comp.createIntegral(RooArgSet(obs)) yields_bkg_tot = Integral_bkg.getVal()*binWidth.getVal() yields_bkg_tot_err = Integral_bkg.getPropagatedError(fit_res)* binWidth.getVal() yields['bkg'] = (yields_bkg_tot, yields_bkg_tot_err) log.info('Bkg Total Yield: {0}'.format(yields_bkg_tot)) # --> bkg+signal PDF central value and error Integral_total = pdfmodel.createIntegral(RooArgSet(obs)) Yield_total = Integral_total.getVal() * binWidth.getVal() log.info('Postfit Total Yield: {0}'.format(Yield_total)) hist_bkg_plus_sig = asrootpy(pdfmodel.createHistogram("hbkg_plus_sig_"+cat.GetName(), obs, ROOT.RooFit.Extended(False))) hist_bkg_plus_sig.name = 'hbkg_plus_sig_'+cat.GetName() hist_bkg_plus_sig.title = '' hist_bkg_plus_sig.Scale(Yield_total) hlist.append(hist_bkg_plus_sig) # --> Add the components to the frame but in an invisible way pdftmp.plotOn(frame, ROOT.RooFit.Normalization(Yield_total, ROOT.RooAbsReal.NumEvent), ROOT.RooFit.Name("Bkg_plus_sig")) if fit_res: pdftmp.plotOn(frame, ROOT.RooFit.VisualizeError(fit_res, 1, error_band_strategy), ROOT.RooFit.Normalization(1, ROOT.RooAbsReal.RelativeExpected), ROOT.RooFit.Name("FitError_AfterFit"), ROOT.RooFit.FillColor(ROOT.kOrange), ROOT.RooFit.LineWidth(2), ROOT.RooFit.LineColor(ROOT.kBlue)) # --> bkg only PDF central value and error poi.setVal(0.) Integral_bkg_total = pdfmodel.createIntegral(RooArgSet(obs)) Yield_bkg_total = Integral_bkg_total.getVal() * binWidth.getVal() hist_bkg = pdfmodel.createHistogram("hbkg_"+cat.GetName(), obs, ROOT.RooFit.Extended(False)) hist_bkg.Scale(Yield_bkg_total) hist_bkg.SetName("hbkg_"+cat.GetName()) hist_bkg.SetTitle("") hlist.append(hist_bkg) pdftmp.plotOn(frame, ROOT.RooFit.Normalization(Yield_bkg_total, ROOT.RooAbsReal.NumEvent), ROOT.RooFit.Name("Bkg"), ROOT.RooFit.LineStyle(ROOT.kDashed)) if fit_res: pdftmp.plotOn(frame, ROOT.RooFit.VisualizeError(fit_res, 1, error_band_strategy), ROOT.RooFit.Normalization(1, ROOT.RooAbsReal.RelativeExpected), ROOT.RooFit.Name("FitError_AfterFit_Mu0"), ROOT.RooFit.FillColor(ROOT.kOrange), ROOT.RooFit.LineWidth(2), ROOT.RooFit.LineColor(ROOT.kBlue)) #if compute_yields: # Yield_bkg_total_err = Integral_bkg_total.getPropagatedError(fit_res)*binWidth.getVal() # yields['bkg'] = (Yield_bkg_total, Yield_bkg_total_err) poi.setVal(poi_fitted_val) if compute_yields: return frame, hlist, yields else: return frame, hlist