Tools/test/TestParticle.h

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

#include "../interface/RecoObjects/Particle.h"

using namespace BAT;

struct TestParticle {
private:
    ParticlePointer particle1, particle2, particle3, particleInBarrelRegion, particleInCrack, particleInEndcap;
    ParticlePointer zParticle1, zParticle2;
    FourVector combinedVector;

public:
    TestParticle() :
        particle1(new Particle(20., 10., 0., 0.)),
        particle2(new Particle(20., -10., 0., 0.)),
        particle3(new Particle(*particle1 + *particle2)),
        particleInBarrelRegion(new Particle(30., 20., -20., 0.)),
        particleInCrack(new Particle(25., 0., 10., -22.)),
        particleInEndcap(new Particle(20., 5., 5., -20.)),
        zParticle1(new Particle(100., 79., -13., -5.)),
        zParticle2(new Particle(100., 99., 13., 5.)),
        combinedVector(FourVector(particle1->getFourVector() + particle2->getFourVector())) {
        particle1->setD0(180.);

        combinedVector = FourVector(particle1->getFourVector() + particle2->getFourVector());

        assert(fabs(particleInBarrelRegion->eta()) < 1.4442);

        assert(fabs(particleInEndcap->eta()) > 1.5660);

        assert(fabs(particleInCrack->eta()) > 1.4442);
        assert(fabs(particleInCrack->eta()) < 1.5660);

        zParticle1->setCharge(-1);
        zParticle2->setCharge(1);
    }

    void testAsignOperator() {
        particle3 = particle1;
        ASSERT_EQUAL(particle1->mass(), particle3->mass());
        ASSERT_EQUAL(particle1->getFourVector(), particle3->getFourVector());
    }

    void testPlusOperatorCorrectFourvector() {
        ASSERT_EQUAL(particle3->getFourVector(), combinedVector);
    }

    void testPlusOperatorCorrectMass() {
        ASSERT_EQUAL(combinedVector.M(), particle3->mass());
    }

    void testDeltaEta() {
        float deltaEta = fabs(particle1->eta() - particle2->eta());
        ASSERT_EQUAL(deltaEta, particle1->deltaEta(particle2));
    }

    void testDeltaPhi() {
        float deltaPhi = particle1->getFourVector().DeltaPhi(particle2->getFourVector());
        ASSERT_EQUAL(deltaPhi, particle1->deltaPhi(particle2));
    }

    void testDeltaR() {
        float deltaR = particle1->getFourVector().DeltaR(particle2->getFourVector());
        ASSERT_EQUAL(deltaR, particle1->deltaR(particle2));
    }

    void testIsWithinDR() {
        ParticlePointer particle(new Particle(20., 9.99, 0., 0.));
        ASSERT_EQUAL(true, particle1->isWithinDeltaR(0.3, particle));
    }

    void testIsNotWithinDR() {
        ParticlePointer particle(new Particle(20., -9.99, 0., 0.));
        ASSERT_EQUAL(false, particle1->isWithinDeltaR(0.3, particle));
    }

    void testStandardConstructor() {
        Particle particle;
        ASSERT_EQUAL(0., particle.energy());
        ASSERT_EQUAL(0., particle.px());
        ASSERT_EQUAL(0., particle.py());
        ASSERT_EQUAL(0., particle.pz());
        ASSERT_EQUAL(0., particle.mass());
        ASSERT_EQUAL(0., particle.massFromEnergyAndMomentum());
    }

    void testFourvectorConstructor() {
        Particle particle(5., 4., 0., 0.);
        ASSERT_EQUAL(5., particle.energy());
        ASSERT_EQUAL(4., particle.px());
        ASSERT_EQUAL(0., particle.py());
        ASSERT_EQUAL(0., particle.pz());
        ASSERT_EQUAL(3., particle.massFromEnergyAndMomentum());
    }

    void testParticleConstructor() {
        Particle particle(*particle1);
        ASSERT_EQUAL(particle1->energy(), particle.energy());
        ASSERT_EQUAL(particle1->px(), particle.px());
        ASSERT_EQUAL(particle1->py(), particle.py());
        ASSERT_EQUAL(particle1->pz(), particle.pz());
    }

    void testSetMass() {
        particle1->setMass(200.);
        ASSERT_EQUAL(200., particle1->mass());
    }

    void testDistanceFromInteractionPointAliasD0() {
        ASSERT_EQUAL(180., particle1->d0());
    }

    void testGetMassFromEnergyAndMomentumIfEquals0() {
        ASSERT(particle1->mass() != 0);
    }

    void testParticleIsInBarrelRegion() {
        ASSERT(particleInBarrelRegion->isInBarrelRegion());
        ASSERT(particleInBarrelRegion->isInEndCapRegion() == false);
        ASSERT(particleInBarrelRegion->isInCrack() == false);

    }

    void testParticleInEndcap() {
        ASSERT(particleInEndcap->isInEndCapRegion());
        ASSERT(particleInEndcap->isInCrack() == false);
        ASSERT(particleInEndcap->isInBarrelRegion() == false);
    }

    void testParticleInCrack() {
        ASSERT(particleInCrack->isInCrack());
        ASSERT(particleInCrack->isInEndCapRegion() == false);
        ASSERT(particleInCrack->isInBarrelRegion() == false);
    }

    void testGetEtaRegionCrack() {
        ASSERT_EQUAL(0, strcmp("crack", particleInCrack->getEtaRegion()));
    }

    void testGetEtaRegionBarrel() {
        ASSERT_EQUAL(0, strcmp("barrel", particleInBarrelRegion->getEtaRegion()));
    }

    void testGetEtaRegionEndcap() {
        ASSERT_EQUAL(0, strcmp("endcap", particleInEndcap->getEtaRegion()));
    }

    void testInvarianMassOfTwoParticles() {
        TLorentzVector combinedParticle(zParticle1->getFourVector() + zParticle2->getFourVector());
        ASSERT_EQUAL_DELTA(combinedParticle.M(), zParticle1->invariantMass(zParticle2), 0.0001);
    }

    void testInvarianMassOfOneParticles() {
        ASSERT_EQUAL_DELTA(2 * zParticle1->mass(), zParticle1->invariantMass(zParticle1), 0.0001);
    }

    void testRelativePtParallelParticles() {
        ASSERT_EQUAL_DELTA(0, particle1->relativePtTo(particle2), 0.001);
    }

    void testRelativePtOrthogonalParticles() {
        TVector3 threeVector = particle1->getFourVector().Vect();
        ASSERT_EQUAL_DELTA(threeVector.Mag(), particle1->relativePtTo(particleInCrack), 0.001);
    }

    void testGetClosest() {
        ParticleCollection particles;
        particles.push_back(particle1);
        particles.push_back(particleInEndcap);
        particles.push_back(particle3);
        ASSERT_EQUAL(0, particle1->getClosest(particles));
    }

    void testGetClosest2() {
        ParticleCollection particles;
        particles.push_back(particleInEndcap);
        particles.push_back(particle1);
        particles.push_back(particle3);
        ASSERT_EQUAL(1, particle1->getClosest(particles));
    }

    void testCharge() {
        ASSERT_EQUAL(-1, zParticle1->charge());
    }

    void testChargeInCollection() {
        ParticleCollection particles;
        particle1->setCharge(-1);
        particleInEndcap->setCharge(-1);
        particles.push_back(particle1);
        particles.push_back(particleInEndcap);
        particles.push_back(zParticle1);
        ASSERT_EQUAL(-1, particles.front()->charge());
    }

    void testAngle(){
        ASSERT_EQUAL_DELTA(3.14159, particle1->angle(particle2), 0.00001);
    }
};

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

    s.push_back(CUTE_SMEMFUN(TestParticle, testPlusOperatorCorrectFourvector));
    s.push_back(CUTE_SMEMFUN(TestParticle, testAsignOperator));
    s.push_back(CUTE_SMEMFUN(TestParticle, testPlusOperatorCorrectMass));
    s.push_back(CUTE_SMEMFUN(TestParticle, testStandardConstructor));
    s.push_back(CUTE_SMEMFUN(TestParticle, testFourvectorConstructor));
    s.push_back(CUTE_SMEMFUN(TestParticle, testSetMass));
    s.push_back(CUTE_SMEMFUN(TestParticle, testDistanceFromInteractionPointAliasD0));
    s.push_back(CUTE_SMEMFUN(TestParticle, testGetMassFromEnergyAndMomentumIfEquals0));
    s.push_back(CUTE_SMEMFUN(TestParticle, testParticleIsInBarrelRegion));
    s.push_back(CUTE_SMEMFUN(TestParticle, testParticleInEndcap));
    s.push_back(CUTE_SMEMFUN(TestParticle, testParticleInCrack));
    s.push_back(CUTE_SMEMFUN(TestParticle, testParticleConstructor));

    s.push_back(CUTE_SMEMFUN(TestParticle, testGetEtaRegionCrack));
    s.push_back(CUTE_SMEMFUN(TestParticle, testGetEtaRegionBarrel));
    s.push_back(CUTE_SMEMFUN(TestParticle, testGetEtaRegionEndcap));

    s.push_back(CUTE_SMEMFUN(TestParticle, testDeltaEta));
    s.push_back(CUTE_SMEMFUN(TestParticle, testDeltaPhi));
    s.push_back(CUTE_SMEMFUN(TestParticle, testDeltaR));

    s.push_back(CUTE_SMEMFUN(TestParticle, testIsWithinDR));
    s.push_back(CUTE_SMEMFUN(TestParticle, testIsNotWithinDR));

    s.push_back(CUTE_SMEMFUN(TestParticle, testInvarianMassOfTwoParticles));
    s.push_back(CUTE_SMEMFUN(TestParticle, testInvarianMassOfOneParticles));

    s.push_back(CUTE_SMEMFUN(TestParticle, testRelativePtParallelParticles));
    s.push_back(CUTE_SMEMFUN(TestParticle, testRelativePtOrthogonalParticles));
    s.push_back(CUTE_SMEMFUN(TestParticle, testGetClosest));
    s.push_back(CUTE_SMEMFUN(TestParticle, testGetClosest2));
    s.push_back(CUTE_SMEMFUN(TestParticle, testCharge));
    s.push_back(CUTE_SMEMFUN(TestParticle, testChargeInCollection));
    s.push_back(CUTE_SMEMFUN(TestParticle, testAngle));

    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
#	Content
1	#include "cute/cute.h"
2	#include "cute/cute_suite.h"
3
4	#include "../interface/RecoObjects/Particle.h"
5
6	using namespace BAT;
7
8	struct TestParticle {
9	private:
10	ParticlePointer particle1, particle2, particle3, particleInBarrelRegion, particleInCrack, particleInEndcap;
11	ParticlePointer zParticle1, zParticle2;
12	FourVector combinedVector;
13
14	public:
15	TestParticle() :
16	particle1(new Particle(20., 10., 0., 0.)),
17	particle2(new Particle(20., -10., 0., 0.)),
18	particle3(new Particle(particle1 + particle2)),
19	particleInBarrelRegion(new Particle(30., 20., -20., 0.)),
20	particleInCrack(new Particle(25., 0., 10., -22.)),
21	particleInEndcap(new Particle(20., 5., 5., -20.)),
22	zParticle1(new Particle(100., 79., -13., -5.)),
23	zParticle2(new Particle(100., 99., 13., 5.)),
24	combinedVector(FourVector(particle1->getFourVector() + particle2->getFourVector())) {
25	particle1->setD0(180.);
26
27	combinedVector = FourVector(particle1->getFourVector() + particle2->getFourVector());
28
29	assert(fabs(particleInBarrelRegion->eta()) < 1.4442);
30
31	assert(fabs(particleInEndcap->eta()) > 1.5660);
32
33	assert(fabs(particleInCrack->eta()) > 1.4442);
34	assert(fabs(particleInCrack->eta()) < 1.5660);
35
36	zParticle1->setCharge(-1);
37	zParticle2->setCharge(1);
38	}
39
40	void testAsignOperator() {
41	particle3 = particle1;
42	ASSERT_EQUAL(particle1->mass(), particle3->mass());
43	ASSERT_EQUAL(particle1->getFourVector(), particle3->getFourVector());
44	}
45
46	void testPlusOperatorCorrectFourvector() {
47	ASSERT_EQUAL(particle3->getFourVector(), combinedVector);
48	}
49
50	void testPlusOperatorCorrectMass() {
51	ASSERT_EQUAL(combinedVector.M(), particle3->mass());
52	}
53
54	void testDeltaEta() {
55	float deltaEta = fabs(particle1->eta() - particle2->eta());
56	ASSERT_EQUAL(deltaEta, particle1->deltaEta(particle2));
57	}
58
59	void testDeltaPhi() {
60	float deltaPhi = particle1->getFourVector().DeltaPhi(particle2->getFourVector());
61	ASSERT_EQUAL(deltaPhi, particle1->deltaPhi(particle2));
62	}
63
64	void testDeltaR() {
65	float deltaR = particle1->getFourVector().DeltaR(particle2->getFourVector());
66	ASSERT_EQUAL(deltaR, particle1->deltaR(particle2));
67	}
68
69	void testIsWithinDR() {
70	ParticlePointer particle(new Particle(20., 9.99, 0., 0.));
71	ASSERT_EQUAL(true, particle1->isWithinDeltaR(0.3, particle));
72	}
73
74	void testIsNotWithinDR() {
75	ParticlePointer particle(new Particle(20., -9.99, 0., 0.));
76	ASSERT_EQUAL(false, particle1->isWithinDeltaR(0.3, particle));
77	}
78
79	void testStandardConstructor() {
80	Particle particle;
81	ASSERT_EQUAL(0., particle.energy());
82	ASSERT_EQUAL(0., particle.px());
83	ASSERT_EQUAL(0., particle.py());
84	ASSERT_EQUAL(0., particle.pz());
85	ASSERT_EQUAL(0., particle.mass());
86	ASSERT_EQUAL(0., particle.massFromEnergyAndMomentum());
87	}
88
89	void testFourvectorConstructor() {
90	Particle particle(5., 4., 0., 0.);
91	ASSERT_EQUAL(5., particle.energy());
92	ASSERT_EQUAL(4., particle.px());
93	ASSERT_EQUAL(0., particle.py());
94	ASSERT_EQUAL(0., particle.pz());
95	ASSERT_EQUAL(3., particle.massFromEnergyAndMomentum());
96	}
97
98	void testParticleConstructor() {
99	Particle particle(*particle1);
100	ASSERT_EQUAL(particle1->energy(), particle.energy());
101	ASSERT_EQUAL(particle1->px(), particle.px());
102	ASSERT_EQUAL(particle1->py(), particle.py());
103	ASSERT_EQUAL(particle1->pz(), particle.pz());
104	}
105
106	void testSetMass() {
107	particle1->setMass(200.);
108	ASSERT_EQUAL(200., particle1->mass());
109	}
110
111	void testDistanceFromInteractionPointAliasD0() {
112	ASSERT_EQUAL(180., particle1->d0());
113	}
114
115	void testGetMassFromEnergyAndMomentumIfEquals0() {
116	ASSERT(particle1->mass() != 0);
117	}
118
119	void testParticleIsInBarrelRegion() {
120	ASSERT(particleInBarrelRegion->isInBarrelRegion());
121	ASSERT(particleInBarrelRegion->isInEndCapRegion() == false);
122	ASSERT(particleInBarrelRegion->isInCrack() == false);
123
124	}
125
126	void testParticleInEndcap() {
127	ASSERT(particleInEndcap->isInEndCapRegion());
128	ASSERT(particleInEndcap->isInCrack() == false);
129	ASSERT(particleInEndcap->isInBarrelRegion() == false);
130	}
131
132	void testParticleInCrack() {
133	ASSERT(particleInCrack->isInCrack());
134	ASSERT(particleInCrack->isInEndCapRegion() == false);
135	ASSERT(particleInCrack->isInBarrelRegion() == false);
136	}
137
138	void testGetEtaRegionCrack() {
139	ASSERT_EQUAL(0, strcmp("crack", particleInCrack->getEtaRegion()));
140	}
141
142	void testGetEtaRegionBarrel() {
143	ASSERT_EQUAL(0, strcmp("barrel", particleInBarrelRegion->getEtaRegion()));
144	}
145
146	void testGetEtaRegionEndcap() {
147	ASSERT_EQUAL(0, strcmp("endcap", particleInEndcap->getEtaRegion()));
148	}
149
150	void testInvarianMassOfTwoParticles() {
151	TLorentzVector combinedParticle(zParticle1->getFourVector() + zParticle2->getFourVector());
152	ASSERT_EQUAL_DELTA(combinedParticle.M(), zParticle1->invariantMass(zParticle2), 0.0001);
153	}
154
155	void testInvarianMassOfOneParticles() {
156	ASSERT_EQUAL_DELTA(2 * zParticle1->mass(), zParticle1->invariantMass(zParticle1), 0.0001);
157	}
158
159	void testRelativePtParallelParticles() {
160	ASSERT_EQUAL_DELTA(0, particle1->relativePtTo(particle2), 0.001);
161	}
162
163	void testRelativePtOrthogonalParticles() {
164	TVector3 threeVector = particle1->getFourVector().Vect();
165	ASSERT_EQUAL_DELTA(threeVector.Mag(), particle1->relativePtTo(particleInCrack), 0.001);
166	}
167
168	void testGetClosest() {
169	ParticleCollection particles;
170	particles.push_back(particle1);
171	particles.push_back(particleInEndcap);
172	particles.push_back(particle3);
173	ASSERT_EQUAL(0, particle1->getClosest(particles));
174	}
175
176	void testGetClosest2() {
177	ParticleCollection particles;
178	particles.push_back(particleInEndcap);
179	particles.push_back(particle1);
180	particles.push_back(particle3);
181	ASSERT_EQUAL(1, particle1->getClosest(particles));
182	}
183
184	void testCharge() {
185	ASSERT_EQUAL(-1, zParticle1->charge());
186	}
187
188	void testChargeInCollection() {
189	ParticleCollection particles;
190	particle1->setCharge(-1);
191	particleInEndcap->setCharge(-1);
192	particles.push_back(particle1);
193	particles.push_back(particleInEndcap);
194	particles.push_back(zParticle1);
195	ASSERT_EQUAL(-1, particles.front()->charge());
196	}
197
198	void testAngle(){
199	ASSERT_EQUAL_DELTA(3.14159, particle1->angle(particle2), 0.00001);
200	}
201	};
202
203	extern cute::suite make_suite_TestParticle() {
204	cute::suite s;
205
206	s.push_back(CUTE_SMEMFUN(TestParticle, testPlusOperatorCorrectFourvector));
207	s.push_back(CUTE_SMEMFUN(TestParticle, testAsignOperator));
208	s.push_back(CUTE_SMEMFUN(TestParticle, testPlusOperatorCorrectMass));
209	s.push_back(CUTE_SMEMFUN(TestParticle, testStandardConstructor));
210	s.push_back(CUTE_SMEMFUN(TestParticle, testFourvectorConstructor));
211	s.push_back(CUTE_SMEMFUN(TestParticle, testSetMass));
212	s.push_back(CUTE_SMEMFUN(TestParticle, testDistanceFromInteractionPointAliasD0));
213	s.push_back(CUTE_SMEMFUN(TestParticle, testGetMassFromEnergyAndMomentumIfEquals0));
214	s.push_back(CUTE_SMEMFUN(TestParticle, testParticleIsInBarrelRegion));
215	s.push_back(CUTE_SMEMFUN(TestParticle, testParticleInEndcap));
216	s.push_back(CUTE_SMEMFUN(TestParticle, testParticleInCrack));
217	s.push_back(CUTE_SMEMFUN(TestParticle, testParticleConstructor));
218
219	s.push_back(CUTE_SMEMFUN(TestParticle, testGetEtaRegionCrack));
220	s.push_back(CUTE_SMEMFUN(TestParticle, testGetEtaRegionBarrel));
221	s.push_back(CUTE_SMEMFUN(TestParticle, testGetEtaRegionEndcap));
222
223	s.push_back(CUTE_SMEMFUN(TestParticle, testDeltaEta));
224	s.push_back(CUTE_SMEMFUN(TestParticle, testDeltaPhi));
225	s.push_back(CUTE_SMEMFUN(TestParticle, testDeltaR));
226
227	s.push_back(CUTE_SMEMFUN(TestParticle, testIsWithinDR));
228	s.push_back(CUTE_SMEMFUN(TestParticle, testIsNotWithinDR));
229
230	s.push_back(CUTE_SMEMFUN(TestParticle, testInvarianMassOfTwoParticles));
231	s.push_back(CUTE_SMEMFUN(TestParticle, testInvarianMassOfOneParticles));
232
233	s.push_back(CUTE_SMEMFUN(TestParticle, testRelativePtParallelParticles));
234	s.push_back(CUTE_SMEMFUN(TestParticle, testRelativePtOrthogonalParticles));
235	s.push_back(CUTE_SMEMFUN(TestParticle, testGetClosest));
236	s.push_back(CUTE_SMEMFUN(TestParticle, testGetClosest2));
237	s.push_back(CUTE_SMEMFUN(TestParticle, testCharge));
238	s.push_back(CUTE_SMEMFUN(TestParticle, testChargeInCollection));
239	s.push_back(CUTE_SMEMFUN(TestParticle, testAngle));
240
241	return s;
242	}