Source code for rootpy.plotting.views


Folder "View" Classes

These classes wrap Directories and perform automatic actions
to Histograms retrieved from them.  The different views can be composited and

Summary of views:

- ScaleView: scale histogram normalization
- NormalizeView: normalize histograms
- SumView: sum histograms from different folders together
- StyleView: apply a style to histograms
- StackView: build THStacks using histograms from different folders
- TitleView: change the title of histograms
- FunctorView: apply a arbitrary transformation function to the histograms
- MultiFunctorView: apply a arbitrary transformation function to a collection
  of histograms
- SubdirectoryView: A view of a subdirectory, which maintains the same view as
  the base.

Example use case

One has a ROOT file with the following content::


and wants to do the following:

1. Merge the two data taking periods together
2. Scale the Z, WZ, and ZZ simulated results to the appropriate int. lumi.
3. Combine WZ and ZZ into a single diboson sample
4. Apply different colors to the MC samples
5. Make a Stack of the expected yields from different simulated processes

This example can be tested by running::

    python -m rootpy.plotting.views

>>> # Mock up the example test case
>>> import as io
>>> # We have to keep these, to make sure PyROOT doesn't garbage collect them
>>> keep = []
>>> zjets_dir = io.Directory('zjets', 'Zjets directory')
>>> zz_dir = io.Directory('zz', 'ZZ directory')
>>> wz_dir = io.Directory('wz', 'WZ directory')
>>> data2010_dir = io.Directory('data2010', 'data2010 directory')
>>> data2011_dir = io.Directory('data2011', 'data2011 directory')
>>> # Make the Zjets case
>>> _ =
>>> zjets_hist = ROOT.TH1F("mutau_mass", "Mu-Tau mass", 100, 0, 100)
>>> zjets_hist.FillRandom('gaus', 5000)
>>> keep.append(zjets_hist)
>>> # Make the ZZ case
>>> _ =
>>> zz_hist = ROOT.TH1F("mutau_mass", "Mu-Tau mass", 100, 0, 100)
>>> zz_hist.FillRandom('gaus', 5000)
>>> keep.append(zz_hist)
>>> # Make the WZ case
>>> _ =
>>> wz_hist = ROOT.TH1F("mutau_mass", "Mu-Tau mass", 100, 0, 100)
>>> wz_hist.FillRandom('gaus', 5000)
>>> keep.append(wz_hist)
>>> # Make the 2010 data case
>>> _ =
>>> data2010_hist = ROOT.TH1F("mutau_mass", "Mu-Tau mass", 100, 0, 100)
>>> data2010_hist.FillRandom('gaus', 30)
>>> keep.append(data2010_hist)
>>> # Make the 2011 data case
>>> _ =
>>> data2011_hist = ROOT.TH1F("mutau_mass", "Mu-Tau mass", 100, 0, 100)
>>> data2011_hist.FillRandom('gaus', 51)
>>> keep.append(data2011_hist)


We can merge the two data periods into a single case using a SumView.

>>> data = SumView(data2010_dir, data2011_dir)
>>> data_hist = data.Get("mutau_mass")
>>> data_hist.Integral()
>>> data_hist.Integral() == data2010_hist.Integral() + data2011_hist.Integral()


The simulated results (Z & diboson) can be scaled to the expected integrated
luminosity using ScaleViews.

>>> zjets = ScaleView(zjets_dir, 0.01)
>>> zjets_hist = zjets.Get("mutau_mass")
>>> abs(zjets_hist.Integral() - 50.0) < 1e-5
>>> # Scale the diboson contribution
>>> zz = ScaleView(zz_dir, 0.001)
>>> wz = ScaleView(wz_dir, 0.003)

Combining views

The dibosons individually are tiny, let's put them together using a SumView.
Note that this operation nests two ScaleViews into a SumView.

>>> dibosons = SumView(zz, wz)
>>> # We expect 5000*0.001 + 5000*0.003 = 20 events
>>> dibosons_hist = dibosons.Get("mutau_mass")
>>> abs(dibosons_hist.Integral() - 20) < 1e-4


A style view automatically applies a style to retrieved Plottable objects.
The style is specified using the same arguments as the Plottable.decorate.
Let's make the Z background red and the diboson background blue.

>>> zjets = StyleView(zjets, fillcolor=ROOT.EColor.kRed)
>>> dibosons = StyleView(dibosons, fillcolor=ROOT.EColor.kBlue)
>>> zjets_hist = zjets.Get("mutau_mass")
>>> zjets_hist.GetFillColor() == ROOT.EColor.kRed
>>> dibosons_hist = dibosons.Get("mutau_mass")
>>> dibosons_hist.GetFillColor() == ROOT.EColor.kBlue


The StackView combines multiple items into a HistStack.  In our example
we stack the SM backgrounds to compare to the data.

>>> sm_bkg = StackView(zjets, dibosons)
>>> sm_bkg_stack = sm_bkg.Get("mutau_mass")
>>> '%0.0f' % sm_bkg_stack.Integral()

Looks like we have an excess of 11 events - must be the Higgs.

Other Examples


The normalization view renormalizes histograms to a given value (default 1.0).
Here is an example of using the NormalizeView to compare the Z and diboson

>>> z_shape = NormalizeView(zjets)
>>> z_shape_hist = z_shape.Get("mutau_mass")
>>> abs(1 - z_shape_hist.Integral()) < 1e-5
>>> # Let's compare the shapes using a HistStack, using the "nostack" option.
>>> diboson_shape = NormalizeView(dibosons)
>>> shape_comparison = StackView(z_shape, diboson_shape)
>>> # To draw the comparison:
>>> # shape_comparison.Get("mutau_mass").Draw('nostack')


FunctorView allows you to apply an arbitrary transformation to the object.
Here we show how you can change the axis range for all histograms in a

>>> rebin = lambda x: x.Rebin(2)
>>> zjets_rebinned = FunctorView(zjets, rebin)
>>> zjets.Get("mutau_mass").GetNbinsX()
>>> zjets_rebinned.Get("mutau_mass").GetNbinsX()

The functor doesn't have to return a histogram.

>>> mean_getter = lambda x: x.GetMean()
>>> mean = zjets.Get("mutau_mass").GetMean()
>>> zjets_mean = FunctorView(zjets, mean_getter)
>>> zjets_mean.Get("mutau_mass") == mean


MultiFunctorView is similar except that it operates on a group of histograms.
The functor should take one argument, a *generator* of the sub-objects.

Here's an example to get the integral of the biggest histogram in a set:

>>> biggest_histo = lambda objects: max(y.Integral() for y in objects)
>>> biggest = MultiFunctorView(biggest_histo, zjets, dibosons)
>>> biggest.Get("mutau_mass") == zjets.Get("mutau_mass").Integral()


If you'd like to "cd" into a lower subdirectory, while still maintaining
the same view, use a SubdirectoryView.

>>> basedir = io.Directory('base', 'base directory')
>>> _ =
>>> subdir1 = io.Directory('subdir1', 'subdir directory in 1')
>>> _ =
>>> hist = ROOT.TH1F("mutau_mass", "Mu-Tau mass", 100, 0, 100)
>>> hist.FillRandom('gaus', 2000)
>>> keep.append(hist)
>>> _ =
>>> subdir2 = io.Directory('subdir2', 'subdir directory 2')
>>> _ =
>>> hist = ROOT.TH1F("mutau_mass", "Mu-Tau mass", 100, 0, 100)
>>> hist.FillRandom('gaus', 5000)
>>> keep.append(hist)

The directory structure is now::

Subdirectory views work on top of other views.

>>> baseview = ScaleView(basedir, 0.1)
>>> subdir1view = SubdirectoryView(baseview, 'subdir1')
>>> subdir2view = SubdirectoryView(baseview, 'subdir2')
>>> histo1 = subdir1view.Get('mutau_mass')
>>> histo2 = subdir2view.Get('mutau_mass')
>>> exp_histo1 = baseview.Get("subdir1/mutau_mass")
>>> exp_histo2 = baseview.Get("subdir2/mutau_mass")
>>> def equivalent(h1, h2):
...     return (abs(h1.GetMean() - h2.GetMean()) < 1e-4 and
...             abs(h1.GetRMS() - h2.GetRMS()) < 1e-4 and
...             abs(h1.Integral() - h2.Integral()) < 1e-4)
>>> equivalent(exp_histo1, histo1)
>>> equivalent(exp_histo2, histo2)
>>> equivalent(histo1, histo2)

from __future__ import absolute_import

import os
import ROOT

from .base import Plottable
from .hist import HistStack
from import Directory, DoesNotExist

__all__ = [

class _FolderView(object):
    Abstract view of an individual folder

    Provides one interface: Get(path) which returns a modified version
    of whatever exists at path.  Subclasses should define::

        apply_view(self, obj)

    which should return the modified [object] as necessary.

    The subclass can get access to the queried path via the self.getting
    def __init__(self, directory):
        ''' Initialize with the directory to be wrapped '''
        self.dir = directory

    def path(self):
        ''' Get the path of the wrapped folder '''
        if isinstance(self.dir, Directory):
            return self.dir._path
        elif isinstance(self.dir, ROOT.TDirectory):
            return self.dir.GetPath()
        elif isinstance(self.dir, _FolderView):
            return self.dir.path()
            return str(self.dir)

    def __str__(self):
        return "{0}('{1}')".format(self.__class__.__name__, self.path())

    def Get(self, path):
        ''' Get the (modified) object from path '''
        self.getting = path
            obj = self.dir.Get(path)
            return self.apply_view(obj)
        except DoesNotExist as dne:
            #print dir(dne)
            raise DoesNotExist(
                str(dne) + "[{0}]".format(self.__class__.__name__))

class _MultiFolderView(object):
    Abstract view of a collection of folders

    Applies some type of "merge" operation to the result of the get from each
    folder.  Subclasses should define::

        merge_views(self, objects)

    which takes a *generator* of objects returns a merged object.

    The subclass can get access to the queried path via the self.getting
    def __init__(self, *directories):
        self.dirs = directories

    def __str__(self):
        return "{0}({1})".format(
            ','.join(str(x) for x in self.dirs))

    def Get(self, path):
        ''' Merge the objects at path in all subdirectories '''
        return self.merge_views(x.Get(path) for x in self.dirs)

[docs]class ScaleView(_FolderView): ''' View of a folder which applies a scaling factor to histograms. ''' def __init__(self, directory, scale_factor): super(ScaleView, self).__init__(directory) self.factor = scale_factor def apply_view(self, obj): if not hasattr(obj, 'Scale'): raise ValueError( "`ScaleView` can't determine how to handle" "an object of type `{0}`; " "it has no `Scale` method".format(type(obj))) clone = obj.Clone() clone.Scale(self.factor) return clone
[docs]class NormalizeView(ScaleView): ''' Normalize histograms to a constant value ''' def __init__(self, directory, normalization=1.0): # Initialize the scale view with a dummy scale factor. # The scale factor is changed dynamically for each histogram. super(NormalizeView, self).__init__(directory, None) self.norm = normalization def apply_view(self, obj): current_norm = obj.Integral() # Update the scale factor (in the base) if current_norm > 0: self.factor = self.norm / current_norm else: self.factor = 0 return super(NormalizeView, self).apply_view(obj)
[docs]class StyleView(_FolderView): ''' View of a folder which applies a style to Plottable objects. The kwargs are passed to Plottable.decorate ''' def __init__(self, directory, **kwargs): super(StyleView, self).__init__(directory) self.kwargs = kwargs def apply_view(self, obj): if not isinstance(obj, Plottable): raise TypeError( "`ScaleView` can't determine how to handle " "an object of type `{0}`; it is not a subclass of " "`Plottable`".format(type(obj))) clone = obj.Clone() clone.decorate(**self.kwargs) return clone
[docs]class TitleView(_FolderView): ''' Override the title of gotten histograms ''' def __init__(self, directory, title): self.title = title super(TitleView, self).__init__(directory) def apply_view(self, obj): clone = obj.Clone() clone.SetTitle(self.title) return clone
[docs]class SumView(_MultiFolderView): ''' Add a collection of histograms together ''' def __init__(self, *directories): super(SumView, self).__init__(*directories) def merge_views(self, objects): output = None for obj in objects: if output is None: output = obj.Clone() else: output += obj return output
[docs]class StackView(_MultiFolderView): ''' Build a HistStack from the input histograms The default draw option that histograms will use is "hist". One can override this for all histograms by passing a string. Individual behavior can be controlled by passing a list of draw options, corresponding to the input directories. In this case the option for all histograms must be specified. The name and title of the HistStack is taken from the first histogram in the list. Normally the histograms will be added to the stack in the order of the constructor. Optionally, one can add them in order of ascending integral by passing the kwarg sorted=True. ''' def __init__(self, *directories, **kwargs): super(StackView, self).__init__(*directories) self.sort = kwargs.get(sorted, False) def merge_views(self, objects): output = None if self.sort: objects = sorted(objects, key=lambda x: x.Integral()) for obj in objects: if output is None: output = HistStack(name=obj.GetName(), title=obj.GetTitle()) output.Add(obj) return output
[docs]class FunctorView(_FolderView): ''' Apply an arbitrary function to the output histogram. The histogram is always cloned before it is passed to the function. ''' def __init__(self, directory, function): self.f = function super(FunctorView, self).__init__(directory) def apply_view(self, obj): clone = obj.Clone() return self.f(clone)
[docs]class MultiFunctorView(_MultiFolderView): ''' Apply an arbitrary function to the output histograms. The function must take one argument, a generator of objects. ''' def __init__(self, f, *directories): self.f = f super(MultiFunctorView, self).__init__(*directories) def merge_views(self, objects): return self.f(objects)
[docs]class PathModifierView(_FolderView): ''' Does some magic to the path User should supply a functor which transforms the path argument passed to Get(...) ''' def __init__(self, dir, path_modifier): self.path_modifier = path_modifier super(PathModifierView, self).__init__(dir) def Get(self, path): newpath = self.path_modifier(path) return super(PathModifierView, self).Get(newpath)
[docs] def apply_view(self, obj): ''' Do nothing ''' return obj
[docs]class SubdirectoryView(PathModifierView): ''' Add some base directories to the path of Get() <subdir> is the directory you want to 'cd' too. ''' def __init__(self, dir, subdirpath): functor = lambda path: os.path.join(subdirpath, path) super(SubdirectoryView, self).__init__(dir, functor)
if __name__ == "__main__": import doctest doctest.testmod()