def get_dataset(varargset, ftree, cut="", wt="", scale=1): """Return a dataset. Return a dataset from the ntuple `ftree'. Apply a selection cut using the `cutVar' variable and the selection `cut'. """ from rplot.fixes import ROOT from rplot.tselect import Tsplice splice = Tsplice(ftree) splice.make_splice("sel", cut) from ROOT import RooDataSet, RooFit, RooFormulaVar, RooArgList tmpdst = RooDataSet("tmpdataset", "", varargset, RooFit.Import(ftree)) if wt: wtvar = RooFormulaVar("wt", "{}*@0".format(scale), RooArgList(varargset[wt])) wtvar = tmpdst.addColumn(wtvar) varargset.remove(varargset[wt]) varargset.add(wtvar) dst = RooDataSet("dataset", "Dataset", varargset, RooFit.Import(tmpdst), RooFit.WeightVar(wtvar)) varargset.remove(wtvar) dst = dst.reduce(varargset) return dst
def main(): # setting for reduced DS to be used on the output of makeSubset.C inputfile_name = "small.root" tree_name = "upsTree" # settings for full dataset (long processing time for unbinned lh) #inputfile_name = "/data1/chibdata/collision/v2/2012_AllData_v2.root" #tree_name = "rootuple/upsTree" print "Opening file" inputfile = TFile.Open(inputfile_name, "READ") print "Importing tree" tree = TTree() inputfile.GetObject(tree_name, tree) mass = RooRealVar("ups_mass", "ups_mass", 7, 11) y = RooRealVar("ups_rapidity", "ups_rapidity", -3, 3) pt = RooRealVar("ups_pt", "ups_pt", 0, 100) print "Assigning dataset" dataArgSet = RooArgSet(mass, y, pt) dataSet = RooDataSet("yds", "Y data set", tree, dataArgSet) cuts= "abs(ups_rapidity) < 1.25"+\ "&& ups_pt>9.5"\ reduced_ds = dataSet.reduce(RooFit.Cut(cuts)) print "Performing likelihood analysis" dofit(reduced_ds, "Y3S")
def predict(self, x, theta_true): """ Run the unbinned ML fit """ # Data roodata = RooDataSet('data', 'data', RooArgSet(self.phistar)) for xval in x: self.phistar.setVal(xval) roodata.add(RooArgSet(self.phistar)) theta = RooRealVar('theta', 'theta', 0.5, self.theta_min, self.theta_max) # The combined pdf model = RooAddPdf('model', 'model', RooArgList(self.pdfs['A'], self.pdfs['H']), RooArgList(theta)) with stdout_redirected_to('%s/minuit_output.log' % self.outdir): res = model.fitTo(roodata, Save(True)) nll = res.minNll() fitted_theta = theta.getValV() # Get Lambda(theta_true | theta_best) with stdout_redirected_to(): logl = model.createNLL(roodata) theta.setVal(theta_true) nll_theta_true = logl.getValV() nll_ratio = nll_theta_true - nll return fitted_theta, nll, nll_ratio
def 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 RooFitSig(mbbarray, bdtarray, weightarray, TC_mass, binstart, binend): fitstart = 40 fitend = 150 mbbarray = range(200) bdtarray = range(200) weightarray = range(200) mass = RooRealVar("X", "m(bb)[GeV]", fitstart, fitend) BDT = RooRealVar("BDT", "BDT", -1, 100) weight = RooRealVar("weight", "weight", -100, 200) branchnames = ["X", "BDT", "weight"] dtype = np.dtype([(branchnames[idx], np.float64) for idx in range(len(branchnames))]) treearray = np.array([(mbbarray[idx], bdtarray[idx], weightarray[idx]) for idx in range(len(mbbarray))], dtype) tree = rnp.array2tree(treearray) m0 = RooRealVar("m0", "m0", TC_mass * 1., TC_mass * 1. - 60., TC_mass * 1. + 60.) m02 = RooRealVar("m02", "m02", TC_mass * 1., TC_mass * 1. - 60., TC_mass * 1. + 60.) alpha = RooRealVar("alpha", "alpha", 1.295, 1.0, 1.6) sigma2 = RooRealVar("sigma2", "sigma2", 35, 8., 100) n = RooRealVar("n", "n", 5, 1, 35) mean = RooRealVar("mean", "mean of gaussian", 750, 0, 6000) sigma = RooRealVar("sigma", "width of gaussian", 90, 38, 300) gauss = RooGaussian("gauss", "gaussian PDF", mass, m0, sigma) gauss2 = RooGaussian("gauss2", "gaussian PDF", mass, m02, sigma2) CBshape = RooCBShape("CBshape", "Crystal Ball PDF", mass, m0, sigma2, alpha, n) ##PDF normalization num1 = RooRealVar("num1", "number of events", 400, 0, 5000) ##relative weight of 2 PDFs f = RooRealVar("f", "f", 0.95, 0.6, 1) sigPdf = RooAddPdf("sigPdf", "Signal PDF", RooArgList(CBshape, gauss), RooArgList(f)) extPdf = RooExtendPdf("extPdf", "extPdf", sigPdf, num1) data = RooDataSet("data", "data", tree, RooArgSet(mass, BDT, weight), "BDT>0", "weight") xframe = mass.frame() mass.setBins(20) data.plotOn(xframe) extPdf.plotOn( xframe) #,Normalization(1.0,RooAbsReal.RelativeExpected),LineColor(1)) hist = extPdf.createHistogram("X", fitend - fitstart) hist.SetAxisRange(binstart, binend) return deepcopy(hist)
def fillDataSet(data, x, N, dsName='ds'): cols = RooArgSet(x) ds = RooDataSet(dsName, dsName, cols) #ds.Print() print 'length data:', N for datum in range(0, N): if (data[datum] < x.getMax()) and (data[datum] > x.getMin()): x.setVal(data[datum]) ds.add(cols) ds.Print() return ds
def main(): inputfile_name = "/data1/chibdata/collision/v2/2012_AllData_v2.root" chibTree_name = "rootuple/chibTree" print "Opening file" inputfile = TFile.Open(inputfile_name, "READ") print "Importing tree" tree = TTree() inputfile.GetObject(chibTree_name, tree) invm1S = RooRealVar("invm1S", "invm1S", 9.5, 11.5) invm2S = RooRealVar("invm2S", "invm2S", 9.5, 20.0) invm3S = RooRealVar("invm3S", "invm3S", 9.5, 20.0) 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", -50.0, 50.0) print "Assigning argset" dataArgSet = RooArgSet(invm1S, invm2S, invm3S, dimuon_mass, dimuon_rapidity, dimuon_pt, photon_eta, photon_pt, ctpv) dataArgSet.add(ctpv_error) dataArgSet.add(pi0_abs_mass) dataArgSet.add(Y1S_nsigma) dataArgSet.add(Y2S_nsigma) dataArgSet.add(Y3S_nsigma) dataArgSet.add(conv_vertex) dataArgSet.add(dz) print "Creating DataSet" dataSet = RooDataSet("chibds", "Chib RooDataSet", tree, dataArgSet) # Selection cuts = "photon_pt > 0.0" + \ "&&dimuon_pt > 9.5" \ "&& abs(photon_eta) < 1.4" + \ "&& abs(dimuon_rapidity) < 1.25 " + \ "&& Y3S_nsigma < 2.5 " + \ "&& abs(dz) < 0.1" rds_cutted = dataSet.reduce(RooFit.Cut(cuts)) dofit(rds_cutted, "Chib_fit_2012_3S")
def fillDataSet(data, x, N, dsName = 'ds'): cols = RooArgSet(x) ds = RooDataSet(dsName, dsName, cols) #ds.Print() print 'length data:', N for datum in range(0,N): if (data[datum] < x.getMax()) and (data[datum] > x.getMin()): x.setVal(data[datum]) ds.add(cols) ds.Print() return ds
def main() : inputfile_name = "/data1/chibdata/collision/v2/2012_AllData_v2.root" chibTree_name = "rootuple/chibTree" print "Opening file" inputfile = TFile.Open(inputfile_name,"READ") print "Importing tree" tree = TTree() inputfile.GetObject(chibTree_name, tree) invm1S = RooRealVar("invm1S", "invm1S", 9.5, 11.5) invm2S = RooRealVar("invm2S", "invm2S", 9.5, 20.0) invm3S = RooRealVar("invm3S", "invm3S", 9.5, 20.0) 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", -50.0, 50.0) print "Assigning argset" dataArgSet = RooArgSet(invm1S, invm2S, invm3S, dimuon_mass, dimuon_rapidity, dimuon_pt, photon_eta, photon_pt, ctpv) dataArgSet.add( ctpv_error ) dataArgSet.add( pi0_abs_mass ) dataArgSet.add( Y1S_nsigma ) dataArgSet.add( Y2S_nsigma ) dataArgSet.add( Y3S_nsigma ) dataArgSet.add( conv_vertex ) dataArgSet.add( dz ) print "Creating DataSet" dataSet = RooDataSet("chibds","Chib RooDataSet", tree, dataArgSet) # Selection cuts = "photon_pt > 0.0" + \ "&&dimuon_pt > 9.5" \ "&& abs(photon_eta) < 1.4" + \ "&& abs(dimuon_rapidity) < 1.25 " + \ "&& Y3S_nsigma < 2.5 " + \ "&& abs(dz) < 0.1" rds_cutted = dataSet.reduce( RooFit.Cut(cuts) ) dofit(rds_cutted, "Chib_fit_2012_3S")
class MLFit : def __init__(self, plot_dire, condition): self.plot_dire = plot_dire self.condition = condition self.mjj = RooRealVar("ZJJMass", "ZJJMass", 50., 7000.) #self.costhetastar = RooRealVar("costhetastar", "costhetastar", -1., 1.) self.weight = RooRealVar("weight", "weight", -100., 100.) self.isSignal = RooCategory("isSignal", "isSignal") self.isSignal.defineType("signal", 1); self.isSignal.defineType("background", 0); self.ras = RooArgSet(self.mjj, self.weight) self.ds = RooDataSet("ds"+condition, "ds"+condition, self.ras, "weight") #self.mu = RooRealVar("mu", "mu", 90., 80., 100.) #self.widthL = RooRealVar("widthL", "widthL", 15., 2., 30.) #self.widthR = RooRealVar("widthR", "widthR", 4., 2., 15.) #self.sigmass = RooBifurGauss("bifurgauss", "bifurgauss", self.mjj, self.mu, self.widthL, self.widthR) self.c0 = RooRealVar("c0", "c0", -100., 100.) self.bkgmass = RooExponential("expo", "expo", self.mjj, self.c0) #self.nsig = RooRealVar("nsig", "nsig", 100, 0, 200) #self.nbkg = RooRealVar("nbkg", "nbkg", 100, 0, 200) #self.components = RooArgList(self.sigmass, self.bkgmass) #self.coefficients = RooArgList(self.nsig, self.nbkg) self.modelmass = self.bkgmass #RooAddPdf("massmodel", "massmodel", self.components, self.coefficients) def addToDataset(self, event, isSignal): if not eval(self.condition): return self.mjj = event.ZJJMass print self.mjj #self.costhetastar = event.costhetastar self.weight = event.weight #self.isSignal = isSignal self.ds.fill() def fit(self): print "nentries", self.ds.numEntries() #for i in range(self.ds.numEntries()): # argset = self.ds.get(i) # argset.Dump() fitresult = self.modelmass.fitTo(self.ds, RooFit.Save(True), RooFit.Extended(), RooFit.PrintLevel(3), RooFit.Strategy(2)) #, RooFit.SumW2Error(True))
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 roofit_poisson_unbinned(data): """returns lambda, error of lambda""" x = RooRealVar('x', 'x', 0, max(data) * 10) lam = RooRealVar('lambda', 'lambda', 0.1, 0.000001, max(data)) model = RooPoisson('model', 'model', x, lam) dataset = RooDataSet('data', 'data', RooArgSet(x)) for val in data: x.setVal(val) dataset.add(RooArgSet(x)) model.fitTo(dataset, RooFit.Save(), RooFit.PrintLevel(-1)) return lam.getVal(), lam.getError()
def __init__(self, plot_dire, condition): self.plot_dire = plot_dire self.condition = condition self.mjj = RooRealVar("ZJJMass", "ZJJMass", 50., 7000.) #self.costhetastar = RooRealVar("costhetastar", "costhetastar", -1., 1.) self.weight = RooRealVar("weight", "weight", -100., 100.) self.isSignal = RooCategory("isSignal", "isSignal") self.isSignal.defineType("signal", 1); self.isSignal.defineType("background", 0); self.ras = RooArgSet(self.mjj, self.weight) self.ds = RooDataSet("ds"+condition, "ds"+condition, self.ras, "weight") #self.mu = RooRealVar("mu", "mu", 90., 80., 100.) #self.widthL = RooRealVar("widthL", "widthL", 15., 2., 30.) #self.widthR = RooRealVar("widthR", "widthR", 4., 2., 15.) #self.sigmass = RooBifurGauss("bifurgauss", "bifurgauss", self.mjj, self.mu, self.widthL, self.widthR) self.c0 = RooRealVar("c0", "c0", -100., 100.) self.bkgmass = RooExponential("expo", "expo", self.mjj, self.c0) #self.nsig = RooRealVar("nsig", "nsig", 100, 0, 200) #self.nbkg = RooRealVar("nbkg", "nbkg", 100, 0, 200) #self.components = RooArgList(self.sigmass, self.bkgmass) #self.coefficients = RooArgList(self.nsig, self.nbkg) self.modelmass = self.bkgmass #RooAddPdf("massmodel", "massmodel", self.components, self.coefficients)
def createDataSet(self, dname, dcut): """Create named dataset""" if dname in self.dataset.keys(): return self.dataset[dname] data = RooDataSet(dname, "", self.ch, self.argset, dcut) self.dataset[dname] = data return data
def addAsciiData(self, ws, ds_name, item_title, var_set_name, var_set_type, ds_file_name, weight_var_name=None, debug=0, sets=None): legend = '[exostConfig::addAsciiData]:' arg_set = RooArgSet() if (var_set_type == 'set'): #_var_set = ws.set(var_set_name) _var_set = sets[var_set_name] arg_set.add(_var_set) if _var_set.getSize() != 1: print legend, 'Error: too many or too few columns in the input ASCII file' print legend, 'Error: Smart program as I am, I can only handle ASCII files' print legend, 'Error: with exactly one column at the moment.' print legend, 'Error: Support for multiple columns will be implemented' print legend, 'Error: eventually, contact the developers.' print legend, 'Error: Better yet, switch to ROOT input files,' print legend, 'Error: all the cool kids are doing that!' return -1 elif (var_set_type == 'var'): arg_set.add(ws.var(var_set_name)) else: print legend, 'error: unknown var_set_type, cannot create dataset', ds_name return -1 #create the dataset if weight_var_name == None: #no weight if (debug > 0): print legend, 'no weight variable given' _arglist = RooArgList(arg_set) #ds = RooDataSet()ds_name, item_title) ds = RooDataSet.read(ds_file_name, _arglist) ds.SetName(ds_name) ds.SetTitle(item_title) else: if (debug > 0): print legend, 'using variable', weight_var_name, 'as weight' print legend, 'Error: Smart program as I am, I cannot handle' print legend, 'Error: weights when loading from ASCII files yet.' print legend, 'Error: Support for weights from ASCII files will' print legend, 'Error: be implemented eventually, contact the developers.' print legend, 'Error: Better yet, switch to ROOT input files,' print legend, 'Error: all the cool kids are doing that!' return -1 # import the datahist. Note workaround 'import' being a reserved word getattr(ws, 'import')(ds)
def get_dataset(varargset, ftree, cut='', cutVars=[], *cmdArgs): """Return a dataset. Return a dataset from the ntuple `ftree'. Apply a selection cut using the `cutVar' variable and the selection `cut'. """ varargsetclone = varargset.clone('varargsetclone') for cvar in cutVars: varargsetclone.add(cvar) # Add selVar to apply cut tmpdataset = RooDataSet('dataset', 'Dataset', varargsetclone, RooFit.Import(ftree), RooFit.Cut(cut), *cmdArgs) dataset = tmpdataset.reduce(varargset) del tmpdataset return dataset
def predict(self, x, theta_true): """ Run an unbinned ML fit to make predictions """ # Create RooDataSet xs = self.scaler.transform(x) preds = self.model.predict(xs)[:, 1] min_nn_output_local, max_nn_output_local = np.min(preds), np.max(preds) if min_nn_output_local < self.min_nn_output: self.min_nn_output = min_nn_output_local if max_nn_output_local > self.max_nn_output: self.max_nn_output = max_nn_output_local roodata = RooDataSet('data', 'data', RooArgSet(self.roopred)) for pred in preds: self.roopred.setVal(pred) roodata.add(RooArgSet(self.roopred)) # Fit theta = RooRealVar('theta', 'theta', 0.5, self.theta_min, self.theta_max) model = RooAddPdf('model', 'model', RooArgList(self.pdfs['A'], self.pdfs['H']), RooArgList(theta)) with stdout_redirected_to('%s/minuit_output.log' % self.outdir): res = model.fitTo(roodata, Save(True)) nll = res.minNll() fitstatus = res.status() fitstatus |= (not subprocess.call(['grep', 'p.d.f value is less than zero', 'output_MLE_unbinned/minuit_output.log'])) fitted_theta = theta.getValV() # Get Lambda(theta_true | theta_best) logl = model.createNLL(roodata) theta.setVal(theta_true) nll_theta_true = logl.getValV() nll_ratio = nll_theta_true - nll return fitted_theta, nll, nll_ratio, fitstatus
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 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 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 make_weighted_dataset(subproc,ws,tree,mc_events): data = RooDataSet('%s_shape_data'%subproc, 'M_{ll#gamma} Shape Data for %s'%subproc, tree, ws.set('vars_with_weights') ) mc_yield_var = RooConstVar('temp','temp',mc_events) weighter = RooFormulaVar('weight','weight','@0*@1/@2', RooArgList( ws.var('procWeight'), ws.var('puWeight'), mc_yield_var ) ) data.addColumn(weighter) data_total_weight = RooDataSet('%s_shape_data'%subproc, 'M_{ll#gamma} Shape Data for %s'%subproc, data, ws.set('vars_with_weights_final'), '','weight') data_pu_weight = RooDataSet('%s_shape_data_puonly'%subproc, 'M_{ll#gamma} Shape Data for %s'%subproc, data, ws.set('vars_with_weights_final'), '','puWeight') return data_total_weight, data_pu_weight
def get_dataset(varargset, ftree, cut='', wt='', scale=1): """Return a dataset. Return a dataset from the ntuple `ftree'. Apply a selection cut using the `cutVar' variable and the selection `cut'. """ from rplot.fixes import ROOT from rplot.tselect import Tsplice splice = Tsplice(ftree) splice.make_splice('sel', cut) from ROOT import RooDataSet, RooFit, RooFormulaVar, RooArgList tmpdst = RooDataSet('tmpdataset', '', varargset, RooFit.Import(ftree)) if wt: wtvar = RooFormulaVar('wt', '{}*@0'.format(scale), RooArgList(varargset[wt])) wtvar = tmpdst.addColumn(wtvar) varargset.remove(varargset[wt]) varargset.add(wtvar) dst = RooDataSet('dataset', 'Dataset', varargset, RooFit.Import(tmpdst), RooFit.WeightVar(wtvar)) varargset.remove(wtvar) dst = dst.reduce(varargset) return dst
def fill_dataset(varargset, ftree, wt, wtvar, cut=""): """Return a dataset (slow, get_dataset is more efficient). Return a dataset from the ntuple `ftree', also apply `cut'. Use `wt' as the weight expression in the tree. `wtvar' is the corresponding RooRealVar weight. Note, varargset should contain wtvar. The dataset is filled by iterating over the tree. This is needed when you want to ensure different datasets have the same weight variable names, so that they can be combined later on. This is needed even if they are combined as different categories. """ from rplot.fixes import ROOT from ROOT import RooDataSet, RooFit, TTreeFormula from helpers import suppress_warnings suppress_warnings() from rplot.tselect import Tsplice splice = Tsplice(ftree) splice.make_splice("sel", cut) formulae = {} wtname = wtvar.GetName() for var in varargset: name = var.GetName() expr = wt if name == wtname else name formulae[name] = TTreeFormula(name, expr, ftree) dataset = RooDataSet("dataset", "Dataset", varargset, RooFit.WeightVar(wtvar)) for i in xrange(ftree.GetEntries()): ftree.GetEntry(i) for var, expr in formulae.iteritems(): realvar = varargset.find(var) realvar.setVal(expr.EvalInstance()) dataset.add(varargset, varargset[wtname].getVal()) 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 CreateSimData(w, typ): sim_dsets = [] for c in range(w.cat("cat").numTypes()): w.cat("cat").setIndex(c) samp = w.cat("cat").getLabel() name = "%s_sim_data" % typ if c == 0 else "%s_sim_data%d" % (typ, c) sim_dsets.append( RooDataSet(name, "", RooArgSet(w.var("B_DTFDict_D0_B_M")), rf.Index(w.cat("cat")), rf.Import(samp, w.data("%s_%s" % (typ, samp))))) if c != 0: sim_dsets[0].append(sim_dsets[c]) getattr(w, 'import')(sim_dsets[0])
def dump_simple(): # try poisson roo_lam = RooRealVar("lambda", ".", lam, 0.0, 1.5) roo_x = RooRealVar('x', 'x range', 0, bins) model = RooPoisson("poisson", "Poisson Model", roo_x, roo_lam) #data = model.generate(RooArgSet(roo_x), n_events) data = RooDataSet('data', 'Data', RooArgSet(roo_x)) for val in unbinned_from_binned(xdata, ydata): roo_x.setVal(val) data.add(RooArgSet(roo_x)) #// --- Perform extended ML fit of composite PDF to toy data --- fitresult = model.fitTo(data, RooFit.Save(), RooFit.PrintLevel(-1)) ; #// --- Plot toy data and composite PDF overlaid --- mesframe = roo_x.frame(bins) ; data.plotOn(mesframe) ; model.plotOn(mesframe) ; mesframe.Draw()
def fill_dataset(varargset, ftree, wt, wtvar, cut=''): """Return a dataset (slow, get_dataset is more efficient). Return a dataset from the ntuple `ftree', also apply `cut'. Use `wt' as the weight expression in the tree. `wtvar' is the corresponding RooRealVar weight. Note, varargset should contain wtvar. The dataset is filled by iterating over the tree. This is needed when you want to ensure different datasets have the same weight variable names, so that they can be combined later on. This is needed even if they are combined as different categories. """ from rplot.fixes import ROOT from ROOT import RooDataSet, RooFit, TTreeFormula from helpers import suppress_warnings suppress_warnings() from rplot.tselect import Tsplice splice = Tsplice(ftree) splice.make_splice('sel', cut) formulae = {} wtname = wtvar.GetName() for var in varargset: name = var.GetName() expr = wt if name == wtname else name formulae[name] = TTreeFormula(name, expr, ftree) dataset = RooDataSet('dataset', 'Dataset', varargset, RooFit.WeightVar(wtvar)) for i in xrange(ftree.GetEntries()): ftree.GetEntry(i) for var, expr in formulae.iteritems(): realvar = varargset.find(var) realvar.setVal(expr.EvalInstance()) dataset.add(varargset, varargset[wtname].getVal()) return dataset
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 gendata(filename, q2Bin, nSample): time_start = time.time() obs = getobs() file = TFile.Open(filename) if not file: print('File not found: ', filename) return wspname = 'ws_b{}p0'.format(q2Bin) wsp = file.Get(wspname) if not wsp: print('Workspace not found in file: ', filename) return ctK = wsp.var('ctK') ctL = wsp.var('ctL') phi = wsp.var('phi') rand = wsp.var("rand") if (not ctK) or (not ctL) or (not phi): print('Variables not found in file: ', filename) return vars = RooArgList(ctK, ctL, phi) datasetname = 'data_genDen_ev_b{}'.format(q2Bin) fullData = wsp.data(datasetname) if not fullData: print('DataSet ', datasetname, ' not found in file: ', filename) return data = RooDataSet() if nSample == 0: data = fullData elif nSample <= 10000: data = fullData.reduce( RooArgSet(vars), 'rand > {:1.6f} && rand < {:1.6f}'.format( (nSample - 1) * dataStat[q2Bin] / genStat[q2Bin], nSample * dataStat[q2Bin] / genStat[q2Bin])) else: data = fullData.reduce( RooArgSet(vars), 'rand > {:.6f} && rand < {:.6f}'.format( (nSample % 10000 - 1) * d16Stat[q2Bin] / genStat[q2Bin], (nSample % 10000) * d16Stat[q2Bin] / genStat[q2Bin])) print('Fit ', data.numEntries(), ' events') ###convert the final dataset to pd.dataframe datalist = [] for i in range(0, data.numEntries()): ctKvalue = data.get(i).getRealValue('ctK') ctLvalue = data.get(i).getRealValue('ctL') phivalue = data.get(i).getRealValue('phi') datalist.append([ctKvalue, ctLvalue, phivalue]) #print ('lenth of datalist ', len(datalist)) finaldata_df = pd.DataFrame(datalist, columns=['costk', 'costl', 'phi']) finaldata = zfit.Data.from_pandas(finaldata_df, obs=obs) print('generate zfit data from RooDataSet successfully') time_end = time.time() time_c = time_end - time_start print('time used in fit data import: ', time_c, 's') return finaldata
def extract_data_in_categories(channel,input_file,ws): pwd = gDirectory.GetPath() fin = TFile.Open(input_file,'read') gDirectory.cd(pwd) tree = fin.Get('selected_zg') data = RooDataSet('%s_data'%channel, 'real data %s channel'%channel, tree, ws.set('vars') ) data_in_ws = ws.data('%s_data'%channel) if not not data_in_ws: data_in_ws.append(data) else: getattr(ws,'import')(data)
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 createDataSet(self, dname, dcut): """Return named dataset, create if not exist""" if dname in self.dataset.keys() and not self.process.cfg['args'].force: self.logger.logINFO("\033[0;34;47m Dataset: ", dname, " Already Exists! \033[0m. Total Entries:", self.dataset[dname].sumEntries()) self.logger.logDEBUG(dcut, Stamp=False) return 1 tempfile_preload = ROOT.TFile(tempfile.gettempdir() + "/temp.root", 'RECREATE') #Pritam RooCut = ROOT.RooFit.Cut(dcut) Import = ROOT.RooFit.Import(self.ch) Range = ROOT.RooFit.CutRange( dname.split(".")[2]) # Not taking effect, need review Weight = ROOT.RooFit.WeightVar(self.cfg['weight']) if self.argset.find("Bmass"): self.argset.find( "Bmass").removeRange() # Analysis specific line introduced if "dataReader" in dname or "sigMCGENReader" in dname: data = RooDataSet(dname, "", self.argset, Import, RooCut, Range) else: data = RooDataSet(dname, "Weighted dataset", self.argset, Import, RooCut, Range, Weight) if self.argset.find("Phimass"): self.argset.find("Phimass").setBins(20) datahist = ROOT.RooDataHist( dname + ".hist", "", ROOT.RooArgSet(self.argset.find("Phimass")), data) self.dataset[dname + ".hist"] = deepcopy(datahist) data.Write() self.dataset[dname] = deepcopy(data) self.logger.logINFO("\033[0;34;47m Creating Dataset: ", dname, ": \033[0m. Total Entries:", data.sumEntries()) self.logger.logDEBUG(dcut, Stamp=False) tempfile_preload.Close() #Pritam return 1
pvz_pdf = Pdf(Name = 'pvz_pdf', Type = Gaussian, Parameters = (pvz, pvz_mean, pvz_sigma)) from ROOT import TFile pv_file = TFile("/stuff/PhD/p2vv/data/pv_data.root") pv_data = pv_file.Get("pv_data") tp_gen = TPGen('tp_gen', TurningPoints = tps, PVZ = pvz, PVZPdf = pvz_pdf, nPVs = pv_data.get().find('nPVs'), Data = pv_data) tp_gen.setDistance(2) tp_gen.setSmearing(3) tp_gen.setDebug(options.debug) ## tp_decay = TPDecay('tp_decay', TPGen = tp_gen, Time = t, Tau = tau, ResolutionModel = tres) from ROOT import RooDataSet, RooPullVar tau_result = RealVar("tau_result", MinMax = (0.1, 4)) result_data = RooDataSet("result_data", "result_data", RooArgSet(tau_result)) # Make a dummy histogram to fitOpts = dict(NumCPU = 1, Timer = 1, Save = True, Minimizer = 'Minuit2', Optimize = 2, Offset = True, Strategy = 2) from ROOT import RooDecay if swimming: sig_t = Pdf(Name = 'sig_t', Type = RooDecay, Parameters = (t, tau, tres, 'SingleSided')) sig_t.setNormRange(','.join(b for b in binnings)) else: # Make an exponential binning def next_bin(prev_bin, tau, n_bins, min_bin, max_bin): from math import e, log a = e ** (- min_bin / tau) - e ** (- max_bin / tau) return - tau * log(e ** (- prev_bin / tau) - a / n_bins)
print 'P2VV - INFO: generateFromFile(): prototype data:' protoData.Print() # read input data inputFile = TFile.Open(args.inputFile) assert inputFile inNTuples = dict( [ ( state, ( inputFile.Get( '%s_%s' % ( args.inputNTupleName , '_'.join( '%s%d' % ( cat, st ) for cat, st in zip( splitCats, state ) ) ) ), [ ] ) )\ for state in states ] ) print 'P2VV - INFO: generateFromFile(): numbers of input events:' for state in states : print ' %s: %7d' % ( state, inNTuples[state][0].GetEntries() ) # create output dataset from ROOT import RooDataSet outputData = RooDataSet( args.protoDataName, args.protoDataName, protoSet ) # draw events from input datasets and combine with proto data import sys import P2VV.RooFitWrappers from ROOT import TRandom3 randGen = TRandom3(args.jobID) for pEvIt, pSet in enumerate(protoData) : if pEvIt % 10000 == 0 : print 'P2VV - INFO: generateFromFile(): processing event %d' % pEvIt sys.stdout.flush() # get state of conditional observables in proto data state = [ ] for cat in splitCats : if splitPars[cat][0] == 'cat' :
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 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()
dataset.SetNameTitle(name_title, name_title) print '%s is weighted: %s' % (dataset.GetName(), dataset.isWeighted()) dsetlist += [dataset] decaycat = RooCategory('decaycat', 'Decay mode category') decaycat.defineType('DsPi') decaycat.defineType('DsK') varlist += [decaycat] for idx, mode in enumerate(['DsPi', 'DsK']): decaycat.setLabel(mode) dsetlist[idx].addColumn(decaycat) dataset = RooDataSet('dataset', 'Combined dataset (DsK + DsPi)', RooArgSet(time, decaycat), RooFit.Import(dsetlist[0])) dataset.append(dsetlist[1]) for dset in dsetlist: dset.Print() dataset.Print() ## Basic B decay pdf with time resolution # Resolution model mean = RooRealVar('mean', 'Mean', 0.) # scale = RooRealVar('scale', 'Per-event time error scale factor', 1.19) resmodel = RooGaussModel('resmodel', 'Time resolution model', time, mean, RooRealConstant.value(0.044), RooRealConstant.value(1.0), RooRealConstant.value(1.0))
# DAS_EX_2.1 # Define a RooRealVar object for the ST variable st = RooRealVar("st", "st", ranges["fit","lo"], ranges["fit","hi"]) ############################################ # Get data and models ############################################ # print "Reading Files" # DAS_EX_2.2 # Read data from file into RooDataSet using the RooDataSet.read() method. #rdata = RooDataSet.add(files["dat"], RooArgList(st)) rdata = RooDataSet.read(files["dat"], RooArgList(st)) ################################### # Set up fit PDFs with information # from fitFuncs dictionary ################################### # Declare a few dictionaries pdfs = {}; pars = {}; aset = {} for func in ["f2", "f1", "f3"]: # DAS_EX_2.3 # Define and initialize (with your ST RooRealVar) a RooArgSet for use in the pdf # We need one RooArgSet for each function, so store in python dictionary indexed # by "func" string:
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)
def rooFit207(): print ">>> setup model signal components: gaussians..." x = RooRealVar("x","x",0,10) mean = RooRealVar("mean","mean of gaussians",5) sigma = RooRealVar("sigma","width of gaussians",0.5) sig = RooGaussian("sig","Signal",x,mean,sigma) print ">>> setup model background components: Chebychev polynomial plus exponential..." a0 = RooRealVar("a0","a0",0.5,0.,1.) a1 = RooRealVar("a1","a1",-0.2,0.,1.) bkg1 = RooChebychev("bkg1","Background 1",x,RooArgList(a0,a1)) alpha = RooRealVar("alpha","alpha",-1) bkg2 = RooExponential("bkg2","Background 2",x,alpha) bkg1frac = RooRealVar("bkg1frac","fraction of component 1 in background",0.2,0.,1.) bkg = RooAddPdf("bkg","Signal",RooArgList(bkg1,bkg2),RooArgList(bkg1frac)) print ">>> sum signal and background component..." bkgfrac = RooRealVar("bkgfrac","fraction of background",0.5,0.,1.) model = RooAddPdf("model","g1+g2+a",RooArgList(bkg,sig),RooArgList(bkgfrac)) # Create dummy dataset that has more observables than the above pdf y = RooRealVar("y","y",-10,10) data = RooDataSet("data","data",RooArgSet(x,y)) # Basic information requests:" print ">>> get list of observables of pdf in context of a dataset..." # Observables are define each context as the variables # shared between a model and a dataset. In this case # that is the variable 'x' model_obs = model.getObservables(data) # RooArgSet model_obs.Print('v') print "\n>>> get list of parameters..." # Get list of parameters, given list of observables model_params = model.getParameters(RooArgSet(x)) # RooArgSet print ">>> model_params.getStringValue(\"a0\") = %s" % (model_params.getStringValue("a0")) print ">>> model_params.getRealValue(\"a0\") = %s" % (model_params.getRealValue("a0")) print ">>> model_params.find(\"a0\").GetName() = %s" % (model_params.find("a0").GetName()) print ">>> model_params.find(\"a0\").getVal() = %s" % (model_params.find("a0").getVal()) # print ">>> for param in model_params:" # for param in model_params.(): # print ">>> %s"%(model_params.first()) # print ">>> %s"%(model_params.first()) # model_params.selectByName("a*").Print('v') model_params.Print('v') print "\n>>> get list of parameters of a dataset..." # Gives identical results to operation above model_params2 = model.getParameters(data) # RooArgSet model_params2.Print() print "\n>>> get list of components..." # Get list of component objects, including top-level node model_comps = model.getComponents() # RooArgSet model_comps.Print('v') print "\n>>> modifications to structure of composites..." sigma2 = RooRealVar("sigma2","width of gaussians",1) sig2 = RooGaussian("sig2","Signal component 1",x,mean,sigma2) sig1frac = RooRealVar("sig1frac","fraction of component 1 in signal",0.8,0.,1.) sigsum = RooAddPdf("sigsum","sig+sig2",RooArgList(sig,sig2),RooArgList(sig1frac)) print ">>> construct a customizer utility to customize model..." cust = RooCustomizer(model,"cust") print ">>> instruct the customizer to replace node 'sig' with node 'sigsum'..." cust.replaceArg(sig,sigsum) # Build a clone of the input pdf according to the above customization # instructions. Each node that requires modified is clone so that the # original pdf remained untouched. The name of each cloned node is that # of the original node suffixed by the name of the customizer object # # The returned head node own all nodes that were cloned as part of # the build process so when cust_clone is deleted so will all other # nodes that were created in the process. cust_clone = cust.build(kTRUE) # RooAbsPdf # Print structure of clone of model with sig->sigsum replacement. cust_clone.Print("t") # delete clone del cust_clone
runPeriod.defineType('p2011', 2011) runPeriod.defineType('p2012', 2012) from ROOT import TFile if args[0].startswith('MC'): from ROOT import TFile sig_file = TFile(input_data['sig_cache']) sig_data = sig_file.Get(input_data['sig_dataset']) prompt_file = TFile(input_data['prompt_cache']) prompt_data = prompt_file.Get(input_data['prompt_dataset']) else: sig_file = TFile("/project/bfys/jleerdam/data/Bs2Jpsiphi/Reco14/fitNTuple_peakBkg_2011_2012_Reco14_TOS_HLT2B_20140415.root") sig_tree = sig_file.Get("DecayTree") period = 'p' + args[0][:4] sig_data = RooDataSet('sig_data', 'sig_data', RooArgSet(momentum, weight, runPeriod), RooFit.Import(sig_tree), RooFit.WeightVar(weight), RooFit.Cut('runPeriod == runPeriod::%s' % period)) from ROOT import TFile prompt_file = TFile(input_data['cache']) prompt_data = prompt_file.Get(input_data['dataset']) from ROOT import TCanvas canvas = TCanvas('momentum_canvas', 'momentum_canvas', 600, 400) canvas.SetLogy() frame = momentum.frame(Range = (0, 500000)) from ROOT import kBlue, kGreen sig_data.plotOn(frame, Rescale = (1 / sig_data.sumEntries()), MarkerColor = kBlue) prompt_data.plotOn(frame, Rescale = (1 / prompt_data.sumEntries()), MarkerColor = kGreen) frame.GetXaxis().SetTitle("P_{B} [MeV]")
obsSet.add(wVar) import os, subprocess, tempfile tmp = tempfile.NamedTemporaryFile() tmpFileName = os.path.realpath(tmp.name) tmp.close() from ROOT import RooDataSet, TObject, gROOT nEvTot = 0 nEvDS = nTupleIn.GetEntries() / numDataSets for it in range(numDataSets) : startEv = it * nEvDS nEv = nEvDS if it < numDataSets - 1 else nTupleIn.GetEntries() - ( numDataSets - 1 ) * nEvDS tmpFile = TFile.Open( tmpFileName, 'RECREATE' ) nTupleSplit = nTupleIn.CopyTree( selection, '', nEv, startEv ) if weightName : dataOut = RooDataSet( protoData.GetName(), protoData.GetTitle(), obsSet, Import = nTupleSplit, WeightVar = ( weightName, True ) ) else : dataOut = RooDataSet( protoData.GetName(), protoData.GetTitle(), obsSet, Import = nTupleSplit ) tmpFile.Close() print 'produced dataset:' dataOut.Print() nEvTot += dataOut.numEntries() dataFileOut = TFile.Open( dataFilePathOut % it, 'RECREATE' ) dataFileOut.Append(dataOut) dataFileOut.Write( dataFilePathOut % it, TObject.kOverwrite ) dataFileOut.Close() os.remove(tmpFileName) print 'total number of events: %d' % nEvTot
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()
fitfunc.SetParName(3,"Tail Z") fitfunc.SetParName(4,"Tail length") w = RooWorkspace("w") w.factory("{0}[0,0.1]".format("uncM")) w.factory("uncVZ[-100,100]") w.factory("uncP[0,10]") w.factory("cut[0,1]") w.defineSet("myVars","{0},uncVZ".format("uncM")) events = infile.Get("cut") #eventsrad = radfile.Get("ntuple") eventsprompt = promptfile.Get("cut") dataset = RooDataSet("data","data",events,w.set("myVars"),"") w.factory("Gaussian::vtx_model(uncVZ,mean[-50,50],sigma[0,50])") gauss_pdf = w.pdf("vtx_model") w.factory("EXPR::gaussExp('exp( ((@0-@1)<@3)*(-0.5*(@0-@1)^2/@2^2) + ((@0-@1)>=@3)*(-0.5*@3^2/@2^2-(@0-@1-@3)/@4))',uncVZ,gauss_mean[-5,-20,20],gauss_sigma[5,1,50],exp_breakpoint[10,0,50],exp_length[3,0.5,20])") gaussexp_pdf = w.pdf("gaussExp") w.defineSet("obs_1d","uncVZ") obs=w.set("obs_1d") uncVZ = w.var("uncVZ") uncVZ.setBins(200) gauss_params = gauss_pdf.getParameters(obs) gaussexp_params = gaussexp_pdf.getParameters(obs) Medges = array.array('d') Epsedges = array.array('d') for i in range(0,nApMass+1):
def prepare_truth_models(ws,cat,mass,channel,turnon,truth): if channel in study_inputs: bkg_data = RooDataSet("bkgdata_%s"%(channel), "M_{ll#gamma} with Errors", ws.set("observables_weight"), "weight") for k,file in enumerate(study_inputs[channel]): f_in = TFile.Open(file,"READ") gDirectory.cd(pwd) n_events = f_in.Get("eventCount").GetBinContent(1) tree = f_in.Get("selected_zg").CloneTree() tree.SetName("tree_%s_%i"%(channel,k)) f_in.Close() d_in = RooDataSet("temp", "M_{ll#gamma} with Errors", tree, ws.set("observables")) norm = RooConstVar("norm","norm",n_events) weight = RooFormulaVar("weight", "weight", "1.3*@0*@1/@2", #1.3 gives 19.6/fb RooArgList(ws.var("puWeight"), ws.var("procWeight"), norm) ) d_in.addColumn(weight) d_in_weight = RooDataSet("temp_weight", "M_{ll#gamma} with Errors", d_in, ws.set("observables_weight"), '','weight') bkg_data.append(d_in_weight) # split off data for each category, create the # toy dataset truth models data = bkg_data.reduce("Mz + Mzg > 185 && r94cat == %i"%cat) getattr(ws,'import')(data, RooFit.Rename('bkgdata_%s_%i'%(channel, cat))) nevts = data.sumEntries('Mzg > %f && Mzg < %f'%(mass-1.5,mass+1.5)) #for sigm turn on we want erf truth if turnon == 'sigm' and truth == 'exp': #make RooDecay 'truth' model with erf turn on ws.factory( 'RooGaussModel::MzgResoShape_exp_erf_%s_cat%i(Mzg,'\ 'bias_exp_erf_%s_cat%i[120,90,150],sigma_exp_erf_%s_cat%i[1,0.01,10])'%( channel,cat, channel,cat, channel,cat) ) ws.factory( 'RooDecay::MzgTruthModelBase_exp_erf_%s_cat%i(Mzg,'\ 'tau_erf_%s_cat%i[25,0,50],MzgResoShape_exp_erf_%s_cat%i,' 'RooDecay::SingleSided)'%(channel,cat, channel,cat, channel,cat) ) ws.factory( 'RooExtendPdf::MzgTruthModel_exp_erf_%s_cat%i('\ 'MzgTruthModelBase_exp_erf_%s_cat%i,'\ 'norm_truth_exp_%s_cat%i[%f,%f,%f],"ROI")'%(channel,cat, channel,cat, channel,cat, nevts, 0.25*nevts,1.75*nevts) ) ws.pdf('MzgTruthModel_exp_erf_%s_cat%i'%(channel,cat)).fitTo( ws.data('bkgdata_%s_%i'%(channel,cat)), RooFit.Minimizer('Minuit2','scan'), RooFit.SumW2Error(False) ) ws.pdf('MzgTruthModel_exp_erf_%s_cat%i'%(channel,cat)).fitTo( ws.data('bkgdata_%s_%i'%(channel,cat)), RooFit.Minimizer('Minuit','simplex'), RooFit.SumW2Error(False) ) ws.pdf('MzgTruthModel_exp_erf_%s_cat%i'%(channel,cat)).fitTo( ws.data('bkgdata_%s_%i'%(channel,cat)), RooFit.SumW2Error(True) ) if turnon == 'sigm' and truth == 'pow': #make power-law truth model with erf turn on ws.factory('EXPR::MzgTruthModelShape_pow_erf_%s_cat%i('\ '"1e-20 + (@0 > @1)*((@0)^(-@2))",'\ '{Mzg,step_pow_erf_%s_cat%i[105,100,130],'\ 'pow_%s_cat%i[2,0,10]})'\ %(channel,cat, channel,cat, channel,cat)) ws.factory( 'RooGaussModel::MzgResoShape_pow_erf_%s_cat%i(Mzg,'\ 'bias_pow_erf_%s_cat%i[0],sigma_pow_erf_%s_cat%i[1,0.01,10])'%( channel,cat, channel,cat, channel,cat) ) ws.factory('FCONV::MzgTruthModelBase_pow_erf_%s_cat%i(Mzg,'\ 'MzgTruthModelShape_pow_erf_%s_cat%i,'\ 'MzgResoShape_pow_erf_%s_cat%i)'%(channel,cat, channel,cat, channel,cat)) ws.factory( 'RooExtendPdf::MzgTruthModel_pow_erf_%s_cat%i('\ 'MzgTruthModelBase_pow_erf_%s_cat%i,'\ 'norm_truth_pow_erf_%s_cat%i[%f,%f,%f],"ROI")'%(channel,cat, channel,cat, channel,cat, nevts, 0.25*nevts,1.75*nevts) ) ws.pdf('MzgTruthModel_pow_erf_%s_cat%i'%(channel,cat)).fitTo( ws.data('bkgdata_%s_%i'%(channel,cat)), RooFit.Minimizer('Minuit2','scan'), RooFit.SumW2Error(False) ) ws.pdf('MzgTruthModel_pow_erf_%s_cat%i'%(channel,cat)).fitTo( ws.data('bkgdata_%s_%i'%(channel,cat)), RooFit.Minimizer('Minuit','simplex'), RooFit.SumW2Error(False) ) ws.pdf('MzgTruthModel_pow_erf_%s_cat%i'%(channel,cat)).fitTo( ws.data('bkgdata_%s_%i'%(channel,cat)), RooFit.SumW2Error(True) ) #for erf fitting turn on we want sigmoid truth if turnon == 'erf' and truth == 'exp': #build exponential convoluted with sigmoid turn-on ws.factory('RooStepExponential::MzgTruthModelShape_exp_sigm_%s_cat%i'\ '(Mzg,tau_sigm_%s_cat%i[-0.05,-10,0],'\ 'step_exp_sigm_%s_cat%i[110,100,130])'%(channel,cat, channel,cat, channel,cat)) ws.factory( 'RooLogistics::MzgResoShape_exp_sigm_%s_cat%i(%s)'%( channel,cat, ','.join(['Mzg', 'bias_exp_sigm_%s_cat%i[0]'%(channel,cat), 'sigma_exp_sigm_%s_cat%i[5,0.01,20]'%(channel,cat)]) ) ) ws.factory('FCONV::MzgTruthModelBase_exp_sigm_%s_cat%i(Mzg,'\ 'MzgTruthModelShape_exp_sigm_%s_cat%i,'\ 'MzgResoShape_exp_sigm_%s_cat%i)'%(channel,cat, channel,cat, channel,cat)) ws.factory( 'RooExtendPdf::MzgTruthModel_exp_sigm_%s_cat%i('\ 'MzgTruthModelBase_exp_sigm_%s_cat%i,'\ 'norm_truth_exp_sigm_%s_cat%i[%f,%f,%f],"ROI")'%(channel,cat, channel,cat, channel,cat, nevts, 0.25*nevts,1.75*nevts) ) ws.pdf('MzgTruthModel_exp_sigm_%s_cat%i'%(channel,cat)).fitTo( ws.data('bkgdata_%s_%i'%(channel,cat)), RooFit.Minimizer('Minuit2','scan'), RooFit.SumW2Error(False) ) ws.pdf('MzgTruthModel_exp_sigm_%s_cat%i'%(channel,cat)).fitTo( ws.data('bkgdata_%s_%i'%(channel,cat)), RooFit.Minimizer('Minuit','simplex'), RooFit.SumW2Error(False) ) ws.pdf('MzgTruthModel_exp_sigm_%s_cat%i'%(channel,cat)).fitTo( ws.data('bkgdata_%s_%i'%(channel,cat)), RooFit.SumW2Error(True) ) if turnon == 'erf' and truth == 'pow': #build power-law convoluted with sigmoid turn-on ws.factory('EXPR::MzgTruthModelShape_pow_sigm_%s_cat%i('\ '"1e-20 + (@0 > @1)*((@0)^(-@2))",'\ '{Mzg,step_pow_sigm_%s_cat%i[105,100,130],'\ 'pow_sigm_%s_cat%i[2,0,10]})'\ %(channel,cat, channel,cat, channel,cat)) ws.factory( 'RooLogistics::MzgResoShape_pow_sigm_%s_cat%i(%s)'%( channel,cat, ','.join(['Mzg', 'bias_pow_sigm_%s_cat%i[0]'%(channel,cat), 'sigma_pow_sigm_%s_cat%i[5,0.01,20]'%(channel,cat)]) ) ) ws.factory('FCONV::MzgTruthModelBase_pow_sigm_%s_cat%i(Mzg,'\ 'MzgTruthModelShape_pow_sigm_%s_cat%i,'\ 'MzgResoShape_pow_sigm_%s_cat%i)'%(channel,cat, channel,cat, channel,cat)) ws.factory( 'RooExtendPdf::MzgTruthModel_pow_sigm_%s_cat%i('\ 'MzgTruthModelBase_pow_sigm_%s_cat%i,'\ 'norm_truth_pow_sigm_%s_cat%i[%f,%f,%f],"ROI")'%(channel,cat, channel,cat, channel,cat, nevts, 0.25*nevts,1.75*nevts) ) ws.pdf('MzgTruthModel_pow_sigm_%s_cat%i'%(channel,cat)).fitTo( ws.data('bkgdata_%s_%i'%(channel,cat)), RooFit.Minimizer('Minuit2','scan'), RooFit.SumW2Error(False) ) ws.pdf('MzgTruthModel_pow_sigm_%s_cat%i'%(channel,cat)).fitTo( ws.data('bkgdata_%s_%i'%(channel,cat)), RooFit.Minimizer('Minuit','simplex'), RooFit.SumW2Error(False) ) ws.pdf('MzgTruthModel_pow_sigm_%s_cat%i'%(channel,cat)).fitTo( ws.data('bkgdata_%s_%i'%(channel,cat)), RooFit.SumW2Error(True) )
x = RooRealVar( 'mass', 'mass', 4000, 7000 ) # Parameters mean = RooRealVar( 'mean', 'mean of gaussian', 0.0 ) sigma = RooRealVar( 'sigma', 'width of gaussian', 5.0 ) # Load reference ROOT tree full_ch = TChain("DecayTree") full_ch.Add("/mnt/home/kklimaszewski/LHCb/Bs2JpsieePhi/M_Bs_Fits/mc/DVNtuples_Bs2JpsieePhi_13154001_MCfull_R14ac_TupleBsDetached_PIDCorr_S21_NewSel_tupleB.root") # Run selection ch = full_ch.CopyTree("sigmam>0. && sigmam<250. && time>0.3 && time<14. && sigmat<0.12 && BDT_response_NewSel>0.2 && eminus_bremmult==0 && eplus_bremmult==0") #fit.mass.setBins(_comp['config']['bins']) # Create hist PDF data = RooDataSet( 'data_set', '', RooArgSet(x), RooFit.Import(ch) ) hist = data.binnedClone() p1 = RooHistPdf( 'histpdf', '', RooArgSet(x), hist, 2 # Order of interpolation function ) #p2 = RooGaussian( p2 = RooGaussModel( "comp_2", "", x,
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)
for i in range(len(tupleDict)): varName = tupleDict.keys()[i] varList += [ RooRealVar(varName, tree1.GetBranch(varName).GetTitle(), tree1.GetMinimum(varName), tree1.GetMaximum(varName)) ] varRenamedList += [RooFit.RenameVariable(varName, tupleDict[varName])] #RooFit.RenameVariable(varName, tupleDict[varName]); #varList[i].SetName(tupleDict.keys()[i]); #tupleDataSet = RooDataSet("treeData","treeData",tree1,RooArgSet(*varList)); weightvar = RooRealVar("weight", "weight", -1e7, 1e7) tupleDataSet = RooDataSet("tupleDataSet", "tupleDataSet", RooArgSet(*varList), RooFit.Import(tree1), RooFit.WeightVar(weightvar)) ws = RooWorkspace('ws_FIT') tupleDataSet = WS(ws, tupleDataSet, varRenamedList) tupleDataSet.Print() sys.exit(0) #qt needs to be a category? # Manuel's shit... #weightvar = RooRealVar("weight", "weight", -1e7, 1e7) #tupleDataSet = RooDataSet("tupleDataSet", "tupleDataSet", # RooArgSet(treetime, treeqt, treeqf, treeeta), # RooFit.Import(tree1), RooFit.WeightVar(weightvar)) #tupleDS = WS(ws, tupleDS, [ # RooFit.RenameVariable("Bs_ctau", "time"), ... ])
sample = ws.cat("sample") simPdf = ws.pdf("simPdf") efficiency = ws.var("efficiency") meanB = ws.var("meanB") # prepare_datasets(ws, p) # Prepare datasets datasetAllMap = {} datasetPassMap = {} hAllMap = {} hPassMap = {} for ptBin1 in range(0, len(ptBinsX)): for ptBin2 in range(0, len(ptBinsY)): datasetAllMap[(ptBin1, ptBin2)] = RooDataSet( buildName("datasetAll_", ptBin1, ptBin2, ptBinsX, ptBinsY), buildName("datasetAll_", ptBin1, ptBin2, ptBinsX, ptBinsY), RooArgSet(mass)) datasetPassMap[(ptBin1, ptBin2)] = RooDataSet( buildName("datasetPass_", ptBin1, ptBin2, ptBinsX, ptBinsY), buildName("datasetPass_", ptBin1, ptBin2, ptBinsX, ptBinsY), RooArgSet(mass)) hAllMap[(ptBin1, ptBin2)] = ROOT.TH1F( buildName("hAll_", ptBin1, ptBin2, ptBinsX, ptBinsY), buildName("All events passing old trigger ", ptBin1, ptBin2, ptBinsX, ptBinsY), 100, 60, 120) hPassMap[(ptBin1, ptBin2)] = ROOT.TH1F( buildName("hPass_", ptBin1, ptBin2, ptBinsX, ptBinsY), buildName("All events passing old trigger and new trigger ", ptBin1, ptBin2, ptBinsX, ptBinsY), 100, 60, 120) # Event loop
LbStabilityFit = False inFile16 = TFile.Open(dataFileName) inN16 = inFile16.Get('pLbL0/2016Data') inn16 = inFile16.Get('nLbL0/2016Data') # load parameters from other workspace and import them in current workspace massLb = space.var('lbl0Mass') massTkTk = space.var('tktkMass') massLb.setBins(50) massLb.setRange('sigRangeLb', 5.4, 5.9) loadDatasetLb = RooDataSet( 'loadDatasetLb', 'loadData16', inN16, RooArgSet(massLb, massTkTk, space.var('lbl0Pt'))).reduce( 'tktkMass>1.110&&tktkMass<1.120 &&{0}'.format(ptCut)) loadDatasetlB = RooDataSet( 'loadDatasetlB', 'loadData16', inn16, RooArgSet(massLb, massTkTk, space.var('lbl0Pt'))).reduce( 'tktkMass>1.110&&tktkMass<1.120 &&{0}'.format(ptCut)) totNum = loadDatasetLb.sumEntries() space.factory('numLb[{0},-1000.,{1}]'.format( space1st.var('numLb').getVal(), totNum)) simulComponents = [] # scan Lb likelihood {{{ # jack's profile likelihood scan if sysFitLb: label = 'sysLbFit'
def fitMass(rangem=[0.4, 2.0], iflag=1, iopt_bkgshape=0, CBpar=[0., 0., 0.]): global myc, fitres m0 = sum(rangem) / 2 #w0=(rangem[1]-rangem[0])/10 w0 = 0.004 mass = RooRealVar("ee_ivm", "ee_ivm", rangem[0], rangem[1]) if iflag == 1: ###Construct signal pdf with gaus mean = RooRealVar("mean", "mean", m0) sigma = RooRealVar("sigma", "sigma", w0) signal = RooGaussian("signal", "signal", mass, mean, sigma) elif iflag == 2 or iflag == 3: ## Construct signal pdf with CB function ##print "outinfo",x,CBpar[0],CBpar[1],CBpar[2],CBpar[3] cbmean = RooRealVar("cbmean", "cbmean", m0) cbsigma = RooRealVar("cbsigma", "cbsigma", CBpar[0]) n1 = RooRealVar("n1", "", CBpar[1]) alpha = RooRealVar("alpha", "", CBpar[2]) cbsigma.setConstant(ROOT.kTRUE) n1.setConstant(ROOT.kTRUE) alpha.setConstant(ROOT.kTRUE) signal = RooCBShape("cball", "crystal ball1", mass, cbmean, cbsigma, alpha, n1) # elif iflag ==3: # pass else: print "ERROR, please specify signal shape for fitting!!" sys.exit() # Construct background pdf a0 = RooRealVar("a0", "a0", 0.1, -1, 1) a1 = RooRealVar("a1", "a1", 0.004, -1, 1) a2 = RooRealVar("a2", "a2", 0.001, -1, 1) if iopt_bkgshape == 0: background = RooChebychev("background", "background", mass, RooArgList(a0, a1)) else: background = RooChebychev("background", "background", mass, RooArgList(a0, a1, a2)) # Construct composite pdf if iflag == 1: up_nsig = 40 else: up_nsig = 60 nsig = RooRealVar("nsig", "nsig", 5, 0.0, up_nsig) nbkg = RooRealVar("nbkg", "nbkg", 800, 0, 3000) #frac = RooRealVar("frac", "frac", 0.001, 0.0001, 0.1) model = RooAddPdf("model", "model", RooArgList(signal, background), RooArgList(nsig, nbkg)) #model = RooAddPdf("model", "model", RooArgList(signal, background), RooArgList(frac)) mcdata = RooDataSet( "ds", "ds", RooArgSet(mass), RooFit.Import(data), RooFit.Cut("ee_ivm<" + str(rangem[1]) + "&&ee_ivm>" + str(rangem[0]))) if optp == 1: ipr = 1 verbose = 0 elif optp == 2: ipr = 1 verbose = 1 else: ipr = -1 verbose = 0 fitres=model.fitTo(mcdata,RooFit.Save(),RooFit.Minos(1), RooFit.Strategy(2),\ RooFit.PrintLevel(ipr), RooFit.Verbose(verbose)) nll = RooNLLVar("nll", "nll", model, mcdata, RooFit.Range(rangem[0], rangem[1])) pll = nll.createProfile(RooArgSet(nsig)) Profile = RooProfileLL("Profile", "Profile", nll, RooArgSet(nsig)) llhoodP = RooFormulaVar("llhoodP", "exp(-0.5*Profile)", RooArgList(Profile)) xframe2 = nsig.frame(RooFit.Title("number of signal")) nllplot = nll.plotOn(xframe2, RooFit.ShiftToZero()) themin = RooConstVar("themin", "themin", nllplot.GetMinimum()) llhood = RooFormulaVar("llhood", "exp(-0.5*(nll-themin*0.95))", RooArgList(nll, themin)) if optp: xframe = mass.frame(RooFit.Title("mass of ee pair")) xframe3 = nsig.frame(RooFit.Title("number of signal")) xframe3.SetYTitle("Likelihood") mcdata.plotOn(xframe) model.plotOn(xframe) model.plotOn(xframe, RooFit.Components("background"), RooFit.LineStyle(ROOT.kDashed), RooFit.LineColor(ROOT.kRed)) model.plotOn(xframe, RooFit.Components("cball"), RooFit.LineStyle(ROOT.kDashed), RooFit.LineColor(ROOT.kGreen)) myc.cd(1) xframe.Draw() #pll.plotOn(xframe2,RooFit.LineColor(ROOT.kRed)) if optp: print "***** archmin ", themin.Print() #llhoodP.plotOn(xframe3, RooFit.LineColor(ROOT.kRed)) llhood.plotOn(xframe3) myc.cd(2) xframe2.SetMinimum(0) xframe2.Draw() myc.cd(3) xframe3.Draw() myc.Update() raw_input() nsig.setRange("IntRange1", 0, 1000.) Int1 = llhood.createIntegral(RooArgSet(nsig), ROOT.RooFit.Range('IntRange1')) Int1Val = Int1.getVal() i = 0 hit = False while not (hit): i = i + 1 nsig.setRange("IntRange2", 0, float(i)) Int2 = llhood.createIntegral(RooArgSet(nsig), ROOT.RooFit.Range('IntRange2')) if Int2.getVal() >= Int1Val * 0.9: if optp: print "&&& ", i hit = True return i
t.SetBranchStatus("ez*",0) hist = TH1F("h", "h", 100, 5200, 5400) hist2 = TH1F("h2", "h2", 100, 5000, 5700) kstmass = TH1F("kst", "kst", 100, 700, 1100) gamma_pt = TH1F("gamma_pt", "gamma_pt", 100, 0, 2000) m = RooRealVar("m", "m", 5200, 5400) argset = RooArgSet(m) m2 = RooRealVar("m2", "m2", 5000, 5600) g1pt = RooRealVar("gamma1_pt", "gamma1_pt", 0, 20000) g2pt = RooRealVar("gamma2_pt", "gamma2_pt", 0, 20000) argset2 = RooArgSet(m2, g1pt, g2pt) ds = RooDataSet("ds", "ds", argset) ds2 = RooDataSet("ds2", "ds2", argset2) counters = [0, 0, 0, 0, 0, 0] counters2 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] for aa in [t,u]: aa.SetBranchStatus("bp1*",0) aa.SetBranchStatus("piz*",0) print aa.GetEntries() for i in range(aa.GetEntries()): s = aa.GetEntry(i) if s == -1: print "Error reading event ",i,", skipping" continue if i%10000 == 0:
# read ntuple ffile_tp = TFile(tpfile, 'read') fkeys = ffile_tp.GetListOfKeys() keys = [] for i in range(fkeys.GetEntries()): keys.append(fkeys.At(i).GetName()) keys.sort() for i in range(0,len(keys),2): if keys[i].find(mode) > 0: ntuples = (ffile_tp.Get(keys[i]), ffile_tp.Get(keys[i+1])) break # found mode # make dataset from tree wt = RooRealVar('wt', '', 1.0, 0.0, 1.0) dst = RooDataSet('dst', '', RooArgSet(time, wt), RooFit.WeightVar(wt)) for tp in ntuples: print '{}: {}'.format(tp.GetName(), tp.GetEntries()) tp.SetBranchStatus('*', 0) tp.SetBranchStatus('wt', 1) tp.SetBranchStatus('Bid', 1) tp.SetBranchStatus('hid', 1) tp.SetBranchStatus('time', 1) for i in range(tp.GetEntries()): tp.GetEntry(i) # choose decay equation (1 of 2 for Dspi) if (tp.Bid == 531 and tp.hid == 211): time.setVal(tp.time) dst.add(RooArgSet(time), tp.wt) dst.Print()
def make_fit(): adc_bin = 12 #18 for low-m gg, 24 for jpsi adc_min = 0. #10. adc_max = 400. #adc_max = 1200 ptmax = 0.18 #mmin = 1.6 #mmin = 2.1 #mmax = 2.6 #mmin = 1.5 #mmax = 5. mmin = 2.9 mmax = 3.2 #mmin = 3.4 #mmax = 4.6 #east/west projections and 2D plot ew = 1 p2d = 2 # 0: single projection by 'ew', 1: 2D plot, 2: both projections #plot colors model_col = rt.kMagenta model_col = rt.kBlue out = open("out.txt", "w") lmg = 6 ut.log_results(out, "in " + infile, lmg) strlog = "adc_bin " + str(adc_bin) + " adc_min " + str( adc_min) + " adc_max " + str(adc_max) strlog += " ptmax " + str(ptmax) + " mmin " + str(mmin) + " mmax " + str( mmax) ut.log_results(out, strlog, lmg) #adc distributions adc_east = RooRealVar("jZDCUnAttEast", "ZDC ADC east", adc_min, adc_max) adc_west = RooRealVar("jZDCUnAttWest", "ZDC ADC west", adc_min, adc_max) #kinematics variables m = RooRealVar("jRecM", "e^{+}e^{-} mass (GeV)", 0., 10.) y = RooRealVar("jRecY", "rapidity", -1., 1.) pT = RooRealVar("jRecPt", "pT", 0., 10.) #adc distributions #adc_east = RooRealVar("zdce", "ZDC ADC east", adc_min, adc_max) #adc_west = RooRealVar("zdcw", "ZDC ADC west", adc_min, adc_max) #kinematics variables #m = RooRealVar("mee", "e^{+}e^{-} mass (GeV)", 0., 10.) #y = RooRealVar("rapee", "rapidity", -1., 1.) #pT = RooRealVar("ptpair", "pT", 0., 10.) strsel = "jRecPt<{0:.3f} && jRecM>{1:.3f} && jRecM<{2:.3f}".format( ptmax, mmin, mmax) #strsel = "ptpair<{0:.3f} && mee>{1:.3f} && mee<{2:.3f}".format(ptmax, mmin, mmax) data_all = RooDataSet("data", "data", tree, RooArgSet(adc_east, adc_west, m, y, pT)) print "All input:", data_all.numEntries() data = data_all.reduce(strsel) print "Sel input:", data.numEntries() model = Model2D(adc_east, adc_west) r1 = model.model.fitTo(data, rf.Save()) ut.log_results(out, ut.log_fit_result(r1), lmg) ut.log_results(out, "Fit parameters:\n", lmg) out.write(ut.log_fit_parameters(r1, lmg + 2) + "\n") #out.write(ut.table_fit_parameters(r1)) #print ut.table_fit_parameters(r1) #create the plot if p2d != 2: can = ut.box_canvas() nbins, adc_max = ut.get_nbins(adc_bin, adc_min, adc_max) adc_east.setMax(adc_max) adc_west.setMax(adc_max) frame_east = adc_east.frame(rf.Bins(nbins), rf.Title("")) frame_west = adc_west.frame(rf.Bins(nbins), rf.Title("")) data.plotOn(frame_east, rf.Name("data")) model.model.plotOn(frame_east, rf.Precision(1e-6), rf.Name("model"), rf.LineColor(model_col)) data.plotOn(frame_west, rf.Name("data")) model.model.plotOn(frame_west, rf.Precision(1e-6), rf.Name("model"), rf.LineColor(model_col)) #reduced chi^2 in east and west projections ut.log_results(out, "chi2/ndf:\n", lmg) ut.log_results( out, " East chi2/ndf: " + str(frame_east.chiSquare("model", "data", 16)), lmg) ut.log_results( out, " West chi2/ndf: " + str(frame_west.chiSquare("model", "data", 16)), lmg) ut.log_results(out, "", 0) ytit = "Events / ({0:.0f} ADC units)".format(adc_bin) frame_east.SetYTitle(ytit) frame_west.SetYTitle(ytit) frame_east.SetTitle("") frame_west.SetTitle("") frame = [frame_east, frame_west] if p2d == 0: plot_projection(frame[ew], ew) plot_pdf = PlotPdf(model, adc_east, adc_west) if p2d == 1: plot_2d(plot_pdf) if p2d == 2: frame2 = ut.prepare_TH1D("frame2", adc_bin, adc_min, 2. * adc_max + 4.1 * adc_bin) plot_proj_both(frame2, frame_east, frame_west, adc_bin, adc_min, adc_max, ptmax, mmin, mmax) lhead = ["east ZDC", "west ZDC"] if p2d == 1: leg = ut.prepare_leg(0.003, 0.9, 0.3, 0.1, 0.035) else: leg = ut.prepare_leg(0.66, 0.8, 0.32, 0.13, 0.03) if p2d == 0: leg.AddEntry(None, "#bf{Projection to " + lhead[ew] + "}", "") leg.SetMargin(0.05) leg.AddEntry(None, "#bf{#it{p}_{T} < " + "{0:.2f}".format(ptmax) + " GeV/c}", "") mmin_fmt = "{0:.1f}".format(mmin) mmax_fmt = "{0:.1f}".format(mmax) leg.AddEntry( None, "#bf{" + mmin_fmt + " < #it{m}_{e^{+}e^{-}} < " + mmax_fmt + " GeV/c^{2}}", "") leg.Draw("same") pleg = ut.prepare_leg(0.99, 0.87, -0.4, 0.11, 0.035) pleg.SetFillStyle(1001) #pleg.AddEntry(None, "STAR Preliminary", "") pleg.AddEntry(None, "AuAu@200 GeV", "") pleg.AddEntry(None, "UPC sample", "") #pleg.Draw("same") #ut.print_pad(gPad) #b3d = TBuffer3D(0) #b3d = None #gPad.GetViewer3D().OpenComposite(b3d) #print b3d #print "All input: ", data.numEntries() #print "All input: 858" #all input data nall = float(tree.Draw("", strsel)) print "All input: ", nall n_1n1n = float(model.num_1n1n.getVal()) print "1n1n events: ", n_1n1n ratio_1n1n = n_1n1n / nall sigma_ratio_1n1n = ratio_1n1n * TMath.Sqrt( (nall - n_1n1n) / (nall * n_1n1n)) print "Ratio 1n1n / all: ", ratio_1n1n, "+/-", sigma_ratio_1n1n ut.log_results(out, "Fraction of 1n1n events:\n", lmg) ut.log_results(out, "All input: " + str(nall), lmg) ut.log_results(out, "1n1n events: " + str(model.num_1n1n.getVal()), lmg) ratio_str = "Ratio 1n1n / all: " + str(ratio_1n1n) + " +/- " + str( sigma_ratio_1n1n) ut.log_results(out, ratio_str, lmg) if p2d != 2: #ut.print_pad(gPad) ut.invert_col(gPad) can.SaveAs("01fig.pdf") if interactive == True: start_interactive()
mmtt_mass = RooRealVar("xM", "xM" + region + "m(#mu#muKK)[GeV]", xmin, xmax) tt_pt = RooRealVar("ttPt", "ttPt" + region + "p_{t}(KK)[GeV]", 0.0, ptmax) mm_pt = RooRealVar("mmPt", "mmPt" + region + "p{t}(#mu#mu)[GeV]", 0.0, ptmax) mmtt_pt = RooRealVar("xPt", "xPt" + region + "p_{t}(#mu#muKK)[GeV]", 0.0, ptmax) lxysig = RooRealVar("xL", "l_{xy} sign." + region + "l_{xy} / #sigma(l_{xy})", -1000.0, 1000.0) massvars = RooArgSet(tt_mass, mm_mass, mmtt_mass) ptvars = RooArgSet(tt_pt, mm_pt, mmtt_pt) kinvars = RooArgSet(massvars, ptvars) extravars = RooArgSet(lxysig) theData = RooDataSet("theData", "theData", theTree, RooArgSet(kinvars, extravars)) c = TCanvas("canvas", "canvas", 1200, 800) if args.nonprompt: theData = theData.reduce("xL > 3.0") if args.prompt: theData = theData.reduce("xL < 1.5") if args.ptcuts is not None: theData = theData.reduce("trigp_pT > " + str(args.ptcuts)) theData = theData.reduce("trign_pT > " + str(args.ptcuts)) cuts += "P_t_" + str(args.ptcuts) + "_" #### #### Plotting variables #### TrakTrak Data
binWidth = 50. #GeV # DAS_EX_2.1 # Define a RooRealVar object for the ST variable st = RooRealVar("st", "st", ranges["fit", "lo"], ranges["fit", "hi"]) ############################################ # Get data and models ############################################ # print "Reading Files" # DAS_EX_2.2 # Read data from file into RooDataSet using the RooDataSet.read() method. #rdata = RooDataSet.add(files["dat"], RooArgList(st)) rdata = RooDataSet.read(files["dat"], RooArgList(st)) ################################### # Set up fit PDFs with information # from fitFuncs dictionary ################################### # Declare a few dictionaries pdfs = {} pars = {} aset = {} for func in ["f2", "f1", "f3"]: # DAS_EX_2.3 # Define and initialize (with your ST RooRealVar) a RooArgSet for use in the pdf
fcUpperHist=TH2D("fcUpperLimit","fcUpperLimit",n_massbins,xedges,n_epsbins,yedges) plrPvalHist=TH2D("plrPval","plrPval",n_massbins,xedges,n_epsbins,yedges) plrSigHist=TH2D("plrSig","plrSig",n_massbins,xedges,n_epsbins,yedges) logplrHist=TH2D("logplr","logplr",n_massbins,xedges,n_epsbins,yedges) candRescaledHist=TH1D("candidates_rescaled","candidates_rescaled",100,0,1.0) candRescaled2DHist=TH2D("candidates_rescaled_2d","candidates_rescaled_2d",n_massbins,xedges,100,0,1.0) w = RooWorkspace("w") w.factory("{0}[0,0.1]".format(massVar)) w.factory("uncVZ[-100,100]") w.factory("uncP[0,10]") w.factory("cut[0,1]") w.defineSet("myVars","{0},uncVZ".format(massVar)) dataset = RooDataSet("data","data",events,w.set("myVars"),"") w.factory("Gaussian::vtx_model(uncVZ,mean[-50,50],sigma[0,50])") gauss_pdf = w.pdf("vtx_model") w.factory("EXPR::gaussExp('exp( ((@0-@1)<@3)*(-0.5*(@0-@1)^2/@2^2) + ((@0-@1)>=@3)*(-0.5*@3^2/@2^2-(@0-@1-@3)/@4))',uncVZ,gauss_mean[-5,-20,20],gauss_sigma[5,1,50],exp_breakpoint[10,0,50],exp_length[3,0.5,20])") gaussexp_pdf = w.pdf("gaussExp") w.defineSet("obs_1d","uncVZ") obs=w.set("obs_1d") uncVZ = w.var("uncVZ") uncVZ.setBins(200) gauss_params = gauss_pdf.getParameters(obs) gaussexp_params = gaussexp_pdf.getParameters(obs) exppol4=TF1("exppol4","exp(pol4(0))",-5,100) w.factory("EXPR::signal('(@0>{0})*exp(@1 + @2*@0 + @3*@0^2 + @4*@0^3 + @5*@0^4)',uncVZ,eff_p0[-1,1],eff_p1[-1,1],eff_p2[-1,1],eff_p3[-1,1],eff_p4[-1,1])".format(targetz)) w.factory("SUM::model(strength[0,1]*signal,gaussExp)")
def gen_data_and_fit(ws, iterations,cat, mass,channel,turnon,truth): if channel in channels: #fit gaus(x)bern to sigm(x)pow and sigm(x)exp #fit sigm(x)bern to erf(x)pow and erf(x)exp n_sample = int(ws.data('bkgdata_%s_%i'%(channel,cat)).sumEntries()) if turnon == 'erf' and truth == 'exp': ws.factory('pull_ROI_erf_on_sigmexp_%s_cat%i[0]'%(channel,cat)) ws.defineSet('biasVars_%s_cat%i'%(channel,cat), 'pull_ROI_erf_on_sigmexp_%s_cat%i,'%(channel,cat)) if turnon == 'erf' and truth == 'pow': ws.factory('pull_ROI_erf_on_sigmpow_%s_cat%i[0]'%(channel,cat)) ws.defineSet('biasVars_%s_cat%i'%(channel,cat), 'pull_ROI_erf_on_sigmpow_%s_cat%i,'%(channel,cat) ) if turnon == 'sigm' and truth == 'exp': ws.factory('pull_ROI_sigm_on_erfexp_%s_cat%i[0]'%(channel,cat)) ws.defineSet('biasVars_%s_cat%i'%(channel,cat), 'pull_ROI_sigm_on_erfexp_%s_cat%i,'%(channel,cat) ) if turnon == 'sigm' and truth == 'pow': ws.factory('pull_ROI_sigm_on_erfpow_%s_cat%i[0]'%(channel,cat)) ws.defineSet('biasVars_%s_cat%i'%(channel,cat), 'pull_ROI_sigm_on_erfpow_%s_cat%i'%(channel,cat) ) biasData = RooDataSet('biasData_%s_cat%i'%(channel,cat), 'bias data', ws.set('biasVars_%s_cat%i'%(channel,cat))) for i in xrange(iterations): ### SIGM #build ERF toy data to fit with SIGM if turnon == 'sigm' and truth == 'exp': truth_exp_erf = ws.pdf('MzgTruthModel_exp_erf_%s_cat%i'%(channel,cat)) toy_data_exp_erf = truth_exp_erf.generate( RooArgSet(ws.var('Mzg')), n_sample, RooFit.Extended(), RooFit.Name('toy_erfexp_%s_cat%i_%i'%(channel,cat,i)) ) true_ROI_yield_erfexp = ws.var('norm_truth_exp_%s_cat%i'%(channel,cat)).getVal() #fit logistics(x)bern to erfexp ws.var('norm_altrsb_cat%i'%cat).setMin(true_ROI_yield_erfexp*0.25) ws.var('norm_altrsb_cat%i'%cat).setMax(true_ROI_yield_erfexp*1.75) ws.var('norm_altrsb_cat%i'%cat).setVal(true_ROI_yield_erfexp) minos_var = RooArgSet(ws.var('norm_altrsb_cat%i'%cat)) sigm_nll = ws.pdf('RSBFitModelAlt_cat%i'%cat).createNLL( toy_data_exp_erf ) sigm_min = RooMinimizer(sigm_nll) sigm_min.setPrintLevel(1) sigm_min.minimize('Minuit2','scan') sigm_min.minimize('Minuit2','simplex') migrad_out = sigm_min.migrad() migrad_out = sigm_min.migrad() hesse_out = sigm_min.hesse() fit_sigm_norm = ws.var('norm_altrsb_cat%i'%cat).getVal() fit_sigm_err = ws.var('norm_altrsb_cat%i'%cat).getError() fit_sigm_pull = (fit_sigm_norm - true_ROI_yield_erfexp)/fit_sigm_err #if fit failed run minos if migrad_out != 0 or hesse_out != 0: migrad_out = sigm_min.migrad() if migrad_out != 0: sigm_min.minos(minos_var) fit_sigm_err = max(abs(ws.var('norm_altrsb_cat%i'%cat).getErrorHi()), abs(ws.var('norm_altrsb_cat%i'%cat).getErrorLo())) else: fit_sigm_err = ws.var('norm_altrsb_cat%i'%cat).getError() fit_sigm_norm = ws.var('norm_altrsb_cat%i'%cat).getVal() fit_sigm_pull = (fit_sigm_norm - true_ROI_yield_erfexp)/fit_sigm_err print i, fit_sigm_norm, fit_sigm_err, true_ROI_yield_erfexp, fit_sigm_pull ws.var('pull_ROI_sigm_on_erfexp_%s_cat%i'%(channel,cat)).setVal( fit_sigm_pull ) biasData.add(ws.set('biasVars_%s_cat%i'%(channel,cat))) var = ws.var('pull_ROI_sigm_on_erfexp_%s_cat%i'%(channel,cat)) print 'cumulative median bias: %.3f'%calculate_median(var,biasData) var = None del sigm_min del sigm_nll del truth_exp_erf if turnon =='sigm' and truth =='pow': truth_pow_erf = ws.pdf('MzgTruthModel_pow_erf_%s_cat%i'%(channel,cat)) toy_data_pow_erf = truth_pow_erf.generate( RooArgSet(ws.var('Mzg')), n_sample, RooFit.Extended(), RooFit.Name('toy_erfpow_%s_cat%i_%i'%(channel,cat,i)) ) true_ROI_yield_erfpow = ws.var('norm_truth_pow_erf_%s_cat%i'%(channel,cat)).getVal() #fit logistics(x)bern to erfpow ws.var('norm_altrsb_cat%i'%cat).setMin(true_ROI_yield_erfpow*0.25) ws.var('norm_altrsb_cat%i'%cat).setMax(true_ROI_yield_erfpow*1.75) ws.var('norm_altrsb_cat%i'%cat).setVal(true_ROI_yield_erfpow) minos_var = RooArgSet(ws.var('norm_altrsb_cat%i'%cat)) sigm_nll = ws.pdf('RSBFitModelAlt_cat%i'%cat).createNLL( toy_data_pow_erf ) sigm_min = RooMinimizer(sigm_nll) sigm_min.setPrintLevel(1) sigm_min.minimize('Minuit2','scan') sigm_min.minimize('Minuit2','simplex') migrad_out = sigm_min.migrad() migrad_out = sigm_min.migrad() hesse_out = sigm_min.hesse() fit_sigm_norm = ws.var('norm_altrsb_cat%i'%cat).getVal() fit_sigm_err = ws.var('norm_altrsb_cat%i'%cat).getError() fit_sigm_pull = (fit_sigm_norm - true_ROI_yield_erfpow)/fit_sigm_err #if fit failed run minos if migrad_out != 0 or hesse_out != 0: migrad_out = sigm_min.migrad() if migrad_out != 0: sigm_min.minos(minos_var) fit_sigm_err = max(abs(ws.var('norm_altrsb_cat%i'%cat).getErrorHi()), abs(ws.var('norm_altrsb_cat%i'%cat).getErrorLo())) else: fit_sigm_err = ws.var('norm_altrsb_cat%i'%cat).getError() fit_sigm_norm = ws.var('norm_altrsb_cat%i'%cat).getVal() fit_sigm_pull = (fit_sigm_norm - true_ROI_yield_erfpow)/fit_sigm_err ws.var('pull_ROI_sigm_on_erfpow_%s_cat%i'%(channel,cat)).setVal( fit_sigm_pull ) print i, fit_sigm_norm, fit_sigm_err, true_ROI_yield_erfpow, fit_sigm_pull biasData.add(ws.set('biasVars_%s_cat%i'%(channel,cat))) var = ws.var('pull_ROI_sigm_on_erfpow_%s_cat%i'%(channel,cat)) print 'cumulative median bias: %.3f'%calculate_median(var,biasData) var = None del sigm_min del sigm_nll del truth_pow_erf ##### ERF # generate SIGM data to fit with ERF #### fit erf(x)bern models if turnon == 'erf' and truth == 'exp': truth_exp_sigm = ws.pdf('MzgTruthModel_exp_sigm_%s_cat%i'%(channel,cat)) toy_data_exp_sigm = truth_exp_sigm.generate( RooArgSet(ws.var('Mzg')), n_sample, RooFit.Extended(), RooFit.Name('toy_sigmexp_%s_cat%i_%i'%(channel,cat,i)) ) true_ROI_yield_sigmexp = ws.var('norm_truth_exp_sigm_%s_cat%i'%(channel,cat)).getVal() #fit erf(x)bern to sigmexp ws.var('norm_rsb_cat%i'%cat).setMin(true_ROI_yield_sigmexp*0.25) ws.var('norm_rsb_cat%i'%cat).setMax(true_ROI_yield_sigmexp*1.75) ws.var('norm_rsb_cat%i'%cat).setVal(true_ROI_yield_sigmexp) minos_var = RooArgSet(ws.var('norm_rsb_cat%i'%cat)) gaus_nll = ws.pdf('RSBFitModel_cat%i'%cat).createNLL( toy_data_exp_sigm ) gaus_min= RooMinimizer(gaus_nll) gaus_min.setPrintLevel(1) gaus_min.minimize('Minuit2','scan') gaus_min.minimize('Minuit2','simplex') migrad_out = gaus_min.migrad() migrad_out = gaus_min.migrad() hesse_out = gaus_min.hesse() #get parabolic errors regardless fit_erf_norm = ws.var('norm_rsb_cat%i'%cat).getVal() fit_erf_err = ws.var('norm_rsb_cat%i'%cat).getError() fit_erf_pull = (fit_erf_norm - true_ROI_yield_sigmexp)/fit_erf_err #if fit failed run minos if migrad_out != 0 or hesse_out != 0: migrad_out = gaus_min.migrad() if migrad_out != 0: gaus_min.minos(minos_var) fit_erf_err = max(abs(ws.var('norm_rsb_cat%i'%cat).getErrorHi()), abs(ws.var('norm_rsb_cat%i'%cat).getErrorLo())) else: fit_erf_err = ws.var('norm_rsb_cat%i'%cat).getError() fit_erf_norm = ws.var('norm_rsb_cat%i'%cat).getVal() fit_erf_pull = (fit_erf_norm - true_ROI_yield_sigmexp)/fit_erf_err ws.var('pull_ROI_erf_on_sigmexp_%s_cat%i'%(channel,cat)).setVal( fit_erf_pull ) print i,fit_erf_norm, fit_erf_err, true_ROI_yield_sigmexp, fit_erf_pull biasData.add(ws.set('biasVars_%s_cat%i'%(channel,cat))) var = ws.var('pull_ROI_erf_on_sigmerf_%s_cat%i'%(channel,cat)) print 'cumulative median bias: %.3f'%calculate_median(var,biasData) var = None del gaus_min del gaus_nll del truth_exp_sigm if turnon == 'erf' and truth == 'pow': truth_pow_sigm = ws.pdf('MzgTruthModel_pow_sigm_%s_cat%i'%(channel,cat)) toy_data_pow_sigm = truth_pow_sigm.generate( RooArgSet(ws.var('Mzg')), n_sample, RooFit.Extended(), RooFit.Name('toy_sigmpow_%s_cat%i_%i'%(channel,cat,i)) ) true_ROI_yield_sigmpow = ws.var('norm_truth_pow_sigm_%s_cat%i'%(channel,cat)).getVal() #fit erf(x)bern to sigmpow ws.var('norm_rsb_cat%i'%cat).setMin(true_ROI_yield_sigmpow*0.25) ws.var('norm_rsb_cat%i'%cat).setMax(true_ROI_yield_sigmpow*1.75) ws.var('norm_rsb_cat%i'%cat).setVal(true_ROI_yield_sigmpow) minos_var = RooArgSet(ws.var('norm_rsb_cat%i'%cat)) gaus_nll = ws.pdf('RSBFitModel_cat%i'%cat).createNLL( toy_data_pow_sigm ) gaus_min= RooMinimizer(gaus_nll) gaus_min.setPrintLevel(1) gaus_min.minimize('Minuit2','scan') gaus_min.minimize('Minuit2','simplex') migrad_out = gaus_min.migrad() migrad_out = gaus_min.migrad() hesse_out = gaus_min.hesse() fit_erf_norm = ws.var('norm_rsb_cat%i'%cat).getVal() fit_erf_err = ws.var('norm_rsb_cat%i'%cat).getError() fit_erf_pull = (fit_erf_norm - true_ROI_yield_sigmpow)/fit_erf_err #if fit failed run minos if migrad_out != 0 or hesse_out != 0: migrad_out = gaus_min.migrad() if migrad_out != 0: gaus_min.minos(minos_var) fit_erf_err = max(abs(ws.var('norm_rsb_cat%i'%cat).getErrorHi()), abs(ws.var('norm_rsb_cat%i'%cat).getErrorLo())) else: fit_erf_err = ws.var('norm_rsb_cat%i'%cat).getError() fit_erf_norm = ws.var('norm_rsb_cat%i'%cat).getVal() fit_erf_pull = (fit_erf_norm - true_ROI_yield_sigmpow)/fit_erf_err print i, fit_erf_norm, fit_erf_err, true_ROI_yield_sigmpow, fit_erf_pull ws.var('pull_ROI_erf_on_sigmpow_%s_cat%i'%(channel,cat)).setVal( fit_erf_pull ) biasData.add(ws.set('biasVars_%s_cat%i'%(channel,cat))) var = ws.var('pull_ROI_erf_on_sigmpow_%s_cat%i'%(channel,cat)) print 'cumulative median bias: %.3f'%calculate_median(var,biasData) var = None #getattr(ws,'import')(toy_data_exp_sigm) #getattr(ws,'import')(toy_data_pow_sigm) del gaus_min del gaus_nll del truth_pow_sigm getattr(ws,'import')(biasData)
def getData(workspace, mean1 = 1., sigma1 = 0.01, mean2 = 1., sigma2 = 0.01, nevents = 5000): ## Make a local workspace to use as a factory. w = RooWorkspace('w', 'w') ## Define the PDF's for m, f1 and f2 in m*sqrt(f1*f2) mPdf = w.factory("BreitWigner::mPdf(m[50,130], MZ[91.12], GammaZ[2.5])") f1Pdf = w.factory("Gaussian::f1Pdf(f1[0.5, 2], mean1[%f], sigma1[%f])" % (mean1, sigma1)) f2Pdf = w.factory("Gaussian::f2Pdf(f2[0.5, 2], mean2[%f], sigma2[%f])" % (mean2, sigma2)) ## Import the PDF's in the given workspace. workspace.Import(mPdf, RenameAllVariables("True")) workspace.Import(f1Pdf, RenameAllVariables("True")) workspace.Import(f2Pdf, RenameAllVariables("True")) ## Generate samples of M, F1 and F2 with a 10% margin for boundaries. moreEvents = int(2*nevents) mData = mPdf.generate(RooArgSet(w.var("m")), moreEvents, NumCPU(3)) f1Data = f1Pdf.generate(RooArgSet(w.var("f1")), moreEvents, NumCPU(3)) f2Data = f2Pdf.generate(RooArgSet(w.var("f2")), moreEvents, NumCPU(3)) ## Create the new data with toy reco mass data = RooDataSet('data', 'toy reco Z->ll mass data', RooArgSet(w.factory('mass[40,140]'))) entry = data.get() ## Loop over the generated values and fill the new reco mass data. for i in range(moreEvents): ## Do we have enough entries already? if data.sumEntries() >= nevents: break ## Get the values of the random variables m, f1, f2. m = mData.get(i).first().getVal() f1 = f1Data.get(i).first().getVal() f2 = f2Data.get(i).first().getVal() ## Here comes the formula!! mass = m * sqrt(f1*f2) ## Is the reco mass within its range? if 60. < mass and mass < 120.: ## Add the reco mass to the data entry.first().setVal(mass) data.addFast(entry) ## End of loop over the generated values workspace.Import(data) return data