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, 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

def plotting._calculateRatios (   histos,   ratioUncertainty = False  )

private

Calculate the ratios for a list of histograms

Definition at line 145 of file plotting.py.

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

Referenced by ntuplePlotting.drawSingle().

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 xrange(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):
            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]
    ref = wrappers[0]

    wrappers_bins = []
    ref_bins = [ref.xvalues(b) for b in xrange(ref.begin(), ref.end())]
    for w in wrappers:
        wrappers_bins.append(findBins(w, ref_bins))

    for i, bin in enumerate(xrange(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

def plotting._copyStyle (   src,   dst  )

private

Definition at line 1664 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)())

def plotting._createCanvas (   name,   width,   height  )

private

Definition at line 106 of file plotting.py.

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

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

def plotting._drawFrame (   pad,   bounds,   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:
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 1183 of file plotting.py.

def _drawFrame(pad, bounds, 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:
    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.SetBit(ROOT.TH1.kNoStats)
        frame.SetBit(ROOT.kCanDelete)
        frame.Draw("")

        xaxis = frame.GetXaxis()
        for i in xrange(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

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 455 of file plotting.py.

References _findBoundsY(), _getXmax(), _getXmin(), ALCARECOTkAlBeamHalo_cff.filter, SiStripPI.max, min(), and harvestTrackValidationPlots.str.

Referenced by ntuplePlotting.drawSingle().

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 = filter(lambda h: h is not None, xmins)
        xmaxs = filter(lambda h: h is not None, xmaxs)

        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 = filter(lambda x: x<=xm, xmin)
                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 = filter(lambda x: x>xm, xmax)
                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)

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 523 of file plotting.py.

References _getYmax(), _getYmin(), _getYminIgnoreOutlier(), _getYminMaxAroundMedian(), ALCARECOTkAlBeamHalo_cff.filter, SiStripPI.max, min(), and harvestTrackValidationPlots.str.

Referenced by _findBounds().

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 = filter(lambda y: y<=ym, ymin)
            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 = filter(lambda y: y>ym, ymax)
            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)

def plotting._getDirectory (   args,   kwargs  )

private

Definition at line 94 of file plotting.py.

References _getDirectoryDetailed().

Referenced by plotting.PlotterTableItem.create().

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

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

private

Get TDirectory from TFile.

Definition at line 70 of file plotting.py.

References join().

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

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

def plotting._getObject (   tdirectory,   name  )

private

Definition at line 46 of file plotting.py.

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

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

def plotting._getOrCreateObject (   tdirectory,   nameOrCreator  )

private

Definition at line 54 of file plotting.py.

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().

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

def plotting._getXmax (   obj,   limitToNonZeroContent = False  )

private

Definition at line 353 of file plotting.py.

References SiStripPI.max, and harvestTrackValidationPlots.str.

Referenced by _findBounds().

def _getXmax(obj, limitToNonZeroContent=False):
    if isinstance(obj, ROOT.TH1):
        xaxis = obj.GetXaxis()
        if limitToNonZeroContent:
            for i in xrange(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 xrange(0, obj.GetN())])
        return m*1.1 if m > 0 else m*0.9
    raise Exception("Unsupported type %s" % str(obj))

def plotting._getXmin (   obj,   limitToNonZeroContent = False  )

private

Definition at line 337 of file plotting.py.

References min(), and harvestTrackValidationPlots.str.

Referenced by _findBounds().

def _getXmin(obj, limitToNonZeroContent=False):
    if isinstance(obj, ROOT.TH1):
        xaxis = obj.GetXaxis()
        if limitToNonZeroContent:
            for i in xrange(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 xrange(0, obj.GetN())])
        return m*0.9 if m > 0 else m*1.1
    raise Exception("Unsupported type %s" % str(obj))

def plotting._getYmax (   obj,   limitToNonZeroContent = False  )

private

Definition at line 384 of file plotting.py.

References SiStripPI.max, and harvestTrackValidationPlots.str.

Referenced by _findBoundsY().

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 xrange(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 xrange(0, obj.GetN())])
        return m*1.1 if m > 0 else m*0.9
    raise Exception("Unsupported type %s" % str(obj))

def plotting._getYmaxWithError (   th1 )

private

Definition at line 399 of file plotting.py.

References SiStripPI.max.

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

def plotting._getYmin (   obj,   limitToNonZeroContent = False  )

private

Definition at line 369 of file plotting.py.

References min(), and harvestTrackValidationPlots.str.

Referenced by _findBoundsY().

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 xrange(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 xrange(0, obj.GetN())])
        return m*0.9 if m > 0 else m*1.1
    raise Exception("Unsupported type %s" % str(obj))

def plotting._getYminIgnoreOutlier (   th1 )

private

Definition at line 402 of file plotting.py.

References ALCARECOTkAlBeamHalo_cff.filter, and createfilelist.int.

Referenced by _findBoundsY().

def _getYminIgnoreOutlier(th1):
    yvals = filter(lambda n: n>0, [th1.GetBinContent(i) for i in xrange(1, th1.GetNbinsX()+1)])
    yvals.sort()
    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 xrange(0, ind_min):
        if yvals[i] > 0.1*min_val:
            return yvals[i]

    return min_val

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

private

Definition at line 419 of file plotting.py.

References ALCARECOTkAlBeamHalo_cff.filter, createfilelist.int, and harvestTrackValidationPlots.str.

Referenced by _findBoundsY().

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 xrange(1, obj.GetNbinsX()+1) if inRange2(obj.GetXaxis().GetBinLowEdge(i), obj.GetXaxis().GetBinUpEdge(i))]
        yvals = filter(lambda x: x != 0, yvals)
    elif isinstance(obj, ROOT.TGraph) or isinstance(obj, ROOT.TGraph2D):
        yvals = [obj.GetY()[i] for i in xrange(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])

def plotting._mergeBinLabels (   labelsAll )

private

Definition at line 709 of file plotting.py.

References SiStripPI.max.

Referenced by _mergeBinLabelsX(), and _mergeBinLabelsY().

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

def plotting._mergeBinLabelsX (   histos )

private

Definition at line 703 of file plotting.py.

References _mergeBinLabels().

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

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

def plotting._mergeBinLabelsY (   histos )

private

Definition at line 706 of file plotting.py.

References _mergeBinLabels().

Referenced by plotting.Plot.draw().

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

def plotting._modifyPadForRatio (   pad,   ratioFactor  )

private

Definition at line 116 of file plotting.py.

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

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))

def plotting._setStyle ( )

private

Definition at line 18 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)

def plotting._th1IncludeOnlyBins (   histos,   xbinlabels  )

private

Definition at line 740 of file plotting.py.

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

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

def plotting._th1RemoveEmptyBins (   histos,   xbinlabels  )

private

Definition at line 603 of file plotting.py.

Referenced by trackingPlots.TrackingSeedingLayerTable.draw().

def _th1RemoveEmptyBins(histos, xbinlabels):
    binsToRemove = set()
    for b in xrange(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 xrange(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 xrange(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)

def plotting._th1ToOrderedDict (   th1,   renameBin = None  )

private

Definition at line 97 of file plotting.py.

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

def _th1ToOrderedDict(th1, renameBin=None):
    values = collections.OrderedDict()
    for i in xrange(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

def plotting._th2RemoveEmptyBins (   histos,   xbinlabels,   ybinlabels  )

private

Definition at line 643 of file plotting.py.

def _th2RemoveEmptyBins(histos, xbinlabels, ybinlabels):
    xbinsToRemove = set()
    ybinsToRemove = set()
    for ih, h in enumerate(histos):
        for bx in xrange(1, h.GetNbinsX()+1):
            binEmpty = True
            for by in xrange(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 xrange(1, h.GetNbinsY()+1):
            binEmpty = True
            for bx in xrange(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 xrange(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 xrange(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)

Variable Documentation

plotting._gr

private

Definition at line 240 of file plotting.py.

plotting._plotStylesColor

private

Definition at line 1180 of file plotting.py.

plotting._plotStylesMarker

private

Definition at line 1181 of file plotting.py.

plotting._ratio

private

Definition at line 200 of file plotting.py.

plotting._ratioYTitle

private

Definition at line 16 of file plotting.py.

plotting._th1

private

Definition at line 192 of file plotting.py.

plotting._uncertainty

private

Definition at line 193 of file plotting.py.

plotting._xerrshigh

private

Definition at line 244 of file plotting.py.

plotting._xerrslow

private

Definition at line 243 of file plotting.py.

plotting._xvalues

private

Definition at line 242 of file plotting.py.

plotting._yerrshigh

private

Definition at line 246 of file plotting.py.

plotting._yerrslow

private

Definition at line 247 of file plotting.py.

plotting._yvalues

private

Definition at line 245 of file plotting.py.

plotting.IgnoreCommandLineOptions

Definition at line 11 of file plotting.py.

plotting.verbose

Definition at line 15 of file plotting.py.