plotting Namespace Reference

Classes
class	AggregateBins
class	AggregateHistos
class	CutEfficiency
class	DQMSubFolder
class	FakeDuplicate
class	Frame
class	FrameRatio
class	FrameTGraph2D
class	GetDirectoryCode
class	Plot
class	PlotEmpty
class	PlotFolder
class	PlotGroup
class	PlotOnSideGroup
class	Plotter
class	PlotterFolder
class	PlotterInstance
class	PlotterItem
class	PlotterTableItem
class	PlotText
class	PlotTextBox
class	ROC
class	Subtract
class	Transform

Functions
def	_calculateRatios (histos, ratioUncertainty=False)
def	_copyStyle (src, dst)
def	_createCanvas (name, width, height)
def	_drawFrame (pad, bounds, zmax=None, xbinlabels=None, xbinlabelsize=None, xbinlabeloption=None, ybinlabels=None, suffix="")
def	_findBounds (th1s, ylog, xmin=None, xmax=None, ymin=None, ymax=None)
def	_findBoundsY (th1s, ylog, ymin=None, ymax=None, coverage=None, coverageRange=None)
def	_getDirectory (*args, **kwargs)
def	_getDirectoryDetailed (tfile, possibleDirs, subDir=None)
def	_getObject (tdirectory, name)
def	_getOrCreateObject (tdirectory, nameOrCreator)
def	_getXmax (obj, limitToNonZeroContent=False)
def	_getXmin (obj, limitToNonZeroContent=False)
def	_getYmax (obj, limitToNonZeroContent=False)
def	_getYmaxWithError (th1)
def	_getYmin (obj, limitToNonZeroContent=False)
def	_getYminIgnoreOutlier (th1)
def	_getYminMaxAroundMedian (obj, coverage, coverageRange=None)
def	_mergeBinLabels (labelsAll)
def	_mergeBinLabelsX (histos)
def	_mergeBinLabelsY (histos)
def	_modifyPadForRatio (pad, ratioFactor)
def	_setStyle ()
def	_th1IncludeOnlyBins (histos, xbinlabels)
def	_th1RemoveEmptyBins (histos, xbinlabels)
def	_th1ToOrderedDict (th1, renameBin=None)
def	_th2RemoveEmptyBins (histos, xbinlabels, ybinlabels)

Variables
	_gr
	_plotStylesColor
	_plotStylesMarker
	_ratio
	_ratioYTitle
	_th1
	_uncertainty
	_xerrshigh
	_xerrslow
	_xvalues
	_yerrshigh
	_yerrslow
	_yvalues
	IgnoreCommandLineOptions
	verbose

Function Documentation

_calculateRatios()

def plotting._calculateRatios (   histos,   ratioUncertainty = False  )

private

Calculate the ratios for a list of histograms

Definition at line 148 of file plotting.py.

def _calculateRatios(histos, ratioUncertainty=False):
    """Calculate the ratios for a list of histograms"""
 
    def _divideOrZero(numerator, denominator):
        if denominator == 0:
            return 0
        return numerator/denominator
 
    def equal(a, b):
        if a == 0. and b == 0.:
            return True
        return abs(a-b)/max(abs(a),abs(b)) < 1e-3
 
    def findBins(wrap, bins_xvalues):
        ret = []
        currBin = wrap.begin()
        i = 0
        while i < len(bins_xvalues) and currBin < wrap.end():
            (xcenter, xlow, xhigh) = bins_xvalues[i]
            xlowEdge = xcenter-xlow
            xupEdge = xcenter+xhigh
 
            (curr_center, curr_low, curr_high) = wrap.xvalues(currBin)
            curr_lowEdge = curr_center-curr_low
            curr_upEdge = curr_center+curr_high
 
            if equal(xlowEdge, curr_lowEdge) and equal(xupEdge,  curr_upEdge):
                ret.append(currBin)
                currBin += 1
                i += 1
            elif curr_upEdge <= xlowEdge:
                currBin += 1
            elif curr_lowEdge >= xupEdge:
                ret.append(None)
                i += 1
            else:
                ret.append(None)
                currBin += 1
                i += 1
        if len(ret) != len(bins_xvalues):
            ret.extend([None]*( len(bins_xvalues) - len(ret) ))
        return ret
 
    # Define wrappers for TH1/TGraph/TGraph2D to have uniform interface
    # TODO: having more global wrappers would make some things simpler also elsewhere in the code
    class WrapTH1:
        def __init__(self, th1, uncertainty):
            self._th1 = th1
            self._uncertainty = uncertainty
 
            xaxis = th1.GetXaxis()
            xaxis_arr = xaxis.GetXbins()
            if xaxis_arr.GetSize() > 0: # unequal binning
                lst = [xaxis_arr[i] for i in range(0, xaxis_arr.GetSize())]
                arr = array.array("d", lst)
                self._ratio = ROOT.TH1F("foo", "foo", xaxis.GetNbins(), arr)
            else:
                self._ratio = ROOT.TH1F("foo", "foo", xaxis.GetNbins(), xaxis.GetXmin(), xaxis.GetXmax())
            _copyStyle(th1, self._ratio)
            self._ratio.SetStats(0)
            self._ratio.SetLineColor(ROOT.kBlack)
            self._ratio.SetLineWidth(1)
        def draw(self, style=None):
            st = style
            if st is None:
                if self._uncertainty:
                    st = "EP"
                else:
                    st = "HIST P"
            self._ratio.Draw("same "+st)
        def begin(self):
            return 1
        def end(self):
            return self._th1.GetNbinsX()+1
        def xvalues(self, bin):
            xval = self._th1.GetBinCenter(bin)
            xlow = xval-self._th1.GetXaxis().GetBinLowEdge(bin)
            xhigh = self._th1.GetXaxis().GetBinUpEdge(bin)-xval
            return (xval, xlow, xhigh)
        def yvalues(self, bin):
            yval = self._th1.GetBinContent(bin)
            yerr = self._th1.GetBinError(bin)
            return (yval, yerr, yerr)
        def y(self, bin):
            return self._th1.GetBinContent(bin)
        def divide(self, bin, scale):
            self._ratio.SetBinContent(bin, _divideOrZero(self._th1.GetBinContent(bin), scale))
            self._ratio.SetBinError(bin, _divideOrZero(self._th1.GetBinError(bin), scale))
        def makeRatio(self):
            pass
        def getRatio(self):
            return self._ratio
 
    class WrapTGraph:
        def __init__(self, gr, uncertainty):
            self._gr = gr
            self._uncertainty = uncertainty
            self._xvalues = []
            self._xerrslow = []
            self._xerrshigh = []
            self._yvalues = []
            self._yerrshigh = []
            self._yerrslow = []
        def draw(self, style=None):
            if self._ratio is None:
                return
            st = style
            if st is None:
                if self._uncertainty:
                    st = "PZ"
                else:
                    st = "PX"
            self._ratio.Draw("same "+st)
        def begin(self):
            return 0
        def end(self):
            return self._gr.GetN()
        def xvalues(self, bin):
            return (self._gr.GetX()[bin], self._gr.GetErrorXlow(bin), self._gr.GetErrorXhigh(bin))
        def yvalues(self, bin):
            return (self._gr.GetY()[bin], self._gr.GetErrorYlow(bin), self._gr.GetErrorYhigh(bin))
        def y(self, bin):
            return self._gr.GetY()[bin]
        def divide(self, bin, scale):
            # Ignore bin if denominator is zero
            if scale == 0:
                return
            # No more items in the numerator
            if bin >= self._gr.GetN():
                return
            # denominator is missing an item
            xvals = self.xvalues(bin)
            xval = xvals[0]
 
            self._xvalues.append(xval)
            self._xerrslow.append(xvals[1])
            self._xerrshigh.append(xvals[2])
            yvals = self.yvalues(bin)
            self._yvalues.append(yvals[0] / scale)
            if self._uncertainty:
                self._yerrslow.append(yvals[1] / scale)
                self._yerrshigh.append(yvals[2] / scale)
            else:
                self._yerrslow.append(0)
                self._yerrshigh.append(0)
        def makeRatio(self):
            if len(self._xvalues) == 0:
                self._ratio = None
                return
            self._ratio = ROOT.TGraphAsymmErrors(len(self._xvalues), array.array("d", self._xvalues), array.array("d", self._yvalues),
                                                 array.array("d", self._xerrslow), array.array("d", self._xerrshigh),
                                                 array.array("d", self._yerrslow), array.array("d", self._yerrshigh))
            _copyStyle(self._gr, self._ratio)
        def getRatio(self):
            return self._ratio
    class WrapTGraph2D(WrapTGraph):
        def __init__(self, gr, uncertainty):
            WrapTGraph.__init__(self, gr, uncertainty)
        def xvalues(self, bin):
            return (self._gr.GetX()[bin], self._gr.GetErrorX(bin), self._gr.GetErrorX(bin))
        def yvalues(self, bin):
            return (self._gr.GetY()[bin], self._gr.GetErrorY(bin), self._gr.GetErrorY(bin))
 
    def wrap(o):
        if isinstance(o, ROOT.TH1) and not isinstance(o, ROOT.TH2):
            return WrapTH1(o, ratioUncertainty)
        elif isinstance(o, ROOT.TGraph):
            return WrapTGraph(o, ratioUncertainty)
        elif isinstance(o, ROOT.TGraph2D):
            return WrapTGraph2D(o, ratioUncertainty)
 
    wrappers = [wrap(h) for h in histos if wrap(h) is not None]
    if len(wrappers) < 1:
        return []
    ref = wrappers[0]
 
    wrappers_bins = []
    ref_bins = [ref.xvalues(b) for b in range(ref.begin(), ref.end())]
    for w in wrappers:
        wrappers_bins.append(findBins(w, ref_bins))
 
    for i, bin in enumerate(range(ref.begin(), ref.end())):
        (scale, ylow, yhigh) = ref.yvalues(bin)
        for w, bins in zip(wrappers, wrappers_bins):
            if bins[i] is None:
                continue
            w.divide(bins[i], scale)
 
    for w in wrappers:
        w.makeRatio()
 
    return wrappers
 
 

References funct.abs(), cond::serialization.equal(), and SiStripPI.max.

Referenced by ntuplePlotting.drawSingle().

_copyStyle()

def plotting._copyStyle (   src,   dst  )

private

Definition at line 1663 of file plotting.py.

def _copyStyle(src, dst):
    properties = []
    if hasattr(src, "GetLineColor") and hasattr(dst, "SetLineColor"):
        properties.extend(["LineColor", "LineStyle", "LineWidth"])
    if hasattr(src, "GetFillColor") and hasattr(dst, "SetFillColor"):
        properties.extend(["FillColor", "FillStyle"])
    if hasattr(src, "GetMarkerColor") and hasattr(dst, "SetMarkerColor"):
        properties.extend(["MarkerColor", "MarkerSize", "MarkerStyle"])
 
    for prop in properties:
        getattr(dst, "Set"+prop)(getattr(src, "Get"+prop)())
 

_createCanvas()

def plotting._createCanvas (   name,   width,   height  )

private

Definition at line 109 of file plotting.py.

def _createCanvas(name, width, height):
    # silence warning of deleting canvas with the same name
    if not verbose:
        backup = ROOT.gErrorIgnoreLevel
        ROOT.gErrorIgnoreLevel = ROOT.kError
    canvas = ROOT.TCanvas(name, name, width, height)
    if not verbose:
        ROOT.gErrorIgnoreLevel = backup
    return canvas
 

Referenced by plotting.PlotGroup._drawSeparate(), ntuplePlotting.draw(), plotting.PlotGroup.draw(), and ntuplePlotting.drawMany().

_drawFrame()

def plotting._drawFrame (   pad,   bounds,   zmax = None,   xbinlabels = None,   xbinlabelsize = None,   xbinlabeloption = None,   ybinlabels = None,   suffix = ""  )

private

Function to draw a frame

Arguments:
pad    -- TPad to where the frame is drawn
bounds -- List or 4-tuple for (xmin, ymin, xmax, ymax)

Keyword arguments:
zmax            -- Maximum Z, needed for TH2 histograms
xbinlabels      -- Optional list of strings for x axis bin labels
xbinlabelsize   -- Optional number for the x axis bin label size
xbinlabeloption -- Optional string for the x axis bin options (passed to ROOT.TH1.LabelsOption())
suffix          -- Optional string for a postfix of the frame name

Definition at line 1187 of file plotting.py.

def _drawFrame(pad, bounds, zmax=None, xbinlabels=None, xbinlabelsize=None, xbinlabeloption=None, ybinlabels=None, suffix=""):
    """Function to draw a frame
 
    Arguments:
    pad    -- TPad to where the frame is drawn
    bounds -- List or 4-tuple for (xmin, ymin, xmax, ymax)
 
    Keyword arguments:
    zmax            -- Maximum Z, needed for TH2 histograms
    xbinlabels      -- Optional list of strings for x axis bin labels
    xbinlabelsize   -- Optional number for the x axis bin label size
    xbinlabeloption -- Optional string for the x axis bin options (passed to ROOT.TH1.LabelsOption())
    suffix          -- Optional string for a postfix of the frame name
    """
    if xbinlabels is None and ybinlabels is None:
        frame = pad.DrawFrame(*bounds)
    else:
        # Special form needed if want to set x axis bin labels
        nbins = len(xbinlabels)
        if ybinlabels is None:
            frame = ROOT.TH1F("hframe"+suffix, "", nbins, bounds[0], bounds[2])
            frame.SetMinimum(bounds[1])
            frame.SetMaximum(bounds[3])
            frame.GetYaxis().SetLimits(bounds[1], bounds[3])
        else:
            ybins = len(ybinlabels)
            frame = ROOT.TH2F("hframe"+suffix, "", nbins,bounds[0],bounds[2], ybins,bounds[1],bounds[3])
            frame.SetMaximum(zmax)
 
        frame.SetBit(ROOT.TH1.kNoStats)
        frame.SetBit(ROOT.kCanDelete)
        frame.Draw("")
 
        xaxis = frame.GetXaxis()
        for i in range(nbins):
            xaxis.SetBinLabel(i+1, xbinlabels[i])
        if xbinlabelsize is not None:
            xaxis.SetLabelSize(xbinlabelsize)
        if xbinlabeloption is not None:
            frame.LabelsOption(xbinlabeloption)
 
        if ybinlabels is not None:
            yaxis = frame.GetYaxis()
            for i, lab in enumerate(ybinlabels):
                yaxis.SetBinLabel(i+1, lab)
            if xbinlabelsize is not None:
                yaxis.SetLabelSize(xbinlabelsize)
            if xbinlabeloption is not None:
                frame.LabelsOption(xbinlabeloption, "Y")
 
    return frame
 

References FastTimerService_cff.range.

_findBounds()

def plotting._findBounds (   th1s,   ylog,   xmin = None,   xmax = None,   ymin = None,   ymax = None  )

private

Find x-y axis boundaries encompassing a list of TH1s if the bounds are not given in arguments.

Arguments:
th1s -- List of TH1s
ylog -- Boolean indicating if y axis is in log scale or not (affects the automatic ymax)

Keyword arguments:
xmin -- Minimum x value; if None, take the minimum of TH1s
xmax -- Maximum x value; if None, take the maximum of TH1s
ymin -- Minimum y value; if None, take the minimum of TH1s
ymax -- Maximum y value; if None, take the maximum of TH1s

Definition at line 459 of file plotting.py.

def _findBounds(th1s, ylog, xmin=None, xmax=None, ymin=None, ymax=None):
    """Find x-y axis boundaries encompassing a list of TH1s if the bounds are not given in arguments.
 
    Arguments:
    th1s -- List of TH1s
    ylog -- Boolean indicating if y axis is in log scale or not (affects the automatic ymax)
 
    Keyword arguments:
    xmin -- Minimum x value; if None, take the minimum of TH1s
    xmax -- Maximum x value; if None, take the maximum of TH1s
    ymin -- Minimum y value; if None, take the minimum of TH1s
    ymax -- Maximum y value; if None, take the maximum of TH1s
    """
 
    (ymin, ymax) = _findBoundsY(th1s, ylog, ymin, ymax)
 
    if xmin is None or xmax is None or isinstance(xmin, list) or isinstance(max, list):
        xmins = []
        xmaxs = []
        for th1 in th1s:
            xmins.append(_getXmin(th1, limitToNonZeroContent=isinstance(xmin, list)))
            xmaxs.append(_getXmax(th1, limitToNonZeroContent=isinstance(xmax, list)))
 
        # Filter out cases where histograms have zero content
        xmins = [h for h in xmins if h is not None]
        xmaxs = [h for h in xmaxs if h is not None]
 
        if xmin is None:
            xmin = min(xmins)
        elif isinstance(xmin, list):
            if len(xmins) == 0: # all histograms zero
                xmin = min(xmin)
                if verbose:
                    print("Histogram is zero, using the smallest given value for xmin from", str(xmin))
            else:
                xm = min(xmins)
                xmins_below = [x for x in xmin if x<=xm]
                if len(xmins_below) == 0:
                    xmin = min(xmin)
                    if xm < xmin:
                        if verbose:
                            print("Histogram minimum x %f is below all given xmin values %s, using the smallest one" % (xm, str(xmin)))
                else:
                    xmin = max(xmins_below)
 
        if xmax is None:
            xmax = max(xmaxs)
        elif isinstance(xmax, list):
            if len(xmaxs) == 0: # all histograms zero
                xmax = max(xmax)
                if verbose:
                    print("Histogram is zero, using the smallest given value for xmax from", str(xmin))
            else:
                xm = max(xmaxs)
                xmaxs_above = [x for x in xmax if x>xm]
                if len(xmaxs_above) == 0:
                    xmax = max(xmax)
                    if xm > xmax:
                        if verbose:
                            print("Histogram maximum x %f is above all given xmax values %s, using the maximum one" % (xm, str(xmax)))
                else:
                    xmax = min(xmaxs_above)
 
    for th1 in th1s:
        th1.GetXaxis().SetRangeUser(xmin, xmax)
 
    return (xmin, ymin, xmax, ymax)
 

References _findBoundsY(), _getXmax(), _getXmin(), SiStripPI.max, min(), print(), and str.

Referenced by ntuplePlotting.drawSingle().

_findBoundsY()

def plotting._findBoundsY (   th1s,   ylog,   ymin = None,   ymax = None,   coverage = None,   coverageRange = None  )

private

Find y axis boundaries encompassing a list of TH1s if the bounds are not given in arguments.

Arguments:
th1s -- List of TH1s
ylog -- Boolean indicating if y axis is in log scale or not (affects the automatic ymax)

Keyword arguments:
ymin -- Minimum y value; if None, take the minimum of TH1s
ymax -- Maximum y value; if None, take the maximum of TH1s
coverage -- If set, use only values within the 'coverage' part around the median are used for min/max (useful for ratio)
coverageRange -- If coverage and this are set, use only the x axis specified by an (xmin,xmax) pair for the coverage

Definition at line 527 of file plotting.py.

def _findBoundsY(th1s, ylog, ymin=None, ymax=None, coverage=None, coverageRange=None):
    """Find y axis boundaries encompassing a list of TH1s if the bounds are not given in arguments.
 
    Arguments:
    th1s -- List of TH1s
    ylog -- Boolean indicating if y axis is in log scale or not (affects the automatic ymax)
 
    Keyword arguments:
    ymin -- Minimum y value; if None, take the minimum of TH1s
    ymax -- Maximum y value; if None, take the maximum of TH1s
    coverage -- If set, use only values within the 'coverage' part around the median are used for min/max (useful for ratio)
    coverageRange -- If coverage and this are set, use only the x axis specified by an (xmin,xmax) pair for the coverage
    """
    if coverage is not None or isinstance(th1s[0], ROOT.TH2):
        # the only use case for coverage for now is ratio, for which
        # the scalings are not needed (actually harmful), so let's
        # just ignore them if 'coverage' is set
        #
        # Also for TH2 do not adjust automatic y bounds
        y_scale_max = lambda y: y
        y_scale_min = lambda y: y
    else:
        if ylog:
            y_scale_max = lambda y: y*1.5
        else:
            y_scale_max = lambda y: y*1.05
        y_scale_min = lambda y: y*0.9 # assuming log
 
    if ymin is None or ymax is None or isinstance(ymin, list) or isinstance(ymax, list):
        ymins = []
        ymaxs = []
        for th1 in th1s:
            if coverage is not None:
                (_ymin, _ymax) = _getYminMaxAroundMedian(th1, coverage, coverageRange)
            else:
                if ylog and isinstance(ymin, list):
                    _ymin = _getYminIgnoreOutlier(th1)
                else:
                    _ymin = _getYmin(th1, limitToNonZeroContent=isinstance(ymin, list))
                _ymax = _getYmax(th1, limitToNonZeroContent=isinstance(ymax, list))
#                _ymax = _getYmaxWithError(th1)
 
            ymins.append(_ymin)
            ymaxs.append(_ymax)
 
        if ymin is None:
            ymin = min(ymins)
        elif isinstance(ymin, list):
            ym_unscaled = min(ymins)
            ym = y_scale_min(ym_unscaled)
            ymins_below = [y for y in ymin if y<=ym]
            if len(ymins_below) == 0:
                ymin = min(ymin)
                if ym_unscaled < ymin:
                    if verbose:
                        print("Histogram minimum y %f is below all given ymin values %s, using the smallest one" % (ym, str(ymin)))
            else:
                ymin = max(ymins_below)
 
        if ymax is None:
            # in case ymax is automatic, ymin is set by list, and the
            # histograms are zero, ensure here that ymax > ymin
            ymax = y_scale_max(max(ymaxs+[ymin]))
        elif isinstance(ymax, list):
            ym_unscaled = max(ymaxs)
            ym = y_scale_max(ym_unscaled)
            ymaxs_above = [y for y in ymax if y>ym]
            if len(ymaxs_above) == 0:
                ymax = max(ymax)
                if ym_unscaled > ymax:
                    if verbose:
                        print("Histogram maximum y %f is above all given ymax values %s, using the maximum one" % (ym_unscaled, str(ymax)))
            else:
                ymax = min(ymaxs_above)
 
    for th1 in th1s:
        th1.GetYaxis().SetRangeUser(ymin, ymax)
 
    return (ymin, ymax)
 

References _getYmax(), _getYmin(), _getYminIgnoreOutlier(), _getYminMaxAroundMedian(), SiStripPI.max, min(), print(), and str.

Referenced by _findBounds().

_getDirectory()

def plotting._getDirectory ( *  args, **  kwargs  )

private

Definition at line 97 of file plotting.py.

def _getDirectory(*args, **kwargs):
    return GetDirectoryCode.codesToNone(_getDirectoryDetailed(*args, **kwargs))
 

References _getDirectoryDetailed().

Referenced by plotting.PlotterTableItem.create().

_getDirectoryDetailed()

def plotting._getDirectoryDetailed (   tfile,   possibleDirs,   subDir = None  )

private

Get TDirectory from TFile.

Definition at line 73 of file plotting.py.

def _getDirectoryDetailed(tfile, possibleDirs, subDir=None):
    """Get TDirectory from TFile."""
    if tfile is None:
        return GetDirectoryCode.FileNotExist
    for pdf in possibleDirs:
        d = tfile.Get(pdf)
        if d:
            if subDir is not None:
                # Pick associator if given
                d = d.Get(subDir)
                if d:
                    return d
                else:
                    if verbose:
                        print("Did not find subdirectory '%s' from directory '%s' in file %s" % (subDir, pdf, tfile.GetName()))
#                        if "Step" in subDir:
#                            raise Exception("Foo")
                    return GetDirectoryCode.SubDirNotExist
            else:
                return d
    if verbose:
        print("Did not find any of directories '%s' from file %s" % (",".join(possibleDirs), tfile.GetName()))
    return GetDirectoryCode.PossibleDirsNotExist
 

References join(), and print().

Referenced by _getDirectory(), and plotting.PlotterFolder.create().

_getObject()

def plotting._getObject (   tdirectory,   name  )

private

Definition at line 49 of file plotting.py.

def _getObject(tdirectory, name):
    obj = tdirectory.Get(name)
    if not obj:
        if verbose:
            print("Did not find {obj} from {dir}".format(obj=name, dir=tdirectory.GetPath()))
        return None
    return obj
 

References print().

Referenced by _getOrCreateObject(), plotting.Subtract.create(), plotting.FakeDuplicate.create(), plotting.AggregateHistos.create(), and plotting.PlotterFolder.create().

_getOrCreateObject()

def plotting._getOrCreateObject (   tdirectory,   nameOrCreator  )

private

Definition at line 57 of file plotting.py.

def _getOrCreateObject(tdirectory, nameOrCreator):
    if hasattr(nameOrCreator, "create"):
        return nameOrCreator.create(tdirectory)
    return _getObject(tdirectory, nameOrCreator)
 

References _getObject().

Referenced by trackingPlots.TimePerEventPlot._create(), plotting.Plot._createOne(), plotting.Transform.create(), plotting.CutEfficiency.create(), plotting.AggregateBins.create(), plotting.ROC.create(), and trackingPlots.TimePerTrackPlot.create().

_getXmax()

def plotting._getXmax (   obj,   limitToNonZeroContent = False  )

private

Definition at line 358 of file plotting.py.

def _getXmax(obj, limitToNonZeroContent=False):
    if isinstance(obj, ROOT.TH1):
        xaxis = obj.GetXaxis()
        if limitToNonZeroContent:
            for i in range(obj.GetNbinsX(), 0, -1):
                if obj.GetBinContent(i) != 0:
                    return xaxis.GetBinUpEdge(i)
            # None for all bins being zero
            return None
        else:
            return xaxis.GetBinUpEdge(xaxis.GetLast())
    elif isinstance(obj, ROOT.TGraph) or isinstance(obj, ROOT.TGraph2D):
        m = max([obj.GetX()[i] for i in range(0, obj.GetN())])
        return m*1.1 if m > 0 else m*0.9
    raise Exception("Unsupported type %s" % str(obj))
 

References SiStripPI.max, FastTimerService_cff.range, and str.

Referenced by _findBounds().

_getXmin()

def plotting._getXmin (   obj,   limitToNonZeroContent = False  )

private

Definition at line 342 of file plotting.py.

def _getXmin(obj, limitToNonZeroContent=False):
    if isinstance(obj, ROOT.TH1):
        xaxis = obj.GetXaxis()
        if limitToNonZeroContent:
            for i in range(1, obj.GetNbinsX()+1):
                if obj.GetBinContent(i) != 0:
                    return xaxis.GetBinLowEdge(i)
            # None for all bins being zero
            return None
        else:
            return xaxis.GetBinLowEdge(xaxis.GetFirst())
    elif isinstance(obj, ROOT.TGraph) or isinstance(obj, ROOT.TGraph2D):
        m = min([obj.GetX()[i] for i in range(0, obj.GetN())])
        return m*0.9 if m > 0 else m*1.1
    raise Exception("Unsupported type %s" % str(obj))
 

References min(), FastTimerService_cff.range, and str.

Referenced by _findBounds().

_getYmax()

def plotting._getYmax (   obj,   limitToNonZeroContent = False  )

private

Definition at line 389 of file plotting.py.

def _getYmax(obj, limitToNonZeroContent=False):
    if isinstance(obj, ROOT.TH2):
        yaxis = obj.GetYaxis()
        return yaxis.GetBinUpEdge(yaxis.GetLast())
    elif isinstance(obj, ROOT.TH1):
        if limitToNonZeroContent:
            lst = [obj.GetBinContent(i) for i in range(1, obj.GetNbinsX()+1) if obj.GetBinContent(i) != 0 ]
            return max(lst) if len(lst) != 0 else 0
        else:
            return obj.GetMaximum()
    elif isinstance(obj, ROOT.TGraph) or isinstance(obj, ROOT.TGraph2D):
        m = max([obj.GetY()[i] for i in range(0, obj.GetN())])
        return m*1.1 if m > 0 else m*0.9
    raise Exception("Unsupported type %s" % str(obj))
 

References SiStripPI.max, FastTimerService_cff.range, and str.

Referenced by _findBoundsY().

_getYmaxWithError()

def plotting._getYmaxWithError (   th1 )

private

Definition at line 404 of file plotting.py.

def _getYmaxWithError(th1):
    return max([th1.GetBinContent(i)+th1.GetBinError(i) for i in range(1, th1.GetNbinsX()+1)])
 

References SiStripPI.max, and FastTimerService_cff.range.

_getYmin()

def plotting._getYmin (   obj,   limitToNonZeroContent = False  )

private

Definition at line 374 of file plotting.py.

def _getYmin(obj, limitToNonZeroContent=False):
    if isinstance(obj, ROOT.TH2):
        yaxis = obj.GetYaxis()
        return yaxis.GetBinLowEdge(yaxis.GetFirst())
    elif isinstance(obj, ROOT.TH1):
        if limitToNonZeroContent:
            lst = [obj.GetBinContent(i) for i in range(1, obj.GetNbinsX()+1) if obj.GetBinContent(i) != 0 ]
            return min(lst) if len(lst) != 0 else 0
        else:
            return obj.GetMinimum()
    elif isinstance(obj, ROOT.TGraph) or isinstance(obj, ROOT.TGraph2D):
        m = min([obj.GetY()[i] for i in range(0, obj.GetN())])
        return m*0.9 if m > 0 else m*1.1
    raise Exception("Unsupported type %s" % str(obj))
 

References min(), FastTimerService_cff.range, and str.

Referenced by _findBoundsY().

_getYminIgnoreOutlier()

def plotting._getYminIgnoreOutlier (   th1 )

private

Definition at line 407 of file plotting.py.

def _getYminIgnoreOutlier(th1):
    yvals = sorted([n for n in [th1.GetBinContent(i) for i in range(1, th1.GetNbinsX()+1)] if n>0])
    if len(yvals) == 0:
        return th1.GetMinimum()
    if len(yvals) == 1:
        return yvals[0]
 
    # Define outlier as being x10 less than minimum of the 95 % of the non-zero largest values
    ind_min = len(yvals)-1 - int(len(yvals)*0.95)
    min_val = yvals[ind_min]
    for i in range(0, ind_min):
        if yvals[i] > 0.1*min_val:
            return yvals[i]
 
    return min_val
 

References createfilelist.int, and FastTimerService_cff.range.

Referenced by _findBoundsY().

_getYminMaxAroundMedian()

def plotting._getYminMaxAroundMedian (   obj,   coverage,   coverageRange = None  )

private

Definition at line 423 of file plotting.py.

def _getYminMaxAroundMedian(obj, coverage, coverageRange=None):
    inRange = lambda x: True
    inRange2 = lambda xmin,xmax: True
    if coverageRange:
        inRange = lambda x: coverageRange[0] <= x <= coverageRange[1]
        inRange2 = lambda xmin,xmax: coverageRange[0] <= xmin and xmax <= coverageRange[1]
 
    if isinstance(obj, ROOT.TH1):
        yvals = [obj.GetBinContent(i) for i in range(1, obj.GetNbinsX()+1) if inRange2(obj.GetXaxis().GetBinLowEdge(i), obj.GetXaxis().GetBinUpEdge(i))]
        yvals = [x for x in yvals if x != 0]
    elif isinstance(obj, ROOT.TGraph) or isinstance(obj, ROOT.TGraph2D):
        yvals = [obj.GetY()[i] for i in range(0, obj.GetN()) if inRange(obj.GetX()[i])]
    else:
        raise Exception("Unsupported type %s" % str(obj))
    if len(yvals) == 0:
        return (0, 0)
    if len(yvals) == 1:
        return (yvals[0], yvals[0])
    if len(yvals) == 2:
        return (yvals[0], yvals[1])
 
    yvals.sort()
    nvals = int(len(yvals)*coverage)
    if nvals < 2:
        # Take median and +- 1 values
        if len(yvals) % 2 == 0:
            half = len(yvals) // 2
            return ( yvals[half-1], yvals[half] )
        else:
            middle = len(yvals) // 2
            return ( yvals[middle-1], yvals[middle+1] )
    ind_min = (len(yvals)-nvals) // 2
    ind_max = len(yvals)-1 - ind_min
 
    return (yvals[ind_min], yvals[ind_max])
 

References createfilelist.int, FastTimerService_cff.range, and str.

Referenced by _findBoundsY().

_mergeBinLabels()

def plotting._mergeBinLabels (   labelsAll )

private

Definition at line 713 of file plotting.py.

def _mergeBinLabels(labelsAll):
    labels_merged = labelsAll[0]
    for labels in labelsAll[1:]:
        diff = difflib.unified_diff(labels_merged, labels, n=max(len(labels_merged), len(labels)))
        labels_merged = []
        operation = []
        for item in diff: # skip the "header" lines
            if item[:2] == "@@":
                break
        for item in diff:
            operation.append(item[0])
            lab = item[1:]
            if lab in labels_merged:
                # pick the last addition of the bin
                ind = labels_merged.index(lab)
                if operation[ind] == "-" and operation[-1] == "+":
                    labels_merged.remove(lab)
                    del operation[ind] # to keep xbinlabels and operation indices in sync
                elif operation[ind] == "+" and operation[-1] == "-":
                    del operation[-1] # to keep xbinlabels and operation indices in sync
                    continue
                else:
                    raise Exception("This should never happen")
            labels_merged.append(lab)
        # unified_diff returns empty diff if labels_merged and labels are equal
        # so if labels_merged is empty here, it can be just set to labels
        if len(labels_merged) == 0:
            labels_merged = labels
 
    return labels_merged
 

References SiStripPI.max.

Referenced by _mergeBinLabelsX(), and _mergeBinLabelsY().

_mergeBinLabelsX()

def plotting._mergeBinLabelsX (   histos )

private

Definition at line 707 of file plotting.py.

def _mergeBinLabelsX(histos):
    return _mergeBinLabels([[h.GetXaxis().GetBinLabel(i) for i in range(1, h.GetNbinsX()+1)] for h in histos])
 

References _mergeBinLabels(), and FastTimerService_cff.range.

Referenced by trackingPlots.TrackingSeedingLayerTable.draw(), and plotting.Plot.draw().

_mergeBinLabelsY()

def plotting._mergeBinLabelsY (   histos )

private

Definition at line 710 of file plotting.py.

def _mergeBinLabelsY(histos):
    return _mergeBinLabels([[h.GetYaxis().GetBinLabel(i) for i in range(1, h.GetNbinsY()+1)] for h in histos])
 

References _mergeBinLabels(), and FastTimerService_cff.range.

Referenced by plotting.Plot.draw().

_modifyPadForRatio()

def plotting._modifyPadForRatio (   pad,   ratioFactor  )

private

Definition at line 119 of file plotting.py.

def _modifyPadForRatio(pad, ratioFactor):
    pad.Divide(1, 2)
 
    divisionPoint = 1-1/ratioFactor
 
    topMargin = pad.GetTopMargin()
    bottomMargin = pad.GetBottomMargin()
    divisionPoint += (1-divisionPoint)*bottomMargin # correct for (almost-)zeroing bottom margin of pad1
    divisionPointForPad1 = 1-( (1-divisionPoint) / (1-0.02) ) # then correct for the non-zero bottom margin, but for pad1 only
 
    # Set the lower point of the upper pad to divisionPoint
    pad1 = pad.cd(1)
    yup = 1.0
    ylow = divisionPointForPad1
    xup = 1.0
    xlow = 0.0
    pad1.SetPad(xlow, ylow, xup, yup)
    pad1.SetFillStyle(4000) # transparent
    pad1.SetBottomMargin(0.02) # need some bottom margin here for eps/pdf output (at least in ROOT 5.34)
 
    # Set the upper point of the lower pad to divisionPoint
    pad2 = pad.cd(2)
    yup = divisionPoint
    ylow = 0.0
    pad2.SetPad(xlow, ylow, xup, yup)
    pad2.SetFillStyle(4000) # transparent
    pad2.SetTopMargin(0.0)
    pad2.SetBottomMargin(bottomMargin/(ratioFactor*divisionPoint))
 

Referenced by ntuplePlotting.draw(), and ntuplePlotting.drawMany().

_setStyle()

def plotting._setStyle ( )

private

Definition at line 21 of file plotting.py.

def _setStyle():
    _absoluteSize = True
    if _absoluteSize:
        font = 43
        titleSize = 22
        labelSize = 22
        statSize = 14
    else:
        font = 42
        titleSize = 0.05
        labelSize = 0.05
        statSize = 0.025
 
    ROOT.gROOT.SetStyle("Plain")
    ROOT.gStyle.SetPadRightMargin(0.07)
    ROOT.gStyle.SetPadLeftMargin(0.13)
    ROOT.gStyle.SetTitleFont(font, "XYZ")
    ROOT.gStyle.SetTitleSize(titleSize, "XYZ")
    ROOT.gStyle.SetTitleOffset(1.2, "Y")
    #ROOT.gStyle.SetTitleFontSize(0.05)
    ROOT.gStyle.SetLabelFont(font, "XYZ")
    ROOT.gStyle.SetLabelSize(labelSize, "XYZ")
    ROOT.gStyle.SetTextSize(labelSize)
    ROOT.gStyle.SetStatFont(font)
    ROOT.gStyle.SetStatFontSize(statSize)
 
    ROOT.TGaxis.SetMaxDigits(4)
 

_th1IncludeOnlyBins()

def plotting._th1IncludeOnlyBins (   histos,   xbinlabels  )

private

Definition at line 744 of file plotting.py.

def _th1IncludeOnlyBins(histos, xbinlabels):
    histos_new = []
    for h in histos:
        h_new = h.Clone(h.GetName()+"_xbinlabels")
        h_new.SetBins(len(xbinlabels), h.GetBinLowEdge(1), h.GetBinLowEdge(1)+len(xbinlabels))
        for i, label in enumerate(xbinlabels):
            bin = h.GetXaxis().FindFixBin(label)
            if bin >= 0:
                h_new.SetBinContent(i+1, h.GetBinContent(bin))
                h_new.SetBinError(i+1, h.GetBinError(bin))
            else:
                h_new.SetBinContent(i+1, 0)
                h_new.SetBinError(i+1, 0)
        histos_new.append(h_new)
    return histos_new
 
 

Referenced by trackingPlots.TrackingSeedingLayerTable.draw(), and plotting.Plot.draw().

_th1RemoveEmptyBins()

def plotting._th1RemoveEmptyBins (   histos,   xbinlabels  )

private

Definition at line 607 of file plotting.py.

def _th1RemoveEmptyBins(histos, xbinlabels):
    binsToRemove = set()
    for b in range(1, histos[0].GetNbinsX()+1):
        binEmpty = True
        for h in histos:
            if h.GetBinContent(b) > 0:
                binEmpty = False
                break
        if binEmpty:
            binsToRemove.add(b)
 
    if len(binsToRemove) > 0:
        # filter xbinlabels
        xbinlab_new = []
        for i in range(len(xbinlabels)):
            if (i+1) not in binsToRemove:
                xbinlab_new.append(xbinlabels[i])
        xbinlabels = xbinlab_new
 
        # filter histogram bins
        histos_new = []
        for h in histos:
            values = []
            for b in range(1, h.GetNbinsX()+1):
                if b not in binsToRemove:
                    values.append( (h.GetXaxis().GetBinLabel(b), h.GetBinContent(b), h.GetBinError(b)) )
 
            if len(values) > 0:
                h_new = h.Clone(h.GetName()+"_empty")
                h_new.SetBins(len(values), h.GetBinLowEdge(1), h.GetBinLowEdge(1)+len(values))
                for b, (l, v, e) in enumerate(values):
                    h_new.GetXaxis().SetBinLabel(b+1, l)
                    h_new.SetBinContent(b+1, v)
                    h_new.SetBinError(b+1, e)
 
                histos_new.append(h_new)
        histos = histos_new
 
    return (histos, xbinlabels)
 

References FastTimerService_cff.range.

Referenced by trackingPlots.TrackingSeedingLayerTable.draw().

_th1ToOrderedDict()

def plotting._th1ToOrderedDict (   th1,   renameBin = None  )

private

Definition at line 100 of file plotting.py.

def _th1ToOrderedDict(th1, renameBin=None):
    values = collections.OrderedDict()
    for i in range(1, th1.GetNbinsX()+1):
        binLabel = th1.GetXaxis().GetBinLabel(i)
        if renameBin is not None:
            binLabel = renameBin(binLabel)
        values[binLabel] = (th1.GetBinContent(i), th1.GetBinError(i))
    return values
 

References FastTimerService_cff.range.

Referenced by trackingPlots.TrackingSummaryTable.create(), and plotting.AggregateBins.create().

_th2RemoveEmptyBins()

def plotting._th2RemoveEmptyBins (   histos,   xbinlabels,   ybinlabels  )

private

Definition at line 647 of file plotting.py.

def _th2RemoveEmptyBins(histos, xbinlabels, ybinlabels):
    xbinsToRemove = set()
    ybinsToRemove = set()
    for ih, h in enumerate(histos):
        for bx in range(1, h.GetNbinsX()+1):
            binEmpty = True
            for by in range(1, h.GetNbinsY()+1):
                if h.GetBinContent(bx, by) > 0:
                    binEmpty = False
                    break
            if binEmpty:
                xbinsToRemove.add(bx)
            elif ih > 0:
                xbinsToRemove.discard(bx)
 
        for by in range(1, h.GetNbinsY()+1):
            binEmpty = True
            for bx in range(1, h.GetNbinsX()+1):
                if h.GetBinContent(bx, by) > 0:
                    binEmpty = False
                    break
            if binEmpty:
                ybinsToRemove.add(by)
            elif ih > 0:
                ybinsToRemove.discard(by)
 
    if len(xbinsToRemove) > 0 or len(ybinsToRemove) > 0:
        xbinlabels_new = []
        xbins = []
        for b in range(1, len(xbinlabels)+1):
            if b not in xbinsToRemove:
                xbinlabels_new.append(histos[0].GetXaxis().GetBinLabel(b))
                xbins.append(b)
        xbinlabels = xbinlabels_new
        ybinlabels_new = []
        ybins = []
        for b in range(1, len(ybinlabels)+1):
            if b not in ybinsToRemove:
                ybinlabels.append(histos[0].GetYaxis().GetBinLabel(b))
                ybins.append(b)
        ybinlabels = xbinlabels_new
 
        histos_new = []
        if len(xbinlabels) == 0 or len(ybinlabels) == 0:
            return (histos_new, xbinlabels, ybinlabels)
        for h in histos:
            h_new = ROOT.TH2F(h.GetName()+"_empty", h.GetTitle(), len(xbinlabels),0,len(xbinlabels), len(ybinlabels),0,len(ybinlabels))
            for b, l in enumerate(xbinlabels):
                h_new.GetXaxis().SetBinLabel(b+1, l)
            for b, l in enumerate(ybinlabels):
                h_new.GetYaxis().SetBinLabel(b+1, l)
 
            for ix, bx in enumerate(xbins):
                for iy, by in enumerate(ybins):
                    h_new.SetBinContent(ix+1, iy+1, h.GetBinContent(bx, by))
                    h_new.SetBinError(ix+1, iy+1, h.GetBinError(bx, by))
            histos_new.append(h_new)
        histos = histos_new
    return (histos, xbinlabels, ybinlabels)
 

References FastTimerService_cff.range.

Variable Documentation

_gr

plotting._gr

private

Definition at line 243 of file plotting.py.

_plotStylesColor

plotting._plotStylesColor

private

Definition at line 1184 of file plotting.py.

_plotStylesMarker

plotting._plotStylesMarker

private

Definition at line 1185 of file plotting.py.

_ratio

plotting._ratio

private

Definition at line 203 of file plotting.py.

_ratioYTitle

plotting._ratioYTitle

private

Definition at line 19 of file plotting.py.

_th1

plotting._th1

private

Definition at line 195 of file plotting.py.

_uncertainty

plotting._uncertainty

private

Definition at line 196 of file plotting.py.

_xerrshigh

plotting._xerrshigh

private

Definition at line 247 of file plotting.py.

_xerrslow

plotting._xerrslow

private

Definition at line 246 of file plotting.py.

_xvalues

plotting._xvalues

private

Definition at line 245 of file plotting.py.

_yerrshigh

plotting._yerrshigh

private

Definition at line 249 of file plotting.py.

_yerrslow

plotting._yerrslow

private

Definition at line 250 of file plotting.py.

_yvalues

plotting._yvalues

private

Definition at line 248 of file plotting.py.

IgnoreCommandLineOptions

plotting.IgnoreCommandLineOptions

Definition at line 14 of file plotting.py.

verbose

plotting.verbose

Definition at line 18 of file plotting.py.