def testBin(self):
one = Bin(5, -3.0, 7.0, named("xaxis", lambda x: x))
for _ in self.simple:
one.fill(_)
self.assertEqual(list(map(lambda _: _.entries, one.values)),
[3.0, 2.0, 2.0, 1.0, 0.0])
self.assertEqual(one.underflow.entries, 1.0)
self.assertEqual(one.overflow.entries, 1.0)
self.assertEqual(one.nanflow.entries, 0.0)
two = Select(lambda x: x.bool, Bin(5, -3.0, 7.0, lambda x: x.double))
for _ in self.struct:
two.fill(_)
self.assertEqual(list(map(lambda _: _.entries, two.cut.values)),
[2.0, 1.0, 1.0, 1.0, 0.0])
self.assertEqual(two.cut.underflow.entries, 0.0)
self.assertEqual(two.cut.overflow.entries, 0.0)
self.assertEqual(two.cut.nanflow.entries, 0.0)
self.checkScaling(one)
self.checkScaling(one.toImmutable())
self.checkJson(one)
self.checkPickle(one)
self.checkName(one)
self.checkScaling(two)
self.checkScaling(two.toImmutable())
self.checkJson(two)
self.checkPickle(two)
self.checkName(two)
def testBinWithSum(self):
one = Bin(5, -3.0, 7.0, named("xaxis", lambda x: x),
Sum(named("yaxis", lambda x: 10.0)), Sum(lambda x: 10.0),
Sum(lambda x: 10.0), Sum(lambda x: 10.0))
for _ in self.simple:
one.fill(_)
self.assertEqual(list(map(lambda _: _.sum, one.values)),
[30.0, 20.0, 20.0, 10.0, 0.0])
self.assertEqual(one.underflow.sum, 10.0)
self.assertEqual(one.overflow.sum, 10.0)
self.assertEqual(one.nanflow.sum, 0.0)
two = Select(
lambda x: x.bool,
Bin(5, -3.0, 7.0, lambda x: x.double, Sum(lambda x: 10.0),
Sum(lambda x: 10.0), Sum(lambda x: 10.0), Sum(lambda x: 10.0)))
for _ in self.struct:
two.fill(_)
self.assertEqual(list(map(lambda _: _.sum, two.cut.values)),
[20.0, 10.0, 10.0, 10.0, 0.0])
self.assertEqual(two.cut.underflow.sum, 0.0)
self.assertEqual(two.cut.overflow.sum, 0.0)
self.assertEqual(two.cut.nanflow.sum, 0.0)
self.checkScaling(one)
self.checkScaling(one.toImmutable())
self.checkJson(one)
self.checkPickle(one)
self.checkName(one)
self.checkScaling(two)
self.checkScaling(two.toImmutable())
self.checkJson(two)
self.checkPickle(two)
self.checkName(two)
def testCountWithFilter(self):
for i in xrange(11):
left, right = self.simple[:i], self.simple[i:]
leftCounting = Select(named("something", lambda x: x > 0.0),
Count())
rightCounting = Select(named("something", lambda x: x > 0.0),
Count())
for _ in left:
leftCounting.fill(_)
for _ in right:
rightCounting.fill(_)
self.assertEqual(leftCounting.cut.entries,
len(list(filter(lambda x: x > 0.0, left))))
self.assertEqual(rightCounting.cut.entries,
len(list(filter(lambda x: x > 0.0, right))))
finalResult = leftCounting + rightCounting
self.assertEqual(finalResult.cut.entries,
len(list(filter(lambda x: x > 0.0, self.simple))))
self.checkScaling(leftCounting)
self.checkScaling(leftCounting.toImmutable())
self.checkJson(leftCounting)
self.checkPickle(leftCounting)
self.checkName(leftCounting)
def testSumWithFilter(self):
for i in xrange(11):
left, right = self.struct[:i], self.struct[i:]
leftSumming = Select(lambda x: x.bool, Sum(lambda x: x.double))
rightSumming = Select(lambda x: x.bool, Sum(lambda x: x.double))
for _ in left:
leftSumming.fill(_)
for _ in right:
rightSumming.fill(_)
self.assertAlmostEqual(leftSumming.cut.sum,
sum(_.double for _ in left if _.bool))
self.assertAlmostEqual(rightSumming.cut.sum,
sum(_.double for _ in right if _.bool))
finalResult = leftSumming + rightSumming
self.assertAlmostEqual(
finalResult.cut.sum,
sum(_.double for _ in self.struct if _.bool))
self.checkScaling(leftSumming)
self.checkScaling(leftSumming.toImmutable())
self.checkJson(leftSumming)
self.checkPickle(leftSumming)
self.checkName(leftSumming)
def testSumWithFilterStringFunctions(self):
for i in xrange(11):
left, right = self.struct[:i], self.struct[i:]
leftSumming = Select("not bool", Sum("double + 1"))
rightSumming = Select("not bool", Sum("double + 1"))
for _ in left:
leftSumming.fill(_)
for _ in right:
rightSumming.fill(_)
self.assertAlmostEqual(
leftSumming.cut.sum,
sum(_.double + 1 for _ in left if not _.bool))
self.assertAlmostEqual(
rightSumming.cut.sum,
sum(_.double + 1 for _ in right if not _.bool))
finalResult = leftSumming + rightSumming
self.assertAlmostEqual(
finalResult.cut.sum,
sum(_.double + 1 for _ in self.struct if not _.bool))
self.checkScaling(leftSumming)
self.checkScaling(leftSumming.toImmutable())
self.checkJson(leftSumming)
self.checkPickle(leftSumming)
self.checkName(leftSumming)
def testSumWithWeightingFactorStringFunctions(self):
for i in xrange(11):
left, right = self.struct[:i], self.struct[i:]
leftSumming = Select("int", Sum("double * 2"))
rightSumming = Select("int", Sum("double * 2"))
for _ in left:
leftSumming.fill(_)
for _ in right:
rightSumming.fill(_)
self.assertAlmostEqual(
leftSumming.cut.sum,
sum(_.double * 2 * _.int for _ in left if _.int > 0))
self.assertAlmostEqual(
rightSumming.cut.sum,
sum(_.double * 2 * _.int for _ in right if _.int > 0))
finalResult = leftSumming + rightSumming
self.assertAlmostEqual(
finalResult.cut.sum,
sum(_.double * 2 * _.int for _ in self.struct if _.int > 0))
self.checkScaling(leftSumming)
self.checkScaling(leftSumming.toImmutable())
self.checkJson(leftSumming)
self.checkPickle(leftSumming)
self.checkName(leftSumming)
def testDeviateWithWeightingFactor(self):
for i in xrange(11):
left, right = self.struct[:i], self.struct[i:]
leftDeviating = Select(lambda x: x.int,
Deviate(lambda x: x.double))
rightDeviating = Select(lambda x: x.int,
Deviate(lambda x: x.double))
for _ in left:
leftDeviating.fill(_)
for _ in right:
rightDeviating.fill(_)
if sum(map(lambda _: _.int if _.int > 0.0 else 0.0, left)) == 0.0:
self.assertTrue(math.isnan(leftDeviating.cut.mean))
self.assertTrue(math.isnan(leftDeviating.cut.variance))
else:
self.assertAlmostEqual(
leftDeviating.cut.mean,
self.meanWeighted(list(map(lambda _: _.double, left)),
list(map(lambda _: _.int, left))))
self.assertAlmostEqual(
leftDeviating.cut.variance,
self.varianceWeighted(list(map(lambda _: _.double, left)),
list(map(lambda _: _.int, left))))
if sum(map(lambda _: _.int if _.int > 0.0 else 0.0, right)) == 0.0:
self.assertTrue(math.isnan(rightDeviating.cut.mean))
self.assertTrue(math.isnan(rightDeviating.cut.variance))
else:
self.assertAlmostEqual(
rightDeviating.cut.mean,
self.meanWeighted(list(map(lambda _: _.double, right)),
list(map(lambda _: _.int, right))))
self.assertAlmostEqual(
rightDeviating.cut.variance,
self.varianceWeighted(list(map(lambda _: _.double, right)),
list(map(lambda _: _.int, right))))
finalResult = leftDeviating + rightDeviating
self.assertAlmostEqual(
finalResult.cut.variance,
self.varianceWeighted(
list(map(lambda _: _.double, self.struct)),
list(map(lambda _: _.int, self.struct))))
self.checkScaling(leftDeviating)
self.checkScaling(leftDeviating.toImmutable())
self.checkJson(leftDeviating)
self.checkPickle(leftDeviating)
self.checkName(leftDeviating)
def TwoDimensionallyHistogram(xnum, xlow, xhigh, xquantity,
ynum, ylow, yhigh, yquantity,
selection=unweighted):
"""Convenience function for creating a conventional, two-dimensional histogram."""
return Select.ing(selection,
Bin.ing(xnum, xlow, xhigh, xquantity,
Bin.ing(ynum, ylow, yhigh, yquantity)))
def TwoDimensionallySparselyHistogram(xbinWidth, xquantity,
ybinWidth, yquantity,
selection=unweighted,
xorigin=0.0, yorigin=0.0):
"""Convenience function for creating a sparsely binned, two-dimensional histogram."""
return Select.ing(selection,
SparselyBin.ing(xbinWidth, xquantity,
SparselyBin.ing(ybinWidth, yquantity,
Count.ing(), Count.ing(), yorigin), Count.ing(), xorigin))
def SparselyProfile(binWidth,
binnedQuantity,
averagedQuantity,
selection=unweighted,
origin=0.0):
"""Convenience function for creating sparsely binned binwise averages."""
return Select.ing(
selection,
SparselyBin.ing(binWidth, binnedQuantity,
Average.ing(averagedQuantity), Count.ing(), origin))
def SparselyProfileErr(binWidth,
binnedQuantity,
averagedQuantity,
selection=unweighted,
origin=0.0):
"""Convenience function for creating a physicist's sparsely binned "profile plot," which is a Profile with variances."""
return Select.ing(
selection,
SparselyBin.ing(binWidth, binnedQuantity,
Deviate.ing(averagedQuantity), Count.ing(), origin))
def ProfileErr(num,
low,
high,
binnedQuantity,
averagedQuantity,
selection=unweighted):
"""Convenience function for creating a physicist's "profile plot," which is a Profile with variances."""
return Select.ing(
selection,
Bin.ing(num, low, high, binnedQuantity, Deviate.ing(averagedQuantity)))
def Profile(num,
low,
high,
binnedQuantity,
averagedQuantity,
selection=unweighted):
"""Convenience function for creating binwise averages."""
return Select.ing(
selection,
Bin.ing(num, low, high, binnedQuantity, Average.ing(averagedQuantity)))
def testDeviateWithFilter(self):
for i in xrange(11):
left, right = self.struct[:i], self.struct[i:]
leftDeviating = Select(lambda x: x.bool,
Deviate(lambda x: x.double))
rightDeviating = Select(lambda x: x.bool,
Deviate(lambda x: x.double))
for _ in left:
leftDeviating.fill(_)
for _ in right:
rightDeviating.fill(_)
if len([_.double for _ in left if _.bool]) == 0:
self.assertTrue(math.isnan(leftDeviating.cut.mean))
self.assertTrue(math.isnan(leftDeviating.cut.variance))
else:
self.assertAlmostEqual(
leftDeviating.cut.mean,
self.mean([_.double for _ in left if _.bool]))
self.assertAlmostEqual(
leftDeviating.cut.variance,
self.variance([_.double for _ in left if _.bool]))
if len([_.double for _ in right if _.bool]) == 0:
self.assertTrue(math.isnan(rightDeviating.cut.mean))
self.assertTrue(math.isnan(rightDeviating.cut.variance))
else:
self.assertAlmostEqual(
rightDeviating.cut.mean,
self.mean([_.double for _ in right if _.bool]))
self.assertAlmostEqual(
rightDeviating.cut.variance,
self.variance([_.double for _ in right if _.bool]))
finalResult = leftDeviating + rightDeviating
self.assertAlmostEqual(
finalResult.cut.variance,
self.variance([_.double for _ in self.struct if _.bool]))
self.checkScaling(leftDeviating)
self.checkScaling(leftDeviating.toImmutable())
self.checkJson(leftDeviating)
self.checkPickle(leftDeviating)
self.checkName(leftDeviating)
def HistogramCut(num, low, high, quantity=identity, selection=unweighted):
"""Create a conventional histogram that is capable of being filled and added, with a selection cut.
Parameters:
num (int): the number of bins; must be at least one.
low (float): the minimum-value edge of the first bin.
high (float): the maximum-value edge of the last bin; must be strictly greater than `low`.
quantity (function returning float or string): function that computes the quantity of interest from
the data. pass on all values by default. If a string is given, quantity is set to identity(string),
in which case that column is picked up from a pandas df.
selection (function returning boolean): function that computes if data point is accepted or not.
default is: lamba x: True
"""
return Select.ing(selection, Bin.ing(num, low, high, quantity, Count.ing(), Count.ing(), Count.ing(), Count.ing()))
def testSelectBin(self):
with Numpy() as numpy:
if numpy is None:
return
sys.stderr.write("\n")
self.compare("SelectBin no data", Select(lambda x: x["empty"], Bin(
100, -3.0, 3.0, lambda x: x["empty"])), self.data, Select(lambda x: x, Bin(100, -3.0, 3.0, lambda x: x)), self.empty)
self.compare("SelectBin noholes", Select(lambda x: x["noholes"], Bin(
100, -3.0, 3.0, lambda x: x["noholes"])), self.data, Select(lambda x: x, Bin(100, -3.0, 3.0, lambda x: x)), self.noholes)
self.compare("SelectBin holes", Select(lambda x: x["withholes"], Bin(
100, -3.0, 3.0, lambda x: x["withholes"])), self.data, Select(lambda x: x, Bin(100, -3.0, 3.0, lambda x: x)), self.withholes)
def CategorizeHistogram(quantity, selection=unweighted):
"""Convenience function for creating a categorize histogram."""
return Select.ing(selection, Categorize.ing(quantity, Count.ing()))
def SparselyHistogram(binWidth, quantity, selection=unweighted, origin=0.0):
"""Convenience function for creating a sparsely binned histogram."""
return Select.ing(selection,
SparselyBin.ing(binWidth, quantity, Count.ing(), Count.ing(), origin))
def SparselyProfile(binWidth, binnedQuantity, averagedQuantity, selection=unweighted, origin=0.0):
"""Convenience function for creating sparsely binned binwise averages."""
return Select.ing(selection,
SparselyBin.ing(binWidth, binnedQuantity,
Average.ing(averagedQuantity), Count.ing(), origin))
def Profile(num, low, high, binnedQuantity, averagedQuantity, selection=unweighted):
"""Convenience function for creating binwise averages."""
return Select.ing(selection,
Bin.ing(num, low, high, binnedQuantity,
Average.ing(averagedQuantity)))
def ProfileErr(num, low, high, binnedQuantity, averagedQuantity, selection=unweighted):
"""Convenience function for creating a physicist's "profile plot," which is a Profile with variances."""
return Select.ing(selection,
Bin.ing(num, low, high, binnedQuantity,
Deviate.ing(averagedQuantity)))
def SparselyProfileErr(binWidth, binnedQuantity, averagedQuantity, selection=unweighted, origin=0.0):
"""Convenience function for creating a physicist's sparsely binned "profile plot," which is a Profile with variances."""
return Select.ing(selection,
SparselyBin.ing(binWidth, binnedQuantity,
Deviate.ing(averagedQuantity), Count.ing(), origin))
def Histogram(num, low, high, quantity, selection=unweighted):
"""Convenience function for creating a conventional histogram."""
return Select.ing(
selection,
Bin.ing(num, low, high, quantity, Count.ing(), Count.ing(),
Count.ing(), Count.ing()))
def SparselyHistogram(binWidth, quantity, selection=unweighted, origin=0.0):
"Convenience function for creating a sparsely binned histogram."
return Select.ing(
selection,
SparselyBin.ing(binWidth, quantity, Count.ing(), Count.ing(), origin))
def Histogram(num, low, high, quantity, selection=unweighted):
"""Convenience function for creating a conventional histogram."""
return Select.ing(selection, Bin.ing(num, low, high, quantity,
Count.ing(), Count.ing(), Count.ing(), Count.ing()))
