Public Member Functions
def	__init__ (self, name, histoName, mapping, normalizeTo=None, scale=None, renameBin=None, ignoreMissingBins=False, minExistingBins=None, originalOrder=False, reorder=None)

def	__str__ (self)

def	create (self, tdirectory)

Private Attributes
	_histoName

	_ignoreMissingBins

	_mapping

	_minExistingBins

	_name

	_normalizeTo

	_originalOrder

	_renameBin

	_reorder

	_scale

Detailed Description

Class to create a histogram by aggregating bins of another histogram to a bin of the resulting histogram.

Definition at line 947 of file plotting.py.

Constructor & Destructor Documentation

def plotting.AggregateBins.__init__	(	self,
		name,
		histoName,
		mapping,
		normalizeTo = `None`,
		scale = `None`,
		renameBin = `None`,
		ignoreMissingBins = `False`,
		minExistingBins = `None`,
		originalOrder = `False`,
		reorder = `None`
	)

Constructor.

Arguments:
name      -- String for the name of the resulting histogram
histoName -- String for the name of the source histogram
mapping   -- Dictionary for mapping the bins (see below)

Keyword arguments:
normalizeTo -- Optional string of a bin label in the source histogram. If given, all bins of the resulting histogram are divided by the value of this bin.
scale       -- Optional number for scaling the histogram (passed to ROOT.TH1.Scale())
renameBin   -- Optional function (string -> string) to rename the bins of the input histogram
originalOrder -- Boolean for using the order of bins in the histogram (default False)
reorder     -- Optional function to reorder the bins

Mapping structure (mapping):

Dictionary (you probably want to use collections.OrderedDict)
should be a mapping from the destination bin label to a list
of source bin labels ("dst -> [src]").

Definition at line 949 of file plotting.py.

     def __init__(self, name, histoName, mapping, normalizeTo=None, scale=None, renameBin=None, ignoreMissingBins=False, minExistingBins=None, originalOrder=False, reorder=None):
         """Constructor.
 
         Arguments:
         name      -- String for the name of the resulting histogram
         histoName -- String for the name of the source histogram
         mapping   -- Dictionary for mapping the bins (see below)
 
         Keyword arguments:
         normalizeTo -- Optional string of a bin label in the source histogram. If given, all bins of the resulting histogram are divided by the value of this bin.
         scale       -- Optional number for scaling the histogram (passed to ROOT.TH1.Scale())
         renameBin   -- Optional function (string -> string) to rename the bins of the input histogram
         originalOrder -- Boolean for using the order of bins in the histogram (default False)
         reorder     -- Optional function to reorder the bins
 
         Mapping structure (mapping):
 
         Dictionary (you probably want to use collections.OrderedDict)
         should be a mapping from the destination bin label to a list
         of source bin labels ("dst -> [src]").
         """
         self._name = name
         self._histoName = histoName
         self._mapping = mapping
         self._normalizeTo = normalizeTo
         self._scale = scale
         self._renameBin = renameBin
         self._ignoreMissingBins = ignoreMissingBins
         self._minExistingBins = minExistingBins
         self._originalOrder = originalOrder
         self._reorder = reorder
         if self._originalOrder and self._reorder is not None:
             raise Exception("reorder is not None and originalOrder is True, please set only one of them")
 

Member Function Documentation

def plotting.AggregateBins.__str__ ( self )

String representation, returns the name

Definition at line 983 of file plotting.py.

References TrackerHitsObject._name, FP420HitsObject._name, PGeometricDet::Item._name, LikelihoodSpecies._name, TrackingRecHitAlgorithm._name, LikelihoodPdfProduct._name, Logger._name, hcaldqm::DQModule._name, LikelihoodPdf._name, citk::IsolationConeDefinitionBase._name, DrellYanValidation._name, WValidation._name, hcaldqm::flag::Flag._name, hcaldqm::quantity::Quantity._name, HistoParams< T >._name, GeometricTimingDetExtra._name, CutApplicatorBase._name, GeometricDetExtra._name, HistoParams< TH2F >._name, HistoParams< TProfile2D >._name, Vispa.Views.PropertyView.Property._name, SequenceTypes.SequencePlaceholder._name, plotting.Subtract._name, plotting.Transform._name, plotting.FakeDuplicate._name, plotting.CutEfficiency._name, plotting.AggregateBins._name, and SequenceTypes.TaskPlaceholder._name.

     def __str__(self):
         """String representation, returns the name"""
         return self._name
 

def plotting.AggregateBins.create	(	self,
		tdirectory
	)

Create and return the histogram from a TDirectory

Definition at line 987 of file plotting.py.

     def create(self, tdirectory):
         """Create and return the histogram from a TDirectory"""
         th1 = _getOrCreateObject(tdirectory, self._histoName)
         if th1 is None:
             return None
 
         binLabels = [""]*len(self._mapping)
         binValues = [None]*len(self._mapping)
 
         # TH1 can't really be used as a map/dict, so convert it here:
         values = _th1ToOrderedDict(th1, self._renameBin)
 
         binIndexOrder = [] # for reordering bins if self._originalOrder is True
         for i, (key, labels) in enumerate(six.iteritems(self._mapping)):
             sumTime = 0.
             sumErrorSq = 0.
             nsum = 0
             for l in labels:
                 try:
                     sumTime += values[l][0]
                     sumErrorSq += values[l][1]**2
                     nsum += 1
                 except KeyError:
                     pass
 
             if nsum > 0:
                 binValues[i] = (sumTime, math.sqrt(sumErrorSq))
             binLabels[i] = key
 
             ivalue = len(values)+1
             if len(labels) > 0:
                 # first label doesn't necessarily exist (especially for
                 # the iteration timing plots), so let's test them all
                 for lab in labels:
                     if lab in values:
                         ivalue = values.keys().index(lab)
                         break
             binIndexOrder.append( (ivalue, i) )
 
         if self._originalOrder:
             binIndexOrder.sort(key=lambda t: t[0])
             tmpVal = []
             tmpLab = []
             for i in range(0, len(binValues)):
                 fromIndex = binIndexOrder[i][1]
                 tmpVal.append(binValues[fromIndex])
                 tmpLab.append(binLabels[fromIndex])
             binValues = tmpVal
             binLabels = tmpLab
         if self._reorder is not None:
             order = self._reorder(tdirectory, binLabels)
             binValues = [binValues[i] for i in order]
             binLabels = [binLabels[i] for i in order]
 
         if self._minExistingBins is not None and (len(binValues)-binValues.count(None)) < self._minExistingBins:
             return None
 
         if self._ignoreMissingBins:
             for i, val in enumerate(binValues):
                 if val is None:
                     binLabels[i] = None
             binValues = [v for v in binValues if v is not None]
             binLabels = [v for v in binLabels if v is not None]
             if len(binValues) == 0:
                 return None
 
         result = ROOT.TH1F(self._name, self._name, len(binValues), 0, len(binValues))
         for i, (value, label) in enumerate(zip(binValues, binLabels)):
             if value is not None:
                 result.SetBinContent(i+1, value[0])
                 result.SetBinError(i+1, value[1])
             result.GetXaxis().SetBinLabel(i+1, label)
 
         if self._normalizeTo is not None:
             bin = th1.GetXaxis().FindBin(self._normalizeTo)
             if bin <= 0:
                 print("Trying to normalize {name} to {binlabel}, which does not exist".format(name=self._name, binlabel=self._normalizeTo))
                 sys.exit(1)
             value = th1.GetBinContent(bin)
             if value != 0:
                 result.Scale(1/value)
 
         if self._scale is not None:
             result.Scale(self._scale)
 
         return result
 