Tools/test/TestEvent.h

#include "cute/cute.h"
#include "cute/cute_suite.h"

#include <boost/scoped_ptr.hpp>

#include "../interface/Event.h"

using namespace BAT;

struct TestEvent {
    Event ttbarEvent, goodZEvent, poorZEvent, DiJetEvent, DiJetEventWithConversion, muonEvent;
    Event emptyEvent;
    ElectronPointer goodIsolatedElectron, goodIsolatedElectron2;
    ElectronPointer goodLooseElectron;
    ElectronPointer badEtElectron;
    ElectronPointer electronFromConversion;
    JetPointer goodJet, goodBJet, badJet, goodJetCloseToElectron;
    VertexPointer goodVertex;
    VertexPointer badVertex;
    MuonPointer goodIsolatedMuon;
    MuonPointer badMuon;
    METPointer met;

    TestEvent() :
    ttbarEvent(),
    goodZEvent(),
    poorZEvent(),
    DiJetEvent(),
    DiJetEventWithConversion(),
    muonEvent(),
    emptyEvent(),
    goodIsolatedElectron(TestObjectFactory::goodIsolatedElectron()),
    goodIsolatedElectron2(TestObjectFactory::goodIsolatedElectron2()),
    goodLooseElectron(TestObjectFactory::goodLooseElectron()),
    badEtElectron(TestObjectFactory::badEtElectron()),
    electronFromConversion(TestObjectFactory::electronWithMissingInnerLayerHit()),
    goodJet(TestObjectFactory::goodCaloJet()),
    goodBJet(TestObjectFactory::goodCaloBJetSSVHEM()),
    badJet(TestObjectFactory::badEMFCaloJet()),
    goodJetCloseToElectron(TestObjectFactory::goodCaloJetCloseToCaloElectron()),
    goodVertex(TestObjectFactory::goodVertex()),
    badVertex(TestObjectFactory::badFakeVertex()),
    goodIsolatedMuon(TestObjectFactory::goodIsolatedMuon()),
    badMuon(TestObjectFactory::badNonGlobalMuon()),
    met(TestObjectFactory::goodMET()) {

        setUpTTbarEvent();
        setUpGoodZEvent();
        setUpPoorZEvent();
        setUpDiJetEvent();
        setUpMuonEvent();
    }

private:

    void setUpTTbarEvent() {
        VertexCollection vertices;
        vertices.push_back(goodVertex);
        ttbarEvent.setVertices(vertices);
        ElectronCollection electrons;
        electrons.push_back(goodIsolatedElectron);
        electrons.push_back(badEtElectron);
        ttbarEvent.setElectrons(electrons);
        JetCollection jets;
        jets.push_back(goodJet);
        jets.push_back(goodJet);
        jets.push_back(goodBJet);
        jets.push_back(goodBJet);
        jets.push_back(badJet);
        ttbarEvent.setJets(jets);

        MuonCollection muons;
        muons.push_back(badMuon);
        ttbarEvent.setMuons(muons);
        ttbarEvent.setMET(met);
    }

    void setUpGoodZEvent() {
        VertexCollection vertices;
        vertices.push_back(goodVertex);
        goodZEvent.setVertices(vertices);
        ElectronCollection electrons;
        electrons.push_back(goodIsolatedElectron);
        electrons.push_back(goodIsolatedElectron2);
        electrons.push_back(badEtElectron);
        goodZEvent.setElectrons(electrons);

        JetCollection jets;
        jets.push_back(goodJet);
        jets.push_back(goodJet);
        jets.push_back(goodJet);
        jets.push_back(goodBJet);
        goodZEvent.setJets(jets);

    }

    void setUpPoorZEvent() {
        VertexCollection vertices;
        vertices.push_back(goodVertex);
        poorZEvent.setVertices(vertices);
        ElectronCollection electrons;
        electrons.push_back(goodIsolatedElectron);
        electrons.push_back(goodLooseElectron);
        electrons.push_back(badEtElectron);
        poorZEvent.setElectrons(electrons);

        JetCollection jets;
        jets.push_back(goodJet);
        jets.push_back(goodJet);
        jets.push_back(goodJet);
        jets.push_back(goodBJet);
        poorZEvent.setJets(jets);

    }

    void setUpDiJetEvent() {
        VertexCollection vertices;
        vertices.push_back(badVertex);
        DiJetEvent.setVertices(vertices);
        JetCollection jets;
        jets.push_back(goodJet);
        jets.push_back(goodJet);
        DiJetEvent.setJets(jets);

    }

    void setUpDiJetEventWithConversion() {
        VertexCollection vertices;
        vertices.push_back(goodVertex);
        DiJetEventWithConversion.setVertices(vertices);
        JetCollection jets;
        jets.push_back(goodJet);
        jets.push_back(goodJet);
        DiJetEventWithConversion.setJets(jets);

        ElectronCollection electrons;
        electrons.push_back(electronFromConversion);
        DiJetEventWithConversion.setElectrons(electrons);
    }

    void setUpMuonEvent() {
        VertexCollection vertices;
        vertices.push_back(goodVertex);
        muonEvent.setVertices(vertices);
        ElectronCollection electrons;
        electrons.push_back(goodIsolatedElectron);
        electrons.push_back(badEtElectron);
        muonEvent.setElectrons(electrons);
        JetCollection jets;
        jets.push_back(goodJet);
        jets.push_back(goodJet);
        jets.push_back(goodBJet);
        jets.push_back(goodBJet);
        jets.push_back(badJet);
        muonEvent.setJets(jets);
        MuonCollection muons;
        muons.push_back(goodIsolatedMuon);
        muonEvent.setMuons(muons);
    }

public:
    void testNumberOfElectrons() {
        ASSERT_EQUAL(2, ttbarEvent.Electrons().size());
    }

    void testNumberOfGoodElectrons() {
        ASSERT_EQUAL(1, ttbarEvent.GoodElectrons().size());
    }

    void testNumberOfGoodIsolatedElectrons() {
        ASSERT_EQUAL(1, ttbarEvent.GoodIsolatedElectrons().size());
    }

    void testNumberOfJets() {
        ASSERT_EQUAL(5, ttbarEvent.Jets().size());
    }

    void testNumberOfGoodJets() {
        ASSERT_EQUAL(4, ttbarEvent.GoodJets().size());
    }

    void testRunNumber() {
        ttbarEvent.setRunNumber(42);
        ASSERT_EQUAL(42, ttbarEvent.runnumber());
    }

    void testEventNumber() {
        ttbarEvent.setEventNumber(42);
        ASSERT_EQUAL(42, ttbarEvent.eventnumber());
    }

    void testLocalEventNumber() {
        ttbarEvent.setLocalEventNumber(42);
        ASSERT_EQUAL(42, ttbarEvent.localnumber());
    }

    void testLumiBlock() {
        ttbarEvent.setLumiBlock(42);
        ASSERT_EQUAL(42, ttbarEvent.lumiblock());
    }

    void testEventWeight() {
        ttbarEvent.setEventWeight(1.152);
        ASSERT_EQUAL_DELTA(1.152, ttbarEvent.weight(), 0.001);
    }

    void testGetMostIsolatedElectron() {
        ASSERT_EQUAL_DELTA(goodIsolatedElectron2->relativeIsolation(),
                goodZEvent.MostIsolatedElectron()->relativeIsolation(), 0.001);
    }

    void testGoodJetCleaning() {
        Event event = Event();
        VertexCollection vertices;
        vertices.push_back(goodVertex);
        event.setVertices(vertices);
        ElectronCollection electrons;
        electrons.push_back(goodIsolatedElectron);
        electrons.push_back(badEtElectron);
        event.setElectrons(electrons);
        JetCollection jets;
        jets.push_back(goodJet);
        jets.push_back(goodJet);
        jets.push_back(goodBJet);
        jets.push_back(goodBJet);
        jets.push_back(goodJetCloseToElectron);
        event.setJets(jets);
        ASSERT_EQUAL(5, event.Jets().size());
        ASSERT_EQUAL(4, event.GoodJets().size());
    }

    void testGoodJetCleaningNoGoodElectrons() {
        Event event = Event();
        VertexCollection vertices;
        vertices.push_back(goodVertex);
        event.setVertices(vertices);
        ElectronCollection electrons;
        goodIsolatedElectron->setSigmaIEtaIEta(0.01 + 2);
        electrons.push_back(goodIsolatedElectron);
        electrons.push_back(badEtElectron);
        event.setElectrons(electrons);
        JetCollection jets;
        jets.push_back(goodJet);
        jets.push_back(goodJet);
        jets.push_back(goodBJet);
        jets.push_back(goodBJet);
        jets.push_back(goodJetCloseToElectron);
        event.setJets(jets);
        ASSERT_EQUAL(0, event.GoodElectrons().size());
        ASSERT_EQUAL(0, event.GoodIsolatedElectrons().size());
        ASSERT_EQUAL(jets.size(), event.Jets().size());
        ASSERT_EQUAL(jets.size() - 1, event.GoodJets().size());
    }

    void testGoodJetCleaningNoElectrons() {
        Event event = Event();
        VertexCollection vertices;
        vertices.push_back(goodVertex);
        event.setVertices(vertices);
        JetCollection jets;
        jets.push_back(goodJet);
        jets.push_back(goodJet);
        jets.push_back(goodBJet);
        jets.push_back(goodBJet);
        jets.push_back(goodJetCloseToElectron);
        event.setJets(jets);
        ASSERT_EQUAL(jets.size(), event.Jets().size());
        ASSERT_EQUAL(jets.size(), event.GoodJets().size());
    }

    void testGoodJetCleaningNoGoodJets() {
        Event event = Event();
        VertexCollection vertices;
        vertices.push_back(goodVertex);
        event.setVertices(vertices);
        ElectronCollection electrons;
        electrons.push_back(goodIsolatedElectron);
        electrons.push_back(badEtElectron);
        event.setElectrons(electrons);
        JetCollection jets;
        jets.push_back(badJet);
        event.setJets(jets);
        ASSERT_EQUAL(jets.size(), event.Jets().size());
        ASSERT_EQUAL(0, event.GoodJets().size());
    }

    void testMET() {
        ASSERT_EQUAL(50, ttbarEvent.MET()->et());
    }

};

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

    s.push_back(CUTE_SMEMFUN(TestEvent, testNumberOfElectrons));
    s.push_back(CUTE_SMEMFUN(TestEvent, testNumberOfGoodElectrons));
    s.push_back(CUTE_SMEMFUN(TestEvent, testNumberOfGoodIsolatedElectrons));
    s.push_back(CUTE_SMEMFUN(TestEvent, testNumberOfJets));
    s.push_back(CUTE_SMEMFUN(TestEvent, testNumberOfGoodJets));

    s.push_back(CUTE_SMEMFUN(TestEvent, testRunNumber));
    s.push_back(CUTE_SMEMFUN(TestEvent, testEventNumber));
    s.push_back(CUTE_SMEMFUN(TestEvent, testLocalEventNumber));
    s.push_back(CUTE_SMEMFUN(TestEvent, testLumiBlock));
    s.push_back(CUTE_SMEMFUN(TestEvent, testEventWeight));

    s.push_back(CUTE_SMEMFUN(TestEvent, testGetMostIsolatedElectron));

    s.push_back(CUTE_SMEMFUN(TestEvent, testGoodJetCleaning));
    s.push_back(CUTE_SMEMFUN(TestEvent, testGoodJetCleaningNoGoodElectrons));
    s.push_back(CUTE_SMEMFUN(TestEvent, testGoodJetCleaningNoElectrons));
    s.push_back(CUTE_SMEMFUN(TestEvent, testGoodJetCleaningNoGoodJets));
    s.push_back(CUTE_SMEMFUN(TestEvent, testMET));

    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
4			#include <boost/scoped_ptr.hpp>
5
6			#include "../interface/Event.h"
7
8			using namespace BAT;
9
10			struct TestEvent {
11			Event ttbarEvent, goodZEvent, poorZEvent, DiJetEvent, DiJetEventWithConversion, muonEvent;
12			Event emptyEvent;
13			ElectronPointer goodIsolatedElectron, goodIsolatedElectron2;
14			ElectronPointer goodLooseElectron;
15			ElectronPointer badEtElectron;
16			ElectronPointer electronFromConversion;
17			JetPointer goodJet, goodBJet, badJet, goodJetCloseToElectron;
18			VertexPointer goodVertex;
19			VertexPointer badVertex;
20			MuonPointer goodIsolatedMuon;
21			MuonPointer badMuon;
22			METPointer met;
23
24			TestEvent() :
25			ttbarEvent(),
26			goodZEvent(),
27			poorZEvent(),
28			DiJetEvent(),
29			DiJetEventWithConversion(),
30			muonEvent(),
31			emptyEvent(),
32			goodIsolatedElectron(TestObjectFactory::goodIsolatedElectron()),
33			goodIsolatedElectron2(TestObjectFactory::goodIsolatedElectron2()),
34			goodLooseElectron(TestObjectFactory::goodLooseElectron()),
35			badEtElectron(TestObjectFactory::badEtElectron()),
36			electronFromConversion(TestObjectFactory::electronWithMissingInnerLayerHit()),
37			goodJet(TestObjectFactory::goodCaloJet()),
38			goodBJet(TestObjectFactory::goodCaloBJetSSVHEM()),
39			badJet(TestObjectFactory::badEMFCaloJet()),
40			goodJetCloseToElectron(TestObjectFactory::goodCaloJetCloseToCaloElectron()),
41			goodVertex(TestObjectFactory::goodVertex()),
42			badVertex(TestObjectFactory::badFakeVertex()),
43			goodIsolatedMuon(TestObjectFactory::goodIsolatedMuon()),
44			badMuon(TestObjectFactory::badNonGlobalMuon()),
45			met(TestObjectFactory::goodMET()) {
46
47			setUpTTbarEvent();
48			setUpGoodZEvent();
49			setUpPoorZEvent();
50			setUpDiJetEvent();
51			setUpMuonEvent();
52			}
53
54			private:
55
56			void setUpTTbarEvent() {
57			VertexCollection vertices;
58			vertices.push_back(goodVertex);
59			ttbarEvent.setVertices(vertices);
60			ElectronCollection electrons;
61			electrons.push_back(goodIsolatedElectron);
62			electrons.push_back(badEtElectron);
63			ttbarEvent.setElectrons(electrons);
64			JetCollection jets;
65			jets.push_back(goodJet);
66			jets.push_back(goodJet);
67			jets.push_back(goodBJet);
68			jets.push_back(goodBJet);
69			jets.push_back(badJet);
70			ttbarEvent.setJets(jets);
71
72			MuonCollection muons;
73			muons.push_back(badMuon);
74			ttbarEvent.setMuons(muons);
75			ttbarEvent.setMET(met);
76			}
77
78			void setUpGoodZEvent() {
79			VertexCollection vertices;
80			vertices.push_back(goodVertex);
81			goodZEvent.setVertices(vertices);
82			ElectronCollection electrons;
83			electrons.push_back(goodIsolatedElectron);
84			electrons.push_back(goodIsolatedElectron2);
85			electrons.push_back(badEtElectron);
86			goodZEvent.setElectrons(electrons);
87
88			JetCollection jets;
89			jets.push_back(goodJet);
90			jets.push_back(goodJet);
91			jets.push_back(goodJet);
92			jets.push_back(goodBJet);
93			goodZEvent.setJets(jets);
94
95			}
96
97			void setUpPoorZEvent() {
98			VertexCollection vertices;
99			vertices.push_back(goodVertex);
100			poorZEvent.setVertices(vertices);
101			ElectronCollection electrons;
102			electrons.push_back(goodIsolatedElectron);
103			electrons.push_back(goodLooseElectron);
104			electrons.push_back(badEtElectron);
105			poorZEvent.setElectrons(electrons);
106
107			JetCollection jets;
108			jets.push_back(goodJet);
109			jets.push_back(goodJet);
110			jets.push_back(goodJet);
111			jets.push_back(goodBJet);
112			poorZEvent.setJets(jets);
113
114			}
115
116			void setUpDiJetEvent() {
117			VertexCollection vertices;
118			vertices.push_back(badVertex);
119			DiJetEvent.setVertices(vertices);
120			JetCollection jets;
121			jets.push_back(goodJet);
122			jets.push_back(goodJet);
123			DiJetEvent.setJets(jets);
124
125			}
126
127			void setUpDiJetEventWithConversion() {
128			VertexCollection vertices;
129			vertices.push_back(goodVertex);
130			DiJetEventWithConversion.setVertices(vertices);
131			JetCollection jets;
132			jets.push_back(goodJet);
133			jets.push_back(goodJet);
134			DiJetEventWithConversion.setJets(jets);
135
136			ElectronCollection electrons;
137			electrons.push_back(electronFromConversion);
138			DiJetEventWithConversion.setElectrons(electrons);
139			}
140
141			void setUpMuonEvent() {
142			VertexCollection vertices;
143			vertices.push_back(goodVertex);
144			muonEvent.setVertices(vertices);
145			ElectronCollection electrons;
146			electrons.push_back(goodIsolatedElectron);
147			electrons.push_back(badEtElectron);
148			muonEvent.setElectrons(electrons);
149			JetCollection jets;
150			jets.push_back(goodJet);
151			jets.push_back(goodJet);
152			jets.push_back(goodBJet);
153			jets.push_back(goodBJet);
154			jets.push_back(badJet);
155			muonEvent.setJets(jets);
156			MuonCollection muons;
157			muons.push_back(goodIsolatedMuon);
158			muonEvent.setMuons(muons);
159			}
160
161			public:
162			void testNumberOfElectrons() {
163			ASSERT_EQUAL(2, ttbarEvent.Electrons().size());
164			}
165
166			void testNumberOfGoodElectrons() {
167			ASSERT_EQUAL(1, ttbarEvent.GoodElectrons().size());
168			}
169
170			void testNumberOfGoodIsolatedElectrons() {
171			ASSERT_EQUAL(1, ttbarEvent.GoodIsolatedElectrons().size());
172			}
173
174			void testNumberOfJets() {
175			ASSERT_EQUAL(5, ttbarEvent.Jets().size());
176			}
177
178			void testNumberOfGoodJets() {
179			ASSERT_EQUAL(4, ttbarEvent.GoodJets().size());
180			}
181
182			void testRunNumber() {
183			ttbarEvent.setRunNumber(42);
184			ASSERT_EQUAL(42, ttbarEvent.runnumber());
185			}
186
187			void testEventNumber() {
188			ttbarEvent.setEventNumber(42);
189			ASSERT_EQUAL(42, ttbarEvent.eventnumber());
190			}
191
192			void testLocalEventNumber() {
193			ttbarEvent.setLocalEventNumber(42);
194			ASSERT_EQUAL(42, ttbarEvent.localnumber());
195			}
196
197			void testLumiBlock() {
198			ttbarEvent.setLumiBlock(42);
199			ASSERT_EQUAL(42, ttbarEvent.lumiblock());
200			}
201
202			void testEventWeight() {
203			ttbarEvent.setEventWeight(1.152);
204			ASSERT_EQUAL_DELTA(1.152, ttbarEvent.weight(), 0.001);
205			}
206
207			void testGetMostIsolatedElectron() {
208			ASSERT_EQUAL_DELTA(goodIsolatedElectron2->relativeIsolation(),
209			goodZEvent.MostIsolatedElectron()->relativeIsolation(), 0.001);
210			}
211
212			void testGoodJetCleaning() {
213			Event event = Event();
214			VertexCollection vertices;
215			vertices.push_back(goodVertex);
216			event.setVertices(vertices);
217			ElectronCollection electrons;
218			electrons.push_back(goodIsolatedElectron);
219			electrons.push_back(badEtElectron);
220			event.setElectrons(electrons);
221			JetCollection jets;
222			jets.push_back(goodJet);
223			jets.push_back(goodJet);
224			jets.push_back(goodBJet);
225			jets.push_back(goodBJet);
226			jets.push_back(goodJetCloseToElectron);
227			event.setJets(jets);
228			ASSERT_EQUAL(5, event.Jets().size());
229			ASSERT_EQUAL(4, event.GoodJets().size());
230			}
231
232			void testGoodJetCleaningNoGoodElectrons() {
233			Event event = Event();
234			VertexCollection vertices;
235			vertices.push_back(goodVertex);
236			event.setVertices(vertices);
237			ElectronCollection electrons;
238			goodIsolatedElectron->setSigmaIEtaIEta(0.01 + 2);
239			electrons.push_back(goodIsolatedElectron);
240			electrons.push_back(badEtElectron);
241			event.setElectrons(electrons);
242			JetCollection jets;
243			jets.push_back(goodJet);
244			jets.push_back(goodJet);
245			jets.push_back(goodBJet);
246			jets.push_back(goodBJet);
247			jets.push_back(goodJetCloseToElectron);
248			event.setJets(jets);
249			ASSERT_EQUAL(0, event.GoodElectrons().size());
250			ASSERT_EQUAL(0, event.GoodIsolatedElectrons().size());
251			ASSERT_EQUAL(jets.size(), event.Jets().size());
252			ASSERT_EQUAL(jets.size() - 1, event.GoodJets().size());
253			}
254
255			void testGoodJetCleaningNoElectrons() {
256			Event event = Event();
257			VertexCollection vertices;
258			vertices.push_back(goodVertex);
259			event.setVertices(vertices);
260			JetCollection jets;
261			jets.push_back(goodJet);
262			jets.push_back(goodJet);
263			jets.push_back(goodBJet);
264			jets.push_back(goodBJet);
265			jets.push_back(goodJetCloseToElectron);
266			event.setJets(jets);
267			ASSERT_EQUAL(jets.size(), event.Jets().size());
268			ASSERT_EQUAL(jets.size(), event.GoodJets().size());
269			}
270
271			void testGoodJetCleaningNoGoodJets() {
272			Event event = Event();
273			VertexCollection vertices;
274			vertices.push_back(goodVertex);
275			event.setVertices(vertices);
276			ElectronCollection electrons;
277			electrons.push_back(goodIsolatedElectron);
278			electrons.push_back(badEtElectron);
279			event.setElectrons(electrons);
280			JetCollection jets;
281			jets.push_back(badJet);
282			event.setJets(jets);
283			ASSERT_EQUAL(jets.size(), event.Jets().size());
284			ASSERT_EQUAL(0, event.GoodJets().size());
285			}
286
287			void testMET() {
288			ASSERT_EQUAL(50, ttbarEvent.MET()->et());
289			}
290
291			};
292
293			extern cute::suite make_suite_TestEvent() {
294			cute::suite s;
295
296			s.push_back(CUTE_SMEMFUN(TestEvent, testNumberOfElectrons));
297			s.push_back(CUTE_SMEMFUN(TestEvent, testNumberOfGoodElectrons));
298			s.push_back(CUTE_SMEMFUN(TestEvent, testNumberOfGoodIsolatedElectrons));
299			s.push_back(CUTE_SMEMFUN(TestEvent, testNumberOfJets));
300			s.push_back(CUTE_SMEMFUN(TestEvent, testNumberOfGoodJets));
301
302			s.push_back(CUTE_SMEMFUN(TestEvent, testRunNumber));
303			s.push_back(CUTE_SMEMFUN(TestEvent, testEventNumber));
304			s.push_back(CUTE_SMEMFUN(TestEvent, testLocalEventNumber));
305			s.push_back(CUTE_SMEMFUN(TestEvent, testLumiBlock));
306			s.push_back(CUTE_SMEMFUN(TestEvent, testEventWeight));
307
308			s.push_back(CUTE_SMEMFUN(TestEvent, testGetMostIsolatedElectron));
309
310			s.push_back(CUTE_SMEMFUN(TestEvent, testGoodJetCleaning));
311			s.push_back(CUTE_SMEMFUN(TestEvent, testGoodJetCleaningNoGoodElectrons));
312			s.push_back(CUTE_SMEMFUN(TestEvent, testGoodJetCleaningNoElectrons));
313			s.push_back(CUTE_SMEMFUN(TestEvent, testGoodJetCleaningNoGoodJets));
314			s.push_back(CUTE_SMEMFUN(TestEvent, testMET));
315
316			return s;
317			}