← Back to branch summary

~christopher-hunt08/maus/maus_integrated_kalman

« back to all changes in this revision

Viewing changes to tests/cpp_unit/DataStructure/SciFiHelicalPRTrackTest.cc

  • Committer: Durga Rajaram
  • Date: 2014-07-16 15:13:05 UTC
  • mfrom: (659.1.92 cand)
  • Revision ID: durga@fnal.gov-20140716151305-q27rv1y9p03v9lks
Tags: MAUS-v0.9, MAUS-v0.9.0
MAUS-v0.9.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/cpp_unit/DataStructure/SciFiHelicalPRTrackTest.cc
33
33
TEST_F(SciFiHelicalPRTrackTestDS, test_default_constructor) {
34
34
  unsigned int size = 0;
35
35
  SciFiHelicalPRTrack prtrack;
36
 
  EXPECT_EQ(prtrack.get_x0(), -1.0);
37
 
  EXPECT_EQ(prtrack.get_y0(), -1.0);
38
 
  EXPECT_EQ(prtrack.get_z0(), -1.0);
 
36
  EXPECT_EQ(prtrack.get_pos0().x(), -1.0);
 
37
  EXPECT_EQ(prtrack.get_pos0().y(), -1.0);
 
38
  EXPECT_EQ(prtrack.get_pos0().z(), -1.0);
39
39
  EXPECT_EQ(prtrack.get_phi0(), -1.0);
40
 
  EXPECT_EQ(prtrack.get_psi0(), -1.0);
41
40
  EXPECT_EQ(prtrack.get_dsdz(), -1.0);
42
41
  EXPECT_EQ(prtrack.get_R(), -1.0);
43
42
  EXPECT_EQ(prtrack.get_chisq(), -1.0);
44
43
  EXPECT_EQ(prtrack.get_chisq_dof(), -1.0);
 
44
  EXPECT_EQ(prtrack.get_point_spread(), -1.0);
45
45
  EXPECT_EQ(prtrack.get_line_sz_chisq(), -1.0);
46
46
  EXPECT_EQ(prtrack.get_circle_x0(), -1.0);
47
47
  EXPECT_EQ(prtrack.get_circle_y0(), -1.0);
49
49
  EXPECT_EQ(prtrack.get_tracker(), -1);
50
50
  EXPECT_EQ(prtrack.get_num_points(), -1);
51
51
  EXPECT_EQ(prtrack.get_charge(), 0);
52
 
  EXPECT_EQ(prtrack.get_spacepoints().size(), size);
 
52
  EXPECT_EQ(prtrack.get_spacepoints()->GetEntries(), size);
53
53
}
54
54
 
55
 
TEST_F(SciFiHelicalPRTrackTestDS, test_parameter_constructor) {
56
 
  SciFiHelicalPRTrack prtrack(0, 3, -1, 1.0, 2.0, 1100.0, 4.0, 2.4, 0.02, 15.0, 30.0);
57
 
  EXPECT_EQ(prtrack.get_x0(), 1.0);
58
 
  EXPECT_EQ(prtrack.get_y0(), 2.0);
59
 
  EXPECT_EQ(prtrack.get_z0(), 1100.0);
60
 
  EXPECT_EQ(prtrack.get_phi0(), 4.0);
61
 
  EXPECT_EQ(prtrack.get_psi0(), 2.4);
62
 
  EXPECT_EQ(prtrack.get_dsdz(), 0.02);
63
 
  EXPECT_EQ(prtrack.get_tracker(), 0);
64
 
  EXPECT_EQ(prtrack.get_num_points(), 3);
65
 
  EXPECT_EQ(prtrack.get_charge(), -1);
66
 
  EXPECT_EQ(prtrack.get_chisq(), 30.0);
67
 
}
 
55
// TEST_F(SciFiHelicalPRTrackTestDS, test_parameter_constructor) {
 
56
//   SciFiHelicalPRTrack prtrack(0, 3, -1, 1.0, 2.0, 1100.0, 4.0, 2.4, 0.02, 15.0, 30.0);
 
57
//   EXPECT_EQ(prtrack.get_x0(), 1.0);
 
58
//   EXPECT_EQ(prtrack.get_y0(), 2.0);
 
59
//   EXPECT_EQ(prtrack.get_z0(), 1100.0);
 
60
//   EXPECT_EQ(prtrack.get_phi0(), 4.0);
 
61
//   EXPECT_EQ(prtrack.get_dsdz(), 0.02);
 
62
//   EXPECT_EQ(prtrack.get_tracker(), 0);
 
63
//   EXPECT_EQ(prtrack.get_num_points(), 3);
 
64
//   EXPECT_EQ(prtrack.get_charge(), -1);
 
65
//   EXPECT_EQ(prtrack.get_chisq(), 30.0);
 
66
// }
68
67
 
69
68
TEST_F(SciFiHelicalPRTrackTestDS, test_simplefit_constructor) {
 
69
  int tracker = 0;
 
70
  int num_points = 5;
 
71
  int charge = -1;
70
72
  double phi0 = 3.0;
71
 
  double psi0 = -1.0;
72
 
  ThreeVector pos0(1.0, 2.0, 1100.0);
 
73
  double x = 1.0;
 
74
  double y = 2.0;
 
75
  double z = 1100.0;
 
76
  double c = 1.0;
 
77
  double m = 0.03;
 
78
  double sz_chisq = 7.0;
 
79
  double R = 13.0;
 
80
  double circ_chisq = 6.0;
 
81
  double chisq = 1.0;
 
82
  double chisq_dof = 2.0;
 
83
  double point_spread = 10.0;
 
84
 
 
85
  ThreeVector pos0(x, y, z);
73
86
  SimpleLine line_sz;
74
87
  SimpleCircle circle;
75
 
  line_sz.set_c(1.0);
76
 
  line_sz.set_m(0.03);
77
 
  line_sz.set_chisq(7.0);
78
 
  circle.set_R(13.0);
79
 
  circle.set_chisq(6.0);
80
 
 
81
 
  SciFiHelicalPRTrack prtrack(0, 5, -1, pos0, phi0, psi0, circle, line_sz);
82
 
  EXPECT_EQ(prtrack.get_x0(), 1.0);
83
 
  EXPECT_EQ(prtrack.get_y0(), 2.0);
84
 
  EXPECT_EQ(prtrack.get_z0(), 1100.0);
85
 
  EXPECT_EQ(prtrack.get_phi0(), phi0);
86
 
  EXPECT_EQ(prtrack.get_psi0(), psi0);
87
 
  EXPECT_EQ(prtrack.get_dsdz(), 0.03);
88
 
  EXPECT_EQ(prtrack.get_R(), 13.0);
89
 
  EXPECT_EQ(prtrack.get_line_sz_chisq(), 7.0);
90
 
  EXPECT_EQ(prtrack.get_circle_chisq(), 6.0);
91
 
  EXPECT_EQ(prtrack.get_tracker(), 0);
92
 
  EXPECT_EQ(prtrack.get_num_points(), 5);
93
 
  EXPECT_EQ(prtrack.get_charge(), -1);
 
88
  line_sz.set_c(c);
 
89
  line_sz.set_m(m);
 
90
  line_sz.set_chisq(sz_chisq);
 
91
  circle.set_R(R);
 
92
  circle.set_chisq(circ_chisq);
 
93
  std::vector<double> phi;
 
94
  std::vector<SciFiSpacePoint*> spnts;
 
95
  SciFiSpacePoint *spoint = new SciFiSpacePoint();
 
96
  spoint->set_tracker(tracker);
 
97
  spnts.push_back(spoint);
 
98
 
 
99
  SciFiHelicalPRTrack trk(tracker, num_points, charge, pos0, phi0, circle, line_sz,
 
100
                          chisq, chisq_dof, point_spread, phi, spnts);
 
101
 
 
102
  EXPECT_EQ(trk.get_pos0().x(), x);
 
103
  EXPECT_EQ(trk.get_pos0().y(), y);
 
104
  EXPECT_EQ(trk.get_pos0().z(), z);
 
105
  EXPECT_EQ(trk.get_phi0(), phi0);
 
106
  EXPECT_EQ(trk.get_dsdz(), m);
 
107
  EXPECT_EQ(trk.get_R(), R);
 
108
  EXPECT_EQ(trk.get_line_sz_chisq(), sz_chisq);
 
109
  EXPECT_EQ(trk.get_circle_chisq(), circ_chisq);
 
110
  EXPECT_EQ(trk.get_tracker(), tracker);
 
111
  EXPECT_EQ(trk.get_num_points(), num_points);
 
112
  EXPECT_EQ(trk.get_charge(), charge);
 
113
  EXPECT_EQ(trk.get_chisq(), chisq);
 
114
  EXPECT_EQ(trk.get_chisq_dof(), chisq_dof);
 
115
  EXPECT_EQ(trk.get_point_spread(), point_spread);
 
116
  size_t size = 1;
 
117
  EXPECT_EQ(trk.get_spacepoints()->GetEntries(), size);
 
118
  EXPECT_EQ(static_cast<SciFiSpacePoint*>(trk.get_spacepoints()->At(0))->get_tracker(), tracker);
 
119
  size = 0;
 
120
  EXPECT_EQ(trk.get_phi().size(), size);
94
121
}
95
122
 
96
123
TEST_F(SciFiHelicalPRTrackTestDS, test_copy_constructor) {
101
128
  double y0 = 2.0;
102
129
  double z0 = 1100.0;
103
130
  double phi0 = 4.0;
104
 
  double psi0 = 2.4;
105
131
  double dsdz = 0.02;
106
132
  double R = 15.0;
107
133
  double chisq = 30.0;
108
134
  double chisq_dof = 10.0;
 
135
  double point_spread = 50.0;
109
136
  double line_sz_chisq = 5.0;
110
137
  double circle_x0 = 6.0;
111
138
  double circle_y0 = 7.0;
112
139
  double circle_chisq = 8.0;
113
140
 
114
 
  SciFiHelicalPRTrack trk1(tracker, num_points, charge, x0, y0, z0, phi0, psi0, dsdz, R, chisq);
115
 
  trk1.set_chisq_dof(chisq_dof);
116
 
  trk1.set_line_sz_chisq(line_sz_chisq);
117
 
  trk1.set_circle_x0(circle_x0);
118
 
  trk1.set_circle_y0(circle_y0);
119
 
  trk1.set_circle_chisq(circle_chisq);
 
141
  SciFiHelicalPRTrack* trk1 = new SciFiHelicalPRTrack;
 
142
  trk1->set_tracker(tracker);
 
143
  trk1->set_num_points(num_points);
 
144
  trk1->set_charge(charge);
 
145
  trk1->set_pos0(ThreeVector(x0, y0, z0));
 
146
  trk1->set_phi0(phi0);
 
147
  trk1->set_dsdz(dsdz);
 
148
  trk1->set_R(R);
 
149
  trk1->set_chisq(chisq);
 
150
  trk1->set_chisq_dof(chisq_dof);
 
151
  trk1->set_point_spread(point_spread);
 
152
  trk1->set_line_sz_chisq(line_sz_chisq);
 
153
  trk1->set_circle_x0(circle_x0);
 
154
  trk1->set_circle_y0(circle_y0);
 
155
  trk1->set_circle_chisq(circle_chisq);
120
156
 
121
157
  SciFiSpacePoint *spoint = new SciFiSpacePoint();
122
158
  spoint->set_tracker(tracker);
123
159
  SciFiSpacePointPArray spoints;
124
160
  spoints.push_back(spoint);
125
 
  trk1.set_spacepoints(spoints);
 
161
  trk1->set_spacepoints_pointers(spoints);
126
162
 
127
163
  std::vector<double> phi_i(0);
128
164
  phi_i.push_back(1.0);
129
165
  phi_i.push_back(-2.0);
130
166
 
131
 
  SciFiHelicalPRTrack trk2(trk1);
 
167
  SciFiHelicalPRTrack trk2(*trk1);
 
168
  delete trk1;
132
169
 
133
 
  EXPECT_EQ(trk2.get_x0(), x0);
134
 
  EXPECT_EQ(trk2.get_y0(), y0);
135
 
  EXPECT_EQ(trk2.get_z0(), z0);
 
170
  EXPECT_EQ(trk2.get_pos0().x(), x0);
 
171
  EXPECT_EQ(trk2.get_pos0().y(), y0);
 
172
  EXPECT_EQ(trk2.get_pos0().z(), z0);
136
173
  EXPECT_EQ(trk2.get_phi0(), phi0);
137
 
  EXPECT_EQ(trk2.get_psi0(), psi0);
138
174
  EXPECT_EQ(trk2.get_dsdz(), dsdz);
139
175
  EXPECT_EQ(trk2.get_R(), R);
140
176
  EXPECT_EQ(trk2.get_chisq(), chisq);
141
177
  EXPECT_EQ(trk2.get_chisq_dof(), chisq_dof);
 
178
  EXPECT_EQ(trk2.get_point_spread(), point_spread);
142
179
  EXPECT_EQ(trk2.get_line_sz_chisq(), line_sz_chisq);
143
180
  EXPECT_EQ(trk2.get_circle_x0(), circle_x0);
144
181
  EXPECT_EQ(trk2.get_circle_y0(), circle_y0);
146
183
  EXPECT_EQ(trk2.get_tracker(), tracker);
147
184
  EXPECT_EQ(trk2.get_num_points(), num_points);
148
185
  EXPECT_EQ(trk2.get_charge(), charge);
149
 
  EXPECT_EQ(trk2.get_spacepoints()[0]->get_tracker(), tracker);
150
 
}
151
 
 
152
 
TEST_F(SciFiHelicalPRTrackTestDS, test_helix_constructor) {
153
 
  int tracker = 0;
154
 
  int num_points = 3;
155
 
  int charge = -1;
156
 
  double x0 = 1.0;
157
 
  double y0 = 2.0;
158
 
  double z0 = 1100.0;
159
 
  double phi0 = 4.0;
160
 
  double dsdz = 0.02;
161
 
  double R = 15.0;
162
 
  double chisq = 30.0;
163
 
  double chisq_dof = 10.0;
164
 
 
165
 
  SimpleHelix hlx;
166
 
  hlx.set_R(R);
167
 
  hlx.set_Phi_0(phi0);
168
 
  hlx.set_dsdz(dsdz);
169
 
  hlx.set_chisq(chisq);
170
 
  hlx.set_chisq_dof(chisq_dof);
171
 
 
172
 
  ThreeVector pos(x0, y0, z0);
173
 
 
174
 
  SciFiHelicalPRTrack prtrack(tracker, num_points, charge, pos, hlx);
175
 
 
176
 
  unsigned int size = 0;
177
 
 
178
 
  EXPECT_EQ(prtrack.get_x0(), x0);
179
 
  EXPECT_EQ(prtrack.get_y0(), y0);
180
 
  EXPECT_EQ(prtrack.get_z0(), z0);
181
 
  EXPECT_EQ(prtrack.get_phi0(), phi0);
182
 
  EXPECT_EQ(prtrack.get_psi0(), -1);
183
 
  EXPECT_EQ(prtrack.get_dsdz(), dsdz);
184
 
  EXPECT_EQ(prtrack.get_R(), R);
185
 
  EXPECT_EQ(prtrack.get_chisq(), chisq);
186
 
  EXPECT_EQ(prtrack.get_chisq_dof(), chisq_dof);
187
 
  EXPECT_EQ(prtrack.get_line_sz_chisq(), -1);
188
 
  EXPECT_EQ(prtrack.get_circle_x0(), -1);
189
 
  EXPECT_EQ(prtrack.get_circle_y0(), -1);
190
 
  EXPECT_EQ(prtrack.get_circle_chisq(), -1);
191
 
  EXPECT_EQ(prtrack.get_spacepoints().size(), size);
192
 
  EXPECT_EQ(prtrack.get_tracker(), tracker);
193
 
  EXPECT_EQ(prtrack.get_num_points(), num_points);
194
 
  EXPECT_EQ(prtrack.get_charge(), charge);
195
 
}
 
186
  EXPECT_EQ(static_cast<SciFiSpacePoint*>(trk2.get_spacepoints()->At(0))->get_tracker(), tracker);
 
187
}
 
188
 
 
189
// TEST_F(SciFiHelicalPRTrackTestDS, test_helix_constructor) {
 
190
//   int tracker = 0;
 
191
//   int num_points = 3;
 
192
//   int charge = -1;
 
193
//   double x0 = 1.0;
 
194
//   double y0 = 2.0;
 
195
//   double z0 = 1100.0;
 
196
//   double phi0 = 4.0;
 
197
//   double dsdz = 0.02;
 
198
//   double R = 15.0;
 
199
//   double chisq = 30.0;
 
200
//   double chisq_dof = 10.0;
 
201
//
 
202
//   SimpleHelix hlx;
 
203
//   hlx.set_R(R);
 
204
//   hlx.set_Phi_0(phi0);
 
205
//   hlx.set_dsdz(dsdz);
 
206
//   hlx.set_chisq(chisq);
 
207
//   hlx.set_chisq_dof(chisq_dof);
 
208
//
 
209
//   ThreeVector pos(x0, y0, z0);
 
210
//
 
211
//   SciFiHelicalPRTrack prtrack(tracker, num_points, charge, pos, hlx);
 
212
//
 
213
//   unsigned int size = 0;
 
214
//
 
215
//   EXPECT_EQ(prtrack.get_x0(), x0);
 
216
//   EXPECT_EQ(prtrack.get_y0(), y0);
 
217
//   EXPECT_EQ(prtrack.get_z0(), z0);
 
218
//   EXPECT_EQ(prtrack.get_phi0(), phi0);
 
219
//   EXPECT_EQ(prtrack.get_dsdz(), dsdz);
 
220
//   EXPECT_EQ(prtrack.get_R(), R);
 
221
//   EXPECT_EQ(prtrack.get_chisq(), chisq);
 
222
//   EXPECT_EQ(prtrack.get_chisq_dof(), chisq_dof);
 
223
//   EXPECT_EQ(prtrack.get_line_sz_chisq(), -1);
 
224
//   EXPECT_EQ(prtrack.get_circle_x0(), -1);
 
225
//   EXPECT_EQ(prtrack.get_circle_y0(), -1);
 
226
//   EXPECT_EQ(prtrack.get_circle_chisq(), -1);
 
227
//   EXPECT_EQ(prtrack.get_spacepoints().size(), size);
 
228
//   EXPECT_EQ(prtrack.get_tracker(), tracker);
 
229
//   EXPECT_EQ(prtrack.get_num_points(), num_points);
 
230
//   EXPECT_EQ(prtrack.get_charge(), charge);
 
231
// }
196
232
 
197
233
TEST_F(SciFiHelicalPRTrackTestDS, test_assignment_operator) {
198
234
  int tracker = 0;
202
238
  double y0 = 2.0;
203
239
  double z0 = 1100.0;
204
240
  double phi0 = 4.0;
205
 
  double psi0 = 2.4;
206
241
  double dsdz = 0.02;
207
242
  double R = 15.0;
208
243
  double chisq = 30.0;
209
244
  double chisq_dof = 10.0;
 
245
  double point_spread = 50.0;
210
246
  double line_sz_chisq = 5.0;
211
247
  double circle_x0 = 6.0;
212
248
  double circle_y0 = 7.0;
213
249
  double circle_chisq = 8.0;
214
250
 
215
 
  SciFiHelicalPRTrack trk1(tracker, num_points, charge, x0, y0, z0, phi0, psi0, dsdz, R, chisq);
216
 
  trk1.set_chisq_dof(chisq_dof);
217
 
  trk1.set_line_sz_chisq(line_sz_chisq);
218
 
  trk1.set_circle_x0(circle_x0);
219
 
  trk1.set_circle_y0(circle_y0);
220
 
  trk1.set_circle_chisq(circle_chisq);
 
251
  SciFiHelicalPRTrack* trk1 = new SciFiHelicalPRTrack();
 
252
  trk1->set_tracker(tracker);
 
253
  trk1->set_num_points(num_points);
 
254
  trk1->set_charge(charge);
 
255
  trk1->set_pos0(ThreeVector(x0, y0, z0));
 
256
  trk1->set_phi0(phi0);
 
257
  trk1->set_dsdz(dsdz);
 
258
  trk1->set_R(R);
 
259
  trk1->set_chisq(chisq);
 
260
  trk1->set_chisq_dof(chisq_dof);
 
261
  trk1->set_point_spread(point_spread);
 
262
  trk1->set_line_sz_chisq(line_sz_chisq);
 
263
  trk1->set_circle_x0(circle_x0);
 
264
  trk1->set_circle_y0(circle_y0);
 
265
  trk1->set_circle_chisq(circle_chisq);
221
266
 
222
267
  SciFiSpacePoint *spoint = new SciFiSpacePoint();
223
268
  spoint->set_tracker(tracker);
224
269
  SciFiSpacePointPArray spoints;
225
270
  spoints.push_back(spoint);
226
 
  trk1.set_spacepoints(spoints);
 
271
  trk1->set_spacepoints_pointers(spoints);
227
272
 
228
273
  SciFiHelicalPRTrack trk2;
229
 
  trk2 = trk1;
 
274
  trk2 = *trk1;
230
275
 
231
 
  EXPECT_EQ(trk2.get_x0(), x0);
232
 
  EXPECT_EQ(trk2.get_y0(), y0);
233
 
  EXPECT_EQ(trk2.get_z0(), z0);
 
276
  EXPECT_EQ(trk2.get_pos0().x(), x0);
 
277
  EXPECT_EQ(trk2.get_pos0().y(), y0);
 
278
  EXPECT_EQ(trk2.get_pos0().z(), z0);
234
279
  EXPECT_EQ(trk2.get_phi0(), phi0);
235
 
  EXPECT_EQ(trk2.get_psi0(), psi0);
236
280
  EXPECT_EQ(trk2.get_dsdz(), dsdz);
237
281
  EXPECT_EQ(trk2.get_R(), R);
238
282
  EXPECT_EQ(trk2.get_chisq(), chisq);
239
283
  EXPECT_EQ(trk2.get_chisq_dof(), chisq_dof);
 
284
  EXPECT_EQ(trk2.get_point_spread(), point_spread);
240
285
  EXPECT_EQ(trk2.get_line_sz_chisq(), line_sz_chisq);
241
286
  EXPECT_EQ(trk2.get_circle_x0(), circle_x0);
242
287
  EXPECT_EQ(trk2.get_circle_y0(), circle_y0);
244
289
  EXPECT_EQ(trk2.get_tracker(), tracker);
245
290
  EXPECT_EQ(trk2.get_num_points(), num_points);
246
291
  EXPECT_EQ(trk2.get_charge(), charge);
247
 
  EXPECT_EQ(trk2.get_spacepoints()[0]->get_tracker(), tracker);
 
292
  EXPECT_EQ(static_cast<SciFiSpacePoint*>(trk2.get_spacepoints()->At(0))->get_tracker(), tracker);
248
293
}
249
294
 
250
295
TEST_F(SciFiHelicalPRTrackTestDS, test_setters_getters) {
255
300
  double y0 = 2.0;
256
301
  double z0 = 1100.0;
257
302
  double phi0 = 4.0;
258
 
  double psi0 = 2.4;
259
303
  double dsdz = 0.02;
260
304
  double R = 15.0;
261
305
  double chisq = 30.0;
262
306
  double chisq_dof = 10.0;
 
307
  double point_spread = 50.0;
263
308
  double line_sz_chisq = 5.0;
264
309
  double circle_x0 = 6.0;
265
310
  double circle_y0 = 7.0;
270
315
  SciFiSpacePointPArray spoints;
271
316
  spoints.push_back(spoint);
272
317
 
273
 
  SciFiHelicalPRTrack prtrack;
274
 
 
275
 
  prtrack.set_x0(x0);
276
 
  prtrack.set_y0(y0);
277
 
  prtrack.set_z0(z0);
278
 
  prtrack.set_phi0(phi0);
279
 
  prtrack.set_psi0(psi0);
280
 
  prtrack.set_dsdz(dsdz);
281
 
  prtrack.set_R(R);
282
 
  prtrack.set_chisq(chisq);
283
 
  prtrack.set_chisq_dof(chisq_dof);
284
 
  prtrack.set_line_sz_chisq(line_sz_chisq);
285
 
  prtrack.set_circle_x0(circle_x0);
286
 
  prtrack.set_circle_y0(circle_y0);
287
 
  prtrack.set_circle_chisq(circle_chisq);
288
 
 
289
 
  prtrack.set_tracker(tracker);
290
 
  prtrack.set_num_points(num_points);
291
 
  prtrack.set_charge(-1);
292
 
 
293
 
  prtrack.set_spacepoints(spoints);
294
 
 
295
 
  EXPECT_EQ(prtrack.get_x0(), x0);
296
 
  EXPECT_EQ(prtrack.get_y0(), y0);
297
 
  EXPECT_EQ(prtrack.get_z0(), z0);
298
 
  EXPECT_EQ(prtrack.get_phi0(), phi0);
299
 
  EXPECT_EQ(prtrack.get_psi0(), psi0);
300
 
  EXPECT_EQ(prtrack.get_dsdz(), dsdz);
301
 
  EXPECT_EQ(prtrack.get_R(), R);
302
 
  EXPECT_EQ(prtrack.get_chisq(), chisq);
303
 
  EXPECT_EQ(prtrack.get_chisq_dof(), chisq_dof);
304
 
  EXPECT_EQ(prtrack.get_line_sz_chisq(), line_sz_chisq);
305
 
  EXPECT_EQ(prtrack.get_circle_x0(), circle_x0);
306
 
  EXPECT_EQ(prtrack.get_circle_y0(), circle_y0);
307
 
  EXPECT_EQ(prtrack.get_circle_chisq(), circle_chisq);
308
 
  EXPECT_EQ(prtrack.get_tracker(), tracker);
309
 
  EXPECT_EQ(prtrack.get_num_points(), num_points);
310
 
  EXPECT_EQ(prtrack.get_charge(), charge);
311
 
 
312
 
  EXPECT_EQ(prtrack.get_spacepoints()[0]->get_tracker(), tracker);
 
318
  SciFiHelicalPRTrack trk;
 
319
 
 
320
  trk.set_tracker(tracker);
 
321
  trk.set_num_points(num_points);
 
322
  trk.set_charge(-1);
 
323
  trk.set_phi0(phi0);
 
324
  trk.set_dsdz(dsdz);
 
325
  trk.set_R(R);
 
326
  trk.set_chisq(chisq);
 
327
  trk.set_chisq_dof(chisq_dof);
 
328
  trk.set_point_spread(point_spread);
 
329
  trk.set_line_sz_chisq(line_sz_chisq);
 
330
  trk.set_circle_x0(circle_x0);
 
331
  trk.set_circle_y0(circle_y0);
 
332
  trk.set_circle_chisq(circle_chisq);
 
333
  trk.set_pos0(ThreeVector(x0, y0, z0));
 
334
  trk.set_spacepoints_pointers(spoints);
 
335
 
 
336
  EXPECT_EQ(trk.get_tracker(), tracker);
 
337
  EXPECT_EQ(trk.get_num_points(), num_points);
 
338
  EXPECT_EQ(trk.get_charge(), charge);
 
339
  EXPECT_EQ(trk.get_phi0(), phi0);
 
340
  EXPECT_EQ(trk.get_dsdz(), dsdz);
 
341
  EXPECT_EQ(trk.get_R(), R);
 
342
  EXPECT_EQ(trk.get_chisq(), chisq);
 
343
  EXPECT_EQ(trk.get_chisq_dof(), chisq_dof);
 
344
  EXPECT_EQ(trk.get_point_spread(), point_spread);
 
345
  EXPECT_EQ(trk.get_line_sz_chisq(), line_sz_chisq);
 
346
  EXPECT_EQ(trk.get_circle_x0(), circle_x0);
 
347
  EXPECT_EQ(trk.get_circle_y0(), circle_y0);
 
348
  EXPECT_EQ(trk.get_circle_chisq(), circle_chisq);
 
349
  EXPECT_EQ(trk.get_pos0().x(), x0);
 
350
  EXPECT_EQ(trk.get_pos0().y(), y0);
 
351
  EXPECT_EQ(trk.get_pos0().z(), z0);
 
352
  EXPECT_EQ(
 
353
    static_cast<SciFiSpacePoint*>(trk.get_spacepoints()->At(0))->get_tracker(), tracker);
 
354
  EXPECT_EQ(trk.get_spacepoints_pointers()[0]->get_tracker(), tracker);
313
355
}
314
356
 
315
357
} // ~namespace MAUS