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
#	User	Rev	Content
1	dhidas	1.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			}