def test_next_None(self):
binning = Echo(nextFunc=None)
self.assertIsNone(binning.next(-5))
self.assertIsNone(binning.next(0))
self.assertIsNone(binning.next(1))
self.assertIsNone(binning.next(3))
self.assertIsNone(binning.next(10))
def test_next_lambda(self):
binning = Echo(nextFunc=lambda x: x + 0.1)
self.assertEqual(-4.9, binning.next(-5))
self.assertEqual(0.1, binning.next(0))
self.assertEqual(1.1, binning.next(1))
self.assertEqual(3.1, binning.next(3))
self.assertEqual(10.1, binning.next(10))
def test_next_plus2(self):
binning = Echo(nextFunc=plus2)
self.assertEqual(-3, binning.next(-5))
self.assertEqual(2, binning.next(0))
self.assertEqual(3, binning.next(1))
self.assertEqual(5, binning.next(3))
self.assertEqual(12, binning.next(10))
def test_next_default(self):
binning = Echo()
self.assertEqual(-4, binning.next(-5))
self.assertEqual(1, binning.next(0))
self.assertEqual(2, binning.next(1))
self.assertEqual(4, binning.next(3))
self.assertEqual(11, binning.next(10))
keyComposer1 = GenericKeyComposer(('met_pt', ), (binning1, ))
nextKeyComposer1 = NextKeyComposer((binning1, ))
resultsCombinationMethod1 = CombineIntoList(('met', ))
deliveryMethod1 = WriteListToFile(outPath1)
collector1 = Collector(resultsCombinationMethod1, deliveryMethod1)
outPath2 = os.path.join(args.outdir, 'tbl_jetpt.txt')
binning2 = RoundLog(0.1, 1)
keyComposer2 = GenericKeyComposer(('jet_pt', ), (binning2, ), (0, ))
nextKeyComposer2 = NextKeyComposer((binning2, ))
resultsCombinationMethod2 = CombineIntoList(('jet_pt', ))
deliveryMethod2 = WriteListToFile(outPath2)
collector2 = Collector(resultsCombinationMethod2, deliveryMethod2)
outPath3 = os.path.join(args.outdir, 'tbl_njets_nbjets.txt')
binning31 = Echo()
binning32 = Echo()
keyComposer3 = GenericKeyComposer(('nJet40', 'nBJet40'),
(binning31, binning32))
nextKeyComposer3 = NextKeyComposer((binning31, binning32))
resultsCombinationMethod3 = CombineIntoList(('njets', 'nbjets'))
deliveryMethod3 = WriteListToFile(outPath3)
collector3 = Collector(resultsCombinationMethod3, deliveryMethod3)
eventBuilder = EventBuilder(analyzerName, fileName, treeName, args.nevents)
progressBar = ProgressBar()
progressMonitor = ProgressMonitor(progressBar)
progressReporter = progressMonitor.createReporter()
heppyResult = HeppyResult(args.heppydir)
tblcfg = [
dict(outFileName = 'tbl_met.txt',
branchNames = ('met_pt', ),
outColumnNames = ('met', ),
binnings = (RoundLog(0.1, 1), ),
countsClass = Counts),
dict(outFileName = 'tbl_jetpt.txt',
branchNames = ('jet_pt', ),
binnings = (RoundLog(0.1, 1), ),
indices = (0, ),
countsClass = Counts),
dict(outFileName = 'tbl_njets_nbjets.txt',
branchNames = ('nJet40', 'nBJet40'),
outColumnNames = ('njets', 'nbjets'),
binnings = (Echo(), Echo()),
countsClass = Counts),
]
alphaTwirl.addTreeReader(
analyzerName = 'treeProducerSusyAlphaT',
fileName = 'tree.root',
treeName = 'tree',
tableConfigs = tblcfg,
eventSelection = None,
)
alphaTwirl.run()
##__________________________________________________________________||
def test_valid(self):
binning = Echo(valid=lambda x: x >= 10)
self.assertEqual(13, binning(13))
self.assertEqual(10, binning(10))
self.assertIsNone(binning(7))
def test_call(self):
binning = Echo()
self.assertEqual(1, binning(1))
self.assertEqual(2, binning(2))
self.assertEqual(0, binning(0))
self.assertEqual(5, binning(5))
def test_two(self):
"""
1:composite
|- 3:composite
| |- 4:counter
| |- 5:counter
|
|- 7:counter
|- 8:counter
"""
progressReporter1 = MockProgressReporter()
keyComposer4 = KeyValueComposer(('var4', ), (Echo(), ))
counts4 = Count()
reader4 = Reader(keyComposer4, counts4)
collector4 = Collector(MockResultsCombinationMethod())
keyComposer5 = KeyValueComposer(('var5', ), (Echo(), ))
counts5 = Count()
reader5 = Reader(keyComposer5, counts5)
collector5 = Collector(MockResultsCombinationMethod())
keyComposer7 = KeyValueComposer(('var7', ), (Echo(), ))
counts7 = Count()
reader7 = Reader(keyComposer7, counts7)
collector7 = Collector(MockResultsCombinationMethod())
keyComposer8 = KeyValueComposer(('var8', ), (Echo(), ))
counts8 = Count()
reader8 = Reader(keyComposer8, counts8)
collector8 = Collector(MockResultsCombinationMethod())
reader3 = ReaderComposite()
reader3.add(reader4)
reader3.add(reader5)
collector3 = CollectorComposite(progressReporter1)
collector3.add(collector4)
collector3.add(collector5)
reader1 = ReaderComposite()
reader1.add(reader3)
reader1.add(reader7)
reader1.add(reader8)
collector1 = CollectorComposite(progressReporter1)
collector1.add(collector3)
collector1.add(collector7)
collector1.add(collector8)
associator1 = Associator(reader1, collector1)
reader1_ds1 = associator1.make('ds1')
reader1_ds2 = associator1.make('ds2')
reader3_ds1 = reader1_ds1.readers[0]
reader4_ds1 = reader3_ds1.readers[0]
reader5_ds1 = reader3_ds1.readers[1]
reader7_ds1 = reader1_ds1.readers[1]
reader8_ds1 = reader1_ds1.readers[2]
self.assertIsInstance(reader1_ds1, ReaderComposite)
self.assertIsInstance(reader3_ds1, ReaderComposite)
self.assertIsInstance(reader4_ds1, Reader)
self.assertIsInstance(reader5_ds1, Reader)
self.assertIsInstance(reader7_ds1, Reader)
self.assertIsInstance(reader8_ds1, Reader)
self.assertIsNot(reader1, reader1_ds1)
self.assertIsNot(reader3, reader3_ds1)
self.assertIsNot(reader4, reader4_ds1)
self.assertIsNot(reader5, reader5_ds1)
self.assertIsNot(reader7, reader7_ds1)
self.assertIsNot(reader8, reader8_ds1)
reader3_ds2 = reader1_ds2.readers[0]
reader4_ds2 = reader3_ds2.readers[0]
reader5_ds2 = reader3_ds2.readers[1]
reader7_ds2 = reader1_ds2.readers[1]
reader8_ds2 = reader1_ds2.readers[2]
self.assertIsInstance(reader1_ds2, ReaderComposite)
self.assertIsInstance(reader3_ds2, ReaderComposite)
self.assertIsInstance(reader4_ds2, Reader)
self.assertIsInstance(reader5_ds2, Reader)
self.assertIsInstance(reader7_ds2, Reader)
self.assertIsInstance(reader8_ds2, Reader)
self.assertIsNot(reader1, reader1_ds2)
self.assertIsNot(reader3, reader3_ds2)
self.assertIsNot(reader4, reader4_ds2)
self.assertIsNot(reader5, reader5_ds2)
self.assertIsNot(reader7, reader7_ds2)
self.assertIsNot(reader8, reader8_ds2)
self.assertIs(2, len(collector4._datasetReaderPairs))
self.assertIs(2, len(collector5._datasetReaderPairs))
self.assertIs(2, len(collector7._datasetReaderPairs))
self.assertIs(2, len(collector8._datasetReaderPairs))
self.assertIs('ds1', collector4._datasetReaderPairs[0][0])
self.assertIs('ds1', collector5._datasetReaderPairs[0][0])
self.assertIs('ds1', collector7._datasetReaderPairs[0][0])
self.assertIs('ds1', collector8._datasetReaderPairs[0][0])
self.assertIs(reader4_ds1, collector4._datasetReaderPairs[0][1])
self.assertIs(reader5_ds1, collector5._datasetReaderPairs[0][1])
self.assertIs(reader7_ds1, collector7._datasetReaderPairs[0][1])
self.assertIs(reader8_ds1, collector8._datasetReaderPairs[0][1])
self.assertIs('ds2', collector4._datasetReaderPairs[1][0])
self.assertIs('ds2', collector5._datasetReaderPairs[1][0])
self.assertIs('ds2', collector7._datasetReaderPairs[1][0])
self.assertIs('ds2', collector8._datasetReaderPairs[1][0])
self.assertIs(reader4_ds2, collector4._datasetReaderPairs[1][1])
self.assertIs(reader5_ds2, collector5._datasetReaderPairs[1][1])
self.assertIs(reader7_ds2, collector7._datasetReaderPairs[1][1])
self.assertIs(reader8_ds2, collector8._datasetReaderPairs[1][1])
