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	PlotFolder
class	PlotGroup
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, 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)
def	_getYmaxWithError (th1)
def	_getYmin (obj)
def	_getYminIgnoreOutlier (th1)
def	_getYminMaxAroundMedian (obj, coverage, coverageRange=None)
def	_modifyPadForRatio (pad, ratioFactor)
def	_setStyle ()
def	_th1ToOrderedDict (th1, renameBin=None)

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

Function Documentation

def plotting._calculateRatios (   histos,   ratioUncertainty = False  )

private

Calculate the ratios for a list of histograms

Definition at line 144 of file plotting.py.

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

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

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

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

def _drawFrame(pad, bounds, xbinlabels=None, xbinlabelsize=None, xbinlabeloption=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:
        frame = pad.DrawFrame(*bounds)
    else:
        # Special form needed if want to set x axis bin labels
        nbins = len(xbinlabels)
        frame = ROOT.TH1F("hframe"+suffix, "", nbins, bounds[0], bounds[2])
        frame.SetBit(ROOT.TH1.kNoStats)
        frame.SetBit(ROOT.kCanDelete)
        frame.SetMinimum(bounds[1])
        frame.SetMaximum(bounds[3])
        frame.GetYaxis().SetLimits(bounds[1], bounds[3])
        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)

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

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

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

References _getYmax(), _getYmin(), _getYminIgnoreOutlier(), _getYminMaxAroundMedian(), ALCARECOTkAlBeamHalo_cff.filter, hpstanc_transforms.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:
        # 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
        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)
                _ymax = _getYmax(th1)
#                _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 93 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 69 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 45 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 53 of file plotting.py.

References _getObject().

Referenced by 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 352 of file plotting.py.

References hpstanc_transforms.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 336 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 )

private

Definition at line 379 of file plotting.py.

References hpstanc_transforms.max, and harvestTrackValidationPlots.str.

Referenced by _findBoundsY().

def _getYmax(obj):
    if isinstance(obj, ROOT.TH2):
        yaxis = obj.GetYaxis()
        return yaxis.GetBinUpEdge(yaxis.GetLast())
    elif isinstance(obj, ROOT.TH1):
        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 390 of file plotting.py.

References hpstanc_transforms.max.

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

def plotting._getYmin (   obj )

private

Definition at line 368 of file plotting.py.

References min(), and harvestTrackValidationPlots.str.

Referenced by _findBoundsY().

def _getYmin(obj):
    if isinstance(obj, ROOT.TH2):
        yaxis = obj.GetYaxis()
        return yaxis.GetBinLowEdge(yaxis.GetFirst())
    elif isinstance(obj, ROOT.TH1):
        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 393 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 410 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._modifyPadForRatio (   pad,   ratioFactor  )

private

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

def plotting._setStyle ( )

private

Definition at line 17 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._th1ToOrderedDict (   th1,   renameBin = None  )

private

Definition at line 96 of file plotting.py.

Referenced by plotting.AggregateBins.create(), and trackingPlots.TrackingSummaryTable.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

Variable Documentation

plotting._gr

private

Definition at line 239 of file plotting.py.

plotting._plotStylesColor

private

Definition at line 1007 of file plotting.py.

plotting._plotStylesMarker

private

Definition at line 1008 of file plotting.py.

plotting._ratio

private

Definition at line 199 of file plotting.py.

plotting._th1

private

Definition at line 191 of file plotting.py.

plotting._uncertainty

private

Definition at line 192 of file plotting.py.

plotting._xerrshigh

private

Definition at line 243 of file plotting.py.

plotting._xerrslow

private

Definition at line 242 of file plotting.py.

plotting._xvalues

private

Definition at line 241 of file plotting.py.

plotting._yerrshigh

private

Definition at line 245 of file plotting.py.

plotting._yerrslow

private

Definition at line 246 of file plotting.py.

plotting._yvalues

private

Definition at line 244 of file plotting.py.

plotting.IgnoreCommandLineOptions

Definition at line 10 of file plotting.py.

plotting.ratioYTitle

Definition at line 15 of file plotting.py.

plotting.verbose

Definition at line 14 of file plotting.py.