def doFit(hist,output,rap="BB",flavour="DATA",trackType="TunePNew",funct="doubleCB"): sig = [] sige = [] meanList = [] meanListe = [] nChi2 = [] gSystem.Load("./RooCruijff_cxx.so") gSystem.Load("./RooDCBShape_cxx.so") for i,h in enumerate(hist): ws = RooWorkspace("tempWS") mass = RooRealVar('mass','mass',91, xLow, xHigh ) getattr(ws,'import')(mass,RooCmdArg()) dataHist = RooDataHist("hist","hist",RooArgList(ws.var("mass")),h) getattr(ws,'import')(dataHist,RooCmdArg()) ws.writeToFile("tmpWorkspace.root") subprocess.call(["python","fitCapsule.py",output,rap,flavour,trackType,funct,"%d"%xLow,"%d"%xHigh,"%d"%rebinFactor,"%d"%i]) returnFile = TFile("tmpWorkspaceReturn.root","OPEN") wsReturn = returnFile.Get("tempWS") sig.append(wsReturn.var("Sig").getVal()) sige.append(wsReturn.var("Sige").getVal()) meanList.append(wsReturn.var("Mean").getVal()) meanListe.append(wsReturn.var("Meane").getVal()) nChi2.append(wsReturn.var("chi2").getVal()/wsReturn.var("nDOF").getVal()) return meanList,meanListe,sig,sige, nChi2
def generate_poly(self, b, low, high, nbins, nev): ws = RooWorkspace('ws', 'ws') ws.factory('Polynomial::bgPol(mass[200, 500], b[-0.001])') ws.var('mass').setRange(low, high) ws.var('b').setVal(b) _pdf = ws.pdf('bgPol') ws.var('mass').setBins(nbins) _ds = _pdf.generateBinned(RooArgSet(ws.var('mass')), nev) _h = _ds.createHistogram('hBgpol', ws.var('mass')) return _h
def _runPath(self): # Hook to registerd file fileName = self.cfg.get('fileName', "") if os.path.exists(fileName): self.ifile = self.process.filemanager.open(str(hex(id(self))), fileName, 'READ') #Open Wspace File #Pritam # Load wspace wspaceName = "wspace.{0}.{1}".format(str(self.process.cfg['args'].Year), self.cfg['wspaceTag']) # print("sourcemanager: ", self.process.sourcemanager.keys()) if wspaceName in self.process.sourcemanager.keys(): self.wspace = self.process.sourcemanager.get(wspaceName) elif not self.ifile == None: self.wspace = self.ifile.Get(wspaceName) # Load desired objects if self.wspace == None: self.logger.logINFO("RooWorkspace {0} not found. Create new workspace without booking target objects.".format(wspaceName)) self.wspace = RooWorkspace(wspaceName) self.cfg['source'][wspaceName] = self.wspace # Update results only for new workspace. # By design you CANNOT overwrite items in RooWorkspace by `Write` or `writeToFile`. self.bookEndSeq() else: self.logger.logINFO("RooWorkspace {0} found. Loading objects...".format(wspaceName)) self.cfg['source'][wspaceName] = self.wspace def readObjs(): """Exactly define how to read varaiables, read `wspace_key` from wspace and book as `source_key`""" for source_key, wspace_key in self.cfg['obj'].items(): if source_key in self.process.sourcemanager.keys(): self.cfg['source'][source_key] = self.process.sourcemanager.get(source_key) else: obj = self.wspace.obj(wspace_key) if obj == None: self.logger.logWARNING("No Variable {0} is found.".format(wspace_key)) else: self.cfg['source'][source_key] = obj def readAll(iArgs): def bookOne(arg): argName = arg.GetName() if argName in self.process.sourcemanager: self.cfg['source'][argName] = self.process.sourcemanager.get(argName) else: self.cfg['source'][argName+".{0}".format(str(self.process.cfg['args'].Year))] = arg FitterCore.ArgLooper(iArgs, bookOne) if self.cfg['obj']: readObjs() else: readAll(self.wspace.allFunctions()) readAll(self.wspace.allPdfs()) readAll(self.wspace.allVars())
def generate_bw(self, peak, width, low, high, nbins, nev): ws = RooWorkspace('ws', 'ws') ws.factory( 'BreitWigner::bw(mass[200, 600], peak[350, 200, 700], width[50])') ws.var('mass').setRange(low, high) ws.var('peak').setVal(peak) ws.var('width').setVal(width) _bw = ws.pdf('bw') ws.var('mass').setBins(nbins) _ds = _bw.generateBinned(RooArgSet(ws.var('mass')), nev) _h = _ds.createHistogram('hBw', ws.var('mass')) return _h
def rooFit510(): print ">>> create and fill workspace..." workspace = RooWorkspace("workspace") # RooWorkspace fillWorkspace(workspace) print ">>>\n>>> retrieve model from workspace..." # Exploit convention encoded in named set "parameters" and "observables" # to use workspace contents w/o need for introspected model = workspace.pdf("model") # RooAbsPdf print ">>> generate and fit data in given observables" data = model.generate(workspace.set("observables"), 1000) # RooDataSet model.fitTo(data) print ">>> plot model and data of first observables..." frame1 = workspace.set("observables").first().frame() # RooPlot data.plotOn(frame1, Name("data"), Binning(50)) model.plotOn(frame1, Name("model")) print ">>> overlay plots with reference parameters as stored in snapshots..." workspace.loadSnapshot("reference_fit") model.plotOn(frame1, LineColor(kRed), Name("model_ref")) workspace.loadSnapshot("reference_fit_bkgonly") model.plotOn(frame1, LineColor(kRed), LineStyle(kDashed), Name("bkg_ref")) print "\n>>> draw on canvas..." canvas = TCanvas("canvas", "canvas", 100, 100, 800, 600) legend = TLegend(0.2, 0.8, 0.4, 0.6) legend.SetTextSize(0.032) legend.SetBorderSize(0) legend.SetFillStyle(0) gPad.SetLeftMargin(0.15) gPad.SetRightMargin(0.02) frame1.GetYaxis().SetLabelOffset(0.008) frame1.GetYaxis().SetTitleOffset(1.5) frame1.GetYaxis().SetTitleSize(0.045) frame1.GetXaxis().SetTitleSize(0.045) frame1.Draw() legend.AddEntry("data", "data", 'LEP') legend.AddEntry("model", "model", 'L') legend.AddEntry("model_ref", "model fit", 'L') legend.AddEntry("bkg_ref", "background only fit", 'L') legend.Draw() canvas.SaveAs("rooFit510.png") # Print workspace contents workspace.Print() # Workspace will remain in memory after macro finishes gDirectory.Add(workspace)
def update(self,wsname,fname,storelist=[]): """Stores the current model (and observable) into a ROOT.Workspace, persistified in a root file Parameters ---------- wsname: str Name to be given to the ROOT.Workspace fname: str Name to be given to the ROOT file storelist: list(ROOT.RooDataSet,ROOT.RooRealVar,...), optional List of RooFit objects to be stored in the same workspace """ import os from ROOT import RooWorkspace, TFile # Create the ws with the model and data available w = RooWorkspace(wsname,'Workspace') wsImport = getattr(w,'import') # Put the models for rawtuple in self.__models.values(): model = rawtuple[0] anythingelse = rawtuple[1:] wsImport(model) # Put whatever the user want to store for _item in storelist: wsImport(_item) # Check if the fname already exist file_exist = os.path.isfile(fname) if file_exist: # Create a new auxiliar file, to provisionaly # store the ws auxfname = '_auxroot.root' w.writeToFile(auxfname) # Previously delete the old Workspace, if any _rootfile = TFile(fname) _rootfile.Delete(wsname+';*') _rootfile.Delete("ProcessID*;*") _rootfile.Close() # Open the auxiliary file _aux = TFile(auxfname) # and copy the ws to the rootfile w = _aux.Get(wsname) # and copy the ws to the rootfile w.writeToFile(fname,False) if file_exist: # And closing and removing auxfile _aux.Close() os.remove(auxfname)
def rooFit511(compact=kFALSE): workspace = RooWorkspace("workspace") print ">>> creating and adding basic pdfs..." # Remake example pdf of tutorial rf502_wspacewrite.C: # # Basic pdf construction: ClassName::ObjectName(constructor arguments) # Variable construction: VarName[x,xlo,xhi], VarName[xlo,xhi], VarName[x] # pdf addition: SUM::ObjectName(coef1*pdf1,...coefM*pdfM,pdfN) if not compact: # Use object factory to build pdf of tutorial rooFit502_wspacewrite workspace.factory("Gaussian::sig1(x[-10,10],mean[5,0,10],0.5)") workspace.factory("Gaussian::sig2(x,mean,1)") workspace.factory("Chebychev::bkg(x,{a0[0.5,0.,1],a1[-0.2,0.,1.]})") workspace.factory("SUM::sig(sig1frac[0.8,0.,1.]*sig1,sig2)") workspace.factory("SUM::model(bkgfrac[0.5,0.,1.]*bkg,sig)") else: # Use object factory to build pdf of tutorial rf502_wspacewrite but # - Contracted to a single line recursive expression, # - Omitting explicit names for components that are not referred to explicitly later workspace.factory("SUM::model(bkgfrac[0.5,0.,1.]*Chebychev::bkg(x[-10,10],{a0[0.5,0.,1],a1[-0.2,0.,1.]}),"+\ "SUM(sig1frac[0.8,0.,1.]*Gaussian(x,mean[5,0,10],0.5),Gaussian(x,mean,1)))") print ">>> advanced pdf constructor arguments..." # pdf constructor arguments may by any type of RooAbsArg, but also the follow conversion are made: # Double_t --> RooConst(...) # {a,b,c} --> RooArgSet() or RooArgList() depending on required ctor arg # dataset name --> RooAbsData reference for any dataset residing in the workspace # enum --> any enum label that belongs to an enum defined in the (base) class print ">>> generate a dummy dataset from 'model' pdf and import it in the workspace..." data = workspace.pdf("model").generate(RooArgSet(workspace.var("x")), 1000) # RooDataSet getattr(workspace, "import")(data, Rename("data")) print ">>> construct keys pdf..." # Construct a KEYS pdf passing a dataset name and an enum type defining the # mirroring strategy workspace.factory("KeysPdf::k(x,data,NoMirror,0.2)") print ">>> workspace contents:" workspace.Print() print ">>> save workspace in memory (gDirectory)..." gDirectory.Add(workspace)
def fit(self, save_to, signal_name=None, fix_p3=False, fit_range=[300., 1200.], fit_strategy=1): # Run a RooFit fit # Create background PDF p1 = RooRealVar('p1','p1',args.p1,0.,100.) p2 = RooRealVar('p2','p2',args.p2,0.,60.) p3 = RooRealVar('p3','p3',args.p3,-10.,10.) if args.fix_p3: p3.setConstant() background_pdf = RooGenericPdf('background_pdf','(pow(1-@0/%.1f,@1)/pow(@0/%.1f,@2+@3*log(@0/%.1f)))'%(self.collision_energy,self.collision_energy,self.collision_energy),RooArgList(self.mjj_,p1,p2,p3)) background_pdf.Print() data_integral = data_histogram.Integral(data_histogram.GetXaxis().FindBin(float(fit_range[0])),data_histogram.GetXaxis().FindBin(float(fit_range[1]))) background_norm = RooRealVar('background_norm','background_norm',data_integral,0.,1e+08) background_norm.Print() # Create signal PDF and fit model if signal_name: signal_pdf = RooHistPdf('signal_pdf', 'signal_pdf', RooArgSet(self.mjj_), self.signal_roohistograms_[signal_name]) signal_pdf.Print() signal_norm = RooRealVar('signal_norm','signal_norm',0,-1e+05,1e+05) signal_norm.Print() model = RooAddPdf("model","s+b",RooArgList(background_pdf,signal_pdf),RooArgList(background_norm,signal_norm)) else: model = RooAddPdf("model","b",RooArgList(background_pdf),RooArgList(background_norm)) # Run fit res = model.fitTo(data_, RooFit.Save(kTRUE), RooFit.Strategy(fit_strategy)) # Save to workspace self.workspace_ = RooWorkspace('w','workspace') #getattr(w,'import')(background,ROOT.RooCmdArg()) getattr(self.workspace_,'import')(background_pdf,RooFit.Rename("background")) getattr(self.workspace_,'import')(background_norm,ROOT.RooCmdArg()) getattr(self.workspace_,'import')(self.data_roohistogram_,RooFit.Rename("data_obs")) getattr(self.workspace_, 'import')(model, RooFit.Rename("model")) if signal_name: getattr(self.workspace_,'import')(signal_roohistogram,RooFit.Rename("signal")) getattr(self.workspace_,'import')(signal_pdf,RooFit.Rename("signal_pdf")) getattr(self.workspace_,'import')(signal_norm,ROOT.RooCmdArg()) self.workspace_.Print() self.workspace_.writeToFile(save_to) if signal_name: roofit_results[signal_name] = save_to else: roofit_results["background"] = save_to
def getWspace(self): """Read workspace""" wspaceName = "wspace.{0}".format(self.cfg.get('wspaceTag', "DEFAULT")) if wspaceName in self.process.sourcemanager.keys(): wspace = self.process.sourcemanager.get(wspaceName) else: if not isDEBUG: self.logger.logERROR( "RooWorkspace '{0}' not found".format(wspaceName)) self.logger.logDEBUG( "Please access RooWorkspace with WspaceReader") raise RuntimeError wspace = RooWorkspace(wspaceName) self.process.sourcemanager.update(wspaceName, wspace) wspace.addClassDeclImportDir(modulePath) #+ '/cpp') wspace.addClassImplImportDir(modulePath) #+ '/cpp') return wspace
def create_master_workspaces(meta_data): pwd = gDirectory.GetPath() ws_list = {} for (sample,chanlist) in meta_data.getAssociation().iteritems(): ws_list[sample] = {} for (channel,proclist) in chanlist.iteritems(): #make the workspace we're going to use this_ws = RooWorkspace('%s-%s'%(channel,sample)) initialize_workspace(this_ws) ws_list[sample][channel] = {} for (process,subproclist) in proclist.iteritems(): print sample, channel, process if 'HToZG'in process: ws_list[sample][channel][process] = [] for (subproc,info) in subproclist.iteritems(): print '\tprocessing: %s'%subproc input_file = info['input_file'] info['num_mc_events'] = -1 if input_file == '': print '\t no input file found! Skipping!' continue if 'data' not in process: print '\t mc input = %s'%input_file.split('/')[-1] if 'HToZG' in subproc: info['num_mc_events'] = \ extract_higgs_data_in_categories(subproc, input_file, this_ws) ws_list[sample][channel][process].append(subproc) else: info['num_mc_events'] = \ extract_bkg_data_in_categories(subproc, input_file, this_ws) else: print '\t data input = %s'%input_file.split('/')[-1] extract_data_in_categories(channel,input_file,this_ws) #end loop over processes and data fout_name = '%s_%s_master_workspace.root'%(channel,sample) fout = TFile.Open(fout_name,'recreate') fout.cd() this_ws.Write() fout.Close() gDirectory.cd(pwd) ws_list[sample][channel]['filename'] = fout_name return ws_list
def Split_DS(Save_DS=False): ws_file = TFile( "/afs/cern.ch/user/" + prefix + "/" + user + "/eos/lhcb/user/" + prefix + "/" + user + "/WrongSign/2015/WorkSpaces/Merged_Merged_WS.root", "read") wsp = ws_file.Get("wspace") ws_file.Close() LOG_D0_IPCHI2_OWNPV = wsp.var("LOG_D0_IPCHI2_OWNPV") Dst_DTF_D0_CTAU = wsp.var("Dst_DTF_D0_CTAU") Dst_DTF_D0_M = wsp.var("Dst_DTF_D0_M") DTF_D0sPi_M = wsp.var("DTF_D0sPi_M") DTF_D0sPi_M.setMax(2020) DTF_D0sPi_M.setMin(2000) dataset_RS_tot = wsp.data("dataset_RS") dataset_RS_tot.SetName("dataset_RS_tot") varset = RooArgSet("varset") varset.add(LOG_D0_IPCHI2_OWNPV) varset.add(DTF_D0sPi_M) varset.add(Dst_DTF_D0_CTAU) varset.add(Dst_DTF_D0_M) for i, bin in enumerate(decaytime_binnning): start = datetime.now() dataset_RS_dtb_init = RooDataSet( "dataset_RS_dtb_init", "Decaytime bin" + str(i), dataset_RS_tot, varset, "Dst_DTF_D0_CTAU>" + str(bin[0] * ctau) + "&&Dst_DTF_D0_CTAU<" + str(bin[1] * ctau) + "&&" + offline_cut) dataset_RS = Subtract_Distribution(dataset_RS_dtb_init, DTF_D0sPi_M, LOG_D0_IPCHI2_OWNPV, str(i)) dataset_RS.SetName("dataset_RS") wspace = RooWorkspace("wspace") wsfile2 = TFile( "~/eos/lhcb/user/" + prefix + "/" + user + "/WrongSign/2015/WorkSpaces/Merged_WS_Bin_" + str(i) + ".root", "recreate") wspace.rfimport(varset) wspace.rfimport(dataset_RS) wspace.Write("wspace") wsfile2.Close() print "Dataset " + str(i) + " creation took " + str(datetime.now() - start) + " \n" return True
def main(options, args): gROOT.Reset() #load our super special Polarization PDF gROOT.ProcessLine('.L RooPolarizationPdf.cxx+') gROOT.ProcessLine('.L RooPolarizationConstraint.cxx+') #setup integration intConf = ROOT.RooAbsReal.defaultIntegratorConfig() #intConf.Print('v') # intConf.method1D().setLabel('RooAdaptiveGaussKronrodIntegrator1D') intConf.setEpsAbs(1e-13) intConf.setEpsRel(1e-13) print intConf.epsAbs() print intConf.epsRel() # intConf.method2D().setLabel('RooMCIntegrator') # intConf.methodND().setLabel('RooMCIntegrator') output = TFile.Open(options.workspaceName + '.root', 'RECREATE') theWS = RooWorkspace(options.workspaceName, 1) #save the polarization PDF code in the RooWorkspace theWS.importClassCode('RooPolarization*', True) buildDataAndCategories(theWS, options, args) buildMassAndLifetimePDF(theWS) # if options.fitFrame is not None: # buildPolarizationPDF(theWS,options) #root is stupid output.cd() theWS.Print('v') ROOT.RooMsgService.instance().Print() doFit(theWS, options) theWS.Write() output.Close()
def __init__ (self, pars): self.pars = pars self.ws = RooWorkspace('wjj2dfitter') self.utils = Wjj2DFitterUtils(self.pars) self.useImportPars = False self.rangeString = None obs = [] for v in self.pars.var: try: vName = self.pars.varNames[v] except AttributeError: vName = v obs.append(vName) var1 = self.ws.factory('%s[%f,%f]' % (vName, self.pars.varRanges[v][1], self.pars.varRanges[v][2]) ) var1.setUnit('GeV') try: var1.SetTitle(self.pars.varTitles[v]) except AttributeError: var1.SetTitle('m_{jj}') var1.setPlotLabel(var1.GetTitle()) if len(self.pars.varRanges[v][3]) > 1: vbinning = RooBinning(len(self.pars.varRanges[v][3]) - 1, array('d', self.pars.varRanges[v][3]), '%sBinning' % vName) var1.setBinning(vbinning) else: var1.setBins(self.pars.varRanges[v][0]) var1.Print() if v in self.pars.exclude: var1.setRange('signalRegion', self.pars.exclude[v][0], self.pars.exclude[v][1]) var1.setRange('lowSideband', var1.getMin(), self.pars.exclude[v][0]) var1.setRange('highSideband', self.pars.exclude[v][1], var1.getMax()) self.rangeString = 'lowSideband,highSideband' self.ws.defineSet('obsSet', ','.join(obs))
def rooFit502(): print ">>> setup model components..." x = RooRealVar("x", "x", 0, 10) mean = RooRealVar("mean", "mean of gaussians", 5, 0, 10) sigma1 = RooRealVar("sigma1", "width of gaussians", 0.5) sigma2 = RooRealVar("sigma2", "width of gaussians", 1) sig1 = RooGaussian("sig1", "Signal component 1", x, mean, sigma1) sig2 = RooGaussian("sig2", "Signal component 2", x, mean, sigma2) a0 = RooRealVar("a0", "a0", 0.5, 0., 1.) a1 = RooRealVar("a1", "a1", -0.2, 0., 1.) bkg = RooChebychev("bkg", "Background", x, RooArgList(a0, a1)) print ">>> sum model components..." sig1frac = RooRealVar("sig1frac", "fraction of component 1 in signal", 0.8, 0., 1.) sig = RooAddPdf("sig", "Signal", RooArgList(sig1, sig2), RooArgList(sig1frac)) bkgfrac = RooRealVar("bkgfrac", "fraction of background", 0.5, 0., 1.) model = RooAddPdf("model", "g1+g2+a", RooArgList(bkg, sig), RooArgList(bkgfrac)) print ">>> generate data..." data = model.generate(RooArgSet(x), 1000) # RooDataSet print ">>> create workspace, import data and model..." workspace = RooWorkspace("workspace", "workspace") # empty RooWorkspace getattr(workspace, 'import')(model) # import model and all its components getattr(workspace, 'import')(data) # import data #workspace.import(model) # causes synthax error in python #workspace.import(data) # causes synthax error in python print "\n>>> print workspace contents:" workspace.Print() print "\n>>> save workspace in file..." workspace.writeToFile("rooFit502_workspace.root") print ">>> save workspace in memory (gDirectory)..." gDirectory.Add(workspace)
#drawCMS(-1, "Work in Progress", year=YEAR, suppressCMS=True) drawCMS(-1, "", year=YEAR, suppressCMS=True) drawAnalysis(category) drawRegion(category) c2.Print(PLOTDIR+"MC_signal_"+YEAR+"/"+stype+"_"+category+"_SignalNorm.pdf") c2.Print(PLOTDIR+"MC_signal_"+YEAR+"/"+stype+"_"+category+"_SignalNorm.png") #*******************************************************# # # # Generate workspace # # # #*******************************************************# # create workspace w = RooWorkspace("Zprime_"+YEAR, "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(WORKDIR+"MC_signal_%s_%s.root" % (YEAR, category), True) print "Workspace", WORKDIR+"MC_signal_%s_%s.root" % (YEAR, category), "saved successfully" def drawPlot(name, channel, variable, model, dataset, fitRes=[], norm=-1, reg=None, cat="", alt=None, anorm=-1, signal=None, snorm=-1): isData = norm>0 isMass = "Mass" in name isSignal = '_M' in name mass = name[8:12] isCategory = reg is not None #isBottomPanel = not isSignal
vtb = 0.999105 # http://pdg.lbl.gov/2018/reviews/rpp2018-rev-ckm-matrix.pdf vts_term_bWsW = 2 * (vts**2) * (vtb**2) # + vts**4 vts_term_bWbW = (vtb**2)**2 f = ROOT.TFile( "/cms/ldap_home/wjjang/wj_nanoAOD_CMSSW_9_4_4/src/nano/analysis/test/vts/tmva/output/vts_dR_04_Jet.root" ) t = f.Get(str(sys.argv[1]) + "/Method_BDT/BDT") t2 = f.Get(str(sys.argv[2]) + "/Method_BDT/BDT") h_sig = t.Get("MVA_BDT_S") h_bkg = t.Get("MVA_BDT_B") h_sig2 = t2.Get("MVA_BDT_S") h_bkg2 = t2.Get("MVA_BDT_B") w = RooWorkspace() c = ROOT.TCanvas("plots", "plots", 1920, 1080) c.Divide(4, 2) w.factory("bdt[-1,1]") rooh_sig = ROOT.RooDataHist("sigHist", "sigHist", ROOT.RooArgList(w.var("bdt")), h_sig) rooh_bkg = ROOT.RooDataHist("bkgHist", "bkgHist", ROOT.RooArgList(w.var("bdt")), h_bkg) getattr(w, 'import')(rooh_sig) getattr(w, 'import')(rooh_bkg) if t.GetPath().find("_JKS_") is not -1 or t.GetPath().find("JKS_") is not -1: w.factory( "Gaussian::sig_1(bdt, meanSig1[-0.0317964,-1, 1.], sigmaSig1[0.0654243,0, 1])" )
def main(o, args): variables = options.variables procs = options.procs cats = options.cats print "****variables***" print variables #from configfile import variables, procs, cats if 0 and options.files.startswith("/store"): filepath = "root://eoscms/" + str(options.files) else: filepath = options.files print 'filepath is ' + str(filepath) infile = TFile.Open(filepath) infile.Print() wspace = infile.Get("tagsDumper/cms_hgg_13TeV") wspace.Print() isData = False dname = "" print variables for varset in variables: print 'we look at the variable ...' print varset if not varset[-1]: #varset[-1]=varset[-2] varset = (varset[0], varset[1], varset[2], varset[2]) if not varset[1]: varset = (varset[0], varset[0], varset[2], [1, 1]) isData = True datasetsReduced = {} c = TCanvas("c", "", 1) binning1 = varset[-2] binning1[-1] = binning1[-2] * 1.2 print binning1 binning2 = varset[-1] binning2[-1] = binning2[-2] * 1.2 print binning2 th2sigtot = TH2D( "signalEv_" + str(varset[0]) + "_vs_" + str(varset[1]) + "_all", "signalEv_" + str(varset[0]) + "_vs_" + str(varset[1]) + "_all", len(binning1) - 1, np.asarray(binning1), len(binning2) - 1, np.asarray(binning2)) th2sigtot.GetXaxis().SetTitle(str(varset[0])) th2sigtot.GetYaxis().SetTitle(str(varset[1])) for proc in procs: for cat in cats: print "reading ds " + str(proc) + "_" + str(cat) + " from ws" dataset = wspace.data(str(proc) + "_" + str(cat)) dataset.Print() th2sig = TH2D( "signalEv_" + str(varset[0]) + "_vs_" + str(varset[1]) + "_" + str(proc) + "_" + str(cat), "signalEv_" + str(varset[0]) + "_vs_" + str(varset[1]) + "_" + str(proc) + "_" + str(cat), len(binning1) - 1, np.asarray(binning1), len(binning2) - 1, np.asarray(binning2)) th2sig.GetXaxis().SetTitle(str(varset[0])) th2sig.GetYaxis().SetTitle(str(varset[1])) for bound1 in range(len(varset[-2]) - 1): for bound2 in range(len(varset[-1]) - 1): if isData: dname = str(proc) + "_" + str( cat) + "_" + varset[0] + "_" + str( varset[-2][bound1]) + "to" + str( varset[-2][bound1 + 1]) else: # dname = str(proc)+"_"+str(cat)+"_"+varset[0]+"_"+str(varset[-2][bound1])+"to"+str(varset[-2][bound1+1])+"_Vs_"+varset[1]+"_"+str(varset[-1][bound2])+"to"+str(varset[-1][bound2+1]) dname = str( proc.split('_', 1)[0] ) + "_" + varset[0] + "_" + str( varset[-2][bound1] ) + "to" + str(varset[-2][bound1 + 1]) + "_" + str( proc.split('_', 1)[1]) + "_" + str( cat) + "_" + varset[1] + "_" + str( varset[-1][bound2]) + "to" + str( varset[-1][bound2 + 1]) datRed = dataset.Clone(dname) datRed.reset() datasetsReduced[dname] = datRed val = 0. maxEntries = dataset.numEntries() if options.maxEntries != -1: maxEntries = options.maxEntries for i in range(maxEntries): if i % 10000 == 0: print i iset = dataset.get(i) val1 = iset.getRealValue(varset[0]) val2 = iset.getRealValue(varset[1]) # print val1,val2 for bound1, bound2 in ( (b1, b2) for b1 in range(len(varset[-2]) - 1) for b2 in range(len(varset[-1]) - 1)): if isData: selCondition = (val1 > varset[-2][bound1]) and ( val1 < varset[-2][bound1 + 1]) dname = str(proc) + "_" + str( cat) + "_" + varset[0] + "_" + str( varset[-2][bound1]) + "to" + str( varset[-2][bound1 + 1]) else: selCondition = (val1 > varset[-2][bound1]) and ( val1 < varset[-2][bound1 + 1]) and ( val2 > varset[-1][bound2]) and ( val2 < varset[-1][bound2 + 1]) # dname = str(proc)+"_"+str(cat)+"_"+varset[0]+"_"+str(varset[-2][bound1])+"to"+str(varset[-2][bound1+1])+"_Vs_"+varset[1]+"_"+str(varset[-1][bound2])+"to"+str(varset[-1][bound2+1]) dname = str( proc.split('_', 1)[0] ) + "_" + varset[0] + "_" + str( varset[-2][bound1] ) + "to" + str(varset[-2][bound1 + 1]) + "_" + str( proc.split('_', 1)[1]) + "_" + str( cat) + "_" + varset[1] + "_" + str( varset[-1][bound2]) + "to" + str( varset[-1][bound2 + 1]) if selCondition: # print "filling dataset" ## print dataset.weight() datasetsReduced[dname].add(iset, dataset.weight()) break for bound1 in range(len(varset[-2]) - 1): for bound2 in range(len(varset[-1]) - 1): if isData: dname = str(proc) + "_" + str( cat) + "_" + varset[0] + "_" + str( varset[-2][bound1]) + "to" + str( varset[-2][bound1 + 1]) else: dname = str( proc.split('_', 1)[0] ) + "_" + varset[0] + "_" + str( varset[-2][bound1] ) + "to" + str(varset[-2][bound1 + 1]) + "_" + str( proc.split('_', 1)[1]) + "_" + str( cat) + "_" + varset[1] + "_" + str( varset[-1][bound2]) + "to" + str( varset[-1][bound2 + 1]) print "binning1 ", float(binning1[bound1]) + ( float(binning1[bound1 + 1]) - float(binning1[bound1])) / 2. print binning1[bound1 + 1] print binning1[bound1] print "cat1 ", (float(varset[-2][bound1 + 1]) - float(varset[-2][bound1])) / 2. print "binning2 ", float(binning2[bound2]) + ( float(binning2[bound2 + 1]) - float(binning2[bound2])) / 2. print binning2[bound2 + 1] print binning2[bound2] print "cat2 ", (float(varset[-1][bound2 + 1]) - float(varset[-1][bound2])) / 2. print "sumentries ", datasetsReduced[ dname].sumEntries() th2sig.Fill( float(binning1[bound1]) + (float(binning1[bound1 + 1]) - float(binning1[bound1])) / 2., float(binning2[bound2]) + (float(binning2[bound2 + 1]) - float(binning2[bound2])) / 2., datasetsReduced[dname].sumEntries()) th2sig.Print("V") c.cd() if options.logz: c.SetLogz(1) th2sigtot.Add(th2sig) th2sig.Draw("colz") for fmt in savefmts: savename = th2sig.GetName() if options.logz: savename = str(savename) + "_logz" c.SaveAs(str(savename) + str(fmt)) c.cd() if options.logz: c.SetLogz(1) th2sigtot.Draw("colz") savename = th2sigtot.GetName() if options.logz: savename = str(savename) + "_logz" for fmt in savefmts: c.SaveAs(str(savename) + str(fmt)) # print "#### Compare reductions ####" new_wspace = RooWorkspace("cms_hgg_13TeV") getattr(new_wspace, 'import')(wspace.var("CMS_hgg_mass")) getattr(new_wspace, 'import')(wspace.var("IntLumi")) if not isData: getattr(new_wspace, 'import')(wspace.var("dZ")) getattr(new_wspace, 'import')(wspace.var("weight")) # alldata = new_wspace.allData() # for ds in alldata : # new_wspace.removeSet(str(ds.GetName())) outfilename = options.outfile.split('.')[0] + '_' + str( varset[0]) + '_3th2.root' outfile = TFile(outfilename, 'RECREATE') stepsize = int(len(datasetsReduced.keys()) / 10) iteration = 0 while (len(datasetsReduced.keys()) > 0): print 'iteration ' + str(iteration) iteration = iteration + 1 try: outfile except NameError: outfile = TFile(outfilename, 'UPDATE') try: new_wspace except NameError: outfile.ls() new_wspace = outfile.Get("cms_hgg_13TeV") print "cms_hgg_13TeV;1" gDirectory.Delete("cms_hgg_13TeV;1") outfile.ls() # if not 'outfile' in globals(): # print 'outfile is not defined' # outfile = TFile(options.outfile, 'UPDATE') # if not 'new_wspace' in globals(): # new_wspace = outfile.Get("cms_hgg_13TeV") # print 'newspace is not defined' written = [] if stepsize > len(datasetsReduced.keys()): stepsize = len(datasetsReduced.keys()) for ikey in range(stepsize): # for ikey in range(len(datasetsReduced.keys())): # dataset.Print("V") # if dataset.numEntries() > 100: getattr(new_wspace, 'import')( datasetsReduced[datasetsReduced.keys()[ikey]]) datasetsReduced[datasetsReduced.keys()[ikey]].Write() written.append(datasetsReduced.keys()[ikey]) print 'Number of data in ws ' print len(new_wspace.allData()) #new_wspace.Print() new_wspace.Write() outfile.Write() outfile.Close() for wkey in written: del datasetsReduced[wkey] del new_wspace del outfile
def makeCard(TYPE, mZp, mChi, DIR): # Setup input and output files indir = DIR old_str = "" new_str = "" if (TYPE == "BARY"): old_str = "sig_ZpBaryonic_mZP10_mChi1" new_str = "sig_ZpBaryonic_mZP" + mZp + "_mChi" + mChi if (TYPE == "2HDM"): old_str = "sig_2HDM_mZP600_mA0300" new_str = "sig_2HDM_mZP" + mZp + "_mA0" + mChi fin = open(indir + "dataCard_" + old_str + "_13TeV.txt", "r") fout = open(indir + "dataCard_" + new_str + "_13TeV.txt", "w") rin = ROOT.TFile(indir + old_str + "_13TeV.root") rout = ROOT.TFile(indir + new_str + "_13TeV.root", "RECREATE") # Copy the datacard for new mass point for line in fin: if old_str in line: line = line.replace(old_str, new_str) fout.write(line) # Get the old and new eff mZ = float(mZp) mDM = float(mChi) old_efflowMET = 1.0 old_effhighMET = 1.0 new_efflowMET = 1.0 new_effhighMET = 1.0 if (TYPE == "BARY"): old_efflowMET = getEffBary(0, 10, 1) old_effhighMET = getEffBary(1, 10, 1) new_efflowMET = getEffBary(0, mZ, mDM) new_effhighMET = getEffBary(1, mZ, mDM) if (TYPE == "2HDM"): old_efflowMET = getEff2HDM(0, 600, 300) old_effhighMET = getEff2HDM(1, 600, 300) new_efflowMET = getEff2HDM(0, mZ, mDM) new_effhighMET = getEff2HDM(1, mZ, mDM) scale_lowMET = new_efflowMET / old_efflowMET scale_highMET = new_effhighMET / old_effhighMET #print("Old eff: low = %f, high = %f" %(old_efflowMET,old_effhighMET)) #print("New eff: low = %f, high = %f" %(new_efflowMET,new_effhighMET)) #print("Scale: low = %f, high = %f" %(scale_lowMET,scale_highMET)) # Copy the input file in_TObjString = TObjString(rin.cfg) out_TObjString = in_TObjString.Clone() in_RooWorkspace = RooWorkspace(rin.wtemplates) #in_RooWorkspace.Print() # print obj in input rooWorkspace w1 = ROOT.RooWorkspace("wtemplates") w1.rooImport = getattr(w1, 'import') var1 = in_RooWorkspace.var('mgg') var2 = in_RooWorkspace.var('model_signal_' + old_str + '_13TeV_met0-130_norm') var3 = in_RooWorkspace.var('model_signal_' + old_str + '_13TeV_met130_norm') # multiply old normalization by new scale valnorm_lowMET = scale_lowMET * var2.getValV() valnorm_highMET = scale_highMET * var3.getValV() norm1 = RooRealVar("model_signal_" + new_str + "_13TeV_met0-130_norm", "model_signal" + new_str + "13TeV_met0-130_norm", valnorm_lowMET) norm2 = RooRealVar("model_signal_" + new_str + "_13TeV_met130_norm", "model_signal" + new_str + "13TeV_met130_norm", valnorm_highMET) varlist = ROOT.RooArgList(var1, norm1, norm2) #print("%f * %f" %(scale_lowMET,var2.getValV())) #print("%f" %valnorm_lowMET) #print("%f" %norm1.getValV()) # get old pdfs and change names pdf1 = in_RooWorkspace.pdf('model_signal_' + old_str + '_13TeV_met0-130') pdf2 = in_RooWorkspace.pdf('model_signal_' + old_str + '_13TeV_met0-130_energyScalemet0-130Down') pdf3 = in_RooWorkspace.pdf('model_signal_' + old_str + '_13TeV_met0-130_energyScalemet0-130Up') pdf4 = in_RooWorkspace.pdf('model_signal_' + old_str + '_13TeV_met130') pdf5 = in_RooWorkspace.pdf('model_signal_' + old_str + '_13TeV_met130_energyScalemet130Down') pdf6 = in_RooWorkspace.pdf('model_signal_' + old_str + '_13TeV_met130_energyScalemet130Up') pdf1new = ROOT.RooHistPdf(pdf1, "model_signal_" + new_str + "_13TeV_met0-130") pdf2new = ROOT.RooHistPdf( pdf2, "model_signal_" + new_str + "_13TeV_met0-130_energyScalemet0-130Down") pdf3new = ROOT.RooHistPdf( pdf3, "model_signal_" + new_str + "_13TeV_met0-130_energyScalemet0-130Up") pdf4new = ROOT.RooHistPdf(pdf4, "model_signal_" + new_str + "_13TeV_met130") pdf5new = ROOT.RooHistPdf( pdf5, "model_signal_" + new_str + "_13TeV_met130_energyScalemet130Down") pdf6new = ROOT.RooHistPdf( pdf6, "model_signal_" + new_str + "_13TeV_met130_energyScalemet130Up") # these are null pointers -- probably don't have right classes (missing from dipho analysis) to read them # but they are also not needed for running higgs combine so left out for now dat1 = in_RooWorkspace.data('signal_' + old_str + '_13TeV_met130') dat2 = in_RooWorkspace.data('signalforPdf_' + old_str + '_13TeV_met130') dat3 = in_RooWorkspace.data('signal_' + old_str + '_13TeV_met0-130') dat4 = in_RooWorkspace.data('signalforPdf_' + old_str + '_13TeV_met0-130') #print("%f" %dat1.sumEntries()) # Write to output file #out_TObjString.Write() w1.rooImport(var1) w1.rooImport(norm1) w1.rooImport(norm2) w1.rooImport(pdf1new) w1.rooImport(pdf2new) w1.rooImport(pdf3new) w1.rooImport(pdf4new) w1.rooImport(pdf5new) w1.rooImport(pdf6new) #w1.Print() # print contents of workspace w1.Write() rout.Close()
def signal(category): interPar = True n = len(genPoints) cColor = color[category] if category in color else 4 nBtag = category.count('b') isAH = False #relict from using Alberto's more complex script if not os.path.exists(PLOTDIR + "MC_signal_" + YEAR): os.makedirs(PLOTDIR + "MC_signal_" + YEAR) #*******************************************************# # # # Variables and selections # # # #*******************************************************# X_mass = RooRealVar("jj_mass_widejet", "m_{jj}", X_min, X_max, "GeV") j1_pt = RooRealVar("jpt_1", "jet1 pt", 0., 13000., "GeV") jj_deltaEta = RooRealVar("jj_deltaEta_widejet", "", 0., 5.) jbtag_WP_1 = RooRealVar("jbtag_WP_1", "", -1., 4.) jbtag_WP_2 = RooRealVar("jbtag_WP_2", "", -1., 4.) fatjetmass_1 = RooRealVar("fatjetmass_1", "", -1., 2500.) fatjetmass_2 = RooRealVar("fatjetmass_2", "", -1., 2500.) jid_1 = RooRealVar("jid_1", "j1 ID", -1., 8.) jid_2 = RooRealVar("jid_2", "j2 ID", -1., 8.) jnmuons_1 = RooRealVar("jnmuons_1", "j1 n_{#mu}", -1., 8.) jnmuons_2 = RooRealVar("jnmuons_2", "j2 n_{#mu}", -1., 8.) jnmuons_loose_1 = RooRealVar("jnmuons_loose_1", "jnmuons_loose_1", -1., 8.) jnmuons_loose_2 = RooRealVar("jnmuons_loose_2", "jnmuons_loose_2", -1., 8.) nmuons = RooRealVar("nmuons", "n_{#mu}", -1., 10.) nelectrons = RooRealVar("nelectrons", "n_{e}", -1., 10.) HLT_AK8PFJet500 = RooRealVar("HLT_AK8PFJet500", "", -1., 1.) HLT_PFJet500 = RooRealVar("HLT_PFJet500", "", -1., 1.) HLT_CaloJet500_NoJetID = RooRealVar("HLT_CaloJet500_NoJetID", "", -1., 1.) HLT_PFHT900 = RooRealVar("HLT_PFHT900", "", -1., 1.) HLT_AK8PFJet550 = RooRealVar("HLT_AK8PFJet550", "", -1., 1.) HLT_PFJet550 = RooRealVar("HLT_PFJet550", "", -1., 1.) HLT_CaloJet550_NoJetID = RooRealVar("HLT_CaloJet550_NoJetID", "", -1., 1.) HLT_PFHT1050 = RooRealVar("HLT_PFHT1050", "", -1., 1.) #HLT_DoublePFJets100_CaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets100_CaloBTagDeepCSV_p71" , "", -1., 1. ) #HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71", "", -1., 1. ) #HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71", "", -1., 1. ) #HLT_DoublePFJets200_CaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets200_CaloBTagDeepCSV_p71" , "", -1., 1. ) #HLT_DoublePFJets350_CaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets350_CaloBTagDeepCSV_p71" , "", -1., 1. ) #HLT_DoublePFJets40_CaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets40_CaloBTagDeepCSV_p71" , "", -1., 1. ) weight = RooRealVar("eventWeightLumi", "", -1.e9, 1.e9) # 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) variables.add( RooArgSet(j1_pt, jj_deltaEta, jbtag_WP_1, jbtag_WP_2, fatjetmass_1, fatjetmass_2, jnmuons_1, jnmuons_2, weight)) variables.add( RooArgSet(nmuons, nelectrons, jid_1, jid_2, jnmuons_loose_1, jnmuons_loose_2)) variables.add( RooArgSet(HLT_AK8PFJet500, HLT_PFJet500, HLT_CaloJet500_NoJetID, HLT_PFHT900, HLT_AK8PFJet550, HLT_PFJet550, HLT_CaloJet550_NoJetID, HLT_PFHT1050)) #variables.add(RooArgSet(HLT_DoublePFJets100_CaloBTagDeepCSV_p71, HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71, HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71, HLT_DoublePFJets200_CaloBTagDeepCSV_p71, HLT_DoublePFJets350_CaloBTagDeepCSV_p71, HLT_DoublePFJets40_CaloBTagDeepCSV_p71)) X_mass.setRange("X_reasonable_range", X_mass.getMin(), X_mass.getMax()) X_mass.setRange("X_integration_range", X_mass.getMin(), X_mass.getMax()) if VARBINS: binsXmass = RooBinning(len(abins) - 1, abins) X_mass.setBinning(binsXmass) plot_binning = RooBinning( int((X_mass.getMax() - X_mass.getMin()) / 100.), X_mass.getMin(), X_mass.getMax()) else: X_mass.setBins(int((X_mass.getMax() - X_mass.getMin()) / 10)) binsXmass = RooBinning(int((X_mass.getMax() - X_mass.getMin()) / 100.), X_mass.getMin(), X_mass.getMax()) plot_binning = binsXmass X_mass.setBinning(plot_binning, "PLOT") #X_mass.setBins(int((X_mass.getMax() - X_mass.getMin())/10)) #binsXmass = RooBinning(int((X_mass.getMax() - X_mass.getMin())/100), X_mass.getMin(), X_mass.getMax()) #X_mass.setBinning(binsXmass, "PLOT") massArg = RooArgSet(X_mass) # Cuts if BTAGGING == 'semimedium': SRcut = aliasSM[category] #SRcut = aliasSM[category+"_vetoAK8"] else: SRcut = alias[category].format(WP=working_points[BTAGGING]) #SRcut = alias[category+"_vetoAK8"].format(WP=working_points[BTAGGING]) if ADDSELECTION: SRcut += SELECTIONS[options.selection] print " Cut:\t", SRcut #*******************************************************# # # # Signal fits # # # #*******************************************************# treeSign = {} setSignal = {} vmean = {} vsigma = {} valpha1 = {} vslope1 = {} valpha2 = {} vslope2 = {} smean = {} ssigma = {} salpha1 = {} sslope1 = {} salpha2 = {} sslope2 = {} sbrwig = {} signal = {} signalExt = {} signalYield = {} signalIntegral = {} signalNorm = {} signalXS = {} frSignal = {} frSignal1 = {} frSignal2 = {} frSignal3 = {} # Signal shape uncertainties (common amongst all mass points) xmean_jes = RooRealVar( "CMS" + YEAR + "_sig_" + category + "_p1_scale_jes", "Variation of the resonance position with the jet energy scale", 0.02, -1., 1.) #0.001 smean_jes = RooRealVar( "CMS" + YEAR + "_sig_" + category + "_p1_jes", "Change of the resonance position with the jet energy scale", 0., -10, 10) xsigma_jer = RooRealVar( "CMS" + YEAR + "_sig_" + category + "_p2_scale_jer", "Variation of the resonance width with the jet energy resolution", 0.10, -1., 1.) ssigma_jer = RooRealVar( "CMS" + YEAR + "_sig_" + category + "_p2_jer", "Change of the resonance width with the jet energy resolution", 0., -10, 10) xmean_jes.setConstant(True) smean_jes.setConstant(True) xsigma_jer.setConstant(True) ssigma_jer.setConstant(True) for m in massPoints: signalMass = "%s_M%d" % (stype, m) signalName = "ZpBB_{}_{}_M{}".format(YEAR, category, m) sampleName = "ZpBB_M{}".format(m) signalColor = sample[sampleName][ 'linecolor'] if signalName in sample else 1 # define the signal PDF vmean[m] = RooRealVar(signalName + "_vmean", "Crystal Ball mean", m, m * 0.96, m * 1.05) smean[m] = RooFormulaVar(signalName + "_mean", "@0*(1+@1*@2)", RooArgList(vmean[m], xmean_jes, smean_jes)) vsigma[m] = RooRealVar(signalName + "_vsigma", "Crystal Ball sigma", m * 0.0233, m * 0.019, m * 0.025) ssigma[m] = RooFormulaVar( signalName + "_sigma", "@0*(1+@1*@2)", RooArgList(vsigma[m], xsigma_jer, ssigma_jer)) valpha1[m] = RooRealVar( signalName + "_valpha1", "Crystal Ball alpha 1", 0.2, 0.05, 0.28 ) # number of sigmas where the exp is attached to the gaussian core. >0 left, <0 right salpha1[m] = RooFormulaVar(signalName + "_alpha1", "@0", RooArgList(valpha1[m])) #vslope1[m] = RooRealVar(signalName + "_vslope1", "Crystal Ball slope 1", 10., 0.1, 20.) # slope of the power tail vslope1[m] = RooRealVar(signalName + "_vslope1", "Crystal Ball slope 1", 13., 10., 20.) # slope of the power tail sslope1[m] = RooFormulaVar(signalName + "_slope1", "@0", RooArgList(vslope1[m])) valpha2[m] = RooRealVar(signalName + "_valpha2", "Crystal Ball alpha 2", 1.) valpha2[m].setConstant(True) salpha2[m] = RooFormulaVar(signalName + "_alpha2", "@0", RooArgList(valpha2[m])) #vslope2[m] = RooRealVar(signalName + "_vslope2", "Crystal Ball slope 2", 6., 2.5, 15.) # slope of the higher power tail ## FIXME test FIXME vslope2_estimation = -5.88111436852 + m * 0.00728809389442 + m * m * ( -1.65059568762e-06) + m * m * m * (1.25128996309e-10) vslope2[m] = RooRealVar(signalName + "_vslope2", "Crystal Ball slope 2", vslope2_estimation, vslope2_estimation * 0.9, vslope2_estimation * 1.1) # slope of the higher power tail ## FIXME end FIXME sslope2[m] = RooFormulaVar( signalName + "_slope2", "@0", RooArgList(vslope2[m])) # slope of the higher power tail signal[m] = RooDoubleCrystalBall(signalName, "m_{%s'} = %d GeV" % ('X', m), X_mass, smean[m], ssigma[m], salpha1[m], sslope1[m], salpha2[m], sslope2[m]) # extend the PDF with the yield to perform an extended likelihood fit signalYield[m] = RooRealVar(signalName + "_yield", "signalYield", 50, 0., 1.e15) signalNorm[m] = RooRealVar(signalName + "_norm", "signalNorm", 1., 0., 1.e15) signalXS[m] = RooRealVar(signalName + "_xs", "signalXS", 1., 0., 1.e15) signalExt[m] = RooExtendPdf(signalName + "_ext", "extended p.d.f", signal[m], signalYield[m]) # ---------- 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") if YEAR == 'run2': pd = sample[sampleName]['files'] if len(pd) > 3: print "multiple files given than years for a single masspoint:", pd sys.exit() for ss in pd: if not '2016' in ss and not '2017' in ss and not '2018' in ss: print "unknown year given in:", ss sys.exit() else: pd = [x for x in sample[sampleName]['files'] if YEAR in x] if len(pd) > 1: print "multiple files given for a single masspoint/year:", pd sys.exit() for ss in pd: if options.unskimmed: j = 0 while True: if os.path.exists(NTUPLEDIR + ss + "/" + ss + "_flatTuple_{}.root".format(j)): treeSign[m].Add(NTUPLEDIR + ss + "/" + ss + "_flatTuple_{}.root".format(j)) j += 1 else: print "found {} files for sample:".format(j), ss break else: if os.path.exists(NTUPLEDIR + ss + ".root"): treeSign[m].Add(NTUPLEDIR + ss + ".root") else: print "found no file for sample:", ss 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("eventWeightLumi*BTagAK4Weight_deepJet"), RooFit.Import(treeSign[m])) 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 entries = setSignal[m].sumEntries() if entries < 0. or entries != entries: entries = 0 signalYield[m].setVal(entries) # Instead of eventWeightLumi #signalYield[m].setVal(entries * LUMI / (300000 if YEAR=='run2' else 100000) ) 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 + "_" + category, stype + category, X_mass, signal[m], setSignal[m], frSignal[m]) else: print " WARNING: signal", stype, "and mass point", m, "in category", category, "has 0 entries or does not exist" # Remove HVT cross sections #xs = getCrossSection(stype, channel, m) xs = 1. signalXS[m].setVal(xs * 1000.) signalIntegral[m] = signalExt[m].createIntegral( massArg, RooFit.NormSet(massArg), RooFit.Range("X_integration_range")) boundaryFactor = signalIntegral[m].getVal() if boundaryFactor < 0. or boundaryFactor != boundaryFactor: boundaryFactor = 0 if VERBOSE: print " - Fit normalization vs integral:", signalYield[ m].getVal(), "/", boundaryFactor, "events" signalNorm[m].setVal(boundaryFactor * signalYield[m].getVal() / signalXS[m].getVal() ) # here normalize to sigma(X) x Br = 1 [fb] vmean[m].setConstant(True) vsigma[m].setConstant(True) valpha1[m].setConstant(True) vslope1[m].setConstant(True) valpha2[m].setConstant(True) vslope2[m].setConstant(True) signalNorm[m].setConstant(True) signalXS[m].setConstant(True) #*******************************************************# # # # Signal interpolation # # # #*******************************************************# ### FIXME FIXME just for a test FIXME FIXME #print #print #print "slope2 fit results:" #print #y_vals = [] #for m in genPoints: # y_vals.append(vslope2[m].getVal()) #print "m =", genPoints #print "y =", y_vals #sys.exit() ### FIXME FIXME test end FIXME FIXME # ====== CONTROL PLOT ====== color_scheme = [ 636, 635, 634, 633, 632, 633, 636, 635, 634, 633, 632, 633, 636, 635, 634, 633, 632, 633, 636, 635, 634, 633, 632, 633, 636, 635, 634, 633, 632, 633, 636, 635, 634, 633, 632, 633, 636, 635, 634, 633, 632, 633 ] c_signal = TCanvas("c_signal", "c_signal", 800, 600) c_signal.cd() frame_signal = X_mass.frame() for j, m in enumerate(genPoints): if m in signalExt.keys(): #print "color:",(j%9)+1 #print "signalNorm[m].getVal() =", signalNorm[m].getVal() #print "RooAbsReal.NumEvent =", RooAbsReal.NumEvent signal[m].plotOn( frame_signal, RooFit.LineColor(color_scheme[j]), RooFit.Normalization(signalNorm[m].getVal(), RooAbsReal.NumEvent), RooFit.Range("X_reasonable_range")) frame_signal.GetXaxis().SetRangeUser(0, 10000) frame_signal.Draw() drawCMS(-1, "Simulation Preliminary", year=YEAR) #drawCMS(-1, "Work in Progress", year=YEAR, suppressCMS=True) #drawCMS(-1, "", year=YEAR, suppressCMS=True) drawAnalysis(category) drawRegion(category) c_signal.SaveAs(PLOTDIR + "MC_signal_" + YEAR + "/" + stype + "_" + category + "_Signal.pdf") c_signal.SaveAs(PLOTDIR + "MC_signal_" + YEAR + "/" + stype + "_" + category + "_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", 700, 3000) 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, 10000) 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, 10000) 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", "pol1", 0, 10000) #pol0 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", "pol1", 0, 10000) #pol0 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", "pol1", 0, 10000) #pol0 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", "pol1", 0, 10000) #pol0 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 if gnorm.GetMaximum() < signalNorm[m].getVal(): gnorm.SetMaximum(signalNorm[m].getVal()) gnorm.SetPoint(n, m, signalNorm[m].getVal()) #gnorm.SetPointError(i, 0, signalNorm[m].getVal()/math.sqrt(treeSign[m].GetEntriesFast())) 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(valpha2[m].getError(), valpha2[m].getVal() * 0.10)) gslope2.SetPoint(n, m, sslope2[m].getVal()) gslope2.SetPointError( n, 0, min(vslope2[m].getError(), vslope2[m].getVal() * 0.10)) #tmpVar = w.var(var+"_"+signalString) #print m, tmpVar.getVal(), tmpVar.getError() n = n + 1 gmean.Fit(fmean, "Q0", "SAME") gsigma.Fit(fsigma, "Q0", "SAME") galpha1.Fit(falpha1, "Q0", "SAME") gslope1.Fit(fslope1, "Q0", "SAME") galpha2.Fit(falpha2, "Q0", "SAME") gslope2.Fit(fslope2, "Q0", "SAME") # gnorm.Fit(fnorm, "Q0", "", 700, 5000) #for m in [5000, 5500]: gnorm.SetPoint(gnorm.GetN(), m, gnorm.Eval(m, 0, "S")) #gnorm.Fit(fnorm, "Q", "SAME", 700, 6000) gnorm.Fit(fnorm, "Q", "SAME", 1800, 8000) ## adjusted recently for m in massPoints: 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) #jalpha2 = galpha2.Eval(m) #jslope2 = gslope2.Eval(m) jmean = gmean.Eval(m, 0, "S") jsigma = gsigma.Eval(m, 0, "S") jalpha1 = galpha1.Eval(m, 0, "S") jslope1 = gslope1.Eval(m, 0, "S") jalpha2 = galpha2.Eval(m, 0, "S") jslope2 = gslope2.Eval(m, 0, "S") 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 jalpha2 = falpha2.GetParameter(0) + falpha2.GetParameter( 1) * m + falpha2.GetParameter(2) * m * m jslope2 = fslope2.GetParameter(0) + fslope2.GetParameter( 1) * m + fslope2.GetParameter(2) * m * m inorm.SetPoint(inorm.GetN(), m, syield) signalNorm[m].setVal(max(0., 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) ialpha2.SetPoint(ialpha2.GetN(), m, jalpha2) if not jalpha2 == 0: valpha2[m].setVal(jalpha2) islope2.SetPoint(islope2.GetN(), m, jslope2) if jslope2 > 0: vslope2[m].setVal(jslope2) #### newly introduced, not yet sure if helpful: vmean[m].removeError() vsigma[m].removeError() valpha1[m].removeError() valpha2[m].removeError() vslope1[m].removeError() vslope2[m].removeError() #signalNorm[m].setConstant(False) ## newly put here to ensure it's freely floating in the combine fit #c1 = TCanvas("c1", "Crystal Ball", 1200, 1200) #if not isAH else 1200 #c1.Divide(2, 3) c1 = TCanvas("c1", "Crystal Ball", 1800, 800) c1.Divide(3, 2) c1.cd(1) gmean.SetMinimum(0.) gmean.Draw("APL") imean.Draw("P, SAME") drawRegion(category) drawCMS(-1, "Simulation Preliminary", year=YEAR) ## new FIXME c1.cd(2) gsigma.SetMinimum(0.) gsigma.Draw("APL") isigma.Draw("P, SAME") drawRegion(category) drawCMS(-1, "Simulation Preliminary", year=YEAR) ## new FIXME c1.cd(3) galpha1.Draw("APL") ialpha1.Draw("P, SAME") drawRegion(category) drawCMS(-1, "Simulation Preliminary", year=YEAR) ## new FIXME galpha1.GetYaxis().SetRangeUser(0., 1.1) #adjusted upper limit from 5 to 2 c1.cd(4) gslope1.Draw("APL") islope1.Draw("P, SAME") drawRegion(category) drawCMS(-1, "Simulation Preliminary", year=YEAR) ## new FIXME gslope1.GetYaxis().SetRangeUser(0., 150.) #adjusted upper limit from 125 to 60 if True: #isAH: c1.cd(5) galpha2.Draw("APL") ialpha2.Draw("P, SAME") drawRegion(category) drawCMS(-1, "Simulation Preliminary", year=YEAR) ## new FIXME galpha2.GetYaxis().SetRangeUser(0., 2.) c1.cd(6) gslope2.Draw("APL") islope2.Draw("P, SAME") drawRegion(category) drawCMS(-1, "Simulation Preliminary", year=YEAR) ## new FIXME gslope2.GetYaxis().SetRangeUser(0., 20.) c1.Print(PLOTDIR + "MC_signal_" + YEAR + "/" + stype + "_" + category + "_SignalShape.pdf") c1.Print(PLOTDIR + "MC_signal_" + YEAR + "/" + stype + "_" + category + "_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, "Simulation Preliminary", year=YEAR) #drawCMS(-1, "Work in Progress", year=YEAR, suppressCMS=True) #drawCMS(-1, "", year=YEAR, suppressCMS=True) drawAnalysis(category) drawRegion(category) c2.Print(PLOTDIR + "MC_signal_" + YEAR + "/" + stype + "_" + category + "_SignalNorm.pdf") c2.Print(PLOTDIR + "MC_signal_" + YEAR + "/" + stype + "_" + category + "_SignalNorm.png") #*******************************************************# # # # Generate workspace # # # #*******************************************************# # create workspace w = RooWorkspace("Zprime_" + YEAR, "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(WORKDIR + "MC_signal_%s_%s.root" % (YEAR, category), True) print "Workspace", WORKDIR + "MC_signal_%s_%s.root" % ( YEAR, category), "saved successfully"
#tree.Add("/afs/cern.ch/user/d/demattia/public/TagAndProbe/TagAndProbe_ZMuMu.root") tree.Add( "/afs/cern.ch/user/d/demattia/public/TagAndProbe/TagAndProbe_Run2012A.root" ) tree.Add( "/afs/cern.ch/user/d/demattia/public/TagAndProbe/TagAndProbe_Run2012B.root" ) tree.Add( "/afs/cern.ch/user/d/demattia/public/TagAndProbe/TagAndProbe_Run2012C.root" ) tree.Add( "/afs/cern.ch/user/d/demattia/public/TagAndProbe/TagAndProbe_Run2012D.root" ) # Prepare the workspace ws = RooWorkspace("ws", "workspace") Workspace.buildPdf(ws, p) mass = ws.var("mass") sample = ws.cat("sample") simPdf = ws.pdf("simPdf") efficiency = ws.var("efficiency") meanB = ws.var("meanB") # prepare_datasets(ws, p) # Prepare datasets datasetAllMap = {} datasetPassMap = {} hAllMap = {} hPassMap = {}
binWidth = 1. if opts.sipm: # maxMip = int(maxPed + pedRms*80) + 0.5 maxMip = int(maxPed + pedRms * 100) + 0.5 binWidth = 5. else: maxMip = int(maxPed + pedRms * 20) + 0.5 while int((maxMip - minMip) / binWidth) * binWidth < (maxMip - minMip): maxMip += 1 Nbins = int((maxMip - minMip) / binWidth + 0.5) print 'ped min: {0:0.2f} max: {1:0.2f}'.format(minPed,maxPed), \ 'sig min: {0:0.1f} max: {1:0.1f}'.format(minMip, maxMip) ws = RooWorkspace('ws') x = RooRealVar('x', 'energy', minMip, maxMip, 'fC') dataTree.Draw( '{0}>>ped_hist({1},{2:0.1f},{3:0.1f})'.format(HOTower, int(maxPed - minPed), minPed, maxPed), pedCut, 'goff') ped_hist = gDirectory.Get('ped_hist') ped_hist.SetLineColor(myBlue) xfped = x.frame(minPed, maxPed, int(maxPed - minPed)) if havePeds: pedDS = fillDataSet(dataTree.GetV1(), x, dataTree.GetSelectedRows()) getattr(ws, 'import')(pedDS) if pedDS.numEntries() < 5:
hData) rooDataHist.Print() if args.runFit: res = model.fitTo(rooDataHist, RooFit.Save(kTRUE), RooFit.Strategy(args.fitStrategy)) if not args.decoBkg: res.Print() # decorrelated background parameters for Bayesian limits if args.decoBkg: signal_norm.setConstant() res = model.fitTo(rooDataHist, RooFit.Save(kTRUE), RooFit.Strategy(args.fitStrategy)) res.Print() ## temp workspace for the PDF diagonalizer w_tmp = RooWorkspace("w_tmp") deco = PdfDiagonalizer("deco", w_tmp, res) # here diagonalizing only the shape parameters since the overall normalization is already decorrelated background_deco = deco.diagonalize(background) print "##################### workspace for decorrelation" w_tmp.Print("v") print "##################### original parameters" background.getParameters(rooDataHist).Print("v") print "##################### decorrelated parameters" # needed if want to evaluate limits without background systematics if args.fixBkg: w_tmp.var("deco_eig1").setConstant() w_tmp.var("deco_eig2").setConstant() if not args.fixP3: w_tmp.var("deco_eig3").setConstant() background_deco.getParameters(rooDataHist).Print("v") print "##################### original pdf"
#space.loadSnapshot(snapshot) return None def recTime(mesg): global currenttime rectime = currenttime currenttime = time.time() txtRecFile.write('{0} in {1} minutes\n'.format( mesg, int((currenttime - rectime) / 60))) # def functions end }}} recTime('def funcs') space = RooWorkspace('space', False) # new parameters space.factory('lbl0Mass[5.4,5.9]') space.factory('tktkMass[0.5,2.0]') space.factory('lbl0Pt[0.,200.]') ########## load workspace #################### workspaceFile1 = TFile.Open('store_root/workspace_0thStep_LbL0Shape.root') space1st = workspaceFile1.Get('space') space1st.SetName('space1st') spaceExt = space1st load2016Data = True if load2016Data: toyCheck = False
RooRealVar(varName, tree1.GetBranch(varName).GetTitle(), tree1.GetMinimum(varName), tree1.GetMaximum(varName)) ] varRenamedList += [RooFit.RenameVariable(varName, tupleDict[varName])] #RooFit.RenameVariable(varName, tupleDict[varName]); #varList[i].SetName(tupleDict.keys()[i]); #tupleDataSet = RooDataSet("treeData","treeData",tree1,RooArgSet(*varList)); weightvar = RooRealVar("weight", "weight", -1e7, 1e7) tupleDataSet = RooDataSet("tupleDataSet", "tupleDataSet", RooArgSet(*varList), RooFit.Import(tree1), RooFit.WeightVar(weightvar)) ws = RooWorkspace('ws_FIT') tupleDataSet = WS(ws, tupleDataSet, varRenamedList) tupleDataSet.Print() sys.exit(0) #qt needs to be a category? # Manuel's shit... #weightvar = RooRealVar("weight", "weight", -1e7, 1e7) #tupleDataSet = RooDataSet("tupleDataSet", "tupleDataSet", # RooArgSet(treetime, treeqt, treeqf, treeeta), # RooFit.Import(tree1), RooFit.WeightVar(weightvar)) #tupleDS = WS(ws, tupleDS, [ # RooFit.RenameVariable("Bs_ctau", "time"), ... ]) # # note: do not forget to add to fitTo options: RooFit.SumW2Error(True) #ROOT.SetOwnership(tupleDataSet,False);
dcFN = outdir_datacards + 'Qstar' + str(mass) + '_datacard_nuisance.txt' wsFN = outdir_datacards + 'Qstar' + str(mass) + '_workspace_nuisance.root' #dcFN = outdir_datacards+'Qstar'+str(mass)+'_datacard_nuisance_testForSignificance.txt' #wsFN = outdir_datacards+'Qstar'+str(mass)+'_workspace_nuisance_testForSignificance.root' else: dcFN = outdir_datacards + 'Qstar' + str( mass) + '_datacard_' + name + '.txt' wsFN = outdir_datacards + 'Qstar' + str( mass) + '_workspace_' + name + '.root' nObs = dataHist_data.sumEntries() #nObs = roohistBkg.sumEntries(); #nBkg = roohistBkg.sumEntries(); w = RooWorkspace('w', 'workspace') getattr(w, 'import')(signal) getattr(w, 'import')(background) getattr(w, 'import')(background_norm) getattr(w, 'import')(roohistBkg, RooFit.Rename("data_obs")) #getattr(w,'import')(dataHist_data,RooFit.Rename("data_obs")) #getattr(w,'import')(background_f6) #getattr(w,'import')(background_f6_norm) w.Print() w.writeToFile(wsFN) # ----------------------------------------- # write a datacard ##not needed #ExpectedSignalRate = signalCrossSection*LUMI*signalEfficiency
def getCard(sig, ch, ifilename, outdir, mode="histo", unblind=False): try: ifile = ROOT.TFile.Open(ifilename) except IOError: print "Cannot open ", ifilename else: print "Opening file ", ifilename ifile.cd() print syst workdir_ = ifilename.split("/")[:-1] WORKDIR = "/".join(workdir_) + "/" carddir = outdir + "/" + sig + "/" hist_filename = os.getcwd() + "/" + ifilename hist = getHist(ch, sig, ifile) #*******************************************************# # # # Generate workspace # # # #*******************************************************# if (mode == "template"): histBkgData = getHist(ch, "Bkg", ifile) histData = histBkgData if (unblind): print "BE CAREFULL: YOU ARE UNBLINDING" histData = getHist(ch, "data_obs", ifile) print "*********Number of data ", histData.Integral() histSig = getHist(ch, sig, ifile) bkgData = RooDataHist("bkgdata", "Data (MC Bkg)", RooArgList(mT), histBkgData, 1.) obsData = RooDataHist("data_obs", "(pseudo) Data", RooArgList(mT), histData, 1.) sigData = RooDataHist("sigdata", "Data (MC sig)", RooArgList(mT), histSig, 1.) print "Bkg Integral: ", histData.Integral() nBkgEvts = histBkgData.Integral() print "Bkg Events: ", nBkgEvts print "Channel: ", ch modelBkg = fitParam[ch].modelBkg normzBkg = RooRealVar(modelBkg.GetName() + "_norm", "Number of background events", nBkgEvts, 0., 1.e3) print "NormBkg ", nBkgEvts modelExt = RooExtendPdf(modelBkg.GetName() + "_ext", modelBkg.GetTitle(), modelBkg, normzBkg) # create workspace w = RooWorkspace("SVJ", "workspace") # Dataset # ATT: include isData getattr(w, "import")(bkgData, RooFit.Rename("Bkg")) getattr(w, "import")(obsData, RooFit.Rename("data_obs")) getattr(w, "import")(sigData, RooFit.Rename(sig)) for i in xrange(hist.GetNbinsX()): mcstatSysName = "mcstat_%s_%s_bin%d" % (ch, sig, i + 1) #print mcstatSysName #print sig + "_" + mcstatSysName + "Up" mcstatSigUp = getHist(ch, sig + "_" + mcstatSysName + "Up", ifile) #print "Integral ", mcstatSigUp.Integral() mcstatSigDown = getHist(ch, sig + "_" + mcstatSysName + "Down", ifile) mcstatSigHistUp = RooDataHist(sig + "_" + mcstatSysName + "Up", "Data (MC sig)", RooArgList(mT), mcstatSigUp, 1.) mcstatSigHistDown = RooDataHist(sig + "_" + mcstatSysName + "Down", "Data (MC sig)", RooArgList(mT), mcstatSigDown, 1.) getattr(w, "import")(mcstatSigHistUp, RooFit.Rename(sig + "_" + mcstatSysName + "Up")) getattr(w, "import")(mcstatSigHistDown, RooFit.Rename(sig + "_" + mcstatSysName + "Down")) for sysName, sysValue in syst.iteritems(): if (sysValue[0] == "shape" and "mcstat" not in sysName): sysUp = getHist(ch, sig + "_" + sysName + "Up", ifile) sysDown = getHist(ch, sig + "_" + sysName + "Down", ifile) print "==> Trigg sys name: ", sig + "_" + sysName + "Down" sysSigHistUp = RooDataHist(sig + "_" + sysName + "Up", sysName + " uncertainty", RooArgList(mT), sysUp, 1.) sysSigHistDown = RooDataHist(sig + "_" + sysName + "Down", sysName + " uncertainty", RooArgList(mT), sysDown, 1.) getattr(w, "import")(sysSigHistUp, RooFit.Rename(sig + "_" + sysName + "Up")) getattr(w, "import")(sysSigHistDown, RooFit.Rename(sig + "_" + sysName + "Down")) #else: getattr(w, "import")(setToys, RooFit.Rename("data_obs")) getattr(w, "import")(modelBkg, RooFit.Rename(modelBkg.GetName())) #getattr(w, "import")(modelAlt, RooFit.Rename(modelAlt.GetName())) getattr(w, "import")(normzBkg, RooFit.Rename(normzBkg.GetName())) w.writeToFile("%sws_%s_%s_%s.root" % (carddir, sig, ch, mode), True) print "Workspace", "%sws_%s_%s_%s.root" % (carddir, sig, ch, mode), "saved successfully" workfile = "./ws_%s_%s_%s.root" % (sig, ch, mode) # ====== END MODEL GENERATION ====== rates = {} procLine = "" procNumbLine = "" rateLine = "" binString = "" if (mode == "template"): processes.append("Bkg") processes[:-1] = [] rates["Bkg"] = nBkgEvts procLine += ("%-43s") % ("Bkg") rateLine += ("%-43s") % (rates["Bkg"]) binString += (("%-43s") % (ch)) * (2) procNumbLine = 1 else: i = 1 bkgrate = 0 print "===> Backgrounds: ", processes nproc = (len(processes) + 1) for p in processes: print "======================= p for rate", p, " syst, ", syst print "ch is ", ch, " process is ", p, " ifile is ", ifile.GetName( ) rates[p] = getRate(ch, p, ifile) bkgrate = rates[p] if (p == "QCD"): print "qcd: ", bkgrate if (bkgrate == 0): nproc = nproc - 1 continue procNumbLine += ("%-43s") % (i) procLine += ("%-43s") % (p) rateLine += ("%-43.2f") % (bkgrate) i += 1 binString += (("%-43s") % (ch)) * (nproc) if ((not unblind) and (mode == "template")): print "N.B: We are in blind mode. Using MC bkg data for data_obs" rates["data_obs"] = getRate(ch, "Bkg", ifile) print "Pseudo data rate: ", rates["data_obs"] else: rates["data_obs"] = getRate(ch, "data_obs", ifile) rates[sig] = getRate(ch, sig, ifile) card = "imax 1 number of channels \n" card += "jmax * number of backgrounds \n" card += "kmax * number of nuisance parameters\n" card += "-----------------------------------------------------------------------------------\n" if (mode == "template"): # card += "shapes %s %s %s %s %s\n" % (sig, ch, ifilename, "$CHANNEL/$PROCESS", "$CHANNEL/$PROCESS_SYSTEMATIC") # card += "shapes %-15s %-5s %s%s.root %s\n" % (sig, ch, WORKDIR, ch, "SVJ:$PROCESS") card += "shapes %s %s %s %s\n" % (modelBkg.GetName(), ch, workfile, "SVJ:$PROCESS") card += "shapes %s %s %s %s %s\n" % ( sig, ch, workfile, "SVJ:$PROCESS", "SVJ:$PROCESS_$SYSTEMATIC") card += "shapes %s %s %s %s\n" % ("data_obs", ch, workfile, "SVJ:$PROCESS") else: card += "shapes * * %s %s %s\n" % ( hist_filename, "$CHANNEL/$PROCESS", "$CHANNEL/$PROCESS_$SYSTEMATIC") card += "shapes data_obs * %s %s\n" % (hist_filename, "$CHANNEL/$PROCESS") card += "-----------------------------------------------------------------------------------\n" card += "bin %s\n" % ch print "===> Observed data: ", rates["data_obs"] card += "observation %0.d\n" % (rates["data_obs"]) card += "-----------------------------------------------------------------------------------\n" card += "bin %-43s\n" % (binString) card += "process %-43s%-43s\n" % ( sig, procLine) #"roomultipdf" card += "process %-43s%-43s\n" % ( "0", procNumbLine) card += "rate %-43.6f%-43s\n" % ( rates[sig], rateLine) #signalYield[m].getVal(), nevents card += "-----------------------------------------------------------------------------------\n" for sysName, sysValue in syst.iteritems(): print "Systematic Uncertainty: ", sysName if ("2016" in sysName and "2016" not in ch): continue elif ("2017" in sysName and "2017" not in ch): continue elif ("2018" in sysName and "2018" not in ch): continue if ("mu" in sysName and "mu" not in ch): continue elif ("ele" in sysName and "ele" not in ch): continue if (sysValue[0] == "lnN"): card += "%-20s%-20s" % (sysName, sysValue[0]) if (sysValue[1] == "all" and len(sysValue) > 2): if (mode == "template"): card += "%-20s" % (sysValue[2]) * (2) else: card += "%-20s" % (sysValue[2]) * (len(processes) + 1) elif (sysValue[1] == "QCD" and len(sysValue) > 2): if (mode == "template"): card += "%-20s" % (sysValue[2]) * (2) else: card += "%-20s" % (sysValue[2]) * (len(processes) + 1) else: if (sysValue[1] == "all"): sysValue[1] = copy.deepcopy(processes) sysValue[1].append(sig) hsysName = "_" + sysName hsysNameUp = "_" + sysName + "Up" hsysNameDown = "_" + sysName + "Down" #print "Applying syst on ", sysValue[1] if ("sig" in sysValue[1]): if (getRate(ch, sig, ifile) != 0.): sigSys = abs((getRate(ch, sig + hsysNameUp, ifile) - getRate(ch, sig + hsysNameDown, ifile)) / (2 * getRate(ch, sig, ifile))) else: sigSys = 1 if (sigSys < 1. and sigSys > 0.): sigSys = sigSys + 1 card += "%-20s" % (sigSys) else: card += "%-20s" % ("-") for p in processes: if (p in sysValue[1]): if (getRate(ch, p, ifile) != 0.): bkgSys = abs( (getRate(ch, p + hsysNameUp, ifile) - getRate(ch, p + hsysNameDown, ifile)) / (2 * getRate(ch, p, ifile))) else: bkgSys = 1 if (bkgSys < 1. and bkgSys > 0.): bkgSys = bkgSys + 1 card += "%-20s" % (bkgSys) else: card += "%-20s" % ("-") elif (sysValue[0] == "shape"): print "sys shape named ", sysName if ("mcstat" not in sysName and 'autoMCstat' not in sysName): card += "%-20s shape " % (sysName) isbogussys = False #if(getRate(ch, sig+"_"+sysName+"Up", ifile)==0 or getRate(ch, sig+"_"+sysName+"Down", ifile)==0):isbogussys=True if ("sig" in sysValue[1]) and ((getRate(ch, sig, ifile) != 0.) and not isbogussys): #print " signal ",sig," channel, ",ch, " file ",ifile, " rate ",(getRate(ch, sig, ifile)) #print " signal ",sig," channel, ",ch, " file ",ifile, " rate up ",(getRate(ch, sig+"_"+sysName+"Up", ifile)) #print " signal ",sig," channel, ",ch, " file ",ifile, " rate down",(getRate(ch, sig+"_"+sysName+"Down", ifile)) card += "%-20s" % ("1") else: card += "%-20s" % ("-") for p in processes: if (p in sysValue[1]): if "q2SingleTop" in sysName: card += "%-20s" % ("1") else: card += "%-20s" % ("1") #print "adding to channel ", p else: card += "%-20s" % ("-") elif ("mcstat" in sysName): # CAMBIARE NOME DELLA SYST for samp in sysValue[1]: sampName = "" line = "" if (samp == "sig" or samp == "Sig"): line = "%-20s" % ("1") line += "%-20s" % ("-") * (len(processes)) sampName = sig elif (mode != "template"): line = "%-20s" % ("-") lineProc = [ "%-20s" % ("-") for x in xrange(len(processes)) ] if samp in processes: index = processes.index(samp) lineProc[index] = "1" lineProc = " ".join(lineProc) line += lineProc sampName = samp else: continue for i in xrange(hist.GetNbinsX()): sysName = "mcstat_%s_%s_bin%d " % (ch, sampName, i + 1) card += "%-20s shape " % (sysName) card += line card += "\n" if ('autoMCstat' in sysName): card += "%-20s%-20s%-20d\n " % (ch, "autoMCStats", 0) card += "\n" # End for loop on syst unc. for k, v in rateParams.items(): for ch_ in v.chs: if ("2016" in k and "2016" not in ch): continue elif ("2017" in k and "2017" not in ch): continue elif ("2018" in k and "2018" not in ch): continue if ("mu" in k and "mu" not in ch): continue elif ("ele" in k and "ele" not in ch): continue if (ch_ == ("_").join(ch.split("_")[:-1])): if (("2016" in k) or ("2017" in k) or ("2018" in k)): if ('mu' in k and 'mu' in ch): card += "%-20s%-20s%-20s%-20s%-20d\n" % ( k, "rateParam", ch, v.bkg, 1) elif ('ele' in k and 'ele' in ch): card += "%-20s%-20s%-20s%-20s%-20d\n" % ( k, "rateParam", ch, v.bkg, 1) else: sameyear = (("2016" in k and "2016" in ch) or ("2017" in k and "2017" in ch) or ("2018" in k and "2018" in ch)) if (sameyear): card += "%-20s%-20s%-20s%-20s%-20d\n" % ( k, "rateParam", ch, v.bkg, 1) else: card += "%-20s%-20s%-20s%-20s%-20d\n" % (k, "rateParam", ch, v.bkg, 1) card += "\n" if not os.path.isdir(outdir): os.system('mkdir ' + outdir) if not os.path.isdir(outdir + "/" + sig): os.system('mkdir ' + outdir + "/" + sig) outname = "%s%s_%s_%s.txt" % (carddir, sig, ch, mode) cardfile = open(outname, 'w') cardfile.write(card) cardfile.close() #print card return card
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 buildTimePdf(config): """ build time pdf, return pdf and associated data in dictionary """ from B2DXFitters.WS import WS print 'CONFIGURATION' for k in sorted(config.keys()): print ' %32s: %32s' % (k, config[k]) # start building the fit ws = RooWorkspace('ws_%s' % config['Context']) one = WS(ws, RooConstVar('one', '1', 1.0)) zero = WS(ws, RooConstVar('zero', '0', 0.0)) # start by defining observables time = WS(ws, RooRealVar('time', 'time [ps]', 0.2, 15.0)) qf = WS(ws, RooCategory('qf', 'final state charge')) qf.defineType('h+', +1) qf.defineType('h-', -1) qt = WS(ws, RooCategory('qt', 'tagging decision')) qt.defineType('B+', +1) qt.defineType('Untagged', 0) qt.defineType('B-', -1) # now other settings Gamma = WS(ws, RooRealVar('Gamma', 'Gamma', 0.661)) # ps^-1 DGamma = WS(ws, RooRealVar('DGamma', 'DGamma', 0.106)) # ps^-1 Dm = WS(ws, RooRealVar('Dm', 'Dm', 17.719)) # ps^-1 mistag = WS(ws, RooRealVar('mistag', 'mistag', 0.35, 0.0, 0.5)) tageff = WS(ws, RooRealVar('tageff', 'tageff', 0.60, 0.0, 1.0)) timeerr = WS(ws, RooRealVar('timeerr', 'timeerr', 0.040, 0.001, 0.100)) # now build the PDF from B2DXFitters.timepdfutils import buildBDecayTimePdf from B2DXFitters.resmodelutils import getResolutionModel from B2DXFitters.acceptanceutils import buildSplineAcceptance obs = [qf, qt, time] acc, accnorm = buildSplineAcceptance( ws, time, 'Bs2DsPi_accpetance', config['SplineAcceptance']['KnotPositions'], config['SplineAcceptance']['KnotCoefficients'][config['Context']], 'FIT' in config['Context']) # float for fitting if 'GEN' in config['Context']: acc = accnorm # use normalised acceptance for generation # get resolution model resmodel, acc = getResolutionModel(ws, config, time, timeerr, acc) # build the time pdf pdf = buildBDecayTimePdf(config, 'Bs2DsPi', ws, time, timeerr, qt, qf, [[mistag]], [tageff], Gamma, DGamma, Dm, C=one, D=zero, Dbar=zero, S=zero, Sbar=zero, timeresmodel=resmodel, acceptance=acc) return { # return things 'ws': ws, 'pdf': pdf, 'obs': obs }
def buildTimePdf(config, tupleDataSet, tupleDict): from B2DXFitters.WS import WS print 'CONFIGURATION' for k in sorted(config.keys()): print ' %32s: %32s' % (k, config[k]) ws = RooWorkspace('ws_%s' % config['Context']) one = WS(ws, RooConstVar('one', '1', 1.0)) zero = WS(ws, RooConstVar('zero', '0', 0.0)) ###USE FIT CONTEXT """ build time pdf, return pdf and associated data in dictionary """ # start by defining observables time = WS(ws, tupleDataSet.get().find('ct')) #qt = WS(ws, tupleDataSet.get().find('ssDecision')); ''' time = WS(ws, RooRealVar('time', 'time [ps]', 0.2, 15.0)) ''' qf = WS(ws, RooCategory('qf', 'final state charge')) qf.defineType('h+', +1) qf.defineType('h-', -1) qt = WS(ws, RooCategory('qt', 'tagging decision')) qt.defineType('B+', +1) qt.defineType('Untagged', 0) qt.defineType('B-', -1) # now other settings Gamma = WS(ws, RooRealVar('Gamma', 'Gamma', 0.661)) # ps^-1 DGamma = WS(ws, RooRealVar('DGamma', 'DGamma', 0.106)) # ps^-1 Dm = WS(ws, RooRealVar('Dm', 'Dm', 17.719)) # ps^-1 # HACK (1/2): be careful about lower bound on eta, since mistagpdf below # is zero below a certain value - generation in accept/reject would get # stuck if 'GEN' in config['Context'] or 'FIT' in config['Context']: eta = WS( ws, RooRealVar( 'eta', 'eta', 0.35, 0.0 if 'FIT' in config['Context'] else (1. + 1e-5) * max(0.0, config['TrivialMistagParams']['omega0']), 0.5)) mistag = WS(ws, RooRealVar('mistag', 'mistag', 0.35, 0.0, 0.5)) tageff = WS(ws, RooRealVar('tageff', 'tageff', 0.60, 0.0, 1.0)) terrpdf = WS(ws, tupleDataSet.get().find('cterr')) timeerr = WS(ws, RooRealVar('timeerr', 'timeerr', 0.040, 0.001, 0.100)) #MISTAGPDF # fit average mistag # add mistagged #ge rid of untagged events by putting restriction on qf or something when reduceing ds # now build the PDF from B2DXFitters.timepdfutils import buildBDecayTimePdf from B2DXFitters.resmodelutils import getResolutionModel from B2DXFitters.acceptanceutils import buildSplineAcceptance obs = [qf, qt, time] acc, accnorm = buildSplineAcceptance( ws, time, 'Bs2DsPi_accpetance', config['SplineAcceptance']['KnotPositions'], config['SplineAcceptance']['KnotCoefficients'][config['Context'][0:3]], 'FIT' in config['Context']) # float for fitting # get resolution model resmodel, acc = getResolutionModel(ws, config, time, timeerr, acc) mistagpdf = WS( ws, RooArgList(tupleDataSet.get().find('ssMistag'), tupleDataSet.get().find('osMistag'))) #??? ''' if 'GEN' in config['Context']: # build a (mock) mistag distribution mistagpdfparams = {} # start with parameters of mock distribution for sfx in ('omega0', 'omegaavg', 'f'): mistagpdfparams[sfx] = WS(ws, RooRealVar( 'Bs2DsPi_mistagpdf_%s' % sfx, 'Bs2DsPi_mistagpdf_%s' % sfx, config['TrivialMistagParams'][sfx])) # build mistag pdf itself mistagpdf = WS(ws, [tupleDataSet.reduce('ssMistag'), tupleDataSet.reduce('osMistag')]); mistagcalibparams = {} # start with parameters of calibration for sfx in ('p0', 'p1', 'etaavg'): mistagcalibparams[sfx] = WS(ws, RooRealVar('Bs2DsPi_mistagcalib_%s' % sfx, 'Bs2DsPi_mistagpdf_%s' % sfx,config['MistagCalibParams'][sfx])); for sfx in ('p0', 'p1'): # float calibration paramters mistagcalibparams[sfx].setConstant(False) mistagcalibparams[sfx].setError(0.1) # build mistag pdf itself omega = WS(ws, MistagCalibration( 'Bs2DsPi_mistagcalib', 'Bs2DsPi_mistagcalib', eta, mistagcalibparams['p0'], mistagcalibparams['p1'], mistagcalibparams['etaavg'])) # build the time pdf if 'GEN' in config['Context']: pdf = buildBDecayTimePdf( config, 'Bs2DsPi', ws, time, timeerr, qt, qf, [ [ omega ] ], [ tageff ], Gamma, DGamma, Dm, C = one, D = zero, Dbar = zero, S = zero, Sbar = zero, timeresmodel = resmodel, acceptance = acc, timeerrpdf, mistagpdf = [mistagpdf], mistagobs = eta) else: pdf = buildBDecayTimePdf( config, 'Bs2DsPi', ws, time, timeerr, qt, qf, [ [ eta ] ], [ tageff ], Gamma, DGamma, Dm, C = one, D = zero, Dbar = zero, S = zero, Sbar = zero, timeresmodel = resmodel, acceptance = acc, timeerrpdf = None) ''' pdf = buildBDecayTimePdf(config, 'Bs2DsPi', ws, time, timeerr, qt, qf, [[eta]], [tageff], Gamma, DGamma, Dm, C=one, D=zero, Dbar=zero, S=zero, Sbar=zero, timeresmodel=resmodel, acceptance=acc, timeerrpdf=terrpdf, mistagpdf=[mistagpdf], mistagobs=eta) return { # return things 'ws': ws, 'pdf': pdf, 'obs': obs }
def buildTimePdf(config): """ build time pdf, return pdf and associated data in dictionary """ from B2DXFitters.WS import WS print 'CONFIGURATION' for k in sorted(config.keys()): print ' %32s: %32s' % (k, config[k]) # start building the fit ws = RooWorkspace('ws_%s' % config['Context']) one = WS(ws, RooConstVar('one', '1', 1.0)) zero = WS(ws, RooConstVar('zero', '0', 0.0)) # start by defining observables time = WS(ws, RooRealVar('time', 'time [ps]', 0.2, 15.0)) qf = WS(ws, RooCategory('qf', 'final state charge')) qf.defineType('h+', +1) qf.defineType('h-', -1) qt = WS(ws, RooCategory('qt', 'tagging decision')) qt.defineType('B+', +1) qt.defineType('Untagged', 0) qt.defineType('B-', -1) # now other settings Gamma = WS(ws, RooRealVar('Gamma', 'Gamma', 0.661)) # ps^-1 DGamma = WS(ws, RooRealVar('DGamma', 'DGamma', 0.106)) # ps^-1 Dm = WS(ws, RooRealVar('Dm', 'Dm', 17.719)) # ps^-1 # HACK (1/2): be careful about lower bound on eta, since mistagpdf below # is zero below a certain value - generation in accept/reject would get # stuck eta = WS( ws, RooRealVar( 'eta', 'eta', 0.35, 0.0 if 'FIT' in config['Context'] else (1. + 1e-5) * max(0.0, config['TrivialMistagParams']['omega0']), 0.5)) tageff = WS(ws, RooRealVar('tageff', 'tageff', 0.60, 0.0, 1.0)) timeerr = WS(ws, RooRealVar('timeerr', 'timeerr', 0.040, 0.001, 0.100)) # now build the PDF from B2DXFitters.timepdfutils import buildBDecayTimePdf from B2DXFitters.resmodelutils import getResolutionModel from B2DXFitters.acceptanceutils import buildSplineAcceptance obs = [qt, qf, time, eta, timeerr] acc, accnorm = buildSplineAcceptance( ws, time, 'Bs2DsPi_accpetance', config['SplineAcceptance']['KnotPositions'], config['SplineAcceptance']['KnotCoefficients'][config['Context']], 'FIT' in config['Context']) # float for fitting if 'GEN' in config['Context']: acc = accnorm # use normalised acceptance for generation # get resolution model resmodel, acc = getResolutionModel(ws, config, time, timeerr, acc) # build a (mock) mistag distribution mistagpdfparams = {} # start with parameters of mock distribution for sfx in ('omega0', 'omegaavg', 'f'): mistagpdfparams[sfx] = WS( ws, RooRealVar('Bs2DsPi_mistagpdf_%s' % sfx, 'Bs2DsPi_mistagpdf_%s' % sfx, config['TrivialMistagParams'][sfx])) # build mistag pdf itself mistagpdf = WS( ws, MistagDistribution('Bs2DsPi_mistagpdf', 'Bs2DsPi_mistagpdf', eta, mistagpdfparams['omega0'], mistagpdfparams['omegaavg'], mistagpdfparams['f'])) # build mistag calibration mistagcalibparams = {} # start with parameters of calibration for sfx in ('p0', 'p1', 'etaavg'): mistagcalibparams[sfx] = WS( ws, RooRealVar('Bs2DsPi_mistagcalib_%s' % sfx, 'Bs2DsPi_mistagpdf_%s' % sfx, config['MistagCalibParams'][sfx])) for sfx in ('p0', 'p1'): # float calibration paramters mistagcalibparams[sfx].setConstant(False) mistagcalibparams[sfx].setError(0.1) # build mistag pdf itself omega = WS( ws, MistagCalibration('Bs2DsPi_mistagcalib', 'Bs2DsPi_mistagcalib', eta, mistagcalibparams['p0'], mistagcalibparams['p1'], mistagcalibparams['etaavg'])) # build mock decay time error distribution (~ timeerr^6 * exp(-timerr / # (timerr_av / 7)) terrpdf_shape = WS( ws, RooConstVar('timeerr_ac', 'timeerr_ac', config['DecayTimeResolutionAvg'] / 7.)) terrpdf_truth = WS( ws, RooTruthModel('terrpdf_truth', 'terrpdf_truth', timeerr)) terrpdf_i0 = WS( ws, RooDecay('terrpdf_i0', 'terrpdf_i0', timeerr, terrpdf_shape, terrpdf_truth, RooDecay.SingleSided)) terrpdf_i1 = WS( ws, RooPolynomial('terrpdf_i1', 'terrpdf_i1', timeerr, RooArgList(zero, zero, zero, zero, zero, zero, one), 0)) terrpdf = WS(ws, RooProdPdf('terrpdf', 'terrpdf', terrpdf_i0, terrpdf_i1)) # build the time pdf pdf = buildBDecayTimePdf(config, 'Bs2DsPi', ws, time, timeerr, qt, qf, [[omega]], [tageff], Gamma, DGamma, Dm, C=one, D=zero, Dbar=zero, S=zero, Sbar=zero, timeresmodel=resmodel, acceptance=acc, timeerrpdf=terrpdf, mistagpdf=[mistagpdf], mistagobs=eta) return { # return things 'ws': ws, 'pdf': pdf, 'obs': obs }