Tools/test/TestTrack.h

/*
 * TestTrack.h
 *
 *  Created on: 19 Sep 2010
 *      Author: kreczko
 */

#ifndef TESTTRACK_H_
#define TESTTRACK_H_
#include "cute/cute.h"
#include "cute/cute_suite.h"
#include "../interface/RecoObjects/Track.h"

using namespace BAT;

struct TestTrack {
private:
    ParticlePointer particle1, particle2;
    TrackPointer track1, track2;
public:
    TestTrack() :
        particle1(new Particle(40, 40, 0, 0)),
        particle2(new Particle(40, -40, 0, 0)),
        track1(new Track(particle1->phi(), particle1->eta(), particle1->pt(), particle1->theta())),
        track2(new Track(particle2->phi(), particle2->eta(), particle2->pt(), particle2->theta())) {
        track1->setCharge(1);
        track2->setCharge(-1);
        track1->setD0(1);
        track2->setD0(1);
    }

    void testCurvatureWithSTDBField() {
        ASSERT_EQUAL(-0.3 * 3.8 * track1->charge() / track1->pt() / 100., track1->curvature());
    }

    void testCurvatureWithCustomBField() {
        ASSERT_EQUAL(-0.3 * 4 * track1->charge() / track1->pt() / 100., track1->curvature(4.));
    }

    void testRadiusWithSTDBField() {
        ASSERT_EQUAL(fabs(1 / track1->curvature()), track1->radius());
    }

    void testRadiusWithCustomBField() {
        ASSERT_EQUAL(fabs(1 / track1->curvature(5)), track1->radius(5));
    }

    void testXWithSTDBField() {
        ASSERT_EQUAL((1/track1->curvature() - track1->d0()) * cos(track1->phi()), track1->x());
    }

    void testXWithCustomBField() {
        ASSERT_EQUAL((1/track1->curvature(3) - track1->d0()) * cos(track1->phi()), track1->x(3));
    }

    void testYWithSTDBField() {
        ASSERT_EQUAL((1/track1->curvature() - track1->d0()) * sin(track1->phi()), track1->y());
    }

    void testYWithCustomBField() {
        ASSERT_EQUAL((1/track1->curvature() - track1->d0()) * sin(track1->phi()), track1->y(3));
    }

    void testDeltaCotThetaWithSTDBField() {
        ASSERT_EQUAL(fabs(1 / tan(track1->theta()) - 1 / tan(track2->theta())), track1->deltaCotTheta(track2));
    }

    void testDistanceWithSTDBfield() {
        double dx = track1->x() - track2->x();
        double dy = track1->y() - track2->y();
        double dist = sqrt(dx * dx + dy * dy);
        dist = fabs(dist - (track1->radius() + track2->radius()));
        ASSERT_EQUAL(dist, track1->distance(track2));
        ASSERT_EQUAL(track1->distance(track2), track2->distance(track1));
    }

    void testDistanceWithCustomBfield() {
        double field = 3.2;
        double dx = track1->x(field) - track2->x(field);
        double dy = track1->y(field) - track2->y(field);
        double dist = sqrt(dx * dx + dy * dy);
        dist = fabs(dist - (track1->radius(field) + track2->radius(field)));
        ASSERT_EQUAL(dist, track1->distance(track2, field));
        ASSERT_EQUAL(track1->distance(track2, field), track2->distance(track1, field));
    }

    void testEta() {
        ASSERT_EQUAL(0, track1->eta());
    }

    void testPhi() {
        ASSERT_EQUAL(true, track1->phi() > -10);
    }

    void testPt() {
        ASSERT_EQUAL(true, track1->pt() > 0);
    }

    void testTheta() {
        ASSERT_EQUAL(true, track1->theta() > 0);
    }

    void testCustomEta() {
        TrackPointer track = TrackPointer(new Track(1, 0.5, 12.5, 23.5));
        ASSERT_EQUAL(0.5, track->eta());
    }

    void testCustomPhi() {
        TrackPointer track = TrackPointer(new Track(1, 0.5, 12.5, 23.5));
        ASSERT_EQUAL(1, track->phi());
    }

    void testCustomPt() {
        TrackPointer track = TrackPointer(new Track(1, 0.5, 12.5, 23.5));
        ASSERT_EQUAL(12.5, track->pt());
    }

    void testCustomTheta() {
        TrackPointer track = TrackPointer(new Track(1, 0.5, 12.5, 23.5));
        ASSERT_EQUAL(23.5, track->theta());
    }

    void testXNCharge() {
        TrackPointer track = TrackPointer(new Track(1, 0.5, 12.5, 23.5));
        track->setCharge(-1);
        double x = (1 / track->curvature(3.8) - track->d0()) * cos(track->phi());
        ASSERT_EQUAL_DELTA(x, track->x(), 0.01);
    }

    void testYNCharge() {
        TrackPointer track = TrackPointer(new Track(1, 0.5, 12.5, 23.5));
        track->setCharge(-1);
        double y = (1 / track->curvature(3.8) - track->d0()) * sin(track->phi());
        ASSERT_EQUAL_DELTA(y, track->y(), 0.01);
    }

    void testXPCharge() {
        TrackPointer track = TrackPointer(new Track(1, 0.5, 12.5, 23.5));
        track->setCharge(1);
        double x = (1 / track->curvature(3.8) - track->d0()) * cos(track->phi());
        ASSERT_EQUAL_DELTA(x, track->x(), 0.01);
    }

    void testYPCharge() {
        TrackPointer track = TrackPointer(new Track(1, 0.5, 12.5, 23.5));
        track->setCharge(1);
        double y = (1 / track->curvature(3.8) - track->d0()) * sin(track->phi());
        ASSERT_EQUAL_DELTA(y, track->y(), 0.01);
    }
};

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

    s.push_back(CUTE_SMEMFUN(TestTrack, testCurvatureWithSTDBField));
    s.push_back(CUTE_SMEMFUN(TestTrack, testCurvatureWithCustomBField));
    s.push_back(CUTE_SMEMFUN(TestTrack, testRadiusWithSTDBField));
    s.push_back(CUTE_SMEMFUN(TestTrack, testRadiusWithCustomBField));
    s.push_back(CUTE_SMEMFUN(TestTrack, testXWithSTDBField));
    s.push_back(CUTE_SMEMFUN(TestTrack, testXWithCustomBField));
    s.push_back(CUTE_SMEMFUN(TestTrack, testYWithSTDBField));
    s.push_back(CUTE_SMEMFUN(TestTrack, testYWithCustomBField));
    s.push_back(CUTE_SMEMFUN(TestTrack, testDeltaCotThetaWithSTDBField));
    s.push_back(CUTE_SMEMFUN(TestTrack, testDistanceWithSTDBfield));
    s.push_back(CUTE_SMEMFUN(TestTrack, testDistanceWithCustomBfield));
    s.push_back(CUTE_SMEMFUN(TestTrack, testEta));
    s.push_back(CUTE_SMEMFUN(TestTrack, testPhi));
    s.push_back(CUTE_SMEMFUN(TestTrack, testPt));
    s.push_back(CUTE_SMEMFUN(TestTrack, testTheta));
    s.push_back(CUTE_SMEMFUN(TestTrack, testCustomEta));
    s.push_back(CUTE_SMEMFUN(TestTrack, testCustomPhi));
    s.push_back(CUTE_SMEMFUN(TestTrack, testCustomPt));
    s.push_back(CUTE_SMEMFUN(TestTrack, testCustomTheta));
    s.push_back(CUTE_SMEMFUN(TestTrack, testXNCharge));
    s.push_back(CUTE_SMEMFUN(TestTrack, testYNCharge));
    s.push_back(CUTE_SMEMFUN(TestTrack, testXPCharge));
    s.push_back(CUTE_SMEMFUN(TestTrack, testYPCharge));

    return s;
}
#endif /* TESTTRACK_H_ */
Revision:	1.1
Committed:	Thu Dec 1 16:28:47 2011 UTC (13 years, 5 months ago) by dhidas
Content type:	text/plain
Branch point for:	dhidas, MAIN
Log Message:	Initial revision
#	User	Rev	Content
1	dhidas	1.1	/*
2			* TestTrack.h
3			*
4			* Created on: 19 Sep 2010
5			* Author: kreczko
6			*/
7
8			#ifndef TESTTRACK_H_
9			#define TESTTRACK_H_
10			#include "cute/cute.h"
11			#include "cute/cute_suite.h"
12			#include "../interface/RecoObjects/Track.h"
13
14			using namespace BAT;
15
16			struct TestTrack {
17			private:
18			ParticlePointer particle1, particle2;
19			TrackPointer track1, track2;
20			public:
21			TestTrack() :
22			particle1(new Particle(40, 40, 0, 0)),
23			particle2(new Particle(40, -40, 0, 0)),
24			track1(new Track(particle1->phi(), particle1->eta(), particle1->pt(), particle1->theta())),
25			track2(new Track(particle2->phi(), particle2->eta(), particle2->pt(), particle2->theta())) {
26			track1->setCharge(1);
27			track2->setCharge(-1);
28			track1->setD0(1);
29			track2->setD0(1);
30			}
31
32			void testCurvatureWithSTDBField() {
33			ASSERT_EQUAL(-0.3 * 3.8 * track1->charge() / track1->pt() / 100., track1->curvature());
34			}
35
36			void testCurvatureWithCustomBField() {
37			ASSERT_EQUAL(-0.3 * 4 * track1->charge() / track1->pt() / 100., track1->curvature(4.));
38			}
39
40			void testRadiusWithSTDBField() {
41			ASSERT_EQUAL(fabs(1 / track1->curvature()), track1->radius());
42			}
43
44			void testRadiusWithCustomBField() {
45			ASSERT_EQUAL(fabs(1 / track1->curvature(5)), track1->radius(5));
46			}
47
48			void testXWithSTDBField() {
49			ASSERT_EQUAL((1/track1->curvature() - track1->d0()) * cos(track1->phi()), track1->x());
50			}
51
52			void testXWithCustomBField() {
53			ASSERT_EQUAL((1/track1->curvature(3) - track1->d0()) * cos(track1->phi()), track1->x(3));
54			}
55
56			void testYWithSTDBField() {
57			ASSERT_EQUAL((1/track1->curvature() - track1->d0()) * sin(track1->phi()), track1->y());
58			}
59
60			void testYWithCustomBField() {
61			ASSERT_EQUAL((1/track1->curvature() - track1->d0()) * sin(track1->phi()), track1->y(3));
62			}
63
64			void testDeltaCotThetaWithSTDBField() {
65			ASSERT_EQUAL(fabs(1 / tan(track1->theta()) - 1 / tan(track2->theta())), track1->deltaCotTheta(track2));
66			}
67
68			void testDistanceWithSTDBfield() {
69			double dx = track1->x() - track2->x();
70			double dy = track1->y() - track2->y();
71			double dist = sqrt(dx * dx + dy * dy);
72			dist = fabs(dist - (track1->radius() + track2->radius()));
73			ASSERT_EQUAL(dist, track1->distance(track2));
74			ASSERT_EQUAL(track1->distance(track2), track2->distance(track1));
75			}
76
77			void testDistanceWithCustomBfield() {
78			double field = 3.2;
79			double dx = track1->x(field) - track2->x(field);
80			double dy = track1->y(field) - track2->y(field);
81			double dist = sqrt(dx * dx + dy * dy);
82			dist = fabs(dist - (track1->radius(field) + track2->radius(field)));
83			ASSERT_EQUAL(dist, track1->distance(track2, field));
84			ASSERT_EQUAL(track1->distance(track2, field), track2->distance(track1, field));
85			}
86
87			void testEta() {
88			ASSERT_EQUAL(0, track1->eta());
89			}
90
91			void testPhi() {
92			ASSERT_EQUAL(true, track1->phi() > -10);
93			}
94
95			void testPt() {
96			ASSERT_EQUAL(true, track1->pt() > 0);
97			}
98
99			void testTheta() {
100			ASSERT_EQUAL(true, track1->theta() > 0);
101			}
102
103			void testCustomEta() {
104			TrackPointer track = TrackPointer(new Track(1, 0.5, 12.5, 23.5));
105			ASSERT_EQUAL(0.5, track->eta());
106			}
107
108			void testCustomPhi() {
109			TrackPointer track = TrackPointer(new Track(1, 0.5, 12.5, 23.5));
110			ASSERT_EQUAL(1, track->phi());
111			}
112
113			void testCustomPt() {
114			TrackPointer track = TrackPointer(new Track(1, 0.5, 12.5, 23.5));
115			ASSERT_EQUAL(12.5, track->pt());
116			}
117
118			void testCustomTheta() {
119			TrackPointer track = TrackPointer(new Track(1, 0.5, 12.5, 23.5));
120			ASSERT_EQUAL(23.5, track->theta());
121			}
122
123			void testXNCharge() {
124			TrackPointer track = TrackPointer(new Track(1, 0.5, 12.5, 23.5));
125			track->setCharge(-1);
126			double x = (1 / track->curvature(3.8) - track->d0()) * cos(track->phi());
127			ASSERT_EQUAL_DELTA(x, track->x(), 0.01);
128			}
129
130			void testYNCharge() {
131			TrackPointer track = TrackPointer(new Track(1, 0.5, 12.5, 23.5));
132			track->setCharge(-1);
133			double y = (1 / track->curvature(3.8) - track->d0()) * sin(track->phi());
134			ASSERT_EQUAL_DELTA(y, track->y(), 0.01);
135			}
136
137			void testXPCharge() {
138			TrackPointer track = TrackPointer(new Track(1, 0.5, 12.5, 23.5));
139			track->setCharge(1);
140			double x = (1 / track->curvature(3.8) - track->d0()) * cos(track->phi());
141			ASSERT_EQUAL_DELTA(x, track->x(), 0.01);
142			}
143
144			void testYPCharge() {
145			TrackPointer track = TrackPointer(new Track(1, 0.5, 12.5, 23.5));
146			track->setCharge(1);
147			double y = (1 / track->curvature(3.8) - track->d0()) * sin(track->phi());
148			ASSERT_EQUAL_DELTA(y, track->y(), 0.01);
149			}
150			};
151
152			extern cute::suite make_suite_TestTrack() {
153			cute::suite s;
154
155			s.push_back(CUTE_SMEMFUN(TestTrack, testCurvatureWithSTDBField));
156			s.push_back(CUTE_SMEMFUN(TestTrack, testCurvatureWithCustomBField));
157			s.push_back(CUTE_SMEMFUN(TestTrack, testRadiusWithSTDBField));
158			s.push_back(CUTE_SMEMFUN(TestTrack, testRadiusWithCustomBField));
159			s.push_back(CUTE_SMEMFUN(TestTrack, testXWithSTDBField));
160			s.push_back(CUTE_SMEMFUN(TestTrack, testXWithCustomBField));
161			s.push_back(CUTE_SMEMFUN(TestTrack, testYWithSTDBField));
162			s.push_back(CUTE_SMEMFUN(TestTrack, testYWithCustomBField));
163			s.push_back(CUTE_SMEMFUN(TestTrack, testDeltaCotThetaWithSTDBField));
164			s.push_back(CUTE_SMEMFUN(TestTrack, testDistanceWithSTDBfield));
165			s.push_back(CUTE_SMEMFUN(TestTrack, testDistanceWithCustomBfield));
166			s.push_back(CUTE_SMEMFUN(TestTrack, testEta));
167			s.push_back(CUTE_SMEMFUN(TestTrack, testPhi));
168			s.push_back(CUTE_SMEMFUN(TestTrack, testPt));
169			s.push_back(CUTE_SMEMFUN(TestTrack, testTheta));
170			s.push_back(CUTE_SMEMFUN(TestTrack, testCustomEta));
171			s.push_back(CUTE_SMEMFUN(TestTrack, testCustomPhi));
172			s.push_back(CUTE_SMEMFUN(TestTrack, testCustomPt));
173			s.push_back(CUTE_SMEMFUN(TestTrack, testCustomTheta));
174			s.push_back(CUTE_SMEMFUN(TestTrack, testXNCharge));
175			s.push_back(CUTE_SMEMFUN(TestTrack, testYNCharge));
176			s.push_back(CUTE_SMEMFUN(TestTrack, testXPCharge));
177			s.push_back(CUTE_SMEMFUN(TestTrack, testYPCharge));
178
179			return s;
180			}
181			#endif /* TESTTRACK_H_ */