← Back to branch summary

~christopher-hunt08/maus/maus_integrated_kalman

« back to all changes in this revision

Viewing changes to tests/cpp_unit/Recon/SciFi/PatternRecognitionTest.cc

  • Committer: Adam Dobbs
  • Date: 2017-06-23 16:38:01 UTC
  • mfrom: (659.2.69 release-candidate)
  • Revision ID: phuccj@gmail.com-20170623163801-s3l66cw3nqi17szl
Tags: MAUS-v2.9.1
MAUS-v2.9.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/cpp_unit/Recon/SciFi/PatternRecognitionTest.cc
36
36
  virtual void SetUp()    {}
37
37
  virtual void TearDown() {}
38
38
 
39
 
  std::vector<SciFiSpacePoint*> set_up_spacepoints() {
 
39
  std::vector<SciFiSpacePoint*> set_up_single_track_spacepoints() {
40
40
    SciFiSpacePoint *sp1 = new SciFiSpacePoint();
41
41
    SciFiSpacePoint *sp2 = new SciFiSpacePoint();
42
42
    SciFiSpacePoint *sp3 = new SciFiSpacePoint();
87
87
 
88
88
    return spnts;
89
89
  }
 
90
 
 
91
  std::vector<SciFiSpacePoint*> set_up_multiple_track_spacepoints() {
 
92
    // Here we use the npe just to keep track of which tracker and
 
93
    // track number each sp belongs to
 
94
    std::vector<SciFiSpacePoint*> spnts_t1_trk1;
 
95
    for ( size_t i = 0; i < 5; ++i ) {
 
96
      spnts_t1_trk1.push_back(new SciFiSpacePoint());
 
97
      spnts_t1_trk1[i]->set_tracker(0);
 
98
      spnts_t1_trk1[i]->set_station(5-i);
 
99
      spnts_t1_trk1[i]->set_used(false);
 
100
      spnts_t1_trk1[i]->set_npe(11);
 
101
    }
 
102
    std::vector<SciFiSpacePoint*> spnts_t1_trk2;
 
103
    for ( size_t i = 0; i < 5; ++i ) {
 
104
      spnts_t1_trk2.push_back(new SciFiSpacePoint());
 
105
      spnts_t1_trk2[i]->set_tracker(0);
 
106
      spnts_t1_trk2[i]->set_station(5-i);
 
107
      spnts_t1_trk2[i]->set_used(false);
 
108
      spnts_t1_trk2[i]->set_npe(12);
 
109
    }
 
110
    std::vector<SciFiSpacePoint*> spnts_t1_trk3;
 
111
    for ( size_t i = 0; i < 5; ++i ) {
 
112
      spnts_t1_trk3.push_back(new SciFiSpacePoint());
 
113
      spnts_t1_trk3[i]->set_tracker(0);
 
114
      spnts_t1_trk3[i]->set_station(5-i);
 
115
      spnts_t1_trk3[i]->set_used(false);
 
116
      spnts_t1_trk3[i]->set_npe(13);
 
117
    }
 
118
    std::vector<SciFiSpacePoint*> spnts_t1_trk4;
 
119
    for ( size_t i = 0; i < 5; ++i ) {
 
120
      spnts_t1_trk4.push_back(new SciFiSpacePoint());
 
121
      spnts_t1_trk4[i]->set_tracker(0);
 
122
      spnts_t1_trk4[i]->set_station(5-i);
 
123
      spnts_t1_trk4[i]->set_used(false);
 
124
      spnts_t1_trk4[i]->set_npe(14);
 
125
    }
 
126
 
 
127
    std::vector<SciFiSpacePoint*> spnts_t2_trk1;
 
128
    for ( size_t i = 0; i < 5; ++i ) {
 
129
      spnts_t2_trk1.push_back(new SciFiSpacePoint());
 
130
      spnts_t2_trk1[i]->set_tracker(1);
 
131
      spnts_t2_trk1[i]->set_station(i+1);
 
132
      spnts_t2_trk1[i]->set_used(false);
 
133
      spnts_t2_trk1[i]->set_npe(21);
 
134
    }
 
135
    std::vector<SciFiSpacePoint*> spnts_t2_trk2;
 
136
    for ( size_t i = 0; i < 5; ++i ) {
 
137
      spnts_t2_trk2.push_back(new SciFiSpacePoint());
 
138
      spnts_t2_trk2[i]->set_tracker(1);
 
139
      spnts_t2_trk2[i]->set_station(i+1);
 
140
      spnts_t2_trk2[i]->set_used(false);
 
141
      spnts_t2_trk2[i]->set_npe(22);
 
142
    }
 
143
    std::vector<SciFiSpacePoint*> spnts_t2_trk3;
 
144
    for ( size_t i = 0; i < 5; ++i ) {
 
145
      spnts_t2_trk3.push_back(new SciFiSpacePoint());
 
146
      spnts_t2_trk3[i]->set_tracker(1);
 
147
      spnts_t2_trk3[i]->set_station(i+1);
 
148
      spnts_t2_trk3[i]->set_used(false);
 
149
      spnts_t2_trk3[i]->set_npe(23);
 
150
    }
 
151
    std::vector<SciFiSpacePoint*> spnts_t2_trk4;
 
152
    for ( size_t i = 0; i < 5; ++i ) {
 
153
      spnts_t2_trk4.push_back(new SciFiSpacePoint());
 
154
      spnts_t2_trk4[i]->set_tracker(1);
 
155
      spnts_t2_trk4[i]->set_station(i+1);
 
156
      spnts_t2_trk4[i]->set_used(false);
 
157
      spnts_t2_trk4[i]->set_npe(24);
 
158
    }
 
159
 
 
160
    // Spill 4, mu plus
 
161
    spnts_t1_trk1[0]->set_position(ThreeVector(0.0, 66.44, 1100.0));
 
162
    spnts_t1_trk1[1]->set_position(ThreeVector(-26.4, 47.46, 750.5));
 
163
    spnts_t1_trk1[2]->set_position(ThreeVector(-2.491, 28.47, 450.5));
 
164
    spnts_t1_trk1[3]->set_position(ThreeVector(14.45, 49.18, 200.6));
 
165
    spnts_t1_trk1[4]->set_position(ThreeVector(1.993, 69.03, 0.6523));
 
166
 
 
167
    spnts_t2_trk1[0]->set_position(ThreeVector(-26.4, 56.09, 0.6523));
 
168
    spnts_t2_trk1[1]->set_position(ThreeVector(-25.9, -1.726, 200.7));
 
169
    spnts_t2_trk1[2]->set_position(ThreeVector(43.84, -17.26, 450.7));
 
170
    spnts_t2_trk1[3]->set_position(ThreeVector(57.79, 63.85, 750.7));
 
171
    spnts_t2_trk1[4]->set_position(ThreeVector(-32.38, 47.46, 1101));
 
172
 
 
173
    // Spill 5, mu plus
 
174
    spnts_t1_trk2[0]->set_position(ThreeVector(-16.44, 15.53, 1100.0));
 
175
    spnts_t1_trk2[1]->set_position(ThreeVector(-19.93, 10.35, 750.5 ));
 
176
    spnts_t1_trk2[2]->set_position(ThreeVector(-15.44, 9.491, 450.5));
 
177
    spnts_t1_trk2[3]->set_position(ThreeVector(-15.44, 12.94, 200.6));
 
178
    spnts_t1_trk2[4]->set_position(ThreeVector(-18.93, 13.81, 0.6523));
 
179
 
 
180
    spnts_t2_trk2[0]->set_position(ThreeVector(-4.982, 15.53, 0.6523));
 
181
    spnts_t2_trk2[1]->set_position(ThreeVector(-12.7, -5.609, 200.7));
 
182
    spnts_t2_trk2[2]->set_position(ThreeVector(10.71, -20.28, 450.7));
 
183
    spnts_t2_trk2[3]->set_position(ThreeVector(23.41, 9.491, 750.7));
 
184
    spnts_t2_trk2[4]->set_position(ThreeVector(-12.95, 5.177, 1101 ));
 
185
 
 
186
    // Spill 6, mu plus
 
187
    spnts_t1_trk3[0]->set_position(ThreeVector(-50.81, -23.3,  1100));
 
188
    spnts_t1_trk3[1]->set_position(ThreeVector(33.88,  8.628,  750.5));
 
189
    spnts_t1_trk3[2]->set_position(ThreeVector(-41.35, 44.01,  450.5));
 
190
    spnts_t1_trk3[3]->set_position(ThreeVector(-43.84, -31.06, 200.6));
 
191
    spnts_t1_trk3[4]->set_position(ThreeVector(18.93,  -27.61, 0.6523 ));
 
192
 
 
193
    spnts_t2_trk3[0]->set_position(ThreeVector(-3.487, 47.46,  0.6523 ));
 
194
    spnts_t2_trk3[1]->set_position(ThreeVector(13.95,  24.16,  200.7));
 
195
    spnts_t2_trk3[2]->set_position(ThreeVector(40.85,  44.87,  450.7));
 
196
    spnts_t2_trk3[3]->set_position(ThreeVector(8.469,  61.26,  750.7 ));
 
197
    spnts_t2_trk3[4]->set_position(ThreeVector(18.43,  26.75,  1101 ));
 
198
 
 
199
    // Spill 2, mu minus
 
200
    spnts_t1_trk4[0]->set_position(ThreeVector(-0.4982, 31.06, 1100));
 
201
    spnts_t1_trk4[1]->set_position(ThreeVector(-9.465, -0.8628, 750.5));
 
202
    spnts_t1_trk4[2]->set_position(ThreeVector(20.42, 4.314, 450.5));
 
203
    spnts_t1_trk4[3]->set_position(ThreeVector(11.46, 30.2, 200.6));
 
204
    spnts_t1_trk4[4]->set_position(ThreeVector(-9.465, 25.02, 0.6523));
 
205
 
 
206
    spnts_t2_trk4[0]->set_position(ThreeVector(-2.491, -19.85, 0.6523));
 
207
    spnts_t2_trk4[1]->set_position(ThreeVector(12.95, -24.16, 200.7));
 
208
    spnts_t2_trk4[2]->set_position(ThreeVector(18.93, -6.903, 450.7));
 
209
    spnts_t2_trk4[3]->set_position(ThreeVector(-2.491, -4.314, 750.7));
 
210
    spnts_t2_trk4[4]->set_position(ThreeVector(7.971, -25.89, 1101.0));
 
211
 
 
212
    std::vector<SciFiSpacePoint*> spnts(spnts_t1_trk1);
 
213
    spnts.insert(spnts.end(), spnts_t1_trk2.begin(), spnts_t1_trk2.end());
 
214
    spnts.insert(spnts.end(), spnts_t1_trk3.begin(), spnts_t1_trk3.end());
 
215
    spnts.insert(spnts.end(), spnts_t1_trk4.begin(), spnts_t1_trk4.end());
 
216
    spnts.insert(spnts.end(), spnts_t2_trk1.begin(), spnts_t2_trk1.end());
 
217
    spnts.insert(spnts.end(), spnts_t2_trk2.begin(), spnts_t2_trk2.end());
 
218
    spnts.insert(spnts.end(), spnts_t2_trk3.begin(), spnts_t2_trk3.end());
 
219
    spnts.insert(spnts.end(), spnts_t2_trk4.begin(), spnts_t2_trk4.end());
 
220
 
 
221
    return spnts;
 
222
  }
90
223
};
91
224
 
92
225
TEST_F(PatternRecognitionTest, test_constructor) {
97
230
  EXPECT_TRUE(pr._up_helical_pr_on);
98
231
  EXPECT_TRUE(pr._down_helical_pr_on);
99
232
  EXPECT_FALSE(pr._sp_search_on);
 
233
  EXPECT_EQ(0, pr._line_fitter);
 
234
  EXPECT_EQ(0, pr._circle_fitter);
100
235
  EXPECT_EQ(0, pr._verb);
101
236
  EXPECT_EQ(2, pr._n_trackers);
102
237
  EXPECT_EQ(5, pr._n_stations);
124
259
  EXPECT_TRUE(pr._up_helical_pr_on);
125
260
  EXPECT_TRUE(pr._down_helical_pr_on);
126
261
  EXPECT_FALSE(pr._sp_search_on);
 
262
  EXPECT_EQ(0, pr._line_fitter);
 
263
  EXPECT_EQ(0, pr._circle_fitter);
127
264
  EXPECT_EQ(0, pr._verb);
128
265
  EXPECT_EQ(2, pr._n_trackers);
129
266
  EXPECT_EQ(5, pr._n_stations);
149
286
  pr.set_parameters_to_default();
150
287
 
151
288
  // Set up the spacepoints vector
152
 
  std::vector<SciFiSpacePoint*> spnts = set_up_spacepoints();
 
289
  std::vector<SciFiSpacePoint*> spnts = set_up_single_track_spacepoints();
153
290
 
154
291
  // For a straight fit
155
292
  // ------------------
216
353
}
217
354
*/
218
355
 
219
 
TEST_F(PatternRecognitionTest, test_multiple_evts_per_trigger) {
 
356
TEST_F(PatternRecognitionTest, test_multiple_evts_per_trigger_lsq) {
220
357
 
221
358
  PatternRecognition pr;
222
359
  pr.set_parameters_to_default();
 
360
  pr.set_circle_fitter(0);
223
361
 
224
362
  // Set up the spacepoints vector
225
 
  std::vector<SciFiSpacePoint*> spnts_t1_trk1;
226
 
  for ( size_t i = 0; i < 5; ++i ) {
227
 
    spnts_t1_trk1.push_back(new SciFiSpacePoint());
228
 
    spnts_t1_trk1[i]->set_tracker(0);
229
 
    spnts_t1_trk1[i]->set_station(5-i);
230
 
    spnts_t1_trk1[i]->set_used(false);
231
 
  }
232
 
  std::vector<SciFiSpacePoint*> spnts_t1_trk2;
233
 
  for ( size_t i = 0; i < 5; ++i ) {
234
 
    spnts_t1_trk2.push_back(new SciFiSpacePoint());
235
 
    spnts_t1_trk2[i]->set_tracker(0);
236
 
    spnts_t1_trk2[i]->set_station(5-i);
237
 
    spnts_t1_trk2[i]->set_used(false);
238
 
  }
239
 
  std::vector<SciFiSpacePoint*> spnts_t1_trk3;
240
 
  for ( size_t i = 0; i < 5; ++i ) {
241
 
    spnts_t1_trk3.push_back(new SciFiSpacePoint());
242
 
    spnts_t1_trk3[i]->set_tracker(0);
243
 
    spnts_t1_trk3[i]->set_station(5-i);
244
 
    spnts_t1_trk3[i]->set_used(false);
245
 
  }
246
 
  std::vector<SciFiSpacePoint*> spnts_t1_trk4;
247
 
  for ( size_t i = 0; i < 5; ++i ) {
248
 
    spnts_t1_trk4.push_back(new SciFiSpacePoint());
249
 
    spnts_t1_trk4[i]->set_tracker(0);
250
 
    spnts_t1_trk4[i]->set_station(5-i);
251
 
    spnts_t1_trk4[i]->set_used(false);
252
 
  }
253
 
 
254
 
  std::vector<SciFiSpacePoint*> spnts_t2_trk1;
255
 
  for ( size_t i = 0; i < 5; ++i ) {
256
 
    spnts_t2_trk1.push_back(new SciFiSpacePoint());
257
 
    spnts_t2_trk1[i]->set_tracker(1);
258
 
    spnts_t2_trk1[i]->set_station(i+1);
259
 
    spnts_t2_trk1[i]->set_used(false);
260
 
  }
261
 
  std::vector<SciFiSpacePoint*> spnts_t2_trk2;
262
 
  for ( size_t i = 0; i < 5; ++i ) {
263
 
    spnts_t2_trk2.push_back(new SciFiSpacePoint());
264
 
    spnts_t2_trk2[i]->set_tracker(1);
265
 
    spnts_t2_trk2[i]->set_station(i+1);
266
 
    spnts_t2_trk2[i]->set_used(false);
267
 
  }
268
 
  std::vector<SciFiSpacePoint*> spnts_t2_trk3;
269
 
  for ( size_t i = 0; i < 5; ++i ) {
270
 
    spnts_t2_trk3.push_back(new SciFiSpacePoint());
271
 
    spnts_t2_trk3[i]->set_tracker(1);
272
 
    spnts_t2_trk3[i]->set_station(i+1);
273
 
    spnts_t2_trk3[i]->set_used(false);
274
 
  }
275
 
  std::vector<SciFiSpacePoint*> spnts_t2_trk4;
276
 
  for ( size_t i = 0; i < 5; ++i ) {
277
 
    spnts_t2_trk4.push_back(new SciFiSpacePoint());
278
 
    spnts_t2_trk4[i]->set_tracker(1);
279
 
    spnts_t2_trk4[i]->set_station(i+1);
280
 
    spnts_t2_trk4[i]->set_used(false);
281
 
  }
282
 
 
283
 
 
284
 
  // Spill 4, mu plus
285
 
  spnts_t1_trk1[0]->set_position(ThreeVector(0.0, 66.44, 1100.0));
286
 
  spnts_t1_trk1[1]->set_position(ThreeVector(-26.4, 47.46, 750.5));
287
 
  spnts_t1_trk1[2]->set_position(ThreeVector(-2.491, 28.47, 450.5));
288
 
  spnts_t1_trk1[3]->set_position(ThreeVector(14.45, 49.18, 200.6));
289
 
  spnts_t1_trk1[4]->set_position(ThreeVector(1.993, 69.03, 0.6523));
290
 
 
291
 
  spnts_t2_trk1[0]->set_position(ThreeVector(-26.4, 56.09, 0.6523));
292
 
  spnts_t2_trk1[1]->set_position(ThreeVector(-25.9, -1.726, 200.7));
293
 
  spnts_t2_trk1[2]->set_position(ThreeVector(43.84, -17.26, 450.7));
294
 
  spnts_t2_trk1[3]->set_position(ThreeVector(57.79, 63.85, 750.7));
295
 
  spnts_t2_trk1[4]->set_position(ThreeVector(-32.38, 47.46, 1101));
296
 
 
297
 
  // Spill 5, mu plus
298
 
  spnts_t1_trk2[0]->set_position(ThreeVector(-16.44, 15.53, 1100.0));
299
 
  spnts_t1_trk2[1]->set_position(ThreeVector(-19.93, 10.35, 750.5 ));
300
 
  spnts_t1_trk2[2]->set_position(ThreeVector(-15.44, 9.491, 450.5));
301
 
  spnts_t1_trk2[3]->set_position(ThreeVector(-15.44, 12.94, 200.6));
302
 
  spnts_t1_trk2[4]->set_position(ThreeVector(-18.93, 13.81, 0.6523));
303
 
 
304
 
  spnts_t2_trk2[0]->set_position(ThreeVector(-4.982, 15.53, 0.6523));
305
 
  spnts_t2_trk2[1]->set_position(ThreeVector(-12.7, -5.609, 200.7));
306
 
  spnts_t2_trk2[2]->set_position(ThreeVector(10.71, -20.28, 450.7));
307
 
  spnts_t2_trk2[3]->set_position(ThreeVector(23.41, 9.491, 750.7));
308
 
  spnts_t2_trk2[4]->set_position(ThreeVector(-12.95, 5.177, 1101 ));
309
 
 
310
 
  // Spill 6, mu plus
311
 
  spnts_t1_trk3[0]->set_position(ThreeVector(-50.81, -23.3,  1100));
312
 
  spnts_t1_trk3[1]->set_position(ThreeVector(33.88,  8.628,  750.5));
313
 
  spnts_t1_trk3[2]->set_position(ThreeVector(-41.35, 44.01,  450.5));
314
 
  spnts_t1_trk3[3]->set_position(ThreeVector(-43.84, -31.06, 200.6));
315
 
  spnts_t1_trk3[4]->set_position(ThreeVector(18.93,  -27.61, 0.6523 ));
316
 
 
317
 
  spnts_t2_trk3[0]->set_position(ThreeVector(-3.487, 47.46,  0.6523 ));
318
 
  spnts_t2_trk3[1]->set_position(ThreeVector(13.95,  24.16,  200.7));
319
 
  spnts_t2_trk3[2]->set_position(ThreeVector(40.85,  44.87,  450.7));
320
 
  spnts_t2_trk3[3]->set_position(ThreeVector(8.469,  61.26,  750.7 ));
321
 
  spnts_t2_trk3[4]->set_position(ThreeVector(18.43,  26.75,  1101 ));
322
 
 
323
 
  // Spill 2, mu minus
324
 
  spnts_t1_trk4[0]->set_position(ThreeVector(-0.4982, 31.06, 1100));
325
 
  spnts_t1_trk4[1]->set_position(ThreeVector(-9.465, -0.8628, 750.5));
326
 
  spnts_t1_trk4[2]->set_position(ThreeVector(20.42, 4.314, 450.5));
327
 
  spnts_t1_trk4[3]->set_position(ThreeVector(11.46, 30.2, 200.6));
328
 
  spnts_t1_trk4[4]->set_position(ThreeVector(-9.465, 25.02, 0.6523));
329
 
 
330
 
  spnts_t2_trk4[0]->set_position(ThreeVector(-2.491, -19.85, 0.6523));
331
 
  spnts_t2_trk4[1]->set_position(ThreeVector(12.95, -24.16, 200.7));
332
 
  spnts_t2_trk4[2]->set_position(ThreeVector(18.93, -6.903, 450.7));
333
 
  spnts_t2_trk4[3]->set_position(ThreeVector(-2.491, -4.314, 750.7));
334
 
  spnts_t2_trk4[4]->set_position(ThreeVector(7.971, -25.89, 1101.0));
335
 
 
336
 
  std::vector<SciFiSpacePoint*> spnts(spnts_t1_trk1);
337
 
  spnts.insert(spnts.end(), spnts_t1_trk2.begin(), spnts_t1_trk2.end());
338
 
  spnts.insert(spnts.end(), spnts_t1_trk3.begin(), spnts_t1_trk3.end());
339
 
  spnts.insert(spnts.end(), spnts_t1_trk4.begin(), spnts_t1_trk4.end());
340
 
  spnts.insert(spnts.end(), spnts_t2_trk1.begin(), spnts_t2_trk1.end());
341
 
  spnts.insert(spnts.end(), spnts_t2_trk2.begin(), spnts_t2_trk2.end());
342
 
  spnts.insert(spnts.end(), spnts_t2_trk3.begin(), spnts_t2_trk3.end());
343
 
  spnts.insert(spnts.end(), spnts_t2_trk4.begin(), spnts_t2_trk4.end());
 
363
  std::vector<SciFiSpacePoint*> spnts = set_up_multiple_track_spacepoints();
344
364
  SciFiEvent evt1;
345
365
  evt1.set_spacepoints(spnts);
346
366
 
377
397
  EXPECT_EQ(5, htrks[5]->get_num_points());
378
398
  EXPECT_EQ(5, htrks[6]->get_num_points());
379
399
  EXPECT_EQ(5, htrks[7]->get_num_points());
 
400
  // Check npe, which we used to encode which sp belongs to which tracks
 
401
  for (SciFiHelicalPRTrack* trk : htrks) {
 
402
    std::vector<SciFiSpacePoint*> spnts = trk->get_spacepoints_pointers();
 
403
    EXPECT_NEAR(spnts[1]->get_npe(), spnts[0]->get_npe(), 0.01);
 
404
    EXPECT_NEAR(spnts[2]->get_npe(), spnts[0]->get_npe(), 0.01);
 
405
    EXPECT_NEAR(spnts[3]->get_npe(), spnts[0]->get_npe(), 0.01);
 
406
    EXPECT_NEAR(spnts[4]->get_npe(), spnts[0]->get_npe(), 0.01);
 
407
  }
380
408
  EXPECT_NEAR(htrks[0]->get_dsdz(), -0.1156, 0.001);
381
409
  EXPECT_NEAR(htrks[1]->get_dsdz(), -0.342, 0.01);
382
410
  EXPECT_NEAR(htrks[2]->get_dsdz(), -0.01834, 0.01);
385
413
  EXPECT_NEAR(htrks[5]->get_dsdz(), 0.3126, 0.001);
386
414
  EXPECT_NEAR(htrks[6]->get_dsdz(), 0.08396, 0.001);
387
415
  EXPECT_NEAR(htrks[7]->get_dsdz(), 0.1257, 0.001);
388
 
 
389
 
  // evt descoping will delete the spacepoints
 
416
}
 
417
 
 
418
TEST_F(PatternRecognitionTest, test_multiple_evts_per_trigger_rootfit) {
 
419
 
 
420
  PatternRecognition pr;
 
421
  pr.set_parameters_to_default();
 
422
  pr.set_circle_fitter(1);
 
423
 
 
424
  // Set up the spacepoints vector
 
425
  std::vector<SciFiSpacePoint*> spnts = set_up_multiple_track_spacepoints();
 
426
  SciFiEvent evt1;
 
427
  evt1.set_spacepoints(spnts);
 
428
 
 
429
  // Randomise things a bit to make it harder
 
430
  SciFiSpacePoint *sp1, *sp2;
 
431
  sp1 = spnts[3];
 
432
  sp2 = spnts[14];
 
433
  spnts[3] = sp2;
 
434
  spnts[14] = sp1;
 
435
  sp1 = spnts[4];
 
436
  sp2 = spnts[17];
 
437
  spnts[4] = sp2;
 
438
  spnts[17] = sp1;
 
439
 
 
440
  // Perform the recon
 
441
  pr.set_up_helical_pr_on(true);
 
442
  pr.set_down_helical_pr_on(true);
 
443
  pr.set_up_straight_pr_on(false);
 
444
  pr.set_down_straight_pr_on(false);
 
445
  pr.process(evt1);
 
446
 
 
447
  std::vector<SciFiStraightPRTrack*> strks;
 
448
  std::vector<SciFiHelicalPRTrack*> htrks;
 
449
  strks = evt1.straightprtracks();
 
450
  htrks = evt1.helicalprtracks();
 
451
 
 
452
  ASSERT_EQ(8u, htrks.size());
 
453
  EXPECT_EQ(0u, strks.size());
 
454
  EXPECT_EQ(5, htrks[0]->get_num_points());
 
455
  EXPECT_EQ(5, htrks[1]->get_num_points());
 
456
  EXPECT_EQ(5, htrks[2]->get_num_points());
 
457
  EXPECT_EQ(5, htrks[3]->get_num_points());
 
458
  EXPECT_EQ(5, htrks[4]->get_num_points());
 
459
  EXPECT_EQ(5, htrks[5]->get_num_points());
 
460
  EXPECT_EQ(5, htrks[6]->get_num_points());
 
461
  EXPECT_EQ(5, htrks[7]->get_num_points());
 
462
  // Check npe, which we used to encode which sp belongs to which tracks
 
463
  for (SciFiHelicalPRTrack* trk : htrks) {
 
464
    std::vector<SciFiSpacePoint*> spnts = trk->get_spacepoints_pointers();
 
465
    EXPECT_NEAR(spnts[1]->get_npe(), spnts[0]->get_npe(), 0.01);
 
466
    EXPECT_NEAR(spnts[2]->get_npe(), spnts[0]->get_npe(), 0.01);
 
467
    EXPECT_NEAR(spnts[3]->get_npe(), spnts[0]->get_npe(), 0.01);
 
468
    EXPECT_NEAR(spnts[4]->get_npe(), spnts[0]->get_npe(), 0.01);
 
469
  }
 
470
  EXPECT_NEAR(htrks[0]->get_dsdz(), -0.342, 0.01);
 
471
  EXPECT_NEAR(htrks[1]->get_dsdz(), -0.1156, 0.005);
 
472
  EXPECT_NEAR(htrks[2]->get_dsdz(), -0.01834, 0.01);
 
473
  EXPECT_NEAR(htrks[3]->get_dsdz(), -0.1178, 0.01);
 
474
  EXPECT_NEAR(htrks[4]->get_dsdz(), 0.08396, 0.001);
 
475
  EXPECT_NEAR(htrks[5]->get_dsdz(), 0.3126, 0.001);
 
476
  EXPECT_NEAR(htrks[6]->get_dsdz(), 0.1257, 0.001);
 
477
  EXPECT_NEAR(htrks[7]->get_dsdz(), 0.1504, 0.001);
390
478
}
391
479
 
392
480
TEST_F(PatternRecognitionTest, test_make_tracks) {
393
481
 
394
482
  // Set up the spacepoints vector
395
 
  std::vector<SciFiSpacePoint*> spnts_all = set_up_spacepoints();
 
483
  std::vector<SciFiSpacePoint*> spnts_all = set_up_single_track_spacepoints();
396
484
  std::vector<SciFiSpacePoint*> spnts;
397
485
  spnts.push_back(spnts_all[4]);
398
486
  spnts.push_back(spnts_all[1]);
517
605
TEST_F(PatternRecognitionTest, test_make_4pt_tracks) {
518
606
 
519
607
  // Set up the spacepoints vector
520
 
  std::vector<SciFiSpacePoint*> spnts_all = set_up_spacepoints();
 
608
  std::vector<SciFiSpacePoint*> spnts_all = set_up_single_track_spacepoints();
521
609
  std::vector<SciFiSpacePoint*> spnts;
522
610
  spnts.push_back(spnts_all[4]);
523
611
  spnts.push_back(spnts_all[2]);
617
705
TEST_F(PatternRecognitionTest, test_make_3pt_tracks) {
618
706
 
619
707
  // Set up the spacepoints vector
620
 
  std::vector<SciFiSpacePoint*> spnts_all = set_up_spacepoints();
 
708
  std::vector<SciFiSpacePoint*> spnts_all = set_up_single_track_spacepoints();
621
709
  std::vector<SciFiSpacePoint*> spnts;
622
710
  spnts.push_back(spnts_all[4]);
623
711
  spnts.push_back(spnts_all[1]);
737
825
  }
738
826
}
739
827
 
740
 
TEST_F(PatternRecognitionTest, test_make_straight_tracks) {
741
 
 
742
 
  int n_stations = 5;
743
 
  int tracker_num = 0;
744
 
  PatternRecognition pr;
745
 
  pr.set_parameters_to_default();
746
 
 
747
 
  // Set up the spacepoints vector
748
 
  std::vector<SciFiSpacePoint*> spnts = set_up_spacepoints();
 
828
TEST_F(PatternRecognitionTest, test_make_straight_tracks_lsq) {
 
829
 
 
830
  int n_stations = 5;
 
831
  int tracker_num = 0;
 
832
  PatternRecognition pr;
 
833
  pr.set_parameters_to_default();
 
834
  pr.set_line_fitter(0);
 
835
 
 
836
  // Set up the spacepoints vector
 
837
  std::vector<SciFiSpacePoint*> spnts = set_up_single_track_spacepoints();
 
838
 
 
839
  // Set up the spacepoints by station 2D vector
 
840
  std::vector< std::vector<SciFiSpacePoint*> > spnts_by_station(n_stations);
 
841
  SciFiTools::sort_by_station(spnts, spnts_by_station);
 
842
 
 
843
  // Check the spacepoints have setup correctly
 
844
  EXPECT_EQ(spnts[0], spnts_by_station[0][0]);
 
845
  EXPECT_EQ(spnts[1], spnts_by_station[1][0]);
 
846
  EXPECT_EQ(spnts[2], spnts_by_station[2][0]);
 
847
  EXPECT_EQ(spnts[3], spnts_by_station[3][0]);
 
848
  EXPECT_EQ(spnts[4], spnts_by_station[4][0]);
 
849
  EXPECT_EQ(-68.24883333333334, spnts_by_station[0][0]->get_position().x());
 
850
 
 
851
  std::vector<int> ignore_stations;
 
852
  std::vector<SciFiStraightPRTrack*> strks;
 
853
 
 
854
  // The track parameters that should be reconstructed from the spacepoints
 
855
  int num_points = 5;
 
856
  double x_chisq = 22.87148204;
 
857
  double y_chisq = 20.99052559;
 
858
  double y0 = -58.85201389;
 
859
  double x0 = -68.94108927;
 
860
  double my = 0.03755825;
 
861
  double mx = -0.02902014;
 
862
 
 
863
  // Make the track from the spacepoints
 
864
  pr.make_straight_tracks(num_points, tracker_num, ignore_stations, spnts_by_station, strks);
 
865
 
 
866
  // Check it matches to within a tolerance epsilon
 
867
  double epsilon = 0.000001;
 
868
  EXPECT_EQ(1u, strks.size());
 
869
  EXPECT_NEAR(x0, strks[0]->get_x0(), epsilon);
 
870
  EXPECT_NEAR(mx, strks[0]->get_mx(), epsilon);
 
871
  EXPECT_NEAR(x_chisq, strks[0]->get_x_chisq(), epsilon);
 
872
  EXPECT_NEAR(y0, strks[0]->get_y0(), epsilon);
 
873
  EXPECT_NEAR(my, strks[0]->get_my(), epsilon);
 
874
  EXPECT_NEAR(y_chisq, strks[0]->get_y_chisq(), epsilon);
 
875
 
 
876
  // Tidy up
 
877
  std::vector<SciFiSpacePoint*>::iterator it;
 
878
  for (it = spnts.begin(); it != spnts.end(); ++it) {
 
879
    delete (*it);
 
880
  }
 
881
  std::vector<SciFiStraightPRTrack*>::iterator strack;
 
882
  for (strack = strks.begin(); strack != strks.end(); ++strack) {
 
883
    delete (*strack);
 
884
  }
 
885
}
 
886
 
 
887
TEST_F(PatternRecognitionTest, test_make_straight_tracks_rootfit) {
 
888
 
 
889
  int n_stations = 5;
 
890
  int tracker_num = 0;
 
891
  PatternRecognition pr;
 
892
  pr.set_parameters_to_default();
 
893
  pr.set_line_fitter(1);
 
894
 
 
895
  // Set up the spacepoints vector
 
896
  std::vector<SciFiSpacePoint*> spnts = set_up_single_track_spacepoints();
749
897
 
750
898
  // Set up the spacepoints by station 2D vector
751
899
  std::vector< std::vector<SciFiSpacePoint*> > spnts_by_station(n_stations);
1212
1360
 
1213
1361
  PatternRecognition* pr = new PatternRecognition();
1214
1362
  pr->set_parameters_to_default();
1215
 
  pr->setup_debug();
 
1363
  pr->setup_debug("test.root");
1216
1364
 
1217
1365
  EXPECT_TRUE(pr->_debug);
1218
1366
  EXPECT_TRUE(pr->_rfile);
1219
 
  EXPECT_TRUE(pr->_hx);
1220
 
  EXPECT_TRUE(pr->_hy);
1221
 
  EXPECT_TRUE(pr->_hxchisq);
1222
 
  EXPECT_TRUE(pr->_hychisq);
 
1367
  EXPECT_TRUE(pr->_hx_line);
 
1368
  EXPECT_TRUE(pr->_hy_line);
 
1369
  EXPECT_TRUE(pr->_hxchisq_line);
 
1370
  EXPECT_TRUE(pr->_hychisq_line);
 
1371
  EXPECT_TRUE(pr->_fail_helix_tku);
 
1372
  EXPECT_TRUE(pr->_fail_helix_tkd);
1223
1373
 
1224
1374
  delete pr;
1225
1375
}