def process_material(lcdd, m): #print 'Adding material ...', m.get('name') doc = lcdd.document() matname = m.get('name') density = m.find('D') composites = m.findall('fraction') table = doc.GetElementTable() mat = doc.GetMaterial(matname) if not mat: mat = TGeoMixture(matname, len(composites), density.getF('value')) SetOwnership(mat, False) elts = [mat.GetElement(i).GetName() for i in range(mat.GetNelements())] for c in composites: nam = c.get('ref') if nam not in elts: fraction = c.getF('n') if table.FindElement(nam): mat.AddElement(table.FindElement(nam), fraction) elif doc.GetMaterial(nam): mat.AddElement(doc.GetMaterial(nam), fraction) else: raise 'Something going very wrong. Undefined material:' + nam medium = doc.GetMedium(matname) if not medium: global unique_mat_id unique_mat_id = unique_mat_id - 1 medium = TGeoMedium(matname, unique_mat_id, mat) SetOwnership(medium, False) medium.SetTitle('material') medium.SetUniqueID(unique_mat_id) lcdd.addMaterial(Handle_t(medium))
def makePlot(lumi, lumi_str, treeDA, treeMC, var, name, nbin, xmin, xmax, theCut, cuts, labelx, logx, protection): MC = treeMC.getTH1F(lumi, "hMC_%s"%(name), var, nbin, xmin, xmax, theCut, '', labelx) MCS = treeMC.getStack(lumi, "hMCS_%s"%(name), var, nbin, xmin, xmax, theCut, "", labelx) DATA = treeDA.getTH1F(lumi, "hDATA_%s"%(name), var, nbin, xmin, xmax, theCut, '', labelx) maxValmc = MC.GetMaximum() #GetBinContent(MC.GetMaximumBin()) maxValdata = DATA.GetMaximum() #GetBinContent(DATA.GetMaximumBin()) maxVal = max(maxValmc, maxValdata) if not logx: MC.GetYaxis().SetRangeUser(0.1, 1.3*maxVal) MCS.SetMaximum(1.3*maxVal) DATA.GetYaxis().SetRangeUser(0.1, 1.3*maxVal) else: MC.GetYaxis().SetRangeUser(0.1, 2.0*maxVal) MCS.SetMaximum(2.0*maxVal) DATA.GetYaxis().SetRangeUser(0.1, 2.0*maxVal) print "DATA integral ", DATA.Integral() print "MC integral ", MC.Integral() SetOwnership(MC, 0 ) # 0 = release (not keep), 1 = keep SetOwnership(MCS, 0 ) # 0 = release (not keep), 1 = keep SetOwnership(DATA, 0 ) # 0 = release (not keep), 1 = keep plot = Canvas.Canvas('DataMC/%s/plot_%s'%(lumi_str,name), 'png,pdf,root', 0.65, 0.6, 0.85, 0.9) plot.addStack(MCS, "HIST", 1, 1) plot.addHisto(DATA, "E1,SAME", "Data", "P", r.kBlack, 1, 0) plot.saveRatio(1, 1, logx, lumi, DATA, MC)
def AeffPhiDepPlot(IRFs, nph, energy, theta, front=True, back=False, plot=True): #get phi points phis = [0 + i * (90. / (nph - 1.)) for i in range(nph)] #access available IRFs pyIrfLoader.Loader_go() if front and back: #get front and back IRFs, get effective area for phis for given energy and theta conv = 'FRONT + BACK' irfs_front = pyIrfLoader.IrfsFactory.instance().create(IRFs + "::FRONT") irfs_back = pyIrfLoader.IrfsFactory.instance().create(IRFs + "::BACK") Aeff_front = getAeff_phi(irfs_front.aeff(), energy, theta, phis) Aeff_back = getAeff_phi(irfs_back.aeff(), energy, theta, phis) Aeff = Aeff_front + Aeff_back else: #access the necessary IRFs, get effective area for phis for given energy and theta conv = ('FRONT' if front else "BACK") irfs = pyIrfLoader.IrfsFactory.instance().create(IRFs + "::" + conv) Aeff = getAeff_phi(irfs.aeff(), energy, theta, phis) #expand the phi values out to 360 degrees, copy effective area values too phibins = array(phis + [p + 90. for p in phis[1:]] + [p + 180. for p in phis[1:]] + [p + 270. for p in phis[1:]]) AeffValues = array([a for a in Aeff] + [a for a in Aeff[1:]] + [a for a in Aeff[1:]] + [a for a in Aeff[1:]]) #make and fill phi graph phigraph = TGraph(len(phibins), phibins, AeffValues) phigraph.SetMarkerStyle(20) phigraph.SetMarkerColor(1) phigraph.SetLineColor(1) if plot: #if plot set to True, draw and make some style choices phcan = TCanvas( 'phcan', '%s %s Effective Area vs. phi for E = %.1f MeV and theta = %.1f deg' % (IRFs, conv, energy, theta), 1000, 800) phcan.SetTicks(1, 1) pdummy = TH1F('pdummy', '', 1000, 0, 360) pdummy.SetXTitle('#phi (#circ)') pdummy.GetXaxis().CenterTitle() pdummy.SetYTitle('A_{eff} (m^{2} )') pdummy.GetYaxis().CenterTitle() pdummy.GetYaxis().SetRangeUser(0., 1.) pdummy.Draw() phigraph.Draw('plsame') SetOwnership(phigraph, False) SetOwnership(phcan, False) SetOwnership(pdummy, False) return phigraph
def addTRUGrid(subsystem, hist): """ Add a grid of TLines representing the TRU on a canvas. Note: Assumes that the canvas is already created. Note: Allocates a large number of TLines which have SetOwnership(obj, False), so this could lead to memory problems. """ # TEMP logger.debug("TRU Grid histName: {0}".format(hist.histName)) # Draw grid for TRUs in full EMCal SMs for x in range(8, 48, 8): line = TLine(x, 0, x, 60) SetOwnership(line, False) line.Draw() # 60 + 1 to ensure that 60 is plotted for y in range(12, 60 + 1, 12): line = TLine(0, y, 48, y) SetOwnership(line, False) line.Draw() # Draw grid for TRUs in 1/3 EMCal SMs line = TLine(0, 64, 48, 64) SetOwnership(line, False) line.Draw() line = TLine(24, 60, 24, 64) SetOwnership(line, False) line.Draw() # Draw grid for TRUs in 2/3 DCal SMs for x in range(8, 48, 8): if (x == 24): # skip PHOS hole continue line = TLine(x, 64, x, 100) SetOwnership(line, False) line.Draw() for y in range(76, 100, 12): line = TLine(0, y, 16, y) SetOwnership(line, False) line.Draw() # skip PHOS hole line = TLine(32, y, 48, y) SetOwnership(line, False) line.Draw() # Draw grid for TRUs in 1/3 DCal SMs line = TLine(0, 100, 48, 100) SetOwnership(line, False) line.Draw() line = TLine(24, 100, 24, 104) SetOwnership(line, False) line.Draw()
def draw_2histograms( histo1, histo2, x_axisName, y_axisName, leg1Name, leg2Name ): histo1.GetXaxis().SetTitle(x_axisName) if (y_axisName==""): histo1.GetYaxis().SetTitle("Entries/per bin") else: histo1.GetYaxis().SetTitle(y_axisName) histo2.SetLineColor(2) if (leg1Name!=""): histo1.SetStats(0) histo2.SetStats(0) legend=TLegend(0.45,0.78,0.9,0.9) legend.AddEntry(histo1, leg1Name, "l") legend.AddEntry(histo2, leg2Name, "l") legend.SetTextSize(0.05) SetOwnership( legend, 0 ) maximum1 = 1.2*histo1.GetMaximum() maximum2 = 1.2*histo2.GetMaximum() maximum = maximum1 if (maximum2>maximum): maximum = maximum2 histo1.SetMaximum(maximum) histo1.Draw() histo2.Draw("same") if (leg1Name!=""): legend.Draw("same") gPad.Update() return
def combined_histogram(histograms_or_stack): """Returns a combined TH1 object from a collection of histograms with bin errors calculated. Args: histograms_or_stack: A single histogram, a non-empty iterable of histograms, or a THStack object which represents the collection of histograms Returns: A single TH1 object which is a combination of the provided histograms and which has bin errors calculated. """ # Convert the histograms to an iterable, always unpacking THStack objects histograms = drawable_iterable(histograms_or_stack, True) # Grab the first histogram, making sure bin errors are calculated before # adding the remaining histograms result = histograms[0].Clone(_rand_uuid()) SetOwnership(result, False) if result.GetSumw2N() == 0: result.Sumw2() # Add the other histograms to the result map(result.Add, histograms[1:]) return result
def addEnergyAxisToPatches(subsystem, hist, processingOptions): """ Adds an additional axis showing the conversion from ADC counts to Energy. These conditions are set for "{EMCal,DCal}(Max)PatchAmp". It creates a new TGaxis that shows the ADC to Energy conversion. It then draws it on selected histogram. Warning: This function assumes that there is already a canvas created. Note: TGaxis removes ownership from Python to ensure that it continues to exist outside of the function scope. Args: hist (TH1): The histogram to be processed. Returns: None """ kEMCL1ADCtoGeV = 0.07874 # Conversion from EMCAL Level1 ADC to energy adcMin = hist.hist.GetXaxis().GetXmin() adcMax = hist.hist.GetXaxis().GetXmax() EMax = adcMax * kEMCL1ADCtoGeV EMin = adcMin * kEMCL1ADCtoGeV #yMax = gPad.GetUymax() # this function does not work here (log problem) yMax = 2 * hist.hist.GetMaximum() energyAxis = TGaxis(adcMin, yMax, adcMax, yMax, EMin, EMax, 510, "-") SetOwnership(energyAxis, False) energyAxis.SetTitle("Energy (GeV)") energyAxis.Draw()
def showAllPlotsInDict(listOfGraphs, hAxes, cDebug): #print listOfGraphs cDebug.cd() color = 0 # black hAxes.Draw("") leg = root.TLegend(0.15, 0.71, 0.35, 0.88) leg.SetBorderSize(1) leg.SetFillColor(0) # trick to have the legend not disappearing SetOwnership(leg, 0) # 0 = release (not keep), 1 = keep, ot for graph in listOfGraphs: color += 1 leg.AddEntry(graph, "Kick Response Meas #%d" % color, "lp") # skip the color white if (color == 10): color = 11 graph.SetLineColor(color) graph.SetMarkerColor(color) graph.SetMarkerStyle(20) graph.Draw("LP") leg.Draw() cDebug.Update()
def matrixCorrection(histds, cf, CR, eventAcc, histdet, opt): histcs = dict() errorMatrices = dict() nsample = len(histds) for isample in range(nsample): histd = histds[isample] title = histd.GetTitle() histc = TH1D("histc" + str(isample), title + " corr", nbin, binEdges) SetOwnership(histc, False) valuesd = getArray(histd) errorsd = getArrayErrors(histd) valuesh = CR.dot(valuesd) if "u" in opt: # Use expected error scf = histd.GetEntries() / histdet.GetEntries() for i in range(nbin): errorsd[i] = histdet.GetBinError(i + 1) * sqrt(scf) # Error propagation from correction matrix; it is not # symmetric so order of indices matters diagErrorMatrixd = np.diag(errorsd**2) errorMatrixh = np.dot(CR, np.dot(diagErrorMatrixd, CR.transpose())) # Set corrected values and bin-by-bin error in histo errorsh = errorsd * cf for i in range(nbin): histc.SetBinContent(i + 1, valuesh[i]) histc.SetBinError(i + 1, errorsh[i]) # Number of entries from filled events and event acceptance nevent = histd.GetEntries() neventCorrected = nevent * eventAcc histc.SetEntries(neventCorrected) histcs[isample] = histc errorMatrices[isample] = errorMatrixh # Fin return histcs, errorMatrices
def OutputRootFile(outfile): o = TFile(outfile,"RECREATE"); print "Output written to: ", outfile SetOwnership( o, False ) # tell python not to take ownership return o
def getLoopTH2F(self, inputdir, hname): ## Correct input dir absolute path: inputdir = inputdir + '/' if inputdir[-1] != '/' else inputdir ## Init histogram: _f0 = r.TFile(inputdir + '{0}__{1}__{2}__0.root'.format(self.name, self.blocks[0].name, self.blocks[0].samples[0].name)) hth2f = copy.deepcopy(_f0.Get(hname + '__{0}__{1}__{2}__0'.format(self.name, self.blocks[0].name, self.blocks[0].samples[0].name))) _f0.Close() SetOwnership(hth2f, 0) ## Loop over files: for _b,b in enumerate(self.blocks): for _s,s in enumerate(b.samples): for t in range(0, len(s.ttrees)): if t == 0 and _s == 0 and _b == 0: continue _ft = r.TFile(inputdir + '{0}__{1}__{2}__{3}.root'.format(self.name, b.name, s.name, str(t))) _haux = _ft.Get(hname + '__{0}__{1}__{2}__{3}'.format(self.name, b.name, s.name, str(t))) try: _h = _haux.Clone() hth2f.Add(_h) except ReferenceError: print(hname + '__{0}__{1}__{2}__{3}'.format(self.name, b.name, s.name, str(t)) + ' cannot be accesed: Skipping') pass _ft.Close() return hth2f
def _make_underlying_model(self): self.pdfs = {} self.yields = {} # yields are plain floats self.ryields = {} # keep track of roofit objects for memory management nbins, xmin, xmax = self.plot.histos[0].GetBinning() self.xvar = RooRealVar("x", "x", xmin, xmax) self.xvar.setBins(nbins) self.pdfs = {} self.hists = [] pdfs = RooArgList() yields = RooArgList() for compname, comp in self.plot.histosDict.iteritems(): if comp.weighted.Integral() == 0: continue assert (isinstance(comp, Histogram)) hist = RooDataHist(compname, compname, RooArgList(self.xvar), comp.weighted) SetOwnership(hist, False) # self.hists.append(hist) pdf = RooHistPdf(compname, compname, RooArgSet(self.xvar), hist) self.pdfs[compname] = pdf # self.pdfs[compname].Print() pdfs.add(pdf) nevts = comp.Integral(xmin=xmin, xmax=xmax) nmin = min(0, nevts * (1 - comp.uncertainty)) nmax = nevts * (1 + comp.uncertainty) theyield = RooRealVar('n{}'.format(compname), 'n{}'.format(compname), nevts, nmin, nmax) self.ryields[compname] = theyield self.yields[compname] = nevts yields.add(theyield) self.underlying_model = RooAddPdf('model', 'model', pdfs, yields)
def getStack(self, lumi, name, var, nbin, xmin, xmax, cut, options, xlabel): if cut == '': cut = '(1)' hs = THStack(name, "") SetOwnership(hs, 0 ) for b in self.blocks: AuxName = "auxStack_block_" + name + "_" + b.name haux = b.getTH1F(lumi, AuxName, var, nbin, xmin, xmax, cut, options, xlabel) haux.SetFillColor(b.color) haux.SetLineColor(r.kBlack) haux.SetTitle(b.label) hs.Add(haux) del haux can_aux = TCanvas("can_%s_%s"%(name, b.name)) can_aux.cd() hs.Draw() del can_aux ylabel = "Events" if xmax != xmin: hs.GetXaxis().SetTitle(xlabel) b = int((xmax-xmin)/nbin) ylabel = "Events / " + str(b) + " GeV" else: ylabel = "Events" hs.GetYaxis().SetTitle(ylabel) return hs
def create_file_and_tree(self): f = ROOT.TFile(self.filename, 'RECREATE') t = ROOT.TTree(self.treename, self.treename) # Prevent double deletion of the tree (Python and C++ TFile) SetOwnership(t, False) return f, t
def histogram_stack(*histograms): """Creates a THStack object with a unique identifier from the specified histograms. This method is useful due to THStack freaking out if a new THStack is created with the same name. Args: histograms: Each argument of this function after plot may be a single histogram, an iterable of histograms (each of which should be plotted), or even an existing THStack object whose component histograms should be included in the new stack. The histograms should be specified from top-to-bottom. Returns: An initialized THStack object containing the specified histograms. """ # Generate an iterable of all histograms provided histograms = chain(*(drawable_iterable(h, unpack_stacks=True) for h in histograms)) # Create a new THStack object with a unique identifier stack = THStack(_rand_uuid(), '') SetOwnership(stack, False) # Add histograms map(stack.Add, histograms) return stack
def makeTObjArray(theList): """Turn a python iterable into a ROOT TObjArray""" # Make PyROOT give up ownership of the things that are being placed in the # TObjArary. They get deleted because of result.SetOwner() result = TObjArray() result.SetOwner() for item in theList: SetOwnership(item, False) result.Add(item) return result
def patchAmpOptions(subsystem, hist, processingOptions): # Setup canvas as desired hist.canvas.SetLogy(True) hist.canvas.SetGrid(1, 1) # Check for the corresponding hist #if "DCal" in hist.GetName(): # nameToCheck = hist.GetName().replace("DCal", "EMCal") #else: # nameToCheck = hist.GetName().replace("EMCal", "DCal") #otherHist = qaContainer.getHist(nameToCheck) # Plot both on the same canvas if they both exist #if otherHist is not None: if hist.hist.InheritsFrom(THStack.Class()): # Add legend legend = TLegend(0.6, 0.9, 0.9, 0.7) legend.SetBorderSize(0) legend.SetFillStyle(0) SetOwnership(legend, False) # Lists to use to plot detectors = ["EMCal", "DCal"] colors = [kRed + 1, kBlue + 1] markers = [kFullCircle, kOpenCircle] options = ["", ""] # Plot elements for tempHist, detector, color, marker, option in zip( hist.hist.GetHists(), detectors, colors, markers, options): tempHist.Sumw2() tempHist.SetMarkerSize(0.8) tempHist.SetMarkerStyle(marker) tempHist.SetLineColor(color) tempHist.SetMarkerColor(color) if processingOptions["scaleHists"]: tempHist.Scale(1. / subsystem.nEvents) tempHist.GetYaxis().SetTitle("entries / events") # Draw hists # This is not the usual philosophy. We are clearing the canvas and then plotting # the second hist on it #tempHist.Draw(option) legend.AddEntry(tempHist, detector, "pe") # Add legend legend.Draw() # Ensure that canvas is updated to account for the new object colors hist.canvas.Update() # Add energy axis addEnergyAxisToPatches(subsystem, hist, processingOptions)
def __init__(self, name='', yMargin = 0.2 ): self.name = name self.frame = TCanvas(name,name) # in case set the width above SetOwnership(self.frame,False) self.mainPad = TPad(name+'mainPad', '' ,0.01,yMargin,0.99,0.99) self.mainPad.SetBottomMargin(0) self.comparisonPad = TPad(name+'comparisonPad', '' ,0.01,0.01,0.99,yMargin) self.comparisonPad.SetTopMargin(0) self.comparisonPad.SetBottomMargin(0.33); self.comparisonPad.SetGridy() self.draw()
def plotMC(mc, signal, name, legend, *text): canvas = TCanvas(name,name) SetOwnership(canvas,False) mc.Draw('fhist') if signal: signal.Draw('hist,same') if legend: legend.Draw() for t in range(len(text)): text[t].Draw() raw_input('plot MC for '+name) # why the hack this is needed?!? canvas.Modified() canvas.Update() return canvas
def draw_2Dbis(t, title, h_bins, nBinsY, binsY, to_draw, extra_cut, opt = ""): nBins = int(h_bins[1:-1].split(',')[0]) minBin = float(h_bins[1:-1].split(',')[1]) maxBin = float(h_bins[1:-1].split(',')[2]) num = TH2F("num", title, nBins, minBin, maxBin, nBinsY, binsY) t.Draw(to_draw + ">>num", extra_cut, opt) SetOwnership(num, False) return num
def process_material(description, m): #print 'Adding material ...', m.get('name') density = m.find('D') radlen = m.find('RL') intlen = m.find('NIL') composites = m.findall('fraction') or m.findall('composite') table = gGeoManager.GetElementTable() mat = gGeoManager.GetMaterial(m.name) if not mat: mat = TGeoMixture( m.name, len(composites), eval( density.get('value') + '*' + density.get('unit') + '/(g/cm3)', constants)) SetOwnership(mat, False) rl = (radlen is not None) and eval( radlen.get('value') + '*' + radlen.get('unit'), constants) or 0.0 il = (intlen is not None) and eval( intlen.get('value') + '*' + intlen.get('unit'), constants) or 0.0 #mat.SetRadLen(-rl, -il) elts = [mat.GetElement(i).GetName() for i in range(mat.GetNelements())] for c in composites: nam = c.ref if nam not in elts: if c.tag == 'composite': fraction = c.getI('n') elif c.tag == 'fraction': fraction = c.getF('n') if table.FindElement(nam): mat.AddElement(table.FindElement(nam), fraction) elif gGeoManager.GetMaterial(nam): mat.AddElement(gGeoManager.GetMaterial(nam), fraction) else: raise 'Something going very wrong. Undefined material:' + nam medium = gGeoManager.GetMedium(m.name) if not medium: global unique_mat_id unique_mat_id = unique_mat_id - 1 medium = TGeoMedium(m.name, unique_mat_id, mat) SetOwnership(medium, False) medium.SetTitle('material') medium.SetUniqueID(unique_mat_id) description.addMaterial(Handle(medium))
def setupLegend(t_plots, x1, y1, x2, y2, textSize): l = TLegend(float(x1), float(y1), float(x2), float(y2)) SetOwnership(l, 0) l.SetFillColor(0) l.SetBorderSize(0) l.SetTextSize(float(textSize)) for i in reversed(xrange(len(t_plots))): if t_plots[i][1]: l.AddEntry(t_plots[i][0], t_plots[i][1], t_plots[i][2]) l.Draw()
def configureCanvasLegend(canvas,aliases,textSize=25): height = 1.2*len(aliases)*textSize/canvas.GetWh() width = int(max([len(name) for name in aliases])*textSize*.50)+70 canvas.SetLeftMargin(canvas.GetLeftMargin()*textSize/14.) canvas.SetBottomMargin(canvas.GetBottomMargin()*textSize/14.) legend = TLegend(0.00,1-canvas.GetTopMargin(),150./width,1-canvas.GetTopMargin()-height) legend.SetTextSize(textSize) legend.SetFillColor(0) legend.SetShadowColor(0) legend.SetBorderSize(0) SetOwnership(legend, 0) return canvas,legend
def draw_geff(t, title, h_bins, to_draw, den_cut, extra_num_cut, opt = "", color = kBlue, marker_st = 1, marker_sz = 1.): """Make an efficiency plot""" ## total numerator selection cut num_cut = AND(den_cut,extra_num_cut) ## PyROOT works a little different than ROOT when you are plotting ## histograms directly from tree. Hence, this work-around nBins = int(h_bins[1:-1].split(',')[0]) minBin = float(h_bins[1:-1].split(',')[1]) maxBin = float(h_bins[1:-1].split(',')[2]) num = TH1F("num", "", nBins, minBin, maxBin) den = TH1F("den", "", nBins, minBin, maxBin) t.Draw(to_draw + ">>num", num_cut, "goff") t.Draw(to_draw + ">>den", den_cut, "goff") debug = False if debug: print("Denominator cut", den_cut, den.GetEntries()) print("Numerator cut", num_cut, num.GetEntries()) ## check if the number of passed entries larger than total entries doConsistencyCheck = False if doConsistencyCheck: for i in range(0,nBins): print(i, num.GetBinContent(i), den.GetBinContent(i)) if num.GetBinContent(i) > den.GetBinContent(i): print(">>>Error: passed entries > total entries") eff = TEfficiency(num, den) ## plotting options if not "same" in opt: num.Reset() num.GetYaxis().SetRangeUser(0.0,1.1) num.SetStats(0) num.SetTitle(title) num.Draw() eff.SetLineWidth(2) eff.SetLineColor(color) eff.SetMarkerStyle(marker_st) eff.SetMarkerColor(color) eff.SetMarkerSize(marker_sz) eff.Draw(opt + " same") SetOwnership(eff, False) return eff
def ratioOnly(ratio_h, thred, name): c = r.TCanvas(name, name, 800, 800) ratio = ratio_h.Clone(name) # ratio = ratio_h.DrawCopy(name) r.gPad.SetGridx() r.gPad.SetGridy() ratio.SetTitle("") ratio.SetMarkerStyle(20) ratio.SetMarkerSize(1.1) ratio.GetYaxis().SetTitle("Correction") ratio.GetYaxis().SetTitleSize(35) ratio.GetYaxis().SetTitleFont(43) ratio.GetYaxis().SetTitleOffset(1.1) ratio.GetYaxis().SetLabelFont(43) ratio.GetYaxis().SetLabelSize(30) ratio.GetXaxis().SetTitle("#Delta R (bb)^{ave}") ratio.GetXaxis().SetTitleOffset(1.0) ratio.GetXaxis().SetTitleSize(35) ratio.GetXaxis().SetTitleFont(43) ratio.GetXaxis().SetLabelFont(43) ratio.GetXaxis().SetLabelSize(30) fitf = r.TF1(name + "_f", "[0]", thred, 5) # fitf.SetLineColor(r.kBlack) fitf.SetLineWidth(2) # res = ratio.Fit(fitf, "R S") ratio.GetYaxis().SetRangeUser(0, 2) ratio.Draw("E0") leg = r.TLegend(0.6, 0.79, 0.89, 0.89) leg.AddEntry(ratio, "Measured") leg.AddEntry(fitf, "Flattened") # text = "#splitline{Flatterning(95% CL)}{#chi^{2} = " + "{:.2f}".format(fitf.GetChisquare()) + " }" # leg.AddEntry(interval, text) leg.SetBorderSize(0) leg.Draw("same") line = r.TLine(0, 1, 5, 1) line.SetLineWidth(2) line.Draw("same") SetOwnership(line, 0) CMS_lumi.CMS_lumi(c, iPeriod, iPos) c.cd() c.Update() c.SaveAs(outdir + "/" + name + "_Fit.pdf") return c
def load_file(file, mode=None): """Open a ROOT file Args: file: The path to the ROOT file mode: The mode with which to open the file Returns: A TFile object """ if mode is None: tf = TFile.Open(file) else: tf = TFile.Open(file, mode) SetOwnership(tf, False) return tf
def checkForOutliers(hist, qaContainer): """ Checks for outliers in selected histograms. Outliers are calculated by looking at the standard deviation. See: :func:`hasSignalOutlier()`. This function is mainly a proof of concept, but could become more viable with a bit more work. Note: This function will add a large TLegend to the histogram noting the mean and the number of outliers. It will also display the recalculated mean excluding the outlier(s). Args: hist (TH1): The histogram to be processed. qaContainer (:class:`~processRuns.qa.qaFunctionContainer`): Contains information about the QA function and histograms, as well as the run being processed. Returns: None """ # If outlier data point, print warning banner if hist.GetName() == "": tempList = hasSignalOutlier( hist ) # array of info from hasSignalOutlier function, to print on legend numOutliers = tempList[0] mean = tempList[1] stdev = tempList[2] newMean = tempList[3] newStdev = tempList[4] if (numOutliers): # Create TLegend and fill with information if there is an outlier. leg = TLegend(0.15, 0.5, 0.7, 0.8) SetOwnership(leg, False) leg.SetBorderSize(4) leg.SetShadowColor(2) leg.SetHeader("#splitline{OUTLIER SIGNAL DETECTED}{IN %s BINS!}" % numOutliers) leg.AddEntry( None, "Mean: %s, Stdev: %s" % ('%.2f' % mean, '%.2f' % stdev), "") leg.AddEntry( None, "New mean: %s, New Stdev: %s" % ('%.2f' % newMean, '%.2f' % newStdev), "") leg.SetTextSize(0.04) leg.SetTextColor(2) leg.Draw()
def LoopAndScale(dir,Weight): """goes through all histos and reweights them""" nextkey=TIter(dir.GetListOfKeys()) key=nextkey() #================================================= #Iterate over the histos in the file #ListOfNewH=[] while(str(key).find('nil') == -1): #GET THE KEY obj=dir.Get(key.GetName() ) #print 'the current directory is ',gDirectory.pwd() #rint 'currently at object',obj.GetName() #raw_input() # #IF a histo # # if obj.IsA().InheritsFrom("TH1"): newhist=obj.Clone(key.GetName()) SetOwnership(newhist,False) newhist.Scale(Weight) elif obj.IsA().InheritsFrom("TDirectory"): newdir=gDirectory.mkdir(obj.GetName()) newdir.cd() LoopAndScale(obj,Weight) # # #set it to return back to where it was gDirectory.GetMotherDir().cd() else: print "Unknown object" print "It is called ",key.GetName() # #dir.cd() key=nextkey()
def draw_1D(t, title, h_bins, to_draw, extra_cut, opt = "", color = kBlue, marker_st = 20): nBins = int(h_bins[1:-1].split(',')[0]) minBin = float(h_bins[1:-1].split(',')[1]) maxBin = float(h_bins[1:-1].split(',')[2]) num = TH1F("num", "", nBins, minBin, maxBin) t.Draw(to_draw + ">>num", extra_cut, "goff") num.SetLineWidth(2) num.SetLineColor(color) num.SetMarkerStyle(marker_st) num.SetMarkerColor(color) num.SetMarkerSize(.5) SetOwnership(num, False) return num
def getLoopTH1F(self, inputdir, hname, doOF = True): ## Correct input dir absolute path: inputdir = inputdir + '/' if inputdir[-1] != '/' else inputdir ## Init histogram: _f0 = r.TFile(inputdir + '{0}__{1}__{2}__0.root'.format(self.name, self.blocks[0].name, self.blocks[0].samples[0].name)) hth1f = copy.deepcopy(_f0.Get(hname + '__{0}__{1}__{2}__0'.format(self.name, self.blocks[0].name, self.blocks[0].samples[0].name))) if doOF: hth1f.SetBinContent(hth1f.GetNbinsX(), hth1f.GetBinContent(hth1f.GetNbinsX()) + hth1f.GetBinContent(hth1f.GetNbinsX() + 1) ) hth1f.SetBinError(hth1f.GetNbinsX(), hth1f.GetBinError(hth1f.GetNbinsX()) + hth1f.GetBinError(hth1f.GetNbinsX() + 1) ) _f0.Close() SetOwnership(hth1f, 0) ## Loop over files: for _b,b in enumerate(self.blocks): for _s,s in enumerate(b.samples): for t in range(0, len(s.ttrees)): if t == 0 and _s == 0 and _b == 0: continue _ft = r.TFile(inputdir + '{0}__{1}__{2}__{3}.root'.format(self.name, b.name, s.name, str(t))) _haux = _ft.Get(hname + '__{0}__{1}__{2}__{3}'.format(self.name, b.name, s.name, str(t))) try: _h = _haux.Clone() if doOF: _h.SetBinContent(_h.GetNbinsX(), _h.GetBinContent(_h.GetNbinsX()) + _h.GetBinContent(_h.GetNbinsX() + 1) ) _h.SetBinError(_h.GetNbinsX(), _h.GetBinError(_h.GetNbinsX()) + _h.GetBinError(_h.GetNbinsX() + 1) ) hth1f.Add(_h) except ReferenceError: print(hname + '__{0}__{1}__{2}__{3}'.format(self.name, b.name, s.name, str(t)) + ' cannot be accesed: Skipping') pass _ft.Close() ## Get some values: xmin = float(hth1f.GetXaxis().GetXmin()) xmax = float(hth1f.GetXaxis().GetXmax()) nbin = hth1f.GetXaxis().GetNbins() ## Correct y axis ylabel = "Events" b = (xmax-xmin)/float(nbin) ylabel = "Events / " + "{:.2f}".format(b) + " units" hth1f.GetYaxis().SetTitle(ylabel) return hth1f