def applyDecayTimeErrPdf(config, name, ws, time, timeerr, qt, qf, mistagobs, timepdf, timeerrpdf, mistagpdf): """ apply the per-event time error pdf config -- configuration dictionary name -- prefix to be used for new RooFit objects ws -- workspace to import new objects into time -- time observable timeerr -- decay time error observable (or None for average decay time error) qt -- tagging decision qf -- final state charge mistagobs -- mistag observable (or None for average mistag) timepdf -- decay time pdf timeerrpdf -- decay time error pdf (or None for av. decay time error) mistagpdf -- mistag pdf (or None for average mistag) returns the (possibly modified) decay time error pdf (with decay time error multiplied on, if applicable). """ # no per-event time error is easy... if None == timeerrpdf: return timepdf from ROOT import RooFit, RooArgSet, RooProdPdf noncondset = RooArgSet(time, qf, qt) if None != mistagpdf: noncondset.add(mistagobs) timepdf = WS(ws, RooProdPdf('%s_TimeTimeerrPdf' % name, '%s (time,timeerr) pdf' % name, RooArgSet(timeerrpdf), RooFit.Conditional(RooArgSet(timepdf), noncondset))) return timepdf
def addAsciiData(self, ws, ds_name, item_title, var_set_name, var_set_type, ds_file_name, weight_var_name=None, debug=0, sets=None): legend = '[exostConfig::addAsciiData]:' arg_set = RooArgSet() if (var_set_type == 'set'): #_var_set = ws.set(var_set_name) _var_set = sets[var_set_name] arg_set.add(_var_set) if _var_set.getSize() != 1: print legend, 'Error: too many or too few columns in the input ASCII file' print legend, 'Error: Smart program as I am, I can only handle ASCII files' print legend, 'Error: with exactly one column at the moment.' print legend, 'Error: Support for multiple columns will be implemented' print legend, 'Error: eventually, contact the developers.' print legend, 'Error: Better yet, switch to ROOT input files,' print legend, 'Error: all the cool kids are doing that!' return -1 elif (var_set_type == 'var'): arg_set.add(ws.var(var_set_name)) else: print legend, 'error: unknown var_set_type, cannot create dataset', ds_name return -1 #create the dataset if weight_var_name == None: #no weight if (debug > 0): print legend, 'no weight variable given' _arglist = RooArgList(arg_set) #ds = RooDataSet()ds_name, item_title) ds = RooDataSet.read(ds_file_name, _arglist) ds.SetName(ds_name) ds.SetTitle(item_title) else: if (debug > 0): print legend, 'using variable', weight_var_name, 'as weight' print legend, 'Error: Smart program as I am, I cannot handle' print legend, 'Error: weights when loading from ASCII files yet.' print legend, 'Error: Support for weights from ASCII files will' print legend, 'Error: be implemented eventually, contact the developers.' print legend, 'Error: Better yet, switch to ROOT input files,' print legend, 'Error: all the cool kids are doing that!' return -1 # import the datahist. Note workaround 'import' being a reserved word getattr(ws, 'import')(ds)
def performFitInLeptonAbsEta(data_histogram, signal_histogram, bkg1_histogram, bkg2_histogram): N_Data = data_histogram.Integral() N_signal = signal_histogram.Integral() N_bkg1 = bkg1_histogram.Integral() N_bkg2 = bkg2_histogram.Integral() leptonAbsEta = RooRealVar("leptonAbsEta", "leptonAbsEta", 0., 3.) variables = RooArgList() variables.add(leptonAbsEta) variable_set = RooArgSet() variable_set.add(leptonAbsEta) lowerBound = 0 upperBound = N_Data * 2 data_RooDataHist = RooDataHist("data", "dataset with leptonAbsEta", variables, data_histogram) signal_RooDataHist = RooDataHist("rh_signal", "signal", variables, signal_histogram) bkg1_RooDataHist = RooDataHist("rh_bkg1", "bkg1", variables, bkg1_histogram) bkg2_RooDataHist = RooDataHist("rh_bkg2", "bkg2", variables, bkg2_histogram) signal_RooHistPdf = RooHistPdf("pdf_signal", "Signal PDF", variable_set, signal_RooDataHist, 0) signal_RooHistPdf = RooHistPdf("pdf_signal", "Signal PDF", variable_set, signal_RooDataHist, 0)
def get_argset(args): """Return and argset of the RooFit objects.""" argset = RooArgSet() for arg in args: if arg.InheritsFrom(RooAbsArg.Class()): argset.add(arg) else: TypeError('%s should inherit from RooAbsArg' % arg.GetName()) return argset
def get_roofit_model( histograms, fit_boundaries, name = 'model' ): data_label = 'data' samples = sorted( histograms.keys() ) samples.remove( data_label ) roofit_histograms = {} roofit_pdfs = {} roofit_variables = {} variables = RooArgList() variable_set = RooArgSet() fit_variable = RooRealVar( name , name, fit_boundaries[0], fit_boundaries[1] ) variables.add( fit_variable ) variable_set.add( fit_variable ) roofit_histograms[data_label] = RooDataHist( data_label, data_label, variables, histograms[data_label] ) pdf_arglist = RooArgList() variable_arglist = RooArgList() N_total = histograms[data_label].Integral() * 2 N_min = 0 for sample in samples: roofit_histogram = RooDataHist( sample, sample, variables, histograms[sample] ) roofit_histograms[sample] = roofit_histogram roofit_pdf = RooHistPdf ( 'pdf' + sample, 'pdf' + sample, variable_set, roofit_histogram, 0 ) roofit_pdfs[sample] = roofit_pdf roofit_variable = RooRealVar( sample, "number of " + sample + " events", histograms[sample].Integral(), N_min, N_total, "event" ) roofit_variables[sample] = roofit_variable pdf_arglist.add( roofit_pdf ) variable_arglist.add( roofit_variable ) model = RooAddPdf( name, name, pdf_arglist, variable_arglist ) return model, roofit_histograms, fit_variable
def main1(): m = RooRealVar('evt.m', 'evt.m', 1.92, 2.02) mode = RooCategory('evt.mode', 'evt.mode') mode.defineType('phipi', 0) aset = RooArgSet('aset') aset.add(m) aset.add(mode) tuplist = tupleList('genmc', 7) dst, _, f = getTree('/'.join([tuplePath(), tuplist[-1]])) # dst.Print() # dst.Show(0) # for evt in dst: # print('Hello!') # print(evt.evt.m) # break ds = RooDataSet('ds', 'ds', dst, aset) print(ds.numEntries()) mean = RooRealVar('mean', 'mean', 1.96, 1.92, 2.0) width = RooRealVar('width', 'width', 0.006, 0.001, 0.010) pdf = RooGaussian('pdf', 'pdf', m, mean, width) pdf.fitTo(ds, Verbose(), Timer(True)) makePlot(m, ds, pdf) raw_input("Press Enter to continue...")
def cnvrt(i) : if not hasattr(i,'__iter__') or any( isinstance(i, t) for t in __doNotConvert ): return i _i = RooArgSet() for j in i : from ROOT import RooAbsArg if not isinstance(j,RooAbsArg) : return i _i.add( j ) return _i
def fit(self): fit_variable = RooRealVar("fit_variable", "fit_variable", self.fit_boundaries[0], self.fit_boundaries[1]) fit_variable.setBins(self.histograms[self.data_label].nbins()) variables = RooArgList() variables.add(fit_variable) variable_set = RooArgSet() variable_set.add(fit_variable) roofit_histograms = {} roofit_pdfs = {} roofit_variables = {} N_min = 0.0 N_max = self.normalisation[self.data_label] * 2.0 pdf_arglist = RooArgList() variable_arglist = RooArgList() roofit_histograms[self.data_label] = RooDataHist( self.data_label, self.data_label, variables, self.histograms[self.data_label] ) for sample in self.samples: roofit_histogram = RooDataHist(sample, sample, variables, self.histograms[sample]) roofit_histograms[sample] = roofit_histogram roofit_pdf = RooHistPdf("pdf" + sample, "pdf" + sample, variable_set, roofit_histogram) roofit_pdfs[sample] = roofit_pdf roofit_variable = RooRealVar(sample, sample + " events", self.normalisation[sample], N_min, N_max) roofit_variables[sample] = roofit_variable pdf_arglist.add(roofit_pdf) variable_arglist.add(roofit_variable) model = RooAddPdf("model", "sum of all known", pdf_arglist, variable_arglist) use_model = model if self.constraints: arg_set = RooArgSet(model) constraints = self.get_fit_normalisation_constraints(model, roofit_variables) for constraint in constraints: arg_set.add(constraint) model_with_constraints = RooProdPdf( "model_with_constraints", "model with gaussian constraints", arg_set, RooLinkedList() ) use_model = model_with_constraints if self.method == "TMinuit": # WARNING: number of cores changes the results!!! self.saved_result = use_model.fitTo( roofit_histograms[self.data_label], RooFit.Minimizer("Minuit2", "Migrad"), RooFit.NumCPU(1), RooFit.Extended(), RooFit.Save(), ) results = {} for sample in self.samples: results[sample] = (roofit_variables[sample].getVal(), roofit_variables[sample].getError()) self.results = results
def File2Dataset(self, fnames, dsName, ws, noCuts=False, weighted=False, CPweight=False, cutOverride=None, interference=0, additionalWgt=1.0): if ws.data(dsName): return ws.data(dsName) cols = RooArgSet(ws.set('obsSet')) # print 'interference weight flag:',interference if (weighted): evtWgt = RooRealVar('evtWgt', 'evtWgt', 1.0) cols.add(evtWgt) ds = RooDataSet(dsName, dsName, cols, 'evtWgt') print 'including weights for eff', if CPweight: print 'and CP weight', if interference in [1, 2, 3]: print 'and interference', print else: ds = RooDataSet(dsName, dsName, cols) if not (type(fnames) == type([])): fnames = [fnames] try: obs = [self.pars.varNames[x] for x in self.pars.var] except AttributeError: obs = self.pars.var for fname in fnames: for (row, effWgt, cpw, iwt) in \ self.TreeLoopFromFile(fname, noCuts, CPweight = CPweight, cutOverride = cutOverride, interference = interference): inRange = True for (i, v) in enumerate(obs): inRange = (inRange and ws.var(v).inRange(row[i], '')) cols.setRealValue(v, row[i]) if CPweight: effWgt *= cpw if interference in [1, 2, 3]: effWgt *= iwt if inRange: ds.add(cols, effWgt * additionalWgt) getattr(ws, 'import')(ds) return ws.data(dsName)
def get_dataset_from_tree( self, path_to_tree, tree_variables, weight="1==1", weight_var_name=0, dataset_name="my_dataset", basket=True, category=None, ): """ Creates RooDataSet from a plain root tree given: - variables name list - weight expression. It works in the same way as TTree cut. Returns: -------- - RooDataSet - also fills the basket with datasets (basket inhereted from RootHelperBase class) TODO ---- - add implementation for category setting(check in prepare_toy_datasets_for_sync) - check if adding toy dataset to each channel workspace individually behaves well after combineCards.py. """ # make RooRealVars from tree_variables my_arg_set = RooArgSet() my_rrv = dict() for var_name in tree_variables: # TODO implement check that branch exist my_rrv[var_name] = RooRealVar(var_name, var_name, -999999999, 999999999) my_arg_set.add(my_rrv[var_name]) if self.DEBUG: self.log.debug("RooArgSet is now:") my_arg_set.Print() # get the tree from path_to_tree my_tree = self.get_TTree(path_to_tree, cut=weight) self.log.debug("Selected tree contains {0} events".format(my_tree.GetEntries())) # create RooDataSet and reduce tree if needed # self.dataset_from_tree = RooDataSet(dataset_name, dataset_name, my_tree, my_arg_set, weight).reduce(my_arg_set) self.dataset_from_tree = RooDataSet(dataset_name, dataset_name, my_tree, my_arg_set) # self.dataset_from_tree = RooDataSet(dataset_name, dataset_name, my_tree, my_arg_set, "", weight_var_name) # data[j]=new RooDataSet(Form("data%d",j),Form("data%d",j),outTree,RooArgSet(rCMS_zz4l_widthKD,rCMS_zz4l_widthMass,rweightFit),"","_weight_"); self.log.debug("RooDataSet contains {0} events".format(self.dataset_from_tree.sumEntries())) # .reduce(ROOT.RooArgSet(self.D0)) self.current_arg_set = my_arg_set # add dataset to basket if basket: self.add_to_basket(self.dataset_from_tree, new_name=dataset_name, new_title=dataset_name) return self.dataset_from_tree
def makeRooDataset(inputfile_name): chibTree_name = 'rootuple/chibTree' inputfile = TFile.Open(inputfile_name,"READ") tree = TTree() inputfile.GetObject(chibTree_name, tree) invm1S = RooRealVar("invm1S", "invm1S", 9.7, 10.1)#9.5, 11.5 invm2S = RooRealVar("invm2S", "invm2S", 9.5, 13.0) invm3S = RooRealVar("invm3S", "invm3S", 9.5, 13.0) chib_mass = RooRealVar("chib_mass", "chib_mass", 5., 15.0) chib_pt = RooRealVar("chib_pt", "chib_pt", 0., 300.) chib_eta = RooRealVar("chib_eta", "chib_eta", -5., 5.) chib_phi = RooRealVar("chib_phi", "chib_phi", -3.2, 3.2) dimuon_mass = RooRealVar("dimuon_mass","dimuon_mass", 8.0, 12.0) dimuon_rapidity = RooRealVar("dimuon_rapidity", "dimuon_rapidity", -5.0, 5.0) dimuon_pt = RooRealVar("dimuon_pt","dimuon_pt", 0.0, 100.0) photon_eta = RooRealVar("photon_eta","photon_eta", -5.0, 5.0) photon_pt = RooRealVar("photon_pt","photon_pt", 0.0, 100.0) ctpv = RooRealVar("ctpv","ctpv", -5.0, 5.0) ctpv_error = RooRealVar("ctpv_err","ctpv_err", -5.0, 5.0) pi0_abs_mass = RooRealVar("pi0_abs_mass","pi0_abs_mass", 0.0, 2.0) Y1S_nsigma = RooRealVar("Y1S_nsigma","Y1S_nsigma",0.0,30.0) Y2S_nsigma = RooRealVar("Y2S_nsigma","Y2S_nsigma",0.0,30.0) Y3S_nsigma = RooRealVar("Y3S_nsigma","Y3S_nsigma",0.0,35.0) conv_vertex = RooRealVar("conv_vertex", "conv_vertex", 0.0, 70.0) dz = RooRealVar("dz","dz", 0., 0.6) numPrimaryVertices = RooRealVar("numPrimaryVertices","numPrimaryVertices",0,60) rf1S_chib_mass = RooRealVar("rf1S_chib_mass","rf1S_chib_mass",9.5,60.) probFit1S = RooRealVar("probFit1S","probFit1S",0.,1.) rf1S_chib_pt = RooRealVar("rf1S_chib_pt", "rf1S_chib_pt", 0., 300.) rf1S_chib_eta = RooRealVar("rf1S_chib_eta", "rf1S_chib_eta", -5., 5.) rf1S_dimuon_mass = RooRealVar("rf1S_dimuon_mass","rf1S_dimuon_mass", 8.0, 12.0) rf1S_dimuon_rapidity = RooRealVar("rf1S_dimuon_rapidity", "rf1S_dimuon_rapidity", -5.0, 5.0) rf1S_dimuon_pt = RooRealVar("rf1S_dimuon_pt","rf1S_dimuon_pt", 0.0, 230.0) rf1S_photon_eta = RooRealVar("rf1S_photon_eta","rf1S_photon_eta", -5.0, 5.0) rf1S_photon_pt = RooRealVar("rf1S_photon_pt","rf1S_photon_pt", 0.0, 100.0) rf2S_chib_mass = RooRealVar("rf2S_chib_mass","rf2S_chib_mass",9.5,60.) probFit2S = RooRealVar("probFit2S","probFit2S",0.,1.) rf3S_chib_mass = RooRealVar("rf3S_chib_mass","rf3S_chib_mass",9.5,60.) probFit3S = RooRealVar("probFit3S","probFit3S",0.,1.) muonP_pt = RooRealVar("muonP_pt","muonP_pt",0.,100.) muonM_pt = RooRealVar("muonM_pt","muonM_pt",0.,100.) muonP_eta = RooRealVar("muonP_eta","muonP_eta",-5.,5.) muonM_eta = RooRealVar("muonM_eta","muonM_eta",-5.,5.) dataArgSet = RooArgSet(invm1S, invm2S, invm3S, dimuon_mass, dimuon_rapidity, dimuon_pt, photon_eta, photon_pt, ctpv) dataArgSet.add(RooArgSet(chib_mass, chib_pt, chib_eta, chib_phi)) dataArgSet.add(RooArgSet(ctpv_error, pi0_abs_mass, Y1S_nsigma, Y2S_nsigma, Y3S_nsigma, conv_vertex, dz, numPrimaryVertices)) dataArgSet.add(RooArgSet(rf1S_chib_mass, probFit1S, rf2S_chib_mass, probFit2S, rf3S_chib_mass, probFit3S)) dataArgSet.add(RooArgSet(rf1S_chib_pt, rf1S_chib_eta, rf1S_dimuon_mass, rf1S_dimuon_rapidity, rf1S_dimuon_pt, rf1S_photon_eta, rf1S_photon_pt)) dataArgSet.add(RooArgSet(muonP_pt, muonM_pt, muonP_eta, muonM_eta)) dataSet = RooDataSet("chibds","Chib RooDataSet", tree, dataArgSet) return dataSet
def addAsciiData(self, ws, ds_name, item_title, var_set_name, var_set_type, ds_file_name, weight_var_name = None, debug = 0, sets = None): legend = '[exostConfig::addAsciiData]:' arg_set = RooArgSet() if (var_set_type == 'set'): #_var_set = ws.set(var_set_name) _var_set = sets[var_set_name] arg_set.add(_var_set) if _var_set.getSize() != 1: print legend, 'Error: too many or too few columns in the input ASCII file' print legend, 'Error: Smart program as I am, I can only handle ASCII files' print legend, 'Error: with exactly one column at the moment.' print legend, 'Error: Support for multiple columns will be implemented' print legend, 'Error: eventually, contact the developers.' print legend, 'Error: Better yet, switch to ROOT input files,' print legend, 'Error: all the cool kids are doing that!' return -1 elif (var_set_type == 'var'): arg_set.add(ws.var(var_set_name)) else: print legend, 'error: unknown var_set_type, cannot create dataset', ds_name return -1 #create the dataset if weight_var_name == None: #no weight if (debug>0): print legend, 'no weight variable given' _arglist = RooArgList(arg_set) #ds = RooDataSet()ds_name, item_title) ds = RooDataSet.read(ds_file_name, _arglist) ds.SetName(ds_name) ds.SetTitle(item_title) else: if (debug>0): print legend, 'using variable', weight_var_name, 'as weight' print legend, 'Error: Smart program as I am, I cannot handle' print legend, 'Error: weights when loading from ASCII files yet.' print legend, 'Error: Support for weights from ASCII files will' print legend, 'Error: be implemented eventually, contact the developers.' print legend, 'Error: Better yet, switch to ROOT input files,' print legend, 'Error: all the cool kids are doing that!' return -1 # import the datahist. Note workaround 'import' being a reserved word getattr(ws, 'import')(ds)
def gen_params(self, observables=None): from ROOT import RooArgSet if self.__parameters: return self.__parameters else: if observables and not isinstance(observables, RooArgSet): obs = RooArgSet() for o in observables: obs.add(o._target_() if hasattr(o, "_target_") else o) observables = obs params = self.__pdf.getParameters(observables) self.__parameters = [p for p in params] + [self.__status] return self.__parameters
def File2Dataset(self, fnames, dsName, ws, noCuts = False, weighted = False, CPweight = False, cutOverride = None, interference = 0, additionalWgt = 1.0): if ws.data(dsName): return ws.data(dsName) cols = RooArgSet(ws.set('obsSet')) # print 'interference weight flag:',interference if (weighted): evtWgt = RooRealVar('evtWgt', 'evtWgt', 1.0) cols.add(evtWgt) ds = RooDataSet(dsName, dsName, cols, 'evtWgt') print 'including weights for eff', if CPweight: print 'and CP weight', if interference in [1,2,3]: print 'and interference', print else: ds = RooDataSet(dsName, dsName, cols) if not (type(fnames) == type([])): fnames = [fnames] try: obs = [ self.pars.varNames[x] for x in self.pars.var ] except AttributeError: obs = self.pars.var for fname in fnames: for (row, effWgt, cpw, iwt) in \ self.TreeLoopFromFile(fname, noCuts, CPweight = CPweight, cutOverride = cutOverride, interference = interference): inRange = True for (i,v) in enumerate(obs): inRange = (inRange and ws.var(v).inRange(row[i], '')) cols.setRealValue(v, row[i]) if CPweight: effWgt *= cpw if interference in [1,2,3]: effWgt *= iwt if inRange: ds.add(cols, effWgt*additionalWgt) getattr(ws, 'import')(ds) return ws.data(dsName)
def write_output(self): # Write the results to a file from ROOT import TFile output_file = TFile.Open(self.options().output, "recreate") output_file.WriteTObject(self._data, self._data.GetName()) gp = self.gen_params() if gp: from ROOT import RooArgSet gpars = RooArgSet() for p in gp: gpars.add(p) gpars = gpars.snapshot(True) output_file.WriteTObject(gpars, "gen_params") output_file.Close()
def fit(self): pdfs = RooArgList() obsvars = RooArgSet('set') for constraint in self.constraint.values(): pdfs.add(constraint.pdf_constraint) if hasattr(constraint, 'var_obs'): obsvars.add(constraint.var_obs) self.model = RooProdPdf('model', 'model', pdfs) self.data = RooDataSet('data', 'data', obsvars) self.data.add(obsvars) self.data.Print() self.fit_result = self.model.fitTo(self.data, ROOT.RooFit.PrintLevel(3), ROOT.RooFit.Optimize(1), ROOT.RooFit.Hesse(1), ROOT.RooFit.Minos(1), ROOT.RooFit.Strategy(2), ROOT.RooFit.Save(1))
def make_roodataset(python_list_of_vars, file_name, tree_name = "BdToKstarMuMu_Data", path_to_save = "select_kstarmumu_roodataset.root", cuts=None): """ Makes a RooDataSet in the current directory. I only really want to do this once since python is slow. """ from ROOT import RooArgSet, RooDataSet # open the files and get the trees from sam.pp.utils.root import get_tree_from_file (f,t) = get_tree_from_file(file_name, tree_name) # get the variables into the stupid roofit format ras = RooArgSet() for var in python_list_of_vars: ras.add(var) ras.Print() from ROOT import TFile fcut = TFile('/tmp/temp.root', 'RECREATE') if cuts: tr = t.CopyTree(cuts) else: tr = t # make a RooDataSet from both trees print("making the RooArgSet... yes this takes a long time because python"\ + " is slower than C++ \nperhaps you could use the time to reflect"\ + "on how much you hate coding C++ and how beautiful python is") ds = RooDataSet("ds", "data set", tr, ras) print("made the RooDataSet") fcut.Close() # save it #from ROOT import TFile fds = TFile(path_to_save, "RECREATE") fds.cd() ds.Write() print("saved the RooDataSet") return ds
def performFitInLeptonAbsEta(data_histogram, signal_histogram, bkg1_histogram, bkg2_histogram): N_Data = data_histogram.Integral() N_signal = signal_histogram.Integral() N_bkg1 = bkg1_histogram.Integral() N_bkg2 = bkg2_histogram.Integral() leptonAbsEta = RooRealVar("leptonAbsEta", "leptonAbsEta", 0., 3.) variables = RooArgList() variables.add(leptonAbsEta) variable_set = RooArgSet() variable_set.add(leptonAbsEta) lowerBound = 0 upperBound = N_Data*2 data_RooDataHist = RooDataHist("data", "dataset with leptonAbsEta", variables, data_histogram) signal_RooDataHist = RooDataHist("rh_signal", "signal", variables, signal_histogram); bkg1_RooDataHist = RooDataHist("rh_bkg1", "bkg1", variables, bkg1_histogram); bkg2_RooDataHist = RooDataHist("rh_bkg2", "bkg2", variables, bkg2_histogram); signal_RooHistPdf = RooHistPdf("pdf_signal", "Signal PDF", variable_set, signal_RooDataHist, 0) signal_RooHistPdf = RooHistPdf("pdf_signal", "Signal PDF", variable_set, signal_RooDataHist, 0)
def addData(self, ws, ds_name, item_title, var_set_name, var_set_type, ds_object, weight_var_name = None, debug = 0, sets = None): legend = '[exostConfig::addData]:' arg_set = RooArgSet() if (var_set_type == 'set'): #arg_set.add(ws.set(var_set_name)) arg_set.add(sets[var_set_name]) elif (var_set_type == 'var'): arg_set.add(ws.var(var_set_name)) else: print legend, 'error: unknown var_set_type, cannot create dataset', ds_name return -1 #create the dataset if weight_var_name == None: #no weight if (debug>0): print legend, 'no weight branch given' ds = RooDataSet(ds_name, item_title, ds_object, arg_set) else: if (debug>0): print legend, 'using weight branch', weight_var_name # old and incorrect(?) way of applying weights # #_var_formula = RooFormulaVar('f'+weight_var_name, # 'f'+weight_var_name, # '@0', # RooArgList(ws.var(weight_var_name))) #ds = RooDataSet(ds_name, item_title, ds_object, arg_set, _var_formula, weight_var_name) arg_set.add(ws.var(weight_var_name)) ds = RooDataSet(ds_name, item_title, ds_object, arg_set, "1>0", weight_var_name) # import the datahist. Note workaround 'import' being a reserved word getattr(ws, 'import')(ds)
def hessian(nll, parameters, N = 9): values = dict([(p.GetName(), (p.getVal(), p.getError())) for p in parameters]) nll_min = nll.getVal() __parameters = RooArgSet() for p in parameters: __parameters.add(p) nll_params = nll.getObservables(__parameters) H = TMatrixTSym('double')(parameters.getSize()) diagonals = {} for i, x in enumerate(parameters): p = nll_params.find(x.GetName()) r = fit_parabola(nll, nll_min, p, N) diagonals[p.GetName()] = r H[i][i] = 2 * r[1] for i, x in enumerate(parameters): x = nll_params.find(x.GetName()) for j in range(i + 1, parameters.getSize()): y = nll_params.find(parameters.at(j).GetName()) H[i][j] = H[j][i] = fit_cross(nll, nll_min, x, y, diagonals, N) return H
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 addData(self, ws, ds_name, item_title, var_set_name, var_set_type, ds_object, weight_var_name=None, debug=0, sets=None): legend = '[exostConfig::addData]:' arg_set = RooArgSet() if (var_set_type == 'set'): #arg_set.add(ws.set(var_set_name)) arg_set.add(sets[var_set_name]) elif (var_set_type == 'var'): arg_set.add(ws.var(var_set_name)) else: print legend, 'error: unknown var_set_type, cannot create dataset', ds_name return -1 #create the dataset if weight_var_name == None: #no weight if (debug > 0): print legend, 'no weight branch given' ds = RooDataSet(ds_name, item_title, ds_object, arg_set) else: if (debug > 0): print legend, 'using weight branch', weight_var_name # old and incorrect(?) way of applying weights # #_var_formula = RooFormulaVar('f'+weight_var_name, # 'f'+weight_var_name, # '@0', # RooArgList(ws.var(weight_var_name))) #ds = RooDataSet(ds_name, item_title, ds_object, arg_set, _var_formula, weight_var_name) arg_set.add(ws.var(weight_var_name)) ds = RooDataSet(ds_name, item_title, ds_object, arg_set, "1>0", weight_var_name) # import the datahist. Note workaround 'import' being a reserved word getattr(ws, 'import')(ds)
def run(self, **kwargs): from ROOT import RooArgSet __check_req_kw__("Observables", kwargs) __check_req_kw__("Pdf", kwargs) observables = kwargs.pop("Observables") obs_set = RooArgSet(*observables) pdf = kwargs.pop("Pdf") genPdf = kwargs.pop("GenPdf", pdf) gen_obs_set = RooArgSet() for o in list(observables) + list(genPdf.ConditionalObservables()): gen_obs_set.add(o._target_()) gen_pdf_params = genPdf.getParameters(gen_obs_set).snapshot(True) genPdf = genPdf.clone(genPdf.GetName() + "_toy_clone") genPdf.recursiveRedirectServers(gen_pdf_params) fit_obs_set = RooArgSet() for o in list(observables) + list(pdf.ConditionalObservables()): fit_obs_set.add(o._target_()) params = pdf.getParameters(fit_obs_set) pdf_params = RooArgSet() for p in params: if p.isConstant(): continue pdf_params.add(p) ## for param in pdf_params: ## if param.GetName() not in ['Gamma', 'dGamma']: ## param.setConstant() self._gen_params = pdf_params.snapshot(True) # Make another ArgSet to put the fit results in result_params = RooArgSet(pdf_params, "result_params") transform = self.transform() if transform: trans_params = transform.gen_params(gen_obs_set) for p in trans_params: result_params.add(p) # Some extra numbers of interest from ROOT import RooRealVar NLL = RooRealVar("NLL", "-log(Likelihood)", 1.0) ngen = RooRealVar("ngen", "number of generated events", self.options().nevents) seed = RooRealVar("seed", "random seed", 0.0) from ROOT import RooCategory status = RooCategory("status", "fit status") status.defineType("success", 0) status.defineType("one", 1) status.defineType("two", 2) status.defineType("three", 3) status.defineType("other", 4) result_params.add(status) result_params.add(NLL) result_params.add(ngen) result_params.add(seed) # The dataset to store the results from ROOT import RooDataSet self._data = RooDataSet("result_data", "result_data", result_params) data_params = self._data.get() from ROOT import RooRandom import struct, os while self._data.numEntries() < self.options().ntoys: # Get a good random seed, set it and store it s = struct.unpack("I", os.urandom(4))[0] RooRandom.randomGenerator().SetSeed(s) seed.setVal(s) # Reset pdf parameters to initial values. Note: this does not reset the estimated errors... pdf_params.assignValueOnly(self.gen_params()) args = dict(NumEvents=self.options().nevents) if "ProtoData" in kwargs: args["ProtoData"] = kwargs.pop("ProtoData") genPdf.getParameters(obs_set).assignValueOnly(gen_pdf_params) data = genPdf.generate(obs_set, **args) if transform: data = transform(data) if not data: # Transform has failed transform.set_params(data_params) self._data.add(data_params) continue if data.isWeighted() and "SumW2Error" not in self.fit_opts(): self.fit_opts()["SumW2Error"] = False j = 0 while j < 4: fit_result = pdf.fitTo(data, NumCPU=self.options().ncpu, **(self.fit_opts())) if fit_result.status() == 0: fit_result.Print() break j += 1 if fit_result.status() != 0: print "Fit result status = %s" % fit_result.status() NLL.setVal(fit_result.minNll()) if fit_result.status() < 4: status.setIndex(fit_result.status()) else: status.setIndex(4) for result_param in result_params: data_param = data_params.find(result_param.GetName()) if isinstance(result_param, RooCategory): data_param.setIndex(result_param.getIndex()) else: data_param.setVal(result_param.getVal()) # This sets a symmetric error, but since we don't run Minos, that's ok data_param.setError(result_param.getError()) if transform: transform.set_params(data_params) self._data.add(data_params) return self.data()
def fitData(fulldata, ibin): cut = cut_base + '&& (mumuMass*mumuMass > %s && mumuMass*mumuMass < %s)' % ( q2binning[ibin], q2binning[ibin + 1]) data = fulldata.reduce(RooArgSet(tagged_mass, mumuMass, mumuMassE), cut) fraction = dict_s_rt[ibin] / (dict_s_rt[ibin] + dict_s_wt[ibin]) print 'mistag fraction on MC for bin ', ibin, ' : ', fraction.n, '+/-', fraction.s ### creating RT component w.loadSnapshot("reference_fit_RT_%s" % ibin) sigmart1 = w.var("#sigma_{1}^{RT%s}" % ibin) sigmart2 = w.var("#sigma_{2}^{RT%s}" % ibin) massrt = w.var("mean^{RT%s}" % ibin) f1rt = w.var("f^{RT%s}" % ibin) theRTgauss = w.pdf("doublegaus_RT%s" % ibin) c_sigma_rt1 = _constrainVar(sigmart1) c_sigma_rt2 = _constrainVar(sigmart2) c_mean_rt = _constrainVar(massrt) c_f1rt = _constrainVar(f1rt) ### creating WT component w.loadSnapshot("reference_fit_WT_%s" % ibin) meanwt = w.var("mean^{WT%s}" % ibin) sigmawt = w.var("#sigma_{CB}^{WT%s}" % ibin) alphawt1 = w.var("#alpha_{1}^{WT%s}" % ibin) alphawt2 = w.var("#alpha_{2}^{WT%s}" % ibin) nwt1 = w.var("n_{1}^{WT%s}" % ibin) nwt2 = w.var("n_{2}^{WT%s}" % ibin) theWTgauss = w.pdf("doublecb_%s" % ibin) c_mean_wt = _constrainVar(meanwt) c_sigma_wt = _constrainVar(sigmawt) c_alpha_wt1 = _constrainVar(alphawt1) c_alpha_wt2 = _constrainVar(alphawt2) c_n_wt1 = _constrainVar(nwt1) c_n_wt2 = _constrainVar(nwt2) ### creating constraints for the RT component c_RTgauss = RooProdPdf( "c_RTgauss", "c_RTgauss", RooArgList(theRTgauss, c_sigma_rt1, c_sigma_rt2, c_mean_rt, c_f1rt)) c_vars = RooArgSet(c_sigma_rt1, c_sigma_rt2, c_f1rt, c_mean_rt) c_vars.add(c_sigma_wt) c_vars.add(c_mean_wt) c_vars.add(c_alpha_wt1) c_vars.add(c_alpha_wt2) c_vars.add(c_n_wt1) c_vars.add(c_n_wt2) ### creating constraints for the WT component c_WTgauss = RooProdPdf( "c_WTgauss", "c_WTgauss", RooArgList(theWTgauss, c_alpha_wt1, c_n_wt1, c_sigma_wt, c_mean_wt, c_alpha_wt2, c_n_wt2)) frt = RooRealVar("F_{RT}", "frt", fraction.n, 0, 1) signalFunction = RooAddPdf("sumgaus", "rt+wt", RooArgList(c_RTgauss, c_WTgauss), RooArgList(frt)) c_frt = RooGaussian("c_frt", "c_frt", frt, ROOT.RooFit.RooConst(fraction.n), ROOT.RooFit.RooConst(fraction.s)) c_signalFunction = RooProdPdf("c_signalFunction", "c_signalFunction", RooArgList(signalFunction, c_frt)) c_vars.add(frt) ### now create background parametrization slope = RooRealVar("slope", "slope", 0.5, -10, 10) bkg_exp = RooExponential("bkg_exp", "exponential", slope, tagged_mass) pol_c1 = RooRealVar("p1", "coeff x^0 term", 0.5, -10, 10) pol_c2 = RooRealVar("p2", "coeff x^1 term", 0.5, -10, 10) bkg_pol = RooChebychev("bkg_pol", "2nd order pol", tagged_mass, RooArgList(pol_c1, pol_c2)) nsig = RooRealVar("Yield", "signal frac", 4000, 0, 1000000) nbkg = RooRealVar("nbkg", "bkg fraction", 1000, 0, 550000) # fitFunction = RooAddPdf ("fitfunction" , "fit function" , RooArgList(c_signalFunction, bkg_pol), RooArgList(nsig, nbkg)) fitFunction = RooAddPdf("fitfunction", "fit function", RooArgList(c_signalFunction, bkg_exp), RooArgList(nsig, nbkg)) r = fitFunction.fitTo(data, RooFit.Extended(True), RooFit.Save(), RooFit.Range("full"), RooFit.Verbose(False), ROOT.RooFit.Constrain(c_vars)) frame = tagged_mass.frame(RooFit.Range("full")) data.plotOn(frame, RooFit.Binning(35), RooFit.MarkerSize(.7)) fitFunction.plotOn(frame) drawPdfComponents(fitFunction, frame, ROOT.kAzure, RooFit.NormRange("full"), RooFit.Range("full"), isData=True) parList = RooArgSet(nsig, massrt, sigmart1, sigmart2, f1rt, meanwt, sigmawt, alphawt1) parList.add(alphawt2) parList.add(nwt1) parList.add(nwt2) parList.add(frt) fitFunction.paramOn(frame, RooFit.Parameters(parList), RooFit.Layout(0.62, 0.86, 0.89)) frame.Draw() niceFrame(frame, '') frame.addObject(_writeFitStatus(r)) if not args.year == 'test': writeCMS(frame, args.year, [q2binning[ibin], q2binning[ibin + 1]]) frame.Draw() c1.SaveAs('fit_results_mass/save_fit_data_%s_%s_LMNR.pdf' % (ibin, args.year))
temp_zj.Rebin(20) temp_stop.Rebin(20) temp_qcd.Rebin(20) temp_qcd.Scale(800/temp_qcd.Integral()) temp_signal = temp_tt.Clone('signal') temp_signal.Add(temp_stop) #temp_tt.Scale(1/temp_tt.Integral()) #temp_wj.Scale(1/temp_wj.Integral()) #temp_zj.Scale(1/temp_zj.Integral()) #temp_stop.Scale(1/temp_stop.Integral()) #temp_qcd.Scale(1/temp_qcd.Integral()) leptonAbsEta = RooRealVar("leptonAbsEta", "leptonAbsEta", 0., 3.) vars = RooArgList() vars.add(leptonAbsEta) vars_set = RooArgSet() vars_set.add(leptonAbsEta) n_event_obs = h_m3_data.GetEntries(); lowerBound = -10 * sqrt(n_event_obs); upperBound = n_event_obs + 10 * sqrt(n_event_obs); n_init = n_event_obs / 2.; data = RooDataHist("data", "dataset with leptonAbsEta", vars, h_m3_data) rh_tt = RooDataHist("rh_tt", "tt", vars, temp_tt); rh_wj = RooDataHist("rh_wj", "wj", vars, temp_wj); rh_zj = RooDataHist("rh_zj", "zj", vars, temp_zj); rh_qcd = RooDataHist("rh_qcd", "qcd", vars, temp_qcd); rh_stop = RooDataHist("rh_stop", "singletop", vars, temp_stop); rh_signal = RooDataHist("rh_signal", "signal", vars, temp_signal); pdf_tt = RooHistPdf("pdf_tt", "Signal pdf", vars_set, rh_tt, 0); pdf_wj = RooHistPdf ("pdf_wj", "W+jets pdf", vars_set, rh_wj, 0); pdf_zj = RooHistPdf ("pdf_zj", "Z+jets pdf", vars_set, rh_zj, 0);
def fit(self): fit_variable = RooRealVar("fit_variable", "fit_variable", self.fit_boundaries[0], self.fit_boundaries[1]) fit_variable.setBins(self.histograms[self.data_label].nbins()) variables = RooArgList() variables.add(fit_variable) variable_set = RooArgSet() variable_set.add(fit_variable) roofit_histograms = {} roofit_pdfs = {} roofit_variables = {} N_min = 0. N_max = self.normalisation[self.data_label] * 2. pdf_arglist = RooArgList() variable_arglist = RooArgList() roofit_histograms[self.data_label] = RooDataHist( self.data_label, self.data_label, variables, self.histograms[self.data_label]) for sample in self.samples: roofit_histogram = RooDataHist(sample, sample, variables, self.histograms[sample]) roofit_histograms[sample] = roofit_histogram roofit_pdf = RooHistPdf('pdf' + sample, 'pdf' + sample, variable_set, roofit_histogram) roofit_pdfs[sample] = roofit_pdf roofit_variable = RooRealVar(sample, sample + " events", self.normalisation[sample], N_min, N_max) roofit_variables[sample] = roofit_variable pdf_arglist.add(roofit_pdf) variable_arglist.add(roofit_variable) model = RooAddPdf('model', 'sum of all known', pdf_arglist, variable_arglist) use_model = model if self.constraints: arg_set = RooArgSet(model) constraints = self.get_fit_normalisation_constraints( model, roofit_variables) for constraint in constraints: arg_set.add(constraint) model_with_constraints = RooProdPdf( "model_with_constraints", "model with gaussian constraints", arg_set, RooLinkedList()) use_model = model_with_constraints if self.method == 'TMinuit': #WARNING: number of cores changes the results!!! self.saved_result = use_model.fitTo( roofit_histograms[self.data_label], RooFit.Minimizer("Minuit2", "Migrad"), RooFit.NumCPU(1), RooFit.Extended(), RooFit.Save(), ) results = {} for sample in self.samples: results[sample] = (roofit_variables[sample].getVal(), roofit_variables[sample].getError()) self.results = results
def 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.) jmuonpt_1 = RooRealVar( "jmuonpt_1", "j1 muon pt", 0., 13000.) jmuonpt_2 = RooRealVar( "jmuonpt_2", "j2 muon pt", 0., 13000.) 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, jmuonpt_1, jmuonpt_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 = "bstar_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]
def buildDataAndCategories(ws, options, args): #Get the input data inputData = TChain(options.treeName, 'The input data') for arg in args: print 'Adding data from: ', arg inputData.Add(arg) foldname = '' phirange = [0, 90] if not options.folded: foldname = '' phirange = [-180, 180] #variables necessary for j/psi mass,lifetime,polarization fit jPsiMass = RooRealVar('JpsiMass', 'M [GeV]', 2.7, 3.5) jPsiRap = RooRealVar('JpsiRap', '#nu', -2.3, 2.3) jPsiPt = RooRealVar("JpsiPt", "pT [GeV]", 0, 40) jPsicTau = RooRealVar('Jpsict', 'l_{J/#psi} [mm]', -1, 2.5) jPsicTauError = RooRealVar('JpsictErr', 'Error on l_{J/#psi} [mm]', 0, 2) jPsiVprob = RooRealVar('JpsiVprob', '', .01, 1) jPsiHXcosth = None jPsiHXphi = None jPsicTau.setBins(10000, "cache") if options.fitFrame is not None: jPsiHXcosth = RooRealVar('costh_' + options.fitFrame + foldname, 'cos(#theta)_{' + options.fitFrame + '}', -1, 1) jPsiHXphi = RooRealVar('phi_' + options.fitFrame + foldname, '#phi_{' + options.fitFrame + '}', phirange[0], phirange[1]) else: jPsiHXcosth = RooRealVar('costh_CS' + foldname, 'cos(#theta)_{CS}', -1, 1) jPsiHXphi = RooRealVar('phi_CS' + foldname, '#phi_{CS}', phirange[0], phirange[1]) #vars needed for on the fly calc of polarization variables jPsimuPosPx = RooRealVar('muPosPx', '+ Muon P_{x} [GeV]', 0) jPsimuPosPy = RooRealVar('muPosPy', '+ Muon P_{y} [GeV]', 0) jPsimuPosPz = RooRealVar('muPosPz', '+ Muon P_{z} [GeV]', 0) jPsimuNegPx = RooRealVar('muNegPx', '- Muon P_{x} [GeV]', 0) jPsimuNegPy = RooRealVar('muNegPy', '- Muon P_{y} [GeV]', 0) jPsimuNegPz = RooRealVar('muNegPz', '- Muon P_{z} [GeV]', 0) #create RooArgSet for eventual dataset creation dataVars = RooArgSet(jPsiMass, jPsiRap, jPsiPt, jPsicTau, jPsicTauError, jPsimuPosPx, jPsimuPosPy, jPsimuPosPz) #add trigger requirement if specified if options.triggerName: trigger = RooRealVar(options.triggerName, 'Passes Trigger', 0.5, 1.5) dataVars.add(trigger) dataVars.add(jPsiVprob) dataVars.add(jPsimuNegPx) dataVars.add(jPsimuNegPy) dataVars.add(jPsimuNegPz) dataVars.add(jPsiHXcosth) dataVars.add(jPsiHXphi) redVars = RooArgSet(jPsiMass, jPsiRap, jPsiPt, jPsicTau, jPsicTauError) redVars.add(jPsiHXcosth) redVars.add(jPsiHXphi) fitVars = redVars.Clone() ### HERE IS WHERE THE BIT FOR CALCULATING POLARIZATION VARS GOES ctauStates = RooCategory('ctauRegion', 'Cut Region in lifetime') ctauStates.defineType('prompt', 0) ctauStates.defineType('nonPrompt', 1) massStates = RooCategory('massRegion', 'Cut Region in mass') massStates.defineType('signal', 1) massStates.defineType('separation', 0) massStates.defineType('leftMassSideBand', -2) massStates.defineType('rightMassSideBand', -1) states = RooCategory('mlRegion', 'Cut Region in mass') states.defineType('nonPromptSignal', 2) states.defineType('promptSignal', 1) states.defineType('separation', 0) states.defineType('leftMassSideBand', -2) states.defineType('rightMassSideBand', -1) #define corresponding ranges in roorealvars #mass is a little tricky since the sidebands change definitions in each rap bin #define the names here and change as we do the fits #jPsiMass.setRange('NormalizationRangeFormlfit_promptSignal',2.7,3.5) #jPsiMass.setRange('NormalizationRangeFormlfit_nonPromptSignal',2.7,3.5) #jPsiMass.setRange('NormalizationRangeFormlfit_leftMassSideBand',2.7,3.1) #jPsiMass.setRange('NormalizationRangeFormlfit_rightMassSideBand',3.1,3.5) #want the prompt fit only done in prompt region #non-prompt only in non-prompt region #background over entire cTau range #jPsicTau.setRange('NormalizationRangeFormlfit_promptSignal',-1,.1) #jPsicTau.setRange('NormalizationRangeFormlfit_nonPromptSignal',.1,2.5) #jPsicTau.setRange('NormalizationRangeFormlfit_leftMassSideBand',-1,2.5) #jPsicTau.setRange('NormalizationRangeFormlfit_rightMassSideBand',-1,2.5) #redVars.add(ctauStates) #redVars.add(massStates) #redVars.add(states) fitVars.add(ctauStates) fitVars.add(massStates) fitVars.add(states) fullData = RooDataSet('fullData', 'The Full Data From the Input ROOT Trees', dataVars, ROOT.RooFit.Import(inputData)) for rap_bin in range(1, len(jpsi.pTRange)): yMin = jpsi.rapForPTRange[rap_bin - 1][0] yMax = jpsi.rapForPTRange[rap_bin - 1][-1] for pt_bin in range(len(jpsi.pTRange[rap_bin])): ptMin = jpsi.pTRange[rap_bin][pt_bin][0] ptMax = jpsi.pTRange[rap_bin][pt_bin][-1] sigMaxMass = jpsi.polMassJpsi[ rap_bin] + jpsi.nSigMass * jpsi.sigmaMassJpsi[rap_bin] sigMinMass = jpsi.polMassJpsi[ rap_bin] - jpsi.nSigMass * jpsi.sigmaMassJpsi[rap_bin] sbHighMass = jpsi.polMassJpsi[ rap_bin] + jpsi.nSigBkgHigh * jpsi.sigmaMassJpsi[rap_bin] sbLowMass = jpsi.polMassJpsi[ rap_bin] - jpsi.nSigBkgLow * jpsi.sigmaMassJpsi[rap_bin] ctauNonPrompt = .1 massFun = RooFormulaVar( 'massRegion', 'Function that returns the mass state.', '(' + jPsiMass.GetName() + ' < ' + str(sigMaxMass) + ' && ' + jPsiMass.GetName() + ' > ' + str(sigMinMass) + ') - (' + jPsiMass.GetName() + ' > ' + str(sbHighMass) + ')' + '-2*(' + jPsiMass.GetName() + ' < ' + str(sbLowMass) + ')', RooArgList(jPsiMass, jPsicTau)) ctauFun = RooFormulaVar( 'ctauRegion', 'Function that returns the ctau state.', '(' + jPsicTau.GetName() + ' > ' + str(ctauNonPrompt) + ')', RooArgList(jPsiMass, jPsicTau)) mlFun = RooFormulaVar( 'mlRegion', 'Function that returns the mass and lifetime state.', '(' + jPsiMass.GetName() + ' < ' + str(sigMaxMass) + ' && ' + jPsiMass.GetName() + ' > ' + str(sigMinMass) + ') + (' + jPsiMass.GetName() + ' < ' + str(sigMaxMass) + ' && ' + jPsiMass.GetName() + ' > ' + str(sigMinMass) + ' && ' + jPsicTau.GetName() + ' > ' + str(ctauNonPrompt) + ') - (' + jPsiMass.GetName() + ' > ' + str(sbHighMass) + ')' + '-2*(' + jPsiMass.GetName() + ' < ' + str(sbLowMass) + ')', RooArgList(jPsiMass, jPsicTau)) cutStringPt = '(' + jPsiPt.GetName() + ' > ' + str( ptMin) + ' && ' + jPsiPt.GetName() + ' < ' + str(ptMax) + ')' cutStringY = '( abs(' + jPsiRap.GetName() + ') > ' + str( yMin) + ' && abs(' + jPsiRap.GetName() + ') < ' + str( yMax) + ')' #cutStringM1 = '('+jPsiMass.GetName()+' < '+str(sigMinMass)+' && '+jPsiMass.GetName()+' > '+str(sbLowMass)+')' #cutStringM2 = '('+jPsiMass.GetName()+' < '+str(sbHighMass)+' && '+jPsiMass.GetName()+' > '+str(sigMaxMass)+')' #cutStringMT = '!('+cutStringM1+' || '+cutStringM2+')' cutString = cutStringPt + ' && ' + cutStringY #+' && '+cutStringMT print cutString #get the reduced dataset we'll do the fit on binData = fullData.reduce( ROOT.RooFit.SelectVars(redVars), ROOT.RooFit.Cut(cutString), ROOT.RooFit.Name('data_rap' + str(rap_bin) + '_pt' + str(pt_bin + 1)), ROOT.RooFit.Title('Data For Fitting')) binDataWithCategory = RooDataSet( 'data_rap' + str(rap_bin) + '_pt' + str(pt_bin + 1), 'Data For Fitting', fitVars) #categorize binData.addColumn(ctauStates) binData.addColumn(massStates) binData.addColumn(states) for ev in range(binData.numEntries()): args = binData.get(ev) jPsiMass.setVal(args.find(jPsiMass.GetName()).getVal()) jPsiRap.setVal(args.find(jPsiRap.GetName()).getVal()) jPsiPt.setVal(args.find(jPsiPt.GetName()).getVal()) jPsicTau.setVal(args.find(jPsicTau.GetName()).getVal()) jPsicTauError.setVal( args.find(jPsicTauError.GetName()).getVal()) jPsiHXcosth.setVal(args.find(jPsiHXcosth.GetName()).getVal()) jPsiHXphi.setVal(args.find(jPsiHXphi.GetName()).getVal()) massStates.setIndex(int(massFun.getVal())) ctauStates.setIndex(int(ctauFun.getVal())) states.setIndex(int(mlFun.getVal())) binDataWithCategory.add(fitVars) getattr(ws, 'import')(binDataWithCategory)
space.factory('Polynomial::pPDF_%s(X,{c1_%s[0.01,-2.,0.2],c2_%s[0.01,-3.,1.0]})' % (label,label,label) ) #space.factory('Polynomial::pPDF_%s(lbl0Mass,{c1_%s[0.01,-5.,5.]})' % (label,label) ) # set resolution issue: Convolute a gaussian. space.factory('numCombBkg_{0}[{1},0.,{2}]'.format(label, totNum,totNum)) myPDF=RooAddPdf('totPdf_{0}'.format(label),'totPdf_{0}'.format(label), RooArgList( space.pdf('pPDF_{0}'.format(label)), space.pdf('gPDF_lbl0Dist_lbl0MC') ), RooArgList( space.var('numCombBkg_{0}'.format(label)), space.var('numLb') ), False) getattr(space,'import')(myPDF) constrSet=RooArgSet() for constredName in constredNames['pLbL0']: constrSet.add(space.pdf(constredName)) fitres=myPDF.fitTo(binData,RooFit.Range('sigShortRange'),RooFit.Save(),RooFit.Minos(True),RooFit.ExternalConstraints(constrSet)) #fitres=myPDF.fitTo(binData,RooFit.Range('sigShortRange'),RooFit.Save(),RooFit.Minos(True)) plotframe=massLb.frame(RooFit.Title(label),RooFit.Range('sigShortRange')) binData.plotOn(plotframe,RooFit.Name('data')) myPDF.plotOn(plotframe,RooFit.Name('totModel'),RooFit.LineWidth(1),RooFit.LineColor(2)) myPDF.plotOn(plotframe,RooFit.Name('combBkg'),RooFit.Components('pPDF_{0}' .format(label)),RooFit.LineWidth(1),RooFit.LineColor(27)) myPDF.plotOn(plotframe,RooFit.Name('sig') ,RooFit.Components('gPDF_lbl0Dist_lbl0MC' ),RooFit.LineStyle(5),RooFit.LineColor(8 )) plotframe.Draw() #canv.SaveAs('tmpLbL0.pdf') #pfigDir.cd()
def fitChicSpectrum(dataset, binname): """ Fit chic spectrum""" x = RooRealVar('Qvalue', 'Q', 9.7, 10.1) x.setBins(80) mean_1 = RooRealVar("mean_1", "mean ChiB1", 9.892, 9, 10, "GeV") sigma_1 = RooRealVar("sigma_1", "sigma ChiB1", 0.0058, 'GeV') a1_1 = RooRealVar('#alpha1_1', '#alpha1_1', 0.748) n1_1 = RooRealVar('n1_1', 'n1_1', 2.8) a2_1 = RooRealVar('#alpha2_1', '#alpha2_1', 1.739) n2_1 = RooRealVar('n2_1', 'n2_1', 3.0) deltam = RooRealVar('deltam', 'deltam', 0.01943) mean_2 = RooFormulaVar("mean_2", "@0+@1", RooArgList(mean_1, deltam)) sigma_2 = RooRealVar("sigma_2", "sigma ChiB2", 0.0059, 'GeV') a1_2 = RooRealVar('#alpha1_2', '#alpha1_2', 0.738) n1_2 = RooRealVar('n1_2', 'n1_2', 2.8) a2_2 = RooRealVar('#alpha2_2', '#alpha2_2', 1.699) n2_2 = RooRealVar('n2_2', 'n2_2', 3.0) parameters = RooArgSet() parameters.add(RooArgSet(sigma_1, sigma_2)) parameters = RooArgSet(a1_1, a2_1, n1_1, n2_1) parameters.add(RooArgSet(a1_2, a2_2, n1_2, n2_2)) chib1_pdf = My_double_CB('chib1', 'chib1', x, mean_1, sigma_1, a1_1, n1_1, a2_1, n2_1) chib2_pdf = My_double_CB('chib2', 'chib2', x, mean_2, sigma_2, a1_2, n1_2, a2_2, n2_2) #background q01S_Start = 9.5 alpha = RooRealVar("#alpha", "#alpha", 1.5, -1, 3.5) #0.2 anziche' 1 beta = RooRealVar("#beta", "#beta", -2.5, -7., 0.) q0 = RooRealVar("q0", "q0", q01S_Start) #,9.5,9.7) delta = RooFormulaVar("delta", "TMath::Abs(@0-@1)", RooArgList(x, q0)) b1 = RooFormulaVar("b1", "@0*(@1-@2)", RooArgList(beta, x, q0)) signum1 = RooFormulaVar("signum1", "( TMath::Sign( -1.,@0-@1 )+1 )/2.", RooArgList(x, q0)) background = RooGenericPdf("background", "Background", "signum1*pow(delta,#alpha)*exp(b1)", RooArgList(signum1, delta, alpha, b1)) parameters.add(RooArgSet(alpha, beta, q0)) #together chibs = RooArgList(chib1_pdf, chib2_pdf, background) n_chib = RooRealVar("n_chib", "n_chib", 2075, 0, 100000) ratio_21 = RooRealVar("ratio_21", "ratio_21", 0.5, 0, 1) n_chib1 = RooFormulaVar("n_chib1", "@0/(1+@1)", RooArgList(n_chib, ratio_21)) n_chib2 = RooFormulaVar("n_chib2", "@0/(1+1/@1)", RooArgList(n_chib, ratio_21)) n_background = RooRealVar('n_background', 'n_background', 4550, 0, 50000) ratio_list = RooArgList(n_chib1, n_chib2, n_background) modelPdf = RooAddPdf('ModelPdf', 'ModelPdf', chibs, ratio_list) frame = x.frame(RooFit.Title('m')) range = x.setRange('range', 9.7, 10.1) result = modelPdf.fitTo(dataset, RooFit.Save(), RooFit.Range('range')) dataset.plotOn(frame, RooFit.MarkerSize(0.7)) modelPdf.plotOn(frame, RooFit.LineWidth(2)) #plotting canvas = TCanvas('fit', "", 1400, 700) canvas.Divide(1) canvas.cd(1) gPad.SetRightMargin(0.3) gPad.SetFillColor(10) modelPdf.paramOn(frame, RooFit.Layout(0.725, 0.9875, 0.9)) frame.Draw() canvas.SaveAs('out-' + binname + '.png')
def doFit(ws,options): rap_bins = range(1,len(jpsi.pTRange)) pt_bins = None if options.testBin is not None: rap_bins = [int(options.testBin.split(',')[0])] pt_bins = [int(options.testBin.split(',')[1])-1] for rap_bin in rap_bins: if options.testBin is None: pt_bins = range(len(jpsi.pTRange[rap_bin])) for pt_bin in pt_bins: sigMaxMass = jpsi.polMassJpsi[rap_bin] + jpsi.nSigMass*jpsi.sigmaMassJpsi[rap_bin] sigMinMass = jpsi.polMassJpsi[rap_bin] - jpsi.nSigMass*jpsi.sigmaMassJpsi[rap_bin] sbHighMass = jpsi.polMassJpsi[rap_bin] + jpsi.nSigBkgHigh*jpsi.sigmaMassJpsi[rap_bin] sbLowMass = jpsi.polMassJpsi[rap_bin] - jpsi.nSigBkgLow*jpsi.sigmaMassJpsi[rap_bin] jPsiMass = ws.var('JpsiMass') jPsicTau = ws.var('Jpsict') jPsiMass.setRange('mlfit_prompt',2.7,3.5) jPsiMass.setRange('mlfit_nonPrompt',2.7,3.5) jPsiMass.setRange('NormalizationRangeFormlfit_prompt',2.7,3.5) jPsiMass.setRange('NormalizationRangeFormlfit_nonPrompt',2.7,3.5) jPsicTau.setRange('mlfit_signal',-1,2.5) jPsicTau.setRange('mlfit_leftMassSideBand',-1,2.5) jPsicTau.setRange('mlfit_rightMassSideBand',-1,2.5) jPsicTau.setRange('NormalizationRangeFormlfit_signal',-1,2.5) jPsicTau.setRange('NormalizationRangeFormlfit_leftMassSideBand',-1,2.5) jPsicTau.setRange('NormalizationRangeFormlfit_rightMassSideBand',-1,2.5) #jPsicTau.setRange('NormalizationRangeFormlfit_promptSignal',-1,.1) #jPsicTau.setRange('NormalizationRangeFormlfit_nonPromptSignal',.1,2.5) #jPsicTau.setRange('NormalizationRangeFormlfit_leftMassSideBand',-1,2.5) #jPsicTau.setRange('NormalizationRangeFormlfit_rightMassSideBand',-1,2.5) #jPsicTau.setRange('mlfit_promptSignal',-1,.1) #jPsicTau.setRange('mlfit_nonPromptSignal',.1,2.5) #jPsicTau.setRange('mlfit_leftMassSideBand',-1,2.5) #jPsicTau.setRange('mlfit_rightMassSideBand',-1,2.5) #reset parameters ws.var('CBn').setVal(.5) ws.var('CBalpha').setVal(.5) ws.var('CBmass').setVal(3.1) ws.var('CBsigma').setVal(.02) ws.var('bkgLambda').setVal(0) ws.var('bkgTauSSDL').setVal(.5) #ws.var('bkgTauFDL').setVal(.5) ws.var('bkgTauDSDL').setVal(.5) ws.var('fBkgSSDL').setVal(.5) ws.var('fBkgLR').setVal(.5) ws.var('bkgTauSSDR').setVal(.5) #ws.var('bkgTauFDR').setVal(.5) ws.var('bkgTauDSDR').setVal(.5) ws.var('fBkgSSDR').setVal(.5) #ws.var('fBkgFDR').setVal(.25) #ws.var('nPrompt').setVal(5000) #ws.var('nNonPrompt').setVal(500) #ws.var('nBackground').setVal(100) #ws.var('nBackgroundL').setVal(50) #ws.var('nBackgroundR').setVal(50) ws.var('nonPromptTau').setVal(.5) ws.var('promptMean').setVal(0) ws.var('ctResolution').setVal(1) LPdf = ws.pdf('LPdf') MPdf = ws.pdf('MPdf') data = ws.data('data_rap'+str(rap_bin)+'_pt'+str(pt_bin+1)) NLLs = RooArgSet() MassNLL = MPdf.createNLL(data, ROOT.RooFit.Range('mlfit'), ROOT.RooFit.SplitRange(True), ROOT.RooFit.ConditionalObservables(RooArgSet(ws.var('JpsictErr'))), ROOT.RooFit.NumCPU(2)) CTauNLL = LPdf.createNLL(data, ROOT.RooFit.Range('mlfit'), ROOT.RooFit.SplitRange(True), ROOT.RooFit.ConditionalObservables(RooArgSet(ws.var('JpsictErr'))), ROOT.RooFit.NumCPU(2)) NLLs.add(MassNLL) NLLs.add(CTauNLL) simNLL = RooAddition('add','add',NLLs) minuit = RooMinuit(simNLL) minuit.setStrategy(2) minuit.setPrintEvalErrors(-1) minuit.simplex() minuit.migrad() minuit.migrad() minuit.hesse() fitresult = minuit.save('polfitresult_rap'+str(rap_bin)+'_pt'+str(pt_bin+1)) getattr(ws,'import')(fitresult) ws.saveSnapshot('snapshot_rap'+str(rap_bin)+'_pt'+str(pt_bin+1),ws.allVars())
n_rt = htag.GetBinContent(3) n_wt = htag.GetBinContent(2) + htag.GetBinContent(4) h_truef.Fill(float(n_rt) / (n_rt + n_wt)) tagged_mass = RooRealVar("tagged_mass", "#mu^{+}#mu^{-}K#pi mass", 5., 5.6, "GeV") mumuMass = RooRealVar("mumuMass", "mumuMass", 0, 6) mumuMassE = RooRealVar("mumuMassE", "mumuMassE", 0, 10000) tagB0 = RooRealVar("tagB0", "tagB0", 0, 6) genSignal = RooRealVar("genSignal", "genSignal", 0, 6) tagged_mass.setRange("full", 5.0, 5.6) thevars = RooArgSet() thevars.add(tagged_mass) thevars.add(mumuMass) thevars.add(mumuMassE) thevars.add(tagB0) thevars.add(genSignal) fulldata = RooDataSet('fulldata', 'fulldataset', tData, RooArgSet(thevars)) ## add to the input tree the combination of the variables, to be used for the cuts on the dimuon mass deltaB0Mfunc = RooFormulaVar("deltaB0M", "deltaB0M", "@0 - @1", RooArgList(tagged_mass, B0Mass)) deltaJMfunc = RooFormulaVar("deltaJpsiM", "deltaJpsiM", "@0 - @1", RooArgList(mumuMass, JPsiMass)) deltaPMfunc = RooFormulaVar("deltaPsiPM", "deltaPsiPM", "@0 - @1", RooArgList(mumuMass, PsiPMass)) deltaB0M = fulldata.addColumn(deltaB0Mfunc) deltaJpsiM = fulldata.addColumn(deltaJMfunc)
dict_b_v1 = {} dict_sigma = {} ### retrieve S from fitting the MC sample bMass = RooRealVar("bMass", "#mu^{+}#mu^{-}K* mass", 2, 20, "GeV") bBarMass = RooRealVar("bBarMass", "#mu^{+}#mu^{-}K* mass", 2, 20, "GeV") mumuMass = RooRealVar("mumuMass", "mumuMass", 0, 1000) mumuMassE = RooRealVar("mumuMassE", "mumuMassE", 0, 10000) tagB0 = RooRealVar("tagB0", "tagB0", -1, 2) bdt_prob = RooRealVar("bdt_prob", "bdt_prob", 0.5, 2) ## already cut here on BDT !!! pass_pre = RooRealVar("pass_preselection", "pass_preselection", 1, 2) ## cut on preselection thevars = RooArgSet() thevars.add(bMass) thevars.add(bBarMass) thevars.add(mumuMass) thevars.add(mumuMassE) thevars.add(tagB0) thevars.add(bdt_prob) tree = ROOT.TChain('ntuple') tree.AddFile(ifileMC) fulldata = RooDataSet('fulldata', 'fulldataset', tree, RooArgSet(thevars)) ## add to the input tree the combination of the variables for the B0 arb. mass theBMassfunc = RooFormulaVar("theBMass", "#mu^{+}#mu^{-}K^{#pm}#pi^{#mp} mass [GeV]", "@0*@1 + (1-@0)*@2", RooArgList(tagB0, bMass, bBarMass))
def fitData(fulldata, ibin, w): cut = cut_base + '&& (mumuMass*mumuMass > %s && mumuMass*mumuMass < %s)'%(q2binning[ibin], q2binning[ibin+1]) data = fulldata.reduce(RooArgSet(tagged_mass,mumuMass,mumuMassE), cut) nrt_mc = _getFittedVar("nRT_%s"%ibin, w) nwt_mc = _getFittedVar("nWT_%s"%ibin, w) fraction = nrt_mc / (nrt_mc + nwt_mc) print 'mistag fraction on MC for bin ', ibin , ' : ' , fraction.n , '+/-', fraction.s ### creating RT component w.loadSnapshot("reference_fit_RT_%s"%ibin) mean_rt = w.var("mean^{RT%s}"%ibin) sigma_rt1 = w.var("#sigma_{RT1}^{%s}"%ibin) sigma_rt2 = RooRealVar() alpha_rt1 = RooRealVar() alpha_rt2 = RooRealVar() n_rt1 = RooRealVar() n_rt2 = RooRealVar() f1rt = RooRealVar() ## double cb fast if ibin < 4: alpha_rt1 = w.var("#alpha_{RT1}^{%s}"%ibin) alpha_rt2 = w.var("#alpha_{RT2}^{%s}"%ibin) n_rt1 = w.var("n_{RT1}^{%s}"%ibin) n_rt2 = w.var("n_{RT2}^{%s}"%ibin) ## double cb old else: sigma_rt2 = w.var("#sigma_{RT2}^{%s}"%ibin) alpha_rt1 = w.var("#alpha_{RT1}^{%s}"%ibin) alpha_rt2 = w.var("#alpha_{RT2}^{%s}"%ibin) n_rt1 = w.var("n_{RT1}^{%s}"%ibin) n_rt2 = w.var("n_{RT2}^{%s}"%ibin) f1rt = w.var("f^{RT%s}"%ibin) theRTgauss = w.pdf("doublecb_RT%s"%ibin) ### creating WT component w.loadSnapshot("reference_fit_WT_%s"%ibin) mean_wt = w.var("mean_{WT}^{%s}"%ibin) sigma_wt = w.var("#sigma_{WT1}^{%s}"%ibin) alpha_wt1 = w.var("#alpha_{WT1}^{%s}"%ibin) alpha_wt2 = w.var("#alpha_{WT2}^{%s}"%ibin) n_wt1 = w.var("n_{WT1}^{%s}"%ibin) n_wt2 = w.var("n_{WT2}^{%s}"%ibin) theWTgauss = w.pdf("doublecb_%s"%ibin) ### creating variable for the difference between the two peaks deltaPeaks = RooFormulaVar("deltaPeaks%s"%ibin, "@0 - @1", RooArgList(mean_rt, mean_wt)) frt = RooRealVar ("F_{RT}%s"%ibin , "frt" , fraction.n , 0, 1) signalFunction = RooAddPdf ("sumgaus%s"%ibin , "rt+wt" , RooArgList(theRTgauss,theWTgauss), RooArgList(frt)) ### now create background parametrization slope = RooRealVar ("slope_%s"%ibin , "slope" , 0.5, -10, 10); bkg_exp = RooExponential("bkg_exp%s"%ibin , "exponential" , slope, tagged_mass ); pol_c1 = RooRealVar ("p1_%s"%ibin , "coeff x^0 term" , 0.5, -10, 10); pol_c2 = RooRealVar ("p2_%s"%ibin , "coeff x^1 term" , 0.5, -10, 10); bkg_pol = RooPolynomial ("bkg_pol%s"%ibin , "2nd order pol" , tagged_mass, RooArgList(pol_c1, pol_c2)); fsig = RooRealVar("fsig%s"%ibin , "fsig" , 0.9, 0, 1); # nsig = RooRealVar("Yield%s"%ibin , "signal frac" , 1000, 0, 10000); # nbkg = RooRealVar("nbkg%s"%ibin , "bkg fraction" , 1000, 0, 500000); nsig = RooRealVar("Yield" , "signal frac" , 600000, 0, 5000000); nbkg = RooRealVar("nbkg" , "bkg fraction" , 100000, 0, 2000000); # if ibin==4: # nsig.setRange(500000,1500000) # nsig.setVal(900000) # nbkg.setRange(80000,1000000) # nbkg.setVal(100000) ### creating constraints c_vars = RooArgSet() c_pdfs = RooArgSet() c_sigma_rt1 = _constrainVar(sigma_rt1, 1) c_alpha_rt1 = _constrainVar(alpha_rt1, 1) c_alpha_rt2 = _constrainVar(alpha_rt2, 1) c_n_rt1 = _constrainVar(n_rt1, 1) c_n_rt2 = _constrainVar(n_rt2, 1) c_sigma_wt = _constrainVar(sigma_wt, 1) c_alpha_wt1 = _constrainVar(alpha_wt1, 1) c_alpha_wt2 = _constrainVar(alpha_wt2, 1) c_n_wt1 = _constrainVar(n_wt1, 1) c_n_wt2 = _constrainVar(n_wt2, 1) if ibin < 4: c_pdfs = RooArgSet(c_sigma_rt1, c_alpha_rt1, c_alpha_rt2, c_n_rt1, c_n_rt2) c_vars = RooArgSet(sigma_rt1, alpha_rt1, alpha_rt2, n_rt1, n_rt2) else: c_sigma_rt2 = _constrainVar(sigma_rt2, 1) c_pdfs = RooArgSet(c_sigma_rt1, c_sigma_rt2, c_alpha_rt1, c_alpha_rt2, c_n_rt1, c_n_rt2) c_vars = RooArgSet( sigma_rt1, sigma_rt2, alpha_rt1, alpha_rt2, n_rt1, n_rt2) c_pdfs.add(c_sigma_wt); c_vars.add(sigma_wt) c_pdfs.add(c_alpha_wt1); c_vars.add(alpha_wt1) c_pdfs.add(c_alpha_wt2); c_vars.add(alpha_wt2) c_pdfs.add(c_n_wt1); c_vars.add(n_wt1) c_pdfs.add(c_n_wt2); c_vars.add(n_wt2) c_deltaPeaks = RooGaussian("c_deltaPeaks%s"%ibin , "c_deltaPeaks", deltaPeaks, ROOT.RooFit.RooConst( deltaPeaks.getVal() ), ROOT.RooFit.RooConst( 0.0005 ) ## value to be checked ) c_pdfs.add(c_deltaPeaks) c_vars.add(deltaPeaks) c_frt = RooGaussian("c_frt%s"%ibin , "c_frt" , frt, ROOT.RooFit.RooConst(fraction.n) , ROOT.RooFit.RooConst(frt_sigma[ibin]) ) c_pdfs.add(c_frt) c_vars.add(frt) constr_list = RooArgList(c_pdfs) constr_list.add(signalFunction) c_signalFunction = RooProdPdf ("c_signalFunction", "c_signalFunction", constr_list) # mean = RooRealVar ("mass" , "mean" , B0Mass_, 3, 7, "GeV") # sigma = RooRealVar ("#sigma_{1}" , "sigma" , 0.028, 0, 10, "GeV") # signalGauss = RooGaussian("signalGauss" , "signal gauss" , tagged_mass, mean,sigma) # # sigma2 = RooRealVar ("#sigma_{2}" , "sigma2" , 0.048, 0, 0.07, "GeV") # signalGauss2 = RooGaussian("signalGauss2" , "signal gauss2" , tagged_mass, mean,sigma2) # f1 = RooRealVar ("f1" , "f1" , 0.8 , 0., 1.) # gaus = RooAddPdf ("gaus" , "gaus1+gaus2" , RooArgList(signalGauss,signalGauss2), RooArgList(f1)) # pol_c1 = RooRealVar ("p1" , "coeff x^0 term", 0.5, -10, 10); # pol_c2 = RooRealVar ("p2" , "coeff x^1 term", 0.5, -10, 10); # pol_c3 = RooRealVar ("p3" , "coeff x^2 term", 0.5, -10, 10); # slope = RooRealVar ("slope" , "slope" , 0.5, -10, 10); # bkg_exp = RooExponential("bkg_exp" , "exponential" , slope, tagged_mass ); # bkg_pol = RooChebychev("bkg_pol" , "2nd order pol" , tagged_mass, RooArgList(pol_c1,pol_c2)); fitFunction = RooAddPdf ("fitfunction%s"%ibin , "fit function" , RooArgList(c_signalFunction, bkg_exp), RooArgList(nsig, nbkg)) # r = fitFunction.fitTo(data, # # RooFit.Extended(True), # RooFit.Range("full"), # ROOT.RooFit.Constrain(c_vars), # ROOT.RooFit.Minimizer("Minuit2","migrad"), # ROOT.RooFit.Hesse(True), # ROOT.RooFit.Strategy(2), # ROOT.RooFit.Minos(False), # ) print 'fit with Hesse strategy 2 done, now Minos' r = fitFunction.fitTo(data, RooFit.Extended(True), RooFit.Save(), RooFit.Range("full"), RooFit.Verbose(False), ROOT.RooFit.Constrain(c_vars), # ROOT.RooFit.Minimizer("Minuit2","migrad"), # ROOT.RooFit.Hesse(True), # ROOT.RooFit.Strategy(2), # ROOT.RooFit.Minos(False), ) r.Print() r.correlationMatrix().Print() fitStats['data%s'%(ibin)] = r.status() covStats['data%s'%(ibin)] = r.covQual() frame = tagged_mass.frame( RooFit.Range("full") ) data.plotOn(frame, RooFit.Binning(nbins), RooFit.MarkerSize(.7)) fitFunction.plotOn(frame, RooFit.NormRange("full"), RooFit.Range("full")) ## evaluate sort of chi2 and save number of RT/WT events observables = RooArgSet(tagged_mass) flparams = fitFunction.getParameters(observables) nparam = int(flparams.selectByAttrib("Constant",ROOT.kFALSE).getSize()) pdfstring = "fitfunction%s_Norm[tagged_mass]_Range[full]_NormRange[full]"%ibin chi2s['data%s'%ibin] = frame.chiSquare(pdfstring, "h_fulldata", nparam) frame. addObject(_writeChi2( chi2s['data%s'%ibin] )) drawPdfComponents(fitFunction, frame, ROOT.kAzure, RooFit.NormRange("full"), RooFit.Range("full"), isData = True) # fitFunction.paramOn(frame, RooFit.Layout(0.62,0.86,0.89)) parList = RooArgSet (nsig, mean_rt, sigma_rt, alpha_rt1, alpha_rt2, n_rt1, n_rt2, mean_wt, sigma_wt) # parList.add(alphawt1) # parList.add(alphawt2) # parList.add(nwt1) # parList.add(nwt2) parList.add(frt) fitFunction.paramOn(frame, RooFit.Parameters(parList), RooFit.Layout(0.62,0.86,0.89)) frame.Draw() niceFrame(frame, '') frame. addObject(_writeFitStatus(r)) c1 = ROOT.TCanvas() upperPad = ROOT.TPad('upperPad' , 'upperPad' , 0., 0.35 , 1., 1. ) lowerPad = ROOT.TPad('lowerPad' , 'lowerPad' , 0., 0.0 , 1., 0.345 ) upperPad.SetBottomMargin(0.012) lowerPad.SetTopMargin(0) lowerPad.SetBottomMargin(0.2) upperPad.Draw(); lowerPad.Draw() upperPad.cd() frame.Draw() if not args.year=='test': writeCMS(frame, args.year, [ q2binning[ibin], q2binning[ibin+1] ], 0) frame.Draw() ## add plot of pulls lowerPad.cd() hpull = frame.pullHist("h_fulldata", pdfstring) frame2 = tagged_mass.frame(RooFit.Range("full"), RooFit.Title('')) frame2.addPlotable(hpull,"P") niceFrameLowerPad(frame2, 'pull') frame2.Draw() line = ROOT.TLine(5.0,1,5.6,1) line.SetLineColor(ROOT.kGreen+3) line.Draw() for ilog in [True,False]: upperPad.SetLogy(ilog) c1.SaveAs('fit_results_mass/save_fit_data_%s_%s_LMNR_Update%s_newSigmaFRT_pars_Jpsi.pdf'%(ibin, args.year, '_logScale'*ilog)) out_f.cd() r.Write('results_data_%s'%(ibin)) params = fitFunction.getParameters(RooArgSet(tagged_mass)) out_w.saveSnapshot("reference_fit_data_%s"%(ibin),params,ROOT.kTRUE) getattr(out_w, 'import')(fitFunction)
ws_file.Close() dataset_COMB_CORR = wsp_0.data("dataset_COMB_CORR") ws_file0 = TFile("/afs/cern.ch/user/"+prefix+"/"+user+"/eos/lhcb/user/"+prefix+"/"+user+"/WrongSign/2015/WorkSpaces/Merged_WS_Bin_0.root", "read") wsp = ws_file0.Get("wspace") ws_file0.Close() start = datetime.now() LOG_D0_IPCHI2_OWNPV = wsp.var("LOG_D0_IPCHI2_OWNPV") Dst_DTF_D0_CTAU = wsp.var("Dst_DTF_D0_CTAU") DTF_D0sPi_M = wsp.var("DTF_D0sPi_M") DTF_D0sPi_M.setMax(2020) DTF_D0sPi_M.setMin(2000) varset_small = RooArgSet("varset_small") varset_small.add(LOG_D0_IPCHI2_OWNPV) varset_small.add(Dst_DTF_D0_CTAU) varset_small.add(DTF_D0sPi_M) #Create histogram for time bin 0 dataset_RS_0 = wsp.data("dataset_RS") dataset_RS_0.SetName("dataset_RS_0") print "dataset_RS_0 extraction took "+str(datetime.now()-start)+" \n" start = datetime.now() hist_RS_0 = RooDataHist("hist_RS_0","hist_RS_0", RooArgSet(LOG_D0_IPCHI2_OWNPV), dataset_RS_0) print "RooDataHist creation took "+str(datetime.now()-start)+" \n" start = datetime.now() shape_RS_0 = RooHistPdf("shape_RS_0", "shape_RS_0", RooArgSet(LOG_D0_IPCHI2_OWNPV), hist_RS_0) print "RooHistPdf creation took "+str(datetime.now()-start)+" \n" h_0 = hist_RS_0.createHistogram("LOG_D0_IPCHI2_OWNPV", 100)
def run(self, **kwargs): from ROOT import RooArgSet __check_req_kw__("Observables", kwargs) __check_req_kw__("Pdf", kwargs) __check_req_kw__("Sigmat", kwargs) __check_req_kw__("Time", kwargs) __check_req_kw__("SigmaGen", kwargs) sigma_gen = kwargs.pop("SigmaGen") observables = kwargs.pop("Observables") obs_set = RooArgSet(*observables) pdf = kwargs.pop("Pdf") sigmat = kwargs.pop("Sigmat") time = kwargs.pop("Time") gen_obs_set = RooArgSet(*observables) # Make another ArgSet to put the fit results in result_params = RooArgSet("result_params") from P2VV.RooFitWrappers import RealVar da = RealVar("da", Observable=True, MinMax=(0.01, 1.1)) dft = RealVar("dft", Observable=True, MinMax=(0.01, 1.1)) result_params.add(da._target_()) result_params.add(dft._target_()) transform = self.transform() if transform: trans_params = transform.gen_params(gen_obs_set) self._gen_params.extend(trans_params) for p in trans_params: result_params.add(p) # Some extra numbers of interest from ROOT import RooRealVar seed = RooRealVar("seed", "random seed", 0.0) result_params.add(seed) # The dataset to store the results from ROOT import RooDataSet self._data = RooDataSet("result_data", "result_data", result_params) data_params = self._data.get() from ROOT import RooRandom import struct, os # Reset pdf parameters to initial values. Note: this does not reset the estimated errors... args = dict(NumEvents=self.options().nevents) if "ProtoData" in kwargs: args["ProtoData"] = kwargs.pop("ProtoData") spec = pdf.prepareMultiGen(obs_set, **args) while self._data.numEntries() < self.options().ntoys: # Get a good random seed, set it and store it s = struct.unpack("I", os.urandom(4))[0] RooRandom.randomGenerator().SetSeed(s) seed.setVal(s) data = pdf.generate(spec) if self.transform(): old_data = data data = self.transform()(old_data) if not data: transform.set_params(data_params) self._data.add(data_params) continue from P2VV import Dilution d_ft = Dilution.dilution_ft(data, time, t_range=2, quiet=True) d_a = Dilution.signal_dilution_dg(data, sigmat, *sigma_gen) da.setVal(d_a[0]) da.setError(d_a[1] if d_a[1] != None else 0.0) dft.setVal(d_ft[0]) dft.setError(d_ft[1] if d_ft[1] != None else 0.0) if transform: transform.set_params(data_params) self._data.add(result_params) return self.data()
def doFit(ws,options): rap_bins = range(1,len(jpsi.pTRange)) pt_bins = None if options.testBin is not None: rap_bins = [int(options.testBin.split(',')[0])] pt_bins = [int(options.testBin.split(',')[1])-1] for rap_bin in rap_bins: if options.testBin is None: pt_bins = range(len(jpsi.pTRange[rap_bin])) for pt_bin in pt_bins: sigMaxMass = jpsi.polMassJpsi[rap_bin] + jpsi.nSigMass*jpsi.sigmaMassJpsi[rap_bin] sigMinMass = jpsi.polMassJpsi[rap_bin] - jpsi.nSigMass*jpsi.sigmaMassJpsi[rap_bin] sbHighMass = jpsi.polMassJpsi[rap_bin] + jpsi.nSigBkgHigh*jpsi.sigmaMassJpsi[rap_bin] sbLowMass = jpsi.polMassJpsi[rap_bin] - jpsi.nSigBkgLow*jpsi.sigmaMassJpsi[rap_bin] jPsiMass = ws.var('JpsiMass') jPsicTau = ws.var('Jpsict') jPsiMass.setRange('mlfit_prompt',2.7,3.5) jPsiMass.setRange('mlfit_nonPrompt',2.7,3.5) jPsiMass.setRange('NormalizationRangeFormlfit_prompt',2.7,3.5) jPsiMass.setRange('NormalizationRangeFormlfit_nonPrompt',2.7,3.5) jPsicTau.setRange('mlfit_signal',-1,2.5) jPsicTau.setRange('mlfit_leftMassSideBand',-1,2.5) jPsicTau.setRange('mlfit_rightMassSideBand',-1,2.5) jPsicTau.setRange('NormalizationRangeFormlfit_signal',-1,2.5) jPsicTau.setRange('NormalizationRangeFormlfit_leftMassSideBand',-1,2.5) jPsicTau.setRange('NormalizationRangeFormlfit_rightMassSideBand',-1,2.5) #jPsicTau.setRange('NormalizationRangeFormlfit_promptSignal',-1,.1) #jPsicTau.setRange('NormalizationRangeFormlfit_nonPromptSignal',.1,2.5) #jPsicTau.setRange('NormalizationRangeFormlfit_leftMassSideBand',-1,2.5) #jPsicTau.setRange('NormalizationRangeFormlfit_rightMassSideBand',-1,2.5) #jPsicTau.setRange('mlfit_promptSignal',-1,.1) #jPsicTau.setRange('mlfit_nonPromptSignal',.1,2.5) #jPsicTau.setRange('mlfit_leftMassSideBand',-1,2.5) #jPsicTau.setRange('mlfit_rightMassSideBand',-1,2.5) #reset parameters ws.var('CBn').setVal(.5) ws.var('CBalpha').setVal(.5) ws.var('CBmass').setVal(3.1) ws.var('CBsigma').setVal(.02) ws.var('bkgLambda').setVal(0) ws.var('bkgTauSSDL').setVal(.5) #ws.var('bkgTauFDL').setVal(.5) ws.var('bkgTauDSDL').setVal(.5) ws.var('fBkgSSDL').setVal(.5) ws.var('fBkgLR').setVal(.5) ws.var('bkgTauSSDR').setVal(.5) #ws.var('bkgTauFDR').setVal(.5) ws.var('bkgTauDSDR').setVal(.5) ws.var('fBkgSSDR').setVal(.5) #ws.var('fBkgFDR').setVal(.25) #ws.var('nPrompt').setVal(5000) #ws.var('nNonPrompt').setVal(500) #ws.var('nBackground').setVal(100) #ws.var('nBackgroundL').setVal(50) #ws.var('nBackgroundR').setVal(50) ws.var('nonPromptTau').setVal(.5) ws.var('promptMean').setVal(0) ws.var('ctResolution').setVal(1) if options.fixBfrac: cutStringM1 = '('+jPsiMass.GetName()+' > '+str(sigMinMass)+' && '+jPsiMass.GetName()+' < '+str(sigMaxMass)+')' data2 = ws.data('data_rap'+str(rap_bin)+'_pt'+str(pt_bin+1)) dataSizeBfrac1 = data2.numEntries() print dataSizeBfrac1 bfracVars = RooArgSet(jPsiMass) bfracData = data2.reduce(ROOT.RooFit.SelectVars(bfracVars), ROOT.RooFit.Cut(cutStringM1), ROOT.RooFit.Name('data_for_normalizing_bfrac'), ROOT.RooFit.Title('data_for_normalizing_bfrac')) print rap_bin print pt_bin bfrac = jpsi.Bfrac[rap_bin-1][pt_bin] print bfrac dataSizeBfrac = bfracData.numEntries() factPrompt = 1-bfrac dataSizePrompt = dataSizeBfrac*factPrompt dataSizeNonPrompt = dataSizeBfrac*bfrac print factPrompt print dataSizeBfrac print dataSizePrompt print dataSizeNonPrompt ws.var('nPromptSignal').setVal(dataSizePrompt) ws.var('nNonPromptSignal').setVal(dataSizeNonPrompt) ws.var('nPromptSignal').setConstant() ws.var('nNonPromptSignal').setConstant() LPdf = ws.pdf('LPdf') MPdf = ws.pdf('MPdf') data = ws.data('data_rap'+str(rap_bin)+'_pt'+str(pt_bin+1)) NLLs = RooArgSet() MassNLL = MPdf.createNLL(data, ROOT.RooFit.Range('mlfit'), ROOT.RooFit.SplitRange(True), ROOT.RooFit.ConditionalObservables(RooArgSet(ws.var('JpsictErr'))), ROOT.RooFit.NumCPU(2)) CTauNLL = LPdf.createNLL(data, ROOT.RooFit.Range('mlfit'), ROOT.RooFit.SplitRange(True), ROOT.RooFit.ConditionalObservables(RooArgSet(ws.var('JpsictErr'))), ROOT.RooFit.NumCPU(2)) NLLs.add(MassNLL) NLLs.add(CTauNLL) simNLL = RooAddition('add','add',NLLs) minuit = RooMinuit(simNLL) minuit.setStrategy(2) minuit.setPrintEvalErrors(-1) if options.do_fit: minuit.simplex() minuit.migrad() minuit.migrad() minuit.hesse() fitresult = minuit.save('polfitresult_rap'+str(rap_bin)+'_pt'+str(pt_bin+1)) getattr(ws,'import')(fitresult) ws.saveSnapshot('snapshot_rap'+str(rap_bin)+'_pt'+str(pt_bin+1),ws.allVars()) fitresult.Print()
def latexfitresults(filename, regionList, sampleList, dataname='obsData', showSum=False, doAsym=True, blinded=False, splitBins=False): """ Calculate before/after-fit yields in all channels given @param filename The filename containing afterFit workspace @param regionList A list of regions to be considered @param sampleList A list of samples to be considered @param dataname The name of dataset (default='obsData') @param showSum Calculates sum of all regions if set to true (default=False) @param doAsym Calculates asymmetric errors taken from MINOS (default=True) @param blinded Observed event count will not be shown if set to True (default=False) @param splitBins Calculates bin-by-bin yields for all regions if set to True (default=False) """ """ pick up workspace from file """ workspacename = 'w' w = Util.GetWorkspaceFromFile(filename, 'w') if w == None: print "ERROR : Cannot open workspace : ", workspacename sys.exit(1) """ pick up after-fit RooExpandedFitResult from workspace """ resultAfterFit = w.obj('RooExpandedFitResult_afterFit') if resultAfterFit == None: print "ERROR : Cannot open fit result after fit RooExpandedFitResult_afterFit" sys.exit(1) """ pick up before-fit RooExpandedFitResult from workspace """ resultBeforeFit = w.obj('RooExpandedFitResult_beforeFit') if resultBeforeFit == None: print "ERROR : Cannot open fit result before fit RooExpandedFitResult_beforeFit" sys.exit(1) """ pick up dataset from workspace """ data_set = w.data(dataname) if data_set == None: print "ERROR : Cannot open dataset : ", "data_set" + suffix sys.exit(1) """ pick up channel category (RooCategory) from workspace """ regionCat = w.obj("channelCat") if not blinded: data_set.table(regionCat).Print("v") """ find full (long) name list of regions (i.e. short=SR3J, long=SR3J_meffInc30_JVF25pt50) """ regionFullNameList = [ Util.GetFullRegionName(regionCat, region) for region in regionList ] """ load afterFit workspace snapshot (=set all parameters to values after fit) """ snapshot = 'snapshot_paramsVals_RooExpandedFitResult_afterFit' w.loadSnapshot(snapshot) if not w.loadSnapshot(snapshot): print "ERROR : Cannot load snapshot : ", snapshot sys.exit(1) """ define set, for all names/yields to be saved in """ tablenumbers = {} """ if showSum=True define names for sum of all regions and add to regionList """ sumName = "" for index, reg in enumerate(regionList): if index == 0: sumName = reg else: sumName = sumName + " + " + reg regionListWithSum = list(regionList) if showSum: regionListWithSum.append(sumName) tablenumbers['names'] = regionListWithSum """ make a list of channelCat calls for every region """ regionCatList = [ 'channelCat==channelCat::' + region.Data() for region in regionFullNameList ] """ retrieve number of observed (=data) events per region """ regionDatasetList = [ data_set.reduce(regioncat) for regioncat in regionCatList ] for index, data in enumerate(regionDatasetList): data.SetName("data_" + regionList[index]) data.SetTitle("data_" + regionList[index]) nobs_regionList = [data.sumEntries() for data in regionDatasetList] """ if showSum=True calculate the total number of observed events in all regions """ sumNobs = 0. for nobs in nobs_regionList: sumNobs += nobs if showSum: nobs_regionList.append(sumNobs) tablenumbers['nobs'] = nobs_regionList """ FROM HERE ON OUT WE CALCULATE THE FITTED NUMBER OF EVENTS __AFTER__ THE FIT """ """ get a list of pdf's and variables per region """ pdfinRegionList = [Util.GetRegionPdf(w, region) for region in regionList] varinRegionList = [Util.GetRegionVar(w, region) for region in regionList] """ if splitBins=True get the list of Nbins, binMax and binMin; make a list of new region names for each bin """ varNbinsInRegionList = [] varBinLowInRegionList = [] varBinHighInRegionList = [] rangeNameBinsInRegionList = [] if splitBins: varNbinsInRegionList = [ Util.GetRegionVar(w, region).getBinning().numBins() for region in regionList ] varBinLowInRegionList = [[ Util.GetRegionVar(w, region).getBinning( (region + "binning")).binLow(ibin) for ibin in range(0, varNbinsInRegionList[idx]) ] for idx, region in enumerate(regionList)] varBinHighInRegionList = [[ Util.GetRegionVar(w, region).getBinning( (region + "binning")).binHigh(ibin) for ibin in range(0, varNbinsInRegionList[idx]) ] for idx, region in enumerate(regionList)] rangeNameBinsInRegionList = [[ regionList[idx] + "_bin" + str(ibin) for ibin in range(0, varNbinsInRegionList[idx]) ] for idx, region in enumerate(regionList)] for index, region in enumerate(regionList): if varNbinsInRegionList[index] == 1: print " \n YieldsTable.py: WARNING: you have called -P (= per-bin yields) but this region ", region, " has only 1 bin \n" """ if splitBins=True reshuffle the regionName list; each region name is followed by names of each bin (i.e. regionNameList=['SR3J','SR3J_bin1','SR3j_bin2','SR4J','SR4J_bin1']) """ regionListWithBins = [] if splitBins: for index, region in enumerate(regionList): regionListWithBins.append(region) for ibin in range(0, varNbinsInRegionList[index]): regionListWithBins.append( rangeNameBinsInRegionList[index][ibin]) tablenumbers['names'] = regionListWithBins """ calculate number of observed(=data) events per bin """ nobs_regionListWithBins = [] if splitBins: binFuncInRegionList = [ RooBinningCategory("bin_" + region, "bin_" + region, varinRegionList[index]) for index, region in enumerate(regionList) ] for index, data in enumerate(regionDatasetList): data.addColumn(binFuncInRegionList[index]) if not blinded: data.table(binFuncInRegionList[index]).Print("v") nobs_regionListWithBins.append(data.sumEntries()) for ibin in range(0, varNbinsInRegionList[index]): nobs_regionListWithBins.append( (data.reduce(binFuncInRegionList[index].GetName() + "==" + binFuncInRegionList[index].GetName() + "::" + varinRegionList[index].GetName() + "_bin" + str(ibin))).sumEntries()) tablenumbers['nobs'] = nobs_regionListWithBins """ if blinded=True, set all numbers of observed events to -1 """ if blinded: for index, nobs in enumerate(nobs_regionListWithBins): nobs_regionListWithBins[index] = -1 tablenumbers['nobs'] = nobs_regionListWithBins """ get a list of RooRealSumPdf per region (RooRealSumPdf is the top-pdf per region containing all samples) """ rrspdfinRegionList = [] for index, pdf in enumerate(pdfinRegionList): prodList = pdf.pdfList() foundRRS = 0 for idx in range(prodList.getSize()): if prodList[idx].InheritsFrom("RooRealSumPdf"): rrspdfInt = prodList[idx].createIntegral( RooArgSet(varinRegionList[index])) rrspdfinRegionList.append(rrspdfInt) if splitBins: origMin = varinRegionList[index].getMin() origMax = varinRegionList[index].getMax() for ibin in range(0, varNbinsInRegionList[index]): rangeName = rangeNameBinsInRegionList[index][ibin] varinRegionList[index].setRange( rangeName, varBinLowInRegionList[index][ibin], varBinHighInRegionList[index][ibin]) rrspdfInt = prodList[idx].createIntegral( RooArgSet(varinRegionList[index]), rangeName) rrspdfinRegionList.append(rrspdfInt) varinRegionList[index].setRange(origMin, origMax) foundRRS += 1 if foundRRS > 1 or foundRRS == 0: print " \n\n WARNING: ", pdf.GetName( ), " has ", foundRRS, " instances of RooRealSumPdf" print pdf.GetName(), " component list:", prodList.Print("v") """ calculate total pdf number of fitted events and error """ nFittedInRegionList = [ pdf.getVal() for index, pdf in enumerate(rrspdfinRegionList) ] pdfFittedErrInRegionList = [ Util.GetPropagatedError(pdf, resultAfterFit, doAsym) for pdf in rrspdfinRegionList ] """ if showSum=True calculate the total number of fitted events in all regions """ if showSum: pdfInAllRegions = RooArgSet() for index, pdf in enumerate(rrspdfinRegionList): pdfInAllRegions.add(pdf) pdfSumInAllRegions = RooAddition("pdf_AllRegions_AFTER", "pdf_AllRegions_AFTER", RooArgList(pdfInAllRegions)) nPdfSumVal = pdfSumInAllRegions.getVal() nPdfSumError = Util.GetPropagatedError(pdfSumInAllRegions, resultAfterFit, doAsym) nFittedInRegionList.append(nPdfSumVal) pdfFittedErrInRegionList.append(nPdfSumError) tablenumbers['TOTAL_FITTED_bkg_events'] = nFittedInRegionList tablenumbers['TOTAL_FITTED_bkg_events_err'] = pdfFittedErrInRegionList """ calculate the fitted number of events and propagated error for each requested sample, by splitting off each sample pdf """ for isam, sample in enumerate(sampleList): sampleName = getName(sample) nSampleInRegionVal = [] nSampleInRegionError = [] sampleInAllRegions = RooArgSet() for ireg, region in enumerate(regionList): sampleInRegion = getPdfInRegions(w, sample, region) sampleInRegionVal = 0. sampleInRegionError = 0. if not sampleInRegion == None: sampleInRegionVal = sampleInRegion.getVal() sampleInRegionError = Util.GetPropagatedError( sampleInRegion, resultAfterFit, doAsym) sampleInAllRegions.add(sampleInRegion) else: print " \n YieldsTable.py: WARNING: sample =", sampleName, " non-existent (empty) in region =", region, "\n" nSampleInRegionVal.append(sampleInRegionVal) nSampleInRegionError.append(sampleInRegionError) """ if splitBins=True calculate numbers of fitted events plus error per bin """ if splitBins: origMin = varinRegionList[ireg].getMin() origMax = varinRegionList[ireg].getMax() for ibin in range(0, varNbinsInRegionList[ireg]): rangeName = rangeNameBinsInRegionList[ireg][ibin] sampleInRegion = getPdfInRegionsWithRangeName( w, sample, region, rangeName) sampleInRegionVal = 0. sampleInRegionError = 0. if not sampleInRegion == None: varinRegionList[ireg].setRange( rangeName, varBinLowInRegionList[ireg][ibin], varBinHighInRegionList[ireg][ibin]) sampleInRegionVal = sampleInRegion.getVal() sampleInRegionError = Util.GetPropagatedError( sampleInRegion, resultAfterFit, doAsym) else: print " \n YieldsTable.py: WARNING: sample =", sampleName, " non-existent (empty) in region=", region, " bin=", ibin, " \n" nSampleInRegionVal.append(sampleInRegionVal) nSampleInRegionError.append(sampleInRegionError) varinRegionList[ireg].setRange(origMin, origMax) """ if showSum=True calculate the total number of fitted events in all regions """ if showSum: sampleSumInAllRegions = RooAddition( (sampleName + "_AllRegions_FITTED"), (sampleName + "_AllRegions_FITTED"), RooArgList(sampleInAllRegions)) nSampleSumVal = sampleSumInAllRegions.getVal() nSampleSumError = Util.GetPropagatedError(sampleSumInAllRegions, resultAfterFit, doAsym) nSampleInRegionVal.append(nSampleSumVal) nSampleInRegionError.append(nSampleSumError) tablenumbers['Fitted_events_' + sampleName] = nSampleInRegionVal tablenumbers['Fitted_err_' + sampleName] = nSampleInRegionError print "\n starting BEFORE-FIT calculations \n" """ FROM HERE ON OUT WE CALCULATE THE EXPECTED NUMBER OF EVENTS __BEFORRE__ THE FIT """ """ load beforeFit workspace snapshot (=set all parameters to values before fit) """ w.loadSnapshot('snapshot_paramsVals_RooExpandedFitResult_beforeFit') """ check if any of the initial scaling factors is != 1 """ _result = w.obj('RooExpandedFitResult_beforeFit') _muFacs = _result.floatParsFinal() for i in range(len(_muFacs)): if "mu_" in _muFacs[i].GetName() and _muFacs[i].getVal() != 1.0: print " \n WARNING: scaling factor %s != 1.0 (%g) expected MC yield WILL BE WRONG!" % ( _muFacs[i].GetName(), _muFacs[i].getVal()) """ get a list of pdf's and variables per region """ pdfinRegionList = [Util.GetRegionPdf(w, region) for region in regionList] varinRegionList = [Util.GetRegionVar(w, region) for region in regionList] """ get a list of RooRealSumPdf per region (RooRealSumPdf is the top-pdf per region containing all samples) """ rrspdfinRegionList = [] for index, pdf in enumerate(pdfinRegionList): prodList = pdf.pdfList() foundRRS = 0 for idx in range(prodList.getSize()): if prodList[idx].InheritsFrom("RooRealSumPdf"): rrspdfInt = prodList[idx].createIntegral( RooArgSet(varinRegionList[index])) rrspdfinRegionList.append(rrspdfInt) if splitBins: origMin = varinRegionList[index].getMin() origMax = varinRegionList[index].getMax() for ibin in range(0, varNbinsInRegionList[index]): rangeName = rangeNameBinsInRegionList[index][ibin] varinRegionList[index].setRange( rangeName, varBinLowInRegionList[index][ibin], varBinHighInRegionList[index][ibin]) rrspdfInt = prodList[idx].createIntegral( RooArgSet(varinRegionList[index]), rangeName) rrspdfinRegionList.append(rrspdfInt) varinRegionList[index].setRange(origMin, origMax) foundRRS += 1 if foundRRS > 1 or foundRRS == 0: print " \n\n WARNING: ", pdf.GetName( ), " has ", foundRRS, " instances of RooRealSumPdf" print pdf.GetName(), " component list:", prodList.Print("v") """ calculate total pdf number of expected events and error """ nExpInRegionList = [ pdf.getVal() for index, pdf in enumerate(rrspdfinRegionList) ] pdfExpErrInRegionList = [ Util.GetPropagatedError(pdf, resultBeforeFit, doAsym) for pdf in rrspdfinRegionList ] """ if showSum=True calculate the total number of expected events in all regions """ if showSum: pdfInAllRegions = RooArgSet() for index, pdf in enumerate(rrspdfinRegionList): pdfInAllRegions.add(pdf) pdfSumInAllRegions = RooAddition("pdf_AllRegions_BEFORE", "pdf_AllRegions_BEFORE", RooArgList(pdfInAllRegions)) nPdfSumVal = pdfSumInAllRegions.getVal() nPdfSumError = Util.GetPropagatedError(pdfSumInAllRegions, resultBeforeFit, doAsym) nExpInRegionList.append(nPdfSumVal) pdfExpErrInRegionList.append(nPdfSumError) tablenumbers['TOTAL_MC_EXP_BKG_events'] = nExpInRegionList tablenumbers['TOTAL_MC_EXP_BKG_err'] = pdfExpErrInRegionList """ calculate the fitted number of events and propagated error for each requested sample, by splitting off each sample pdf """ for isam, sample in enumerate(sampleList): sampleName = getName(sample) nMCSampleInRegionVal = [] nMCSampleInRegionError = [] MCSampleInAllRegions = RooArgSet() for ireg, region in enumerate(regionList): MCSampleInRegion = getPdfInRegions(w, sample, region) MCSampleInRegionVal = 0. MCSampleInRegionError = 0. if not MCSampleInRegion == None: MCSampleInRegionVal = MCSampleInRegion.getVal() MCSampleInRegionError = Util.GetPropagatedError( MCSampleInRegion, resultBeforeFit, doAsym) MCSampleInAllRegions.add(MCSampleInRegion) else: print " \n WARNING: sample=", sampleName, " non-existent (empty) in region=", region nMCSampleInRegionVal.append(MCSampleInRegionVal) nMCSampleInRegionError.append(MCSampleInRegionError) """ if splitBins=True calculate numbers of fitted events plus error per bin """ if splitBins: origMin = varinRegionList[ireg].getMin() origMax = varinRegionList[ireg].getMax() for ibin in range(0, varNbinsInRegionList[ireg]): rangeName = rangeNameBinsInRegionList[ireg][ibin] MCSampleInRegion = getPdfInRegionsWithRangeName( w, sample, region, rangeName) MCSampleInRegionVal = 0. MCSampleInRegionError = 0. if not MCSampleInRegion == None: varinRegionList[ireg].setRange( rangeName, varBinLowInRegionList[ireg][ibin], varBinHighInRegionList[ireg][ibin]) MCSampleInRegionVal = MCSampleInRegion.getVal() MCSampleInRegionError = Util.GetPropagatedError( MCSampleInRegion, resultBeforeFit, doAsym) else: print " \n YieldsTable.py: WARNING: sample =", sampleName, " non-existent (empty) in region=", region, " bin=", ibin, " \n" nMCSampleInRegionVal.append(MCSampleInRegionVal) nMCSampleInRegionError.append(MCSampleInRegionError) varinRegionList[ireg].setRange(origMin, origMax) """ if showSum=True calculate the total number of fitted events in all regions """ if showSum: MCSampleSumInAllRegions = RooAddition( (sampleName + "_AllRegions_MC"), (sampleName + "_AllRegions_MC"), RooArgList(MCSampleInAllRegions)) nMCSampleSumVal = MCSampleSumInAllRegions.getVal() nMCSampleSumError = Util.GetPropagatedError( MCSampleSumInAllRegions, resultBeforeFit, doAsym) nMCSampleInRegionVal.append(nMCSampleSumVal) nMCSampleInRegionError.append(nMCSampleSumError) tablenumbers['MC_exp_events_' + sampleName] = nMCSampleInRegionVal tablenumbers['MC_exp_err_' + sampleName] = nMCSampleInRegionError """ sort the tablenumbers set """ map_listofkeys = tablenumbers.keys() map_listofkeys.sort() """ print the sorted tablenumbers set """ for name in map_listofkeys: if tablenumbers.has_key(name): print name, ": ", tablenumbers[name] return tablenumbers
def makeRooDataSet(type,infile_name,outfile_name,tree_name,nevents): """ Make RooDataSets from TTrees""" inputfile = TFile.Open(infile_name,"READ") print "Importing tree" tree = TTree() inputfile.GetObject(tree_name, tree) #get the tree from the data file #define variables for the RooDataSet m_mumu = RooRealVar("m_mumu", "m_mumu", 0.0, 4.0) y_mumu = RooRealVar("y_mumu", "y_mumu", 0.0, 2.0 ) pt_mumu = RooRealVar("pt_mumu", "pt_mumu", 0.0, 260.0) eta_gamma = RooRealVar("eta_gamma","eta_gamma",-3.5, 3.5) pt_gamma = RooRealVar("pt_gamma", "pt_gamma", 0.0, 100.0) m_gamma = RooRealVar("m_gamma", "m_gamma", -0.1,0.1) m_chi_rf1S = RooRealVar("m_chi_rf1S", "m_chi_rf1S", 0.0, 7.0) m_chi_rf2S = RooRealVar("m_chi_rf2S", "m_chi_rf2S", -1.0, 1.0) Qvalue = RooRealVar("Qvalue","Q", -15., 15.) ctpv = RooRealVar("ctpv","ctpv", -1.0, 3.5) ctpv_error = RooRealVar("ctpv_err","ctpv_err", -1.0, 1.0) pi0_abs_mass = RooRealVar("pi0_abs_mass","pi0_abs_mass", 0.0, 2.2) psi1S_nsigma = RooRealVar("psi1S_nsigma","psi1S_nsigma",0.0,1.0) psi2S_nsigma = RooRealVar("psi2S_nsigma","psi2S_nsigma",0.0,1.0) psi3S_nsigma = RooRealVar("psi3S_nsigma","psi3S_nsigma",0.0,1.0) rho_conv = RooRealVar("rho_conv", "rho_conv", 0.0, 70.0) dz = RooRealVar("dz","dz", -1.0, 1.0) probFit1S = RooRealVar('probFit1S','probFit1S',0,1) probFit2S = RooRealVar('probFit2S','probFit2S',0,1) probFit3S = RooRealVar('probFit3S','probFit3S',0,1) dataArgSet = RooArgSet(m_mumu, y_mumu, pt_mumu, eta_gamma, pt_gamma, m_gamma, m_chi_rf1S) dataArgSet.add( m_chi_rf2S ) dataArgSet.add( Qvalue ) dataArgSet.add( ctpv ) dataArgSet.add( ctpv_error ) dataArgSet.add( pi0_abs_mass ) dataArgSet.add( psi1S_nsigma ) dataArgSet.add( psi2S_nsigma ) dataArgSet.add( psi3S_nsigma ) dataArgSet.add( rho_conv ) dataArgSet.add( dz ) dataArgSet.add( probFit1S) dataArgSet.add( probFit2S) dataArgSet.add( probFit3S) print "Creating DataSet" dataSet = RooDataSet("chicds","Chic RooDataSet", dataArgSet) entries = tree.GetEntries() print entries if nevents is not 0: entries = nevents for ientry in range(0,entries): tree.GetEntry(ientry) # unfort ntuples are slightly different for chic and chib if applyscale: if usekinfit : spatial = tree.rf3S_photon_p4.Vect() #spatial = tree.photon_p4.Vect() spatial *= (1/escale) corr_photon_p4=TLorentzVector() #corr_photon_p4.SetVectM(spatial,tree.rf1S_photon_p4.M()) corr_photon_p4.SetVectM(spatial,0) corr_chi_p4 = tree.rf3S_dimuon_p4 + corr_photon_p4 else: spatial = tree.photon_p4.Vect() spatial *= (1/escale) corr_photon_p4=TLorentzVector() corr_photon_p4.SetVectM(spatial,tree.photon_p4.M()) corr_chi_p4 = tree.dimuon_p4 + corr_photon_p4 else : corr_chi_p4 = tree.chi_p4 if type == 'chic': m_mumu.setVal(tree.dimuon_p4.M()) y_mumu.setVal(tree.dimuon_p4.Rapidity()) pt_mumu.setVal(tree.dimuon_p4.Pt()) eta_gamma.setVal(tree.photon_p4.Eta()) pt_gamma.setVal(tree.photon_p4.Pt()) m_gamma.setVal(tree.photon_p4.M()) m_chi_rf1S.setVal(tree.rf1S_chi_p4.M()) m_chi_rf2S.setVal(tree.rf2S_chi_p4.M()) if usekinfit : Qvalue.setVal(corr_chi_p4.M()) else: Qvalue.setVal((corr_chi_p4).M() - tree.dimuon_p4.M()) #Qvalue.setVal((tree.chi_p4).M()**2 - tree.dimuon_p4.M()**2) psi1S_nsigma.setVal(tree.psi1S_nsigma) psi2S_nsigma.setVal(tree.psi2S_nsigma) psi3S_nsigma.setVal(0) elif type == 'chib': m_mumu.setVal(tree.dimuon_p4.M()) y_mumu.setVal(tree.dimuon_p4.Rapidity()) pt_mumu.setVal(tree.dimuon_p4.Pt()) eta_gamma.setVal(tree.photon_p4.Eta()) pt_gamma.setVal(tree.photon_p4.Pt()) m_chi_rf1S.setVal(tree.rf1S_chi_p4.M()) m_chi_rf2S.setVal(tree.rf2S_chi_p4.M()) if usekinfit : Qvalue.setVal(corr_chi_p4.M()) #if usekinfit : Qvalue.setVal(tree.rf3S_chi_p4.M()) #uncorrected else: Qvalue.setVal(corr_chi_p4.M() - tree.dimuon_p4.M()) psi1S_nsigma.setVal(tree.Y1S_nsigma) psi2S_nsigma.setVal(tree.Y2S_nsigma) psi3S_nsigma.setVal(tree.Y3S_nsigma) ctpv.setVal(tree.ctpv) ctpv_error.setVal(tree.ctpv_error) pi0_abs_mass.setVal(tree.pi0_abs_mass) rho_conv.setVal(tree.conv_vertex) dz.setVal(tree.dz) probFit1S.setVal(tree.probFit1S) probFit2S.setVal(tree.probFit2S) probFit3S.setVal(tree.probFit3S) if selectchi1: if ( tree.chic_pdgId == 20443): dataSet.add(dataArgSet) else : dataSet.add(dataArgSet) outfile = TFile(outfile_name,'recreate') dataSet.Write()
def latexfitresults(filename,regionList,sampleList,exactRegionNames=False,dataname='obsData',showSum=False, doAsym=True, blinded=False): workspacename = 'w' w = Util.GetWorkspaceFromFile(filename,'w') if w==None: print "ERROR : Cannot open workspace : ", workspacename sys.exit(1) resultAfterFit = w.obj('RooExpandedFitResult_afterFit') if resultAfterFit==None: print "ERROR : Cannot open fit result after fit RooExpandedFitResult_afterFit" sys.exit(1) resultBeforeFit = w.obj('RooExpandedFitResult_beforeFit') if resultBeforeFit==None: print "ERROR : Cannot open fit result before fit RooExpandedFitResult_beforeFit" sys.exit(1) data_set = w.data(dataname) if data_set==None: print "ERROR : Cannot open dataset : ", "data_set"+suffix sys.exit(1) regionCat = w.obj("channelCat") data_set.table(regionCat).Print("v"); regionFullNameList = [ Util.GetFullRegionName(regionCat, region) for region in regionList] print regionFullNameList ###### snapshot = 'snapshot_paramsVals_RooExpandedFitResult_afterFit' w.loadSnapshot(snapshot) if not w.loadSnapshot(snapshot): print "ERROR : Cannot load snapshot : ", snapshot sys.exit(1) tablenumbers = {} # SUM ALL REGIONS sumName = "" for index, reg in enumerate(regionList): if index == 0: sumName = reg else: sumName = sumName + " + " + reg regionListWithSum = list(regionList) if showSum: regionListWithSum.append(sumName) tablenumbers['names'] = regionListWithSum regionCatList = [ 'channelCat==channelCat::' +region.Data() for region in regionFullNameList] regionDatasetList = [data_set.reduce(regioncat) for regioncat in regionCatList] for index, data in enumerate(regionDatasetList): data.SetName("data_" + regionList[index]) data.SetTitle("data_" + regionList[index]) nobs_regionList = [ data.sumEntries() for data in regionDatasetList] #SUM sumNobs = 0. for nobs in nobs_regionList: sumNobs += nobs ## print " \n XXX nobs = ", nobs, " sumNobs = ", sumNobs if showSum: nobs_regionList.append(sumNobs) tablenumbers['nobs'] = nobs_regionList ###### ###### ###### FROM HERE ON OUT WE CALCULATE THE FITTED NUMBER OF EVENTS __AFTER__ THE FIT ###### ###### # total pdf, not splitting in components pdfinRegionList = [ Util.GetRegionPdf(w, region) for region in regionList] varinRegionList = [ Util.GetRegionVar(w, region) for region in regionList] rrspdfinRegionList = [] for index,pdf in enumerate(pdfinRegionList): # pdf.Print("t") prodList = pdf.pdfList() foundRRS = 0 for idx in range(prodList.getSize()): # if "BG" in prodList[idx].GetName(): # prodList[idx].Print("t") if prodList[idx].InheritsFrom("RooRealSumPdf"): rrspdfInt = prodList[idx].createIntegral(RooArgSet(varinRegionList[index])); rrspdfinRegionList.append(rrspdfInt) foundRRS += 1 if foundRRS >1 or foundRRS==0: print " \n\n WARNING: ", pdf.GetName(), " has ", foundRRS, " instances of RooRealSumPdf" print pdf.GetName(), " component list:", prodList.Print("v") nFittedInRegionList = [ pdf.getVal() for index, pdf in enumerate(rrspdfinRegionList)] pdfFittedErrInRegionList = [ Util.GetPropagatedError(pdf, resultAfterFit, doAsym) for pdf in rrspdfinRegionList] if showSum: pdfInAllRegions = RooArgSet() for index, pdf in enumerate(rrspdfinRegionList): pdfInAllRegions.add(pdf) pdfSumInAllRegions = RooAddition( "pdf_AllRegions_AFTER", "pdf_AllRegions_AFTER", RooArgList(pdfInAllRegions)) pdfSumInAllRegions.Print() nPdfSumVal = pdfSumInAllRegions.getVal() nPdfSumError = Util.GetPropagatedError(pdfSumInAllRegions, resultAfterFit, doAsym) nFittedInRegionList.append(nPdfSumVal) pdfFittedErrInRegionList.append(nPdfSumError) tablenumbers['TOTAL_FITTED_bkg_events'] = nFittedInRegionList tablenumbers['TOTAL_FITTED_bkg_events_err'] = pdfFittedErrInRegionList if blinded: nobs_regionList = [ data.sumEntries() for data in regionDatasetList] nobs_regionList[-1] = -1 tablenumbers['nobs'] = nobs_regionList # components for isam, sample in enumerate(sampleList): sampleName=getName(sample) nSampleInRegionVal = [] nSampleInRegionError = [] sampleInAllRegions = RooArgSet() for ireg, region in enumerate(regionList): sampleInRegion=getPdfInRegions(w,sample,region) #sampleInRegion = Util.GetComponent(w,sample,region,exactRegionNames) sampleInRegionVal = 0. sampleInRegionError = 0. if not sampleInRegion==None: sampleInRegion.Print() sampleInRegionVal = sampleInRegion.getVal() sampleInRegionError = Util.GetPropagatedError(sampleInRegion, resultAfterFit, doAsym) sampleInAllRegions.add(sampleInRegion) else: print " \n YieldsTable.py: WARNING: sample =", sampleName, " non-existent (empty) in region =",region, "\n" nSampleInRegionVal.append(sampleInRegionVal) nSampleInRegionError.append(sampleInRegionError) if showSum: sampleSumInAllRegions = RooAddition( (sampleName+"_AllRegions_FITTED"), (sampleName+"_AllRegions_FITTED"), RooArgList(sampleInAllRegions)) sampleSumInAllRegions.Print() nSampleSumVal = sampleSumInAllRegions.getVal() nSampleSumError = Util.GetPropagatedError(sampleSumInAllRegions, resultAfterFit, doAsym) nSampleInRegionVal.append(nSampleSumVal) nSampleInRegionError.append(nSampleSumError) tablenumbers['Fitted_events_'+sampleName] = nSampleInRegionVal tablenumbers['Fitted_err_'+sampleName] = nSampleInRegionError print tablenumbers ###### ###### ###### FROM HERE ON OUT WE CALCULATE THE EXPECTED NUMBER OF EVENTS __BEFORE__ THE FIT ###### ###### # FROM HERE ON OUT WE CALCULATE THE EXPECTED NUMBER OF EVENTS BEFORE THE FIT w.loadSnapshot('snapshot_paramsVals_RooExpandedFitResult_beforeFit') # check if any of the initial scaling factors is != 1 _result = w.obj('RooExpandedFitResult_beforeFit') _muFacs = _result.floatParsFinal() for i in range(len(_muFacs)): if "mu_" in _muFacs[i].GetName() and _muFacs[i].getVal() != 1.0: print " \n WARNING: scaling factor %s != 1.0 (%g) expected MC yield WILL BE WRONG!" % (_muFacs[i].GetName(), _muFacs[i].getVal()) pdfinRegionList = [ Util.GetRegionPdf(w, region) for region in regionList] varinRegionList = [ Util.GetRegionVar(w, region) for region in regionList] rrspdfinRegionList = [] for index,pdf in enumerate(pdfinRegionList): prodList = pdf.pdfList() foundRRS = 0 for idx in range(prodList.getSize()): if prodList[idx].InheritsFrom("RooRealSumPdf"): prodList[idx].Print() rrspdfInt = prodList[idx].createIntegral(RooArgSet(varinRegionList[index])) rrspdfinRegionList.append(rrspdfInt) foundRRS += 1 if foundRRS >1 or foundRRS==0: print " \n\n WARNING: ", pdf.GetName(), " has ", foundRRS, " instances of RooRealSumPdf" print pdf.GetName(), " component list:", prodList.Print("v") nExpInRegionList = [ pdf.getVal() for index, pdf in enumerate(rrspdfinRegionList)] pdfExpErrInRegionList = [ Util.GetPropagatedError(pdf, resultBeforeFit, doAsym) for pdf in rrspdfinRegionList] if showSum: pdfInAllRegions = RooArgSet() for index, pdf in enumerate(rrspdfinRegionList): pdfInAllRegions.add(pdf) pdfSumInAllRegions = RooAddition( "pdf_AllRegions_BEFORE", "pdf_AllRegions_BEFORE", RooArgList(pdfInAllRegions)) nPdfSumVal = pdfSumInAllRegions.getVal() nPdfSumError = Util.GetPropagatedError(pdfSumInAllRegions, resultBeforeFit, doAsym) nExpInRegionList.append(nPdfSumVal) pdfExpErrInRegionList.append(nPdfSumError) tablenumbers['TOTAL_MC_EXP_BKG_events'] = nExpInRegionList tablenumbers['TOTAL_MC_EXP_BKG_err'] = pdfExpErrInRegionList for isam, sample in enumerate(sampleList): sampleName=getName(sample) nMCSampleInRegionVal = [] nMCSampleInRegionError = [] MCSampleInAllRegions = RooArgSet() for ireg, region in enumerate(regionList): MCSampleInRegion = getPdfInRegions(w,sample,region) #MCSampleInRegion = Util.GetComponent(w,sample,region,exactRegionNames) MCSampleInRegionVal = 0. MCSampleInRegionError = 0. if not MCSampleInRegion==None: MCSampleInRegionVal = MCSampleInRegion.getVal() MCSampleInRegionError = Util.GetPropagatedError(MCSampleInRegion, resultBeforeFit, doAsym) MCSampleInAllRegions.add(MCSampleInRegion) else: print " \n WARNING: sample=", sampleName, " non-existent (empty) in region=",region nMCSampleInRegionVal.append(MCSampleInRegionVal) nMCSampleInRegionError.append(MCSampleInRegionError) if showSum: MCSampleSumInAllRegions = RooAddition( (sampleName+"_AllRegions_MC"), (sampleName+"_AllRegions_MC"), RooArgList(MCSampleInAllRegions)) nMCSampleSumVal = MCSampleSumInAllRegions.getVal() nMCSampleSumError = Util.GetPropagatedError(MCSampleSumInAllRegions, resultBeforeFit, doAsym) nMCSampleInRegionVal.append(nMCSampleSumVal) nMCSampleInRegionError.append(nMCSampleSumError) tablenumbers['MC_exp_events_'+sampleName] = nMCSampleInRegionVal tablenumbers['MC_exp_err_'+sampleName] = nMCSampleInRegionError # sorted(tablenumbers, key=lambda sample: sample[1]) # sort by age map_listofkeys = tablenumbers.keys() map_listofkeys.sort() for name in map_listofkeys: if tablenumbers.has_key(name) : print name, ": ", tablenumbers[name] ### return tablenumbers
def doFit(ws, options): rap_bins = range(1, len(jpsi.pTRange)) pt_bins = None if options.testBin is not None: rap_bins = [int(options.testBin.split(',')[0])] pt_bins = [int(options.testBin.split(',')[1]) - 1] for rap_bin in rap_bins: if options.testBin is None: pt_bins = range(len(jpsi.pTRange[rap_bin])) for pt_bin in pt_bins: sigMaxMass = jpsi.polMassJpsi[ rap_bin] + jpsi.nSigMass * jpsi.sigmaMassJpsi[rap_bin] sigMinMass = jpsi.polMassJpsi[ rap_bin] - jpsi.nSigMass * jpsi.sigmaMassJpsi[rap_bin] sbHighMass = jpsi.polMassJpsi[ rap_bin] + jpsi.nSigBkgHigh * jpsi.sigmaMassJpsi[rap_bin] sbLowMass = jpsi.polMassJpsi[ rap_bin] - jpsi.nSigBkgLow * jpsi.sigmaMassJpsi[rap_bin] jPsiMass = ws.var('JpsiMass') jPsicTau = ws.var('Jpsict') jPsiMass.setRange('mlfit_prompt', 2.7, 3.5) jPsiMass.setRange('mlfit_nonPrompt', 2.7, 3.5) jPsiMass.setRange('NormalizationRangeFormlfit_prompt', 2.7, 3.5) jPsiMass.setRange('NormalizationRangeFormlfit_nonPrompt', 2.7, 3.5) jPsicTau.setRange('mlfit_signal', -1, 2.5) jPsicTau.setRange('mlfit_leftMassSideBand', -1, 2.5) jPsicTau.setRange('mlfit_rightMassSideBand', -1, 2.5) jPsicTau.setRange('NormalizationRangeFormlfit_signal', -1, 2.5) jPsicTau.setRange('NormalizationRangeFormlfit_leftMassSideBand', -1, 2.5) jPsicTau.setRange('NormalizationRangeFormlfit_rightMassSideBand', -1, 2.5) #jPsicTau.setRange('NormalizationRangeFormlfit_promptSignal',-1,.1) #jPsicTau.setRange('NormalizationRangeFormlfit_nonPromptSignal',.1,2.5) #jPsicTau.setRange('NormalizationRangeFormlfit_leftMassSideBand',-1,2.5) #jPsicTau.setRange('NormalizationRangeFormlfit_rightMassSideBand',-1,2.5) #jPsicTau.setRange('mlfit_promptSignal',-1,.1) #jPsicTau.setRange('mlfit_nonPromptSignal',.1,2.5) #jPsicTau.setRange('mlfit_leftMassSideBand',-1,2.5) #jPsicTau.setRange('mlfit_rightMassSideBand',-1,2.5) #reset parameters ws.var('CBn').setVal(.5) ws.var('CBalpha').setVal(.5) ws.var('CBmass').setVal(3.1) ws.var('CBsigma').setVal(.02) ws.var('bkgLambda').setVal(0) ws.var('bkgTauSSDL').setVal(.5) #ws.var('bkgTauFDL').setVal(.5) ws.var('bkgTauDSDL').setVal(.5) ws.var('fBkgSSDL').setVal(.5) ws.var('fBkgLR').setVal(.5) ws.var('bkgTauSSDR').setVal(.5) #ws.var('bkgTauFDR').setVal(.5) ws.var('bkgTauDSDR').setVal(.5) ws.var('fBkgSSDR').setVal(.5) #ws.var('fBkgFDR').setVal(.25) #ws.var('nPrompt').setVal(5000) #ws.var('nNonPrompt').setVal(500) #ws.var('nBackground').setVal(100) #ws.var('nBackgroundL').setVal(50) #ws.var('nBackgroundR').setVal(50) ws.var('nonPromptTau').setVal(.5) ws.var('promptMean').setVal(0) ws.var('ctResolution').setVal(1) LPdf = ws.pdf('LPdf') MPdf = ws.pdf('MPdf') data = ws.data('data_rap' + str(rap_bin) + '_pt' + str(pt_bin + 1)) NLLs = RooArgSet() MassNLL = MPdf.createNLL( data, ROOT.RooFit.Range('mlfit'), ROOT.RooFit.SplitRange(True), ROOT.RooFit.ConditionalObservables( RooArgSet(ws.var('JpsictErr'))), ROOT.RooFit.NumCPU(2)) CTauNLL = LPdf.createNLL( data, ROOT.RooFit.Range('mlfit'), ROOT.RooFit.SplitRange(True), ROOT.RooFit.ConditionalObservables( RooArgSet(ws.var('JpsictErr'))), ROOT.RooFit.NumCPU(2)) NLLs.add(MassNLL) NLLs.add(CTauNLL) simNLL = RooAddition('add', 'add', NLLs) minuit = RooMinuit(simNLL) minuit.setStrategy(2) minuit.setPrintEvalErrors(-1) minuit.simplex() minuit.migrad() minuit.migrad() minuit.hesse() fitresult = minuit.save('polfitresult_rap' + str(rap_bin) + '_pt' + str(pt_bin + 1)) getattr(ws, 'import')(fitresult) ws.saveSnapshot( 'snapshot_rap' + str(rap_bin) + '_pt' + str(pt_bin + 1), ws.allVars())
"(Dst_DTF_P1_PY+Dst_DTF_P2_PY)", RooArgList(Dst_DTF_P1_PY, Dst_DTF_P2_PY)) Dst_DTF_D0_PZ = RooFormulaVar("Dst_DTF_D0_PZ", "Dst_DTF_D0_PZ", "(Dst_DTF_P1_PZ+Dst_DTF_P2_PZ)", RooArgList(Dst_DTF_P1_PZ, Dst_DTF_P2_PZ)) Dst_M = RooRealVar("Dst_M", "Dst_M", 1700, 2100, "MeV/c^{2}") D0_TAU = RooRealVar("D0_TAU", "D0_TAU", 0, 20 * tau, "ns") B_M = RooRealVar("B_M", "B_M", 2900, 8000, "MeV/c^{2}") B_ENDVERTEX_CHI2 = RooRealVar("B_ENDVERTEX_CHI2", "B_ENDVERTEX_CHI2", -1, 80) B_ENDVERTEX_NDOF = RooRealVar("B_ENDVERTEX_NDOF", "B_ENDVERTEX_NDOF", 1, 10) Mu_IPCHI2_OWNPV = RooRealVar("Mu_IPCHI2_OWNPV", "Mu_IPCHI2_OWNPV", 0, 8000) Mu_IP_OWNPV = RooRealVar("Mu_IP_OWNPV", "Mu_IP_OWNPV", 0, 5) Mu_PT = RooRealVar("Mu_PT", "Mu_PT", 0, 15000, "MeV/c") varset = RooArgSet(D0_M) varset.add(D0_TAU) varset.add(runNumber) varset.add(Dst_M) varset.add(D0_IPCHI2_OWNPV) varset.add(sPi_M) varset.add(D0_PE) varset.add(sPi_PE) varset.add(D0_PX) varset.add(sPi_PX) varset.add(D0_PY) varset.add(sPi_PY) varset.add(D0_PZ) varset.add(sPi_PZ) varset.add(Dst_DTF_CHI2NDOF) varset.add(Dst_DTF_D0_CTAU) varset.add(Dst_DTF_D0_M)
def makeRooDataSet(type, infile_name, outfile_name, tree_name, nevents): """ Make RooDataSets from TTrees""" inputfile = TFile.Open(infile_name, "READ") print "Importing tree" tree = TTree() inputfile.GetObject(tree_name, tree) #get the tree from the data file #define variables for the RooDataSet m_mumu = RooRealVar("m_mumu", "m_mumu", 0.0, 4.0) y_mumu = RooRealVar("y_mumu", "y_mumu", 0.0, 2.0) pt_mumu = RooRealVar("pt_mumu", "pt_mumu", 0.0, 260.0) eta_gamma = RooRealVar("eta_gamma", "eta_gamma", -3.5, 3.5) pt_gamma = RooRealVar("pt_gamma", "pt_gamma", 0.0, 100.0) m_gamma = RooRealVar("m_gamma", "m_gamma", -0.1, 0.1) m_chi_rf1S = RooRealVar("m_chi_rf1S", "m_chi_rf1S", 0.0, 7.0) m_chi_rf2S = RooRealVar("m_chi_rf2S", "m_chi_rf2S", -1.0, 1.0) Qvalue = RooRealVar("Qvalue", "Q", -15., 15.) ctpv = RooRealVar("ctpv", "ctpv", -1.0, 3.5) ctpv_error = RooRealVar("ctpv_err", "ctpv_err", -1.0, 1.0) pi0_abs_mass = RooRealVar("pi0_abs_mass", "pi0_abs_mass", 0.0, 2.2) psi1S_nsigma = RooRealVar("psi1S_nsigma", "psi1S_nsigma", 0.0, 1.0) psi2S_nsigma = RooRealVar("psi2S_nsigma", "psi2S_nsigma", 0.0, 1.0) psi3S_nsigma = RooRealVar("psi3S_nsigma", "psi3S_nsigma", 0.0, 1.0) rho_conv = RooRealVar("rho_conv", "rho_conv", 0.0, 70.0) dz = RooRealVar("dz", "dz", -1.0, 1.0) probFit1S = RooRealVar('probFit1S', 'probFit1S', 0, 1) probFit2S = RooRealVar('probFit2S', 'probFit2S', 0, 1) probFit3S = RooRealVar('probFit3S', 'probFit3S', 0, 1) dataArgSet = RooArgSet(m_mumu, y_mumu, pt_mumu, eta_gamma, pt_gamma, m_gamma, m_chi_rf1S) dataArgSet.add(m_chi_rf2S) dataArgSet.add(Qvalue) dataArgSet.add(ctpv) dataArgSet.add(ctpv_error) dataArgSet.add(pi0_abs_mass) dataArgSet.add(psi1S_nsigma) dataArgSet.add(psi2S_nsigma) dataArgSet.add(rho_conv) dataArgSet.add(dz) dataArgSet.add(probFit1S) dataArgSet.add(probFit2S) dataArgSet.add(probFit3S) print "Creating DataSet" dataSet = RooDataSet("chicds", "Chic RooDataSet", dataArgSet) entries = tree.GetEntries() print entries if nevents is not 0: entries = nevents for ientry in range(0, entries): tree.GetEntry(ientry) # unfort ntuples are slightly different for chic and chib if applyscale: if usekinfit: spatial = tree.rf1S_photon_p4.Vect() spatial *= (1 / escale) corr_photon_p4 = TLorentzVector() #corr_photon_p4.SetVectM(spatial,tree.rf1S_photon_p4.M()) corr_photon_p4.SetVectM(spatial, 0) corr_chi_p4 = tree.rf1S_dimuon_p4 + corr_photon_p4 else: spatial = tree.photon_p4.Vect() spatial *= (1 / escale) corr_photon_p4 = TLorentzVector() corr_photon_p4.SetVectM(spatial, tree.photon_p4.M()) corr_chi_p4 = tree.dimuon_p4 + corr_photon_p4 else: corr_chi_p4 = tree.chi_p4 if type == 'chic': m_mumu.setVal(tree.dimuon_p4.M()) y_mumu.setVal(tree.dimuon_p4.Rapidity()) pt_mumu.setVal(tree.dimuon_p4.Pt()) eta_gamma.setVal(tree.photon_p4.Eta()) pt_gamma.setVal(tree.photon_p4.Pt()) m_gamma.setVal(tree.photon_p4.M()) m_chi_rf1S.setVal(tree.rf1S_chi_p4.M()) m_chi_rf1S.setVal(tree.rf2S_chi_p4.M()) if usekinfit: Qvalue.setVal(corr_chi_p4.M()) else: Qvalue.setVal((corr_chi_p4).M() - tree.dimuon_p4.M()) print 'corr value ', corr_chi_p4.M() #Qvalue.setVal((tree.chi_p4).M()**2 - tree.dimuon_p4.M()**2) psi1S_nsigma.setVal(tree.psi1S_nsigma) psi2S_nsigma.setVal(tree.psi2S_nsigma) psi3S_nsigma.setVal(0) elif type == 'chib': m_mumu.setVal(tree.dimuon_p4.M()) y_mumu.setVal(tree.dimuon_p4.Rapidity()) pt_mumu.setVal(tree.dimuon_p4.Pt()) eta_gamma.setVal(tree.photon_p4.Eta()) pt_gamma.setVal(tree.photon_p4.Pt()) m_chi_rf1S.setVal(tree.rf1S_chi_p4.M()) m_chi_rf2S.setVal(tree.rf2S_chi_p4.M()) if usekinfit: Qvalue.setVal(corr_chi_p4.M()) else: Qvalue.setVal(corr_chi_p4.M() - tree.dimuon_p4.M()) psi1S_nsigma.setVal(tree.Y1S_nsigma) psi2S_nsigma.setVal(tree.Y2S_nsigma) psi3S_nsigma.setVal(tree.Y3S_nsigma) probFit1S.setVal(tree.probFit1S) probFit2S.setVal(tree.probFit2S) probFit3S.setVal(tree.probFit3S) ctpv.setVal(tree.ctpv) ctpv_error.setVal(tree.ctpv_error) pi0_abs_mass.setVal(tree.pi0_abs_mass) rho_conv.setVal(tree.conv_vertex) dz.setVal(tree.dz) if selectchi1: if (tree.chic_pdgId == 20443): dataSet.add(dataArgSet) else: dataSet.add(dataArgSet) outfile = TFile(outfile_name, 'recreate') dataSet.Write()
t_wsp = ws_file.Get("wspace") B_M = t_wsp.var("B_M") LOG_D0_IPCHI2_OWNPV = t_wsp.var("LOG_D0_IPCHI2_OWNPV") D0_TAU = t_wsp.var("D0_TAU") D0_M = t_wsp.var("D0_M") Dst_M = t_wsp.var("Dst_M") Dst_DTF_D0_CTAU = t_wsp.var("Dst_DTF_D0_CTAU") Dst_DTF_D0_M = t_wsp.var("Dst_DTF_D0_M") D0sPi_M = t_wsp.var("D0sPi_M") B_ENDVERTEX_CHI2 = t_wsp.var("B_ENDVERTEX_CHI2") DTF_D0sPi_M = t_wsp.var("DTF_D0sPi_M") Mu_PT = t_wsp.var("Mu_PT") runNumber = t_wsp.var("runNumber") varset_comb = RooArgSet("varset_comb") varset_comb.add(B_M) varset_comb.add(D0_TAU) varset_comb.add(LOG_D0_IPCHI2_OWNPV) varset_comb.add(D0sPi_M) varset_comb.add(D0_M) varset_comb.add(Mu_PT) varset_comb.add(B_ENDVERTEX_CHI2) varset_comb.add(runNumber) varset = RooArgSet("varset") varset.add(D0_M) varset.add(D0_TAU) varset.add(LOG_D0_IPCHI2_OWNPV) varset.add(DTF_D0sPi_M) varset.add(Dst_DTF_D0_CTAU) varset.add(runNumber)
obsSetIn = dsIn.get() dsIn.Print() runPeriodCat = obsSetIn.find('runPeriod') for period in runPeriods : assert runPeriodCat.isValidIndex(period) if len(runPeriods) < runPeriodCat.numTypes() : from ROOT import RooCategory runPeriodCatOut = RooCategory( runPeriodCat.GetName(), runPeriodCat.GetTitle() ) for catType in runPeriodCat : if catType.getVal() in runPeriods : runPeriodCatOut.defineType( catType.GetName(), catType.getVal() ) from ROOT import RooArgSet obsSetOut = RooArgSet(obsSetIn) obsSetOut.remove(runPeriodCat) obsSetOut.add(runPeriodCatOut) else : obsSetOut = obsSetIn cuts = '||'.join( 'runPeriod==%d' % period for period in runPeriods ) from ROOT import RooDataSet, RooFit print 'creating new data set for run periods %s' % runPeriods print 'applying cuts "%s"' % cuts dsOut = RooDataSet( dsIn.GetName(), dsIn.GetTitle(), obsSetOut, Import = dsIn, Cut = cuts, WeightVar = ( weightName, True ) ) dsOut.Print() print 'writing data set to file "%s"' % filePathOut fileOut = TFile.Open( filePathOut, 'RECREATE' ) fileOut.Add(dsOut) fileOut.Write()
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"
def fitData(fulldata, ibin, n_bkg, w): cut = cut_base + '&& (mumuMass*mumuMass > %s && mumuMass*mumuMass < %s)' % ( q2binning[ibin], q2binning[ibin + 1]) fulldata_v2 = fulldata.reduce( RooArgSet(tagged_mass, mumuMass, mumuMassE, randVar), cut) ## reduce to data-like statistics nDataEntries = fulldata_v2.sumEntries() nDesired = n_bin[ibin] / nDataEntries cut = 'rand < %f' % nDesired signaldata = fulldata_v2.reduce( RooArgSet(tagged_mass, mumuMass, mumuMassE), cut) n_realsignal = signaldata.sumEntries() nrt_mc = _getFittedVar("nRT_%s" % ibin, w) nwt_mc = _getFittedVar("nWT_%s" % ibin, w) fraction = nrt_mc / (nrt_mc + nwt_mc) ### creating RT component w.loadSnapshot("reference_fit_RT_%s" % ibin) meanrt = w.var("mean^{RT%s}" % ibin) sigmart = RooRealVar() sigmart1 = RooRealVar() sigmart2 = RooRealVar() alphart1 = RooRealVar() alphart2 = RooRealVar() nrt1 = RooRealVar() nrt2 = RooRealVar() ## double cb fast if ibin < 5: sigmart = w.var("#sigma_{CB}^{RT%s}" % ibin) alphart1 = w.var("#alpha_{1}^{RT%s}" % ibin) alphart2 = w.var("#alpha_{2}^{RT%s}" % ibin) nrt1 = w.var("n_{1}^{RT%s}" % ibin) nrt2 = w.var("n_{2}^{RT%s}" % ibin) ## double cb old else: sigmart1 = w.var("#sigma_{CBRT0}^{%s}" % ibin) sigmart2 = w.var("#sigma_{CBRT1}^{%s}" % ibin) alphart1 = w.var("#alpha_{RT0}^{%s}" % ibin) alphart2 = w.var("#alpha_{RT1}^{%s}" % ibin) nrt1 = w.var("n_{RT0}^{%s}" % ibin) nrt2 = w.var("n_{RT1}^{%s}" % ibin) pars_init_vals = {} theRTgauss = w.pdf("doublecb_RT%s" % ibin) if ibin < 5: c_sigma_rt = _constrainVar(sigmart, 1, pars_init_vals) else: c_sigma_rt1 = _constrainVar(sigmart1, 1, pars_init_vals) c_sigma_rt2 = _constrainVar(sigmart2, 1, pars_init_vals) c_alpha_rt1 = _constrainVar(alphart1, 1, pars_init_vals) c_alpha_rt2 = _constrainVar(alphart2, 1, pars_init_vals) c_n_rt1 = _constrainVar(nrt1, 1, pars_init_vals) c_n_rt2 = _constrainVar(nrt2, 1, pars_init_vals) ### creating WT component w.loadSnapshot("reference_fit_WT_%s" % ibin) meanwt = w.var("mean^{WT%s}" % ibin) sigmawt = w.var("#sigma_{CB}^{WT%s}" % ibin) alphawt1 = w.var("#alpha_{1}^{WT%s}" % ibin) alphawt2 = w.var("#alpha_{2}^{WT%s}" % ibin) nwt1 = w.var("n_{1}^{WT%s}" % ibin) nwt2 = w.var("n_{2}^{WT%s}" % ibin) theWTgauss = w.pdf("doublecb_%s" % ibin) c_sigma_wt = _constrainVar(sigmawt, 1, pars_init_vals) c_alpha_wt1 = _constrainVar(alphawt1, 1, pars_init_vals) c_alpha_wt2 = _constrainVar(alphawt2, 1, pars_init_vals) c_n_wt1 = _constrainVar(nwt1, 1, pars_init_vals) c_n_wt2 = _constrainVar(nwt2, 1, pars_init_vals) ### creating constraints for the RT component c_vars = RooArgSet() if ibin < 5: c_RTgauss = RooProdPdf( "c_RTgauss", "c_RTgauss", RooArgList(theRTgauss, c_alpha_rt1, c_n_rt1, c_sigma_rt, c_alpha_rt2, c_n_rt2)) c_vars = RooArgSet(c_sigma_rt, c_alpha_rt1, c_alpha_rt2, c_n_rt1, c_n_rt2) else: c_RTgauss = RooProdPdf( "c_RTgauss", "c_RTgauss", RooArgList(theRTgauss, c_alpha_rt1, c_n_rt1, c_sigma_rt1, c_sigma_rt2, c_alpha_rt2, c_n_rt2)) c_vars = RooArgSet(c_sigma_rt1, c_sigma_rt2, c_alpha_rt1, c_alpha_rt2, c_n_rt1, c_n_rt2) ### creating constraints for the WT component c_WTgauss = RooProdPdf( "c_WTgauss", "c_WTgauss", RooArgList(theWTgauss, c_alpha_wt1, c_n_wt1, c_sigma_wt, c_alpha_wt2, c_n_wt2)) c_vars.add(c_sigma_wt) c_vars.add(c_alpha_wt1) c_vars.add(c_alpha_wt2) c_vars.add(c_n_wt1) c_vars.add(c_n_wt2) frt = RooRealVar("F_{RT}", "frt", fraction.n, 0, 1) signalFunction = RooAddPdf("sumgaus", "rt+wt", RooArgList(c_RTgauss, c_WTgauss), RooArgList(frt)) c_frt = RooGaussian("c_frt", "c_frt", frt, ROOT.RooFit.RooConst(fraction.n), ROOT.RooFit.RooConst(fraction.s)) ### creating constraints for the difference between the two peaks deltaPeaks = RooFormulaVar("deltaPeaks", "@0 - @1", RooArgList(meanrt, meanwt)) c_deltaPeaks = RooGaussian( "c_deltaPeaks", "c_deltaPeaks", deltaPeaks, ROOT.RooFit.RooConst(deltaPeaks.getVal()), ROOT.RooFit.RooConst(0.0005) ## value to be checked ) c_signalFunction = RooProdPdf( "c_signalFunction", "c_signalFunction", RooArgList(signalFunction, c_frt, c_deltaPeaks)) c_vars.add(frt) c_vars.add(deltaPeaks) ### now create background parametrization slope = RooRealVar("slope", "slope", 0.5, -10, 10) bkg_exp = RooExponential("bkg_exp", "exponential", slope, tagged_mass) pol_c1 = RooRealVar("p1", "coeff x^0 term", 0.5, -10, 10) pol_c2 = RooRealVar("p2", "coeff x^1 term", 0.5, -10, 10) bkg_pol = RooChebychev("bkg_pol", "2nd order pol", tagged_mass, RooArgList(pol_c1, pol_c2)) nsig = RooRealVar("Yield", "signal frac", nrt_mc.n + nwt_mc.n, 0, 1000000) nbkg = RooRealVar("nbkg", "bkg fraction", 1000, 0, 550000) print nsig.getVal() fitFunction = RooAddPdf("fitfunction", "fit function", RooArgList(c_signalFunction, bkg_pol), RooArgList(nsig, nbkg)) pars_to_tune = [ sigmawt, alphawt1, alphawt2, nwt1, nwt2, alphart1, alphart2, nrt1, nrt2 ] if ibin < 5: pars_to_tune.append(sigmart) else: pars_to_tune.append(sigmart1) pars_to_tune.append(sigmart2) ## add toy bkg for itoy in range(args.ntoys): data = deepcopy(signaldata) toy_bkg = generateBkg(tagged_mass, ibin, n_bkg) data.append(toy_bkg) print 'toy number', itoy for ipar in pars_to_tune: ipar.setVal(pars_init_vals[ipar.GetName()]) # r = fitFunction.fitTo(data, # RooFit.Extended(True), # RooFit.Range("full"), # ROOT.RooFit.Constrain(c_vars), # # ROOT.RooFit.Minimizer("Minuit2","migrad"), # ROOT.RooFit.Hesse(True), # ROOT.RooFit.Strategy(2), # ROOT.RooFit.Minos(False), # ) # # print 'fit with Hesse strategy 2 done, now Minos' r = fitFunction.fitTo( data, RooFit.Extended(True), RooFit.Save(), RooFit.Range("full"), RooFit.Verbose(False), ROOT.RooFit.Constrain(c_vars), # ROOT.RooFit.Minimizer("Minuit2","migrad"), # ROOT.RooFit.Hesse(True), ROOT.RooFit.Strategy(2), ROOT.RooFit.Minos(True), ) # # r.Print() # # r.correlationMatrix().Print() fitStats['data%s_itoy%s' % (ibin, itoy)] = r.status() covStats['data%s_itoy%s' % (ibin, itoy)] = r.covQual() frame = tagged_mass.frame(RooFit.Range("full")) data.plotOn(frame, RooFit.Binning(nbins), RooFit.MarkerSize(.7)) fitFunction.plotOn(frame, RooFit.NormRange("full"), RooFit.Range("full")) ## evaluate sort of chi2 and save number of RT/WT events observables = RooArgSet(tagged_mass) flparams = fitFunction.getParameters(observables) nparam = int( flparams.selectByAttrib("Constant", ROOT.kFALSE).getSize()) pdfstring = "fitfunction_Norm[tagged_mass]_Range[full]_NormRange[full]" chi2s['data%s_itoy%s' % (ibin, itoy)] = frame.chiSquare( pdfstring, "h_fulldata", nparam) frame.addObject(_writeChi2(chi2s['data%s_itoy%s' % (ibin, itoy)])) ## save plot only if 1 toy is run if args.ntoys == 1: drawPdfComponents(fitFunction, frame, ROOT.kAzure, RooFit.NormRange("full"), RooFit.Range("full"), isData=True) fitFunction.paramOn(frame, RooFit.Layout(0.62, 0.86, 0.89)) # parList = RooArgSet (nsig, nbkg, meanrt, meanwt, alphart1, alphart2, meanwt, sigmawt) # if ibin < 5 : # parList.add(sigmart) # else: # parList.add(sigmart1) # parList.add(sigmart2) # parList.add(alphawt1) # parList.add(alphawt2) # parList.add(nwt1) # parList.add(nwt2) # parList.add(frt) # fitFunction.paramOn(frame, RooFit.Parameters(parList), RooFit.Layout(0.62,0.86,0.89)) frame.Draw() niceFrame(frame, '') frame.addObject(_writeFitStatus(r)) c1 = ROOT.TCanvas() upperPad = ROOT.TPad('upperPad', 'upperPad', 0., 0.35, 1., 1.) lowerPad = ROOT.TPad('lowerPad', 'lowerPad', 0., 0.0, 1., 0.345) upperPad.SetBottomMargin(0.012) lowerPad.SetTopMargin(0) lowerPad.SetBottomMargin(0.2) upperPad.Draw() lowerPad.Draw() upperPad.cd() frame.Draw() if not args.year == 'test': writeCMS(frame, args.year, [q2binning[ibin], q2binning[ibin + 1]], 1) frame.Draw() ## add plot of pulls lowerPad.cd() hpull = frame.pullHist("h_fulldata", pdfstring) frame2 = tagged_mass.frame(RooFit.Range("full"), RooFit.Title('')) frame2.addPlotable(hpull, "P") niceFrameLowerPad(frame2, 'pull') frame2.Draw() line = ROOT.TLine(5.0, 1, 5.6, 1) line.SetLineColor(ROOT.kGreen + 3) line.Draw() for ilog in [True, False]: upperPad.SetLogy(ilog) c1.SaveAs( 'fit_results_mass_checkOnMC/toybkg/save_fit_data_%s_%s_nbkg%s_LMNR_Final%s_%s_update_pol2bkg.pdf' % (ibin, args.year, n_bkg, '_logScale' * ilog, itoy)) out_f.cd() # r.Write('results_data_%s_ntoy%s'%(ibin,itoy)) ## compare nkbg fitted w/ original value nbkgs['data%s_itoy%s' % (ibin, itoy)] = (toy_bkg.sumEntries() - nbkg.getVal()) / toy_bkg.sumEntries() nsigs['data%s_itoy%s' % (ibin, itoy)] = (n_realsignal - nsig.getVal()) / n_realsignal
def setupWorkspace(ws,options): cfg = options.config #for convenience fit_sections = cfg.sections() fit_sections.remove('Global') #don't need to iterate over the global configuration if not isinstance(ws,RooWorkspace): print "You didn't pass a RooWorkspace!" exit(1) cpling_type = cfg.get('Global','couplingType') par1 = cfg.get('Global','par1Name') par1bound = [-cfg.getfloat('Global','par1Max'), cfg.getfloat('Global','par1Max')] par2 = cfg.get('Global','par2Name') par2bound = [-cfg.getfloat('Global','par2Max'), cfg.getfloat('Global','par2Max')] #create the parameters in the workspace ws.factory('%s_%s[0,%f,%f]'%(par1,cpling_type,par1bound[0],par1bound[1])) ws.factory('%s_%s[0,%f,%f]'%(par2,cpling_type,par2bound[0],par2bound[1])) # since the lumi error is correlated among all channels we only need one penalty term for it lumi_err = exp(options.config.getfloat('Global','lumi_err')) # exp because we use log normal ws.factory('luminosityError[%f]'%lumi_err) ws.factory('RooLognormal::lumiErr(err_gl[1,0.0001,50],1,luminosityError)') channel_cat = RooCategory('channels','channels') #first pass: process the backgrounds, signal and data into # simultaneous counting pdfs over the bins for section in fit_sections: #create the basic observable, this is used behind the scenes #in the background and signal models channel_cat.defineType(section) channel_cat.setLabel(section) print 'Building pdf for configuration section:',section for it,bkg in getBackgroundsInCfg(section,cfg).iteritems(): ws.factory('backgroundError_%s_%s[%f]'%(section,it,exp(bkg[1]))) ws.factory('selectionError_%s[%f]'%(section,exp(cfg.getfloat(section,'selection_err')))) processFittingData(ws,cfg,section) processSignalModel(ws,cfg,section) processBackgroundModel(ws,cfg,section) createPdfForChannel(ws,cfg,section) ws.data('countingdata_%s'%section).addColumn(channel_cat) getattr(ws,'import')(channel_cat) top = RooSimultaneous('TopLevelPdf', 'TopLevelPdf', ws.cat('channels')) alldatavars = RooArgSet(ws.cat('channels')) conditionals = RooArgSet() #second pass: process counting pdfs into simultaneous pdf over channels for section in fit_sections: top.addPdf(ws.pdf('countingpdf_%s'%section),section) alldatavars.add(ws.var('%s_%s'%(cfg.get(section,'obsVar'),section))) conditionals.add(ws.var('%s_%s'%(cfg.get(section,'obsVar'),section))) alldatavars.add(ws.var('n_observed_%s'%section)) getattr(ws,'import')(top) ws.defineSet('condObs',conditionals) allcountingdata = RooDataSet('allcountingdata', 'allcountingdata', alldatavars) getattr(ws,'import')(allcountingdata) allcountingdata = ws.data('allcountingdata') #third pass: make the final combined dataset for section in fit_sections: current = ws.data('countingdata_%s'%section) print 'countingdata_%s has %d entries'%(section,current.numEntries()) for i in range(current.numEntries()): alldatavars = current.get(i) allcountingdata.add(alldatavars)
if not 'Optimize' in fitOpts or fitOpts['Optimize'] < 2 : # unset cache-and-track for par in pdfBuild['taggingParams'].parameters() : par.setAttribute( 'CacheAndTrack', False ) ########################################################################################################################################### ## generate data ## ################### ## Read data to use protodata from P2VV.Utilities.DataHandling import readData proto_data = pdfBuild['data'] from ROOT import RooArgSet conditionals = RooArgSet() for c in pdf.ConditionalObservables(): r = conditionals.add(c._target_()) proto_data = proto_data.reduce(conditionals) # read parameters from file pdfConfig.readParametersFromFile( filePath = parameterFile ) pdfConfig.setParametersInPdf(pdf) # Hack to set maximum value pdf.setMaxVal(0.15) # Wrong PV shape from P2VV.Parameterizations.WrongPV import ShapeBuilder from P2VV.RooFitWrappers import Component, Projection wpv = ShapeBuilder(time, {'B' : BMass}, UseKeysPdf = True, Weights = 'B', InputFile = "/bfys/raaij/p2vv/data/Bs2JpsiPhiPrescaled_2011.root") wpv_signal = wpv.shape('B')
def doDataFit(Chib1_parameters,Chib2_parameters, cuts, inputfile_name = None, RooDataSet = None, ptBin_label='', plotTitle = "#chi_{b}",fittedVariable='qValue', printSigReso = False, noPlots = False, useOtherSignalParametrization = False, useOtherBackgroundParametrization = False, massFreeToChange = False, sigmaFreeToChange = False, legendOnPlot=True, drawPulls=False, titleOnPlot=False, cmsOnPlot=True, printLegend=True): if RooDataSet != None: dataSet = RooDataSet elif inputfile_name != None: print "Creating DataSet from file "+str(inputfile_name) dataSet = makeRooDataset(inputfile_name) else: raise ValueError('No dataset and no inputfile passed to function doDataFit') if(fittedVariable == 'refittedMass'): x_var = 'rf1S_chib_mass' output_suffix = '_refit' x_axis_label= 'm_{#mu^{+} #mu^{-} #gamma} [GeV]' else: x_var = 'invm1S' output_suffix = '_qValue' x_axis_label = 'm_{#gamma #mu^{+} #mu^{-}} - m_{#mu^{+} #mu^{-}} + m^{PDG}_{#Upsilon} [GeV]' cuts_str = str(cuts) #cuts_str = quality_cut + "photon_pt > 0.5 && abs(photon_eta) < 1.0 && ctpv < 0.01 && abs(dimuon_rapidity) < 1.3 && pi0_abs_mass > 0.025 && abs(dz) < 0.5" data = dataSet.reduce( RooFit.Cut(cuts_str) ) print 'Creating pdf' x=RooRealVar(x_var, 'm(#mu #mu #gamma) - m(#mu #mu) + m_{#Upsilon}',9.7,10.1,'GeV') numBins = 80 # define here so that if I change it also the ndof change accordingly x.setBins(numBins) # cristal balls mean_1 = RooRealVar("mean_1","mean ChiB1",Chib1_parameters.mean,"GeV") sigma_1 = RooRealVar("sigma_1","sigma ChiB1",Chib1_parameters.sigma,'GeV') a1_1 = RooRealVar('#alpha1_1', '#alpha1_1', Chib1_parameters.a1) n1_1 = RooRealVar('n1_1', 'n1_1', Chib1_parameters.n1) a2_1 = RooRealVar('#alpha2_1', '#alpha2_1',Chib1_parameters.a2) n2_1 = RooRealVar('n2_1', 'n2_1', Chib1_parameters.n2) parameters = RooArgSet(a1_1, a2_1, n1_1, n2_1) mean_2 = RooRealVar("mean_2","mean ChiB2",Chib2_parameters.mean,"GeV") sigma_2 = RooRealVar("sigma_2","sigma ChiB2",Chib2_parameters.sigma,'GeV') a1_2 = RooRealVar('#alpha1_2', '#alpha1_2', Chib2_parameters.a1) n1_2 = RooRealVar('n1_2', 'n1_2', Chib2_parameters.n1) a2_2 = RooRealVar('#alpha2_2', '#alpha2_2', Chib2_parameters.a2) n2_2 = RooRealVar('n2_2', 'n2_2', Chib2_parameters.n2) parameters.add(RooArgSet( a1_2, a2_2, n1_2, n2_2)) if massFreeToChange: # scale_mean = RooRealVar('scale_mean', 'Scale that multiplies masses found with MC', 0.8,1.2) # mean_1_fixed = RooRealVar("mean_1_fixed","mean ChiB1",Chib1_parameters.mean,"GeV") # mean_2_fixed = RooRealVar("mean_2_fixed","mean ChiB2",Chib2_parameters.mean,"GeV") # mean_1 = RooFormulaVar("mean_1",'@0*@1', RooArgList(scale_mean, mean_1_fixed)) # mean_2 = RooFormulaVar("mean_2",'@0*@1', RooArgList(scale_mean, mean_2_fixed)) variazione_m = 0.05 # 50 MeV diff_m_12 = RooRealVar('diff_m_12', 'Difference between masses chib1 and chib2',0.0194,'GeV') # 19.4 MeV from PDG mean_1=RooRealVar("mean_1","mean ChiB1",Chib1_parameters.mean,Chib1_parameters.mean-variazione_m,Chib1_parameters.mean+variazione_m ,"GeV") mean_2=RooFormulaVar('mean_2', '@0+@1',RooArgList(mean_1, diff_m_12)) # mean_2=RooRealVar("mean_2","mean ChiB2",Chib2_parameters.mean,Chib2_parameters.mean-variazione_m,Chib2_parameters.mean+variazione_m ,"GeV") parameters.add(mean_1) else: parameters.add(RooArgSet(mean_1, mean_2)) chib1_pdf = My_double_CB('chib1', 'chib1', x, mean_1, sigma_1, a1_1, n1_1, a2_1, n2_1) chib2_pdf = My_double_CB('chib2', 'chib2', x, mean_2, sigma_2, a1_2, n1_2, a2_2, n2_2) if sigmaFreeToChange: scale_sigma = RooRealVar('scale_sigma', 'Scale that multiplies sigmases found with MC', 1, 1.1)#1.01 sigma_1_fixed = RooRealVar("sigma_1","sigma ChiB1",Chib1_parameters.sigma,'GeV') sigma_2_fixed = RooRealVar("sigma_2","sigma ChiB2",Chib2_parameters.sigma,'GeV') sigma_1 = RooFormulaVar("sigma_1",'@0*@1', RooArgList(scale_sigma, sigma_1_fixed)) sigma_2 = RooFormulaVar("sigma_2",'@0*@1', RooArgList(scale_sigma, sigma_2_fixed)) parameters.add(scale_sigma) else: parameters.add(RooArgSet(sigma_1, sigma_2)) chib1_pdf = My_double_CB('chib1', 'chib1', x, mean_1, sigma_1, a1_1, n1_1, a2_1, n2_1) chib2_pdf = My_double_CB('chib2', 'chib2', x, mean_2, sigma_2, a1_2, n1_2, a2_2, n2_2) if useOtherSignalParametrization: # In this case I redefine cb_pdf cb1 = RooCBShape('cb1', 'cb1', x, mean_1, sigma_1, a1_1, n1_1) cb2 = RooCBShape('cb2', 'cb2', x, mean_2, sigma_2, a1_2, n1_2) # I use a2 as the sigma of my gaussian gauss1 = RooCBShape('gauss1', 'gauss1',x, mean_1, a2_1, a1_1, n1_1) gauss2 = RooCBShape('gauss2', 'gauss2',x, mean_2, a2_2, a1_2, n1_2) # I use n2 as the ratio of cb with respect to gauss chib1_pdf = RooAddPdf('chib1','chib1',RooArgList(cb1, gauss1),RooArgList(n2_1)) chib2_pdf = RooAddPdf('chib2','chib2',RooArgList(cb2, gauss2),RooArgList(n2_2)) #background q01S_Start = 9.5 alpha = RooRealVar("#alpha","#alpha",1.5,-1,3.5)#0.2 anziche' 1 beta = RooRealVar("#beta","#beta",-2.5,-7.,0.) q0 = RooRealVar("q0","q0",q01S_Start)#,9.5,9.7) delta = RooFormulaVar("delta","TMath::Abs(@0-@1)",RooArgList(x,q0)) b1 = RooFormulaVar("b1","@0*(@1-@2)",RooArgList(beta,x,q0)) signum1 = RooFormulaVar( "signum1","( TMath::Sign( -1.,@0-@1 )+1 )/2.", RooArgList(x,q0) ) background = RooGenericPdf("background","Background", "signum1*pow(delta,#alpha)*exp(b1)", RooArgList(signum1,delta,alpha,b1) ) if useOtherBackgroundParametrization: # in thies case I redefine background a0 = RooRealVar('a0','a0',1.,-1.,1.) #,0.5,0.,1.) a1 = RooRealVar('a1','a1',0.1,-1.,1.) #-0.2,0.,1.) #a2 = RooRealVar('a2','a2',-0.1,1.,-1.) background = RooChebychev('background','Background',x,RooArgList(a0,a1)) parameters.add(RooArgSet(a0, a1)) else: parameters.add(RooArgSet(alpha, beta, q0)) #together chibs = RooArgList(chib1_pdf,chib2_pdf,background) # ndof floatPars = parameters.selectByAttrib("Constant",ROOT.kFALSE) ndof = numBins - floatPars.getSize() - 1 # # Here I have as parameters N1, N2, and N_background # n_chib1 = RooRealVar("n_chib1","n_chib1",1250, 0, 50000) # n_chib2 = RooRealVar("n_chib2","n_chib2",825, 0, 50000) # n_background = RooRealVar('n_background','n_background',4550, 0, 50000) # ratio_list = RooArgList(n_chib1, n_chib2, n_background) # modelPdf = RooAddPdf('ModelPdf', 'ModelPdf', chibs, ratio_list) # Here I have as parameters N_12, ratio_12, N_background n_chib = RooRealVar("n_chib","n_chib",2075, 0, 100000) ratio_21 = RooRealVar("ratio_21","ratio_21",0.6, 0, 1) n_chib1 = RooFormulaVar("n_chib1","@0/(1+@1)",RooArgList(n_chib, ratio_21)) n_chib2 = RooFormulaVar("n_chib2","@0/(1+1/@1)",RooArgList(n_chib, ratio_21)) n_background = RooRealVar('n_background','n_background',4550, 0, 50000) ratio_list = RooArgList(n_chib1, n_chib2, n_background) parameters.add(RooArgSet(n_chib1, n_chib2, n_background)) modelPdf = RooAddPdf('ModelPdf', 'ModelPdf', chibs, ratio_list) print 'Fitting to data' fit_region = x.setRange("fit_region",9.7,10.1) result=modelPdf.fitTo(data,RooFit.Save(), RooFit.Range("fit_region")) # define frame frame = x.frame() frame.SetNameTitle("fit_resonance","Fit Resonanace") frame.GetXaxis().SetTitle(x_axis_label ) frame.GetYaxis().SetTitle( "Events/5 MeV " ) frame.GetXaxis().SetTitleSize(0.04) frame.GetYaxis().SetTitleSize(0.04) frame.GetXaxis().SetTitleOffset(1.1) frame.GetXaxis().SetLabelSize(0.04) frame.GetYaxis().SetLabelSize(0.04) frame.SetLineWidth(1) frame.SetTitle(plotTitle) # plot things on frame data.plotOn(frame, RooFit.MarkerSize(0.7)) chib1P_set = RooArgSet(chib1_pdf) modelPdf.plotOn(frame,RooFit.Components(chib1P_set), RooFit.LineColor(ROOT.kGreen+2), RooFit.LineStyle(2), RooFit.LineWidth(1)) chib2P_set = RooArgSet(chib2_pdf) modelPdf.plotOn(frame, RooFit.Components(chib2P_set),RooFit.LineColor(ROOT.kRed), RooFit.LineStyle(2), RooFit.LineWidth(1)) background_set = RooArgSet(background) modelPdf.plotOn(frame,RooFit.Components(background_set), RooFit.LineColor(ROOT.kBlack), RooFit.LineStyle(2), RooFit.LineWidth(1)) modelPdf.plotOn(frame, RooFit.LineWidth(2)) frame.SetName("fit_resonance") # Make numChib object numChib = NumChib(numChib=n_chib.getVal(), s_numChib=n_chib.getError(), ratio_21=ratio_21.getVal(), s_ratio_21=ratio_21.getError(), numBkg=n_background.getVal(), s_numBkg=n_background.getError(), corr_NB=result.correlation(n_chib, n_background),corr_NR=result.correlation(n_chib, ratio_21) , name='numChib'+output_suffix+ptBin_label,q0=q0.getVal(),s_q0=q0.getError(),alpha=alpha.getVal(),s_alpha=alpha.getError(), beta=beta.getVal(), s_beta=beta.getError(), chiSquare=frame.chiSquare()) #numChib.saveToFile('numChib'+output_suffix+'.txt') if noPlots: chi2 = frame.chiSquare() del frame return numChib, chi2 # Legend parameters_on_legend = RooArgSet()#n_chib, ratio_21, n_background) if massFreeToChange: #parameters_on_legend.add(scale_mean) parameters_on_legend.add(mean_1) #parameters_on_legend.add(mean_2) if sigmaFreeToChange: parameters_on_legend.add(scale_sigma) if massFreeToChange or sigmaFreeToChange: modelPdf.paramOn(frame, RooFit.Layout(0.1,0.6,0.2),RooFit.Parameters(parameters_on_legend)) if printLegend: #chiquadro, prob, numchib... leg = TLegend(0.48,0.75,0.97,0.95) leg.SetBorderSize(0) #leg.SetTextSize(0.04) leg.SetFillStyle(0) chi2 = frame.chiSquare() probChi2 = TMath.Prob(chi2*ndof, ndof) chi2 = round(chi2,2) probChi2 = round(probChi2,2) leg.AddEntry(0,'#chi^{2} = '+str(chi2),'') leg.AddEntry(0,'Prob #chi^{2} = '+str(probChi2),'') N_bkg, s_N_bkg = roundPair(numChib.numBkg, numChib.s_numBkg) leg.AddEntry(0,'N_{bkg} = '+str(N_bkg)+' #pm '+str(s_N_bkg),'') N_chib12, s_N_chib12 = roundPair(numChib.numChib, numChib.s_numChib) leg.AddEntry(0,'N_{#chi_{b}} = '+str(N_chib12)+' #pm '+str(s_N_chib12),'') Ratio = numChib.calcRatio() s_Ratio = numChib.calcRatioError() Ratio, s_Ratio = roundPair(Ratio, s_Ratio) leg.AddEntry(0,'N_{2}/N_{1} = '+str(Ratio)+' #pm '+str(s_Ratio),'') if printSigReso: # Add Significance Sig = numChib.calcSignificance() s_Sig = numChib.calcSignificanceError() Sig, s_Sig = roundPair(Sig, s_Sig) leg.AddEntry(0,'Sig = '+str(Sig)+' #pm '+str(s_Sig),'') if(Chib1_parameters.sigma>Chib2_parameters.sigma): Reso = Chib1_parameters.sigma * 1000 # So it's in MeV and not in GeV s_Reso = Chib1_parameters.s_sigma * 1000 # So it's in MeV and not in GeV else: Reso = Chib2_parameters.sigma * 1000 # So it's in MeV and not in GeV s_Reso = Chib2_parameters.s_sigma * 1000 # So it's in MeV and not in GeV Reso, s_Reso =roundPair(Reso, s_Reso) leg.AddEntry(0,'Reso = '+str(Reso)+' #pm '+str(s_Reso)+' MeV','') #N1 = numChib.numChib1 #s_N1 = numChib.s_numChib1 #N1, s_N1 = roundPair(N1, s_N1) #leg.AddEntry(0,'N_{1} = '+str(N1)+' #pm '+str(s_N1),'') #N2 = numChib.numChib2 #s_N2 = numChib.s_numChib2 #N2, s_N2 = roundPair(N2, s_N2) #leg.AddEntry(0,'N_{2} = '+str(N2)+' #pm '+str(s_N2),'') frame.addObject(leg) if legendOnPlot: # < pT < legend = TLegend(.06,.75,.53,.93) legend.SetFillStyle(0) legend.SetBorderSize(0) #legend.AddEntry(0,'CMS','') legend.AddEntry(0,str(cuts.upsilon_pt_lcut)+' GeV < p_{T}(#Upsilon) < '+str(cuts.upsilon_pt_hcut)+' GeV','') #legend.AddEntry(0,'p_{T}(#Upsilon)<'+str(cuts.upsilon_pt_hcut),'') frame.addObject(legend) if titleOnPlot: titleLegend = TLegend(.06,.4,.55,.73) #titleLegend.SetTextSize(0.03) titleLegend.SetFillStyle(0) titleLegend.SetBorderSize(0) titleLegend.AddEntry(0,plotTitle,'') frame.addObject(titleLegend) if cmsOnPlot: if printLegend: pvtxt = TPaveText(.1,.55,.55,.73,"NDC") else: pvtxt = TPaveText(0.5,0.75,0.97,0.9,"NDC") #(.06,.4,.55,.73) pvtxt.AddText('CMS Preliminary') pvtxt.AddText('pp, #sqrt{s} = 8 TeV') pvtxt.AddText('L = 20.7 fb^{-1}') pvtxt.SetFillStyle(0) pvtxt.SetBorderSize(0) pvtxt.SetTextSize(0.04) frame.addObject(pvtxt) # Canvas c1=TCanvas('Chib12_1P'+output_suffix+ptBin_label,'Chib12_1P'+output_suffix+ptBin_label) frame.Draw() if drawPulls: #c1=TCanvas(output_name+output_suffix,output_name+output_suffix,700, 625) hpull = frame.pullHist() framePulls = x.frame() framePulls.SetTitle(';;Pulls') framePulls.GetYaxis().SetLabelSize(0.18) framePulls.GetYaxis().SetTitle('Pulls') framePulls.GetYaxis().SetTitleSize(0.18) framePulls.GetYaxis().SetTitleOffset(0.15) framePulls.GetYaxis().SetNdivisions(005) framePulls.GetXaxis().SetLabelSize(0.16) framePulls.GetXaxis().SetTitle('') line0 = TLine(9.7, 0, 10.1, 0) line0.SetLineColor(ROOT.kBlue) line0.SetLineWidth(2) framePulls.addObject(line0) framePulls.addPlotable(hpull,"P") framePulls.SetMaximum(5) framePulls.SetMinimum(-5) pad1 = TPad("pad1", "The pad 80% of the height",0.0,0.2,1.0,1.0) pad1.cd() frame.Draw() pad2 = TPad("pad2", "The pad 20% of the height",0.0,0.01,1.0,0.2) pad2.cd() framePulls.Draw() c1.cd() pad1.Draw() pad2.Draw() #c1.SaveAs('Chib12_1P'+output_suffix+'.png') print 'Chi2 = '+str(frame.chiSquare()) # print ratio background/all in the signal refion signal_region = x.setRange("signal_region",9.87,9.92) pdf_integral = modelPdf.createIntegral(RooArgSet(x), RooFit.Range('signal_region')).getVal() * (n_chib.getVal() + n_background.getVal()) bkg_integral = background.createIntegral(RooArgSet(x), RooFit.Range('signal_region')).getVal() * n_background.getVal() print 'Ratio bkg/all in signal region = '+str(bkg_integral/pdf_integral) return numChib, c1
def dijet(category): channel = 'bb' stype = channel isSB = True # relict from using Alberto's more complex script isData = not ISMC nTupleDir = NTUPLEDIR samples = data if isData else back pd = [] for sample_name in samples: if YEAR == 'run2': pd += sample[sample_name]['files'] else: pd += [x for x in sample[sample_name]['files'] if YEAR in x] print "datasets:", pd if not os.path.exists(PLOTDIR): os.makedirs(PLOTDIR) if BIAS: print "Running in BIAS mode" order = 0 RSS = {} X_mass = RooRealVar("jj_mass_widejet", "m_{jj}", X_min, X_max, "GeV") weight = RooRealVar("MANtag_weight", "", -1.e9, 1.e9) variables = RooArgSet(X_mass) variables.add(RooArgSet(weight)) if VARBINS: binsXmass = RooBinning(len(abins) - 1, abins) X_mass.setBinning(RooBinning(len(abins_narrow) - 1, abins_narrow)) plot_binning = RooBinning( int((X_mass.getMax() - X_mass.getMin()) / 100), X_mass.getMin(), X_mass.getMax()) else: X_mass.setBins(int((X_mass.getMax() - X_mass.getMin()) / 10)) binsXmass = RooBinning(int((X_mass.getMax() - X_mass.getMin()) / 100), X_mass.getMin(), X_mass.getMax()) plot_binning = binsXmass baseCut = "" print stype, "|", baseCut print " - Reading from Tree" treeBkg = TChain("tree") for ss in pd: if os.path.exists(nTupleDir + ss + "_" + BTAGGING + ".root"): treeBkg.Add(nTupleDir + ss + "_" + BTAGGING + ".root") else: print "found no file for sample:", ss setData = RooDataSet("setData", "Data (QCD+TTbar MC)", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeBkg)) nevents = setData.sumEntries() dataMin, dataMax = array('d', [0.]), array('d', [0.]) setData.getRange(X_mass, dataMin, dataMax) xmin, xmax = dataMin[0], dataMax[0] lastBin = X_mass.getMax() if VARBINS: for b in narrow_bins: if b > xmax: lastBin = b break print "Imported", ( "data" if isData else "MC" ), "RooDataSet with", nevents, "events between [%.1f, %.1f]" % (xmin, xmax) #xmax = xmax+binsXmass.averageBinWidth() # start form next bin # 1 parameter print "fitting 1 parameter model" p1_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p1_1", "p1", 7.0, 0., 2000.) modelBkg1 = RooGenericPdf("Bkg1", "Bkg. fit (2 par.)", "1./pow(@0/13000, @1)", RooArgList(X_mass, p1_1)) normzBkg1 = RooRealVar( modelBkg1.GetName() + "_norm", "Number of background events", nevents, 0., 5. * nevents) #range dependent of actual number of events! modelExt1 = RooExtendPdf(modelBkg1.GetName() + "_ext", modelBkg1.GetTitle(), modelBkg1, normzBkg1) fitRes1 = modelExt1.fitTo(setData, RooFit.Extended(True), RooFit.Save(1), RooFit.SumW2Error(not isData), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.PrintLevel(1 if VERBOSE else -1)) fitRes1.Print() RSS[1] = drawFit("Bkg1", category, X_mass, modelBkg1, setData, binsXmass, [fitRes1], normzBkg1.getVal()) # 2 parameters print "fitting 2 parameter model" p2_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p2_1", "p1", 0., -100., 1000.) p2_2 = RooRealVar("CMS" + YEAR + "_" + category + "_p2_2", "p2", p1_1.getVal(), -100., 600.) modelBkg2 = RooGenericPdf("Bkg2", "Bkg. fit (3 par.)", "pow(1-@0/13000, @1) / pow(@0/13000, @2)", RooArgList(X_mass, p2_1, p2_2)) normzBkg2 = RooRealVar(modelBkg2.GetName() + "_norm", "Number of background events", nevents, 0., 5. * nevents) modelExt2 = RooExtendPdf(modelBkg2.GetName() + "_ext", modelBkg2.GetTitle(), modelBkg2, normzBkg2) fitRes2 = modelExt2.fitTo(setData, RooFit.Extended(True), RooFit.Save(1), RooFit.SumW2Error(not isData), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.PrintLevel(1 if VERBOSE else -1)) fitRes2.Print() RSS[2] = drawFit("Bkg2", category, X_mass, modelBkg2, setData, binsXmass, [fitRes2], normzBkg2.getVal()) # 3 parameters print "fitting 3 parameter model" p3_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p3_1", "p1", p2_1.getVal(), -2000., 2000.) p3_2 = RooRealVar("CMS" + YEAR + "_" + category + "_p3_2", "p2", p2_2.getVal(), -400., 2000.) p3_3 = RooRealVar("CMS" + YEAR + "_" + category + "_p3_3", "p3", -2.5, -500., 500.) modelBkg3 = RooGenericPdf( "Bkg3", "Bkg. fit (4 par.)", "pow(1-@0/13000, @1) / pow(@0/13000, @2+@3*log(@0/13000))", RooArgList(X_mass, p3_1, p3_2, p3_3)) normzBkg3 = RooRealVar(modelBkg3.GetName() + "_norm", "Number of background events", nevents, 0., 5. * nevents) modelExt3 = RooExtendPdf(modelBkg3.GetName() + "_ext", modelBkg3.GetTitle(), modelBkg3, normzBkg3) fitRes3 = modelExt3.fitTo(setData, RooFit.Extended(True), RooFit.Save(1), RooFit.SumW2Error(not isData), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.PrintLevel(1 if VERBOSE else -1)) fitRes3.Print() RSS[3] = drawFit("Bkg3", category, X_mass, modelBkg3, setData, binsXmass, [fitRes3], normzBkg3.getVal()) # 4 parameters print "fitting 4 parameter model" p4_1 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_1", "p1", p3_1.getVal(), -2000., 2000.) p4_2 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_2", "p2", p3_2.getVal(), -2000., 2000.) p4_3 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_3", "p3", p3_3.getVal(), -50., 50.) p4_4 = RooRealVar("CMS" + YEAR + "_" + category + "_p4_4", "p4", 0.1, -50., 50.) modelBkg4 = RooGenericPdf( "Bkg4", "Bkg. fit (5 par.)", "pow(1 - @0/13000, @1) / pow(@0/13000, @2+@3*log(@0/13000)+@4*pow(log(@0/13000), 2))", RooArgList(X_mass, p4_1, p4_2, p4_3, p4_4)) normzBkg4 = RooRealVar(modelBkg4.GetName() + "_norm", "Number of background events", nevents, 0., 5. * nevents) modelExt4 = RooExtendPdf(modelBkg4.GetName() + "_ext", modelBkg4.GetTitle(), modelBkg4, normzBkg4) fitRes4 = modelExt4.fitTo(setData, RooFit.Extended(True), RooFit.Save(1), RooFit.SumW2Error(not isData), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.PrintLevel(1 if VERBOSE else -1)) fitRes4.Print() RSS[4] = drawFit("Bkg4", category, X_mass, modelBkg4, setData, binsXmass, [fitRes4], normzBkg4.getVal()) # Normalization parameters are should be set constant, but shape ones should not # if BIAS: # p1_1.setConstant(True) # p2_1.setConstant(True) # p2_2.setConstant(True) # p3_1.setConstant(True) # p3_2.setConstant(True) # p3_3.setConstant(True) # p4_1.setConstant(True) # p4_2.setConstant(True) # p4_3.setConstant(True) # p4_4.setConstant(True) normzBkg1.setConstant(True) normzBkg2.setConstant(True) normzBkg3.setConstant(True) normzBkg4.setConstant(True) #*******************************************************# # # # Fisher # # # #*******************************************************# # Fisher test with open(PLOTDIR + "/Fisher_" + category + ".tex", 'w') as fout: fout.write(r"\begin{tabular}{c|c|c|c|c}") fout.write("\n") fout.write(r"function & $\chi^2$ & RSS & ndof & F-test \\") fout.write("\n") fout.write("\hline") fout.write("\n") CL_high = False for o1 in range(1, 5): o2 = min(o1 + 1, 5) fout.write("%d par & %.2f & %.2f & %d & " % (o1 + 1, RSS[o1]["chi2"], RSS[o1]["rss"], RSS[o1]["nbins"] - RSS[o1]["npar"])) if o2 > len(RSS): fout.write(r"\\") fout.write("\n") continue #order==0 and CL = fisherTest(RSS[o1]['rss'], RSS[o2]['rss'], o1 + 1., o2 + 1., RSS[o1]["nbins"]) fout.write("CL=%.3f " % (CL)) if CL > 0.10: # The function with less parameters is enough if not CL_high: order = o1 #fout.write( "%d par are sufficient " % (o1+1)) CL_high = True else: #fout.write( "%d par are needed " % (o2+1)) if not CL_high: order = o2 fout.write(r"\\") fout.write("\n") fout.write("\hline") fout.write("\n") fout.write(r"\end{tabular}") print "saved F-test table as", PLOTDIR + "/Fisher_" + category + ".tex" #print "-"*25 #print "function & $\\chi^2$ & RSS & ndof & F-test & result \\\\" #print "\\multicolumn{6}{c}{", "Zprime_to_bb", "} \\\\" #print "\\hline" #CL_high = False #for o1 in range(1, 5): # o2 = min(o1 + 1, 5) # print "%d par & %.2f & %.2f & %d & " % (o1+1, RSS[o1]["chi2"], RSS[o1]["rss"], RSS[o1]["nbins"]-RSS[o1]["npar"]), # if o2 > len(RSS): # print "\\\\" # continue #order==0 and # CL = fisherTest(RSS[o1]['rss'], RSS[o2]['rss'], o1+1., o2+1., RSS[o1]["nbins"]) # print "%d par vs %d par CL=%f & " % (o1+1, o2+1, CL), # if CL > 0.10: # The function with less parameters is enough # if not CL_high: # order = o1 # print "%d par are sufficient" % (o1+1), # CL_high=True # else: # print "%d par are needed" % (o2+1), # if not CL_high: # order = o2 # print "\\\\" #print "\\hline" #print "-"*25 #print "@ Order is", order, "("+category+")" #order = min(3, order) #order = 2 if order == 1: modelBkg = modelBkg1 #.Clone("Bkg") modelAlt = modelBkg2 #.Clone("BkgAlt") normzBkg = normzBkg1 #.Clone("Bkg_norm") fitRes = fitRes1 elif order == 2: modelBkg = modelBkg2 #.Clone("Bkg") modelAlt = modelBkg3 #.Clone("BkgAlt") normzBkg = normzBkg2 #.Clone("Bkg_norm") fitRes = fitRes2 elif order == 3: modelBkg = modelBkg3 #.Clone("Bkg") modelAlt = modelBkg4 #.Clone("BkgAlt") normzBkg = normzBkg3 #.Clone("Bkg_norm") fitRes = fitRes3 elif order == 4: modelBkg = modelBkg4 #.Clone("Bkg") modelAlt = modelBkg3 #.Clone("BkgAlt") normzBkg = normzBkg4 #.Clone("Bkg_norm") fitRes = fitRes4 else: print "Functions with", order + 1, "or more parameters are needed to fit the background" exit() modelBkg.SetName("Bkg_" + YEAR + "_" + category) modelAlt.SetName("Alt_" + YEAR + "_" + category) normzBkg.SetName("Bkg_" + YEAR + "_" + category + "_norm") print "-" * 25 # Generate pseudo data setToys = RooDataSet() setToys.SetName("data_toys") setToys.SetTitle("Data (toys)") if not isData: print " - Generating", nevents, "events for toy data" setToys = modelBkg.generate(RooArgSet(X_mass), nevents) #setToys = modelAlt.generate(RooArgSet(X_mass), nevents) print "toy data generated" if VERBOSE: raw_input("Press Enter to continue...") #*******************************************************# # # # Plot # # # #*******************************************************# print "starting to plot" c = TCanvas("c_" + category, category, 800, 800) c.Divide(1, 2) setTopPad(c.GetPad(1), RATIO) setBotPad(c.GetPad(2), RATIO) c.cd(1) frame = X_mass.frame() setPadStyle(frame, 1.25, True) if VARBINS: frame.GetXaxis().SetRangeUser(X_mass.getMin(), lastBin) signal = getSignal( category, stype, 2000) #replacing Alberto's getSignal by own dummy function graphData = setData.plotOn(frame, RooFit.Binning(plot_binning), RooFit.Scaling(False), RooFit.Invisible()) modelBkg.plotOn(frame, RooFit.VisualizeError(fitRes, 1, False), RooFit.LineColor(602), RooFit.FillColor(590), RooFit.FillStyle(1001), RooFit.DrawOption("FL"), RooFit.Name("1sigma")) modelBkg.plotOn(frame, RooFit.LineColor(602), RooFit.FillColor(590), RooFit.FillStyle(1001), RooFit.DrawOption("L"), RooFit.Name(modelBkg.GetName())) modelAlt.plotOn(frame, RooFit.LineStyle(7), RooFit.LineColor(613), RooFit.FillColor(609), RooFit.FillStyle(1001), RooFit.DrawOption("L"), RooFit.Name(modelAlt.GetName())) if not isSB and signal[0] is not None: # FIXME remove /(2./3.) signal[0].plotOn( frame, RooFit.Normalization(signal[1] * signal[2], RooAbsReal.NumEvent), RooFit.LineStyle(3), RooFit.LineWidth(6), RooFit.LineColor(629), RooFit.DrawOption("L"), RooFit.Name("Signal")) graphData = setData.plotOn( frame, RooFit.Binning(plot_binning), RooFit.Scaling(False), RooFit.XErrorSize(0 if not VARBINS else 1), RooFit.DataError(RooAbsData.Poisson if isData else RooAbsData.SumW2), RooFit.DrawOption("PE0"), RooFit.Name(setData.GetName())) fixData(graphData.getHist(), True, True, not isData) pulls = frame.pullHist(setData.GetName(), modelBkg.GetName(), True) chi = frame.chiSquare(setData.GetName(), modelBkg.GetName(), True) #setToys.plotOn(frame, RooFit.DataError(RooAbsData.Poisson), RooFit.DrawOption("PE0"), RooFit.MarkerColor(2)) frame.GetYaxis().SetTitle("Events / ( 100 GeV )") frame.GetYaxis().SetTitleOffset(1.05) frame.Draw() #print "frame drawn" # Get Chi2 # chi2[1] = frame.chiSquare(modelBkg1.GetName(), setData.GetName()) # chi2[2] = frame.chiSquare(modelBkg2.GetName(), setData.GetName()) # chi2[3] = frame.chiSquare(modelBkg3.GetName(), setData.GetName()) # chi2[4] = frame.chiSquare(modelBkg4.GetName(), setData.GetName()) frame.SetMaximum(frame.GetMaximum() * 10) frame.SetMinimum(max(frame.GetMinimum(), 1.e-1)) c.GetPad(1).SetLogy() drawAnalysis(category) drawRegion(category, True) #drawCMS(LUMI, "Simulation Preliminary") drawCMS(LUMI, "Work in Progress", suppressCMS=True) leg = TLegend(0.575, 0.6, 0.95, 0.9) leg.SetBorderSize(0) leg.SetFillStyle(0) #1001 leg.SetFillColor(0) leg.AddEntry(setData.GetName(), setData.GetTitle() + " (%d events)" % nevents, "PEL") leg.AddEntry(modelBkg.GetName(), modelBkg.GetTitle(), "FL") #.SetTextColor(629) leg.AddEntry(modelAlt.GetName(), modelAlt.GetTitle(), "L") if not isSB and signal[0] is not None: leg.AddEntry("Signal", signal[0].GetTitle(), "L") leg.SetY1(0.9 - leg.GetNRows() * 0.05) leg.Draw() latex = TLatex() latex.SetNDC() latex.SetTextSize(0.04) latex.SetTextFont(42) if not isSB: latex.DrawLatex(leg.GetX1() * 1.16, leg.GetY1() - 0.04, "HVT model B (g_{V}=3)") # latex.DrawLatex(0.67, leg.GetY1()-0.045, "#sigma_{X} = 1.0 pb") c.cd(2) frame_res = X_mass.frame() setPadStyle(frame_res, 1.25) frame_res.addPlotable(pulls, "P") setBotStyle(frame_res, RATIO, False) if VARBINS: frame_res.GetXaxis().SetRangeUser(X_mass.getMin(), lastBin) frame_res.GetYaxis().SetRangeUser(-5, 5) frame_res.GetYaxis().SetTitle("pulls(#sigma)") frame_res.GetYaxis().SetTitleOffset(0.3) frame_res.Draw() fixData(pulls, False, True, False) drawChi2(RSS[order]["chi2"], RSS[order]["nbins"] - (order + 1), True) line = drawLine(X_mass.getMin(), 0, lastBin, 0) if VARBINS: c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".pdf") c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".png") else: c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".pdf") c.SaveAs(PLOTDIR + "/BkgSR_" + category + ".png") #*******************************************************# # # # Generate workspace # # # #*******************************************************# if BIAS: gSystem.Load("libHiggsAnalysisCombinedLimit.so") from ROOT import RooMultiPdf cat = RooCategory("pdf_index", "Index of Pdf which is active") pdfs = RooArgList(modelBkg, modelAlt) roomultipdf = RooMultiPdf("roomultipdf", "All Pdfs", cat, pdfs) normulti = RooRealVar("roomultipdf_norm", "Number of background events", nevents, 0., 1.e6) normzBkg.setConstant( False ) ## newly put here to ensure it's freely floating in the combine fit # create workspace w = RooWorkspace("Zprime_" + YEAR, "workspace") # Dataset if isData: getattr(w, "import")(setData, RooFit.Rename("data_obs")) else: getattr(w, "import")(setToys, RooFit.Rename("data_obs")) #getattr(w, "import")(setData, RooFit.Rename("data_obs")) if BIAS: getattr(w, "import")(cat, RooFit.Rename(cat.GetName())) getattr(w, "import")(normulti, RooFit.Rename(normulti.GetName())) getattr(w, "import")(roomultipdf, RooFit.Rename(roomultipdf.GetName())) getattr(w, "import")(modelBkg, RooFit.Rename(modelBkg.GetName())) getattr(w, "import")(modelAlt, RooFit.Rename(modelAlt.GetName())) getattr(w, "import")(normzBkg, RooFit.Rename(normzBkg.GetName())) w.writeToFile(WORKDIR + "%s_%s.root" % (DATA_TYPE + "_" + YEAR, category), True) print "Workspace", WORKDIR + "%s_%s.root" % ( DATA_TYPE + "_" + YEAR, category), "saved successfully" if VERBOSE: raw_input("Press Enter to continue...")
def buildDataAndCategories(ws,options,args): #Get the input data inputData = TChain(options.treeName,'The input data') for arg in args: print 'Adding data from: ',arg inputData.Add(arg) foldname = '' phirange = [0,90] if not options.folded: foldname='' phirange = [-180,180] #variables necessary for j/psi mass,lifetime,polarization fit jPsiMass = RooRealVar('JpsiMass','M [GeV]',2.7,3.5) jPsiRap = RooRealVar('JpsiRap','#nu',-2.3,2.3) jPsiPt = RooRealVar("JpsiPt","pT [GeV]",0,40); jPsicTau = RooRealVar('Jpsict','l_{J/#psi} [mm]',-1,2.5) jPsicTauError = RooRealVar('JpsictErr','Error on l_{J/#psi} [mm]',0,2) jPsiVprob = RooRealVar('JpsiVprob','',.01,1) jPsiHXcosth = None jPsiHXphi = None jPsicTau.setBins(10000,"cache") if options.fitFrame is not None: jPsiHXcosth = RooRealVar('costh_'+options.fitFrame+foldname,'cos(#theta)_{'+options.fitFrame+'}',-1,1) jPsiHXphi = RooRealVar('phi_'+options.fitFrame+foldname,'#phi_{'+options.fitFrame+'}',phirange[0],phirange[1]) else: jPsiHXcosth = RooRealVar('costh_CS'+foldname,'cos(#theta)_{CS}',-1,1) jPsiHXphi = RooRealVar('phi_CS'+foldname,'#phi_{CS}',phirange[0],phirange[1]) #vars needed for on the fly calc of polarization variables jPsimuPosPx = RooRealVar('muPosPx','+ Muon P_{x} [GeV]',0) jPsimuPosPy = RooRealVar('muPosPy','+ Muon P_{y} [GeV]',0) jPsimuPosPz = RooRealVar('muPosPz','+ Muon P_{z} [GeV]',0) jPsimuNegPx = RooRealVar('muNegPx','- Muon P_{x} [GeV]',0) jPsimuNegPy = RooRealVar('muNegPy','- Muon P_{y} [GeV]',0) jPsimuNegPz = RooRealVar('muNegPz','- Muon P_{z} [GeV]',0) #create RooArgSet for eventual dataset creation dataVars = RooArgSet(jPsiMass,jPsiRap,jPsiPt, jPsicTau,jPsicTauError, jPsimuPosPx,jPsimuPosPy,jPsimuPosPz) #add trigger requirement if specified if options.triggerName: trigger = RooRealVar(options.triggerName,'Passes Trigger',0.5,1.5) dataVars.add(trigger) dataVars.add(jPsiVprob) dataVars.add(jPsimuNegPx) dataVars.add(jPsimuNegPy) dataVars.add(jPsimuNegPz) dataVars.add(jPsiHXcosth) dataVars.add(jPsiHXphi) redVars = RooArgSet(jPsiMass,jPsiRap,jPsiPt, jPsicTau,jPsicTauError) redVars.add(jPsiHXcosth) redVars.add(jPsiHXphi) fitVars = redVars.Clone() ### HERE IS WHERE THE BIT FOR CALCULATING POLARIZATION VARS GOES ctauStates = RooCategory('ctauRegion','Cut Region in lifetime') ctauStates.defineType('prompt',0) ctauStates.defineType('nonPrompt',1) massStates = RooCategory('massRegion','Cut Region in mass') massStates.defineType('signal',1) massStates.defineType('separation',0) massStates.defineType('leftMassSideBand',-2) massStates.defineType('rightMassSideBand',-1) states = RooCategory('mlRegion','Cut Region in mass') states.defineType('nonPromptSignal',2) states.defineType('promptSignal',1) states.defineType('separation',0) states.defineType('leftMassSideBand',-2) states.defineType('rightMassSideBand',-1) #define corresponding ranges in roorealvars #mass is a little tricky since the sidebands change definitions in each rap bin #define the names here and change as we do the fits #jPsiMass.setRange('NormalizationRangeFormlfit_promptSignal',2.7,3.5) #jPsiMass.setRange('NormalizationRangeFormlfit_nonPromptSignal',2.7,3.5) #jPsiMass.setRange('NormalizationRangeFormlfit_leftMassSideBand',2.7,3.1) #jPsiMass.setRange('NormalizationRangeFormlfit_rightMassSideBand',3.1,3.5) #want the prompt fit only done in prompt region #non-prompt only in non-prompt region #background over entire cTau range #jPsicTau.setRange('NormalizationRangeFormlfit_promptSignal',-1,.1) #jPsicTau.setRange('NormalizationRangeFormlfit_nonPromptSignal',.1,2.5) #jPsicTau.setRange('NormalizationRangeFormlfit_leftMassSideBand',-1,2.5) #jPsicTau.setRange('NormalizationRangeFormlfit_rightMassSideBand',-1,2.5) #redVars.add(ctauStates) #redVars.add(massStates) #redVars.add(states) fitVars.add(ctauStates) fitVars.add(massStates) fitVars.add(states) fullData = RooDataSet('fullData','The Full Data From the Input ROOT Trees', dataVars, ROOT.RooFit.Import(inputData)) for rap_bin in range(1,len(jpsi.pTRange)): yMin = jpsi.rapForPTRange[rap_bin-1][0] yMax = jpsi.rapForPTRange[rap_bin-1][-1] for pt_bin in range(len(jpsi.pTRange[rap_bin])): ptMin = jpsi.pTRange[rap_bin][pt_bin][0] ptMax = jpsi.pTRange[rap_bin][pt_bin][-1] sigMaxMass = jpsi.polMassJpsi[rap_bin] + jpsi.nSigMass*jpsi.sigmaMassJpsi[rap_bin] sigMinMass = jpsi.polMassJpsi[rap_bin] - jpsi.nSigMass*jpsi.sigmaMassJpsi[rap_bin] sbHighMass = jpsi.polMassJpsi[rap_bin] + jpsi.nSigBkgHigh*jpsi.sigmaMassJpsi[rap_bin] sbLowMass = jpsi.polMassJpsi[rap_bin] - jpsi.nSigBkgLow*jpsi.sigmaMassJpsi[rap_bin] ctauNonPrompt = .1 massFun = RooFormulaVar('massRegion','Function that returns the mass state.', '('+jPsiMass.GetName()+' < '+str(sigMaxMass)+' && '+jPsiMass.GetName()+' > '+str(sigMinMass)+ ') - ('+jPsiMass.GetName()+' > '+str(sbHighMass)+')'+ '-2*('+jPsiMass.GetName()+' < '+str(sbLowMass)+')', RooArgList(jPsiMass,jPsicTau)) ctauFun = RooFormulaVar('ctauRegion','Function that returns the ctau state.', '('+jPsicTau.GetName()+' > '+str(ctauNonPrompt)+')', RooArgList(jPsiMass,jPsicTau)) mlFun = RooFormulaVar('mlRegion','Function that returns the mass and lifetime state.', '('+jPsiMass.GetName()+' < '+str(sigMaxMass)+' && '+jPsiMass.GetName()+' > '+str(sigMinMass)+ ') + ('+jPsiMass.GetName()+' < '+str(sigMaxMass)+' && '+jPsiMass.GetName()+' > '+ str(sigMinMass)+' && '+jPsicTau.GetName()+' > '+str(ctauNonPrompt)+ ') - ('+jPsiMass.GetName()+' > '+str(sbHighMass)+')'+ '-2*('+jPsiMass.GetName()+' < '+str(sbLowMass)+')', RooArgList(jPsiMass,jPsicTau)) cutStringPt = '('+jPsiPt.GetName()+' > '+str(ptMin)+' && '+jPsiPt.GetName()+' < '+str(ptMax)+')' cutStringY = '( abs('+jPsiRap.GetName()+') > '+str(yMin)+' && abs('+jPsiRap.GetName()+') < '+str(yMax)+')' #cutStringM1 = '('+jPsiMass.GetName()+' < '+str(sigMinMass)+' && '+jPsiMass.GetName()+' > '+str(sbLowMass)+')' #cutStringM2 = '('+jPsiMass.GetName()+' < '+str(sbHighMass)+' && '+jPsiMass.GetName()+' > '+str(sigMaxMass)+')' #cutStringMT = '!('+cutStringM1+' || '+cutStringM2+')' cutString = cutStringPt+' && '+cutStringY #+' && '+cutStringMT print cutString #get the reduced dataset we'll do the fit on binData = fullData.reduce(ROOT.RooFit.SelectVars(redVars), ROOT.RooFit.Cut(cutString), ROOT.RooFit.Name('data_rap'+str(rap_bin)+'_pt'+str(pt_bin+1)), ROOT.RooFit.Title('Data For Fitting')) binDataWithCategory = RooDataSet('data_rap'+str(rap_bin)+'_pt'+str(pt_bin+1), 'Data For Fitting', fitVars) #categorize binData.addColumn(ctauStates) binData.addColumn(massStates) binData.addColumn(states) for ev in range(binData.numEntries()): args = binData.get(ev) jPsiMass.setVal(args.find(jPsiMass.GetName()).getVal()) jPsiRap.setVal(args.find(jPsiRap.GetName()).getVal()) jPsiPt.setVal(args.find(jPsiPt.GetName()).getVal()) jPsicTau.setVal(args.find(jPsicTau.GetName()).getVal()) jPsicTauError.setVal(args.find(jPsicTauError.GetName()).getVal()) jPsiHXcosth.setVal(args.find(jPsiHXcosth.GetName()).getVal()) jPsiHXphi.setVal(args.find(jPsiHXphi.GetName()).getVal()) massStates.setIndex(int(massFun.getVal())) ctauStates.setIndex(int(ctauFun.getVal())) states.setIndex(int(mlFun.getVal())) binDataWithCategory.add(fitVars) getattr(ws,'import')(binDataWithCategory)
def get_fitted_normalisation_from_ROOT(channel, input_files, variable, met_type, b_tag_bin): results = {} initial_values = {} templates = {} for variable_bin in variable_bins_ROOT[variable]: histograms = get_histograms(channel, input_files, variable=variable, met_type=met_type, variable_bin=variable_bin, b_tag_bin=b_tag_bin, rebin=measurement_config.rebin) # create signal histograms h_eta_signal = histograms['TTJet'] + histograms['SingleTop'] N_ttbar_before_fit = histograms['TTJet'].Integral() N_SingleTop_before_fit = histograms['SingleTop'].Integral() N_vjets_before_fit = histograms['V+Jets'].Integral() N_qcd_before_fit = histograms['QCD'].Integral() N_signal_before_fit = N_ttbar_before_fit + N_SingleTop_before_fit N_ttbar_error_before_fit = sum(histograms['TTJet'].errors()) N_SingleTop_error_before_fit = sum(histograms['SingleTop'].errors()) N_vjets_error_before_fit = sum(histograms['V+Jets'].errors()) N_QCD_error_before_fit = sum(histograms['QCD'].errors()) if (N_SingleTop_before_fit != 0): TTJet_SingleTop_ratio = N_ttbar_before_fit / N_SingleTop_before_fit else: print 'Bin ', variable_bin, ': ttbar/singleTop ratio undefined for %s channel! Setting to 0.' % channel TTJet_SingleTop_ratio = 0 leptonAbsEta = RooRealVar("leptonAbsEta", "leptonAbsEta", 0., 2.4) # this has to move to dps.utils.Fitting.py vars = RooArgList() vars.add(leptonAbsEta) vars_set = RooArgSet() vars_set.add(leptonAbsEta) n_event_obs = histograms['data'].Integral() lowerBound = 0. upperBound = n_event_obs + 10 * sqrt(n_event_obs) n_init = n_event_obs / 2. data = RooDataHist("data", "dataset with leptonAbsEta", vars, histograms['data']) rh_vj = RooDataHist("rh_vj", "vj", vars, histograms['V+Jets']) rh_qcd = RooDataHist("rh_qcd", "qcd", vars, histograms['QCD']) rh_signal = RooDataHist("rh_signal", "signal", vars, h_eta_signal) pdf_vj = RooHistPdf("pdf_vj", "V+Jets pdf", vars_set, rh_vj, 0) pdf_qcd = RooHistPdf("pdf_qcd", "QCD pdf ", vars_set, rh_qcd, 0) pdf_signal = RooHistPdf("pdf_signal", "single top pdf", vars_set, rh_signal, 0) # RooRealVar(const char *name, const char *title, Double_t value, Double_t minValue, Double_t maxValue, const char *unit) : nSignal = RooRealVar("nSignal", "number of single top + ttbar events", N_signal_before_fit, lowerBound, upperBound, "event") nvj = RooRealVar("nvj", "number of V+Jets bgnd events", N_vjets_before_fit, lowerBound, upperBound, "event") nqcd = RooRealVar("nqcd", "number of QCD bgnd events", N_QCD_error_before_fit, lowerBound, upperBound, "event") model = RooAddPdf("model", "sig+vj+qcd", RooArgList(pdf_signal, pdf_vj, pdf_qcd), RooArgList(nSignal, nvj, nqcd)) vj_constraint = RooGaussian("nvj_constraint", "nvj_constraint", nvj, RooFit.RooConst(N_vjets_before_fit), RooFit.RooConst(0.5 * N_vjets_before_fit)) qcd_constraint = RooGaussian("nqcd_constraint", "nqcd_constraint", nqcd, RooFit.RooConst(N_qcd_before_fit), RooFit.RooConst(2 * N_qcd_before_fit)) model_with_constraints = RooProdPdf( "model_with_constraints", "model with gaussian constraints", RooArgSet(model, vj_constraint, qcd_constraint), RooLinkedList()) model_with_constraints.fitTo(data, RooFit.Minimizer( "Minuit2", "Migrad")) #WARNING: number of cores changes the results!!! # nll = model.createNLL(data, RooFit.NumCPU(2)) # RooMinuit(nll).migrad() # frame1 = nSignal.frame(RooFit.Bins(100), RooFit.Range(lowerBound, n_event_obs), RooFit.Title("LL and profileLL in nSignal")) # nll.plotOn(frame1, RooFit.ShiftToZero()) # frame2 = nvj.frame(RooFit.Bins(100), RooFit.Range(lowerBound, n_event_obs), RooFit.Title("LL and profileLL in nvj")) # nll.plotOn(frame2, RooFit.ShiftToZero()) # frame3 = nqcd.frame(RooFit.Bins(100), RooFit.Range(lowerBound, n_event_obs), RooFit.Title("LL and profileLL in nqcd")) # nll.plotOn(frame3, RooFit.ShiftToZero()) # # pll_nSignal = nll.createProfile(nSignal) # pll_nSignal.plotOn(frame1, RooFit.LineColor(2)) # frame1.SetMinimum(0) # frame1.SetMaximum(3) # # pll_nvj = nll.createProfile(nvj) # pll_nvj.plotOn(frame2, RooFit.LineColor(2)) # frame2.SetMinimum(0) # frame2.SetMaximum(3) # # pll_nqcd = nll.createProfile(nqcd) # pll_nqcd.plotOn(frame3, RooFit.LineColor(2)) # frame3.SetMinimum(0) # frame3.SetMaximum(3) # c = TCanvas("profilell","profilell",1200, 400) # c.Divide(3) # c.cd(1) # frame1.Draw() # c.cd(2) # frame2.Draw() # c.cd(3) # frame3.Draw() # c.SaveAs('profileLL.png') # model.fitTo(data, RooFit.Minimizer("Minuit2", "Migrad"), RooFit.NumCPU(1))#WARNING: number of cores changes the results!!! fit_results = {} fit_results['signal'] = (nSignal.getVal(), nSignal.getError()) fit_results['QCD'] = ufloat(nqcd.getVal(), nqcd.getError()) fit_results['V+Jets'] = ufloat(nvj.getVal(), nvj.getError()) N_ttbar, N_SingleTop = decombine_result(fit_results['signal'], TTJet_SingleTop_ratio) fit_results['signal'] = ufloat(nSignal.getVal(), nSignal.getError()) fit_results['TTJet'] = ufloat(N_ttbar) fit_results['SingleTop'] = ufloat(N_SingleTop) if results == {}: # empty for sample in fit_results.keys(): results[sample] = [fit_results[sample]] else: for sample in fit_results.keys(): results[sample].append(fit_results[sample]) return results, None, None
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 bookHistos(): global argSet argSet = RooArgSet() argSet.add(invm1S) argSet.add(invm2S) argSet.add(invm3S) argSet.add(jpsipt) argSet.add(jpsieta) argSet.add(jpsimass) argSet.add(gammapt) argSet.add(deltaRJpsig) argSet.add(deltaRChiJpsi) argSet.add(ctpv) argSet.add(ctpverr) argSet.add(ctpvsig) argSet.add(ctbs) argSet.add(ctbserr) argSet.add(ctbssig) argSet.add(Rconv) argSet.add(jpsiVprob) argSet.add(Y1Smass_nSigma) argSet.add(Y2Smass_nSigma) argSet.add(Y3Smass_nSigma) argSet.add(jpsipx) argSet.add(jpsipy) argSet.add(jpsipz) argSet.add(gammapx) argSet.add(gammapy) argSet.add(gammapz) argSet.add(gammaeta) argSet.add(vertexChi2ProbGamma) argSet.add(Q) argSet.add(ndofConv) argSet.add(chi2Conv) argSet.add(Pi0Mass) argSet.add(vtxdz) argSet.add(vtxerrdz) argSet.add(vtxNsigmadz) argSet.add(UpsIndex) argSet.add(GammaIndex) global rds rds = RooDataSet("d","d",argSet,"weight") global hlist hlist = []
import P2VV.RooFitWrappers from ROOT import TFile, RooArgSet protoFile = TFile.Open(protoFilePathIn) nTupleFileIn = TFile.Open(nTupleFilePathIn) protoData = protoFile.Get('JpsiKK_sigSWeight') nTupleIn = nTupleFileIn.Get('DecayTree') from ROOT import RooRealVar, RooCategory obsSet = RooArgSet( protoData.get() ) if runPeriods : rp = obsSet.find('runPeriod') if rp : obsSet.remove(rp) rp = RooCategory( 'runPeriod', 'runPeriod' ) for per in runPeriods : rp.defineType( 'p%d' % per, per ) obsSet.add(rp) if KKMassBins : KKCat = obsSet.find('KKMassCat') if KKCat : obsSet.remove(KKCat) KKCat = RooCategory( 'KKMassCat', 'KKMassCat' ) for ind in range( len(KKMassBins) - 1 ) : KKCat.defineType( 'bin%d' % ind, ind ) obsSet.add(KKCat) from array import array KKBinsArray = array( 'd', KKMassBins ) from ROOT import RooBinning KKBinning = RooBinning( len(KKMassBins) - 1, KKBinsArray, 'KKMassBinning' ) obsSet.find('mdau2').setBinning( KKBinning, 'KKMassBinning' ) if removeVars :
def alpha(channel): nElec = channel.count('e') nMuon = channel.count('m') nLept = nElec + nMuon nBtag = channel.count('b') # Channel-dependent settings # Background function. Semi-working options are: EXP, EXP2, EXPN, EXPTAIL if nLept == 0: treeName = 'SR' signName = 'XZh' colorVjet = sample['DYJetsToNuNu']['linecolor'] triName = "HLT_PFMET" leptCut = "0==0" topVeto = selection["TopVetocut"] massVar = "X_cmass" binFact = 1 #fitFunc = "EXP" #fitFunc = "EXP2" #fitFunc = "EXPN" #fitFunc = "EXPTAIL" fitFunc = "EXPN" if nBtag < 2 else "EXP" fitAltFunc = "EXPTAIL" if nBtag < 2 else "EXPTAIL" fitFuncVjet = "ERFEXP" if nBtag < 2 else "ERFEXP" fitFuncVV = "EXPGAUS" fitFuncTop = "GAUS2" elif nLept == 1: treeName = 'WCR' signName = 'XWh' colorVjet = sample['WJetsToLNu']['linecolor'] triName = "HLT_Ele" if nElec > 0 else "HLT_Mu" leptCut = "isWtoEN" if nElec > 0 else "isWtoMN" topVeto = selection["TopVetocut"] massVar = "X_mass" binFact = 2 if nElec > 0: fitFunc = "EXP" if nBtag < 2 else "EXP" fitAltFunc = "EXPTAIL" if nBtag < 2 else "EXPTAIL" else: fitFunc = "EXPTAIL" if nBtag < 2 else "EXP" fitAltFunc = "EXPN" if nBtag < 2 else "EXPTAIL" fitFuncVjet = "ERFEXP" if nBtag < 2 else "ERFEXP" fitFuncVV = "EXPGAUS" fitFuncTop = "GAUS3" if nBtag < 2 else "GAUS2" else: treeName = 'XZh' signName = 'XZh' colorVjet = sample['DYJetsToLL']['linecolor'] triName = "HLT_Ele" if nElec > 0 else "HLT_Mu" leptCut = "isZtoEE" if nElec > 0 else "isZtoMM" topVeto = "0==0" massVar = "X_mass" binFact = 5 if nElec > 0: fitFunc = "EXP" if nBtag < 2 else "EXP" fitAltFunc = "POW" if nBtag < 2 else "POW" else: fitFunc = "EXP" if nBtag < 2 else "EXP" fitAltFunc = "POW" if nBtag < 2 else "POW" fitFuncVjet = "ERFEXP" if nBtag < 2 else "EXP" fitFuncVV = "EXPGAUS2" fitFuncTop = "GAUS" btagCut = selection["2Btag"] if nBtag == 2 else selection["1Btag"] print "--- Channel", channel, "---" print " number of electrons:", nElec, " muons:", nMuon, " b-tags:", nBtag print " read tree:", treeName, "and trigger:", triName if ALTERNATIVE: print " using ALTERNATIVE fit functions" print "-"*11*2 # Silent RooFit RooMsgService.instance().setGlobalKillBelow(RooFit.FATAL) #*******************************************************# # # # Variables and selections # # # #*******************************************************# # Define all the variables from the trees that will be used in the cuts and fits # this steps actually perform a "projection" of the entire tree on the variables in thei ranges, so be careful once setting the limits X_mass = RooRealVar( massVar, "m_{X}" if nLept > 0 else "m_{T}^{X}", XBINMIN, XBINMAX, "GeV") J_mass = RooRealVar( "fatjet1_prunedMassCorr", "corrected pruned mass", HBINMIN, HBINMAX, "GeV") CSV1 = RooRealVar( "fatjet1_CSVR1", "", -1.e99, 1.e4 ) CSV2 = RooRealVar( "fatjet1_CSVR2", "", -1.e99, 1.e4 ) nBtag = RooRealVar( "fatjet1_nBtag", "", 0., 4 ) CSVTop = RooRealVar( "bjet1_CSVR", "", -1.e99, 1.e4 ) isZtoEE = RooRealVar("isZtoEE", "", 0., 2 ) isZtoMM = RooRealVar("isZtoMM", "", 0., 2 ) isWtoEN = RooRealVar("isWtoEN", "", 0., 2 ) isWtoMN = RooRealVar("isWtoMN", "", 0., 2 ) weight = RooRealVar( "eventWeightLumi", "", -1.e9, 1. ) # 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, CSV1, CSV2, nBtag, CSVTop) variables.add(RooArgSet(isZtoEE, isZtoMM, isWtoEN, isWtoMN, weight)) # Define the ranges in fatJetMass - these will be used to define SB and SR J_mass.setRange("LSBrange", LOWMIN, LOWMAX) J_mass.setRange("HSBrange", HIGMIN, HIGMAX) J_mass.setRange("VRrange", LOWMAX, SIGMIN) J_mass.setRange("SRrange", SIGMIN, SIGMAX) J_mass.setBins(54) # Define the selection for the various categories (base + SR / LSBcut / HSBcut ) baseCut = leptCut + " && " + btagCut + "&&" + topVeto massCut = massVar + ">%d" % XBINMIN baseCut += " && " + massCut # Cuts SRcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), SIGMIN, J_mass.GetName(), SIGMAX) LSBcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), LOWMIN, J_mass.GetName(), LOWMAX) HSBcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), HIGMIN, J_mass.GetName(), HIGMAX) SBcut = baseCut + " && ((%s>%d && %s<%d) || (%s>%d && %s<%d))" % (J_mass.GetName(), LOWMIN, J_mass.GetName(), LOWMAX, J_mass.GetName(), HIGMIN, J_mass.GetName(), HIGMAX) VRcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), LOWMAX, J_mass.GetName(), SIGMIN) # Binning binsJmass = RooBinning(HBINMIN, HBINMAX) binsJmass.addUniform(HBINS, HBINMIN, HBINMAX) binsXmass = RooBinning(XBINMIN, XBINMAX) binsXmass.addUniform(binFact*XBINS, XBINMIN, XBINMAX) #*******************************************************# # # # Input files # # # #*******************************************************# # Import the files using TChains (separately for the bkg "classes" that we want to describe: here DY and VV+ST+TT) treeData = TChain(treeName) treeMC = TChain(treeName) treeVjet = TChain(treeName) treeVV = TChain(treeName) treeTop = TChain(treeName) # treeSign = {} # nevtSign = {} # Read data pd = getPrimaryDataset(triName) if len(pd)==0: raw_input("Warning: Primary Dataset not recognized, continue?") for i, s in enumerate(pd): treeData.Add(NTUPLEDIR + s + ".root") # Read V+jets backgrounds for i, s in enumerate(["WJetsToLNu_HT", "DYJetsToNuNu_HT", "DYJetsToLL_HT"]): for j, ss in enumerate(sample[s]['files']): treeVjet.Add(NTUPLEDIR + ss + ".root") # Read VV backgrounds for i, s in enumerate(["VV"]): for j, ss in enumerate(sample[s]['files']): treeVV.Add(NTUPLEDIR + ss + ".root") # Read Top backgrounds for i, s in enumerate(["ST", "TTbar"]): for j, ss in enumerate(sample[s]['files']): treeTop.Add(NTUPLEDIR + ss + ".root") # Sum all background MC treeMC.Add(treeVjet) treeMC.Add(treeVV) treeMC.Add(treeTop) # create a dataset to host data in sideband (using this dataset we are automatically blind in the SR!) setDataSB = RooDataSet("setDataSB", "setDataSB", variables, RooFit.Cut(SBcut), RooFit.WeightVar(weight), RooFit.Import(treeData)) setDataLSB = RooDataSet("setDataLSB", "setDataLSB", variables, RooFit.Import(setDataSB), RooFit.Cut(LSBcut), RooFit.WeightVar(weight)) setDataHSB = RooDataSet("setDataHSB", "setDataHSB", variables, RooFit.Import(setDataSB), RooFit.Cut(HSBcut), RooFit.WeightVar(weight)) # Observed data (WARNING, BLIND!) setDataSR = RooDataSet("setDataSR", "setDataSR", variables, RooFit.Cut(SRcut), RooFit.WeightVar(weight), RooFit.Import(treeData)) setDataVR = RooDataSet("setDataVR", "setDataVR", variables, RooFit.Cut(VRcut), RooFit.WeightVar(weight), RooFit.Import(treeData)) # Observed in the VV mass, just for plotting purposes # same for the bkg datasets from MC, where we just apply the base selections (not blind) setVjet = RooDataSet("setVjet", "setVjet", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeVjet)) setVjetSB = RooDataSet("setVjetSB", "setVjetSB", variables, RooFit.Import(setVjet), RooFit.Cut(SBcut), RooFit.WeightVar(weight)) setVjetSR = RooDataSet("setVjetSR", "setVjetSR", variables, RooFit.Import(setVjet), RooFit.Cut(SRcut), RooFit.WeightVar(weight)) setVV = RooDataSet("setVV", "setVV", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeVV)) setVVSB = RooDataSet("setVVSB", "setVVSB", variables, RooFit.Import(setVV), RooFit.Cut(SBcut), RooFit.WeightVar(weight)) setVVSR = RooDataSet("setVVSR", "setVVSR", variables, RooFit.Import(setVV), RooFit.Cut(SRcut), RooFit.WeightVar(weight)) setTop = RooDataSet("setTop", "setTop", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeTop)) setTopSB = RooDataSet("setTopSB", "setTopSB", variables, RooFit.Import(setTop), RooFit.Cut(SBcut), RooFit.WeightVar(weight)) setTopSR = RooDataSet("setTopSR", "setTopSR", variables, RooFit.Import(setTop), RooFit.Cut(SRcut), RooFit.WeightVar(weight)) print " Data events SB: %.2f" % setDataSB.sumEntries() print " V+jets entries: %.2f" % setVjet.sumEntries() print " VV, VH entries: %.2f" % setVV.sumEntries() print " Top,ST entries: %.2f" % setTop.sumEntries() # the relative normalization of the varius bkg is taken from MC by counting all the events in the full fatJetMass range #coef = RooRealVar("coef", "coef", setVV.sumEntries()/setVjet.sumEntries(),0.,1.) coef_VV_Vjet = RooRealVar("coef2_1", "coef2_1", setVV.sumEntries()/setVjet.sumEntries(), 0., 1.) coef_Top_VVVjet = RooRealVar("coef3_21", "coef3_21", setTop.sumEntries()/(setVjet.sumEntries()+setVV.sumEntries()),0.,1.); coef_VV_Vjet.setConstant(True) coef_Top_VVVjet.setConstant(True) # Define entries entryVjet = RooRealVar("entryVjets", "V+jets normalization", setVjet.sumEntries(), 0., 1.e6) entryVV = RooRealVar("entryVV", "VV normalization", setVV.sumEntries(), 0., 1.e6) entryTop = RooRealVar("entryTop", "Top normalization", setTop.sumEntries(), 0., 1.e6) entrySB = RooRealVar("entrySB", "Data SB normalization", setDataSB.sumEntries(SBcut), 0., 1.e6) entrySB.setError(math.sqrt(entrySB.getVal())) entryLSB = RooRealVar("entryLSB", "Data LSB normalization", setDataSB.sumEntries(LSBcut), 0., 1.e6) entryLSB.setError(math.sqrt(entryLSB.getVal())) entryHSB = RooRealVar("entryHSB", "Data HSB normalization", setDataSB.sumEntries(HSBcut), 0., 1.e6) entryHSB.setError(math.sqrt(entryHSB.getVal())) #*******************************************************# # # # NORMALIZATION # # # #*******************************************************# # set reasonable ranges for J_mass and X_mass # these are used in the fit in order to avoid ROOFIT to look in regions very far away from where we are fitting J_mass.setRange("h_reasonable_range", LOWMIN, HIGMAX) X_mass.setRange("X_reasonable_range", XBINMIN, XBINMAX) # Set RooArgSets once for all, see https://root.cern.ch/phpBB3/viewtopic.php?t=11758 jetMassArg = RooArgSet(J_mass) #*******************************************************# # # # V+jets normalization # # # #*******************************************************# # Variables for V+jets constVjet = RooRealVar("constVjet", "slope of the exp", -0.020, -1., 0.) offsetVjet = RooRealVar("offsetVjet", "offset of the erf", 30., -50., 200.) widthVjet = RooRealVar("widthVjet", "width of the erf", 100., 1., 200.) offsetVjet.setConstant(True) a0Vjet = RooRealVar("a0Vjet", "width of the erf", -0.1, -5, 0) a1Vjet = RooRealVar("a1Vjet", "width of the erf", 0.6, 0, 5) a2Vjet = RooRealVar("a2Vjet", "width of the erf", -0.1, -1, 1) # Define V+jets model if fitFuncVjet == "ERFEXP": modelVjet = RooErfExpPdf("modelVjet", "error function for V+jets mass", J_mass, constVjet, offsetVjet, widthVjet) elif fitFuncVjet == "EXP": modelVjet = RooExponential("modelVjet", "exp for V+jets mass", J_mass, constVjet) elif fitFuncVjet == "POL": modelVjet = RooChebychev("modelVjet", "polynomial for V+jets mass", J_mass, RooArgList(a0Vjet, a1Vjet, a2Vjet)) elif fitFuncVjet == "POW": modelVjet = RooGenericPdf("modelVjet", "powerlaw for X mass", "@0^@1", RooArgList(J_mass, a0Vjet)) else: print " ERROR! Pdf", fitFuncVjet, "is not implemented for Vjets" exit() # fit to main bkg in MC (whole range) frVjet = modelVjet.fitTo(setVjet, RooFit.SumW2Error(True), RooFit.Range("h_reasonable_range"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.Save(1), RooFit.PrintLevel(1 if VERBOSE else -1)) # integrals and number of events iSBVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange,HSBrange")) iLSBVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange")) iHSBVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("HSBrange")) iSRVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange")) iVRVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("VRrange")) # Do not remove the following lines, integrals are computed here iALVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg)) nSBVjet = iSBVjet.getVal()/iALVjet.getVal()*setVjet.sumEntries(SBcut) nLSBVjet = iLSBVjet.getVal()/iALVjet.getVal()*setVjet.sumEntries(LSBcut) nHSBVjet = iHSBVjet.getVal()/iALVjet.getVal()*setVjet.sumEntries(HSBcut) nSRVjet = iSRVjet.getVal()/iALVjet.getVal()*setVjet.sumEntries(SRcut) drawPlot("JetMass_Vjet", channel, J_mass, modelVjet, setVjet, binsJmass, frVjet) if VERBOSE: print "********** Fit result [JET MASS Vjets] *"+"*"*40, "\n", frVjet.Print(), "\n", "*"*80 #*******************************************************# # # # VV, VH normalization # # # #*******************************************************# # Variables for VV # Error function and exponential to model the bulk constVV = RooRealVar("constVV", "slope of the exp", -0.030, -0.1, 0.) offsetVV = RooRealVar("offsetVV", "offset of the erf", 90., 1., 300.) widthVV = RooRealVar("widthVV", "width of the erf", 50., 1., 100.) erfrVV = RooErfExpPdf("baseVV", "error function for VV jet mass", J_mass, constVV, offsetVV, widthVV) expoVV = RooExponential("baseVV", "error function for VV jet mass", J_mass, constVV) # gaussian for the V mass peak meanVV = RooRealVar("meanVV", "mean of the gaussian", 90., 60., 100.) sigmaVV = RooRealVar("sigmaVV", "sigma of the gaussian", 10., 6., 30.) fracVV = RooRealVar("fracVV", "fraction of gaussian wrt erfexp", 3.2e-1, 0., 1.) gausVV = RooGaussian("gausVV", "gaus for VV jet mass", J_mass, meanVV, sigmaVV) # gaussian for the H mass peak meanVH = RooRealVar("meanVH", "mean of the gaussian", 125., 100., 150.) sigmaVH = RooRealVar("sigmaVH", "sigma of the gaussian", 30., 5., 40.) fracVH = RooRealVar("fracVH", "fraction of gaussian wrt erfexp", 1.5e-2, 0., 1.) gausVH = RooGaussian("gausVH", "gaus for VH jet mass", J_mass, meanVH, sigmaVH) # Define VV model if fitFuncVV == "ERFEXPGAUS": modelVV = RooAddPdf("modelVV", "error function + gaus for VV jet mass", RooArgList(gausVV, erfrVV), RooArgList(fracVV)) elif fitFuncVV == "ERFEXPGAUS2": modelVV = RooAddPdf("modelVV", "error function + gaus + gaus for VV jet mass", RooArgList(gausVH, gausVV, erfrVV), RooArgList(fracVH, fracVV)) elif fitFuncVV == "EXPGAUS": modelVV = RooAddPdf("modelVV", "error function + gaus for VV jet mass", RooArgList(gausVV, expoVV), RooArgList(fracVV)) elif fitFuncVV == "EXPGAUS2": modelVV = RooAddPdf("modelVV", "error function + gaus + gaus for VV jet mass", RooArgList(gausVH, gausVV, expoVV), RooArgList(fracVH, fracVV)) else: print " ERROR! Pdf", fitFuncVV, "is not implemented for VV" exit() # fit to secondary bkg in MC (whole range) frVV = modelVV.fitTo(setVV, RooFit.SumW2Error(True), RooFit.Range("h_reasonable_range"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.Save(1), RooFit.PrintLevel(1 if VERBOSE else -1)) # integrals and number of events iSBVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange,HSBrange")) iLSBVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange")) iHSBVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("HSBrange")) iSRVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange")) iVRVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("VRrange")) # Do not remove the following lines, integrals are computed here iALVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg)) nSBVV = iSBVV.getVal()/iALVV.getVal()*setVV.sumEntries(SBcut) nLSBVV = iLSBVV.getVal()/iALVV.getVal()*setVV.sumEntries(LSBcut) nHSBVV = iHSBVV.getVal()/iALVV.getVal()*setVV.sumEntries(HSBcut) nSRVV = iSRVV.getVal()/iALVV.getVal()*setVV.sumEntries(SRcut) rSBSRVV = nSRVV/nSBVV drawPlot("JetMass_VV", channel, J_mass, modelVV, setVV, binsJmass, frVV) if VERBOSE: print "********** Fit result [JET MASS VV] ****"+"*"*40, "\n", frVV.Print(), "\n", "*"*80 #*******************************************************# # # # Top, ST normalization # # # #*******************************************************# # Variables for Top # Error Function * Exponential to model the bulk constTop = RooRealVar("constTop", "slope of the exp", -0.030, -1., 0.) offsetTop = RooRealVar("offsetTop", "offset of the erf", 175.0, 50., 250.) widthTop = RooRealVar("widthTop", "width of the erf", 100.0, 1., 300.) gausTop = RooGaussian("baseTop", "gaus for Top jet mass", J_mass, offsetTop, widthTop) erfrTop = RooErfExpPdf("baseTop", "error function for Top jet mass", J_mass, constTop, offsetTop, widthTop) # gaussian for the W mass peak meanW = RooRealVar("meanW", "mean of the gaussian", 80., 70., 90.) sigmaW = RooRealVar("sigmaW", "sigma of the gaussian", 10., 2., 20.) fracW = RooRealVar("fracW", "fraction of gaussian wrt erfexp", 0.1, 0., 1.) gausW = RooGaussian("gausW", "gaus for W jet mass", J_mass, meanW, sigmaW) # gaussian for the Top mass peak meanT = RooRealVar("meanT", "mean of the gaussian", 175., 150., 200.) sigmaT = RooRealVar("sigmaT", "sigma of the gaussian", 12., 5., 50.) fracT = RooRealVar("fracT", "fraction of gaussian wrt erfexp", 0.1, 0., 1.) gausT = RooGaussian("gausT", "gaus for T jet mass", J_mass, meanT, sigmaT) # Define Top model if fitFuncTop == "ERFEXPGAUS2": modelTop = RooAddPdf("modelTop", "error function + gaus + gaus for Top jet mass", RooArgList(gausW, gausT, erfrTop), RooArgList(fracW, fracT)) elif fitFuncTop == "ERFEXPGAUS": modelTop = RooAddPdf("modelTop", "error function + gaus for Top jet mass", RooArgList(gausT, erfrTop), RooArgList(fracT)) elif fitFuncTop == "GAUS3": modelTop = RooAddPdf("modelTop", "gaus + gaus + gaus for Top jet mass", RooArgList(gausW, gausT, gausTop), RooArgList(fracW, fracT)) elif fitFuncTop == "GAUS2": modelTop = RooAddPdf("modelTop", "gaus + gaus for Top jet mass", RooArgList(gausT, gausTop), RooArgList(fracT)) elif fitFuncTop == "GAUS": modelTop = RooGaussian("modelTop", "gaus for Top jet mass", J_mass, offsetTop, widthTop) else: print " ERROR! Pdf", fitFuncTop, "is not implemented for Top" exit() # fit to secondary bkg in MC (whole range) frTop = modelTop.fitTo(setTop, RooFit.SumW2Error(True), RooFit.Range("h_reasonable_range"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.Save(1), RooFit.PrintLevel(1 if VERBOSE else -1)) # integrals and number of events iSBTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange,HSBrange")) iLSBTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange")) iHSBTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("HSBrange")) iSRTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange")) iVRTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("VRrange")) # Do not remove the following lines, integrals are computed here iALTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg)) nSBTop = iSBTop.getVal()/iALTop.getVal()*setTop.sumEntries(SBcut) nLSBTop = iLSBTop.getVal()/iALTop.getVal()*setTop.sumEntries(LSBcut) nHSBTop = iHSBTop.getVal()/iALTop.getVal()*setTop.sumEntries(HSBcut) nSRTop = iSRTop.getVal()/iALTop.getVal()*setTop.sumEntries(SRcut) drawPlot("JetMass_Top", channel, J_mass, modelTop, setTop, binsJmass, frTop) if VERBOSE: print "********** Fit result [JET MASS TOP] ***"+"*"*40, "\n", frTop.Print(), "\n", "*"*80 #*******************************************************# # # # All bkg normalization # # # #*******************************************************# constVjet.setConstant(True) offsetVjet.setConstant(True) widthVjet.setConstant(True) a0Vjet.setConstant(True) a1Vjet.setConstant(True) a2Vjet.setConstant(True) constVV.setConstant(True) offsetVV.setConstant(True) widthVV.setConstant(True) meanVV.setConstant(True) sigmaVV.setConstant(True) fracVV.setConstant(True) meanVH.setConstant(True) sigmaVH.setConstant(True) fracVH.setConstant(True) constTop.setConstant(True) offsetTop.setConstant(True) widthTop.setConstant(True) meanW.setConstant(True) sigmaW.setConstant(True) fracW.setConstant(True) meanT.setConstant(True) sigmaT.setConstant(True) fracT.setConstant(True) # Final background model by adding the main+secondary pdfs (using 'coef': ratio of the secondary/main, from MC) model = RooAddPdf("model", "model", RooArgList(modelTop, modelVV, modelVjet), RooArgList(coef_Top_VVVjet, coef_VV_Vjet))#FIXME model.fixAddCoefRange("h_reasonable_range") # Extended fit model to data in SB # all the 3 sidebands (Low / High / the 2 combined) could be used # currently using the LOW+HIGH (the others are commented out) yieldLSB = RooRealVar("yieldLSB", "Lower SB normalization", 10, 0., 1.e6) yieldHSB = RooRealVar("yieldHSB", "Higher SB normalization", 10, 0., 1.e6) yieldSB = RooRealVar("yieldSB", "All SB normalization", 10, 0., 1.e6) #model_ext = RooExtendPdf("model_ext", "extended p.d.f", model, yieldLSB) #model_ext = RooExtendPdf("model_ext", "extended p.d.f", model, yieldHSB) model_ext = RooExtendPdf("model_ext", "extended p.d.f", model, yieldSB) #frMass = model_ext.fitTo(setDataSB, RooFit.ConditionalObservables(RooArgSet(J_mass)),RooFit.SumW2Error(True),RooFit.Extended(True),RooFit.Range("LSBrange"),RooFit.PrintLevel(-1)) #frMass = model_ext.fitTo(setDataSB, RooFit.ConditionalObservables(RooArgSet(J_mass)),RooFit.SumW2Error(True),RooFit.Extended(True),RooFit.Range("HSBrange"),RooFit.PrintLevel(-1)) #frMass = model_ext.fitTo(setDataSB, RooFit.ConditionalObservables(RooArgSet(J_mass)), RooFit.SumW2Error(True), RooFit.Extended(True), RooFit.Range("LSBrange,HSBrange"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.PrintLevel(1 if VERBOSE else -1)) #print "********** Fit result [JET MASS DATA] **"+"*"*40 #print frMass.Print() #print "*"*80 # Calculate integral of the model obtained from the fit to data (fraction of PDF that is within a given region) #nSB = model_ext.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange,HSBrange")) #nSB = model_ext.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange")) #nSB = model_ext.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("HSBrange")) #nSR = model_ext.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange")) #nVR = model_ext.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("VRrange")) # scale the yieldSB from SB to SR using the ratio of the PDFs defined by the two integrals SRyield = RooFormulaVar("SRyield", "extrapolation to SR","(@0-@1*@3-@2*@4) * @5/@6 +@1*@7+@2*@8", RooArgList(entrySB, entryVV, entryTop, iSBVV, iSBTop, iSRVjet, iSBVjet, iSRVV, iSRTop)) VRyield = RooFormulaVar("VRyield", "extrapolation to VR","(@0-@1*@3-@2*@4) * @5/@6 +@1*@7+@2*@8", RooArgList(entrySB, entryVV, entryTop, iSBVV, iSBTop, iVRVjet, iSBVjet, iVRVV, iVRTop)) HSByield = RooFormulaVar("SRyield", "extrapolation to SR","(@0-@1*@3-@2*@4) * @5/@6 +@1*@7+@2*@8", RooArgList(entryLSB, entryVV, entryTop, iLSBVV, iLSBTop, iHSBVjet, iLSBVjet, iHSBVV, iHSBTop)) # RooFormulaVar SRyield("SRyield","extrapolation to SR","(@0/@1)*@2",RooArgList(*nSR,*nSB,yieldLowerSB)) # RooFormulaVar SRyield("SRyield","extrapolation to SR","(@0/@1)*@2",RooArgList(*nSR,*nSB,yieldHigherSB)) #SRyield = RooFormulaVar("SRyield", "extrapolation to SR","(@0/@1)*@2", RooArgList(nSR, nSB, entrySB)) bkgYield = SRyield.getVal() bkgYield_error = math.sqrt(SRyield.getPropagatedError(frVjet)**2 + SRyield.getPropagatedError(frVV)**2 + SRyield.getPropagatedError(frTop)**2 + (entrySB.getError()*rSBSRVV)**2) bkgNorm = entrySB.getVal() + SRyield.getVal() + VRyield.getVal() bkgYield_eig_norm = RooRealVar("predSR_eig_norm", "expected yield in SR", bkgYield, 0., 1.e6) bkgYieldExt = HSByield.getVal() drawPlot("JetMass", channel, J_mass, model, setDataSB, binsJmass, None, None, "", bkgNorm, True) print channel, "normalization = %.3f +/- %.3f, observed = %.0f" % (bkgYield, bkgYield_error, setDataSR.sumEntries() if not BLIND else -1) if VERBOSE: raw_input("Press Enter to continue...")