Tools/test/TestNTupleEventReader.h

#include "cute/cute.h"
#include "cute/cute_suite.h"
#include <boost/scoped_ptr.hpp>

#include "../interface/Event.h"
#include "../interface/TopPairEventCandidate.h"
#include "../interface/Readers/NTupleEventReader.h"
#include "InputFiles.h"

using namespace BAT;

struct TestNTupleEventReader {
private:
    boost::scoped_ptr<NTupleEventReader> TTbarReader;
    boost::scoped_ptr<NTupleEventReader> QCDenri1Reader;
    boost::scoped_ptr<NTupleEventReader> QCDenri2Reader;
    boost::scoped_ptr<NTupleEventReader> QCDenri3Reader;

    boost::scoped_ptr<NTupleEventReader> QCDbce1Reader;
    boost::scoped_ptr<NTupleEventReader> QCDbce2Reader;
    boost::scoped_ptr<NTupleEventReader> QCDbce3Reader;

    boost::scoped_ptr<NTupleEventReader> WjetsReader;
    boost::scoped_ptr<NTupleEventReader> ZJetsReader;
    boost::scoped_ptr<NTupleEventReader> TWReader;
    boost::scoped_ptr<NTupleEventReader> TChanReader;
    boost::scoped_ptr<NTupleEventReader> DataReader;
    boost::scoped_ptr<NTupleEventReader> DataReader2;
    boost::scoped_ptr<NTupleEventReader> AllMCReader;

public:
    TestNTupleEventReader() :
        TTbarReader(new NTupleEventReader()),
        QCDenri1Reader(new NTupleEventReader()),
        QCDenri2Reader(new NTupleEventReader()),
        QCDenri3Reader(new NTupleEventReader()),
        QCDbce1Reader(new NTupleEventReader()),
        QCDbce2Reader(new NTupleEventReader()),
        QCDbce3Reader(new NTupleEventReader()),
        WjetsReader(new NTupleEventReader()),
        ZJetsReader(new NTupleEventReader()),
        TWReader(new NTupleEventReader()),
        TChanReader(new NTupleEventReader()),
        DataReader(new NTupleEventReader()),
        DataReader2(new NTupleEventReader()),
        AllMCReader(new NTupleEventReader()) {

        TTbarReader->addInputFile(InputFile::ttbar);
        QCDenri1Reader->addInputFile(InputFile::enri1);
        QCDenri2Reader->addInputFile(InputFile::enri2);
        QCDenri3Reader->addInputFile(InputFile::enri3);

        QCDbce1Reader->addInputFile(InputFile::bce1);
        QCDbce2Reader->addInputFile(InputFile::bce2);
        QCDbce3Reader->addInputFile(InputFile::bce3);

        WjetsReader->addInputFile(InputFile::wjets);
        ZJetsReader->addInputFile(InputFile::zjets);
        TWReader->addInputFile(InputFile::tW);
        TChanReader->addInputFile(InputFile::tchan);
        DataReader->addInputFile(InputFile::data);
        DataReader->addInputFile(InputFile::data2);
        DataReader2->addInputFile(InputFile::data2);
        DataReader2->addInputFile(InputFile::data);

        AllMCReader->addInputFile(InputFile::ttbar);
        AllMCReader->addInputFile(InputFile::enri1);
        AllMCReader->addInputFile(InputFile::enri2);
        AllMCReader->addInputFile(InputFile::enri3);
        AllMCReader->addInputFile(InputFile::bce1);
        AllMCReader->addInputFile(InputFile::bce2);
        AllMCReader->addInputFile(InputFile::bce3);
        AllMCReader->addInputFile(InputFile::wjets);
        AllMCReader->addInputFile(InputFile::zjets);
        AllMCReader->addInputFile(InputFile::tW);
        AllMCReader->addInputFile(InputFile::tchan);
        AllMCReader->addInputFile(InputFile::pj1);
        AllMCReader->addInputFile(InputFile::pj2);
        AllMCReader->addInputFile(InputFile::pj3);

    }

    void testTTbarType() {
        Event currentEvent = TTbarReader->getNextEvent();
        ASSERT_EQUAL(DataType::ttbar, currentEvent.getDataType());
    }

    void testQCD_EMEnriched_80_to_170Type() {
        Event currentEvent = QCDenri3Reader->getNextEvent();
        ASSERT_EQUAL(DataType::QCD_EMEnriched_Pt80to170, currentEvent.getDataType());
    }

    void testQCD_EMEnriched_30_to_80Type() {
        Event currentEvent = QCDenri2Reader->getNextEvent();
        ASSERT_EQUAL(DataType::QCD_EMEnriched_Pt30to80, currentEvent.getDataType());
    }

    void testQCD_EMEnriched_20_to_30Type() {
        Event currentEvent = QCDenri1Reader->getNextEvent();
        ASSERT_EQUAL(DataType::QCD_EMEnriched_Pt20to30, currentEvent.getDataType());
    }

    void testQCD_BCtoE_80_to_170Type() {
        Event currentEvent = QCDbce3Reader->getNextEvent();
        ASSERT_EQUAL(DataType::QCD_BCtoE_Pt80to170, currentEvent.getDataType());
    }

    void testQCD_BCtoE_30_to_80Type() {
        Event currentEvent = QCDbce2Reader->getNextEvent();
        ASSERT_EQUAL(DataType::QCD_BCtoE_Pt30to80, currentEvent.getDataType());
    }

    void testQCD_BCtoE_20_to_30Type() {
        Event currentEvent = QCDbce1Reader->getNextEvent();
        ASSERT_EQUAL(DataType::QCD_BCtoE_Pt20to30, currentEvent.getDataType());
    }

    void testWjetsType() {
        Event currentEvent = WjetsReader->getNextEvent();
        ASSERT_EQUAL(DataType::Wjets, currentEvent.getDataType());
    }

    void testZjetsType() {
        ASSERT(ZJetsReader->hasNextEvent());
        Event currentEvent = ZJetsReader->getNextEvent();
        ASSERT_EQUAL(DataType::Zjets, currentEvent.getDataType());
    }

    void testTWType() {
        ASSERT(TWReader->hasNextEvent());
        Event currentEvent = TWReader->getNextEvent();
        ASSERT_EQUAL(DataType::singleTop_And_W, currentEvent.getDataType());
    }

    void testTChanType() {
        Event currentEvent = TChanReader->getNextEvent();
        ASSERT_EQUAL(DataType::singleTopTChannel, currentEvent.getDataType());
    }

    void testDataType() {
        Event currentEvent = DataReader->getNextEvent();
        ASSERT_EQUAL(DataType::DATA, currentEvent.getDataType());
    }

    void testReadDataType() {
        ASSERT(DataReader->hasNextEvent());
        Event currentEvent = DataReader->getNextEvent();
        ASSERT_EQUAL(true, currentEvent.isRealData());
    }

    void testNumberOfTracksInEvent1() {
        ASSERT(TTbarReader->hasNextEvent());
        Event currentEvent = TTbarReader->getNextEvent();
        ASSERT_EQUAL(0, currentEvent.Tracks().size());//Tracks deactivated
    }

    void testNumberOfElectronsInEvent1() {
        Event currentEvent = TTbarReader->getNextEvent();
        ASSERT_EQUAL(2, currentEvent.Electrons().size());
    }

    void testNumberOfJetsInEvent1() {
        Event currentEvent = TTbarReader->getNextEvent();
        ASSERT_EQUAL(8, currentEvent.Jets().size());
    }

    void testNumberOfMuonsInEvent1() {
        Event currentEvent = TTbarReader->getNextEvent();
        ASSERT_EQUAL(1, currentEvent.Muons().size());
    }

    void testHasNextEvent() {
        ASSERT_EQUAL(true, TTbarReader->hasNextEvent());
    }

    void testHasNotNextEvent() {
        TTbarReader->skipNumberOfEvents(123456789);
        ASSERT(TTbarReader->hasNextEvent() == false);
    }

    void testGetProccessedNumberOfEvents() {
        TTbarReader->getNextEvent();
        ASSERT_EQUAL(1, TTbarReader->getNumberOfProccessedEvents());
        TTbarReader->getNextEvent();
        ASSERT_EQUAL(2, TTbarReader->getNumberOfProccessedEvents());
    }

    void testGetProccessedNumberOfEventsWithSkippedEvents() {
        TTbarReader->getNextEvent();
        TTbarReader->skipNumberOfEvents(100);
        ASSERT_EQUAL(1, TTbarReader->getNumberOfProccessedEvents());
    }
    void testSkipEvents() {
        TTbarReader->skipNumberOfEvents(10);
        ASSERT_EQUAL(10, TTbarReader->getCurrentLocalEventNumber());
    }

    void testGetCurrentLocalEventNumber() {
        ASSERT_EQUAL(0, TTbarReader->getCurrentLocalEventNumber());
        TTbarReader->getNextEvent();
        ASSERT_EQUAL(1, TTbarReader->getCurrentLocalEventNumber());
    }

    void testSetMaximumNumberOfEventsWithSkippedEvents() {
        TTbarReader->setMaximumNumberOfEvents(5);
        TTbarReader->skipNumberOfEvents(10);
        ASSERT(TTbarReader->hasNextEvent() == false);
    }

    void testSetMaximumNumberOfEvents() {
        unsigned int maxEvents = 5;
        TTbarReader->setMaximumNumberOfEvents(maxEvents);
        while (TTbarReader->hasNextEvent())
            TTbarReader->getNextEvent();
        ASSERT_EQUAL(maxEvents, TTbarReader->getNumberOfProccessedEvents());
    }

    void testMCRunNumber() {
        ASSERT_EQUAL(1, TTbarReader->getNextEvent().runnumber());
    }

    void testMCLumiBlock() {
        ASSERT_EQUAL(7, TTbarReader->getNextEvent().lumiblock());
    }

    void testLocalEventNumber() {
        ASSERT_EQUAL(1, TTbarReader->getNextEvent().localnumber());
    }

    void testInitialEventWeigth() {
        ASSERT(TTbarReader->hasNextEvent());
        ASSERT_EQUAL(1., TTbarReader->getNextEvent().weight());
    }

    void testPrimaryVertex() {
        ASSERT_EQUAL(true, TTbarReader->getNextEvent().PrimaryVertex()->isGood());
    }

    void testHLTTrigger() {
        TopPairEventCandidate candidate = TopPairEventCandidate(TTbarReader->getNextEvent());
        ASSERT_EQUAL(true, candidate.passesHighLevelTrigger());
    }

    void testEventChainConstant() {
        ASSERT_EQUAL(0, strcmp("rootTupleTree/tree", NTupleEventReader::EVENT_CHAIN));
    }

    void testTTbarEventMET() {
        Event event = TTbarReader->getNextEvent();
        ASSERT_EQUAL_DELTA(69.2572,event.MET()->et(), 0.001);
    }

    void testSeenTTbar() {
        const boost::array<bool, DataType::NUMBER_OF_DATA_TYPES> seenTypes = TTbarReader->getSeenDatatypes();

        for (unsigned short index = 0; index < DataType::NUMBER_OF_DATA_TYPES; ++index) {
            if (index == DataType::ttbar)
                ASSERT_EQUAL(true, seenTypes.at(index));
                else
                ASSERT_EQUAL(false, seenTypes.at(index));
        }
    }

    void testSeenAllMC() {
        const boost::array<bool, DataType::NUMBER_OF_DATA_TYPES> seenTypes = AllMCReader->getSeenDatatypes();

        for (unsigned short index = 0; index < DataType::NUMBER_OF_DATA_TYPES; ++index) {
            if (index == DataType::DATA || index >= DataType::Zprime_M500GeV_W5GeV || index
                    == DataType::singleTopSChannel || index == DataType::VQQ)
                ASSERT_EQUAL(false, seenTypes.at(index));
            else {
                std::string msg("index ");
                std::stringstream stream;
                stream << index;
                msg += stream.str();
                ASSERT_EQUALM(msg.c_str(), true, seenTypes.at(index));
            }

        }
    }

    void testAddInputFileNoFileThrowsException() {
        boost::scoped_ptr<NTupleEventReader> reader(new NTupleEventReader());
        ASSERT_THROWS(reader->addInputFile("dfjndkjvnvh"), NoFileFoundException);
    }

    void testGenJetsMC() {
                Event event = TTbarReader->getNextEvent();
                ASSERT_EQUAL(10, event.GenJets().size());
        }

        void testGenJetsDATA() {
                Event event = DataReader->getNextEvent();
                ASSERT_EQUAL(0, event.GenJets().size());
        }

};

extern cute::suite make_suite_TestNTupleEventReader() {
    cute::suite s;

    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testTTbarType));

    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testQCD_EMEnriched_20_to_30Type));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testQCD_EMEnriched_30_to_80Type));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testQCD_EMEnriched_80_to_170Type));

    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testQCD_BCtoE_20_to_30Type));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testQCD_BCtoE_30_to_80Type));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testQCD_BCtoE_80_to_170Type));

    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testWjetsType));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testZjetsType));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testTWType));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testTChanType));

    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testDataType));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testReadDataType));

    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testNumberOfTracksInEvent1));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testNumberOfElectronsInEvent1));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testNumberOfJetsInEvent1));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testNumberOfMuonsInEvent1));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testHasNextEvent));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testHasNotNextEvent));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testGetProccessedNumberOfEvents));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testGetProccessedNumberOfEventsWithSkippedEvents));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testSkipEvents));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testGetCurrentLocalEventNumber));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testSetMaximumNumberOfEventsWithSkippedEvents));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testSetMaximumNumberOfEvents));

    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testMCRunNumber));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testMCLumiBlock));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testLocalEventNumber));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testInitialEventWeigth));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testPrimaryVertex));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testHLTTrigger));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testEventChainConstant));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testTTbarEventMET));

    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testSeenTTbar));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testSeenAllMC));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testAddInputFileNoFileThrowsException));

    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testGenJetsMC));
    s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testGenJetsDATA));

    return s;
}
Revision:	1.1.1.1 (vendor branch)
Committed:	Thu Dec 1 16:28:47 2011 UTC (13 years, 5 months ago) by dhidas
Content type:	text/plain
Branch:	dhidas, MAIN
CVS Tags:	START, HEAD
Changes since 1.1:	+0 -0 lines
Error occurred while calculating annotation data.
Log Message:	osu copy modified
#	Content
1	#include "cute/cute.h"
2	#include "cute/cute_suite.h"
3	#include <boost/scoped_ptr.hpp>
4
5	#include "../interface/Event.h"
6	#include "../interface/TopPairEventCandidate.h"
7	#include "../interface/Readers/NTupleEventReader.h"
8	#include "InputFiles.h"
9
10	using namespace BAT;
11
12	struct TestNTupleEventReader {
13	private:
14	boost::scoped_ptr<NTupleEventReader> TTbarReader;
15	boost::scoped_ptr<NTupleEventReader> QCDenri1Reader;
16	boost::scoped_ptr<NTupleEventReader> QCDenri2Reader;
17	boost::scoped_ptr<NTupleEventReader> QCDenri3Reader;
18
19	boost::scoped_ptr<NTupleEventReader> QCDbce1Reader;
20	boost::scoped_ptr<NTupleEventReader> QCDbce2Reader;
21	boost::scoped_ptr<NTupleEventReader> QCDbce3Reader;
22
23	boost::scoped_ptr<NTupleEventReader> WjetsReader;
24	boost::scoped_ptr<NTupleEventReader> ZJetsReader;
25	boost::scoped_ptr<NTupleEventReader> TWReader;
26	boost::scoped_ptr<NTupleEventReader> TChanReader;
27	boost::scoped_ptr<NTupleEventReader> DataReader;
28	boost::scoped_ptr<NTupleEventReader> DataReader2;
29	boost::scoped_ptr<NTupleEventReader> AllMCReader;
30
31	public:
32	TestNTupleEventReader() :
33	TTbarReader(new NTupleEventReader()),
34	QCDenri1Reader(new NTupleEventReader()),
35	QCDenri2Reader(new NTupleEventReader()),
36	QCDenri3Reader(new NTupleEventReader()),
37	QCDbce1Reader(new NTupleEventReader()),
38	QCDbce2Reader(new NTupleEventReader()),
39	QCDbce3Reader(new NTupleEventReader()),
40	WjetsReader(new NTupleEventReader()),
41	ZJetsReader(new NTupleEventReader()),
42	TWReader(new NTupleEventReader()),
43	TChanReader(new NTupleEventReader()),
44	DataReader(new NTupleEventReader()),
45	DataReader2(new NTupleEventReader()),
46	AllMCReader(new NTupleEventReader()) {
47
48	TTbarReader->addInputFile(InputFile::ttbar);
49	QCDenri1Reader->addInputFile(InputFile::enri1);
50	QCDenri2Reader->addInputFile(InputFile::enri2);
51	QCDenri3Reader->addInputFile(InputFile::enri3);
52
53	QCDbce1Reader->addInputFile(InputFile::bce1);
54	QCDbce2Reader->addInputFile(InputFile::bce2);
55	QCDbce3Reader->addInputFile(InputFile::bce3);
56
57	WjetsReader->addInputFile(InputFile::wjets);
58	ZJetsReader->addInputFile(InputFile::zjets);
59	TWReader->addInputFile(InputFile::tW);
60	TChanReader->addInputFile(InputFile::tchan);
61	DataReader->addInputFile(InputFile::data);
62	DataReader->addInputFile(InputFile::data2);
63	DataReader2->addInputFile(InputFile::data2);
64	DataReader2->addInputFile(InputFile::data);
65
66	AllMCReader->addInputFile(InputFile::ttbar);
67	AllMCReader->addInputFile(InputFile::enri1);
68	AllMCReader->addInputFile(InputFile::enri2);
69	AllMCReader->addInputFile(InputFile::enri3);
70	AllMCReader->addInputFile(InputFile::bce1);
71	AllMCReader->addInputFile(InputFile::bce2);
72	AllMCReader->addInputFile(InputFile::bce3);
73	AllMCReader->addInputFile(InputFile::wjets);
74	AllMCReader->addInputFile(InputFile::zjets);
75	AllMCReader->addInputFile(InputFile::tW);
76	AllMCReader->addInputFile(InputFile::tchan);
77	AllMCReader->addInputFile(InputFile::pj1);
78	AllMCReader->addInputFile(InputFile::pj2);
79	AllMCReader->addInputFile(InputFile::pj3);
80
81	}
82
83	void testTTbarType() {
84	Event currentEvent = TTbarReader->getNextEvent();
85	ASSERT_EQUAL(DataType::ttbar, currentEvent.getDataType());
86	}
87
88	void testQCD_EMEnriched_80_to_170Type() {
89	Event currentEvent = QCDenri3Reader->getNextEvent();
90	ASSERT_EQUAL(DataType::QCD_EMEnriched_Pt80to170, currentEvent.getDataType());
91	}
92
93	void testQCD_EMEnriched_30_to_80Type() {
94	Event currentEvent = QCDenri2Reader->getNextEvent();
95	ASSERT_EQUAL(DataType::QCD_EMEnriched_Pt30to80, currentEvent.getDataType());
96	}
97
98	void testQCD_EMEnriched_20_to_30Type() {
99	Event currentEvent = QCDenri1Reader->getNextEvent();
100	ASSERT_EQUAL(DataType::QCD_EMEnriched_Pt20to30, currentEvent.getDataType());
101	}
102
103	void testQCD_BCtoE_80_to_170Type() {
104	Event currentEvent = QCDbce3Reader->getNextEvent();
105	ASSERT_EQUAL(DataType::QCD_BCtoE_Pt80to170, currentEvent.getDataType());
106	}
107
108	void testQCD_BCtoE_30_to_80Type() {
109	Event currentEvent = QCDbce2Reader->getNextEvent();
110	ASSERT_EQUAL(DataType::QCD_BCtoE_Pt30to80, currentEvent.getDataType());
111	}
112
113	void testQCD_BCtoE_20_to_30Type() {
114	Event currentEvent = QCDbce1Reader->getNextEvent();
115	ASSERT_EQUAL(DataType::QCD_BCtoE_Pt20to30, currentEvent.getDataType());
116	}
117
118	void testWjetsType() {
119	Event currentEvent = WjetsReader->getNextEvent();
120	ASSERT_EQUAL(DataType::Wjets, currentEvent.getDataType());
121	}
122
123	void testZjetsType() {
124	ASSERT(ZJetsReader->hasNextEvent());
125	Event currentEvent = ZJetsReader->getNextEvent();
126	ASSERT_EQUAL(DataType::Zjets, currentEvent.getDataType());
127	}
128
129	void testTWType() {
130	ASSERT(TWReader->hasNextEvent());
131	Event currentEvent = TWReader->getNextEvent();
132	ASSERT_EQUAL(DataType::singleTop_And_W, currentEvent.getDataType());
133	}
134
135	void testTChanType() {
136	Event currentEvent = TChanReader->getNextEvent();
137	ASSERT_EQUAL(DataType::singleTopTChannel, currentEvent.getDataType());
138	}
139
140	void testDataType() {
141	Event currentEvent = DataReader->getNextEvent();
142	ASSERT_EQUAL(DataType::DATA, currentEvent.getDataType());
143	}
144
145	void testReadDataType() {
146	ASSERT(DataReader->hasNextEvent());
147	Event currentEvent = DataReader->getNextEvent();
148	ASSERT_EQUAL(true, currentEvent.isRealData());
149	}
150
151	void testNumberOfTracksInEvent1() {
152	ASSERT(TTbarReader->hasNextEvent());
153	Event currentEvent = TTbarReader->getNextEvent();
154	ASSERT_EQUAL(0, currentEvent.Tracks().size());//Tracks deactivated
155	}
156
157	void testNumberOfElectronsInEvent1() {
158	Event currentEvent = TTbarReader->getNextEvent();
159	ASSERT_EQUAL(2, currentEvent.Electrons().size());
160	}
161
162	void testNumberOfJetsInEvent1() {
163	Event currentEvent = TTbarReader->getNextEvent();
164	ASSERT_EQUAL(8, currentEvent.Jets().size());
165	}
166
167	void testNumberOfMuonsInEvent1() {
168	Event currentEvent = TTbarReader->getNextEvent();
169	ASSERT_EQUAL(1, currentEvent.Muons().size());
170	}
171
172	void testHasNextEvent() {
173	ASSERT_EQUAL(true, TTbarReader->hasNextEvent());
174	}
175
176	void testHasNotNextEvent() {
177	TTbarReader->skipNumberOfEvents(123456789);
178	ASSERT(TTbarReader->hasNextEvent() == false);
179	}
180
181	void testGetProccessedNumberOfEvents() {
182	TTbarReader->getNextEvent();
183	ASSERT_EQUAL(1, TTbarReader->getNumberOfProccessedEvents());
184	TTbarReader->getNextEvent();
185	ASSERT_EQUAL(2, TTbarReader->getNumberOfProccessedEvents());
186	}
187
188	void testGetProccessedNumberOfEventsWithSkippedEvents() {
189	TTbarReader->getNextEvent();
190	TTbarReader->skipNumberOfEvents(100);
191	ASSERT_EQUAL(1, TTbarReader->getNumberOfProccessedEvents());
192	}
193	void testSkipEvents() {
194	TTbarReader->skipNumberOfEvents(10);
195	ASSERT_EQUAL(10, TTbarReader->getCurrentLocalEventNumber());
196	}
197
198	void testGetCurrentLocalEventNumber() {
199	ASSERT_EQUAL(0, TTbarReader->getCurrentLocalEventNumber());
200	TTbarReader->getNextEvent();
201	ASSERT_EQUAL(1, TTbarReader->getCurrentLocalEventNumber());
202	}
203
204	void testSetMaximumNumberOfEventsWithSkippedEvents() {
205	TTbarReader->setMaximumNumberOfEvents(5);
206	TTbarReader->skipNumberOfEvents(10);
207	ASSERT(TTbarReader->hasNextEvent() == false);
208	}
209
210	void testSetMaximumNumberOfEvents() {
211	unsigned int maxEvents = 5;
212	TTbarReader->setMaximumNumberOfEvents(maxEvents);
213	while (TTbarReader->hasNextEvent())
214	TTbarReader->getNextEvent();
215	ASSERT_EQUAL(maxEvents, TTbarReader->getNumberOfProccessedEvents());
216	}
217
218	void testMCRunNumber() {
219	ASSERT_EQUAL(1, TTbarReader->getNextEvent().runnumber());
220	}
221
222	void testMCLumiBlock() {
223	ASSERT_EQUAL(7, TTbarReader->getNextEvent().lumiblock());
224	}
225
226	void testLocalEventNumber() {
227	ASSERT_EQUAL(1, TTbarReader->getNextEvent().localnumber());
228	}
229
230	void testInitialEventWeigth() {
231	ASSERT(TTbarReader->hasNextEvent());
232	ASSERT_EQUAL(1., TTbarReader->getNextEvent().weight());
233	}
234
235	void testPrimaryVertex() {
236	ASSERT_EQUAL(true, TTbarReader->getNextEvent().PrimaryVertex()->isGood());
237	}
238
239	void testHLTTrigger() {
240	TopPairEventCandidate candidate = TopPairEventCandidate(TTbarReader->getNextEvent());
241	ASSERT_EQUAL(true, candidate.passesHighLevelTrigger());
242	}
243
244	void testEventChainConstant() {
245	ASSERT_EQUAL(0, strcmp("rootTupleTree/tree", NTupleEventReader::EVENT_CHAIN));
246	}
247
248	void testTTbarEventMET() {
249	Event event = TTbarReader->getNextEvent();
250	ASSERT_EQUAL_DELTA(69.2572,event.MET()->et(), 0.001);
251	}
252
253	void testSeenTTbar() {
254	const boost::array<bool, DataType::NUMBER_OF_DATA_TYPES> seenTypes = TTbarReader->getSeenDatatypes();
255
256	for (unsigned short index = 0; index < DataType::NUMBER_OF_DATA_TYPES; ++index) {
257	if (index == DataType::ttbar)
258	ASSERT_EQUAL(true, seenTypes.at(index));
259	else
260	ASSERT_EQUAL(false, seenTypes.at(index));
261	}
262	}
263
264	void testSeenAllMC() {
265	const boost::array<bool, DataType::NUMBER_OF_DATA_TYPES> seenTypes = AllMCReader->getSeenDatatypes();
266
267	for (unsigned short index = 0; index < DataType::NUMBER_OF_DATA_TYPES; ++index) {
268	if (index == DataType::DATA \|\| index >= DataType::Zprime_M500GeV_W5GeV \|\| index
269	== DataType::singleTopSChannel \|\| index == DataType::VQQ)
270	ASSERT_EQUAL(false, seenTypes.at(index));
271	else {
272	std::string msg("index ");
273	std::stringstream stream;
274	stream << index;
275	msg += stream.str();
276	ASSERT_EQUALM(msg.c_str(), true, seenTypes.at(index));
277	}
278
279	}
280	}
281
282	void testAddInputFileNoFileThrowsException() {
283	boost::scoped_ptr<NTupleEventReader> reader(new NTupleEventReader());
284	ASSERT_THROWS(reader->addInputFile("dfjndkjvnvh"), NoFileFoundException);
285	}
286
287	void testGenJetsMC() {
288	Event event = TTbarReader->getNextEvent();
289	ASSERT_EQUAL(10, event.GenJets().size());
290	}
291
292	void testGenJetsDATA() {
293	Event event = DataReader->getNextEvent();
294	ASSERT_EQUAL(0, event.GenJets().size());
295	}
296
297	};
298
299	extern cute::suite make_suite_TestNTupleEventReader() {
300	cute::suite s;
301
302	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testTTbarType));
303
304	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testQCD_EMEnriched_20_to_30Type));
305	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testQCD_EMEnriched_30_to_80Type));
306	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testQCD_EMEnriched_80_to_170Type));
307
308	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testQCD_BCtoE_20_to_30Type));
309	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testQCD_BCtoE_30_to_80Type));
310	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testQCD_BCtoE_80_to_170Type));
311
312	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testWjetsType));
313	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testZjetsType));
314	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testTWType));
315	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testTChanType));
316
317	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testDataType));
318	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testReadDataType));
319
320	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testNumberOfTracksInEvent1));
321	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testNumberOfElectronsInEvent1));
322	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testNumberOfJetsInEvent1));
323	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testNumberOfMuonsInEvent1));
324	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testHasNextEvent));
325	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testHasNotNextEvent));
326	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testGetProccessedNumberOfEvents));
327	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testGetProccessedNumberOfEventsWithSkippedEvents));
328	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testSkipEvents));
329	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testGetCurrentLocalEventNumber));
330	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testSetMaximumNumberOfEventsWithSkippedEvents));
331	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testSetMaximumNumberOfEvents));
332
333	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testMCRunNumber));
334	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testMCLumiBlock));
335	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testLocalEventNumber));
336	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testInitialEventWeigth));
337	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testPrimaryVertex));
338	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testHLTTrigger));
339	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testEventChainConstant));
340	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testTTbarEventMET));
341
342	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testSeenTTbar));
343	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testSeenAllMC));
344	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testAddInputFileNoFileThrowsException));
345
346	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testGenJetsMC));
347	s.push_back(CUTE_SMEMFUN(TestNTupleEventReader, testGenJetsDATA));
348
349	return s;
350	}