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
Log Message:	osu copy modified
#	User	Rev	Content
1	dhidas	1.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			}