def makeTTbarModel(workspace,label, model,channel, wtagger, constraint=[],peak="W", spectrum="_mj"): info ="" if label.find("_ttbar_data")!=-1 and label.find("fail")==-1: rrv_number_total = RooRealVar("rrv_number_total_ttbar_data"+info+"_"+channel,"rrv_number_total_ttbar_data"+info+"_"+channel,500,0.,1e10) eff_ttbar = RooRealVar("eff_ttbar_data"+info+"_"+channel,"eff_ttbar_data"+info+"_"+channel,0.7,0.2,1.0) if peak == "Wt":eff_ttbar = RooRealVar("eff_ttbar_data"+info+"_"+channel,"eff_ttbar_data"+info+"_"+channel,0.7,0.0,1.0) rrv_number = RooFormulaVar("rrv_number"+label+"_"+channel+spectrum, "@0*@1", RooArgList(eff_ttbar,rrv_number_total)) elif label.find("_ttbar_data")!=-1 and label.find("fail")!=-1: rrv_number_total = workspace.var("rrv_number_total_ttbar_data"+info+"_"+channel) eff_ttbar = workspace.var("eff_ttbar_data"+info+"_"+channel) rrv_number = RooFormulaVar("rrv_number"+label+"_"+channel+spectrum, "(1-@0)*@1", RooArgList(eff_ttbar,rrv_number_total)) elif label.find("_ttbar_TotalMC")!=-1 and label.find("fail")==-1: rrv_number_total = RooRealVar("rrv_number_total_ttbar_TotalMC"+info+"_"+channel,"rrv_number_total_ttbar_TotalMC"+info+"_"+channel,500,0.,1e10) eff_ttbar = RooRealVar("eff_ttbar_TotalMC"+info+"_"+channel,"eff_ttbar_TotalMC"+info+"_"+channel,0.7,0.2,1.0) if peak == "Wt": eff_ttbar = RooRealVar("eff_ttbar_TotalMC"+info+"_"+channel,"eff_ttbar_TotalMC"+info+"_"+channel,0.7,0.0,1.0) rrv_number = RooFormulaVar("rrv_number"+label+"_"+channel+spectrum, "@0*@1", RooArgList(eff_ttbar,rrv_number_total)) elif label.find("_ttbar_TotalMC")!=-1 and label.find("fail")!=-1: rrv_number_total = workspace.var("rrv_number_total_ttbar_TotalMC"+info+"_"+channel) eff_ttbar = workspace.var("eff_ttbar_TotalMC"+info+"_"+channel) rrv_number = RooFormulaVar("rrv_number"+label+"_"+channel+spectrum, "(1-@0)*@1", RooArgList(eff_ttbar,rrv_number_total)) model_pdf = MakeGeneralPdf(workspace,label,model,spectrum,wtagger,channel,constraint,peak) model = RooExtendPdf("model"+label+"_"+channel+spectrum,"model"+label+"_"+channel+spectrum, model_pdf, rrv_number) getattr(workspace,"import")(model) return workspace.pdf("model"+label+"_"+channel+spectrum)
def __init__(self, super=False): DoubleGauss.__init__(self, super=super) sXY = ('x', 'y') s12 = ('1', '2') diffW = {name: RooRealVar(name, name, 0.01, 1.7) for name in \ [c+'WidthW'+i+'Diff' for c in sXY for i in s12]} widthW = {c+'WidthW'+i: RooFormulaVar(c+'WidthW'+i, c+'WidthN'+i+'+'+ \ c+'WidthM'+i+'Diff'+'+'+c+'WidthW'+i+'Diff', \ RooArgList(diffW[c+'WidthW'+i+'Diff'], \ self.Parameter[c+'WidthM'+i+'Diff'], self.Parameter[c+'WidthN'+i])) for c in sXY for i in s12} rhoW = {name: RooRealVar(name, name, -0.48, 0.48) for name in \ ['rhoW'+i for i in s12]} if super: self.super = True extra = {name: RooRealVar(name, name, 0.0, 1.0) for name in \ ['w'+i+'MFraction' for i in s12]} nf = [('M', lambda i: 'w'+i+'MFraction*(1.0-w'+i+'N)'), \ ('W', lambda i: '(1.0-w'+i+'MFraction)*(1.0-w'+i+'N)')] w = {'w'+i+n: RooFormulaVar('w'+i+n, f(i), \ RooArgList(extra['w'+i+'MFraction'], self.Parameter['w'+i+'N'])) \ for i in s12 for (n, f) in nf} else: extra = {name: RooRealVar(name, name, 0.0, 0.5*pi) for name in \ [a+i for a in ('theta', 'phi') for i in s12]} nf = [('N', lambda i: 'sin(theta'+i+')**2*cos(phi'+i+')**2'), \ ('M', lambda i: 'sin(theta'+i+')**2*sin(phi'+i+')**2'), \ ('W', lambda i: 'cos(theta'+i+')**2')] w = {'w'+i+n: RooFormulaVar('w'+i+n, f(i), \ RooArgList(extra['theta'+i], extra['phi'+i])) for i in s12 \ for (n, f) in nf} for d in (diffW, widthW, rhoW, extra, w): self.Parameter.update(d)
def __init__(self, name, formula, arglist, error=None): """Initialize a variable. Takes a name, a formula (strings), an list of variables (RooArgList) the variable depends on, and (optionally) an error (function). """ RooFormulaVar.__init__(self, name, name, formula, arglist) self.set_error(error)
def makeMorphingPdf(self, component, useAlternateModels, convModels): if self.ws.pdf(component): return self.ws.pdf(component) filesNom = getattr(self.pars, '%s_NomFiles' % component) modelsNom = getattr(self.pars, '%s_NomModels' % component) filesMU = getattr(self.pars, '%s_MUFiles' % component) modelsMU = getattr(self.pars, '%s_MUModels' % component) filesMD = getattr(self.pars, '%s_MDFiles' % component) modelsMD = getattr(self.pars, '%s_MDModels' % component) filesSU = getattr(self.pars, '%s_SUFiles' % component) modelsSU = getattr(self.pars, '%s_SUModels' % component) filesSD = getattr(self.pars, '%s_SDFiles' % component) modelsSD = getattr(self.pars, '%s_SDModels' % component) if useAlternateModels: modelsNom = getattr(self.pars, '%s_NomModelsAlt' % component) modelsMU = getattr(self.pars, '%s_MUModelsAlt' % component) modelsMD = getattr(self.pars, '%s_MDModelsAlt' % component) modelsSU = getattr(self.pars, '%s_SUModelsAlt' % component) modelsSD = getattr(self.pars, '%s_SDModelsAlt' % component) # Adds five (sub)components for the component with suffixes Nom, MU, MD, SU, SD NomPdf = self.makeComponentPdf('%s_Nom' % component, filesNom, modelsNom, False, convModels) if hasattr(self, '%s_NomExpected' % component): setattr(self, '%sExpected' % component, getattr(self, '%s_NomExpected' % component)) MUPdf = self.makeComponentPdf('%s_MU' % component, filesMU, modelsMU, False, convModels) MDPdf = self.makeComponentPdf('%s_MD' % component, filesMD, modelsMD, False, convModels) SUPdf = self.makeComponentPdf('%s_SU' % component, filesSU, modelsSU, False, convModels) SDPdf = self.makeComponentPdf('%s_SD' % component, filesSD, modelsSD, False, convModels) fMU_comp = self.ws.factory("fMU_%s[0., -1., 1.]" % component) fSU_comp = self.ws.factory("fSU_%s[0., -1., 1.]" % component) fMU = RooFormulaVar("f_fMU_%s" % component, "1.0*@0*(@0 >= 0.)", RooArgList( fMU_comp ) ) fMD = RooFormulaVar("f_fMD_%s" % component, "-1.0*@0*(@0 < 0.)", RooArgList( fMU_comp ) ) fSU = RooFormulaVar("f_fSU_%s" % component, "@0*(@0 >= 0.)", RooArgList( fSU_comp ) ) fSD = RooFormulaVar("f_fSD_%s" % component, "@0*(-1)*(@0 < 0.)", RooArgList( fSU_comp ) ) fNom = RooFormulaVar("f_fNom_%s" % component, "(1.-abs(@0)-abs(@1))", RooArgList(fMU_comp,fSU_comp) ) morphPdf = RooAddPdf(component,component, RooArgList(MUPdf,MDPdf,SUPdf,SDPdf,NomPdf), RooArgList(fMU, fMD, fSU, fSD, fNom)) morphPdf.SetName(component) getattr(self.ws, 'import')(morphPdf) return self.ws.pdf(component)
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 FinalPlotter(inputDirForLimit): frame_nevents , canvas_nevents , YieldsInDataCards = PlotTotalNumberOfEvents(inputDirForLimit) YieldsInDataCards_HistFunc = YieldsInDataCards.CtOverCvDataHistFunc print frame_nevents frame_nevents.Print() canvas_limit , retobjects_limits = PlotLimitResults(inputDirForLimit.split("/")[1] , 3) Limits_HistFunc = retobjects_limits[0] print Limits_HistFunc Limits_HistFunc.Print() rTimes_nEvents = RooFormulaVar("UpperLimitOnNEvents" , "UpperLimitOnNEvents" , "@0*@1" , RooArgList( Limits_HistFunc , YieldsInDataCards_HistFunc ) ) canvas_nevents.cd() rTimes_nEvents.plotOn( frame_nevents , RooFit.LineColor( kGreen ) ).getCurve().SetTitle("Upper limit on #events") frame_nevents.Draw() return (frame_nevents, canvas_nevents, YieldsInDataCards, canvas_limit, retobjects_limits, Limits_HistFunc, rTimes_nEvents )
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 rooFit103(): print ">>> construct generic pdf from interpreted expression..." # To construct a proper p.d.f, the formula expression is explicitly normalized internally # by dividing it by a numeric integral of the expresssion over x in the range [-20,20] x = RooRealVar("x", "x", -20, 20) alpha = RooRealVar("alpha", "alpha", 5, 0.1, 10) genpdf = RooGenericPdf("genpdf", "genpdf", "(1+0.1*abs(x)+sin(sqrt(abs(x*alpha+0.1))))", RooArgList(x, alpha)) print ">>> generate and fit toy data...\n" data = genpdf.generate(RooArgSet(x), 10000) # RooDataSet genpdf.fitTo(data) frame1 = x.frame(Title("Interpreted expression pdf")) # RooPlot data.plotOn(frame1, Binning(40)) genpdf.plotOn(frame1) print "\n>>> construct standard pdf with formula replacing parameter..." mean2 = RooRealVar("mean2", "mean^2", 10, 0, 200) sigma = RooRealVar("sigma", "sigma", 3, 0.1, 10) mean = RooFormulaVar("mean", "mean", "sqrt(mean2)", RooArgList(mean2)) gaus2 = RooGaussian("gaus2", "gaus2", x, mean, sigma) print ">>> generate and fit toy data...\n" gaus1 = RooGaussian("gaus1", "gaus1", x, RooConst(10), RooConst(3)) data2 = gaus1.generate(RooArgSet(x), 1000) # RooDataSet result = gaus2.fitTo(data2, Save()) # RooFitResult result.Print() frame2 = x.frame(Title("Tailored Gaussian pdf")) # RooPlot data2.plotOn(frame2, Binning(40)) gaus2.plotOn(frame2) print "\n>>> draw pfds and fits on canvas..." canvas = TCanvas("canvas", "canvas", 100, 100, 1400, 600) canvas.Divide(2) canvas.cd(1) gPad.SetLeftMargin(0.15) gPad.SetRightMargin(0.02) frame1.GetYaxis().SetLabelOffset(0.008) frame1.GetYaxis().SetTitleOffset(1.6) frame1.GetYaxis().SetTitleSize(0.045) frame1.GetXaxis().SetTitleSize(0.045) frame1.Draw() canvas.cd(2) gPad.SetLeftMargin(0.15) gPad.SetRightMargin(0.02) frame2.GetYaxis().SetLabelOffset(0.008) frame2.GetYaxis().SetTitleOffset(1.6) frame2.GetYaxis().SetTitleSize(0.045) frame2.GetXaxis().SetTitleSize(0.045) frame2.Draw() canvas.SaveAs("rooFit103.png")
def __init__(self, super=False): SingleGauss.__init__(self, uncorrelated=False) sXY = ('x', 'y') s12 = ('1', '2') diffM = {name: RooRealVar(name, name, 0.01, 1.7) for name in \ [c+'WidthM'+i+'Diff' for c in sXY for i in s12]} widthM = {c+'WidthM'+i: RooFormulaVar(c+'WidthM'+i, c+'WidthN'+i+'+'+ \ c+'WidthM'+i+'Diff', RooArgList(diffM[c+'WidthM'+i+'Diff'], \ self.Parameter[c+'WidthN'+i])) for c in sXY for i in s12} rhoM = {name: RooRealVar(name, name, -0.48, 0.48) for name in \ ['rhoM'+i for i in s12]} for i in s12: wN = self.Parameter['w' + i + 'N'] wN.setConstant(False) if super: wN.setRange(-1.0, 0.0) wN.setVal(-0.5) else: wN.setVal(0.5) self.Parameter['w' + i + 'N'] = wN wM = {'w'+i+'M': RooFormulaVar('w'+i+'M', '1.0-w'+i+'N', \ RooArgList(self.Parameter['w'+i+'N'])) for i in s12} for d in (diffM, widthM, rhoM, wM): self.Parameter.update(d)
def __init__(self,name,binning,formula,constraints={},forcePositive=True): '''Represents parametric functions as a group of RooFormulaVars which create a binned distribution and which change as the underlying function parameters change. Set parameter specific values by specifying the `constraints` argument with a dict formatted as \code{.json} {0: { 'constraint': 'flatParam' or 'param <mu> <sigma>', 'MIN' = -1000, 'MAX' = 1000, 'NOM' = 0, 'ERROR' = 0.1 } } \endcode The 'constraint' can only be 'flatParam' or 'param <mu> <sigma>' (options in the Combine card) which represent "no constraint" and "Gaussian constraint centered at <mu> and with width <sigma>", respectively. @param name (str): Unique name for the new object. @param formula (str): Must reference fit parameters by ordinal with @. Use "x" and "y" to represent the "x" and "y" axes of the space. All other terms are indexed starting at 0. Ex. "@0 + x*@1 +y*@2". @param constraints (dict, optional): Map of formula parameters to constraint information. Defaults to {} in which case the constraint will be flat, the starting value of the parameter will be 0 with a step size of 0.1, and the range of the parameter will be [-1000,1000]. @param forcePositive (bool, optional). Defaults to True in which case the bin values will be lower bound by 1e-9. ''' super(ParametricFunction,self).__init__(name,binning,forcePositive) self.formula = formula self.nuisances = self._createFuncVars(constraints) self.arglist = RooArgList() for n in self.nuisances: self.arglist.add(n['obj']) for cat in _subspace: cat_name = name+'_'+cat for ybin in range(1,len(self.binning.ybinList)): for xbin in range(1,len(self.binning.xbinByCat[cat])): bin_name = '%s_bin_%s-%s'%(cat_name,xbin,ybin) xConst,yConst = self.mappedBinCenter(xbin,ybin,cat) if forcePositive: final_formula = "max(1e-9,%s)"%(self._replaceXY(xConst,yConst)) else: final_formula = self._replaceXY(xConst,yConst) self.binVars[bin_name] = RooFormulaVar( bin_name, bin_name, final_formula, self.arglist )
def singleBinInterp(name, nuis, binVar, upVal, downVal, forcePositive): '''Create a RooFormulaVar containing the nuisance parameter that can morph the initial `binVar` value between the values of `upVal` and `downVal`. To accomodate the potential for multiple shape templates, the new parameter will control the relative yield of the bin (ie. as a percentage). This means for a nuisance value of 0, the multiplicative term on the bin yield will be 1. For nuisance value +1(-1), the multiplicative term on the bin yield will be the ratio of the bin value in `up_shape`(`down_shape`) to the starting nominal value. If `forcePositive` is True, the parameters will extrapolate bin values above(below) nuisance values of +1(-1) using exponentials so that the values asymptotically approach 0. When `forcePositive` is False, the values are exptrapolated linearly. For asymmetric uncertainties in a given nuisance `n`, the region defined by `n > -1` and `n < 1` is modeled using sigmoid functions which smoothly turn "on" and "off" the extrapolated pieces. This modeling provides a consistent description between -1 and 1, satisifies the boundary conditions at `n` of 0, 1, and -1, and is continuous in its first and second derivatives. Args: name (str): Name for output RooFormulaVar. nuis (RooRealVar): Parameter to control yield changes across multiple bins. binVar (RooAbsReal): Current bin value represented as RooRealVar or RooFormulaVar (derives from RooAbsReal). upVal (float): Absolute "up" variation of the bin value. downVal (float): Absolute "down" variation of the bin value. forcePositive (bool): If True, shape template mapping will use exponentials so that values asymptotically approach zero as the associated nuisance increases/decreases. If False, the mapping will be linear. Returns: RooFormulaVar: New bin value which includes interpolation term. ''' activate_pos = '(1/(1 + exp(-5x)))' # Use sigmoid for activation activate_neg = '(1/(1 + exp(5x)))' if forcePositive: pos_term = '({u}^@0)'.format(u=upVal) neg_term = '({d}^(-1*@0))'.format(d=downVal) else: pos_term = '(1+({u}-1)*@0)'.format(u=upVal) neg_term = '(1+(1-{d})*@0)'.format(d=downVal) full = '@1*({act_pos}*{pos}+{act_neg}*{neg})/{nom}'.format(act_pos=activate_pos, act_neg=activate_neg, pos=pos_term, neg=neg_term, nom=binVar.getValV()) return RooFormulaVar(name, name, full, RooArgList(nuis,binVar))
def _manipulate(self,name,other,operator=''): '''Base method to create a new Generic2D object. When combining `self` and `other`, a new set of RooFormulaVars will be created for the new Generic2D object that connect `self` and `other` with the `operator` string. The associated nuisances of `self` and `other` will also be passed to the new object as one set (with potential duplicates removed). If attempting to add, subtract, multiply, or divide, use the dedicated methods. More complex use cases could be built here. Args: name (str): Unique name for the new output Generic2D object. other (Generic2D): Object to combine with self. operator (str, optional): Connecting mathematical operator string for the combination. Defaults to '*' which causes the method to return self*other. Returns: Generic2D: Object containing the combination of `self` and `other`. ''' out = Generic2D(name,self.binning,self.forcePositive) for cat in _subspace: new_cat_name = name+'_'+cat for ybin in range(1,len(self.binning.ybinList)): for xbin in range(1,len(self.binning.xbinByCat[cat])): new_bin_name = '%s_bin_%s-%s'%(new_cat_name,xbin,ybin) self_bin_name = new_bin_name.replace(new_cat_name, self.name+'_'+cat) other_bin_name = new_bin_name.replace(new_cat_name, other.name+'_'+cat) out.binVars[new_bin_name] = RooFormulaVar( new_bin_name, new_bin_name, '@0%s@1'%operator, RooArgList( self.binVars[self_bin_name], other.binVars[other_bin_name])) all_nuisances = self.nuisances+other.nuisances for nuisance in all_nuisances: if nuisance['name'] in [n['name'] for n in out.nuisances]: raise RuntimeError('Already tracking nuisance %s. Printing all nuisances...\n\t'%(nuisance['name'],all_nuisances)) out.nuisances.append(nuisance) return out
def signal(category): interPar = True n = len(genPoints) cColor = color[category] if category in color else 4 nBtag = category.count('b') isAH = False #relict from using Alberto's more complex script if not os.path.exists(PLOTDIR+"MC_signal_"+YEAR): os.makedirs(PLOTDIR+"MC_signal_"+YEAR) #*******************************************************# # # # Variables and selections # # # #*******************************************************# X_mass = RooRealVar ( "jj_mass_widejet", "m_{jj}", X_min, X_max, "GeV") j1_pt = RooRealVar( "jpt_1", "jet1 pt", 0., 13000., "GeV") jj_deltaEta = RooRealVar( "jj_deltaEta_widejet", "", 0., 5.) jbtag_WP_1 = RooRealVar("jbtag_WP_1", "", -1., 4. ) jbtag_WP_2 = RooRealVar("jbtag_WP_2", "", -1., 4. ) fatjetmass_1 = RooRealVar("fatjetmass_1", "", -1., 2500. ) fatjetmass_2 = RooRealVar("fatjetmass_2", "", -1., 2500. ) jid_1 = RooRealVar( "jid_1", "j1 ID", -1., 8.) jid_2 = RooRealVar( "jid_2", "j2 ID", -1., 8.) jnmuons_1 = RooRealVar( "jnmuons_1", "j1 n_{#mu}", -1., 8.) jnmuons_2 = RooRealVar( "jnmuons_2", "j2 n_{#mu}", -1., 8.) jmuonpt_1 = RooRealVar( "jmuonpt_1", "j1 muon pt", 0., 13000.) jmuonpt_2 = RooRealVar( "jmuonpt_2", "j2 muon pt", 0., 13000.) nmuons = RooRealVar( "nmuons", "n_{#mu}", -1., 10. ) nelectrons = RooRealVar("nelectrons", "n_{e}", -1., 10. ) HLT_AK8PFJet500 = RooRealVar("HLT_AK8PFJet500" , "", -1., 1. ) HLT_PFJet500 = RooRealVar("HLT_PFJet500" , "" , -1., 1. ) HLT_CaloJet500_NoJetID = RooRealVar("HLT_CaloJet500_NoJetID" , "" , -1., 1. ) HLT_PFHT900 = RooRealVar("HLT_PFHT900" , "" , -1., 1. ) HLT_AK8PFJet550 = RooRealVar("HLT_AK8PFJet550" , "", -1., 1. ) HLT_PFJet550 = RooRealVar("HLT_PFJet550" , "" , -1., 1. ) HLT_CaloJet550_NoJetID = RooRealVar("HLT_CaloJet550_NoJetID" , "" , -1., 1. ) HLT_PFHT1050 = RooRealVar("HLT_PFHT1050" , "" , -1., 1. ) HLT_DoublePFJets100_CaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets100_CaloBTagDeepCSV_p71" , "", -1., 1. ) HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71", "", -1., 1. ) HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71", "", -1., 1. ) HLT_DoublePFJets200_CaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets200_CaloBTagDeepCSV_p71" , "", -1., 1. ) HLT_DoublePFJets350_CaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets350_CaloBTagDeepCSV_p71" , "", -1., 1. ) HLT_DoublePFJets40_CaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets40_CaloBTagDeepCSV_p71" , "", -1., 1. ) weight = RooRealVar( "eventWeightLumi", "", -1.e9, 1.e9 ) # Define the RooArgSet which will include all the variables defined before # there is a maximum of 9 variables in the declaration, so the others need to be added with 'add' variables = RooArgSet(X_mass) variables.add(RooArgSet(j1_pt, jj_deltaEta, jbtag_WP_1, jbtag_WP_2, fatjetmass_1, fatjetmass_2, jnmuons_1, jnmuons_2, weight)) variables.add(RooArgSet(nmuons, nelectrons, jid_1, jid_2, jmuonpt_1, jmuonpt_2)) variables.add(RooArgSet(HLT_AK8PFJet500, HLT_PFJet500, HLT_CaloJet500_NoJetID, HLT_PFHT900, HLT_AK8PFJet550, HLT_PFJet550, HLT_CaloJet550_NoJetID, HLT_PFHT1050)) variables.add(RooArgSet(HLT_DoublePFJets100_CaloBTagDeepCSV_p71, HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71, HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71, HLT_DoublePFJets200_CaloBTagDeepCSV_p71, HLT_DoublePFJets350_CaloBTagDeepCSV_p71, HLT_DoublePFJets40_CaloBTagDeepCSV_p71)) X_mass.setRange("X_reasonable_range", X_mass.getMin(), X_mass.getMax()) X_mass.setRange("X_integration_range", X_mass.getMin(), X_mass.getMax()) if VARBINS: binsXmass = RooBinning(len(abins)-1, abins) X_mass.setBinning(binsXmass) plot_binning = RooBinning(int((X_mass.getMax()-X_mass.getMin())/100), X_mass.getMin(), X_mass.getMax()) else: X_mass.setBins(int((X_mass.getMax()-X_mass.getMin())/10)) binsXmass = RooBinning(int((X_mass.getMax()-X_mass.getMin())/100), X_mass.getMin(), X_mass.getMax()) plot_binning = binsXmass X_mass.setBinning(plot_binning, "PLOT") #X_mass.setBins(int((X_mass.getMax() - X_mass.getMin())/10)) #binsXmass = RooBinning(int((X_mass.getMax() - X_mass.getMin())/100), X_mass.getMin(), X_mass.getMax()) #X_mass.setBinning(binsXmass, "PLOT") massArg = RooArgSet(X_mass) # Cuts if BTAGGING=='semimedium': SRcut = aliasSM[category] #SRcut = aliasSM[category+"_vetoAK8"] else: SRcut = alias[category].format(WP=working_points[BTAGGING]) #SRcut = alias[category+"_vetoAK8"].format(WP=working_points[BTAGGING]) if ADDSELECTION: SRcut += SELECTIONS[options.selection] print " Cut:\t", SRcut #*******************************************************# # # # Signal fits # # # #*******************************************************# treeSign = {} setSignal = {} vmean = {} vsigma = {} valpha1 = {} vslope1 = {} valpha2 = {} vslope2 = {} smean = {} ssigma = {} salpha1 = {} sslope1 = {} salpha2 = {} sslope2 = {} sbrwig = {} signal = {} signalExt = {} signalYield = {} signalIntegral = {} signalNorm = {} signalXS = {} frSignal = {} frSignal1 = {} frSignal2 = {} frSignal3 = {} # Signal shape uncertainties (common amongst all mass points) xmean_jes = RooRealVar("CMS"+YEAR+"_sig_"+category+"_p1_scale_jes", "Variation of the resonance position with the jet energy scale", 0.02, -1., 1.) #0.001 smean_jes = RooRealVar("CMS"+YEAR+"_sig_"+category+"_p1_jes", "Change of the resonance position with the jet energy scale", 0., -10, 10) xsigma_jer = RooRealVar("CMS"+YEAR+"_sig_"+category+"_p2_scale_jer", "Variation of the resonance width with the jet energy resolution", 0.10, -1., 1.) ssigma_jer = RooRealVar("CMS"+YEAR+"_sig_"+category+"_p2_jer", "Change of the resonance width with the jet energy resolution", 0., -10, 10) xmean_jes.setConstant(True) smean_jes.setConstant(True) xsigma_jer.setConstant(True) ssigma_jer.setConstant(True) for m in massPoints: signalMass = "%s_M%d" % (stype, m) signalName = "ZpBB_{}_{}_M{}".format(YEAR, category, m) sampleName = "bstar_M{}".format(m) signalColor = sample[sampleName]['linecolor'] if signalName in sample else 1 # define the signal PDF vmean[m] = RooRealVar(signalName + "_vmean", "Crystal Ball mean", m, m*0.96, m*1.05) smean[m] = RooFormulaVar(signalName + "_mean", "@0*(1+@1*@2)", RooArgList(vmean[m], xmean_jes, smean_jes)) vsigma[m] = RooRealVar(signalName + "_vsigma", "Crystal Ball sigma", m*0.0233, m*0.019, m*0.025) ssigma[m] = RooFormulaVar(signalName + "_sigma", "@0*(1+@1*@2)", RooArgList(vsigma[m], xsigma_jer, ssigma_jer)) valpha1[m] = RooRealVar(signalName + "_valpha1", "Crystal Ball alpha 1", 0.2, 0.05, 0.28) # number of sigmas where the exp is attached to the gaussian core. >0 left, <0 right salpha1[m] = RooFormulaVar(signalName + "_alpha1", "@0", RooArgList(valpha1[m])) #vslope1[m] = RooRealVar(signalName + "_vslope1", "Crystal Ball slope 1", 10., 0.1, 20.) # slope of the power tail vslope1[m] = RooRealVar(signalName + "_vslope1", "Crystal Ball slope 1", 13., 10., 20.) # slope of the power tail sslope1[m] = RooFormulaVar(signalName + "_slope1", "@0", RooArgList(vslope1[m])) valpha2[m] = RooRealVar(signalName + "_valpha2", "Crystal Ball alpha 2", 1.) valpha2[m].setConstant(True) salpha2[m] = RooFormulaVar(signalName + "_alpha2", "@0", RooArgList(valpha2[m])) #vslope2[m] = RooRealVar(signalName + "_vslope2", "Crystal Ball slope 2", 6., 2.5, 15.) # slope of the higher power tail ## FIXME test FIXME vslope2_estimation = -5.88111436852 + m*0.00728809389442 + m*m*(-1.65059568762e-06) + m*m*m*(1.25128996309e-10) vslope2[m] = RooRealVar(signalName + "_vslope2", "Crystal Ball slope 2", vslope2_estimation, vslope2_estimation*0.9, vslope2_estimation*1.1) # slope of the higher power tail ## FIXME end FIXME sslope2[m] = RooFormulaVar(signalName + "_slope2", "@0", RooArgList(vslope2[m])) # slope of the higher power tail signal[m] = RooDoubleCrystalBall(signalName, "m_{%s'} = %d GeV" % ('X', m), X_mass, smean[m], ssigma[m], salpha1[m], sslope1[m], salpha2[m], sslope2[m]) # extend the PDF with the yield to perform an extended likelihood fit signalYield[m] = RooRealVar(signalName+"_yield", "signalYield", 50, 0., 1.e15) signalNorm[m] = RooRealVar(signalName+"_norm", "signalNorm", 1., 0., 1.e15) signalXS[m] = RooRealVar(signalName+"_xs", "signalXS", 1., 0., 1.e15) signalExt[m] = RooExtendPdf(signalName+"_ext", "extended p.d.f", signal[m], signalYield[m]) # ---------- if there is no simulated signal, skip this mass point ---------- if m in genPoints: if VERBOSE: print " - Mass point", m # define the dataset for the signal applying the SR cuts treeSign[m] = TChain("tree") if YEAR=='run2': pd = sample[sampleName]['files'] if len(pd)>3: print "multiple files given than years for a single masspoint:",pd sys.exit() for ss in pd: if not '2016' in ss and not '2017' in ss and not '2018' in ss: print "unknown year given in:", ss sys.exit() else: pd = [x for x in sample[sampleName]['files'] if YEAR in x] if len(pd)>1: print "multiple files given for a single masspoint/year:",pd sys.exit() for ss in pd: if options.unskimmed: j=0 while True: if os.path.exists(NTUPLEDIR + ss + "/" + ss + "_flatTuple_{}.root".format(j)): treeSign[m].Add(NTUPLEDIR + ss + "/" + ss + "_flatTuple_{}.root".format(j)) j += 1 else: print "found {} files for sample:".format(j), ss break else: if os.path.exists(NTUPLEDIR + ss + ".root"): treeSign[m].Add(NTUPLEDIR + ss + ".root") else: print "found no file for sample:", ss if treeSign[m].GetEntries() <= 0.: if VERBOSE: print " - 0 events available for mass", m, "skipping mass point..." signalNorm[m].setVal(-1) vmean[m].setConstant(True) vsigma[m].setConstant(True) salpha1[m].setConstant(True) sslope1[m].setConstant(True) salpha2[m].setConstant(True) sslope2[m].setConstant(True) signalNorm[m].setConstant(True) signalXS[m].setConstant(True) continue #setSignal[m] = RooDataSet("setSignal_"+signalName, "setSignal", variables, RooFit.Cut(SRcut), RooFit.WeightVar("eventWeightLumi*BTagAK4Weight_deepJet"), RooFit.Import(treeSign[m])) setSignal[m] = RooDataSet("setSignal_"+signalName, "setSignal", variables, RooFit.Cut(SRcut), RooFit.WeightVar(weight), RooFit.Import(treeSign[m])) if VERBOSE: print " - Dataset with", setSignal[m].sumEntries(), "events loaded" # FIT entries = setSignal[m].sumEntries() if entries < 0. or entries != entries: entries = 0 signalYield[m].setVal(entries) # Instead of eventWeightLumi #signalYield[m].setVal(entries * LUMI / (300000 if YEAR=='run2' else 100000) ) if treeSign[m].GetEntries(SRcut) > 5: if VERBOSE: print " - Running fit" frSignal[m] = signalExt[m].fitTo(setSignal[m], RooFit.Save(1), RooFit.Extended(True), RooFit.SumW2Error(True), RooFit.PrintLevel(-1)) if VERBOSE: print "********** Fit result [", m, "] **", category, "*"*40, "\n", frSignal[m].Print(), "\n", "*"*80 if VERBOSE: frSignal[m].correlationMatrix().Print() drawPlot(signalMass+"_"+category, stype+category, X_mass, signal[m], setSignal[m], frSignal[m]) else: print " WARNING: signal", stype, "and mass point", m, "in category", category, "has 0 entries or does not exist" # Remove HVT cross sections #xs = getCrossSection(stype, channel, m) xs = 1. signalXS[m].setVal(xs * 1000.) signalIntegral[m] = signalExt[m].createIntegral(massArg, RooFit.NormSet(massArg), RooFit.Range("X_integration_range")) boundaryFactor = signalIntegral[m].getVal() if boundaryFactor < 0. or boundaryFactor != boundaryFactor: boundaryFactor = 0 if VERBOSE: print " - Fit normalization vs integral:", signalYield[m].getVal(), "/", boundaryFactor, "events" signalNorm[m].setVal( boundaryFactor * signalYield[m].getVal() / signalXS[m].getVal()) # here normalize to sigma(X) x Br = 1 [fb]
def buildDataAndCategories(ws, options, args): #Get the input data inputData = TChain(options.treeName, 'The input data') for arg in args: print 'Adding data from: ', arg inputData.Add(arg) foldname = '' phirange = [0, 90] if not options.folded: foldname = '' phirange = [-180, 180] #variables necessary for j/psi mass,lifetime,polarization fit jPsiMass = RooRealVar('JpsiMass', 'M [GeV]', 2.7, 3.5) jPsiRap = RooRealVar('JpsiRap', '#nu', -2.3, 2.3) jPsiPt = RooRealVar("JpsiPt", "pT [GeV]", 0, 40) jPsicTau = RooRealVar('Jpsict', 'l_{J/#psi} [mm]', -1, 2.5) jPsicTauError = RooRealVar('JpsictErr', 'Error on l_{J/#psi} [mm]', 0, 2) jPsiVprob = RooRealVar('JpsiVprob', '', .01, 1) jPsiHXcosth = None jPsiHXphi = None jPsicTau.setBins(10000, "cache") if options.fitFrame is not None: jPsiHXcosth = RooRealVar('costh_' + options.fitFrame + foldname, 'cos(#theta)_{' + options.fitFrame + '}', -1, 1) jPsiHXphi = RooRealVar('phi_' + options.fitFrame + foldname, '#phi_{' + options.fitFrame + '}', phirange[0], phirange[1]) else: jPsiHXcosth = RooRealVar('costh_CS' + foldname, 'cos(#theta)_{CS}', -1, 1) jPsiHXphi = RooRealVar('phi_CS' + foldname, '#phi_{CS}', phirange[0], phirange[1]) #vars needed for on the fly calc of polarization variables jPsimuPosPx = RooRealVar('muPosPx', '+ Muon P_{x} [GeV]', 0) jPsimuPosPy = RooRealVar('muPosPy', '+ Muon P_{y} [GeV]', 0) jPsimuPosPz = RooRealVar('muPosPz', '+ Muon P_{z} [GeV]', 0) jPsimuNegPx = RooRealVar('muNegPx', '- Muon P_{x} [GeV]', 0) jPsimuNegPy = RooRealVar('muNegPy', '- Muon P_{y} [GeV]', 0) jPsimuNegPz = RooRealVar('muNegPz', '- Muon P_{z} [GeV]', 0) #create RooArgSet for eventual dataset creation dataVars = RooArgSet(jPsiMass, jPsiRap, jPsiPt, jPsicTau, jPsicTauError, jPsimuPosPx, jPsimuPosPy, jPsimuPosPz) #add trigger requirement if specified if options.triggerName: trigger = RooRealVar(options.triggerName, 'Passes Trigger', 0.5, 1.5) dataVars.add(trigger) dataVars.add(jPsiVprob) dataVars.add(jPsimuNegPx) dataVars.add(jPsimuNegPy) dataVars.add(jPsimuNegPz) dataVars.add(jPsiHXcosth) dataVars.add(jPsiHXphi) redVars = RooArgSet(jPsiMass, jPsiRap, jPsiPt, jPsicTau, jPsicTauError) redVars.add(jPsiHXcosth) redVars.add(jPsiHXphi) fitVars = redVars.Clone() ### HERE IS WHERE THE BIT FOR CALCULATING POLARIZATION VARS GOES ctauStates = RooCategory('ctauRegion', 'Cut Region in lifetime') ctauStates.defineType('prompt', 0) ctauStates.defineType('nonPrompt', 1) massStates = RooCategory('massRegion', 'Cut Region in mass') massStates.defineType('signal', 1) massStates.defineType('separation', 0) massStates.defineType('leftMassSideBand', -2) massStates.defineType('rightMassSideBand', -1) states = RooCategory('mlRegion', 'Cut Region in mass') states.defineType('nonPromptSignal', 2) states.defineType('promptSignal', 1) states.defineType('separation', 0) states.defineType('leftMassSideBand', -2) states.defineType('rightMassSideBand', -1) #define corresponding ranges in roorealvars #mass is a little tricky since the sidebands change definitions in each rap bin #define the names here and change as we do the fits #jPsiMass.setRange('NormalizationRangeFormlfit_promptSignal',2.7,3.5) #jPsiMass.setRange('NormalizationRangeFormlfit_nonPromptSignal',2.7,3.5) #jPsiMass.setRange('NormalizationRangeFormlfit_leftMassSideBand',2.7,3.1) #jPsiMass.setRange('NormalizationRangeFormlfit_rightMassSideBand',3.1,3.5) #want the prompt fit only done in prompt region #non-prompt only in non-prompt region #background over entire cTau range #jPsicTau.setRange('NormalizationRangeFormlfit_promptSignal',-1,.1) #jPsicTau.setRange('NormalizationRangeFormlfit_nonPromptSignal',.1,2.5) #jPsicTau.setRange('NormalizationRangeFormlfit_leftMassSideBand',-1,2.5) #jPsicTau.setRange('NormalizationRangeFormlfit_rightMassSideBand',-1,2.5) #redVars.add(ctauStates) #redVars.add(massStates) #redVars.add(states) fitVars.add(ctauStates) fitVars.add(massStates) fitVars.add(states) fullData = RooDataSet('fullData', 'The Full Data From the Input ROOT Trees', dataVars, ROOT.RooFit.Import(inputData)) for rap_bin in range(1, len(jpsi.pTRange)): yMin = jpsi.rapForPTRange[rap_bin - 1][0] yMax = jpsi.rapForPTRange[rap_bin - 1][-1] for pt_bin in range(len(jpsi.pTRange[rap_bin])): ptMin = jpsi.pTRange[rap_bin][pt_bin][0] ptMax = jpsi.pTRange[rap_bin][pt_bin][-1] sigMaxMass = jpsi.polMassJpsi[ rap_bin] + jpsi.nSigMass * jpsi.sigmaMassJpsi[rap_bin] sigMinMass = jpsi.polMassJpsi[ rap_bin] - jpsi.nSigMass * jpsi.sigmaMassJpsi[rap_bin] sbHighMass = jpsi.polMassJpsi[ rap_bin] + jpsi.nSigBkgHigh * jpsi.sigmaMassJpsi[rap_bin] sbLowMass = jpsi.polMassJpsi[ rap_bin] - jpsi.nSigBkgLow * jpsi.sigmaMassJpsi[rap_bin] ctauNonPrompt = .1 massFun = RooFormulaVar( 'massRegion', 'Function that returns the mass state.', '(' + jPsiMass.GetName() + ' < ' + str(sigMaxMass) + ' && ' + jPsiMass.GetName() + ' > ' + str(sigMinMass) + ') - (' + jPsiMass.GetName() + ' > ' + str(sbHighMass) + ')' + '-2*(' + jPsiMass.GetName() + ' < ' + str(sbLowMass) + ')', RooArgList(jPsiMass, jPsicTau)) ctauFun = RooFormulaVar( 'ctauRegion', 'Function that returns the ctau state.', '(' + jPsicTau.GetName() + ' > ' + str(ctauNonPrompt) + ')', RooArgList(jPsiMass, jPsicTau)) mlFun = RooFormulaVar( 'mlRegion', 'Function that returns the mass and lifetime state.', '(' + jPsiMass.GetName() + ' < ' + str(sigMaxMass) + ' && ' + jPsiMass.GetName() + ' > ' + str(sigMinMass) + ') + (' + jPsiMass.GetName() + ' < ' + str(sigMaxMass) + ' && ' + jPsiMass.GetName() + ' > ' + str(sigMinMass) + ' && ' + jPsicTau.GetName() + ' > ' + str(ctauNonPrompt) + ') - (' + jPsiMass.GetName() + ' > ' + str(sbHighMass) + ')' + '-2*(' + jPsiMass.GetName() + ' < ' + str(sbLowMass) + ')', RooArgList(jPsiMass, jPsicTau)) cutStringPt = '(' + jPsiPt.GetName() + ' > ' + str( ptMin) + ' && ' + jPsiPt.GetName() + ' < ' + str(ptMax) + ')' cutStringY = '( abs(' + jPsiRap.GetName() + ') > ' + str( yMin) + ' && abs(' + jPsiRap.GetName() + ') < ' + str( yMax) + ')' #cutStringM1 = '('+jPsiMass.GetName()+' < '+str(sigMinMass)+' && '+jPsiMass.GetName()+' > '+str(sbLowMass)+')' #cutStringM2 = '('+jPsiMass.GetName()+' < '+str(sbHighMass)+' && '+jPsiMass.GetName()+' > '+str(sigMaxMass)+')' #cutStringMT = '!('+cutStringM1+' || '+cutStringM2+')' cutString = cutStringPt + ' && ' + cutStringY #+' && '+cutStringMT print cutString #get the reduced dataset we'll do the fit on binData = fullData.reduce( ROOT.RooFit.SelectVars(redVars), ROOT.RooFit.Cut(cutString), ROOT.RooFit.Name('data_rap' + str(rap_bin) + '_pt' + str(pt_bin + 1)), ROOT.RooFit.Title('Data For Fitting')) binDataWithCategory = RooDataSet( 'data_rap' + str(rap_bin) + '_pt' + str(pt_bin + 1), 'Data For Fitting', fitVars) #categorize binData.addColumn(ctauStates) binData.addColumn(massStates) binData.addColumn(states) for ev in range(binData.numEntries()): args = binData.get(ev) jPsiMass.setVal(args.find(jPsiMass.GetName()).getVal()) jPsiRap.setVal(args.find(jPsiRap.GetName()).getVal()) jPsiPt.setVal(args.find(jPsiPt.GetName()).getVal()) jPsicTau.setVal(args.find(jPsicTau.GetName()).getVal()) jPsicTauError.setVal( args.find(jPsicTauError.GetName()).getVal()) jPsiHXcosth.setVal(args.find(jPsiHXcosth.GetName()).getVal()) jPsiHXphi.setVal(args.find(jPsiHXphi.GetName()).getVal()) massStates.setIndex(int(massFun.getVal())) ctauStates.setIndex(int(ctauFun.getVal())) states.setIndex(int(mlFun.getVal())) binDataWithCategory.add(fitVars) getattr(ws, 'import')(binDataWithCategory)
x = RooRealVar("Qvalue","Qvalue",10.35,10.8) x.setBins(90) sigma_1S = RooRealVar("sigma_1S","#sigma(3P1)1S", 0.014) sigma_2S = RooRealVar("sigma_2S","#sigma(3P1)2S", 0.010) alpha_1S = RooRealVar("alpha_1S","#alpha(3P)1S", 0.6) alpha_2S = RooRealVar("alpha_2S","#alpha(3P)2S", 0.6) n_1S = RooRealVar("n_1S","n(3P1)1S", 2.5) n_2S = RooRealVar("n_2S","n(3P1)2S", 2.5) rawmass = RooRealVar('rm','rm',10.5,10.4,10.6) mass3P_1S2 =RooFormulaVar("m1","(@0+@1)",RooArgList(rawmass,deltaM_v3s)) mass3P_2S2 =RooFormulaVar("m2","(@0+@1)",RooArgList(rawmass,deltaM_v3s)) mass3P_3S2 =RooFormulaVar("m3","(@0+@1)",RooArgList(rawmass,deltaM_v3s)) signal1S_1 = RooCBShape('signal1S1','s1S1',x,rawmass,sigma_1S,alpha_1S,n_1S) signal1S_2 = RooCBShape('signal1S2','s1S2',x,mass3P_1S2,sigma_1S,alpha_1S,n_1S) signal2S_1 = RooCBShape('signal2S1','s2S1',x,rawmass,sigma_2S,alpha_2S,n_2S) signal2S_2 = RooCBShape('signal2S2','s2S1',x,mass3P_2S2,sigma_2S,alpha_2S,n_2S) #3S parameters
def fitChicSpectrum(dataset, binname): """ Fit chic spectrum""" x = RooRealVar('s', 's', -2, 2) x.setBins(200) #signal model q_chi1 = RooRealVar('qchi1', 'q_{#chi 1}', 0.414, 0.2, 0.6) q_chi2 = RooRealVar('qchi2', 'q_{#chi 2}', 0.430, 0.2, 0.6) delta_chi10 = RooRealVar('delta_chi10', 'delta_chi10', 0.09591) q_chi0 = RooFormulaVar('q_chi0', '@0 - @1', RooArgList(q_chi1, delta_chi10)) alphacb_chi1 = RooRealVar('alphacb_chi1', '#alpha^{CB}_{#chi 1}', 0.6, 0, 2) alphacb_chi2 = RooRealVar('alphacb_chi2', '#alpha^{CB}_{#chi 2}', 0.4, 0, 2) sigmacb_chi1 = RooRealVar('sigmacb_chi1', '#sigma^{CB}_{#chi 1}', 0.005, 0, 1) sigmacb_chi2 = RooRealVar('sigmacb_chi2', '#sigma^{CB}_{#chi 2}', 0.005, 0, 1) n_cb = RooRealVar('ncb', 'n^{CB}', 3.0, 0., 5.) gamma_chi0 = RooRealVar('gamma_chi0', 'gamma_chi0', 0.0104) sigmacb_chi0 = RooRealVar('sigmacb_chi0', '#sigma^{CB}_{#chi 0}', 0.005) chi0_sig = RooVoigtian('chi0sig', 'chi0sig,', x, q_chi0, sigmacb_chi0, gamma_chi0) chi1_sig = RooCBShape('chi1sig', 'chi1sig', x, q_chi1, sigmacb_chi1, alphacb_chi1, n_cb) chi2_sig = RooCBShape('chi2sig', 'chi2sig', x, q_chi2, sigmacb_chi2, alphacb_chi2, n_cb) fchi0 = RooRealVar('fchi0', 'f_{#chi 0}', 0.01, 0, 1) fchi1 = RooRealVar('fchi1', 'f_{#chi 1}', 0.5, 0, 1) fchi2 = RooFormulaVar('fchi2', '1-@0-@1', RooArgList(fchi0, fchi1)) fbck = RooRealVar('fbck', 'f_{bck}', 0.2, 0, 1) sigmodel = RooAddPdf('sigm', 'sigm', RooArgList(chi0_sig, chi1_sig, chi2_sig), RooArgList(fchi0, fchi1, fchi2)) #background model q0Start = 0.0 a_bck = RooRealVar('a_bck', 'a_{bck}', 0.5, -5, 5) b_bck = RooRealVar('b_bck', 'b_{bck}', -2.5, -7., 0.) q0 = RooRealVar('q0', 'q0', q0Start) delta = RooFormulaVar('delta', 'TMath::Abs(@0-@1)', RooArgList(x, q0)) bfun = RooFormulaVar('bfun', '@0*(@1-@2)', RooArgList(b_bck, x, q0)) signum = RooFormulaVar('signum', '( TMath::Sign( -1.,@0-@1 )+1 )/2.', RooArgList(x, q0)) background = RooGenericPdf('background', 'Background', 'signum*pow(delta,a_bck)*exp(bfun)', RooArgList(signum, delta, a_bck, bfun)) modelPdf = RooAddPdf('chicmodel', 'chicmodel', RooArgList(sigmodel, background), RooArgList(fbck)) frame = x.frame(RooFit.Title('Q')) range = x.setRange('range', 0, 2) # result = modelPdf.fitTo(dataset,RooFit.Save(),RooFit.Range('range')) dataset.plotOn(frame, RooFit.MarkerSize(0.7)) modelPdf.plotOn(frame, RooFit.LineWidth(2)) #plotting canvas = TCanvas('fit', "", 1400, 700) canvas.Divide(1) canvas.cd(1) gPad.SetRightMargin(0.3) gPad.SetFillColor(10) modelPdf.paramOn(frame, RooFit.Layout(0.725, 0.9875, 0.9)) frame.Draw() canvas.SaveAs('out-' + binname + '.png') canvas.SaveAs('out-' + binname + '.root')
def mbc_dline_che(evtfile, mc, setMres, setGamma, setR, sp1, sp2, sp3, fa, fb, setmd, setp, setxi, setN1, setN2, setNbkgd1, setNbkgd2, title1, title2, epsfile, txtfile, ymin=0.5, cuts=None, err_type='SYMM', test=False): from ROOT import (gROOT, RooRealVar, RooCategory, RooArgSet, RooDataSet, RooFit, RooGaussian, RooArgList, RooAddPdf, RooSimultaneous, RooArgusBG, RooFormulaVar, RooChebychev, RooAbsData, RooDataHist, TCanvas, kRed, kBlue, kGreen, kMagenta, TPaveText, RooDLineShape) set_root_style(stat=1, grid=0) mbc = RooRealVar('mbc', 'Beam constrained mass', 1.83, 1.89, 'GeV') ebeam = RooRealVar('ebeam', 'Ebeam', 1.8815, 1.892, 'GeV') dflav = RooCategory('dflav', 'D0 flavor') dflav.defineType('dflav', 1) dflav.defineType('dbarflav', -1) if cuts != None: if 'kkmass' in cuts: kkmass = RooRealVar('kkmass', 'KK invariant mass', 0.97, 1.90, 'GeV') ras = RooArgSet(mbc, ebeam, kkmass, dflav) dataset = RooDataSet.read(evtfile, ras) else: raise NameError(cuts) sys.stdout.write('Using cuts: %s...' % cuts) dataset = dataset.reduce(cuts) sys.stdout.write(' selected %s events.\n' % dataset.numEntries()) else: ras = RooArgSet(mbc, ebeam, dflav) dataset = RooDataSet.read(evtfile, ras) res = RooRealVar("datares", "datares", mc) mres = RooRealVar("mres", "mres", setMres) gamma = RooRealVar('gamma', 'gamma', setGamma) r = RooRealVar('r', 'r', setR) sigmaE = RooRealVar("sigmaE", "sigmaE", 0.0021) sigmap1 = RooRealVar("sigmap1", "sigmap1", sp1, 0.002, 0.040) scalep2 = RooRealVar("scalep2", "scalep2", 2.00, 1.500, 5.500) scalep3 = RooRealVar("scalep3", "scalep3", 5.00, 3.00, 10.000) scalep2.setVal(sp2) scalep2.setConstant(1) scalep3.setVal(sp3) scalep3.setConstant(1) as12 = RooArgList(sigmap1, scalep2) sigmap2 = RooFormulaVar("sigmap2", "sigma2", "sigmap1*scalep2", as12) as123 = RooArgList(sigmap1, scalep2, scalep3) sigmap3 = RooFormulaVar("sigmap3", "sigma3", "sigmap1*scalep2*scalep3", as123) md = RooRealVar("md", "md", setmd, 1.863, 1.875) f2 = RooRealVar("f2", "f2", fa) f3 = RooRealVar("f3", "f3", fb) al23 = RooArgList(f2, f3) f1 = RooFormulaVar("f1", "f1", "1.0-f2-f3", al23) # Construct signal shape fcn1_1 = RooDLineShape("DLineshape1_1", "DLineShape1_1", 4, mbc, ebeam, mres, gamma, r, sigmaE, sigmap1, md, res) fcn1_2 = RooDLineShape("DLineshape1_2", "DLineShape1_2", 4, mbc, ebeam, mres, gamma, r, sigmaE, sigmap2, md, res) fcn1_3 = RooDLineShape("DLineshape1_3", "DLineShape1_3", 4, mbc, ebeam, mres, gamma, r, sigmaE, sigmap3, md, res) fcn2_1 = RooDLineShape("DLineshape2_1", "DLineShape2_1", 4, mbc, ebeam, mres, gamma, r, sigmaE, sigmap1, md, res) fcn2_2 = RooDLineShape("DLineshape2_2", "DLineShape2_2", 4, mbc, ebeam, mres, gamma, r, sigmaE, sigmap2, md, res) fcn2_3 = RooDLineShape("DLineshape2_3", "DLineShape2_3", 4, mbc, ebeam, mres, gamma, r, sigmaE, sigmap3, md, res) alf1_123 = RooArgList(fcn1_1, fcn1_2, fcn1_3) af12 = RooArgList(f1, f2) sigpdf = RooAddPdf("signal1_3", "signal1_3", alf1_123, af12) alf2_123 = RooArgList(fcn2_1, fcn2_2, fcn2_3) sigbarpdf = RooAddPdf("signal2_3", "signal2_3", alf2_123, af12) con0 = RooRealVar('c0', 'constant', -1, 1) con1 = RooRealVar('c1', 'linear', -10, 10) con2 = RooRealVar('c2', 'quadratic', 1) bkgpdf = RooChebychev('bkgpdf', 'Background', mbc, RooArgList(con1, con2)) bkgbarpdf = RooChebychev('bkgbarpdf', 'Background', mbc, RooArgList(con1, con2)) yld = RooRealVar('yld', 'D yield', 100, 0, 2000) bkg = RooRealVar('bkg', 'Background', 100, 0, 1000) sumpdf = RooAddPdf('sumpdf', 'Sum pdf', RooArgList(sigpdf, bkgpdf), RooArgList(yld, bkg)) yldbar = RooRealVar('yldbar', 'Dbar yield', 100, 0, 2000) bkgbar = RooRealVar('bkgbar', 'Background', 100, 0, 1000) sumpdfbar = RooAddPdf('sumpdfbar', 'Sum pdf', RooArgList(sigbarpdf, bkgbarpdf), RooArgList(yldbar, bkgbar)) totalpdf = RooSimultaneous('rs', 'Simultaneous PDF', dflav) totalpdf.addPdf(sumpdf, 'dflav') totalpdf.addPdf(sumpdfbar, 'dbarflav') MINUIT = 'ermh4' if err_type == 'ASYM': MINUIT = 'erh4' if test: sys.stdout.write('Will save epsfile as: %s \n' % epsfile) sys.stdout.write('Will save txtfile as: %s \n' % txtfile) return if dataset.numEntries() == 0: yld.setVal(0) yldbar.setVal(0) else: # Start Fitting fitres = totalpdf.fitTo(dataset, MINUIT) fitres.Print('v') # Save plots canvas = TCanvas('canvas', 'mbc', 400, 400) xframe = mbc.frame(50) ProjWData = RooFit.ProjWData(dataset) RooAbsData.plotOn(dataset, xframe) totalpdf.plotOn(xframe, ProjWData) totalpdf.paramOn(xframe) xframe.Draw() canvas.Print(epsfile) # Save fitting parameters pars = [bkg, bkgbar, con1, md, sigmap1, yld, yldbar] save_fit_result(pars, txtfile, err_type=err_type, verbose=1)
def mbc_single_3s(evtfile, mc, setMres, setGamma, setR, sp1, sp2, sp3, fa, fb, setmd, setp, setxi, setN1, setN2, setNbkgd1, setNbkgd2, title1, title2, epsfile, txtfile, ymin=0.5, cuts=None, err_type='SYMM', test=False): from ROOT import (gROOT, RooRealVar, RooCategory, RooArgSet, RooDataSet, RooFit, RooGaussian, RooArgList, RooAddPdf, RooSimultaneous, RooArgusBG, RooFormulaVar, RooDLineShape, RooAbsData, RooDataHist, TCanvas, kRed, kBlue, kGreen, kMagenta, TPaveText) set_root_style(stat=1, grid=0) # // sp1 = sigma of signal # // sp2 = ratio of sigmas betwwen sigma2 sigma 1 # // sp3 = ratio of sigmas betwwen sigma3 sigma 2 # // fa, fb, - fractions # // xi_side - slope of argus # // p_side - power of argus # mc = 1 Monte Carlo Model: EvtGenModels/Class/EvtVPHOtoVISR.cc # mc = 3 Data Model: with BES 2007 paper (BES2006 lineshape hepex/0612056) mbc = RooRealVar('mbc', 'Beam constrained mass', 1.83, 1.89, 'GeV') ebeam = RooRealVar('ebeam', 'Ebeam', 1.8815, 1.892, 'GeV') dflav = RooCategory('dflav', 'D flavor') dflav.defineType('dflav', 1) dflav.defineType('dbarflav', -1) if cuts != None: if 'kkmass' in cuts: kkmass = RooRealVar('kkmass', 'KK invariant mass', 0.97, 1.90, 'GeV') ras = RooArgSet(mbc, ebeam, kkmass, dflav) dataset = RooDataSet.read(evtfile, ras) elif 'kpimass' in cuts: kpimass = RooRealVar('kpimass', 'Kpi invariant mass', 0.6, 1.4, 'GeV') ras = RooArgSet(mbc, ebeam, kpimass, dflav) dataset = RooDataSet.read(evtfile, ras) else: raise NameError(cuts) sys.stdout.write('Using cuts: %s...' % cuts) dataset = dataset.reduce(cuts) sys.stdout.write(' selected %s events.\n' % dataset.numEntries()) else: ras = RooArgSet(mbc, ebeam, dflav) dataset = RooDataSet.read(evtfile, ras) res = RooRealVar("datares", "datares", mc) mres = RooRealVar("mres", "mres", setMres) gamma = RooRealVar('gamma', 'gamma', setGamma) r = RooRealVar('r', 'r', setR) sigmaE = RooRealVar("sigmaE", "sigmaE", 0.0021) sigmap1 = RooRealVar("sigmap1", "sigmap1", sp1, 0.002, 0.040) scalep2 = RooRealVar("scalep2", "scalep2", 2.00, 1.500, 5.500) scalep3 = RooRealVar("scalep3", "scalep3", 5.00, 3.00, 10.000) scalep2.setVal(sp2) scalep2.setConstant(1) scalep3.setVal(sp3) scalep3.setConstant(1) as12 = RooArgList(sigmap1, scalep2) sigmap2 = RooFormulaVar("sigmap2", "sigma2", "sigmap1*scalep2", as12) as123 = RooArgList(sigmap1, scalep2, scalep3) sigmap3 = RooFormulaVar("sigmap3", "sigma3", "sigmap1*scalep2*scalep3", as123) md = RooRealVar("md", "md", setmd, 1.863, 1.875) f2 = RooRealVar("f2", "f2", fa) f3 = RooRealVar("f3", "f3", fb) al23 = RooArgList(f2, f3) f1 = RooFormulaVar("f1", "f1", "1.0-f2-f3", al23) # Construct signal shape fcn1_1 = RooDLineShape("DLineshape1_1", "DLineShape1_1", 4, mbc, ebeam, mres, gamma, r, sigmaE, sigmap1, md, res) fcn1_2 = RooDLineShape("DLineshape1_2", "DLineShape1_2", 4, mbc, ebeam, mres, gamma, r, sigmaE, sigmap2, md, res) fcn1_3 = RooDLineShape("DLineshape1_3", "DLineShape1_3", 4, mbc, ebeam, mres, gamma, r, sigmaE, sigmap3, md, res) fcn2_1 = RooDLineShape("DLineshape2_1", "DLineShape2_1", 4, mbc, ebeam, mres, gamma, r, sigmaE, sigmap1, md, res) fcn2_2 = RooDLineShape("DLineshape2_2", "DLineShape2_2", 4, mbc, ebeam, mres, gamma, r, sigmaE, sigmap2, md, res) fcn2_3 = RooDLineShape("DLineshape2_3", "DLineShape2_3", 4, mbc, ebeam, mres, gamma, r, sigmaE, sigmap3, md, res) alf1_123 = RooArgList(fcn1_1, fcn1_2, fcn1_3) af12 = RooArgList(f1, f2) signal1_3 = RooAddPdf("signal1_3", "signal1_3", alf1_123, af12) alf2_123 = RooArgList(fcn2_1, fcn2_2, fcn2_3) signal2_3 = RooAddPdf("signal2_3", "signal2_3", alf2_123, af12) p = RooRealVar("p", "p", setp, 0.1, 1.5) xi = RooRealVar("xi", "xi", setxi, -100.0, -0.1) Bkgd1 = RooArgusBG("argus1", "argus1", mbc, ebeam, xi, p) Bkgd2 = RooArgusBG("argus2", "argus2", mbc, ebeam, xi, p) shapes1 = RooArgList(signal1_3) shapes1.add(signal1_3) shapes1.add(Bkgd1) shapes2 = RooArgList(signal2_3) shapes2.add(signal2_3) shapes2.add(Bkgd2) N1 = RooRealVar("N1", "N1", setN1, 0.0, 200000000.0) N2 = RooRealVar("N2", "N2", setN2, 0.0, 200000000.0) Nbkgd1 = RooRealVar("Nbkgd1", "Nbkgd1", setNbkgd1, 0.0, 200000000.0) Nbkgd2 = RooRealVar("Nbkgd2", "Nbkgd2", setNbkgd2, 0.0, 200000000.0) yields1 = RooArgList(N1) yields1.add(N1) yields1.add(Nbkgd1) yields2 = RooArgList(N2) yields2.add(N2) yields2.add(Nbkgd2) totalPdf1 = RooAddPdf("totalPdf1", "totalPdf1", shapes1, yields1) totalPdf2 = RooAddPdf("totalPdf2", "totalPdf2", shapes2, yields2) totalPdf = RooSimultaneous("totalPdf", "totalPdf", dflav) totalPdf.addPdf(totalPdf1, "dflav") totalPdf.addPdf(totalPdf2, "dbarflav") # Check fitTo options at: # http://root.cern.ch/root/html512/RooAbsPdf.html#RooAbsPdf:fitTo # # Available fit options: # "m" = MIGRAD only, i.e. no MINOS # "s" = estimate step size with HESSE before starting MIGRAD # "h" = run HESSE after MIGRAD # "e" = Perform extended MLL fit # "0" = Run MIGRAD with strategy MINUIT 0 # (no correlation matrix calculation at end) # Does not apply to HESSE or MINOS, if run afterwards. # "q" = Switch off verbose mode # "l" = Save log file with parameter values at each MINUIT step # "v" = Show changed parameters at each MINUIT step # "t" = Time fit # "r" = Save fit output in RooFitResult object # Available optimizer options # "c" = Cache and precalculate components of PDF that exclusively # depend on constant parameters # "2" = Do NLL calculation in multi-processor mode on 2 processors # "3" = Do NLL calculation in multi-processor mode on 3 processors # "4" = Do NLL calculation in multi-processor mode on 4 processors MINUIT = 'ermh4' if err_type == 'ASYM': MINUIT = 'erh4' if test: sys.stdout.write('Will save epsfile as: %s \n' % epsfile) sys.stdout.write('Will save txtfile as: %s \n' % txtfile) return if dataset.numEntries() == 0: N1.setVal(0) N2.setVal(0) else: # Start Fitting fitres = totalPdf.fitTo(dataset, MINUIT) fitres.Print('v') # Save plots canvas = TCanvas('canvas', 'mbc', 1200, 400) canvas.Divide(3, 1) canvas_1 = canvas.GetListOfPrimitives().FindObject('canvas_1') canvas_2 = canvas.GetListOfPrimitives().FindObject('canvas_2') canvas_1.SetLogy(1) canvas_2.SetLogy(1) LineColorRed = RooFit.LineColor(kRed) LineColorBlue = RooFit.LineColor(kBlue) LineWidth = RooFit.LineWidth(1) #0.6) # Plot the D canvas.cd(1) mbcFrame = mbc.frame() mbcFrame = mbc.frame(60) dflav.setLabel('dflav') ebas = RooArgSet(ebeam, dflav) ebeamdata = RooDataHist("ebeamdata", "ebeamdata", ebas, dataset) dataset.plotOn(mbcFrame, RooFit.Cut("dflav==dflav::dflav")) mbcFrame.getAttMarker().SetMarkerSize(0.6) mbcFrame.Draw() Slice = RooFit.Slice(dflav) ProjWData = RooFit.ProjWData(ebas, ebeamdata) totalPdf.plotOn(mbcFrame, LineColorRed, LineWidth, Slice, ProjWData) chisq1 = mbcFrame.chiSquare() * mbcFrame.GetNbinsX() mbcFrame.Draw() as_bkg1 = RooArgSet(Bkgd1) cp_bkg1 = RooFit.Components(as_bkg1) totalPdf.plotOn(mbcFrame, cp_bkg1, Slice, LineColorBlue, LineWidth, ProjWData) mbcFrame.SetTitle(title1) mbcFrame.SetMinimum(ymin) mbcFrame.Draw() # Plot the D bar canvas.cd(2) mbcFrame = mbc.frame() mbcFrame = mbc.frame(60) dflav.setLabel('dbarflav') ebas = RooArgSet(ebeam, dflav) ebeamdata = RooDataHist("ebeamdata", "ebeamdata", ebas, dataset) dataset.plotOn(mbcFrame, RooFit.Cut("dflav==dflav::dbarflav")) mbcFrame.getAttMarker().SetMarkerSize(0.6) mbcFrame.Draw() Slice = RooFit.Slice(dflav) ProjWData = RooFit.ProjWData(ebas, ebeamdata) totalPdf.plotOn(mbcFrame, LineColorRed, LineWidth, Slice, ProjWData) chisq2 = mbcFrame.chiSquare() * mbcFrame.GetNbinsX() mbcFrame.Draw() as_bkg2 = RooArgSet(Bkgd2) cp_bkg2 = RooFit.Components(as_bkg2) totalPdf.plotOn(mbcFrame, cp_bkg2, Slice, LineColorBlue, LineWidth, ProjWData) mbcFrame.SetTitle(title2) mbcFrame.SetMinimum(ymin) mbcFrame.Draw() # Plot Statistics Box canvas.cd(3) mbcFrame = mbc.frame() paramWin1 = totalPdf.paramOn(mbcFrame, dataset, "", 2, "NELU", 0.1, 0.9, 0.9) mbcFrame.GetXaxis().SetLabelSize(0) mbcFrame.GetXaxis().SetTickLength(0) mbcFrame.GetXaxis().SetLabelSize(0) mbcFrame.GetXaxis().SetTitle("") mbcFrame.GetXaxis().CenterTitle() mbcFrame.GetYaxis().SetLabelSize(0) mbcFrame.GetYaxis().SetTitleSize(0.03) mbcFrame.GetYaxis().SetTickLength(0) paramWin1.getAttText().SetTextSize(0.06) mbcFrame.Draw() mbcFrame.SetTitle("Fit Parameters") ATextBox = TPaveText(.1, .1, .8, .2, "BRNDC") tempString = "#chi^{2}_{1} = %.1f, #chi^{2}_{2} = %.1f" % (chisq1, chisq2) ATextBox.AddText(tempString) ATextBox.SetFillColor(0) ATextBox.SetBorderSize(1) mbcFrame.addObject(ATextBox) mbcFrame.Draw() canvas.Print(epsfile) rootfile = epsfile.replace('.eps', '.root') canvas.Print(rootfile) # Save fitting parameters pars = [N1, N2, Nbkgd1, Nbkgd2, md, p, sigmap1, xi] save_fit_result(pars, txtfile, err_type=err_type, verbose=1)
def PlotTotalNumberOfEvents( inputDirForLimit , signalDir = "./signals/14August1percentSystLimit/"): thqEff_File = TFile.Open( signalDir + "/out_ctcv_thq_syst.root" ) thqEff_Canvas = thqEff_File.Get("thq/Canvas_Efficiency_thq").GetListOfPrimitives().At(0) thqEff_Canvas.Print() thqEff_H2 = thqEff_Canvas.GetListOfPrimitives().At(1) #thqEff_H2.Print("ALL") thqEff = CtCvCpInfo("thqEff") thqEff.FillFrom2DHisto( thqEff_H2 ) thqEff_File.Close() thqEff.GetCtOverCv() thqEff_Func = thqEff.CtOverCvDataHistFunc thqFinalYield_List = RooArgList( thqEff_Func , kappa.tHqXSecValue , kappa.BRGammaGammaValue , kappa.LUMI ) thqFinalYield = RooFormulaVar( "thq_norm" , "thq Norm formula" , "1000.*@0*@1*@2*@3/100." , thqFinalYield_List ) thwEff_File = TFile.Open( signalDir + "/out_ctcv_thw_syst.root" ) thwEff_Canvas = thwEff_File.Get("thw/Canvas_Efficiency_thw").GetListOfPrimitives().At(0) thwEff_Canvas.Print() thwEff_H2 = thwEff_Canvas.GetListOfPrimitives().At(1) #thwEff_H2.Print("ALL") thwEff = CtCvCpInfo("thwEff") thwEff.FillFrom2DHisto( thwEff_H2 ) thwEff_File.Close() thwEff.GetCtOverCv() thwEff_Func = thwEff.CtOverCvDataHistFunc thwFinalYield_List = RooArgList( thwEff_Func , kappa.tHWXSecValue , kappa.BRGammaGammaValue , kappa.LUMI ) thwFinalYield = RooFormulaVar( "thw_norm" , "thw Norm formula" , "1000.*@0*@1*@2*@3/100." , thwFinalYield_List ) tthAT_SM = 1.69902 vhAT_SM = 0.0640522 gghOverTTH = 0.0127844 tthAT_SM *= (1+gghOverTTH) otherHiggsYields = RooFormulaVar("otherHiggsYields" , "otherHiggsYields" , "@0*(%.5f*@1*@1 + %.5f*@2*@2)" % (tthAT_SM , vhAT_SM) , RooArgList( kappa.BRGammaGamma , kappa.CT, kappa.CV) ) totalYield = RooFormulaVar("TotalYield" , "Total Yield" , "@0+@1+@2" , RooArgList( otherHiggsYields , thwFinalYield , thqFinalYield ) ) INPUT_FILE = inputDirForLimit+"/ctcv%g/input.root" YieldsInDataCards = CtCvCpInfo("YieldsInDataCards") for ctcv in sorted(YieldsInDataCards.AllCtOverCVs): ct = ctcv input_file = TFile.Open( INPUT_FILE%( ctcv) ) nevents = 0 if input_file : wsPreselection = input_file.Get("WSTHQLeptonicTag") factor = (1+gghOverTTH) additive = vhAT_SM additive *= kappa.GetXSecBR( "vh" , ct , 1. ) factor = 1.0 additive = 0.0 nevents = ( wsPreselection.var("RVthq_mh125_norm").getVal() + factor*wsPreselection.var("RVtth_mh125_norm").getVal() + wsPreselection.var("RVthw_mh125_norm").getVal() + additive ) input_file.Close() YieldsInDataCards.SetValueByCtOverCv( ctcv , nevents ) YieldsInDataCards.GetCtOverCv() YieldsInDataCards_HistFunc = YieldsInDataCards.CtOverCvDataHistFunc frame = kappa.CtOverCv.frame() frame.SetAxisRange( -6 , 6 , "X" ) kappa.CV.setVal( 1. ) totalYield.plotOn( frame , RooFit.LineColor(kRed) ).getCurve().SetTitle("CV=1") #kappa.CV.setVal( 2. ) #totalYield.plotOn( frame , RooFit.LineColor(kAzure) ).getCurve().SetTitle("CV=2") #kappa.CV.setVal( 0.5 ) #totalYield.plotOn( frame , RooFit.LineColor(kOrange) ).getCurve().SetTitle("CV=0.5") YieldsInDataCards_HistFunc.plotOn( frame , RooFit.LineColor(kBlue) ).getCurve().SetTitle("Input of datacards") #kappa.SumXSectionsTimesLumi.plotOn (frame, RooFit.LineColor(kOrange) ) TotalEff = RooFormulaVar("TotalEff" , "TotalEff" , "100*@0/@1" , RooArgList( totalYield , kappa.SumXSectionsTimesLumi ) ) #YieldsInDataCards_HistFunc TotalEff.plotOn( frame , RooFit.LineColor( kBlack )) frame.SetAxisRange( 0.01 , 800 , "Y" ) c = TCanvas("Yields" , "Yields") #c.SetLogy() #frame.Draw() return (frame,c, YieldsInDataCards)
def signal(channel, stype): if 'VBF' in channel: stype = 'XZHVBF' else: stype = 'XZH' # HVT model if stype.startswith('X'): signalType = 'HVT' genPoints = [800, 1000, 1200, 1400, 1600, 1800, 2000, 2500, 3000, 3500, 4000, 4500, 5000] massPoints = [x for x in range(800, 5000+1, 100)] interPar = True else: print "Signal type", stype, "not recognized" return n = len(genPoints) category = channel cColor = color[category] if category in color else 1 nElec = channel.count('e') nMuon = channel.count('m') nLept = nElec + nMuon nBtag = channel.count('b') if '0b' in channel: nBtag = 0 X_name = "VH_mass" if not os.path.exists(PLOTDIR+stype+category): os.makedirs(PLOTDIR+stype+category) #*******************************************************# # # # Variables and selections # # # #*******************************************************# X_mass = RooRealVar( "X_mass", "m_{ZH}", XBINMIN, XBINMAX, "GeV") J_mass = RooRealVar( "H_mass", "jet mass", LOWMIN, HIGMAX, "GeV") V_mass = RooRealVar( "V_mass", "V jet mass", -9., 1.e6, "GeV") CSV1 = RooRealVar( "H_csv1", "", -999., 2. ) CSV2 = RooRealVar( "H_csv2", "", -999., 2. ) DeepCSV1= RooRealVar( "H_deepcsv1", "", -999., 2. ) DeepCSV2= RooRealVar( "H_deepcsv2", "", -999., 2. ) H_ntag = RooRealVar( "H_ntag", "", -9., 9. ) H_dbt = RooRealVar( "H_dbt", "", -2., 2. ) H_tau21 = RooRealVar( "H_tau21", "", -9., 2. ) H_eta = RooRealVar( "H_eta", "", -9., 9. ) H_tau21_ddt = RooRealVar( "H_ddt", "", -9., 2. ) MaxBTag = RooRealVar( "MaxBTag", "", -10., 2. ) H_chf = RooRealVar( "H_chf", "", -1., 2. ) MinDPhi = RooRealVar( "MinDPhi", "", -1., 99. ) DPhi = RooRealVar( "DPhi", "", -1., 99. ) DEta = RooRealVar( "DEta", "", -1., 99. ) Mu1_relIso = RooRealVar( "Mu1_relIso", "", -1., 99. ) Mu2_relIso = RooRealVar( "Mu2_relIso", "", -1., 99. ) nTaus = RooRealVar( "nTaus", "", -1., 99. ) Vpt = RooRealVar( "V.Pt()", "", -1., 1.e6 ) V_pt = RooRealVar( "V_pt", "", -1., 1.e6 ) H_pt = RooRealVar( "H_pt", "", -1., 1.e6 ) VH_deltaR=RooRealVar( "VH_deltaR", "", -1., 99. ) isZtoNN = RooRealVar( "isZtoNN", "", 0., 2. ) isZtoEE = RooRealVar( "isZtoEE", "", 0., 2. ) isZtoMM = RooRealVar( "isZtoMM", "", 0., 2. ) isHtobb = RooRealVar( "isHtobb", "", 0., 2. ) isVBF = RooRealVar( "isVBF", "", 0., 2. ) isMaxBTag_loose = RooRealVar( "isMaxBTag_loose", "", 0., 2. ) weight = RooRealVar( "eventWeightLumi", "", -1.e9, 1.e9 ) Xmin = XBINMIN Xmax = XBINMAX # Define the RooArgSet which will include all the variables defined before # there is a maximum of 9 variables in the declaration, so the others need to be added with 'add' variables = RooArgSet(X_mass, J_mass, V_mass, CSV1, CSV2, H_ntag, H_dbt, H_tau21) variables.add(RooArgSet(DEta, DPhi, MaxBTag, MinDPhi, nTaus, Vpt)) variables.add(RooArgSet(DeepCSV1, DeepCSV2,VH_deltaR, H_tau21_ddt)) variables.add(RooArgSet(isZtoNN, isZtoEE, isZtoMM, isHtobb, isMaxBTag_loose, weight)) variables.add(RooArgSet(isVBF, Mu1_relIso, Mu2_relIso, H_chf, H_pt, V_pt,H_eta)) #X_mass.setRange("X_extended_range", X_mass.getMin(), X_mass.getMax()) X_mass.setRange("X_reasonable_range", X_mass.getMin(), X_mass.getMax()) X_mass.setRange("X_integration_range", Xmin, Xmax) X_mass.setBins(int((X_mass.getMax() - X_mass.getMin())/100)) binsXmass = RooBinning(int((X_mass.getMax() - X_mass.getMin())/100), X_mass.getMin(), X_mass.getMax()) X_mass.setBinning(binsXmass, "PLOT") massArg = RooArgSet(X_mass) # Cuts SRcut = selection[category]+selection['SR'] print " Cut:\t", SRcut #*******************************************************# # # # Signal fits # # # #*******************************************************# treeSign = {} setSignal = {} vmean = {} vsigma = {} valpha1 = {} vslope1 = {} smean = {} ssigma = {} salpha1 = {} sslope1 = {} salpha2 = {} sslope2 = {} a1 = {} a2 = {} sbrwig = {} signal = {} signalExt = {} signalYield = {} signalIntegral = {} signalNorm = {} signalXS = {} frSignal = {} frSignal1 = {} frSignal2 = {} frSignal3 = {} # Signal shape uncertainties (common amongst all mass points) xmean_fit = RooRealVar("sig_p1_fit", "Variation of the resonance position with the fit uncertainty", 0.005, -1., 1.) smean_fit = RooRealVar("CMSRunII_sig_p1_fit", "Change of the resonance position with the fit uncertainty", 0., -10, 10) xmean_jes = RooRealVar("sig_p1_scale_jes", "Variation of the resonance position with the jet energy scale", 0.010, -1., 1.) #0.001 smean_jes = RooRealVar("CMSRunII_sig_p1_jes", "Change of the resonance position with the jet energy scale", 0., -10, 10) xmean_e = RooRealVar("sig_p1_scale_e", "Variation of the resonance position with the electron energy scale", 0.001, -1., 1.) smean_e = RooRealVar("CMSRunII_sig_p1_scale_e", "Change of the resonance position with the electron energy scale", 0., -10, 10) xmean_m = RooRealVar("sig_p1_scale_m", "Variation of the resonance position with the muon energy scale", 0.001, -1., 1.) smean_m = RooRealVar("CMSRunII_sig_p1_scale_m", "Change of the resonance position with the muon energy scale", 0., -10, 10) xsigma_fit = RooRealVar("sig_p2_fit", "Variation of the resonance width with the fit uncertainty", 0.02, -1., 1.) ssigma_fit = RooRealVar("CMSRunII_sig_p2_fit", "Change of the resonance width with the fit uncertainty", 0., -10, 10) xsigma_jes = RooRealVar("sig_p2_scale_jes", "Variation of the resonance width with the jet energy scale", 0.010, -1., 1.) #0.001 ssigma_jes = RooRealVar("CMSRunII_sig_p2_jes", "Change of the resonance width with the jet energy scale", 0., -10, 10) xsigma_jer = RooRealVar("sig_p2_scale_jer", "Variation of the resonance width with the jet energy resolution", 0.020, -1., 1.) ssigma_jer = RooRealVar("CMSRunII_sig_p2_jer", "Change of the resonance width with the jet energy resolution", 0., -10, 10) xsigma_e = RooRealVar("sig_p2_scale_e", "Variation of the resonance width with the electron energy scale", 0.001, -1., 1.) ssigma_e = RooRealVar("CMSRunII_sig_p2_scale_e", "Change of the resonance width with the electron energy scale", 0., -10, 10) xsigma_m = RooRealVar("sig_p2_scale_m", "Variation of the resonance width with the muon energy scale", 0.040, -1., 1.) ssigma_m = RooRealVar("CMSRunII_sig_p2_scale_m", "Change of the resonance width with the muon energy scale", 0., -10, 10) xalpha1_fit = RooRealVar("sig_p3_fit", "Variation of the resonance alpha with the fit uncertainty", 0.03, -1., 1.) salpha1_fit = RooRealVar("CMSRunII_sig_p3_fit", "Change of the resonance alpha with the fit uncertainty", 0., -10, 10) xslope1_fit = RooRealVar("sig_p4_fit", "Variation of the resonance slope with the fit uncertainty", 0.10, -1., 1.) sslope1_fit = RooRealVar("CMSRunII_sig_p4_fit", "Change of the resonance slope with the fit uncertainty", 0., -10, 10) xmean_fit.setConstant(True) smean_fit.setConstant(True) xmean_jes.setConstant(True) smean_jes.setConstant(True) xmean_e.setConstant(True) smean_e.setConstant(True) xmean_m.setConstant(True) smean_m.setConstant(True) xsigma_fit.setConstant(True) ssigma_fit.setConstant(True) xsigma_jes.setConstant(True) ssigma_jes.setConstant(True) xsigma_jer.setConstant(True) ssigma_jer.setConstant(True) xsigma_e.setConstant(True) ssigma_e.setConstant(True) xsigma_m.setConstant(True) ssigma_m.setConstant(True) xalpha1_fit.setConstant(True) salpha1_fit.setConstant(True) xslope1_fit.setConstant(True) sslope1_fit.setConstant(True) # the alpha method is now done. for m in massPoints: signalString = "M%d" % m signalMass = "%s_M%d" % (stype, m) signalName = "%s%s_M%d" % (stype, category, m) signalColor = sample[signalMass]['linecolor'] if signalName in sample else 1 # define the signal PDF vmean[m] = RooRealVar(signalName + "_vmean", "Crystal Ball mean", m, m*0.5, m*1.25) smean[m] = RooFormulaVar(signalName + "_mean", "@0*(1+@1*@2)*(1+@3*@4)*(1+@5*@6)*(1+@7*@8)", RooArgList(vmean[m], xmean_e, smean_e, xmean_m, smean_m, xmean_jes, smean_jes, xmean_fit, smean_fit)) vsigma[m] = RooRealVar(signalName + "_vsigma", "Crystal Ball sigma", m*0.035, m*0.01, m*0.4) sigmaList = RooArgList(vsigma[m], xsigma_e, ssigma_e, xsigma_m, ssigma_m, xsigma_jes, ssigma_jes, xsigma_jer, ssigma_jer) sigmaList.add(RooArgList(xsigma_fit, ssigma_fit)) ssigma[m] = RooFormulaVar(signalName + "_sigma", "@0*(1+@1*@2)*(1+@3*@4)*(1+@5*@6)*(1+@7*@8)*(1+@9*@10)", sigmaList) valpha1[m] = RooRealVar(signalName + "_valpha1", "Crystal Ball alpha", 1., 0., 5.) # number of sigmas where the exp is attached to the gaussian core. >0 left, <0 right salpha1[m] = RooFormulaVar(signalName + "_alpha1", "@0*(1+@1*@2)", RooArgList(valpha1[m], xalpha1_fit, salpha1_fit)) vslope1[m] = RooRealVar(signalName + "_vslope1", "Crystal Ball slope", 10., 1., 60.) # slope of the power tail #10 1 60 sslope1[m] = RooFormulaVar(signalName + "_slope1", "@0*(1+@1*@2)", RooArgList(vslope1[m], xslope1_fit, sslope1_fit)) salpha2[m] = RooRealVar(signalName + "_alpha2", "Crystal Ball alpha", 2, 1., 5.) # number of sigmas where the exp is attached to the gaussian core. >0 left, <0 right sslope2[m] = RooRealVar(signalName + "_slope2", "Crystal Ball slope", 10, 1.e-1, 115.) # slope of the power tail #define polynomial #a1[m] = RooRealVar(signalName + "_a1", "par 1 for polynomial", m, 0.5*m, 2*m) a1[m] = RooRealVar(signalName + "_a1", "par 1 for polynomial", 0.001*m, 0.0005*m, 0.01*m) a2[m] = RooRealVar(signalName + "_a2", "par 2 for polynomial", 0.05, -1.,1.) #if channel=='nnbbVBF' or channel=='nn0bVBF': # signal[m] = RooPolynomial(signalName,"m_{%s'} = %d GeV" % (stype[1], m) , X_mass, RooArgList(a1[m],a2[m])) #else: # signal[m] = RooCBShape(signalName, "m_{%s'} = %d GeV" % (stype[1], m), X_mass, smean[m], ssigma[m], salpha1[m], sslope1[m]) # Signal name does not have the channel signal[m] = RooCBShape(signalName, "m_{%s'} = %d GeV" % (stype[1], m), X_mass, smean[m], ssigma[m], salpha1[m], sslope1[m]) # Signal name does not have the channel # extend the PDF with the yield to perform an extended likelihood fit signalYield[m] = RooRealVar(signalName+"_yield", "signalYield", 100, 0., 1.e6) signalNorm[m] = RooRealVar(signalName+"_norm", "signalNorm", 1., 0., 1.e6) signalXS[m] = RooRealVar(signalName+"_xs", "signalXS", 1., 0., 1.e6) signalExt[m] = RooExtendPdf(signalName+"_ext", "extended p.d.f", signal[m], signalYield[m]) vslope1[m].setMax(50.) vslope1[m].setVal(20.) #valpha1[m].setVal(1.0) #valpha1[m].setConstant(True) if 'bb' in channel and 'VBF' not in channel: if 'nn' in channel: valpha1[m].setVal(0.5) elif '0b' in channel and 'VBF' not in channel: if 'nn' in channel: if m==800: valpha1[m].setVal(2.) vsigma[m].setVal(m*0.04) elif 'ee' in channel: valpha1[m].setVal(0.8) if m==800: #valpha1[m].setVal(1.2) valpha1[m].setVal(2.5) vslope1[m].setVal(50.) elif 'mm' in channel: if m==800: valpha1[m].setVal(2.) vsigma[m].setVal(m*0.03) else: vmean[m].setVal(m*0.9) vsigma[m].setVal(m*0.08) elif 'bb' in channel and 'VBF' in channel: if 'nn' in channel: if m!=1800: vmean[m].setVal(m*0.8) vsigma[m].setVal(m*0.08) valpha1[m].setMin(1.) elif 'ee' in channel: valpha1[m].setVal(0.7) elif 'mm' in channel: if m==800: vslope1[m].setVal(50.) valpha1[m].setVal(0.7) elif '0b' in channel and 'VBF' in channel: if 'nn' in channel: valpha1[m].setVal(3.) vmean[m].setVal(m*0.8) vsigma[m].setVal(m*0.08) valpha1[m].setMin(1.) elif 'ee' in channel: if m<2500: valpha1[m].setVal(2.) if m==800: vsigma[m].setVal(m*0.05) elif m==1000: vsigma[m].setVal(m*0.03) elif m>1000 and m<1800: vsigma[m].setVal(m*0.04) elif 'mm' in channel: if m<2000: valpha1[m].setVal(2.) if m==1000 or m==1800: vsigma[m].setVal(m*0.03) elif m==1200 or m==1600: vsigma[m].setVal(m*0.04) #if m < 1000: vsigma[m].setVal(m*0.06) # If it's not the proper channel, make it a gaussian #if nLept==0 and 'VBF' in channel: # valpha1[m].setVal(5) # valpha1[m].setConstant(True) # vslope1[m].setConstant(True) # salpha2[m].setConstant(True) # sslope2[m].setConstant(True) # ---------- if there is no simulated signal, skip this mass point ---------- if m in genPoints: if VERBOSE: print " - Mass point", m # define the dataset for the signal applying the SR cuts treeSign[m] = TChain("tree") for j, ss in enumerate(sample[signalMass]['files']): treeSign[m].Add(NTUPLEDIR + ss + ".root") if treeSign[m].GetEntries() <= 0.: if VERBOSE: print " - 0 events available for mass", m, "skipping mass point..." signalNorm[m].setVal(-1) vmean[m].setConstant(True) vsigma[m].setConstant(True) salpha1[m].setConstant(True) sslope1[m].setConstant(True) salpha2[m].setConstant(True) sslope2[m].setConstant(True) signalNorm[m].setConstant(True) signalXS[m].setConstant(True) continue setSignal[m] = RooDataSet("setSignal_"+signalName, "setSignal", variables, RooFit.Cut(SRcut), RooFit.WeightVar(weight), RooFit.Import(treeSign[m])) if VERBOSE: print " - Dataset with", setSignal[m].sumEntries(), "events loaded" # FIT signalYield[m].setVal(setSignal[m].sumEntries()) if treeSign[m].GetEntries(SRcut) > 5: if VERBOSE: print " - Running fit" frSignal[m] = signalExt[m].fitTo(setSignal[m], RooFit.Save(1), RooFit.Extended(True), RooFit.SumW2Error(True), RooFit.PrintLevel(-1)) if VERBOSE: print "********** Fit result [", m, "] **", category, "*"*40, "\n", frSignal[m].Print(), "\n", "*"*80 if VERBOSE: frSignal[m].correlationMatrix().Print() drawPlot(signalMass, stype+channel, X_mass, signal[m], setSignal[m], frSignal[m]) else: print " WARNING: signal", stype, "and mass point", m, "in channel", channel, "has 0 entries or does not exist" # Remove HVT cross section (which is the same for Zlep and Zinv) if stype == "XZHVBF": sample_name = 'Zprime_VBF_Zh_Zlephinc_narrow_M-%d' % m else: sample_name = 'ZprimeToZHToZlepHinc_narrow_M%d' % m xs = xsection[sample_name]['xsec'] signalXS[m].setVal(xs * 1000.) signalIntegral[m] = signalExt[m].createIntegral(massArg, RooFit.NormSet(massArg), RooFit.Range("X_integration_range")) boundaryFactor = signalIntegral[m].getVal() if VERBOSE: print " - Fit normalization vs integral:", signalYield[m].getVal(), "/", boundaryFactor, "events" if channel=='nnbb' and m==5000: signalNorm[m].setVal(2.5) elif channel=='nn0b' and m==5000: signalNorm[m].setVal(6.7) else: signalNorm[m].setVal( boundaryFactor * signalYield[m].getVal() / signalXS[m].getVal()) # here normalize to sigma(X) x Br(X->VH) = 1 [fb] a1[m].setConstant(True) a2[m].setConstant(True) vmean[m].setConstant(True) vsigma[m].setConstant(True) valpha1[m].setConstant(True) vslope1[m].setConstant(True) salpha2[m].setConstant(True) sslope2[m].setConstant(True) signalNorm[m].setConstant(True) signalXS[m].setConstant(True) #*******************************************************# # # # Signal interpolation # # # #*******************************************************# # ====== CONTROL PLOT ====== c_signal = TCanvas("c_signal", "c_signal", 800, 600) c_signal.cd() frame_signal = X_mass.frame() for m in genPoints[:-2]: if m in signalExt.keys(): signal[m].plotOn(frame_signal, RooFit.LineColor(sample["%s_M%d" % (stype, m)]['linecolor']), RooFit.Normalization(signalNorm[m].getVal(), RooAbsReal.NumEvent), RooFit.Range("X_reasonable_range")) frame_signal.GetXaxis().SetRangeUser(0, 6500) frame_signal.Draw() drawCMS(-1, YEAR, "Simulation") drawAnalysis(channel) drawRegion(channel) c_signal.SaveAs(PLOTDIR+"/"+stype+category+"/"+stype+"_Signal.pdf") c_signal.SaveAs(PLOTDIR+"/"+stype+category+"/"+stype+"_Signal.png") #if VERBOSE: raw_input("Press Enter to continue...") # ====== CONTROL PLOT ====== # Normalization gnorm = TGraphErrors() gnorm.SetTitle(";m_{X} (GeV);integral (GeV)") gnorm.SetMarkerStyle(20) gnorm.SetMarkerColor(1) gnorm.SetMaximum(0) inorm = TGraphErrors() inorm.SetMarkerStyle(24) fnorm = TF1("fnorm", "pol9", 800, 5000) #"pol5" if not channel=="XZHnnbb" else "pol6" #pol5*TMath::Floor(x-1800) + ([5]*x + [6]*x*x)*(1-TMath::Floor(x-1800)) fnorm.SetLineColor(920) fnorm.SetLineStyle(7) fnorm.SetFillColor(2) fnorm.SetLineColor(cColor) # Mean gmean = TGraphErrors() gmean.SetTitle(";m_{X} (GeV);gaussian mean (GeV)") gmean.SetMarkerStyle(20) gmean.SetMarkerColor(cColor) gmean.SetLineColor(cColor) imean = TGraphErrors() imean.SetMarkerStyle(24) fmean = TF1("fmean", "pol1", 0, 5000) fmean.SetLineColor(2) fmean.SetFillColor(2) # Width gsigma = TGraphErrors() gsigma.SetTitle(";m_{X} (GeV);gaussian width (GeV)") gsigma.SetMarkerStyle(20) gsigma.SetMarkerColor(cColor) gsigma.SetLineColor(cColor) isigma = TGraphErrors() isigma.SetMarkerStyle(24) fsigma = TF1("fsigma", "pol1", 0, 5000) fsigma.SetLineColor(2) fsigma.SetFillColor(2) # Alpha1 galpha1 = TGraphErrors() galpha1.SetTitle(";m_{X} (GeV);crystal ball lower alpha") galpha1.SetMarkerStyle(20) galpha1.SetMarkerColor(cColor) galpha1.SetLineColor(cColor) ialpha1 = TGraphErrors() ialpha1.SetMarkerStyle(24) falpha1 = TF1("falpha", "pol0", 0, 5000) falpha1.SetLineColor(2) falpha1.SetFillColor(2) # Slope1 gslope1 = TGraphErrors() gslope1.SetTitle(";m_{X} (GeV);exponential lower slope (1/Gev)") gslope1.SetMarkerStyle(20) gslope1.SetMarkerColor(cColor) gslope1.SetLineColor(cColor) islope1 = TGraphErrors() islope1.SetMarkerStyle(24) fslope1 = TF1("fslope", "pol0", 0, 5000) fslope1.SetLineColor(2) fslope1.SetFillColor(2) # Alpha2 galpha2 = TGraphErrors() galpha2.SetTitle(";m_{X} (GeV);crystal ball upper alpha") galpha2.SetMarkerStyle(20) galpha2.SetMarkerColor(cColor) galpha2.SetLineColor(cColor) ialpha2 = TGraphErrors() ialpha2.SetMarkerStyle(24) falpha2 = TF1("falpha", "pol0", 0, 5000) falpha2.SetLineColor(2) falpha2.SetFillColor(2) # Slope2 gslope2 = TGraphErrors() gslope2.SetTitle(";m_{X} (GeV);exponential upper slope (1/Gev)") gslope2.SetMarkerStyle(20) gslope2.SetMarkerColor(cColor) gslope2.SetLineColor(cColor) islope2 = TGraphErrors() islope2.SetMarkerStyle(24) fslope2 = TF1("fslope", "pol0", 0, 5000) fslope2.SetLineColor(2) fslope2.SetFillColor(2) n = 0 for i, m in enumerate(genPoints): if not m in signalNorm.keys(): continue if signalNorm[m].getVal() < 1.e-6: continue signalString = "M%d" % m signalName = "%s_M%d" % (stype, m) if gnorm.GetMaximum() < signalNorm[m].getVal(): gnorm.SetMaximum(signalNorm[m].getVal()) gnorm.SetPoint(n, m, signalNorm[m].getVal()) gmean.SetPoint(n, m, vmean[m].getVal()) gmean.SetPointError(n, 0, min(vmean[m].getError(), vmean[m].getVal()*0.02)) gsigma.SetPoint(n, m, vsigma[m].getVal()) gsigma.SetPointError(n, 0, min(vsigma[m].getError(), vsigma[m].getVal()*0.05)) galpha1.SetPoint(n, m, valpha1[m].getVal()) galpha1.SetPointError(n, 0, min(valpha1[m].getError(), valpha1[m].getVal()*0.10)) gslope1.SetPoint(n, m, vslope1[m].getVal()) gslope1.SetPointError(n, 0, min(vslope1[m].getError(), vslope1[m].getVal()*0.10)) galpha2.SetPoint(n, m, salpha2[m].getVal()) galpha2.SetPointError(n, 0, min(salpha2[m].getError(), salpha2[m].getVal()*0.10)) gslope2.SetPoint(n, m, sslope2[m].getVal()) gslope2.SetPointError(n, 0, min(sslope2[m].getError(), sslope2[m].getVal()*0.10)) n = n + 1 print "fit on gmean:" gmean.Fit(fmean, "Q0", "SAME") print "fit on gsigma:" gsigma.Fit(fsigma, "Q0", "SAME") print "fit on galpha:" galpha1.Fit(falpha1, "Q0", "SAME") print "fit on gslope:" gslope1.Fit(fslope1, "Q0", "SAME") galpha2.Fit(falpha2, "Q0", "SAME") gslope2.Fit(fslope2, "Q0", "SAME") #for m in [5000, 5500]: gnorm.SetPoint(gnorm.GetN(), m, gnorm.Eval(m, 0, "S")) gnorm.Fit(fnorm, "Q", "SAME", 700, 5000) for m in massPoints: signalName = "%s_M%d" % (stype, m) if vsigma[m].getVal() < 10.: vsigma[m].setVal(10.) # Interpolation method syield = gnorm.Eval(m) spline = gnorm.Eval(m, 0, "S") sfunct = fnorm.Eval(m) #delta = min(abs(1.-spline/sfunct), abs(1.-spline/syield)) delta = abs(1.-spline/sfunct) if sfunct > 0 else 0 syield = spline if interPar: jmean = gmean.Eval(m) jsigma = gsigma.Eval(m) jalpha1 = galpha1.Eval(m) jslope1 = gslope1.Eval(m) else: jmean = fmean.GetParameter(0) + fmean.GetParameter(1)*m + fmean.GetParameter(2)*m*m jsigma = fsigma.GetParameter(0) + fsigma.GetParameter(1)*m + fsigma.GetParameter(2)*m*m jalpha1 = falpha1.GetParameter(0) + falpha1.GetParameter(1)*m + falpha1.GetParameter(2)*m*m jslope1 = fslope1.GetParameter(0) + fslope1.GetParameter(1)*m + fslope1.GetParameter(2)*m*m inorm.SetPoint(inorm.GetN(), m, syield) signalNorm[m].setVal(syield) imean.SetPoint(imean.GetN(), m, jmean) if jmean > 0: vmean[m].setVal(jmean) isigma.SetPoint(isigma.GetN(), m, jsigma) if jsigma > 0: vsigma[m].setVal(jsigma) ialpha1.SetPoint(ialpha1.GetN(), m, jalpha1) if not jalpha1==0: valpha1[m].setVal(jalpha1) islope1.SetPoint(islope1.GetN(), m, jslope1) if jslope1 > 0: vslope1[m].setVal(jslope1) c1 = TCanvas("c1", "Crystal Ball", 1200, 800) c1.Divide(2, 2) c1.cd(1) gmean.SetMinimum(0.) gmean.Draw("APL") imean.Draw("P, SAME") drawRegion(channel) c1.cd(2) gsigma.SetMinimum(0.) gsigma.Draw("APL") isigma.Draw("P, SAME") drawRegion(channel) c1.cd(3) galpha1.Draw("APL") ialpha1.Draw("P, SAME") drawRegion(channel) galpha1.GetYaxis().SetRangeUser(0., 5.) c1.cd(4) gslope1.Draw("APL") islope1.Draw("P, SAME") drawRegion(channel) gslope1.GetYaxis().SetRangeUser(0., 125.) if False: c1.cd(5) galpha2.Draw("APL") ialpha2.Draw("P, SAME") drawRegion(channel) c1.cd(6) gslope2.Draw("APL") islope2.Draw("P, SAME") drawRegion(channel) gslope2.GetYaxis().SetRangeUser(0., 10.) c1.Print(PLOTDIR+stype+category+"/"+stype+"_SignalShape.pdf") c1.Print(PLOTDIR+stype+category+"/"+stype+"_SignalShape.png") c2 = TCanvas("c2", "Signal Efficiency", 800, 600) c2.cd(1) gnorm.SetMarkerColor(cColor) gnorm.SetMarkerStyle(20) gnorm.SetLineColor(cColor) gnorm.SetLineWidth(2) gnorm.Draw("APL") inorm.Draw("P, SAME") gnorm.GetXaxis().SetRangeUser(genPoints[0]-100, genPoints[-1]+100) gnorm.GetYaxis().SetRangeUser(0., gnorm.GetMaximum()*1.25) drawCMS(-1,YEAR , "Simulation") drawAnalysis(channel) drawRegion(channel) c2.Print(PLOTDIR+stype+category+"/"+stype+"_SignalNorm.pdf") c2.Print(PLOTDIR+stype+category+"/"+stype+"_SignalNorm.png") #*******************************************************# # # # Generate workspace # # # #*******************************************************# # create workspace w = RooWorkspace("ZH_RunII", "workspace") for m in massPoints: getattr(w, "import")(signal[m], RooFit.Rename(signal[m].GetName())) getattr(w, "import")(signalNorm[m], RooFit.Rename(signalNorm[m].GetName())) getattr(w, "import")(signalXS[m], RooFit.Rename(signalXS[m].GetName())) w.writeToFile("%s%s.root" % (WORKDIR, stype+channel), True) print "Workspace", "%s%s.root" % (WORKDIR, stype+channel), "saved successfully" sys.exit()
def alpha(channel): nElec = channel.count("e") nMuon = channel.count("m") nLept = nElec + nMuon nBtag = channel.count("b") # Channel-dependent settings # Background function. Semi-working options are: EXP, EXP2, EXPN, EXPTAIL if nLept == 0: treeName = "SR" signName = "XZh" colorVjet = sample["DYJetsToNuNu"]["linecolor"] triName = "HLT_PFMET" leptCut = "0==0" topVeto = selection["TopVetocut"] massVar = "X_cmass" binFact = 1 fitFunc = "EXPN" if nBtag < 2 else "EXPN" fitAltFunc = "EXPTAIL" if nBtag < 2 else "EXPTAIL" fitFuncVjet = "ERFEXP" if nBtag < 2 else "EXP" fitAltFuncVjet = "POL" if nBtag < 2 else "POL" fitFuncVV = "EXPGAUS" if nBtag < 2 else "EXPGAUS" fitFuncTop = "GAUS2" elif nLept == 1: treeName = "WCR" signName = "XWh" colorVjet = sample["WJetsToLNu"]["linecolor"] triName = "HLT_Ele" if nElec > 0 else "HLT_Mu" leptCut = "isWtoEN" if nElec > 0 else "isWtoMN" topVeto = selection["TopVetocut"] massVar = "X_mass" binFact = 2 if nElec > 0: fitFunc = "EXPTAIL" if nBtag < 2 else "EXPN" fitAltFunc = "EXPN" if nBtag < 2 else "POW" else: fitFunc = "EXPN" if nBtag < 2 else "EXPN" fitAltFunc = "EXPTAIL" if nBtag < 2 else "POW" fitFuncVjet = "ERFEXP" if nBtag < 2 else "EXP" fitAltFuncVjet = "POL" if nBtag < 2 else "POL" fitFuncVV = "EXPGAUS" if nBtag < 2 else "EXPGAUS" fitFuncTop = "GAUS3" if nBtag < 2 else "GAUS2" else: treeName = "XZh" signName = "XZh" colorVjet = sample["DYJetsToLL"]["linecolor"] triName = "HLT_Ele" if nElec > 0 else "HLT_Mu" leptCut = "isZtoEE" if nElec > 0 else "isZtoMM" topVeto = "X_dPhi>2.5" massVar = "X_mass" binFact = 2 if nElec > 0: fitFunc = "EXPTAIL" if nBtag < 2 else "EXPTAIL" fitAltFunc = "POW" if nBtag < 2 else "POW" else: fitFunc = "EXPTAIL" if nBtag < 2 else "EXPTAIL" fitAltFunc = "POW" if nBtag < 2 else "POW" fitFuncVjet = "ERFEXP" if nBtag < 2 and nElec < 1 else "EXP" fitAltFuncVjet = "POL" if nBtag < 2 else "POL" fitFuncVV = "EXPGAUS2" if nBtag < 2 else "EXPGAUS2" fitFuncTop = "GAUS" btagCut = selection["2Btag"] if nBtag == 2 else selection["1Btag"] print "--- Channel", channel, "---" print " number of electrons:", nElec, " muons:", nMuon, " b-tags:", nBtag print " read tree:", treeName, "and trigger:", triName if ALTERNATIVE: print " using ALTERNATIVE fit functions" print "-" * 11 * 2 # Silent RooFit RooMsgService.instance().setGlobalKillBelow(RooFit.FATAL) # *******************************************************# # # # Variables and selections # # # # *******************************************************# # Define all the variables from the trees that will be used in the cuts and fits # this steps actually perform a "projection" of the entire tree on the variables in thei ranges, so be careful once setting the limits X_mass = RooRealVar(massVar, "m_{X}" if nLept > 0 else "m_{T}^{X}", XBINMIN, XBINMAX, "GeV") J_mass = RooRealVar("fatjet1_prunedMassCorr", "jet corrected pruned mass", HBINMIN, HBINMAX, "GeV") CSV1 = RooRealVar("fatjet1_CSVR1", "", -1.0e99, 1.0e4) CSV2 = RooRealVar("fatjet1_CSVR2", "", -1.0e99, 1.0e4) nB = RooRealVar("fatjet1_nBtag", "", 0.0, 4) CSVTop = RooRealVar("bjet1_CSVR", "", -1.0e99, 1.0e4) X_dPhi = RooRealVar("X_dPhi", "", 0.0, 3.15) isZtoEE = RooRealVar("isZtoEE", "", 0.0, 2) isZtoMM = RooRealVar("isZtoMM", "", 0.0, 2) isWtoEN = RooRealVar("isWtoEN", "", 0.0, 2) isWtoMN = RooRealVar("isWtoMN", "", 0.0, 2) weight = RooRealVar("eventWeightLumi", "", -1.0e9, 1.0) # Define the RooArgSet which will include all the variables defined before # there is a maximum of 9 variables in the declaration, so the others need to be added with 'add' variables = RooArgSet(X_mass, J_mass, CSV1, CSV2, nB, CSVTop, X_dPhi) variables.add(RooArgSet(isZtoEE, isZtoMM, isWtoEN, isWtoMN, weight)) # set reasonable ranges for J_mass and X_mass # these are used in the fit in order to avoid ROOFIT to look in regions very far away from where we are fitting # (honestly, it is not clear to me why it is necessary, but without them the fit often explodes) J_mass.setRange("h_reasonable_range", LOWMIN, HIGMAX) X_mass.setRange("X_reasonable_range", XBINMIN, XBINMAX) # Set RooArgSets once for all, see https://root.cern.ch/phpBB3/viewtopic.php?t=11758 jetMassArg = RooArgSet(J_mass) # Define the ranges in fatJetMass - these will be used to define SB and SR J_mass.setRange("LSBrange", LOWMIN, LOWMAX) J_mass.setRange("HSBrange", HIGMIN, HIGMAX) J_mass.setRange("VRrange", LOWMAX, SIGMIN) J_mass.setRange("SRrange", SIGMIN, SIGMAX) # Set binning for plots J_mass.setBins(HBINS) X_mass.setBins(binFact * XBINS) # Define the selection for the various categories (base + SR / LSBcut / HSBcut ) baseCut = leptCut + " && " + btagCut + "&&" + topVeto massCut = massVar + ">%d" % XBINMIN baseCut += " && " + massCut # Cuts SRcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), SIGMIN, J_mass.GetName(), SIGMAX) LSBcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), LOWMIN, J_mass.GetName(), LOWMAX) HSBcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), HIGMIN, J_mass.GetName(), HIGMAX) SBcut = baseCut + " && ((%s>%d && %s<%d) || (%s>%d && %s<%d))" % ( J_mass.GetName(), LOWMIN, J_mass.GetName(), LOWMAX, J_mass.GetName(), HIGMIN, J_mass.GetName(), HIGMAX, ) VRcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), LOWMAX, J_mass.GetName(), SIGMIN) # Binning binsJmass = RooBinning(HBINS, HBINMIN, HBINMAX) # binsJmass.addUniform(HBINS, HBINMIN, HBINMAX) binsXmass = RooBinning(binFact * XBINS, XBINMIN, XBINMAX) # binsXmass.addUniform(binFact*XBINS, XBINMIN, XBINMAX) # *******************************************************# # # # Input files # # # # *******************************************************# # Import the files using TChains (separately for the bkg "classes" that we want to describe: here DY and VV+ST+TT) treeData = TChain(treeName) treeMC = TChain(treeName) treeVjet = TChain(treeName) treeVV = TChain(treeName) treeTop = TChain(treeName) treeSign = {} nevtSign = {} for i, m in enumerate(massPoints): treeSign[m] = TChain(treeName) # Read data pd = getPrimaryDataset(triName) if len(pd) == 0: raw_input("Warning: Primary Dataset not recognized, continue?") for i, s in enumerate(pd): treeData.Add(NTUPLEDIR + s + ".root") # Read V+jets backgrounds for i, s in enumerate(["WJetsToLNu_HT", "DYJetsToNuNu_HT", "DYJetsToLL_HT"]): for j, ss in enumerate(sample[s]["files"]): treeVjet.Add(NTUPLEDIR + ss + ".root") # Read VV backgrounds for i, s in enumerate(["VV"]): for j, ss in enumerate(sample[s]["files"]): treeVV.Add(NTUPLEDIR + ss + ".root") # Read Top backgrounds for i, s in enumerate(["ST", "TTbar"]): for j, ss in enumerate(sample[s]["files"]): treeTop.Add(NTUPLEDIR + ss + ".root") # Read signals for i, m in enumerate(massPoints): for j, ss in enumerate(sample["%s_M%d" % (signName, m)]["files"]): treeSign[m].Add(NTUPLEDIR + ss + ".root") sfile = TFile(NTUPLEDIR + ss + ".root", "READ") shist = sfile.Get("Counters/Counter") nevtSign[m] = shist.GetBinContent(1) sfile.Close() # Sum all background MC treeMC.Add(treeVjet) treeMC.Add(treeVV) treeMC.Add(treeTop) # create a dataset to host data in sideband (using this dataset we are automatically blind in the SR!) setDataSB = RooDataSet( "setDataSB", "setDataSB", variables, RooFit.Cut(SBcut), RooFit.WeightVar(weight), RooFit.Import(treeData) ) setDataLSB = RooDataSet( "setDataLSB", "setDataLSB", variables, RooFit.Import(setDataSB), RooFit.Cut(LSBcut), RooFit.WeightVar(weight) ) setDataHSB = RooDataSet( "setDataHSB", "setDataHSB", variables, RooFit.Import(setDataSB), RooFit.Cut(HSBcut), RooFit.WeightVar(weight) ) # Observed data (WARNING, BLIND!) setDataSR = RooDataSet( "setDataSR", "setDataSR", variables, RooFit.Cut(SRcut), RooFit.WeightVar(weight), RooFit.Import(treeData) ) setDataVR = RooDataSet( "setDataVR", "setDataVR", variables, RooFit.Cut(VRcut), RooFit.WeightVar(weight), RooFit.Import(treeData) ) # Observed in the VV mass, just for plotting purposes setDataSRSB = RooDataSet( "setDataSRSB", "setDataSRSB", variables, RooFit.Cut("(" + SRcut + ") || (" + SBcut + ")"), RooFit.WeightVar(weight), RooFit.Import(treeData), ) # same for the bkg datasets from MC, where we just apply the base selections (not blind) setVjet = RooDataSet( "setVjet", "setVjet", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeVjet) ) setVjetSB = RooDataSet( "setVjetSB", "setVjetSB", variables, RooFit.Import(setVjet), RooFit.Cut(SBcut), RooFit.WeightVar(weight) ) setVjetSR = RooDataSet( "setVjetSR", "setVjetSR", variables, RooFit.Import(setVjet), RooFit.Cut(SRcut), RooFit.WeightVar(weight) ) setVV = RooDataSet( "setVV", "setVV", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeVV) ) setVVSB = RooDataSet( "setVVSB", "setVVSB", variables, RooFit.Import(setVV), RooFit.Cut(SBcut), RooFit.WeightVar(weight) ) setVVSR = RooDataSet( "setVVSR", "setVVSR", variables, RooFit.Import(setVV), RooFit.Cut(SRcut), RooFit.WeightVar(weight) ) setTop = RooDataSet( "setTop", "setTop", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeTop) ) setTopSB = RooDataSet( "setTopSB", "setTopSB", variables, RooFit.Import(setTop), RooFit.Cut(SBcut), RooFit.WeightVar(weight) ) setTopSR = RooDataSet( "setTopSR", "setTopSR", variables, RooFit.Import(setTop), RooFit.Cut(SRcut), RooFit.WeightVar(weight) ) print " Data events SB: %.2f" % setDataSB.sumEntries() print " V+jets entries: %.2f" % setVjet.sumEntries() print " VV, VH entries: %.2f" % setVV.sumEntries() print " Top,ST entries: %.2f" % setTop.sumEntries() nVV = RooRealVar("nVV", "VV normalization", setVV.sumEntries(SBcut), 0.0, 2 * setVV.sumEntries(SBcut)) nTop = RooRealVar("nTop", "Top normalization", setTop.sumEntries(SBcut), 0.0, 2 * setTop.sumEntries(SBcut)) nVjet = RooRealVar("nVjet", "Vjet normalization", setDataSB.sumEntries(), 0.0, 2 * setDataSB.sumEntries(SBcut)) nVjet2 = RooRealVar("nVjet2", "Vjet2 normalization", setDataSB.sumEntries(), 0.0, 2 * setDataSB.sumEntries(SBcut)) # Apply Top SF nTop.setVal(nTop.getVal() * topSF[nLept][nBtag]) nTop.setError(nTop.getVal() * topSFErr[nLept][nBtag]) # Define entries entryVjet = RooRealVar("entryVjets", "V+jets normalization", setVjet.sumEntries(), 0.0, 1.0e6) entryVV = RooRealVar("entryVV", "VV normalization", setVV.sumEntries(), 0.0, 1.0e6) entryTop = RooRealVar("entryTop", "Top normalization", setTop.sumEntries(), 0.0, 1.0e6) entrySB = RooRealVar("entrySB", "Data SB normalization", setDataSB.sumEntries(SBcut), 0.0, 1.0e6) entrySB.setError(math.sqrt(entrySB.getVal())) entryLSB = RooRealVar("entryLSB", "Data LSB normalization", setDataSB.sumEntries(LSBcut), 0.0, 1.0e6) entryLSB.setError(math.sqrt(entryLSB.getVal())) entryHSB = RooRealVar("entryHSB", "Data HSB normalization", setDataSB.sumEntries(HSBcut), 0.0, 1.0e6) entryHSB.setError(math.sqrt(entryHSB.getVal())) ################################################################################### # _ _ # # | \ | | | (_) | | (_) # # | \| | ___ _ __ _ __ ___ __ _| |_ ___ __ _| |_ _ ___ _ __ # # | . ` |/ _ \| '__| '_ ` _ \ / _` | | / __|/ _` | __| |/ _ \| '_ \ # # | |\ | (_) | | | | | | | | (_| | | \__ \ (_| | |_| | (_) | | | | # # |_| \_|\___/|_| |_| |_| |_|\__,_|_|_|___/\__,_|\__|_|\___/|_| |_| # # # ################################################################################### # fancy ASCII art thanks to, I guess, Jose # start by creating the fit models to get the normalization: # * MAIN and SECONDARY bkg are taken from MC by fitting the whole J_mass range # * The two PDFs are added together using the relative normalizations of the two bkg from MC # * DATA is then fit in the sidebands only using the combined bkg PDF # * The results of the fit are then estrapolated in the SR and the integral is evaluated. # * This defines the bkg normalization in the SR # *******************************************************# # # # V+jets normalization # # # # *******************************************************# # Variables for V+jets constVjet = RooRealVar("constVjet", "slope of the exp", -0.020, -1.0, 0.0) offsetVjet = RooRealVar("offsetVjet", "offset of the erf", 30.0, -50.0, 400.0) widthVjet = RooRealVar("widthVjet", "width of the erf", 100.0, 1.0, 200.0) # 0, 400 a0Vjet = RooRealVar("a0Vjet", "width of the erf", -0.1, -5, 0) a1Vjet = RooRealVar("a1Vjet", "width of the erf", 0.6, 0, 5) a2Vjet = RooRealVar("a2Vjet", "width of the erf", -0.1, -1, 1) if channel == "XZhnnb": offsetVjet = RooRealVar("offsetVjet", "offset of the erf", 500.0, 200.0, 1000.0) if channel == "XZhnnbb": offsetVjet = RooRealVar("offsetVjet", "offset of the erf", 350.0, 200.0, 500.0) # if channel == "XWhenb" or channel == "XZheeb": # offsetVjet.setVal(120.) # offsetVjet.setConstant(True) if channel == "XWhenb": offsetVjet = RooRealVar("offsetVjet", "offset of the erf", 120.0, 80.0, 155.0) if channel == "XWhenbb" or channel == "XZhmmb": offsetVjet = RooRealVar("offsetVjet", "offset of the erf", 67.0, 50.0, 100.0) if channel == "XWhmnb": offsetVjet = RooRealVar("offsetVjet", "offset of the erf", 30.0, -50.0, 600.0) if channel == "XZheeb": offsetVjet.setMin(-400) offsetVjet.setVal(0.0) offsetVjet.setMax(1000) widthVjet.setVal(1.0) # Define V+jets model if fitFuncVjet == "ERFEXP": VjetMass = RooErfExpPdf("VjetMass", fitFuncVjet, J_mass, constVjet, offsetVjet, widthVjet) elif fitFuncVjet == "EXP": VjetMass = RooExponential("VjetMass", fitFuncVjet, J_mass, constVjet) elif fitFuncVjet == "GAUS": VjetMass = RooGaussian("VjetMass", fitFuncVjet, J_mass, offsetVjet, widthVjet) elif fitFuncVjet == "POL": VjetMass = RooChebychev("VjetMass", fitFuncVjet, J_mass, RooArgList(a0Vjet, a1Vjet, a2Vjet)) elif fitFuncVjet == "POW": VjetMass = RooGenericPdf("VjetMass", fitFuncVjet, "@0^@1", RooArgList(J_mass, a0Vjet)) else: print " ERROR! Pdf", fitFuncVjet, "is not implemented for Vjets" exit() if fitAltFuncVjet == "POL": VjetMass2 = RooChebychev("VjetMass2", "polynomial for V+jets mass", J_mass, RooArgList(a0Vjet, a1Vjet, a2Vjet)) else: print " ERROR! Pdf", fitAltFuncVjet, "is not implemented for Vjets" exit() # fit to main bkg in MC (whole range) frVjet = VjetMass.fitTo( setVjet, RooFit.SumW2Error(True), RooFit.Range("h_reasonable_range"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.Save(1), RooFit.PrintLevel(1 if VERBOSE else -1), ) frVjet2 = VjetMass2.fitTo( setVjet, RooFit.SumW2Error(True), RooFit.Range("h_reasonable_range"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.Save(1), RooFit.PrintLevel(1 if VERBOSE else -1), ) if VERBOSE: print "********** Fit result [JET MASS Vjets] *" + "*" * 40, "\n", frVjet.Print(), "\n", "*" * 80 # likelihoodScan(VjetMass, setVjet, [constVjet, offsetVjet, widthVjet]) # *******************************************************# # # # VV, VH normalization # # # # *******************************************************# # Variables for VV # Error function and exponential to model the bulk constVV = RooRealVar("constVV", "slope of the exp", -0.030, -0.1, 0.0) offsetVV = RooRealVar("offsetVV", "offset of the erf", 90.0, 1.0, 300.0) widthVV = RooRealVar("widthVV", "width of the erf", 50.0, 1.0, 100.0) erfrVV = RooErfExpPdf("baseVV", "error function for VV jet mass", J_mass, constVV, offsetVV, widthVV) expoVV = RooExponential("baseVV", "error function for VV jet mass", J_mass, constVV) # gaussian for the V mass peak meanVV = RooRealVar("meanVV", "mean of the gaussian", 90.0, 60.0, 100.0) sigmaVV = RooRealVar("sigmaVV", "sigma of the gaussian", 10.0, 6.0, 30.0) fracVV = RooRealVar("fracVV", "fraction of gaussian wrt erfexp", 3.2e-1, 0.0, 1.0) gausVV = RooGaussian("gausVV", "gaus for VV jet mass", J_mass, meanVV, sigmaVV) # gaussian for the H mass peak meanVH = RooRealVar("meanVH", "mean of the gaussian", 125.0, 100.0, 150.0) sigmaVH = RooRealVar("sigmaVH", "sigma of the gaussian", 10.0, 5.0, 50.0) fracVH = RooRealVar("fracVH", "fraction of gaussian wrt erfexp", 1.5e-2, 0.0, 1.0) gausVH = RooGaussian("gausVH", "gaus for VH jet mass", J_mass, meanVH, sigmaVH) # Define VV model if fitFuncVV == "ERFEXPGAUS": VVMass = RooAddPdf("VVMass", fitFuncVV, RooArgList(gausVV, erfrVV), RooArgList(fracVV)) elif fitFuncVV == "ERFEXPGAUS2": VVMass = RooAddPdf("VVMass", fitFuncVV, RooArgList(gausVH, gausVV, erfrVV), RooArgList(fracVH, fracVV)) elif fitFuncVV == "EXPGAUS": VVMass = RooAddPdf("VVMass", fitFuncVV, RooArgList(gausVV, expoVV), RooArgList(fracVV)) elif fitFuncVV == "EXPGAUS2": VVMass = RooAddPdf("VVMass", fitFuncVV, RooArgList(gausVH, gausVV, expoVV), RooArgList(fracVH, fracVV)) else: print " ERROR! Pdf", fitFuncVV, "is not implemented for VV" exit() # fit to secondary bkg in MC (whole range) frVV = VVMass.fitTo( setVV, RooFit.SumW2Error(True), RooFit.Range("h_reasonable_range"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.Save(1), RooFit.PrintLevel(1 if VERBOSE else -1), ) if VERBOSE: print "********** Fit result [JET MASS VV] ****" + "*" * 40, "\n", frVV.Print(), "\n", "*" * 80 # *******************************************************# # # # Top, ST normalization # # # # *******************************************************# # Variables for Top # Error Function * Exponential to model the bulk constTop = RooRealVar("constTop", "slope of the exp", -0.030, -1.0, 0.0) offsetTop = RooRealVar("offsetTop", "offset of the erf", 175.0, 50.0, 250.0) widthTop = RooRealVar("widthTop", "width of the erf", 100.0, 1.0, 300.0) gausTop = RooGaussian("baseTop", "gaus for Top jet mass", J_mass, offsetTop, widthTop) erfrTop = RooErfExpPdf("baseTop", "error function for Top jet mass", J_mass, constTop, offsetTop, widthTop) # gaussian for the W mass peak meanW = RooRealVar("meanW", "mean of the gaussian", 80.0, 70.0, 90.0) sigmaW = RooRealVar("sigmaW", "sigma of the gaussian", 10.0, 2.0, 20.0) fracW = RooRealVar("fracW", "fraction of gaussian wrt erfexp", 0.1, 0.0, 1.0) gausW = RooGaussian("gausW", "gaus for W jet mass", J_mass, meanW, sigmaW) # gaussian for the Top mass peak meanT = RooRealVar("meanT", "mean of the gaussian", 175.0, 150.0, 200.0) sigmaT = RooRealVar("sigmaT", "sigma of the gaussian", 12.0, 5.0, 30.0) fracT = RooRealVar("fracT", "fraction of gaussian wrt erfexp", 0.1, 0.0, 1.0) gausT = RooGaussian("gausT", "gaus for T jet mass", J_mass, meanT, sigmaT) if channel == "XZheeb" or channel == "XZheebb" or channel == "XZhmmb" or channel == "XZhmmbb": offsetTop = RooRealVar("offsetTop", "offset of the erf", 200.0, -50.0, 450.0) widthTop = RooRealVar("widthTop", "width of the erf", 100.0, 1.0, 1000.0) # Define Top model if fitFuncTop == "ERFEXPGAUS2": TopMass = RooAddPdf("TopMass", fitFuncTop, RooArgList(gausW, gausT, erfrTop), RooArgList(fracW, fracT)) elif fitFuncTop == "ERFEXPGAUS": TopMass = RooAddPdf("TopMass", fitFuncTop, RooArgList(gausT, erfrTop), RooArgList(fracT)) elif fitFuncTop == "GAUS3": TopMass = RooAddPdf("TopMass", fitFuncTop, RooArgList(gausW, gausT, gausTop), RooArgList(fracW, fracT)) elif fitFuncTop == "GAUS2": TopMass = RooAddPdf("TopMass", fitFuncTop, RooArgList(gausT, gausTop), RooArgList(fracT)) elif fitFuncTop == "GAUS": TopMass = RooGaussian("TopMass", fitFuncTop, J_mass, offsetTop, widthTop) else: print " ERROR! Pdf", fitFuncTop, "is not implemented for Top" exit() # fit to secondary bkg in MC (whole range) frTop = TopMass.fitTo( setTop, RooFit.SumW2Error(True), RooFit.Range("h_reasonable_range"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.Save(1), RooFit.PrintLevel(1 if VERBOSE else -1), ) if VERBOSE: print "********** Fit result [JET MASS TOP] ***" + "*" * 40, "\n", frTop.Print(), "\n", "*" * 80 # likelihoodScan(TopMass, setTop, [offsetTop, widthTop]) # *******************************************************# # # # All bkg normalization # # # # *******************************************************# # nVjet.setConstant(False) # nVjet2.setConstant(False) # # constVjet.setConstant(False) # offsetVjet.setConstant(False) # widthVjet.setConstant(False) # a0Vjet.setConstant(False) # a1Vjet.setConstant(False) # a2Vjet.setConstant(False) constVV.setConstant(True) offsetVV.setConstant(True) widthVV.setConstant(True) meanVV.setConstant(True) sigmaVV.setConstant(True) fracVV.setConstant(True) meanVH.setConstant(True) sigmaVH.setConstant(True) fracVH.setConstant(True) constTop.setConstant(True) offsetTop.setConstant(True) widthTop.setConstant(True) meanW.setConstant(True) sigmaW.setConstant(True) fracW.setConstant(True) meanT.setConstant(True) sigmaT.setConstant(True) fracT.setConstant(True) nVV.setConstant(True) nTop.setConstant(True) nVjet.setConstant(False) nVjet2.setConstant(False) # Final background model by adding the main+secondary pdfs (using 'coef': ratio of the secondary/main, from MC) TopMass_ext = RooExtendPdf("TopMass_ext", "extended p.d.f", TopMass, nTop) VVMass_ext = RooExtendPdf("VVMass_ext", "extended p.d.f", VVMass, nVV) VjetMass_ext = RooExtendPdf("VjetMass_ext", "extended p.d.f", VjetMass, nVjet) VjetMass2_ext = RooExtendPdf("VjetMass_ext", "extended p.d.f", VjetMass, nVjet2) BkgMass = RooAddPdf( "BkgMass", "BkgMass", RooArgList(TopMass_ext, VVMass_ext, VjetMass_ext), RooArgList(nTop, nVV, nVjet) ) BkgMass2 = RooAddPdf( "BkgMass2", "BkgMass2", RooArgList(TopMass_ext, VVMass_ext, VjetMass2_ext), RooArgList(nTop, nVV, nVjet2) ) BkgMass.fixAddCoefRange("h_reasonable_range") BkgMass2.fixAddCoefRange("h_reasonable_range") # Extended fit model to data in SB frMass = BkgMass.fitTo( setDataSB, RooFit.SumW2Error(True), RooFit.Extended(True), RooFit.Range("LSBrange,HSBrange"), RooFit.Strategy(2), RooFit.Minimizer("Minuit"), RooFit.Save(1), RooFit.PrintLevel(1 if VERBOSE else -1), ) # , RooFit.NumCPU(10) if VERBOSE: print "********** Fit result [JET MASS DATA] **" + "*" * 40, "\n", frMass.Print(), "\n", "*" * 80 frMass2 = BkgMass2.fitTo( setDataSB, RooFit.SumW2Error(True), RooFit.Extended(True), RooFit.Range("LSBrange,HSBrange"), RooFit.Strategy(2), RooFit.Minimizer("Minuit"), RooFit.Save(1), RooFit.PrintLevel(1 if VERBOSE else -1), ) if VERBOSE: print "********** Fit result [JET MASS DATA] **" + "*" * 40, "\n", frMass2.Print(), "\n", "*" * 80 # if SCAN: # likelihoodScan(VjetMass, setVjet, [constVjet, offsetVjet, widthVjet]) # Fix normalization and parameters of V+jets after the fit to data nVjet.setConstant(True) nVjet2.setConstant(True) constVjet.setConstant(True) offsetVjet.setConstant(True) widthVjet.setConstant(True) a0Vjet.setConstant(True) a1Vjet.setConstant(True) a2Vjet.setConstant(True) # integrals for global normalization # do not integrate the composte model: results have no sense # integral for normalization in the SB iSBVjet = VjetMass.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange,HSBrange")) iSBVV = VVMass.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange,HSBrange")) iSBTop = TopMass.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange,HSBrange")) # integral for normalization in the SR iSRVjet = VjetMass.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange")) iSRVV = VVMass.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange")) iSRTop = TopMass.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange")) # integral for normalization in the VR iVRVjet = VjetMass.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("VRrange")) iVRVV = VVMass.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("VRrange")) iVRTop = TopMass.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("VRrange")) # formual vars SByield = RooFormulaVar( "SByield", "extrapolation to SR", "@0*@1 + @2*@3 + @4*@5", RooArgList(iSBVjet, nVjet, iSBVV, nVV, iSBTop, nTop) ) VRyield = RooFormulaVar( "VRyield", "extrapolation to VR", "@0*@1 + @2*@3 + @4*@5", RooArgList(iVRVjet, nVjet, iVRVV, nVV, iVRTop, nTop) ) SRyield = RooFormulaVar( "SRyield", "extrapolation to SR", "@0*@1 + @2*@3 + @4*@5", RooArgList(iSRVjet, nVjet, iSRVV, nVV, iSRTop, nTop) ) # fractions fSBVjet = RooRealVar( "fVjet", "Fraction of Vjet events in SB", iSBVjet.getVal() * nVjet.getVal() / SByield.getVal(), 0.0, 1.0 ) fSBVV = RooRealVar( "fSBVV", "Fraction of VV events in SB", iSBVV.getVal() * nVV.getVal() / SByield.getVal(), 0.0, 1.0 ) fSBTop = RooRealVar( "fSBTop", "Fraction of Top events in SB", iSBTop.getVal() * nTop.getVal() / SByield.getVal(), 0.0, 1.0 ) fSRVjet = RooRealVar( "fSRVjet", "Fraction of Vjet events in SR", iSRVjet.getVal() * nVjet.getVal() / SRyield.getVal(), 0.0, 1.0 ) fSRVV = RooRealVar( "fSRVV", "Fraction of VV events in SR", iSRVV.getVal() * nVV.getVal() / SRyield.getVal(), 0.0, 1.0 ) fSRTop = RooRealVar( "fSRTop", "Fraction of Top events in SR", iSRTop.getVal() * nTop.getVal() / SRyield.getVal(), 0.0, 1.0 ) # final normalization values bkgYield = SRyield.getVal() bkgYield2 = ( (VjetMass2.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange"))).getVal() * nVjet2.getVal() + iSRVV.getVal() * nVV.getVal() + iSRTop.getVal() * nTop.getVal() ) bkgYield_syst = math.sqrt(SRyield.getPropagatedError(frVV) ** 2 + SRyield.getPropagatedError(frTop) ** 2) bkgYield_stat = math.sqrt(SRyield.getPropagatedError(frMass) ** 2) bkgYield_alte = abs(bkgYield - bkgYield2) # /bkgYield bkgYield_eig_norm = RooRealVar("predSR_eig_norm", "expected yield in SR", bkgYield, 0.0, 1.0e6) print "Events in channel", channel, ": V+jets %.3f (%.1f%%), VV %.3f (%.1f%%), Top %.3f (%.1f%%)" % ( iSRVjet.getVal() * nVjet.getVal(), fSRVjet.getVal() * 100, iSRVV.getVal() * nVV.getVal(), fSRVV.getVal() * 100, iSRTop.getVal() * nTop.getVal(), fSRTop.getVal() * 100, ) print "Events in channel", channel, ": Integral = $%.3f$ & $\pm %.3f$ & $\pm %.3f$ & $\pm %.3f$, observed = %.0f" % ( bkgYield, bkgYield_stat, bkgYield_syst, bkgYield_alte, setDataSR.sumEntries() if not False else -1, )
resultM = rowM * ( corM * colM ) print "resultM(0,0):", resultM(0,0) var_by_hand_error = math.sqrt( pow( resultM(0,0) , 2 ) ) print "var_by_hand_central: ", var_by_hand_central ," +/- ",var_by_hand_error # ------------------------------------------------- # Rooformula var = [ 2*mean2 + 3*sigma2 ] mean2.setVal(par1_value) sigma2.setVal(par2_value) var_formula = RooFormulaVar("var", "2*mean2 + 3*sigma2", "2 * @0 + 3 * @1", RooArgList(mean2,sigma2) ) var_formula_error = var_formula.getPropagatedError( fit_result ) print "var_formula: ", var_formula.getVal()," +/- ", var_formula_error print "" # save Save_Dir = "/afs/cern.ch/user/y/yuchang/www/jacopo_plotsAlpha/my_test_plot" c1 = TCanvas("c1","c 1",800,600) c1.cd() xframe.Draw() c1.SaveAs(Save_Dir+"/"+"test_correlation_matrix_and_error.pdf")
myReader = TTreeReader("outuple", inputfile) nentries = xTuple.GetEntries() print nentries # In[8]: massbins = (6.0 - 4.0) / 0.005 mass = RooRealVar("xM", "M(#mu#muKK)[GeV]", 4.0, 6.0) mass.setBins(int(massbins)) lxy = RooRealVar("xL", "l(xy)", 0.0, 10000.) hlt = RooRealVar("xHlt", "xHlt", 0.0, 20.0) masskk = RooRealVar("kkM", "kkM", 0.5, 1.5) massbins = 100 masskk.setBins(int(massbins)) massmumu = RooRealVar("mumuM", "mumuM", 2.5, 3.5) cutFormula = RooFormulaVar("cutFormula", "cutFormula", "xHlt!=8.0", RooArgList(hlt)) # In[9]: alldata = RooDataSet("alldata", "alldata", xTuple, RooArgSet(masskk, mass, lxy, hlt, massmumu)) #,cutFormula) datasetfile = TFile("xMassDataset.root", "RECREATE") datasetfile.cd() alldata.Write() # In[10]: alldata.numEntries() # In[ ]:
mumuMass = RooRealVar("mumuMass", "mumuMass", 0, 6) mumuMassE = RooRealVar("mumuMassE", "mumuMassE", 0, 10000) tagB0 = RooRealVar("tagB0", "tagB0", 0, 6) genSignal = RooRealVar("genSignal", "genSignal", 0, 6) tagged_mass.setRange("full", 5.0, 5.6) thevars = RooArgSet() thevars.add(tagged_mass) thevars.add(mumuMass) thevars.add(mumuMassE) thevars.add(tagB0) thevars.add(genSignal) fulldata = RooDataSet('fulldata', 'fulldataset', tData, RooArgSet(thevars)) ## add to the input tree the combination of the variables, to be used for the cuts on the dimuon mass deltaB0Mfunc = RooFormulaVar("deltaB0M", "deltaB0M", "@0 - @1", RooArgList(tagged_mass, B0Mass)) deltaJMfunc = RooFormulaVar("deltaJpsiM", "deltaJpsiM", "@0 - @1", RooArgList(mumuMass, JPsiMass)) deltaPMfunc = RooFormulaVar("deltaPsiPM", "deltaPsiPM", "@0 - @1", RooArgList(mumuMass, PsiPMass)) deltaB0M = fulldata.addColumn(deltaB0Mfunc) deltaJpsiM = fulldata.addColumn(deltaJMfunc) deltaPsiPM = fulldata.addColumn(deltaPMfunc) thevars.add(deltaB0M) thevars.add(deltaJpsiM) thevars.add(deltaPsiPM) out_f = TFile("checkfrt%s_jpsi.root" % args.year, "RECREATE") out_w = ROOT.RooWorkspace("toy_w") for ibin in range(len(q2binning) - 1):
thevars = RooArgSet() thevars.add(bMass) thevars.add(bBarMass) thevars.add(mumuMass) thevars.add(mumuMassE) thevars.add(tagB0) thevars.add(bdt_prob) tree = ROOT.TChain('ntuple') tree.AddFile(ifileMC) fulldata = RooDataSet('fulldata', 'fulldataset', tree, RooArgSet(thevars)) ## add to the input tree the combination of the variables for the B0 arb. mass theBMassfunc = RooFormulaVar("theBMass", "#mu^{+}#mu^{-}K^{#pm}#pi^{#mp} mass [GeV]", "@0*@1 + (1-@0)*@2", RooArgList(tagB0, bMass, bBarMass)) ## add to the input tree the combination of the variables, to be used for the cuts on the dimuon mass theBMass = fulldata.addColumn(theBMassfunc) deltaB0Mfunc = RooFormulaVar("deltaB0M", "deltaB0M", "@0 - @1", RooArgList(theBMass, B0Mass)) deltaJMfunc = RooFormulaVar("deltaJpsiM", "deltaJpsiM", "@0 - @1", RooArgList(mumuMass, JPsiMass)) deltaPMfunc = RooFormulaVar("deltaPsiPM", "deltaPsiPM", "@0 - @1", RooArgList(mumuMass, PsiPMass)) theBMass.setRange(4.9, 5.6) deltaB0M = fulldata.addColumn(deltaB0Mfunc) deltaJpsiM = fulldata.addColumn(deltaJMfunc) deltaPsiPM = fulldata.addColumn(deltaPMfunc)
def pdf_logPt2_incoh(): #PDF fit to log_10(pT^2) #tree_in = tree_incoh tree_in = tree #ptbin = 0.04 ptbin = 0.12 ptmin = -5. ptmax = 1. mmin = 2.8 mmax = 3.2 #fitran = [-5., 1.] fitran = [-0.9, 0.1] binned = False #gamma-gamma 131 evt for pT<0.18 #output log file out = open("out.txt", "w") ut.log_results( out, "in " + infile + " in_coh " + infile_coh + " in_gg " + infile_gg) loglist = [(x, eval(x)) for x in ["ptbin", "ptmin", "ptmax", "mmin", "mmax", "fitran", "binned"]] strlog = ut.make_log_string(loglist) ut.log_results(out, strlog + "\n") #input data pT = RooRealVar("jRecPt", "pT", 0, 10) m = RooRealVar("jRecM", "mass", 0, 10) dataIN = RooDataSet("data", "data", tree_in, RooArgSet(pT, m)) strsel = "jRecM>{0:.3f} && jRecM<{1:.3f}".format(mmin, mmax) data = dataIN.reduce(strsel) #x is RooRealVar for log(Pt2) draw = "TMath::Log10(jRecPt*jRecPt)" draw_func = RooFormulaVar("x", "log_{10}( #it{p}_{T}^{2} ) (GeV^{2})", draw, RooArgList(pT)) x = data.addColumn(draw_func) x.setRange("fitran", fitran[0], fitran[1]) #binned data nbins, ptmax = ut.get_nbins(ptbin, ptmin, ptmax) hPt = TH1D("hPt", "hPt", nbins, ptmin, ptmax) tree_in.Draw(draw + " >> hPt", strsel) dataH = RooDataHist("dataH", "dataH", RooArgList(x), hPt) #range for plot x.setMin(ptmin) x.setMax(ptmax) x.setRange("plotran", ptmin, ptmax) #create the pdf b = RooRealVar("b", "b", 5., 0., 10.) pdf_func = "log(10.)*pow(10.,x)*exp(-b*pow(10.,x))" pdf_logPt2 = RooGenericPdf("pdf_logPt2", pdf_func, RooArgList(x, b)) #make the fit if binned == True: r1 = pdf_logPt2.fitTo(dataH, rf.Range("fitran"), rf.Save()) else: r1 = pdf_logPt2.fitTo(data, rf.Range("fitran"), rf.Save()) ut.log_results(out, ut.log_fit_result(r1)) #calculate norm to number of events xset = RooArgSet(x) ipdf = pdf_logPt2.createIntegral(xset, rf.NormSet(xset), rf.Range("fitran")) print "PDF integral:", ipdf.getVal() if binned == True: nevt = tree_incoh.Draw( "", strsel + " && " + draw + ">{0:.3f}".format(fitran[0]) + " && " + draw + "<{1:.3f}".format(fitran[0], fitran[1])) else: nevt = data.sumEntries("x", "fitran") print "nevt:", nevt pdf_logPt2.setNormRange("fitran") print "PDF norm:", pdf_logPt2.getNorm(RooArgSet(x)) #a = nevt/ipdf.getVal() a = nevt / pdf_logPt2.getNorm(RooArgSet(x)) ut.log_results(out, "log_10(pT^2) parametrization:") ut.log_results(out, "A = {0:.2f}".format(a)) ut.log_results(out, ut.log_fit_parameters(r1, 0, 2)) print "a =", a #Coherent contribution hPtCoh = ut.prepare_TH1D("hPtCoh", ptbin, ptmin, ptmax) hPtCoh.Sumw2() #tree_coh.Draw(draw + " >> hPtCoh", strsel) tree_coh.Draw("TMath::Log10(jGenPt*jGenPt) >> hPtCoh", strsel) ut.norm_to_data(hPtCoh, hPt, rt.kBlue, -5., -2.2) # norm for coh #ut.norm_to_data(hPtCoh, hPt, rt.kBlue, -5, -2.1) #ut.norm_to_num(hPtCoh, 405, rt.kBlue) print "Coherent integral:", hPtCoh.Integral() #TMath::Log10(jRecPt*jRecPt) #Sartre generated coherent shape sartre = TFile.Open( "/home/jaroslav/sim/sartre_tx/sartre_AuAu_200GeV_Jpsi_coh_2p7Mevt.root" ) sartre_tree = sartre.Get("sartre_tree") hSartre = ut.prepare_TH1D("hSartre", ptbin, ptmin, ptmax) sartre_tree.Draw("TMath::Log10(pT*pT) >> hSartre", "rapidity>-1 && rapidity<1") ut.norm_to_data(hSartre, hPt, rt.kViolet, -5, -2) # norm for Sartre #gamma-gamma contribution hPtGG = ut.prepare_TH1D("hPtGG", ptbin, ptmin, ptmax) tree_gg.Draw(draw + " >> hPtGG", strsel) #ut.norm_to_data(hPtGG, hPt, rt.kGreen, -5., -2.9) ut.norm_to_num(hPtGG, 131., rt.kGreen) print "Int GG:", hPtGG.Integral() #psi' contribution psiP = TFile.Open(basedir_mc + "/ana_slight14e4x1_s6_sel5z.root") psiP_tree = psiP.Get("jRecTree") hPtPsiP = ut.prepare_TH1D("hPtPsiP", ptbin, ptmin, ptmax) psiP_tree.Draw(draw + " >> hPtPsiP", strsel) ut.norm_to_num(hPtPsiP, 12, rt.kViolet) #sum of all contributions hSum = ut.prepare_TH1D("hSum", ptbin, ptmin, ptmax) hSum.SetLineWidth(3) #add ggel to the sum hSum.Add(hPtGG) #add incoherent contribution func_logPt2 = TF1("pdf_logPt2", "[0]*log(10.)*pow(10.,x)*exp(-[1]*pow(10.,x))", -10., 10.) func_logPt2.SetParameters(a, b.getVal()) hInc = ut.prepare_TH1D("hInc", ptbin, ptmin, ptmax) ut.fill_h1_tf(hInc, func_logPt2) hSum.Add(hInc) #add coherent contribution hSum.Add(hPtCoh) #add psi(2S) contribution #hSum.Add(hPtPsiP) #set to draw as a lines ut.line_h1(hSum, rt.kBlack) #create canvas frame can = ut.box_canvas() ut.set_margin_lbtr(gPad, 0.11, 0.09, 0.01, 0.01) frame = x.frame(rf.Bins(nbins), rf.Title("")) frame.SetTitle("") frame.SetMaximum(75) frame.SetYTitle("Events / ({0:.3f}".format(ptbin) + " GeV^{2})") print "Int data:", hPt.Integral() #plot the data if binned == True: dataH.plotOn(frame, rf.Name("data")) else: data.plotOn(frame, rf.Name("data")) pdf_logPt2.plotOn(frame, rf.Range("fitran"), rf.LineColor(rt.kRed), rf.Name("pdf_logPt2")) pdf_logPt2.plotOn(frame, rf.Range("plotran"), rf.LineColor(rt.kRed), rf.Name("pdf_logPt2_full"), rf.LineStyle(rt.kDashed)) frame.Draw() amin = TMath.Power(10, ptmin) amax = TMath.Power(10, ptmax) - 1 print amin, amax pt2func = TF1("f1", "TMath::Power(10, x)", amin, amax) #TMath::Power(x, 10) aPt2 = TGaxis(-5, 75, 1, 75, "f1", 510, "-") ut.set_axis(aPt2) aPt2.SetTitle("pt2") #aPt2.Draw(); leg = ut.prepare_leg(0.57, 0.78, 0.14, 0.19, 0.03) ut.add_leg_mass(leg, mmin, mmax) hx = ut.prepare_TH1D("hx", 1, 0, 1) hx.Draw("same") ln = ut.col_lin(rt.kRed) leg.AddEntry(hx, "Data") leg.AddEntry(hPtCoh, "Sartre MC", "l") leg.AddEntry(hPtGG, "#gamma#gamma#rightarrow e^{+}e^{-} MC", "l") #leg.AddEntry(ln, "ln(10)*#it{A}*10^{log_{10}#it{p}_{T}^{2}}exp(-#it{b}10^{log_{10}#it{p}_{T}^{2}})", "l") #leg.AddEntry(ln, "Incoherent fit", "l") leg.Draw("same") l0 = ut.cut_line(fitran[0], 0.9, frame) l1 = ut.cut_line(fitran[1], 0.9, frame) #l0.Draw() #l1.Draw() desc = pdesc(frame, 0.14, 0.8, 0.054) desc.set_text_size(0.03) desc.itemD("#chi^{2}/ndf", frame.chiSquare("pdf_logPt2", "data", 2), -1, rt.kRed) desc.itemD("#it{A}", a, -1, rt.kRed) desc.itemR("#it{b}", b, rt.kRed) desc.draw() #put the sum #hSum.Draw("same") #gPad.SetLogy() frame.Draw("same") #put gamma-gamma hPtGG.Draw("same") #put coherent J/psi hPtCoh.Draw("same") #put Sartre generated coherent shape #hSartre.Draw("same") #put psi(2S) contribution #hPtPsiP.Draw("same") leg2 = ut.prepare_leg(0.14, 0.9, 0.14, 0.08, 0.03) leg2.AddEntry( ln, "ln(10)*#it{A}*10^{log_{10}#it{p}_{T}^{2}}exp(-#it{b}10^{log_{10}#it{p}_{T}^{2}})", "l") #leg2.AddEntry(hPtCoh, "Sartre MC reconstructed", "l") #leg2.AddEntry(hSartre, "Sartre MC generated", "l") leg2.Draw("same") ut.invert_col(rt.gPad) can.SaveAs("01fig.pdf")
# retrieve acceptance functions acceptance1 = workspace.function('acceptance_%s' % mode1) # DsK acceptance2 = workspace.function('acceptance_%s' % mode2) # Dsπ # Acceptance ratio FIXME: hardcoded ROOT file rfile = TFile('data/acceptance-ratio-hists.root', 'read') hcorr = rfile.Get('haccratio_cpowerlaw') ardhist = RooDataHist('ardhist', 'DsK/DsPi acceptance ratio datahist', RooArgList(time), RooFit.Import(hcorr, False)) accratio = RooHistFunc('accratio', 'DsK/DsPi acceptance ratio', RooArgSet(time), ardhist) cacceptance = PowLawAcceptance(acceptance2, 'cacceptance', accratio) # cacceptance = PowLawAcceptance('cacceptance', 'Corrected Power law acceptance', # turnon, time, offset, exponent, beta, accratio) ratio = RooFormulaVar('ratio', '@0/@1', RooArgList(acceptance1, cacceptance)) tframe = time.frame(RooFit.Range('fullrange'), RooFit.Name('ptime'), RooFit.Title('Acceptance ratio (0.2 - 10 ps)')) acceptance1.plotOn(tframe, RooFit.LineColor(kBlue)) # acceptance2.plotOn(tframe, RooFit.LineColor(kRed)) # accratio.plotOn(tframe, RooFit.LineColor(kBlack)) cacceptance.plotOn(tframe, RooFit.LineColor(kRed)) ratio.plotOn(tframe, RooFit.LineColor(kGreen)) tframe.Draw() if doPrint: gPad.Print('plots/flat-test.png')
models = {} gauss_models = {} canvases = {} __objects = [] for o, d in zip((x_obs, y_obs, pull_xm, pull_ym), ('x', 'y', 'xm', 'ym')): tag = '_' + d mean1 = RooRealVar('mean1' + tag, 'mean1' + tag, 0, -10, 10) s1 = RooRealVar('s1' + tag, 's1' + tag, 10, 0, 20) s2 = RooRealVar('s2' + tag, 's2' + tag, 15, 0, 40) frac = RooRealVar('f' + tag, 'f' + tag, 0.2, 0.001, 0.499) __objects += [mean1, s1, s2, frac] sm = RooRealVar('sm' + tag, 'sm' + tag, 1, 0.02, 20) ss = RooRealVar('ss' + tag, 'ss' + tag, 1, 0.01, 19) sf1 = RooFormulaVar("sf1" + tag, "sf1" + tag, "- sqrt(@0 / (1 - @0)) * @1 + @2", RooArgList(frac, ss, sm)) sf2 = RooFormulaVar("sf2" + tag, "sf2" + tag, "sqrt((1 - @0) / @0) * @1 + @2", RooArgList(frac, ss, sm)) __objects += [sm, ss, sf1, sf2] # else: # mean2 = RooRealVar('mean2' + tag, 'mean2' + tag, 0, -10, 10) # __objects += [mean2] gauss = RooGaussian("gauss" + tag, "gauss" + tag, o, mean1, s1) gauss_models[d] = gauss g1 = RooGaussian("g1" + tag, "g1" + tag, o, mean1, sf1) g2 = RooGaussian("g2" + tag, "g2" + tag, o, mean1, sf2) model = RooAddModel("model" + tag, "model" + tag, RooArgList(g1, g2), RooArgList(frac)) __objects += [g1, g2, model]
def signal(category): interPar = True n = len(genPoints) cColor = color[category] if category in color else 4 nBtag = category.count('b') isAH = False #relict from using Alberto's more complex script if not os.path.exists(PLOTDIR + "MC_signal_" + YEAR): os.makedirs(PLOTDIR + "MC_signal_" + YEAR) #*******************************************************# # # # Variables and selections # # # #*******************************************************# X_mass = RooRealVar("jj_mass_widejet", "m_{jj}", X_min, X_max, "GeV") j1_pt = RooRealVar("jpt_1", "jet1 pt", 0., 13000., "GeV") jj_deltaEta = RooRealVar("jj_deltaEta_widejet", "", 0., 5.) jbtag_WP_1 = RooRealVar("jbtag_WP_1", "", -1., 4.) jbtag_WP_2 = RooRealVar("jbtag_WP_2", "", -1., 4.) fatjetmass_1 = RooRealVar("fatjetmass_1", "", -1., 2500.) fatjetmass_2 = RooRealVar("fatjetmass_2", "", -1., 2500.) jid_1 = RooRealVar("jid_1", "j1 ID", -1., 8.) jid_2 = RooRealVar("jid_2", "j2 ID", -1., 8.) jnmuons_1 = RooRealVar("jnmuons_1", "j1 n_{#mu}", -1., 8.) jnmuons_2 = RooRealVar("jnmuons_2", "j2 n_{#mu}", -1., 8.) jnmuons_loose_1 = RooRealVar("jnmuons_loose_1", "jnmuons_loose_1", -1., 8.) jnmuons_loose_2 = RooRealVar("jnmuons_loose_2", "jnmuons_loose_2", -1., 8.) nmuons = RooRealVar("nmuons", "n_{#mu}", -1., 10.) nelectrons = RooRealVar("nelectrons", "n_{e}", -1., 10.) HLT_AK8PFJet500 = RooRealVar("HLT_AK8PFJet500", "", -1., 1.) HLT_PFJet500 = RooRealVar("HLT_PFJet500", "", -1., 1.) HLT_CaloJet500_NoJetID = RooRealVar("HLT_CaloJet500_NoJetID", "", -1., 1.) HLT_PFHT900 = RooRealVar("HLT_PFHT900", "", -1., 1.) HLT_AK8PFJet550 = RooRealVar("HLT_AK8PFJet550", "", -1., 1.) HLT_PFJet550 = RooRealVar("HLT_PFJet550", "", -1., 1.) HLT_CaloJet550_NoJetID = RooRealVar("HLT_CaloJet550_NoJetID", "", -1., 1.) HLT_PFHT1050 = RooRealVar("HLT_PFHT1050", "", -1., 1.) #HLT_DoublePFJets100_CaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets100_CaloBTagDeepCSV_p71" , "", -1., 1. ) #HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71", "", -1., 1. ) #HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71", "", -1., 1. ) #HLT_DoublePFJets200_CaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets200_CaloBTagDeepCSV_p71" , "", -1., 1. ) #HLT_DoublePFJets350_CaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets350_CaloBTagDeepCSV_p71" , "", -1., 1. ) #HLT_DoublePFJets40_CaloBTagDeepCSV_p71 =RooRealVar("HLT_DoublePFJets40_CaloBTagDeepCSV_p71" , "", -1., 1. ) weight = RooRealVar("eventWeightLumi", "", -1.e9, 1.e9) # Define the RooArgSet which will include all the variables defined before # there is a maximum of 9 variables in the declaration, so the others need to be added with 'add' variables = RooArgSet(X_mass) variables.add( RooArgSet(j1_pt, jj_deltaEta, jbtag_WP_1, jbtag_WP_2, fatjetmass_1, fatjetmass_2, jnmuons_1, jnmuons_2, weight)) variables.add( RooArgSet(nmuons, nelectrons, jid_1, jid_2, jnmuons_loose_1, jnmuons_loose_2)) variables.add( RooArgSet(HLT_AK8PFJet500, HLT_PFJet500, HLT_CaloJet500_NoJetID, HLT_PFHT900, HLT_AK8PFJet550, HLT_PFJet550, HLT_CaloJet550_NoJetID, HLT_PFHT1050)) #variables.add(RooArgSet(HLT_DoublePFJets100_CaloBTagDeepCSV_p71, HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71, HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71, HLT_DoublePFJets200_CaloBTagDeepCSV_p71, HLT_DoublePFJets350_CaloBTagDeepCSV_p71, HLT_DoublePFJets40_CaloBTagDeepCSV_p71)) X_mass.setRange("X_reasonable_range", X_mass.getMin(), X_mass.getMax()) X_mass.setRange("X_integration_range", X_mass.getMin(), X_mass.getMax()) if VARBINS: binsXmass = RooBinning(len(abins) - 1, abins) X_mass.setBinning(binsXmass) plot_binning = RooBinning( int((X_mass.getMax() - X_mass.getMin()) / 100.), X_mass.getMin(), X_mass.getMax()) else: X_mass.setBins(int((X_mass.getMax() - X_mass.getMin()) / 10)) binsXmass = RooBinning(int((X_mass.getMax() - X_mass.getMin()) / 100.), X_mass.getMin(), X_mass.getMax()) plot_binning = binsXmass X_mass.setBinning(plot_binning, "PLOT") #X_mass.setBins(int((X_mass.getMax() - X_mass.getMin())/10)) #binsXmass = RooBinning(int((X_mass.getMax() - X_mass.getMin())/100), X_mass.getMin(), X_mass.getMax()) #X_mass.setBinning(binsXmass, "PLOT") massArg = RooArgSet(X_mass) # Cuts if BTAGGING == 'semimedium': SRcut = aliasSM[category] #SRcut = aliasSM[category+"_vetoAK8"] else: SRcut = alias[category].format(WP=working_points[BTAGGING]) #SRcut = alias[category+"_vetoAK8"].format(WP=working_points[BTAGGING]) if ADDSELECTION: SRcut += SELECTIONS[options.selection] print " Cut:\t", SRcut #*******************************************************# # # # Signal fits # # # #*******************************************************# treeSign = {} setSignal = {} vmean = {} vsigma = {} valpha1 = {} vslope1 = {} valpha2 = {} vslope2 = {} smean = {} ssigma = {} salpha1 = {} sslope1 = {} salpha2 = {} sslope2 = {} sbrwig = {} signal = {} signalExt = {} signalYield = {} signalIntegral = {} signalNorm = {} signalXS = {} frSignal = {} frSignal1 = {} frSignal2 = {} frSignal3 = {} # Signal shape uncertainties (common amongst all mass points) xmean_jes = RooRealVar( "CMS" + YEAR + "_sig_" + category + "_p1_scale_jes", "Variation of the resonance position with the jet energy scale", 0.02, -1., 1.) #0.001 smean_jes = RooRealVar( "CMS" + YEAR + "_sig_" + category + "_p1_jes", "Change of the resonance position with the jet energy scale", 0., -10, 10) xsigma_jer = RooRealVar( "CMS" + YEAR + "_sig_" + category + "_p2_scale_jer", "Variation of the resonance width with the jet energy resolution", 0.10, -1., 1.) ssigma_jer = RooRealVar( "CMS" + YEAR + "_sig_" + category + "_p2_jer", "Change of the resonance width with the jet energy resolution", 0., -10, 10) xmean_jes.setConstant(True) smean_jes.setConstant(True) xsigma_jer.setConstant(True) ssigma_jer.setConstant(True) for m in massPoints: signalMass = "%s_M%d" % (stype, m) signalName = "ZpBB_{}_{}_M{}".format(YEAR, category, m) sampleName = "ZpBB_M{}".format(m) signalColor = sample[sampleName][ 'linecolor'] if signalName in sample else 1 # define the signal PDF vmean[m] = RooRealVar(signalName + "_vmean", "Crystal Ball mean", m, m * 0.96, m * 1.05) smean[m] = RooFormulaVar(signalName + "_mean", "@0*(1+@1*@2)", RooArgList(vmean[m], xmean_jes, smean_jes)) vsigma[m] = RooRealVar(signalName + "_vsigma", "Crystal Ball sigma", m * 0.0233, m * 0.019, m * 0.025) ssigma[m] = RooFormulaVar( signalName + "_sigma", "@0*(1+@1*@2)", RooArgList(vsigma[m], xsigma_jer, ssigma_jer)) valpha1[m] = RooRealVar( signalName + "_valpha1", "Crystal Ball alpha 1", 0.2, 0.05, 0.28 ) # number of sigmas where the exp is attached to the gaussian core. >0 left, <0 right salpha1[m] = RooFormulaVar(signalName + "_alpha1", "@0", RooArgList(valpha1[m])) #vslope1[m] = RooRealVar(signalName + "_vslope1", "Crystal Ball slope 1", 10., 0.1, 20.) # slope of the power tail vslope1[m] = RooRealVar(signalName + "_vslope1", "Crystal Ball slope 1", 13., 10., 20.) # slope of the power tail sslope1[m] = RooFormulaVar(signalName + "_slope1", "@0", RooArgList(vslope1[m])) valpha2[m] = RooRealVar(signalName + "_valpha2", "Crystal Ball alpha 2", 1.) valpha2[m].setConstant(True) salpha2[m] = RooFormulaVar(signalName + "_alpha2", "@0", RooArgList(valpha2[m])) #vslope2[m] = RooRealVar(signalName + "_vslope2", "Crystal Ball slope 2", 6., 2.5, 15.) # slope of the higher power tail ## FIXME test FIXME vslope2_estimation = -5.88111436852 + m * 0.00728809389442 + m * m * ( -1.65059568762e-06) + m * m * m * (1.25128996309e-10) vslope2[m] = RooRealVar(signalName + "_vslope2", "Crystal Ball slope 2", vslope2_estimation, vslope2_estimation * 0.9, vslope2_estimation * 1.1) # slope of the higher power tail ## FIXME end FIXME sslope2[m] = RooFormulaVar( signalName + "_slope2", "@0", RooArgList(vslope2[m])) # slope of the higher power tail signal[m] = RooDoubleCrystalBall(signalName, "m_{%s'} = %d GeV" % ('X', m), X_mass, smean[m], ssigma[m], salpha1[m], sslope1[m], salpha2[m], sslope2[m]) # extend the PDF with the yield to perform an extended likelihood fit signalYield[m] = RooRealVar(signalName + "_yield", "signalYield", 50, 0., 1.e15) signalNorm[m] = RooRealVar(signalName + "_norm", "signalNorm", 1., 0., 1.e15) signalXS[m] = RooRealVar(signalName + "_xs", "signalXS", 1., 0., 1.e15) signalExt[m] = RooExtendPdf(signalName + "_ext", "extended p.d.f", signal[m], signalYield[m]) # ---------- if there is no simulated signal, skip this mass point ---------- if m in genPoints: if VERBOSE: print " - Mass point", m # define the dataset for the signal applying the SR cuts treeSign[m] = TChain("tree") if YEAR == 'run2': pd = sample[sampleName]['files'] if len(pd) > 3: print "multiple files given than years for a single masspoint:", pd sys.exit() for ss in pd: if not '2016' in ss and not '2017' in ss and not '2018' in ss: print "unknown year given in:", ss sys.exit() else: pd = [x for x in sample[sampleName]['files'] if YEAR in x] if len(pd) > 1: print "multiple files given for a single masspoint/year:", pd sys.exit() for ss in pd: if options.unskimmed: j = 0 while True: if os.path.exists(NTUPLEDIR + ss + "/" + ss + "_flatTuple_{}.root".format(j)): treeSign[m].Add(NTUPLEDIR + ss + "/" + ss + "_flatTuple_{}.root".format(j)) j += 1 else: print "found {} files for sample:".format(j), ss break else: if os.path.exists(NTUPLEDIR + ss + ".root"): treeSign[m].Add(NTUPLEDIR + ss + ".root") else: print "found no file for sample:", ss if treeSign[m].GetEntries() <= 0.: if VERBOSE: print " - 0 events available for mass", m, "skipping mass point..." signalNorm[m].setVal(-1) vmean[m].setConstant(True) vsigma[m].setConstant(True) salpha1[m].setConstant(True) sslope1[m].setConstant(True) salpha2[m].setConstant(True) sslope2[m].setConstant(True) signalNorm[m].setConstant(True) signalXS[m].setConstant(True) continue #setSignal[m] = RooDataSet("setSignal_"+signalName, "setSignal", variables, RooFit.Cut(SRcut), RooFit.WeightVar("eventWeightLumi*BTagAK4Weight_deepJet"), RooFit.Import(treeSign[m])) setSignal[m] = RooDataSet("setSignal_" + signalName, "setSignal", variables, RooFit.Cut(SRcut), RooFit.WeightVar(weight), RooFit.Import(treeSign[m])) if VERBOSE: print " - Dataset with", setSignal[m].sumEntries( ), "events loaded" # FIT entries = setSignal[m].sumEntries() if entries < 0. or entries != entries: entries = 0 signalYield[m].setVal(entries) # Instead of eventWeightLumi #signalYield[m].setVal(entries * LUMI / (300000 if YEAR=='run2' else 100000) ) if treeSign[m].GetEntries(SRcut) > 5: if VERBOSE: print " - Running fit" frSignal[m] = signalExt[m].fitTo(setSignal[m], RooFit.Save(1), RooFit.Extended(True), RooFit.SumW2Error(True), RooFit.PrintLevel(-1)) if VERBOSE: print "********** Fit result [", m, "] **", category, "*" * 40, "\n", frSignal[ m].Print(), "\n", "*" * 80 if VERBOSE: frSignal[m].correlationMatrix().Print() drawPlot(signalMass + "_" + category, stype + category, X_mass, signal[m], setSignal[m], frSignal[m]) else: print " WARNING: signal", stype, "and mass point", m, "in category", category, "has 0 entries or does not exist" # Remove HVT cross sections #xs = getCrossSection(stype, channel, m) xs = 1. signalXS[m].setVal(xs * 1000.) signalIntegral[m] = signalExt[m].createIntegral( massArg, RooFit.NormSet(massArg), RooFit.Range("X_integration_range")) boundaryFactor = signalIntegral[m].getVal() if boundaryFactor < 0. or boundaryFactor != boundaryFactor: boundaryFactor = 0 if VERBOSE: print " - Fit normalization vs integral:", signalYield[ m].getVal(), "/", boundaryFactor, "events" signalNorm[m].setVal(boundaryFactor * signalYield[m].getVal() / signalXS[m].getVal() ) # here normalize to sigma(X) x Br = 1 [fb] vmean[m].setConstant(True) vsigma[m].setConstant(True) valpha1[m].setConstant(True) vslope1[m].setConstant(True) valpha2[m].setConstant(True) vslope2[m].setConstant(True) signalNorm[m].setConstant(True) signalXS[m].setConstant(True) #*******************************************************# # # # Signal interpolation # # # #*******************************************************# ### FIXME FIXME just for a test FIXME FIXME #print #print #print "slope2 fit results:" #print #y_vals = [] #for m in genPoints: # y_vals.append(vslope2[m].getVal()) #print "m =", genPoints #print "y =", y_vals #sys.exit() ### FIXME FIXME test end FIXME FIXME # ====== CONTROL PLOT ====== color_scheme = [ 636, 635, 634, 633, 632, 633, 636, 635, 634, 633, 632, 633, 636, 635, 634, 633, 632, 633, 636, 635, 634, 633, 632, 633, 636, 635, 634, 633, 632, 633, 636, 635, 634, 633, 632, 633, 636, 635, 634, 633, 632, 633 ] c_signal = TCanvas("c_signal", "c_signal", 800, 600) c_signal.cd() frame_signal = X_mass.frame() for j, m in enumerate(genPoints): if m in signalExt.keys(): #print "color:",(j%9)+1 #print "signalNorm[m].getVal() =", signalNorm[m].getVal() #print "RooAbsReal.NumEvent =", RooAbsReal.NumEvent signal[m].plotOn( frame_signal, RooFit.LineColor(color_scheme[j]), RooFit.Normalization(signalNorm[m].getVal(), RooAbsReal.NumEvent), RooFit.Range("X_reasonable_range")) frame_signal.GetXaxis().SetRangeUser(0, 10000) frame_signal.Draw() drawCMS(-1, "Simulation Preliminary", year=YEAR) #drawCMS(-1, "Work in Progress", year=YEAR, suppressCMS=True) #drawCMS(-1, "", year=YEAR, suppressCMS=True) drawAnalysis(category) drawRegion(category) c_signal.SaveAs(PLOTDIR + "MC_signal_" + YEAR + "/" + stype + "_" + category + "_Signal.pdf") c_signal.SaveAs(PLOTDIR + "MC_signal_" + YEAR + "/" + stype + "_" + category + "_Signal.png") #if VERBOSE: raw_input("Press Enter to continue...") # ====== CONTROL PLOT ====== # Normalization gnorm = TGraphErrors() gnorm.SetTitle(";m_{X} (GeV);integral (GeV)") gnorm.SetMarkerStyle(20) gnorm.SetMarkerColor(1) gnorm.SetMaximum(0) inorm = TGraphErrors() inorm.SetMarkerStyle(24) fnorm = TF1("fnorm", "pol9", 700, 3000) fnorm.SetLineColor(920) fnorm.SetLineStyle(7) fnorm.SetFillColor(2) fnorm.SetLineColor(cColor) # Mean gmean = TGraphErrors() gmean.SetTitle(";m_{X} (GeV);gaussian mean (GeV)") gmean.SetMarkerStyle(20) gmean.SetMarkerColor(cColor) gmean.SetLineColor(cColor) imean = TGraphErrors() imean.SetMarkerStyle(24) fmean = TF1("fmean", "pol1", 0, 10000) fmean.SetLineColor(2) fmean.SetFillColor(2) # Width gsigma = TGraphErrors() gsigma.SetTitle(";m_{X} (GeV);gaussian width (GeV)") gsigma.SetMarkerStyle(20) gsigma.SetMarkerColor(cColor) gsigma.SetLineColor(cColor) isigma = TGraphErrors() isigma.SetMarkerStyle(24) fsigma = TF1("fsigma", "pol1", 0, 10000) fsigma.SetLineColor(2) fsigma.SetFillColor(2) # Alpha1 galpha1 = TGraphErrors() galpha1.SetTitle(";m_{X} (GeV);crystal ball lower alpha") galpha1.SetMarkerStyle(20) galpha1.SetMarkerColor(cColor) galpha1.SetLineColor(cColor) ialpha1 = TGraphErrors() ialpha1.SetMarkerStyle(24) falpha1 = TF1("falpha", "pol1", 0, 10000) #pol0 falpha1.SetLineColor(2) falpha1.SetFillColor(2) # Slope1 gslope1 = TGraphErrors() gslope1.SetTitle(";m_{X} (GeV);exponential lower slope (1/Gev)") gslope1.SetMarkerStyle(20) gslope1.SetMarkerColor(cColor) gslope1.SetLineColor(cColor) islope1 = TGraphErrors() islope1.SetMarkerStyle(24) fslope1 = TF1("fslope", "pol1", 0, 10000) #pol0 fslope1.SetLineColor(2) fslope1.SetFillColor(2) # Alpha2 galpha2 = TGraphErrors() galpha2.SetTitle(";m_{X} (GeV);crystal ball upper alpha") galpha2.SetMarkerStyle(20) galpha2.SetMarkerColor(cColor) galpha2.SetLineColor(cColor) ialpha2 = TGraphErrors() ialpha2.SetMarkerStyle(24) falpha2 = TF1("falpha", "pol1", 0, 10000) #pol0 falpha2.SetLineColor(2) falpha2.SetFillColor(2) # Slope2 gslope2 = TGraphErrors() gslope2.SetTitle(";m_{X} (GeV);exponential upper slope (1/Gev)") gslope2.SetMarkerStyle(20) gslope2.SetMarkerColor(cColor) gslope2.SetLineColor(cColor) islope2 = TGraphErrors() islope2.SetMarkerStyle(24) fslope2 = TF1("fslope", "pol1", 0, 10000) #pol0 fslope2.SetLineColor(2) fslope2.SetFillColor(2) n = 0 for i, m in enumerate(genPoints): if not m in signalNorm.keys(): continue if signalNorm[m].getVal() < 1.e-6: continue if gnorm.GetMaximum() < signalNorm[m].getVal(): gnorm.SetMaximum(signalNorm[m].getVal()) gnorm.SetPoint(n, m, signalNorm[m].getVal()) #gnorm.SetPointError(i, 0, signalNorm[m].getVal()/math.sqrt(treeSign[m].GetEntriesFast())) gmean.SetPoint(n, m, vmean[m].getVal()) gmean.SetPointError(n, 0, min(vmean[m].getError(), vmean[m].getVal() * 0.02)) gsigma.SetPoint(n, m, vsigma[m].getVal()) gsigma.SetPointError( n, 0, min(vsigma[m].getError(), vsigma[m].getVal() * 0.05)) galpha1.SetPoint(n, m, valpha1[m].getVal()) galpha1.SetPointError( n, 0, min(valpha1[m].getError(), valpha1[m].getVal() * 0.10)) gslope1.SetPoint(n, m, vslope1[m].getVal()) gslope1.SetPointError( n, 0, min(vslope1[m].getError(), vslope1[m].getVal() * 0.10)) galpha2.SetPoint(n, m, salpha2[m].getVal()) galpha2.SetPointError( n, 0, min(valpha2[m].getError(), valpha2[m].getVal() * 0.10)) gslope2.SetPoint(n, m, sslope2[m].getVal()) gslope2.SetPointError( n, 0, min(vslope2[m].getError(), vslope2[m].getVal() * 0.10)) #tmpVar = w.var(var+"_"+signalString) #print m, tmpVar.getVal(), tmpVar.getError() n = n + 1 gmean.Fit(fmean, "Q0", "SAME") gsigma.Fit(fsigma, "Q0", "SAME") galpha1.Fit(falpha1, "Q0", "SAME") gslope1.Fit(fslope1, "Q0", "SAME") galpha2.Fit(falpha2, "Q0", "SAME") gslope2.Fit(fslope2, "Q0", "SAME") # gnorm.Fit(fnorm, "Q0", "", 700, 5000) #for m in [5000, 5500]: gnorm.SetPoint(gnorm.GetN(), m, gnorm.Eval(m, 0, "S")) #gnorm.Fit(fnorm, "Q", "SAME", 700, 6000) gnorm.Fit(fnorm, "Q", "SAME", 1800, 8000) ## adjusted recently for m in massPoints: if vsigma[m].getVal() < 10.: vsigma[m].setVal(10.) # Interpolation method syield = gnorm.Eval(m) spline = gnorm.Eval(m, 0, "S") sfunct = fnorm.Eval(m) #delta = min(abs(1.-spline/sfunct), abs(1.-spline/syield)) delta = abs(1. - spline / sfunct) if sfunct > 0 else 0 syield = spline if interPar: #jmean = gmean.Eval(m) #jsigma = gsigma.Eval(m) #jalpha1 = galpha1.Eval(m) #jslope1 = gslope1.Eval(m) #jalpha2 = galpha2.Eval(m) #jslope2 = gslope2.Eval(m) jmean = gmean.Eval(m, 0, "S") jsigma = gsigma.Eval(m, 0, "S") jalpha1 = galpha1.Eval(m, 0, "S") jslope1 = gslope1.Eval(m, 0, "S") jalpha2 = galpha2.Eval(m, 0, "S") jslope2 = gslope2.Eval(m, 0, "S") else: jmean = fmean.GetParameter( 0) + fmean.GetParameter(1) * m + fmean.GetParameter(2) * m * m jsigma = fsigma.GetParameter(0) + fsigma.GetParameter( 1) * m + fsigma.GetParameter(2) * m * m jalpha1 = falpha1.GetParameter(0) + falpha1.GetParameter( 1) * m + falpha1.GetParameter(2) * m * m jslope1 = fslope1.GetParameter(0) + fslope1.GetParameter( 1) * m + fslope1.GetParameter(2) * m * m jalpha2 = falpha2.GetParameter(0) + falpha2.GetParameter( 1) * m + falpha2.GetParameter(2) * m * m jslope2 = fslope2.GetParameter(0) + fslope2.GetParameter( 1) * m + fslope2.GetParameter(2) * m * m inorm.SetPoint(inorm.GetN(), m, syield) signalNorm[m].setVal(max(0., syield)) imean.SetPoint(imean.GetN(), m, jmean) if jmean > 0: vmean[m].setVal(jmean) isigma.SetPoint(isigma.GetN(), m, jsigma) if jsigma > 0: vsigma[m].setVal(jsigma) ialpha1.SetPoint(ialpha1.GetN(), m, jalpha1) if not jalpha1 == 0: valpha1[m].setVal(jalpha1) islope1.SetPoint(islope1.GetN(), m, jslope1) if jslope1 > 0: vslope1[m].setVal(jslope1) ialpha2.SetPoint(ialpha2.GetN(), m, jalpha2) if not jalpha2 == 0: valpha2[m].setVal(jalpha2) islope2.SetPoint(islope2.GetN(), m, jslope2) if jslope2 > 0: vslope2[m].setVal(jslope2) #### newly introduced, not yet sure if helpful: vmean[m].removeError() vsigma[m].removeError() valpha1[m].removeError() valpha2[m].removeError() vslope1[m].removeError() vslope2[m].removeError() #signalNorm[m].setConstant(False) ## newly put here to ensure it's freely floating in the combine fit #c1 = TCanvas("c1", "Crystal Ball", 1200, 1200) #if not isAH else 1200 #c1.Divide(2, 3) c1 = TCanvas("c1", "Crystal Ball", 1800, 800) c1.Divide(3, 2) c1.cd(1) gmean.SetMinimum(0.) gmean.Draw("APL") imean.Draw("P, SAME") drawRegion(category) drawCMS(-1, "Simulation Preliminary", year=YEAR) ## new FIXME c1.cd(2) gsigma.SetMinimum(0.) gsigma.Draw("APL") isigma.Draw("P, SAME") drawRegion(category) drawCMS(-1, "Simulation Preliminary", year=YEAR) ## new FIXME c1.cd(3) galpha1.Draw("APL") ialpha1.Draw("P, SAME") drawRegion(category) drawCMS(-1, "Simulation Preliminary", year=YEAR) ## new FIXME galpha1.GetYaxis().SetRangeUser(0., 1.1) #adjusted upper limit from 5 to 2 c1.cd(4) gslope1.Draw("APL") islope1.Draw("P, SAME") drawRegion(category) drawCMS(-1, "Simulation Preliminary", year=YEAR) ## new FIXME gslope1.GetYaxis().SetRangeUser(0., 150.) #adjusted upper limit from 125 to 60 if True: #isAH: c1.cd(5) galpha2.Draw("APL") ialpha2.Draw("P, SAME") drawRegion(category) drawCMS(-1, "Simulation Preliminary", year=YEAR) ## new FIXME galpha2.GetYaxis().SetRangeUser(0., 2.) c1.cd(6) gslope2.Draw("APL") islope2.Draw("P, SAME") drawRegion(category) drawCMS(-1, "Simulation Preliminary", year=YEAR) ## new FIXME gslope2.GetYaxis().SetRangeUser(0., 20.) c1.Print(PLOTDIR + "MC_signal_" + YEAR + "/" + stype + "_" + category + "_SignalShape.pdf") c1.Print(PLOTDIR + "MC_signal_" + YEAR + "/" + stype + "_" + category + "_SignalShape.png") c2 = TCanvas("c2", "Signal Efficiency", 800, 600) c2.cd(1) gnorm.SetMarkerColor(cColor) gnorm.SetMarkerStyle(20) gnorm.SetLineColor(cColor) gnorm.SetLineWidth(2) gnorm.Draw("APL") inorm.Draw("P, SAME") gnorm.GetXaxis().SetRangeUser(genPoints[0] - 100, genPoints[-1] + 100) gnorm.GetYaxis().SetRangeUser(0., gnorm.GetMaximum() * 1.25) drawCMS(-1, "Simulation Preliminary", year=YEAR) #drawCMS(-1, "Work in Progress", year=YEAR, suppressCMS=True) #drawCMS(-1, "", year=YEAR, suppressCMS=True) drawAnalysis(category) drawRegion(category) c2.Print(PLOTDIR + "MC_signal_" + YEAR + "/" + stype + "_" + category + "_SignalNorm.pdf") c2.Print(PLOTDIR + "MC_signal_" + YEAR + "/" + stype + "_" + category + "_SignalNorm.png") #*******************************************************# # # # Generate workspace # # # #*******************************************************# # create workspace w = RooWorkspace("Zprime_" + YEAR, "workspace") for m in massPoints: getattr(w, "import")(signal[m], RooFit.Rename(signal[m].GetName())) getattr(w, "import")(signalNorm[m], RooFit.Rename(signalNorm[m].GetName())) getattr(w, "import")(signalXS[m], RooFit.Rename(signalXS[m].GetName())) w.writeToFile(WORKDIR + "MC_signal_%s_%s.root" % (YEAR, category), True) print "Workspace", WORKDIR + "MC_signal_%s_%s.root" % ( YEAR, category), "saved successfully"
def pdf_logPt2_prelim(): #PDF fit to log_10(pT^2) for preliminary figure #tree_in = tree_incoh tree_in = tree #ptbin = 0.04 ptbin = 0.12 ptmin = -5. ptmax = 1. mmin = 2.8 mmax = 3.2 #fitran = [-5., 1.] fitran = [-0.9, 0.1] binned = False #gamma-gamma 131 evt for pT<0.18 #input data pT = RooRealVar("jRecPt", "pT", 0, 10) m = RooRealVar("jRecM", "mass", 0, 10) dataIN = RooDataSet("data", "data", tree_in, RooArgSet(pT, m)) strsel = "jRecM>{0:.3f} && jRecM<{1:.3f}".format(mmin, mmax) data = dataIN.reduce(strsel) #x is RooRealVar for log(Pt2) draw = "TMath::Log10(jRecPt*jRecPt)" draw_func = RooFormulaVar( "x", "Dielectron log_{10}( #it{p}_{T}^{2} ) ((GeV/c)^{2})", draw, RooArgList(pT)) x = data.addColumn(draw_func) x.setRange("fitran", fitran[0], fitran[1]) #binned data nbins, ptmax = ut.get_nbins(ptbin, ptmin, ptmax) hPt = TH1D("hPt", "hPt", nbins, ptmin, ptmax) hPtCoh = ut.prepare_TH1D("hPtCoh", ptbin, ptmin, ptmax) hPtCoh.SetLineWidth(2) #fill in binned data tree_in.Draw(draw + " >> hPt", strsel) tree_coh.Draw(draw + " >> hPtCoh", strsel) dataH = RooDataHist("dataH", "dataH", RooArgList(x), hPt) #range for plot x.setMin(ptmin) x.setMax(ptmax) x.setRange("plotran", ptmin, ptmax) #create the pdf b = RooRealVar("b", "b", 5., 0., 10.) pdf_func = "log(10.)*pow(10.,x)*exp(-b*pow(10.,x))" pdf_logPt2 = RooGenericPdf("pdf_logPt2", pdf_func, RooArgList(x, b)) #make the fit if binned == True: r1 = pdf_logPt2.fitTo(dataH, rf.Range("fitran"), rf.Save()) else: r1 = pdf_logPt2.fitTo(data, rf.Range("fitran"), rf.Save()) #calculate norm to number of events xset = RooArgSet(x) ipdf = pdf_logPt2.createIntegral(xset, rf.NormSet(xset), rf.Range("fitran")) print "PDF integral:", ipdf.getVal() if binned == True: nevt = tree_incoh.Draw( "", strsel + " && " + draw + ">{0:.3f}".format(fitran[0]) + " && " + draw + "<{1:.3f}".format(fitran[0], fitran[1])) else: nevt = data.sumEntries("x", "fitran") print "nevt:", nevt pdf_logPt2.setNormRange("fitran") print "PDF norm:", pdf_logPt2.getNorm(RooArgSet(x)) #a = nevt/ipdf.getVal() a = nevt / pdf_logPt2.getNorm(RooArgSet(x)) print "a =", a #gamma-gamma contribution hPtGG = ut.prepare_TH1D("hPtGG", ptbin, ptmin, ptmax) tree_gg.Draw(draw + " >> hPtGG", strsel) #ut.norm_to_data(hPtGG, hPt, rt.kGreen, -5., -2.9) ut.norm_to_num(hPtGG, 131., rt.kGreen + 1) print "Int GG:", hPtGG.Integral() #sum of all contributions hSum = ut.prepare_TH1D("hSum", ptbin, ptmin, ptmax) hSum.SetLineWidth(3) #add ggel to the sum hSum.Add(hPtGG) #add incoherent contribution func_logPt2 = TF1("pdf_logPt2", "[0]*log(10.)*pow(10.,x)*exp(-[1]*pow(10.,x))", -10., 10.) func_logPt2.SetParameters(a, b.getVal()) hInc = ut.prepare_TH1D("hInc", ptbin, ptmin, ptmax) ut.fill_h1_tf(hInc, func_logPt2) hSum.Add(hInc) #add coherent contribution ut.norm_to_data(hPtCoh, hPt, rt.kBlue, -5., -2.2) # norm for coh hSum.Add(hPtCoh) #set to draw as a lines ut.line_h1(hSum, rt.kBlack) #create canvas frame can = ut.box_canvas() ut.set_margin_lbtr(gPad, 0.11, 0.1, 0.01, 0.01) frame = x.frame(rf.Bins(nbins), rf.Title("")) frame.SetTitle("") frame.SetYTitle("J/#psi candidates / ({0:.3f}".format(ptbin) + " (GeV/c)^{2})") frame.GetXaxis().SetTitleOffset(1.2) frame.GetYaxis().SetTitleOffset(1.6) print "Int data:", hPt.Integral() #plot the data if binned == True: dataH.plotOn(frame, rf.Name("data")) else: data.plotOn(frame, rf.Name("data")) pdf_logPt2.plotOn(frame, rf.Range("fitran"), rf.LineColor(rt.kRed), rf.Name("pdf_logPt2")) pdf_logPt2.plotOn(frame, rf.Range("plotran"), rf.LineColor(rt.kRed), rf.Name("pdf_logPt2_full"), rf.LineStyle(rt.kDashed)) frame.Draw() leg = ut.prepare_leg(0.61, 0.77, 0.16, 0.19, 0.03) #ut.add_leg_mass(leg, mmin, mmax) hx = ut.prepare_TH1D("hx", 1, 0, 1) hx.Draw("same") ln = ut.col_lin(rt.kRed, 2) leg.AddEntry(hx, "Data", "p") leg.AddEntry(hSum, "Sum", "l") leg.AddEntry(hPtCoh, "Coherent J/#psi", "l") leg.AddEntry(ln, "Incoherent parametrization", "l") leg.AddEntry(hPtGG, "#gamma#gamma#rightarrow e^{+}e^{-}", "l") #leg.AddEntry(ln, "ln(10)*#it{A}*10^{log_{10}#it{p}_{T}^{2}}exp(-#it{b}10^{log_{10}#it{p}_{T}^{2}})", "l") leg.Draw("same") l0 = ut.cut_line(fitran[0], 0.9, frame) l1 = ut.cut_line(fitran[1], 0.9, frame) #l0.Draw() #l1.Draw() pleg = ut.prepare_leg(0.12, 0.75, 0.14, 0.22, 0.03) pleg.AddEntry(None, "#bf{|#kern[0.3]{#it{y}}| < 1}", "") ut.add_leg_mass(pleg, mmin, mmax) pleg.AddEntry(None, "STAR Preliminary", "") pleg.AddEntry(None, "AuAu@200 GeV", "") pleg.AddEntry(None, "UPC sample", "") pleg.Draw("same") desc = pdesc(frame, 0.14, 0.9, 0.057) desc.set_text_size(0.03) desc.itemD("#chi^{2}/ndf", frame.chiSquare("pdf_logPt2", "data", 2), -1, rt.kRed) desc.itemD("#it{A}", a, -1, rt.kRed) desc.itemR("#it{b}", b, rt.kRed) #desc.draw() #put the sum hSum.Draw("same") frame.Draw("same") #put gamma-gamma and coherent J/psi hPtGG.Draw("same") hPtCoh.Draw("same") #ut.invert_col(rt.gPad) can.SaveAs("01fig.pdf")
#h_background_m3Hist.Add(h_wjets_m3Hist) h_background_m3Hist.Add(h_singletop_t_m3HistS) h_background_m3Hist.Add(h_zjets_m3HistS) rttbar = n_ttbar / (n_ttbar + n_background) #+n_qcd) x = RooRealVar("x", "x", h_zjets_m3Hist.GetXaxis().GetXmin(), h_zjets_m3Hist.GetXaxis().GetXmax()) k2 = RooRealVar("k2", "normalization factor", 1.0, 0.5, 1.5) k1 = RooRealVar("k1", "k1", rttbar, 0., 0.5) #k2 =RooRealVar("k2","k2",rQCD,0.0,0.2); nttbar = RooRealVar("nttbar", "number of ttbar events", n_ttbar, n_ttbar, n_ttbar) k1nttbar = RooFormulaVar("k1nttbar", "number of ttbar events after fitting", "k*nttbar", RooArgList(k1, nttbar)) n_mc = n_ttbar + n_background nmc = RooRealVar("nmc", "number of mc events", n_mc, n_mc, n_mc) k2nmc = RooFormulaVar("k2nmc", "number of mc events", " ", RooArgList(k2, nmc)) #RooRealVar nbackground("nbackground","number of background events", n_background , n_background, n_background); #RooFormulaVar k2background("k2background","number of background events after fitting","k2*nbackground",RooArgList(k2,nbackground) ); nqcd = RooRealVar("nqcd", "number of qcd events", n_qcd, n_qcd, n_qcd) #k2nqcd = RooFormulaVar("k2nqcd","number of qcd events"," ",RooArgList(k2,nqcd)) data = RooDataHist("data", "data set with (x)", RooArgList(x), h_data_m3HistS) ttbar = RooDataHist("ttbar", "data set with (x)", RooArgList(x), h_ttbar_m3HistS) background = RooDataHist("background", "data set with (x)", RooArgList(x), h_background_m3Hist)
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
if i < n_sig_pdf - 1 : fracs.append(RooRealVar("frac_{}".format(i), "frac_{}".format(i), p_fracFits[i], 0, 1)) fracs[i].setConstant(True) for i in range(n_regions) : region = regions[i] #Setting up parameters to allow only single shift (means) and scale (sigmas) shifts.append(RooRealVar("shift_"+region, "shift_"+region, 0., -1, 1)) shifts[i].setError(0.01) scales.append(RooRealVar("scale_"+region, "scale_"+region, 1., 0.001, 5)) scales[i].setError(0.01) for j in range(n_sig_pdf) : shiftedMeans[i].append(RooFormulaVar("shifted_mean_{}_".format(j)+region, "mean_{}+shift_".format(j)+region, RooArgList(means[j], shifts[i]))) scaledWidths[i].append(RooFormulaVar("scaled_width_{}_".format(j)+region, "width_{}*scale_".format(j)+region, RooArgList(widths[j], scales[i]))) sig[i].append(RooGaussian("sig_{}_".format(j)+region, "sig_{}_".format(j)+region, deltam, shiftedMeans[i][j], scaledWidths[i][j])) #Adding components to form total signal pdf region_sig_pdfs.append(RooAddPdf("signal_pdf_"+region, "signal_pdf_"+region, RooArgList(*sig[i]), RooArgList(*fracs))) bg_fracs.append(RooRealVar("bg_frac_"+region, "bg_frac_"+region, 0.107, 0, 1)) region_total_pdfs.append(RooAddPdf("total_pdf_"+region, "total_pdf_"+region, RooArgList(region_sig_pdfs[i], bg_pdf), RooArgList(bg_fracs[i]))) #Adding to simultaneous pdf total_pdf.addPdf(region_total_pdfs[i], region) #Simultaneously fit all mass regions - bg free and signal with shift/scale only total_pdf.fitTo(datahist)
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)
if ratiofn == 'exponential': # ratio parameters: only for DsK rturnon = RooRealVar('rturnon', 'rturnon', 6.4, 0.5, 10.0) roffset = RooRealVar('roffset', 'roffset', 0.0, -0.5, 0.1) rbeta = RooRealVar('rbeta', 'rbeta', 0.01, -0.05, 0.05) # rbeta = RooRealConstant.value(0.0) ratio = AcceptanceRatio('ratio', 'Acceptance ratio', time, rturnon, roffset, rbeta) varlist += [rturnon, roffset, rbeta] elif ratiofn == 'quadratic': rquad = RooRealVar('rquad', 'rquad', 1.0, -10.0, 10.0) rlinear = RooRealVar('rlinear', 'rlinear', 1.0, -10.0, 10.0) # roffset = RooRealVar('roffset', 'roffset', 1.0, 0.0, 2.0) roffset = RooRealConstant.value(0.0) ratio = RooFormulaVar( 'ratio', '@2*(@0-@1)**2 + @3*(@0-@1) - @4', RooArgList(time, dsk_time_avg, rquad, rlinear, roffset)) varlist += [rquad, rlinear, roffset] elif ratiofn == 'linear': rslope = RooRealVar('rslope', 'rslope', 0.01, -0.2, 0.2) roffset = RooRealConstant.value(0.9) ratio = RooFormulaVar('ratio', '@2*(@0-@1) - @3', RooArgList(time, dsk_time_avg, rslope, roffset)) varlist += [rslope, roffset] elif ratiofn == 'flat': ratio = RooRealVar('ratio', 'ratio', 1.0, 0.0, 2.0) varlist += [ratio] else: sys.exit('Unknown acceptance type. Aborting') dsk_acceptance = RooProduct('dsk_acceptance', 'DsK Acceptance with ratio', RooArgList(dspi_acceptance, ratio))
def fitChicSpectrum(dataset, binname): """ Fit chic spectrum""" x = RooRealVar('Qvalue', 'Q', 9.7, 10.1) x.setBins(80) mean_1 = RooRealVar("mean_1", "mean ChiB1", 9.892, 9, 10, "GeV") sigma_1 = RooRealVar("sigma_1", "sigma ChiB1", 0.0058, 'GeV') a1_1 = RooRealVar('#alpha1_1', '#alpha1_1', 0.748) n1_1 = RooRealVar('n1_1', 'n1_1', 2.8) a2_1 = RooRealVar('#alpha2_1', '#alpha2_1', 1.739) n2_1 = RooRealVar('n2_1', 'n2_1', 3.0) deltam = RooRealVar('deltam', 'deltam', 0.01943) mean_2 = RooFormulaVar("mean_2", "@0+@1", RooArgList(mean_1, deltam)) sigma_2 = RooRealVar("sigma_2", "sigma ChiB2", 0.0059, 'GeV') a1_2 = RooRealVar('#alpha1_2', '#alpha1_2', 0.738) n1_2 = RooRealVar('n1_2', 'n1_2', 2.8) a2_2 = RooRealVar('#alpha2_2', '#alpha2_2', 1.699) n2_2 = RooRealVar('n2_2', 'n2_2', 3.0) parameters = RooArgSet() parameters.add(RooArgSet(sigma_1, sigma_2)) parameters = RooArgSet(a1_1, a2_1, n1_1, n2_1) parameters.add(RooArgSet(a1_2, a2_2, n1_2, n2_2)) chib1_pdf = My_double_CB('chib1', 'chib1', x, mean_1, sigma_1, a1_1, n1_1, a2_1, n2_1) chib2_pdf = My_double_CB('chib2', 'chib2', x, mean_2, sigma_2, a1_2, n1_2, a2_2, n2_2) #background q01S_Start = 9.5 alpha = RooRealVar("#alpha", "#alpha", 1.5, -1, 3.5) #0.2 anziche' 1 beta = RooRealVar("#beta", "#beta", -2.5, -7., 0.) q0 = RooRealVar("q0", "q0", q01S_Start) #,9.5,9.7) delta = RooFormulaVar("delta", "TMath::Abs(@0-@1)", RooArgList(x, q0)) b1 = RooFormulaVar("b1", "@0*(@1-@2)", RooArgList(beta, x, q0)) signum1 = RooFormulaVar("signum1", "( TMath::Sign( -1.,@0-@1 )+1 )/2.", RooArgList(x, q0)) background = RooGenericPdf("background", "Background", "signum1*pow(delta,#alpha)*exp(b1)", RooArgList(signum1, delta, alpha, b1)) parameters.add(RooArgSet(alpha, beta, q0)) #together chibs = RooArgList(chib1_pdf, chib2_pdf, background) n_chib = RooRealVar("n_chib", "n_chib", 2075, 0, 100000) ratio_21 = RooRealVar("ratio_21", "ratio_21", 0.5, 0, 1) n_chib1 = RooFormulaVar("n_chib1", "@0/(1+@1)", RooArgList(n_chib, ratio_21)) n_chib2 = RooFormulaVar("n_chib2", "@0/(1+1/@1)", RooArgList(n_chib, ratio_21)) n_background = RooRealVar('n_background', 'n_background', 4550, 0, 50000) ratio_list = RooArgList(n_chib1, n_chib2, n_background) modelPdf = RooAddPdf('ModelPdf', 'ModelPdf', chibs, ratio_list) frame = x.frame(RooFit.Title('m')) range = x.setRange('range', 9.7, 10.1) result = modelPdf.fitTo(dataset, RooFit.Save(), RooFit.Range('range')) dataset.plotOn(frame, RooFit.MarkerSize(0.7)) modelPdf.plotOn(frame, RooFit.LineWidth(2)) #plotting canvas = TCanvas('fit', "", 1400, 700) canvas.Divide(1) canvas.cd(1) gPad.SetRightMargin(0.3) gPad.SetFillColor(10) modelPdf.paramOn(frame, RooFit.Layout(0.725, 0.9875, 0.9)) frame.Draw() canvas.SaveAs('out-' + binname + '.png')
def alpha(channel): nElec = channel.count('e') nMuon = channel.count('m') nLept = nElec + nMuon nBtag = channel.count('b') # Channel-dependent settings # Background function. Semi-working options are: EXP, EXP2, EXPN, EXPTAIL if nLept == 0: treeName = 'SR' signName = 'XZh' colorVjet = sample['DYJetsToNuNu']['linecolor'] triName = "HLT_PFMET" leptCut = "0==0" topVeto = selection["TopVetocut"] massVar = "X_cmass" binFact = 1 #fitFunc = "EXP" #fitFunc = "EXP2" #fitFunc = "EXPN" #fitFunc = "EXPTAIL" fitFunc = "EXPN" if nBtag < 2 else "EXP" fitAltFunc = "EXPTAIL" if nBtag < 2 else "EXPTAIL" fitFuncVjet = "ERFEXP" if nBtag < 2 else "ERFEXP" fitFuncVV = "EXPGAUS" fitFuncTop = "GAUS2" elif nLept == 1: treeName = 'WCR' signName = 'XWh' colorVjet = sample['WJetsToLNu']['linecolor'] triName = "HLT_Ele" if nElec > 0 else "HLT_Mu" leptCut = "isWtoEN" if nElec > 0 else "isWtoMN" topVeto = selection["TopVetocut"] massVar = "X_mass" binFact = 2 if nElec > 0: fitFunc = "EXP" if nBtag < 2 else "EXP" fitAltFunc = "EXPTAIL" if nBtag < 2 else "EXPTAIL" else: fitFunc = "EXPTAIL" if nBtag < 2 else "EXP" fitAltFunc = "EXPN" if nBtag < 2 else "EXPTAIL" fitFuncVjet = "ERFEXP" if nBtag < 2 else "ERFEXP" fitFuncVV = "EXPGAUS" fitFuncTop = "GAUS3" if nBtag < 2 else "GAUS2" else: treeName = 'XZh' signName = 'XZh' colorVjet = sample['DYJetsToLL']['linecolor'] triName = "HLT_Ele" if nElec > 0 else "HLT_Mu" leptCut = "isZtoEE" if nElec > 0 else "isZtoMM" topVeto = "0==0" massVar = "X_mass" binFact = 5 if nElec > 0: fitFunc = "EXP" if nBtag < 2 else "EXP" fitAltFunc = "POW" if nBtag < 2 else "POW" else: fitFunc = "EXP" if nBtag < 2 else "EXP" fitAltFunc = "POW" if nBtag < 2 else "POW" fitFuncVjet = "ERFEXP" if nBtag < 2 else "EXP" fitFuncVV = "EXPGAUS2" fitFuncTop = "GAUS" btagCut = selection["2Btag"] if nBtag == 2 else selection["1Btag"] print "--- Channel", channel, "---" print " number of electrons:", nElec, " muons:", nMuon, " b-tags:", nBtag print " read tree:", treeName, "and trigger:", triName if ALTERNATIVE: print " using ALTERNATIVE fit functions" print "-"*11*2 # Silent RooFit RooMsgService.instance().setGlobalKillBelow(RooFit.FATAL) #*******************************************************# # # # Variables and selections # # # #*******************************************************# # Define all the variables from the trees that will be used in the cuts and fits # this steps actually perform a "projection" of the entire tree on the variables in thei ranges, so be careful once setting the limits X_mass = RooRealVar( massVar, "m_{X}" if nLept > 0 else "m_{T}^{X}", XBINMIN, XBINMAX, "GeV") J_mass = RooRealVar( "fatjet1_prunedMassCorr", "corrected pruned mass", HBINMIN, HBINMAX, "GeV") CSV1 = RooRealVar( "fatjet1_CSVR1", "", -1.e99, 1.e4 ) CSV2 = RooRealVar( "fatjet1_CSVR2", "", -1.e99, 1.e4 ) nBtag = RooRealVar( "fatjet1_nBtag", "", 0., 4 ) CSVTop = RooRealVar( "bjet1_CSVR", "", -1.e99, 1.e4 ) isZtoEE = RooRealVar("isZtoEE", "", 0., 2 ) isZtoMM = RooRealVar("isZtoMM", "", 0., 2 ) isWtoEN = RooRealVar("isWtoEN", "", 0., 2 ) isWtoMN = RooRealVar("isWtoMN", "", 0., 2 ) weight = RooRealVar( "eventWeightLumi", "", -1.e9, 1. ) # Define the RooArgSet which will include all the variables defined before # there is a maximum of 9 variables in the declaration, so the others need to be added with 'add' variables = RooArgSet(X_mass, J_mass, CSV1, CSV2, nBtag, CSVTop) variables.add(RooArgSet(isZtoEE, isZtoMM, isWtoEN, isWtoMN, weight)) # Define the ranges in fatJetMass - these will be used to define SB and SR J_mass.setRange("LSBrange", LOWMIN, LOWMAX) J_mass.setRange("HSBrange", HIGMIN, HIGMAX) J_mass.setRange("VRrange", LOWMAX, SIGMIN) J_mass.setRange("SRrange", SIGMIN, SIGMAX) J_mass.setBins(54) # Define the selection for the various categories (base + SR / LSBcut / HSBcut ) baseCut = leptCut + " && " + btagCut + "&&" + topVeto massCut = massVar + ">%d" % XBINMIN baseCut += " && " + massCut # Cuts SRcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), SIGMIN, J_mass.GetName(), SIGMAX) LSBcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), LOWMIN, J_mass.GetName(), LOWMAX) HSBcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), HIGMIN, J_mass.GetName(), HIGMAX) SBcut = baseCut + " && ((%s>%d && %s<%d) || (%s>%d && %s<%d))" % (J_mass.GetName(), LOWMIN, J_mass.GetName(), LOWMAX, J_mass.GetName(), HIGMIN, J_mass.GetName(), HIGMAX) VRcut = baseCut + " && %s>%d && %s<%d" % (J_mass.GetName(), LOWMAX, J_mass.GetName(), SIGMIN) # Binning binsJmass = RooBinning(HBINMIN, HBINMAX) binsJmass.addUniform(HBINS, HBINMIN, HBINMAX) binsXmass = RooBinning(XBINMIN, XBINMAX) binsXmass.addUniform(binFact*XBINS, XBINMIN, XBINMAX) #*******************************************************# # # # Input files # # # #*******************************************************# # Import the files using TChains (separately for the bkg "classes" that we want to describe: here DY and VV+ST+TT) treeData = TChain(treeName) treeMC = TChain(treeName) treeVjet = TChain(treeName) treeVV = TChain(treeName) treeTop = TChain(treeName) # treeSign = {} # nevtSign = {} # Read data pd = getPrimaryDataset(triName) if len(pd)==0: raw_input("Warning: Primary Dataset not recognized, continue?") for i, s in enumerate(pd): treeData.Add(NTUPLEDIR + s + ".root") # Read V+jets backgrounds for i, s in enumerate(["WJetsToLNu_HT", "DYJetsToNuNu_HT", "DYJetsToLL_HT"]): for j, ss in enumerate(sample[s]['files']): treeVjet.Add(NTUPLEDIR + ss + ".root") # Read VV backgrounds for i, s in enumerate(["VV"]): for j, ss in enumerate(sample[s]['files']): treeVV.Add(NTUPLEDIR + ss + ".root") # Read Top backgrounds for i, s in enumerate(["ST", "TTbar"]): for j, ss in enumerate(sample[s]['files']): treeTop.Add(NTUPLEDIR + ss + ".root") # Sum all background MC treeMC.Add(treeVjet) treeMC.Add(treeVV) treeMC.Add(treeTop) # create a dataset to host data in sideband (using this dataset we are automatically blind in the SR!) setDataSB = RooDataSet("setDataSB", "setDataSB", variables, RooFit.Cut(SBcut), RooFit.WeightVar(weight), RooFit.Import(treeData)) setDataLSB = RooDataSet("setDataLSB", "setDataLSB", variables, RooFit.Import(setDataSB), RooFit.Cut(LSBcut), RooFit.WeightVar(weight)) setDataHSB = RooDataSet("setDataHSB", "setDataHSB", variables, RooFit.Import(setDataSB), RooFit.Cut(HSBcut), RooFit.WeightVar(weight)) # Observed data (WARNING, BLIND!) setDataSR = RooDataSet("setDataSR", "setDataSR", variables, RooFit.Cut(SRcut), RooFit.WeightVar(weight), RooFit.Import(treeData)) setDataVR = RooDataSet("setDataVR", "setDataVR", variables, RooFit.Cut(VRcut), RooFit.WeightVar(weight), RooFit.Import(treeData)) # Observed in the VV mass, just for plotting purposes # same for the bkg datasets from MC, where we just apply the base selections (not blind) setVjet = RooDataSet("setVjet", "setVjet", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeVjet)) setVjetSB = RooDataSet("setVjetSB", "setVjetSB", variables, RooFit.Import(setVjet), RooFit.Cut(SBcut), RooFit.WeightVar(weight)) setVjetSR = RooDataSet("setVjetSR", "setVjetSR", variables, RooFit.Import(setVjet), RooFit.Cut(SRcut), RooFit.WeightVar(weight)) setVV = RooDataSet("setVV", "setVV", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeVV)) setVVSB = RooDataSet("setVVSB", "setVVSB", variables, RooFit.Import(setVV), RooFit.Cut(SBcut), RooFit.WeightVar(weight)) setVVSR = RooDataSet("setVVSR", "setVVSR", variables, RooFit.Import(setVV), RooFit.Cut(SRcut), RooFit.WeightVar(weight)) setTop = RooDataSet("setTop", "setTop", variables, RooFit.Cut(baseCut), RooFit.WeightVar(weight), RooFit.Import(treeTop)) setTopSB = RooDataSet("setTopSB", "setTopSB", variables, RooFit.Import(setTop), RooFit.Cut(SBcut), RooFit.WeightVar(weight)) setTopSR = RooDataSet("setTopSR", "setTopSR", variables, RooFit.Import(setTop), RooFit.Cut(SRcut), RooFit.WeightVar(weight)) print " Data events SB: %.2f" % setDataSB.sumEntries() print " V+jets entries: %.2f" % setVjet.sumEntries() print " VV, VH entries: %.2f" % setVV.sumEntries() print " Top,ST entries: %.2f" % setTop.sumEntries() # the relative normalization of the varius bkg is taken from MC by counting all the events in the full fatJetMass range #coef = RooRealVar("coef", "coef", setVV.sumEntries()/setVjet.sumEntries(),0.,1.) coef_VV_Vjet = RooRealVar("coef2_1", "coef2_1", setVV.sumEntries()/setVjet.sumEntries(), 0., 1.) coef_Top_VVVjet = RooRealVar("coef3_21", "coef3_21", setTop.sumEntries()/(setVjet.sumEntries()+setVV.sumEntries()),0.,1.); coef_VV_Vjet.setConstant(True) coef_Top_VVVjet.setConstant(True) # Define entries entryVjet = RooRealVar("entryVjets", "V+jets normalization", setVjet.sumEntries(), 0., 1.e6) entryVV = RooRealVar("entryVV", "VV normalization", setVV.sumEntries(), 0., 1.e6) entryTop = RooRealVar("entryTop", "Top normalization", setTop.sumEntries(), 0., 1.e6) entrySB = RooRealVar("entrySB", "Data SB normalization", setDataSB.sumEntries(SBcut), 0., 1.e6) entrySB.setError(math.sqrt(entrySB.getVal())) entryLSB = RooRealVar("entryLSB", "Data LSB normalization", setDataSB.sumEntries(LSBcut), 0., 1.e6) entryLSB.setError(math.sqrt(entryLSB.getVal())) entryHSB = RooRealVar("entryHSB", "Data HSB normalization", setDataSB.sumEntries(HSBcut), 0., 1.e6) entryHSB.setError(math.sqrt(entryHSB.getVal())) #*******************************************************# # # # NORMALIZATION # # # #*******************************************************# # set reasonable ranges for J_mass and X_mass # these are used in the fit in order to avoid ROOFIT to look in regions very far away from where we are fitting J_mass.setRange("h_reasonable_range", LOWMIN, HIGMAX) X_mass.setRange("X_reasonable_range", XBINMIN, XBINMAX) # Set RooArgSets once for all, see https://root.cern.ch/phpBB3/viewtopic.php?t=11758 jetMassArg = RooArgSet(J_mass) #*******************************************************# # # # V+jets normalization # # # #*******************************************************# # Variables for V+jets constVjet = RooRealVar("constVjet", "slope of the exp", -0.020, -1., 0.) offsetVjet = RooRealVar("offsetVjet", "offset of the erf", 30., -50., 200.) widthVjet = RooRealVar("widthVjet", "width of the erf", 100., 1., 200.) offsetVjet.setConstant(True) a0Vjet = RooRealVar("a0Vjet", "width of the erf", -0.1, -5, 0) a1Vjet = RooRealVar("a1Vjet", "width of the erf", 0.6, 0, 5) a2Vjet = RooRealVar("a2Vjet", "width of the erf", -0.1, -1, 1) # Define V+jets model if fitFuncVjet == "ERFEXP": modelVjet = RooErfExpPdf("modelVjet", "error function for V+jets mass", J_mass, constVjet, offsetVjet, widthVjet) elif fitFuncVjet == "EXP": modelVjet = RooExponential("modelVjet", "exp for V+jets mass", J_mass, constVjet) elif fitFuncVjet == "POL": modelVjet = RooChebychev("modelVjet", "polynomial for V+jets mass", J_mass, RooArgList(a0Vjet, a1Vjet, a2Vjet)) elif fitFuncVjet == "POW": modelVjet = RooGenericPdf("modelVjet", "powerlaw for X mass", "@0^@1", RooArgList(J_mass, a0Vjet)) else: print " ERROR! Pdf", fitFuncVjet, "is not implemented for Vjets" exit() # fit to main bkg in MC (whole range) frVjet = modelVjet.fitTo(setVjet, RooFit.SumW2Error(True), RooFit.Range("h_reasonable_range"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.Save(1), RooFit.PrintLevel(1 if VERBOSE else -1)) # integrals and number of events iSBVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange,HSBrange")) iLSBVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange")) iHSBVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("HSBrange")) iSRVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange")) iVRVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("VRrange")) # Do not remove the following lines, integrals are computed here iALVjet = modelVjet.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg)) nSBVjet = iSBVjet.getVal()/iALVjet.getVal()*setVjet.sumEntries(SBcut) nLSBVjet = iLSBVjet.getVal()/iALVjet.getVal()*setVjet.sumEntries(LSBcut) nHSBVjet = iHSBVjet.getVal()/iALVjet.getVal()*setVjet.sumEntries(HSBcut) nSRVjet = iSRVjet.getVal()/iALVjet.getVal()*setVjet.sumEntries(SRcut) drawPlot("JetMass_Vjet", channel, J_mass, modelVjet, setVjet, binsJmass, frVjet) if VERBOSE: print "********** Fit result [JET MASS Vjets] *"+"*"*40, "\n", frVjet.Print(), "\n", "*"*80 #*******************************************************# # # # VV, VH normalization # # # #*******************************************************# # Variables for VV # Error function and exponential to model the bulk constVV = RooRealVar("constVV", "slope of the exp", -0.030, -0.1, 0.) offsetVV = RooRealVar("offsetVV", "offset of the erf", 90., 1., 300.) widthVV = RooRealVar("widthVV", "width of the erf", 50., 1., 100.) erfrVV = RooErfExpPdf("baseVV", "error function for VV jet mass", J_mass, constVV, offsetVV, widthVV) expoVV = RooExponential("baseVV", "error function for VV jet mass", J_mass, constVV) # gaussian for the V mass peak meanVV = RooRealVar("meanVV", "mean of the gaussian", 90., 60., 100.) sigmaVV = RooRealVar("sigmaVV", "sigma of the gaussian", 10., 6., 30.) fracVV = RooRealVar("fracVV", "fraction of gaussian wrt erfexp", 3.2e-1, 0., 1.) gausVV = RooGaussian("gausVV", "gaus for VV jet mass", J_mass, meanVV, sigmaVV) # gaussian for the H mass peak meanVH = RooRealVar("meanVH", "mean of the gaussian", 125., 100., 150.) sigmaVH = RooRealVar("sigmaVH", "sigma of the gaussian", 30., 5., 40.) fracVH = RooRealVar("fracVH", "fraction of gaussian wrt erfexp", 1.5e-2, 0., 1.) gausVH = RooGaussian("gausVH", "gaus for VH jet mass", J_mass, meanVH, sigmaVH) # Define VV model if fitFuncVV == "ERFEXPGAUS": modelVV = RooAddPdf("modelVV", "error function + gaus for VV jet mass", RooArgList(gausVV, erfrVV), RooArgList(fracVV)) elif fitFuncVV == "ERFEXPGAUS2": modelVV = RooAddPdf("modelVV", "error function + gaus + gaus for VV jet mass", RooArgList(gausVH, gausVV, erfrVV), RooArgList(fracVH, fracVV)) elif fitFuncVV == "EXPGAUS": modelVV = RooAddPdf("modelVV", "error function + gaus for VV jet mass", RooArgList(gausVV, expoVV), RooArgList(fracVV)) elif fitFuncVV == "EXPGAUS2": modelVV = RooAddPdf("modelVV", "error function + gaus + gaus for VV jet mass", RooArgList(gausVH, gausVV, expoVV), RooArgList(fracVH, fracVV)) else: print " ERROR! Pdf", fitFuncVV, "is not implemented for VV" exit() # fit to secondary bkg in MC (whole range) frVV = modelVV.fitTo(setVV, RooFit.SumW2Error(True), RooFit.Range("h_reasonable_range"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.Save(1), RooFit.PrintLevel(1 if VERBOSE else -1)) # integrals and number of events iSBVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange,HSBrange")) iLSBVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange")) iHSBVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("HSBrange")) iSRVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange")) iVRVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("VRrange")) # Do not remove the following lines, integrals are computed here iALVV = modelVV.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg)) nSBVV = iSBVV.getVal()/iALVV.getVal()*setVV.sumEntries(SBcut) nLSBVV = iLSBVV.getVal()/iALVV.getVal()*setVV.sumEntries(LSBcut) nHSBVV = iHSBVV.getVal()/iALVV.getVal()*setVV.sumEntries(HSBcut) nSRVV = iSRVV.getVal()/iALVV.getVal()*setVV.sumEntries(SRcut) rSBSRVV = nSRVV/nSBVV drawPlot("JetMass_VV", channel, J_mass, modelVV, setVV, binsJmass, frVV) if VERBOSE: print "********** Fit result [JET MASS VV] ****"+"*"*40, "\n", frVV.Print(), "\n", "*"*80 #*******************************************************# # # # Top, ST normalization # # # #*******************************************************# # Variables for Top # Error Function * Exponential to model the bulk constTop = RooRealVar("constTop", "slope of the exp", -0.030, -1., 0.) offsetTop = RooRealVar("offsetTop", "offset of the erf", 175.0, 50., 250.) widthTop = RooRealVar("widthTop", "width of the erf", 100.0, 1., 300.) gausTop = RooGaussian("baseTop", "gaus for Top jet mass", J_mass, offsetTop, widthTop) erfrTop = RooErfExpPdf("baseTop", "error function for Top jet mass", J_mass, constTop, offsetTop, widthTop) # gaussian for the W mass peak meanW = RooRealVar("meanW", "mean of the gaussian", 80., 70., 90.) sigmaW = RooRealVar("sigmaW", "sigma of the gaussian", 10., 2., 20.) fracW = RooRealVar("fracW", "fraction of gaussian wrt erfexp", 0.1, 0., 1.) gausW = RooGaussian("gausW", "gaus for W jet mass", J_mass, meanW, sigmaW) # gaussian for the Top mass peak meanT = RooRealVar("meanT", "mean of the gaussian", 175., 150., 200.) sigmaT = RooRealVar("sigmaT", "sigma of the gaussian", 12., 5., 50.) fracT = RooRealVar("fracT", "fraction of gaussian wrt erfexp", 0.1, 0., 1.) gausT = RooGaussian("gausT", "gaus for T jet mass", J_mass, meanT, sigmaT) # Define Top model if fitFuncTop == "ERFEXPGAUS2": modelTop = RooAddPdf("modelTop", "error function + gaus + gaus for Top jet mass", RooArgList(gausW, gausT, erfrTop), RooArgList(fracW, fracT)) elif fitFuncTop == "ERFEXPGAUS": modelTop = RooAddPdf("modelTop", "error function + gaus for Top jet mass", RooArgList(gausT, erfrTop), RooArgList(fracT)) elif fitFuncTop == "GAUS3": modelTop = RooAddPdf("modelTop", "gaus + gaus + gaus for Top jet mass", RooArgList(gausW, gausT, gausTop), RooArgList(fracW, fracT)) elif fitFuncTop == "GAUS2": modelTop = RooAddPdf("modelTop", "gaus + gaus for Top jet mass", RooArgList(gausT, gausTop), RooArgList(fracT)) elif fitFuncTop == "GAUS": modelTop = RooGaussian("modelTop", "gaus for Top jet mass", J_mass, offsetTop, widthTop) else: print " ERROR! Pdf", fitFuncTop, "is not implemented for Top" exit() # fit to secondary bkg in MC (whole range) frTop = modelTop.fitTo(setTop, RooFit.SumW2Error(True), RooFit.Range("h_reasonable_range"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.Save(1), RooFit.PrintLevel(1 if VERBOSE else -1)) # integrals and number of events iSBTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange,HSBrange")) iLSBTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange")) iHSBTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("HSBrange")) iSRTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange")) iVRTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("VRrange")) # Do not remove the following lines, integrals are computed here iALTop = modelTop.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg)) nSBTop = iSBTop.getVal()/iALTop.getVal()*setTop.sumEntries(SBcut) nLSBTop = iLSBTop.getVal()/iALTop.getVal()*setTop.sumEntries(LSBcut) nHSBTop = iHSBTop.getVal()/iALTop.getVal()*setTop.sumEntries(HSBcut) nSRTop = iSRTop.getVal()/iALTop.getVal()*setTop.sumEntries(SRcut) drawPlot("JetMass_Top", channel, J_mass, modelTop, setTop, binsJmass, frTop) if VERBOSE: print "********** Fit result [JET MASS TOP] ***"+"*"*40, "\n", frTop.Print(), "\n", "*"*80 #*******************************************************# # # # All bkg normalization # # # #*******************************************************# constVjet.setConstant(True) offsetVjet.setConstant(True) widthVjet.setConstant(True) a0Vjet.setConstant(True) a1Vjet.setConstant(True) a2Vjet.setConstant(True) constVV.setConstant(True) offsetVV.setConstant(True) widthVV.setConstant(True) meanVV.setConstant(True) sigmaVV.setConstant(True) fracVV.setConstant(True) meanVH.setConstant(True) sigmaVH.setConstant(True) fracVH.setConstant(True) constTop.setConstant(True) offsetTop.setConstant(True) widthTop.setConstant(True) meanW.setConstant(True) sigmaW.setConstant(True) fracW.setConstant(True) meanT.setConstant(True) sigmaT.setConstant(True) fracT.setConstant(True) # Final background model by adding the main+secondary pdfs (using 'coef': ratio of the secondary/main, from MC) model = RooAddPdf("model", "model", RooArgList(modelTop, modelVV, modelVjet), RooArgList(coef_Top_VVVjet, coef_VV_Vjet))#FIXME model.fixAddCoefRange("h_reasonable_range") # Extended fit model to data in SB # all the 3 sidebands (Low / High / the 2 combined) could be used # currently using the LOW+HIGH (the others are commented out) yieldLSB = RooRealVar("yieldLSB", "Lower SB normalization", 10, 0., 1.e6) yieldHSB = RooRealVar("yieldHSB", "Higher SB normalization", 10, 0., 1.e6) yieldSB = RooRealVar("yieldSB", "All SB normalization", 10, 0., 1.e6) #model_ext = RooExtendPdf("model_ext", "extended p.d.f", model, yieldLSB) #model_ext = RooExtendPdf("model_ext", "extended p.d.f", model, yieldHSB) model_ext = RooExtendPdf("model_ext", "extended p.d.f", model, yieldSB) #frMass = model_ext.fitTo(setDataSB, RooFit.ConditionalObservables(RooArgSet(J_mass)),RooFit.SumW2Error(True),RooFit.Extended(True),RooFit.Range("LSBrange"),RooFit.PrintLevel(-1)) #frMass = model_ext.fitTo(setDataSB, RooFit.ConditionalObservables(RooArgSet(J_mass)),RooFit.SumW2Error(True),RooFit.Extended(True),RooFit.Range("HSBrange"),RooFit.PrintLevel(-1)) #frMass = model_ext.fitTo(setDataSB, RooFit.ConditionalObservables(RooArgSet(J_mass)), RooFit.SumW2Error(True), RooFit.Extended(True), RooFit.Range("LSBrange,HSBrange"), RooFit.Strategy(2), RooFit.Minimizer("Minuit2"), RooFit.PrintLevel(1 if VERBOSE else -1)) #print "********** Fit result [JET MASS DATA] **"+"*"*40 #print frMass.Print() #print "*"*80 # Calculate integral of the model obtained from the fit to data (fraction of PDF that is within a given region) #nSB = model_ext.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange,HSBrange")) #nSB = model_ext.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("LSBrange")) #nSB = model_ext.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("HSBrange")) #nSR = model_ext.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("SRrange")) #nVR = model_ext.createIntegral(jetMassArg, RooFit.NormSet(jetMassArg), RooFit.Range("VRrange")) # scale the yieldSB from SB to SR using the ratio of the PDFs defined by the two integrals SRyield = RooFormulaVar("SRyield", "extrapolation to SR","(@0-@1*@3-@2*@4) * @5/@6 +@1*@7+@2*@8", RooArgList(entrySB, entryVV, entryTop, iSBVV, iSBTop, iSRVjet, iSBVjet, iSRVV, iSRTop)) VRyield = RooFormulaVar("VRyield", "extrapolation to VR","(@0-@1*@3-@2*@4) * @5/@6 +@1*@7+@2*@8", RooArgList(entrySB, entryVV, entryTop, iSBVV, iSBTop, iVRVjet, iSBVjet, iVRVV, iVRTop)) HSByield = RooFormulaVar("SRyield", "extrapolation to SR","(@0-@1*@3-@2*@4) * @5/@6 +@1*@7+@2*@8", RooArgList(entryLSB, entryVV, entryTop, iLSBVV, iLSBTop, iHSBVjet, iLSBVjet, iHSBVV, iHSBTop)) # RooFormulaVar SRyield("SRyield","extrapolation to SR","(@0/@1)*@2",RooArgList(*nSR,*nSB,yieldLowerSB)) # RooFormulaVar SRyield("SRyield","extrapolation to SR","(@0/@1)*@2",RooArgList(*nSR,*nSB,yieldHigherSB)) #SRyield = RooFormulaVar("SRyield", "extrapolation to SR","(@0/@1)*@2", RooArgList(nSR, nSB, entrySB)) bkgYield = SRyield.getVal() bkgYield_error = math.sqrt(SRyield.getPropagatedError(frVjet)**2 + SRyield.getPropagatedError(frVV)**2 + SRyield.getPropagatedError(frTop)**2 + (entrySB.getError()*rSBSRVV)**2) bkgNorm = entrySB.getVal() + SRyield.getVal() + VRyield.getVal() bkgYield_eig_norm = RooRealVar("predSR_eig_norm", "expected yield in SR", bkgYield, 0., 1.e6) bkgYieldExt = HSByield.getVal() drawPlot("JetMass", channel, J_mass, model, setDataSB, binsJmass, None, None, "", bkgNorm, True) print channel, "normalization = %.3f +/- %.3f, observed = %.0f" % (bkgYield, bkgYield_error, setDataSR.sumEntries() if not BLIND else -1) if VERBOSE: raw_input("Press Enter to continue...")