Main YODA objects¶
The wrappers on the core C++ YODA data types and functions are all defined in the yoda.core module, which is generated semiautomatically by the Cython system. However, they are all available directly in the yoda namespace by virtue of a from yoda.core import * in the yoda package.
 class yoda.core.AnalysisObject¶
AnalysisObject is the base class of the main userfacing objects, such as the Histo, Profile and Scatter classes.
 annotation(self, string k, default=None)¶
Get annotation k from this object (falling back to default if not set).
 annotations¶
AnalysisObject.annotations(self) () > list[str]
A list of all annotation/metadata keys.
 clearAnnotations(self)¶
Clear the annotations dictionary.
 dim¶
AnalysisObject.dim(self) Fill dimension or plot dimension of this object, for fillables and scatters respectively
 dump(self)¶
A human readable representation of this object.
 hasAnnotation(self, string k)¶
Check if this object has annotation k.
 name¶
AnalysisObject.name(self)
Return the histogram name, i.e. the last part of the path (which may be empty).
 path¶
Used for persistence and as a unique identifier. Must begin with a ‘/’ if not the empty string.
 rmAnnotation(self, string k)¶
Remove annotation k from this object.
 setAnnotation(self, string k, v)¶
Set annotation k on this object.
 title¶
Convenient access to the histogram title (optional).
 type¶
AnalysisObject.type(self) String identifier for this type
 class yoda.core.Bin1D_Dbn1D¶
Bin1D_Dbn1D(xlow, xhigh)
1D Bin based on an underlying Dbn1D.
ProfileBin1D(xlow, xhigh)
 merge(self, Bin1D_Dbn1D other)¶
merge(other) > Bin1D_Dbn1D. Merge this bin with another of the same type. Only directly adjacent bins, i.e. those sharing a common edge, can be merged.
 sumWX¶
Bin1D_Dbn1D.sumWX(self)
The sum of weightstimesx: sum(weights * x)
 sumWX2¶
Bin1D_Dbn1D.sumWX2(self)
The sum of weightstimesxsquared: sum(weights * x * x)
 xEdges¶
Bin1D_Dbn1D.xEdges(self) The lower and upper edges.
 xFocus¶
Bin1D_Dbn1D.xFocus(self)
The focus of the bin. If the bin has been filled, then this is the mean fill on this bin. If the bin has not been filled, then the focus is the midpoint of the bin.
 xMax¶
Bin1D_Dbn1D.xMax(self) The upper bin edge.
 xMean¶
Bin1D_Dbn1D.xMean(self) The mean of the xvalues that have filled the bin.
 xMid¶
Bin1D_Dbn1D.xMid(self) The midpoint of the bin.
 xMin¶
Bin1D_Dbn1D.xMin(self) The lower bin edge.
 xRMS¶
Bin1D_Dbn1D.xRMS(self)
The rootmeansquare of the xvalues that have filled the bin.
 xStdDev¶
Bin1D_Dbn1D.xStdDev(self)
The standard deviation of the xvalues that have filled the bin.
 xStdErr¶
Bin1D_Dbn1D.xStdErr(self)
The standard error of the xvalues that have filled the bin.
 xVariance¶
Bin1D_Dbn1D.xVariance(self)
The variance of the xvalues that have filled the bin.
 xWidth¶
Bin1D_Dbn1D.xWidth(self) The width of the bin.
 class yoda.core.Bin1D_Dbn2D¶
Bin1D_Dbn2D(xlow, xhigh)
1D Bin based on an underlying Dbn2D.
ProfileBin1D(xlow, xhigh)
 merge(self, Bin1D_Dbn2D other)¶
merge(other) > Bin1D_Dbn2D. Merge this bin with another of the same type. Only directly adjacent bins, i.e. those sharing a common edge, can be merged.
 sumWX¶
Bin1D_Dbn2D.sumWX(self)
The sum of weightstimesx: sum(weights * x)
 sumWX2¶
Bin1D_Dbn2D.sumWX2(self)
The sum of weightstimesxsquared: sum(weights * x * x)
 xEdges¶
Bin1D_Dbn2D.xEdges(self) The lower and upper edges.
 xFocus¶
Bin1D_Dbn2D.xFocus(self)
The focus of the bin. If the bin has been filled, then this is the mean fill on this bin. If the bin has not been filled, then the focus is the midpoint of the bin.
 xMax¶
Bin1D_Dbn2D.xMax(self) The upper bin edge.
 xMean¶
Bin1D_Dbn2D.xMean(self) The mean of the xvalues that have filled the bin.
 xMid¶
Bin1D_Dbn2D.xMid(self) The midpoint of the bin.
 xMin¶
Bin1D_Dbn2D.xMin(self) The lower bin edge.
 xRMS¶
Bin1D_Dbn2D.xRMS(self)
The rootmeansquare of the xvalues that have filled the bin.
 xStdDev¶
Bin1D_Dbn2D.xStdDev(self)
The standard deviation of the xvalues that have filled the bin.
 xStdErr¶
Bin1D_Dbn2D.xStdErr(self)
The standard error of the xvalues that have filled the bin.
 xVariance¶
Bin1D_Dbn2D.xVariance(self)
The variance of the xvalues that have filled the bin.
 xWidth¶
Bin1D_Dbn2D.xWidth(self) The width of the bin.
 class yoda.core.Bin2D_Dbn2D¶
Bin2D_Dbn2D(xlow, xhigh, ylow, yhigh) 2D Bin class templated on a Dbn2D
 adjacentTo(self, Bin2D_Dbn2D other)¶
 sumWX¶
Bin2D_Dbn2D.sumWX(self)
 sumWX2¶
Bin2D_Dbn2D.sumWX2(self)
 sumWXY¶
Bin2D_Dbn2D.sumWXY(self)
 sumWY¶
Bin2D_Dbn2D.sumWY(self)
 sumWY2¶
Bin2D_Dbn2D.sumWY2(self)
 xEdges¶
Bin2D_Dbn2D.xEdges(self)
The lower and upper x edges.
 xFocus¶
Bin2D_Dbn2D.xFocus(self) Focus of the bin in x
 xMax¶
Bin2D_Dbn2D.xMax(self) High edge in x.
 xMean¶
Bin2D_Dbn2D.xMean(self)
 xMid¶
Bin2D_Dbn2D.xMid(self) Geometric centre of the bin in x
 xMin¶
Bin2D_Dbn2D.xMin(self) Low edge in x.
 xRMS¶
Bin2D_Dbn2D.xRMS(self)
 xStdDev¶
Bin2D_Dbn2D.xStdDev(self)
 xStdErr¶
Bin2D_Dbn2D.xStdErr(self)
 xVariance¶
Bin2D_Dbn2D.xVariance(self)
 xWidth¶
Bin2D_Dbn2D.xWidth(self) Width of the bin in x
 xyEdges¶
Bin2D_Dbn2D.xyEdges(self)
The lower and upper x,y edge pairs.
 xyFocus¶
Bin2D_Dbn2D.xyFocus(self) The focus of the bin in the x and ydimensions
 xyMax¶
Bin2D_Dbn2D.xyMax(self) High edges in x,y.
 xyMean¶
Bin2D_Dbn2D.xyMean(self)
 xyMid¶
Bin2D_Dbn2D.xyMid(self) Geometric centre of the bin
 xyMin¶
Bin2D_Dbn2D.xyMin(self) Low edges in x,y.
 xyRMS¶
Bin2D_Dbn2D.xyRMS(self)
 xyStdDev¶
Bin2D_Dbn2D.xyStdDev(self)
 xyStdErr¶
Bin2D_Dbn2D.xyStdErr(self)
 xyVariance¶
Bin2D_Dbn2D.xyVariance(self)
 xyWidths¶
Bin2D_Dbn2D.xyWidths(self) The widths of this bin in the x and ydimensions.
 yEdges¶
Bin2D_Dbn2D.yEdges(self)
The lower and upper y edges.
 yFocus¶
Bin2D_Dbn2D.yFocus(self) Focus of the bin in y
 yMax¶
Bin2D_Dbn2D.yMax(self) High edge in y.
 yMean¶
Bin2D_Dbn2D.yMean(self)
 yMid¶
Bin2D_Dbn2D.yMid(self) Geometric centre of the bin in y
 yMin¶
Bin2D_Dbn2D.yMin(self) Low edge in y.
 yRMS¶
Bin2D_Dbn2D.yRMS(self)
 yStdDev¶
Bin2D_Dbn2D.yStdDev(self)
 yStdErr¶
Bin2D_Dbn2D.yStdErr(self)
 yVariance¶
Bin2D_Dbn2D.yVariance(self)
 yWidth¶
Bin2D_Dbn2D.yWidth(self) Width of the bin in y
 class yoda.core.Bin2D_Dbn3D¶
Bin2D_Dbn3D(xlow, xhigh, ylow, yhigh) 2D Bin class templated on a Dbn3D
 adjacentTo(self, Bin2D_Dbn3D other)¶
 sumWX¶
Bin2D_Dbn3D.sumWX(self)
 sumWX2¶
Bin2D_Dbn3D.sumWX2(self)
 sumWXY¶
Bin2D_Dbn3D.sumWXY(self)
 sumWY¶
Bin2D_Dbn3D.sumWY(self)
 sumWY2¶
Bin2D_Dbn3D.sumWY2(self)
 xEdges¶
Bin2D_Dbn3D.xEdges(self)
The lower and upper x edges.
 xFocus¶
Bin2D_Dbn3D.xFocus(self) Focus of the bin in x
 xMax¶
Bin2D_Dbn3D.xMax(self) High edge in x.
 xMean¶
Bin2D_Dbn3D.xMean(self)
 xMid¶
Bin2D_Dbn3D.xMid(self) Geometric centre of the bin in x
 xMin¶
Bin2D_Dbn3D.xMin(self) Low edge in x.
 xRMS¶
Bin2D_Dbn3D.xRMS(self)
 xStdDev¶
Bin2D_Dbn3D.xStdDev(self)
 xStdErr¶
Bin2D_Dbn3D.xStdErr(self)
 xVariance¶
Bin2D_Dbn3D.xVariance(self)
 xWidth¶
Bin2D_Dbn3D.xWidth(self) Width of the bin in x
 xyEdges¶
Bin2D_Dbn3D.xyEdges(self)
The lower and upper x,y edge pairs.
 xyFocus¶
Bin2D_Dbn3D.xyFocus(self) The focus of the bin in the x and ydimensions
 xyMax¶
Bin2D_Dbn3D.xyMax(self) High edges in x,y.
 xyMean¶
Bin2D_Dbn3D.xyMean(self)
 xyMid¶
Bin2D_Dbn3D.xyMid(self) Geometric centre of the bin
 xyMin¶
Bin2D_Dbn3D.xyMin(self) Low edges in x,y.
 xyRMS¶
Bin2D_Dbn3D.xyRMS(self)
 xyStdDev¶
Bin2D_Dbn3D.xyStdDev(self)
 xyStdErr¶
Bin2D_Dbn3D.xyStdErr(self)
 xyVariance¶
Bin2D_Dbn3D.xyVariance(self)
 xyWidths¶
Bin2D_Dbn3D.xyWidths(self) The widths of this bin in the x and ydimensions.
 yEdges¶
Bin2D_Dbn3D.yEdges(self)
The lower and upper y edges.
 yFocus¶
Bin2D_Dbn3D.yFocus(self) Focus of the bin in y
 yMax¶
Bin2D_Dbn3D.yMax(self) High edge in y.
 yMean¶
Bin2D_Dbn3D.yMean(self)
 yMid¶
Bin2D_Dbn3D.yMid(self) Geometric centre of the bin in y
 yMin¶
Bin2D_Dbn3D.yMin(self) Low edge in y.
 yRMS¶
Bin2D_Dbn3D.yRMS(self)
 yStdDev¶
Bin2D_Dbn3D.yStdDev(self)
 yStdErr¶
Bin2D_Dbn3D.yStdErr(self)
 yVariance¶
Bin2D_Dbn3D.yVariance(self)
 yWidth¶
Bin2D_Dbn3D.yWidth(self) Width of the bin in y
 class yoda.core.Counter¶
Counter(char *path=’‘, char *title=’‘)
Weight counter. Like a histogram without any axis (and hence only one bin).
Call fill() like with a histogram. Sums of weights can be returned, with val() and err() being shorthand for the sum of weights and its binomial error.
 Counter(path=””, title=””).
 Construct a counter with optional path and title but no bins.
 clone(self)¶
None > Couner. Clone this Counter.
 divideBy(self, Counter other, efficiency=False)¶
 effNumEntries(self)¶
None > float Effective number of times this counter was filled, computed from weights.
 err¶
Counter.err(self) () > float
Binomial uncertainty on the sum of weights filled into this counter.
 fill(self, weight=1.0)¶
([w]) > None. Fill with given optional weight.
 mkScatter(self)¶
None > Scatter1D. Convert this Counter to a Scatter1D, with x representing the value and error.
 numEntries(self)¶
None > int Number of times this counter was filled.
 relErr¶
Counter.relErr(self) () > float
Relative binomial uncertainty on the sum of weights filled into this counter.
 reset(self)¶
None > None. Reset the counter.
 scaleW(self, w)¶
(float) > None. Rescale the weights in this counter by the factor w.
 sumW(self)¶
() > float Sum of weights filled into this counter.
 sumW2(self)¶
() > float Sum of weights filled into this counter.
 val¶
Counter.val(self) () > float
Sum of weights filled into this counter.
 class yoda.core.Dbn0D¶
Dbn0D()
A zerodimensional ‘counter’, used and exposed by Counter.
 copy(self)¶
 effNumEntries¶
Dbn0D.effNumEntries(self) Effective number of entries (for weighted events)
 errW¶
Dbn0D.errW(self) Error on sumW
 fill(self, weight=1.0)¶
(float weight=1.0) > None
Fills the distribution with the given weight at given x.
 numEntries¶
Dbn0D.numEntries(self) The number of entries
 relErrW¶
Dbn0D.relErrW(self) Relative error on sumW
 reset(self)¶
() > None
Reset the distribution counters to the unfilled state.
 scaleW(self, w)¶
(float) > None
Scale the weights by the given factor.
 sumW¶
Dbn0D.sumW(self) sum(weights)
 sumW2¶
Dbn0D.sumW2(self) sum(weights * weights)
 class yoda.core.Dbn1D¶
Dbn1D()
A 1D distribution ‘counter’, used and exposed by 1D histograms and their bins.
 copy(self)¶
 effNumEntries¶
Dbn1D.effNumEntries(self) Effective number of entries (for weighted events)
 errW¶
Dbn1D.errW(self) Error on sumW
 fill(self, x, weight=1.0)¶
(float x, float weight=1.0) > None
Fills the distribution with the given weight at given x.
 mean¶
Dbn1D.xMean(self) Weighted mean of x
 numEntries¶
Dbn1D.numEntries(self) The number of entries
 relErrW¶
Dbn1D.relErrW(self) Relative error on sumW
 reset(self)¶
() > None
Reset the distribution counters to the unfilled state.
 rms¶
Dbn1D.xRMS(self) Weighted root mean squared (RMS) of x
 scaleW(self, w)¶
(float) > None
Scale the weights by the given factor.
 scaleX(self, x)¶
(float) > None
Scale the x dimension by the given factor.
 stdDev¶
Dbn1D.xStdDev(self) Weighted standard deviation of x
 stdErr¶
Dbn1D.xStdErr(self) Weighted standard error on <x>
 sumW¶
Dbn1D.sumW(self) sum(weights)
 sumW2¶
Dbn1D.sumW2(self) sum(weights * weights)
 sumWX¶
Dbn1D.sumWX(self) sum(weights * xs)
 sumWX2¶
Dbn1D.sumWX2(self) sum(weights * xs * xs)
 variance¶
Dbn1D.xVariance(self) Weighted variance of x
 xMean¶
Dbn1D.xMean(self) Weighted mean of x
 xRMS¶
Dbn1D.xRMS(self) Weighted root mean squared (RMS) of x
 xStdDev¶
Dbn1D.xStdDev(self) Weighted standard deviation of x
 xStdErr¶
Dbn1D.xStdErr(self) Weighted standard error on <x>
 xVariance¶
Dbn1D.xVariance(self) Weighted variance of x
 class yoda.core.Dbn2D¶
Dbn2D()
A 2D distribution ‘counter’, used and exposed by 2D histograms and 1D profiles and their bins.
TODO: also provide normal scalar access to quantities like xRMS
 copy(self)¶
 effNumEntries¶
Dbn2D.effNumEntries(self) Effective number of entries (for weighted events)
 errW¶
Dbn2D.errW(self) Error on sumW
 fill(self, x, y, weight=1.0)¶
(x, y, weight=1.0) > None
Fills the distribution with the given weight at given (x, y).
 mean¶
Dbn2D.mean(self) Weighted mean of x
 numEntries¶
Dbn2D.numEntries(self) The number of entries
 relErrW¶
Dbn2D.relErrW(self) Relative error on sumW
 reset(self)¶
() > None
Reset the distribution counters to the unfilled state.
 rms¶
Dbn2D.rms(self) Weighted root mean squared (RMS) of x
 scaleW(self, w)¶
(float) > None
Scale the weights by the given factor.
 scaleX(self, x)¶
(float) > None
Scale the x dimension by the given factor.
 scaleXY(self, x, y)¶
(float, float) > None
Scale the x and y dimensions by the given factors.
 scaleY(self, y)¶
(float) > None
Scale the y dimension by the given factor.
 stdDev¶
Dbn2D.stdDev(self) Weighted standard deviation of x
 stdErr¶
Dbn2D.stdErr(self) Weighted standard error on <x>
 sumW¶
Dbn2D.sumW(self) sum(weights)
 sumW2¶
Dbn2D.sumW2(self) sum(weights * weights)
 sumWX¶
Dbn2D.sumWX(self) sum(weights * xs)
 sumWX2¶
Dbn2D.sumWX2(self) sum(weights * xs * xs)
 sumWXY¶
Dbn2D.sumWXY(self) sum(weights xs * ys)
 sumWY¶
Dbn2D.sumWY(self) sum(weights * ys)
 sumWY2¶
Dbn2D.sumWY2(self) sum(weights * ys * ys)
 variance¶
Dbn2D.variance(self) Weighted variance of x
 class yoda.core.Dbn3D¶
Dbn3D()
A 3D distribution ‘counter’, used and exposed by 2D profiles and their bins.
TODO: also provide normal scalar access to quantities like xRMS
 copy(self)¶
 effNumEntries¶
Dbn3D.effNumEntries(self) Effective number of entries (for weighted events)
 errW¶
Dbn3D.errW(self) Error on sumW
 fill(self, x, y, z, weight=1.0)¶
(x, y, z, weight=1.0) > None
Fills the distribution with the given weight at given (x, y).
 mean¶
Dbn3D.mean(self) Weighted mean of x
 numEntries¶
Dbn3D.numEntries(self) The number of entries
 relErrW¶
Dbn3D.relErrW(self) Relative error on sumW
 reset(self)¶
() > None
Reset the distribution counters to the unfilled state.
 rms¶
Dbn3D.rms(self) Weighted root mean squared (RMS) of x
 scaleW(self, w)¶
(float) > None
Scale the weights by the given factor.
 scaleX(self, x)¶
(float) > None
Scale the x dimension by the given factor.
 scaleXYZ(self, x, y, z)¶
(float, float, float) > None
Scale the x, y and z dimensions by the given factors.
 scaleY(self, y)¶
(float) > None
Scale the y dimension by the given factor.
 scaleZ(self, z)¶
(float) > None
Scale the z dimension by the given factor.
 stdDev¶
Dbn3D.stdDev(self) Weighted standard deviation of x
 stdErr¶
Dbn3D.stdErr(self) Weighted standard error on <x>
 sumW¶
Dbn3D.sumW(self) sum(weights)
 sumW2¶
Dbn3D.sumW2(self) sum(weights * weights)
 sumWX¶
Dbn3D.sumWX(self) sum(weights * xs)
 sumWX2¶
Dbn3D.sumWX2(self) sum(weights * xs * xs)
 sumWXY¶
Dbn3D.sumWXY(self) sum(weights * xs * ys)
 sumWXZ¶
Dbn3D.sumWXZ(self) sum(weights * xs * zs)
 sumWY¶
Dbn3D.sumWY(self) sum(weights * ys)
 sumWY2¶
Dbn3D.sumWY2(self) sum(weights * ys * ys)
 sumWYZ¶
Dbn3D.sumWYZ(self) sum(weights * ys * zs)
 sumWZ¶
Dbn3D.sumWZ(self) sum(weights * zs)
 sumWZ2¶
Dbn3D.sumWZ2(self) sum(weights * zs * zs)
 variance¶
Dbn3D.variance(self) Weighted variance of x
 class yoda.core.Histo1D¶

1D histogram, with distinction between bin areas and heights.
Complete histogram binning is supported, including uniform/regular binning, variablewidth binning, unbinned gaps in the covered range, and under/overflows. Rebinning by integer factors, or by explicit merging of contiguous bins is also supported.
Rescaling of weights and/or the x axis is permitted inplace: the result is still a valid Histo1D. Binningcompatible 1D histograms may be divided, resulting in a Scatter2D since further fills would not be meaningful.
Several sets of arguments are tried by the constructor in the following order.
 Histo1D(path=””, title=””).
 Construct a histogram with optional path and title but no bins.
 Histo1D(nbins, low, high, path=””, title=””)
 Construct a histogram with optional path and title, and nbins bins uniformly distributed between low and high.
 Histo1D(B, path=””, title=””).
 Construct a histogram with optional path and title, from an iterator of bins, B.
 addBin(self, low, high)¶
(low, high) > None. Add a bin.
 addBins(self, edges_or_bins)¶
Add several bins.
 bin(self, i)¶
Get the i’th bin (equivalent to bins[i]
 binAt(self, x)¶
Get the bin containing position x
 binIndexAt(self, x)¶
Get the bin index containing position x
 bins¶
Histo1D.bins(self) Access the ordered bins list.
 clone(self)¶
None > Histo1D. Clone this Histo1D.
 divideBy(self, Histo1D h, efficiency=False)¶
Histo1D > Scatter2D
Divide this histogram by h, returning a Scatter2D. The optional ‘efficiency’ argument, if set True, will use a binomial efficiency treatment of the errors.
 effNumEntries(self, includeoverflows=True)¶
([bool]) > float Effective number of times this histogram was filled, computed from weights, and optionally excluding the overflows.
 fill(self, x, weight=1.0)¶
(x,[w]) > None. Fill with given x value and optional weight.
 fillBin(self, size_t ix, weight=1.0)¶
(ix,[w]) > None. Fill bin ix and optional weight.
 integral(self, includeoverflows=True)¶
([bool]) > float Histogram integral, optionally excluding the overflows.
 integralRange(self, int ia, int ib)¶
(int, int) > float Integral between bins ia..ib inclusive
 integralTo(self, int ia, includeunderflow=True)¶
(int, [bool]) > float Integral up to bin ia inclusive, optionally excluding the underflow
 mergeBins(self, ia, ib)¶
mergeBins(ia, ib) > None. Merge bins from indices ia through ib.
 mkScatter(self, usefocus=False)¶
None > Scatter2D. Convert this Histo1D to a Scatter2D, with y representing bin heights (not sumW) and height errors.
 normalize(self, normto=1.0, includeoverflows=True)¶
(float, bool) > None. Normalize the histogram.
 numBins¶
Histo1D.numBins(self) () > int
Number of bins (not including overflows).
 numEntries(self, includeoverflows=True)¶
([bool]) > int Number of times this histogram was filled, optionally excluding the overflows.
 overflow¶
Histo1D.overflow(self) None > Dbn1D
The Dbn1D representing the overflow distribution.
 rebin(self, arg, **kwargs)¶
(n) > None or ([edges]) > None Merge bins, like rebinBy if an int argument is given; like rebinTo if an iterable is given.
 rebinBy(self, n, begin=0, end=None)¶
(n) > None. Merge every group of n bins together (between begin and end, if specified).
 rebinTo(self, edges)¶
([edges]) > None. Merge bins to produce the given new edges... which must be a subset of the current ones.
 reset(self)¶
None > None. Reset the histogram but leave the bin structure.
 scaleW(self, w)¶
(float) > None. Rescale the weights in this histogram by the factor w.
 sumW(self, includeoverflows=True)¶
([bool]) > float Sum of weights filled into this histogram, optionally excluding the overflows.
 sumW2(self, includeoverflows=True)¶
([bool]) > float Sum of weights filled into this histogram, optionally excluding the overflows.
 toIntegral(self, efficiency=False, includeunderflow=True, includeoverflow=True)¶
None > Scatter2D.
Convert this Histo1D to a Scatter2D representing an integral (i.e. cumulative) histogram constructed from this differential one.
The efficiency argument is used to construct an ‘efficiency integral’ histogram and the includeXXXflow bools determine whether under and overflows are included in computing the (efficiency) integral.
 totalDbn¶
Histo1D.totalDbn(self) None > Dbn1D
The Dbn1D representing the total distribution.
 underflow¶
Histo1D.underflow(self) None > Dbn1D
The Dbn1D representing the underflow distribution.
 xEdges¶
Histo1D.xEdges(self) All x edges of the histo.
 xMax¶
Histo1D.xMax(self) High x edge of the histo.
 xMean(self, includeoverflows=True)¶
([bool]) > float Mean x of the histogram, optionally excluding the overflows.
 xMin¶
Histo1D.xMin(self) Low x edge of the histo.
 xRMS(self, includeoverflows=True)¶
([bool]) > float RMS in x of the histogram, optionally excluding the overflows.
 xStdDev(self, includeoverflows=True)¶
([bool]) > float Standard deviation in x of the histogram, optionally excluding the overflows.
 xStdErr(self, includeoverflows=True)¶
([bool]) > float Standard error on the mean x of the histogram, optionally excluding the overflows.
 xVariance(self, includeoverflows=True)¶
([bool]) > float Variance in x of the histogram, optionally excluding the overflows.
 class yoda.core.Histo2D¶

2D histogram.
Complete histogramming is supported, including uniform/regular binning, variablewidth bininng, unbinned gaps in the covered range, and outflows (under/overflows around all edges and corners).
Rebinning by integer factors, or by explicit merging of contiguous bins is also supported, but in development.
Rescaling of weights and/or the x axis is permitted inplace: the result is still a valid Histo2D. Binningcompatible 2D histograms may be divided, resulting in a Scatter3D since further fills would not be meaningful.
Several sets of arguments are tried by the constructor in the following order.
 Histo2D(path=””, title=””).
 Construct a histogram with optional path and title but no bins.
 Histo2D(nxbins, xlow, xhigh, nybins, ylow, yhigh, path=””, title=””).
 Construct a histogram with nxbins on the x axis and nybins on the y axis, distributed linearly between the respective low–high limits.
 addBin(self, xlow, xhigh, ylow, yhigh)¶
Add a bin.
 addBins(self, bounds)¶
Add several bins.
 bin(self, i)¶
Get the i’th bin
 binAt(self, x, y)¶
Get the bin containing position (x,y)
 binIndexAt(self, x, y)¶
Get the bin index pair containing position (x,y)
 bins¶
Histo2D.bins(self) Access the ordered bins list.
 clone(self)¶
None > Histo2D. Clone this Profile2D.
 divideBy(self, Histo2D h, efficiency=False)¶
Histo2D > Scatter3D
Divide this histogram by Histo2D h, returning a Scatter3D. The optional ‘efficiency’ argument, if set True, will use a binomial efficiency treatment of the errors.
 effNumEntries(self, includeoverflows=True)¶
([bool]) > float Effective number of times this histogram was filled, computed from weights and optionally excluding overflows.
 fill(self, double x, double y, weight=1.0)¶
(x,y,[w]) > None. Fill with given x,y values and optional weight.
 fillBin(self, size_t i, weight=1.0)¶
(i,[w]) > None. Fill bin i and optional weight.
 integral(self, includeoverflows=True)¶
([bool]) > float Histogram integral, optionally excluding the overflows.
 mkScatter(self, usefocus=False)¶
None > Scatter3D. Convert this Histo2D to a Scatter3D, with y representing bin heights (not sumW) and height errors.
 normalize(self, double normto, bool includeoverflows=True)¶
(float, bool) > None. Normalize the histogram.
 numBins¶
Histo2D.numBins(self) () > int
Number of bins (not including overflows).
 numBinsX¶
Histo2D.numBinsX(self) () > int
Number of bins (edges) along the x axis.
 numBinsY¶
Histo2D.numBinsY(self) () > int
Number of bins (edges) along the y axis.
 numEntries(self, includeoverflows=True)¶
([bool]) > int Number of times this histogram was filled, optionally excluding overflows.
 reset(self)¶
None > None. Reset the histogram but leave the bin structure.
 scaleW(self, w)¶
(float) > None. Rescale the weights in this histogram by the factor w.
 sumW(self, includeoverflows=True)¶
([bool]) > float Sum of weights filled into this histogram.
 sumW2(self, includeoverflows=True)¶
([bool]) > float Sum of squared weights filled into this histogram.
 totalDbn¶
Histo2D.totalDbn(self) () > Dbn2D
The Dbn2D representing the total distribution.
 xMax¶
Histo2D.xMax(self) High x edge of the histo.
 xMean(self, includeoverflows=True)¶
([bool]) > float Mean x of the histogram, optionally excluding the overflows.
 xMin¶
Histo2D.xMin(self) Low x edge of the histo.
 xRMS(self, includeoverflows=True)¶
([bool]) > float RMS in x of the histogram, optionally excluding the overflows.
 xStdDev(self, includeoverflows=True)¶
([bool]) > float Standard deviation in x of the histogram, optionally excluding the overflows.
 xStdErr(self, includeoverflows=True)¶
([bool]) > float Standard error on the mean x of the histogram, optionally excluding the overflows.
 xVariance(self, includeoverflows=True)¶
([bool]) > float Variance in x of the histogram, optionally excluding the overflows.
 xyMean(self, includeoverflows=True)¶
([bool]) > (float,float) Mean (x,y) of the histogram, optionally excluding the overflows.
 xyRMS(self, includeoverflows=True)¶
([bool]) > (float,float) RMS in (x,y) of the histogram, optionally excluding the overflows.
 xyStdDev(self, includeoverflows=True)¶
([bool]) > (float,float) Standard deviations in (x,y) of the histogram, optionally excluding the overflows.
 xyStdErr(self, includeoverflows=True)¶
([bool]) > (float,float) Standard errors on the mean (x,y) of the histogram, optionally excluding the overflows.
 xyVariance(self, includeoverflows=True)¶
([bool]) > (float,float) Variances in (x,y) of the histogram, optionally excluding the overflows.
 yMax¶
Histo2D.yMax(self) High y edge of the histo.
 yMean(self, includeoverflows=True)¶
([bool]) > float Mean y of the histogram, optionally excluding the overflows.
 yMin¶
Histo2D.yMin(self) Low y edge of the histo.
 yRMS(self, includeoverflows=True)¶
([bool]) > float RMS in y of the histogram, optionally excluding the overflows.
 yStdDev(self, includeoverflows=True)¶
([bool]) > float Standard deviation in y of the histogram, optionally excluding the overflows.
 yStdErr(self, includeoverflows=True)¶
([bool]) > float Standard error on the mean y of the histogram, optionally excluding the overflows.
 yVariance(self, includeoverflows=True)¶
([bool]) > float Variance in y of the histogram, optionally excluding the overflows.
 class yoda.core.HistoBin1D¶
HistoBin1D(double a, double b)
 area¶
HistoBin1D.area(self)
b.area <==> b.sumW
The area of the bin is the sum of weights of the bin; it is independent of width.
 areaErr¶
HistoBin1D.areaErr(self)
Error computed using binomial statistics on squared sum of bin weights, i.e. s.areaErr = sqrt(s.sumW2)
 height¶
HistoBin1D.height(self)
b.height <==> b.area / b.width
The height of the bin is defined as the area divided by the width.
 heightErr¶
HistoBin1D.heightErr(self)
Height error  scales the s.areaError by the reciprocal of the bin width.
 relErr¶
HistoBin1D.relErr(self)
Relative error  same for either area or height interpretations.
 class yoda.core.HistoBin2D¶
HistoBin2D(xlow, xhigh, ylow, yhigh)
 height¶
HistoBin2D.height(self)
 heightErr¶
HistoBin2D.heightErr(self)
 relErr¶
HistoBin2D.relErr(self)
 volume¶
HistoBin2D.volume(self)
 volumeErr¶
HistoBin2D.volumeErr(self)
 class yoda.core.Point¶
A generic point with errors, used by the Scatter classes.
 dim¶
Point.dim(self) None > int
Space dimension of the point (should match containing Scatter)
 errAvg(self, i)¶
int > float Average error on axis i
 errMinus(self, i)¶
int > float Minus error on axis i
 errPlus(self, i)¶
int > float Plus error on axis i
 errs(self, i)¶
int > float Errors on axis i
 set(self, i, val, *es)¶
 (int, float, float) > None
 (int, float, [float, float]) > None (int, float, float, float) > None
Set value and errors on axis i
 setErr(self, i, e)¶
(int, float) > None Set symmetric errors on axis i
 setErrMinus(self, i, e)¶
(int, float) > None Set minus error on axis i
 setErrPlus(self, i, e)¶
(int, float) > None Set plus error on axis i
 setErrs(self, i, *es)¶
 (int, float) > None
 (int, [float, float]) > None (int, float, float) > None
Set asymmetric errors on axis i
 setVal(self, i, val)¶
(int, float) > None Value on axis i
 val(self, i)¶
int > float Value on axis i
 class yoda.core.Point1D¶
Point1D(x=0, xerrs=0)
A 1D point with errors, used by the Scatter1D class.
 copy(self)¶
 scaleX(self, a)¶
(float) > None Scale the x values and errors by factor a.
 x¶
x coordinate
 xErrs¶
The x errors
 xMax¶
Point1D.xMax(self) The maximum x position, i.e. highest error
 xMin¶
Point1D.xMin(self) The minimum x position, i.e. lowest error
 class yoda.core.Point2D¶
Point2D(x=0, y=0, xerrs=0, yerrs=0)
A 2D point with errors, used by the Scatter2D class.
 copy(self)¶
 scale(self, x=1.0, y=1.0)¶
(float=1, float=1) > None DEPRECATED! Use scaleXY Scale the point coordinates by the given factors.
 scaleX(self, a)¶
(float) > None Scale the x values and errors by factor a.
 scaleXY(self, x=1.0, y=1.0)¶
(float=1, float=1) > None Scale the point coordinates by the given factors.
 scaleY(self, a)¶
(float) > None Scale the y values and errors by factor a.
 x¶
x coordinate
 xErrs¶
The x errors
 xMax¶
Point2D.xMax(self) The maximum x position, i.e. highest error
 xMin¶
Point2D.xMin(self) The minimum x position, i.e. lowest error
 xy¶
x and y coordinates as a tuple
 y¶
y coordinate
 yErrs¶
The y errors
 yMax¶
Point2D.yMax(self) The maximum y position, i.e. highest error
 yMin¶
Point2D.yMin(self) The minimum y position, i.e. lowest error
 class yoda.core.Point3D¶
Point3D(x=0, y=0, z=0, xerrs=0, yerrs=0, zerrs=0)
A 3D point with errors, used by the Scatter3D class.
 copy(self)¶
 scaleX(self, ax)¶
(float) > None Scale the x point coordinates by the given factor.
 scaleXYZ(self, ax=1.0, ay=1.0, az=1.0)¶
(float=1.0, float=1.0, float=1.0) > None Scale the point coordinates by the given factors.
 scaleY(self, ay)¶
(float) > None Scale the y point coordinates by the given factor.
 scaleZ(self, az)¶
(float) > None Scale the z point coordinates by the given factor.
 x¶
x coordinate
 xMax¶
Point3D.xMax(self) The maximum x position, i.e. highest error
 xMin¶
Point3D.xMin(self) The minimum x position, i.e. lowest error
 y¶
y coordinate
 yMax¶
Point3D.yMax(self) The maximum y position, i.e. highest error
 yMin¶
Point3D.yMin(self) The minimum y position, i.e. lowest error
 z¶
y coordinate
 zMax¶
Point3D.zMax(self) The maximum z position, i.e. highest error
 zMin¶
Point3D.zMin(self) The minimum z position, i.e. lowest error
 class yoda.core.Profile1D¶

1D profile histogram, used to measure mean values of a y variable, binned in x.
Complete histogram binning is supported, including uniform/regular binning, variablewidth binning, unbinned gaps in the covered range, and under/overflows. Rebinning by integer factors, or by explicit merging of contiguous bins is also supported.
Rescaling of weights and/or the x axis is permitted inplace: the result is still a valid Histo1D. Binningcompatible 1D histograms may be divided, resulting in a Scatter2D since further fills would not be meaningful.
Several sets of arguments are tried by the constructor in the following order.
 Profile1D(path=””, title=””).
 Construct a histogram with optional path and title but no bins.
 Profile1D(nbins, low, high, path=””, title=””)
 Construct a histogram with optional path and title, and nbins bins uniformly distributed between low and high.
 Profile1D(B, path=””, title=””).
 Construct a histogram with optional path and title, from an iterator of bins, B.
 addBin(self, low, high)¶
Add a bin.
 addBins(self, edges)¶
Add several bins.
 binAt(self, x)¶
Get the bin containing position x
 binIndexAt(self, x)¶
Get the bin index containing position x
 bins¶
Profile1D.bins(self) Access the ordered bins list.
 clone(self)¶
None > Profile1D. Clone this Profile1D.
 divideBy(self, Profile1D h)¶
 effNumEntries(self, includeoverflows=True)¶
([bool]) > float Effective number of times this histogram was filled, computed from weights and optionally excluding the overflows.
 fill(self, x, y, weight=1.0)¶
(x,y,[w]) > None. Fill with given x & y values and optional weight.
 fillBin(self, size_t ix, double y, weight=1.0)¶
(ix,y,[w]) > None. Fill bin ix with y value and optional weight.
 mergeBins(self, a, b)¶
mergeBins(ia, ib) > None. Merge bins from indices ia through ib.
 mkScatter(self, usefocus=False, usestddev=False)¶
None > Scatter2D. Convert this Profile1D to a Scatter2D, with y representing mean bin y values and their standard errors.
 numBins¶
Profile1D.numBins(self) () > int
Number of bins (not including overflows).
 numEntries(self, includeoverflows=True)¶
([bool]) > int Number of times this histogram was filled, optionally excluding the overflows.
 overflow¶
Profile1D.overflow(self) () > Dbn2D
The Dbn2D representing the overflow distribution.
 rebin(self, arg, **kwargs)¶
(n) > None or ([edges]) > None Merge bins, like rebinBy if an int argument is given; like rebinTo if an iterable is given.
 rebinBy(self, n, begin=0, end=None)¶
(n) > None. Merge every group of n bins together (between begin and end, if specified).
 rebinTo(self, edges)¶
([edges]) > None. Merge bins to produce the given new edges... which must be a subset of the current ones.
 reset(self)¶
None > None. Reset the histogram but leave the bin structure.
 scaleW(self, double w)¶
(float) > None. Rescale the weights in this histogram by the factor w.
 scaleY(self, double f)¶
(float) > None. Scale the ydirection (profiled value) in this histogram by the factor f.
 sumW(self, includeoverflows=True)¶
([bool]) > float Sum of weights filled into this histogram.
 sumW2(self, includeoverflows=True)¶
([bool]) > float Sum of weights filled into this histogram.
 totalDbn¶
Profile1D.totalDbn(self) () > Dbn2D
The Dbn2D representing the total distribution.
 underflow¶
Profile1D.underflow(self) () > Dbn2D
The Dbn2D representing the underflow distribution.
 xEdges¶
Profile1D.xEdges(self) All x edges of the histo.
 xMax¶
Profile1D.xMax(self) High x edge of the histo.
 xMean(self, includeoverflows=True)¶
([bool]) > float Mean x of the histogram, optionally excluding the overflows.
 xMin¶
Profile1D.xMin(self) Low x edge of the histo.
 xRMS(self, includeoverflows=True)¶
([bool]) > float RMS in x of the histogram, optionally excluding the overflows.
 xStdDev(self, includeoverflows=True)¶
([bool]) > float Standard deviation in x of the histogram, optionally excluding the overflows.
 xStdErr(self, includeoverflows=True)¶
([bool]) > float Standard error on the mean x of the histogram, optionally excluding the overflows.
 xVariance(self, includeoverflows=True)¶
([bool]) > float Variance in x of the histogram, optionally excluding the overflows.
 class yoda.core.Profile2D¶

2D profile histogram, used to measure mean values of a z variable, binned in x and y.
Complete histogramming is supported, including uniform/regular binning, variablewidth bininng, unbinned gaps in the covered range, and outflows (under/overflows around all edges and corners).
Rebinning by integer factors, or by explicit merging of contiguous bins is also supported, but in development.
Rescaling of weights and/or the x axis is permitted inplace: the result is still a valid Histo2D. Binningcompatible 1D histograms may be divided, resulting in a Scatter3D since further fills would not be meaningful.
Several sets of arguments are tried by the constructor in the following order.
 Histo2D(path=””, title=””).
 Construct a histogram with optional path and title but no bins.
 Histo2D(nxbins, xlow, xhigh, nybins, ylow, yhigh, path=””, title=””).
 Construct a histogram with nxbins on the x axis and nybins on the y axis, distributed linearly between the respective low–high limits.
NOT YET FINISHED: please contact the YODA authors if you require extra functionality.
 addBin(self, double xlow, double xhigh, double ylow, double yhigh)¶
Add a bin.
 addBins(self, xcuts, ycuts)¶
Add several bins.
 bin(self, i)¶
Get the i’th bin
 binAt(self, x, y)¶
Get the bin containing position (x,y)
 binIndexAt(self, x, y)¶
Get the bin index pair containing position (x,y)
 bins¶
Profile2D.bins(self) Access the ordered bins list.
 clone(self)¶
None > Profile2D. Clone this Profile2D.
 divideBy(self, Profile2D h)¶
 effNumEntries(self, includeoverflows=True)¶
([bool]) > float Effective number of times this histogram was filled, computed from weights and optionally excluding the overflows.
 fill(self, double x, double y, double z, double weight=1.0)¶
(x,y,z,[w]) > None. Fill with given x,y & z values and optional weight.
 fillBin(self, size_t i, double z, weight=1.0)¶
(i,z,[w]) > None. Fill bin i with value z and optional weight.
 mkScatter(self, usefocus=False, usestddev=False)¶
None > Scatter3D. Convert this Profile2D to a Scatter3D, with z representing mean bin y values and their standard errors.
 numBins¶
Profile2D.numBins(self) () > int
Number of bins (not including overflows).
 numBinsX¶
Profile2D.numBinsX(self) () > int
Number of bins (edges) along the x axis.
 numBinsY¶
Profile2D.numBinsY(self) () > int
Number of bins (edges) along the y axis.
 numEntries(self, includeoverflows=True)¶
([bool]) > int Number of times this histogram was filled, optionally excluding the overflows.
 reset(self)¶
None > None. Reset the histogram but leave the bin structure.
 scaleW(self, w)¶
(float) > None. Rescale the weights in this histogram by the factor w.
 scaleZ(self, double f)¶
(float) > None. Scale the zdirection (profiled value) in this histogram by the factor f.
 sumW(self, includeoverflows=True)¶
([bool]) > float Sum of weights filled into this histogram.
 sumW2(self, includeoverflows=True)¶
([bool]) > float Sum of squared weights filled into this histogram.
 totalDbn¶
Profile2D.totalDbn(self) () > Dbn3D
The Dbn3D representing the total distribution.
 xMax¶
Profile2D.xMax(self) High x edge of the histo.
 xMean(self, includeoverflows=True)¶
([bool]) > float Mean x of the histogram, optionally excluding the overflows.
 xMin¶
Profile2D.xMin(self) Low x edge of the histo.
 xRMS(self, includeoverflows=True)¶
([bool]) > float RMS in x of the histogram, optionally excluding the overflows.
 xStdDev(self, includeoverflows=True)¶
([bool]) > float Standard deviation in x of the histogram, optionally excluding the overflows.
 xStdErr(self, includeoverflows=True)¶
([bool]) > float Standard error on the mean x of the histogram, optionally excluding the overflows.
 xVariance(self, includeoverflows=True)¶
([bool]) > float Variance in x of the histogram, optionally excluding the overflows.
 xyMean(self, includeoverflows=True)¶
([bool]) > (float,float) Mean (x,y) of the histogram, optionally excluding the overflows.
 xyRMS(self, includeoverflows=True)¶
([bool]) > (float,float) RMS in (x,y) of the histogram, optionally excluding the overflows.
 xyStdDev(self, includeoverflows=True)¶
([bool]) > (float,float) Standard deviations in (x,y) of the histogram, optionally excluding the overflows.
 xyStdErr(self, includeoverflows=True)¶
([bool]) > (float,float) Standard errors on the mean (x,y) of the histogram, optionally excluding the overflows.
 xyVariance(self, includeoverflows=True)¶
([bool]) > (float,float) Variances in (x,y) of the histogram, optionally excluding the overflows.
 yMax¶
Profile2D.yMax(self) High y edge of the histo.
 yMean(self, includeoverflows=True)¶
([bool]) > float Mean y of the histogram, optionally excluding the overflows.
 yMin¶
Profile2D.yMin(self) Low y edge of the histo.
 yRMS(self, includeoverflows=True)¶
([bool]) > float RMS in y of the histogram, optionally excluding the overflows.
 yStdDev(self, includeoverflows=True)¶
([bool]) > float Standard deviation in y of the histogram, optionally excluding the overflows.
 yStdErr(self, includeoverflows=True)¶
([bool]) > float Standard error on the mean y of the histogram, optionally excluding the overflows.
 yVariance(self, includeoverflows=True)¶
([bool]) > float Variance in y of the histogram, optionally excluding the overflows.
 class yoda.core.ProfileBin1D¶
ProfileBin1D(double a, double b)
A 1D profile bin, as stored inside Profile1D.
Only one constructor:
 ProfileBin1D(xlow, xhigh)
 mean¶
ProfileBin1D.mean(self) The mean of the yvalues that have filled the bin.
 rms¶
ProfileBin1D.rms(self) The RMS of the yvalues that have filled the bin.
 stdDev¶
ProfileBin1D.stdDev(self) The standard deviation of the yvalues that have filled the bin.
 stdErr¶
ProfileBin1D.stdErr(self) The standard error of the yvalues that have filled the bin.
 stddev¶
ProfileBin1D.stdDev(self) The standard deviation of the yvalues that have filled the bin.
 stderr¶
ProfileBin1D.stdErr(self) The standard error of the yvalues that have filled the bin.
 sumWY¶
ProfileBin1D.sumWY(self) sum(weights * ys)
 sumWY2¶
ProfileBin1D.sumWY2(self) sum(weights * ys * ys)
 variance¶
ProfileBin1D.variance(self) The variance of the yvalues that have filled the bin.
 class yoda.core.ProfileBin2D¶
ProfileBin2D(xlow, xhigh, ylow, yhigh)
 mean¶
ProfileBin2D.mean(self)
 rms¶
ProfileBin2D.rms(self)
 stdDev¶
ProfileBin2D.stdDev(self)
 stdErr¶
ProfileBin2D.stdErr(self)
 stddev¶
ProfileBin2D.stdDev(self)
 stderr¶
ProfileBin2D.stdErr(self)
 sumWZ¶
ProfileBin2D.sumWZ(self)
 sumWZ2¶
ProfileBin2D.sumWZ2(self)
 variance¶
ProfileBin2D.variance(self)
 class yoda.core.Scatter1D¶

1D scatter plot, i.e. a collection of Point1D objects with positions and errors.
Constructor calling idioms:
 Scatter1D(path=””, title=””)
 Create a new empty scatter, with optional path and title.
 Scatter1D(points, path=””, title=””):
 Create a new empty scatter from an iterable of points, with optional path and title.
TODO: more documentation!
 addPoint(self, *args, **kwargs)¶
Add a new point.
Provide either a single yoda.Point1D object, or the two args: x, xerrs=0.
 addPoints(self, iterable)¶
Add several new points.
 clone(self)¶
() > Scatter1D. Clone this Scatter1D.
 mkScatter(self)¶
None > Scatter1D. Make a new Scatter1D. Exists to allow mkScatter calls on any AnalysisObject, even if it already is a scatter.
 numPoints¶
Scatter1D.numPoints(self) () > int
Number of points in this scatter.
 point(self, size_t i)¶
Access the i’th point.
 points¶
Scatter1D.points(self) Access the ordered list of points.
 scaleX(self, a)¶
(float) > None Scale the x values and errors of the points in this scatter by factor a.
 transformX(self, f)¶
(fn) > None Transform the x values and errors of the points in this scatter by function f.
 class yoda.core.Scatter2D¶

2D scatter plot, i.e. a collection of Point2D objects with positions and errors.
Constructor calling idioms:
 Scatter2D(path=””, title=””)
 Create a new empty scatter, with optional path and title.
 Scatter2D(points, path=””, title=””):
 Create a new empty scatter from an iterable of points, with optional path and title.
TODO: more documentation!
 addPoint(self, *args, **kwargs)¶
Add a new point.
Provide either a single yoda.Point2D object, or the four args: x, y, xerrs=0, yerrs=0.
 addPoints(self, iterable)¶
Add several new points.
 clone(self)¶
() > Scatter2D. Clone this Scatter2D.
 combineWith(self, others)¶
Try to add points from other Scatter2Ds into this one.
 mkScatter(self)¶
None > Scatter2D. Make a new Scatter2D. Exists to allow mkScatter calls on any AnalysisObject, even if it already is a scatter.
 numPoints¶
Scatter2D.numPoints(self) () > int
Number of points in this scatter.
 point(self, size_t i)¶
Access the i’th point.
 points¶
Scatter2D.points(self) Access the ordered list of points.
 scale(self, ax=1.0, ay=1.0)¶
(float=1, float=1) > None DEPRECATED: USE scaleXY Scale the values and errors of the points in this scatter by factors ax, ay.
 scaleX(self, a)¶
(float) > None Scale the x values and errors of the points in this scatter by factor a.
 scaleXY(self, ax=1.0, ay=1.0)¶
(float=1, float=1) > None Scale the values and errors of the points in this scatter by factors ax, ay.
 scaleY(self, a)¶
(float) > None Scale the y values and errors of the points in this scatter by factor a.
 transformX(self, f)¶
(fn) > None Transform the x values and errors of the points in this scatter by function f.
 transformY(self, f)¶
(fn) > None Transform the y values and errors of the points in this scatter by function f.
 class yoda.core.Scatter3D¶

3D scatter plot, i.e. a collection of Point3D objects with positions and errors.
Constructor calling idioms:
 Scatter3D(path=””, title=””)
 Create a new empty scatter, with optional path and title.
 Scatter3D(points, path=””, title=””):
 Create a new empty scatter from an iterable of points, with optional path and title.
TODO: more documentation!
 addPoint(self, *args, **kwargs)¶
Add a new point.
Provide either a single yoda.Point3D object, or the 36 args: x, y, z, xerrs=0, yerrs=0, zerrs=0.
 addPoints(self, iterable)¶
Add several new points.
 clone(self)¶
() > Scatter3D. Clone this Scatter3D.
 combineWith(self, others)¶
Try to add points from other Scatter3Ds into this one.
 mkScatter(self)¶
None > Scatter3D. Make a new Scatter3D. Exists to allow mkScatter calls on any AnalysisObject, even if it already is a scatter.
 numPoints¶
Scatter3D.numPoints(self) () > int
Number of points in this scatter.
 point(self, size_t i)¶
Access the i’th point.
 points¶
Scatter3D.points(self) Access the ordered list of points.
 scale(self, ax=1, ay=1, az=1)¶
(float=1, float=1, float=1) > None DEPRECATED: USE scaleXYZ Scale the values and errors of the points in this scatter by factors ax, ay, az.
 scaleX(self, a)¶
(float) > None Scale the x values and errors of the points in this scatter by factor a.
 scaleXYZ(self, ax=1, ay=1, az=1)¶
(float=1, float=1, float=1) > None Scale the values and errors of the points in this scatter by factors ax, ay, az.
 scaleY(self, a)¶
(float) > None Scale the y values and errors of the points in this scatter by factor a.
 scaleZ(self, a)¶
(float) > None Scale the z values and errors of the points in this scatter by factor a.
 transformX(self, f)¶
(fn) > None Transform the x values and errors of the points in this scatter by function f.
 transformY(self, f)¶
(fn) > None Transform the y values and errors of the points in this scatter by function f.
 transformZ(self, f)¶
(fn) > None Transform the z values and errors of the points in this scatter by function f.
 yoda.core.correlation(sample1, sample2)¶
(float, list[float]) > int Return the unweighted correlation of the two provided sample lists.
 yoda.core.covariance(sample1, sample2)¶
(list[float], list[float]) > float Return the unweighted covariance of the two provided sample lists.
 yoda.core.divide(ao1, ao2)¶
(AnalysisObject, AnalysisObject) > Scatter{1,2,3}D Divide one AnalysisObject by another, producing a Scatter of appropriate dimension by using the logic of the bound divideBy methods.
 yoda.core.index_between(x, binedges)¶
(float, list[float]) > int Return the index of the bin which would contain x, or 1 if there is no enclosing bin in the given set of n+1 bin edges.
 yoda.core.linspace(nbins, start, end)¶
(int, float, float) > list[float] Make a list of n+1 bin edges linearly spaced between start and end, with the first and last edges on those boundaries.
 yoda.core.logspace(nbins, start, end)¶
(int, float, float) > list[float] Make a list of n+1 bin edges linearly spaced on the interval log(start..end), with the first and last edges on those boundaries.
 yoda.core.mean(sample)¶
(list[float]) > float Return the unweighted mean of the entries in the provided sample list.
 yoda.core.mkScatter(ao, usefocus=False, usestddev=False)¶
AnalysisObject > Scatter{1,2,3}D Convert an AnalysisObject to a Scatter, using the logic of the bound mkScatter methods.
@todo This falls back on use of optional args until we find one that works: is there a nicer way?
 yoda.core.read(filename, asdict=True, patterns=None, unpatterns=None)¶
Read data objects from the provided filename, autodetermining the format from the file extension.
The loaded data objects can be filtered on their path strings, using the optional patterns and unpatterns arguments. These can be strings, compiled regex objects with a ‘match’ method, or any iterable of those types. If given, only analyses with paths which match at least one pattern, and do not match any unpatterns, will be returned.
Returns a dict or list of analysis objects depending on the asdict argument.
 yoda.core.readAIDA(file_or_filename, asdict=True, patterns=None, unpatterns=None)¶
Read data objects from the provided AIDAformat file.
The loaded data objects can be filtered on their path strings, using the optional patterns and unpatterns arguments. These can be strings, compiled regex objects with a ‘match’ method, or any iterable of those types. If given, only analyses with paths which match at least one pattern, and do not match any unpatterns, will be returned.
Returns a dict or list of analysis objects depending on the asdict argument.
DEPRECATED: AIDA is a dead format. At some point we will stop supporting it.
 yoda.core.readFLAT(file_or_filename, asdict=True, patterns=None, unpatterns=None)¶
Read data objects from the provided FLATformat file.
The loaded data objects can be filtered on their path strings, using the optional patterns and unpatterns arguments. These can be strings, compiled regex objects with a ‘match’ method, or any iterable of those types. If given, only analyses with paths which match at least one pattern, and do not match any unpatterns, will be returned.
Returns a dict or list of analysis objects depending on the asdict argument.
 yoda.core.readYODA(file_or_filename, asdict=True, patterns=None, unpatterns=None)¶
Read data objects from the provided YODAformat file.
The loaded data objects can be filtered on their path strings, using the optional patterns and unpatterns arguments. These can be strings, compiled regex objects with a ‘match’ method, or any iterable of those types. If given, only analyses with paths which match at least one pattern, and do not match any unpatterns, will be returned.
Returns a dict or list of analysis objects depending on the asdict argument.
 yoda.core.version()¶
Return YODA library version as a string
 yoda.core.write(ana_objs, filename)¶
Write data objects to the provided filename, autodetermining the format from the file extension.
 yoda.core.writeAIDA(ana_objs, file_or_filename)¶
Write data objects to the provided file in AIDA format.
 yoda.core.writeFLAT(ana_objs, file_or_filename)¶
Write data objects to the provided file in FLAT format.
 yoda.core.writeYODA(ana_objs, file_or_filename)¶
Write data objects to the provided file in YODA format.