← Back to branch summary

~mwinter4/maus/ckov_0_9_3

« back to all changes in this revision

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

Merged from trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/cpp_unit/Recon/SciFi/PatternRecognitionTest.cc
19
19
 
20
20
#include "gtest/gtest.h"
21
21
 
 
22
#include "src/common_cpp/Recon/SciFi/SciFiTools.hh"
22
23
#include "src/common_cpp/Recon/SciFi/PatternRecognition.hh"
23
 
#include "src/common_cpp/Recon/SciFi/LSQFit.hh"
 
24
#include "src/common_cpp/Recon/SciFi/LeastSquaresFitter.hh"
24
25
#include "src/common_cpp/DataStructure/SciFiSpacePoint.hh"
25
26
#include "src/common_cpp/DataStructure/SciFiStraightPRTrack.hh"
26
27
#include "src/common_cpp/DataStructure/SciFiEvent.hh"
159
160
 
160
161
  // evt descoping will delete the spacepoints
161
162
}
 
163
*/
162
164
 
163
165
TEST_F(PatternRecognitionTest, test_multiple_evts_per_trigger) {
164
166
 
172
174
    spnts_t1_trk1[i]->set_station(5-i);
173
175
    spnts_t1_trk1[i]->set_used(false);
174
176
  }
175
 
 
176
177
  std::vector<SciFiSpacePoint*> spnts_t1_trk2;
177
178
  for ( size_t i = 0; i < 5; ++i ) {
178
179
    spnts_t1_trk2.push_back(new SciFiSpacePoint());
180
181
    spnts_t1_trk2[i]->set_station(5-i);
181
182
    spnts_t1_trk2[i]->set_used(false);
182
183
  }
 
184
  std::vector<SciFiSpacePoint*> spnts_t1_trk3;
 
185
  for ( size_t i = 0; i < 5; ++i ) {
 
186
    spnts_t1_trk3.push_back(new SciFiSpacePoint());
 
187
    spnts_t1_trk3[i]->set_tracker(0);
 
188
    spnts_t1_trk3[i]->set_station(5-i);
 
189
    spnts_t1_trk3[i]->set_used(false);
 
190
  }
 
191
  std::vector<SciFiSpacePoint*> spnts_t1_trk4;
 
192
  for ( size_t i = 0; i < 5; ++i ) {
 
193
    spnts_t1_trk4.push_back(new SciFiSpacePoint());
 
194
    spnts_t1_trk4[i]->set_tracker(0);
 
195
    spnts_t1_trk4[i]->set_station(5-i);
 
196
    spnts_t1_trk4[i]->set_used(false);
 
197
  }
183
198
 
184
199
  std::vector<SciFiSpacePoint*> spnts_t2_trk1;
185
200
  for ( size_t i = 0; i < 5; ++i ) {
188
203
    spnts_t2_trk1[i]->set_station(i+1);
189
204
    spnts_t2_trk1[i]->set_used(false);
190
205
  }
191
 
 
192
206
  std::vector<SciFiSpacePoint*> spnts_t2_trk2;
193
207
  for ( size_t i = 0; i < 5; ++i ) {
194
208
    spnts_t2_trk2.push_back(new SciFiSpacePoint());
196
210
    spnts_t2_trk2[i]->set_station(i+1);
197
211
    spnts_t2_trk2[i]->set_used(false);
198
212
  }
199
 
 
200
 
  spnts_t1_trk1[0]->set_position(ThreeVector(10.46, -13.81, 1100.41));
201
 
  spnts_t1_trk1[1]->set_position(ThreeVector(5.48, -23.30, 750.48));
202
 
  spnts_t1_trk1[2]->set_position(ThreeVector(0.50, -14.67, 450.48));
203
 
  spnts_t1_trk1[3]->set_position(ThreeVector(8.47, -11.22, 200.62));
204
 
  spnts_t1_trk1[4]->set_position(ThreeVector(12.70, -14.24, 0.65));
205
 
 
206
 
  spnts_t1_trk2[0]->set_position(ThreeVector(0.50, 31.06, 1100.41));
207
 
  spnts_t1_trk2[1]->set_position(ThreeVector(9.96, 0.00, 750.48));
208
 
  spnts_t1_trk2[2]->set_position(ThreeVector(-20.42, 6.04, 450.48));
209
 
  spnts_t1_trk2[3]->set_position(ThreeVector(-10.96, 29.34, 200.62));
210
 
  spnts_t1_trk2[4]->set_position(ThreeVector(9.47, 23.30, 0.65));
211
 
 
212
 
  spnts_t2_trk1[0]->set_position(ThreeVector(-18.93, 1.73, 0.65));
213
 
  spnts_t2_trk1[1]->set_position(ThreeVector(0.75, 9.92, 200.65));
214
 
  spnts_t2_trk1[2]->set_position(ThreeVector(14.45, -12.94, 450.65));
215
 
  spnts_t2_trk1[3]->set_position(ThreeVector(-13.95, -24.16, 750.65));
216
 
  spnts_t2_trk1[4]->set_position(ThreeVector(-9.47, 7.77, 1100.65));
217
 
 
218
 
  spnts_t2_trk2[0]->set_position(ThreeVector(6.73, -22.00, 0.65));
219
 
  spnts_t2_trk2[1]->set_position(ThreeVector(-9.96, -24.16, 200.65));
220
 
  spnts_t2_trk2[2]->set_position(ThreeVector(-13.95, -6.90, 450.65));
221
 
  spnts_t2_trk2[3]->set_position(ThreeVector(5.98, -4.31, 750.65));
222
 
  spnts_t2_trk2[4]->set_position(ThreeVector(-3.74, -23.73, 1100.65));
 
213
  std::vector<SciFiSpacePoint*> spnts_t2_trk3;
 
214
  for ( size_t i = 0; i < 5; ++i ) {
 
215
    spnts_t2_trk3.push_back(new SciFiSpacePoint());
 
216
    spnts_t2_trk3[i]->set_tracker(1);
 
217
    spnts_t2_trk3[i]->set_station(i+1);
 
218
    spnts_t2_trk3[i]->set_used(false);
 
219
  }
 
220
  std::vector<SciFiSpacePoint*> spnts_t2_trk4;
 
221
  for ( size_t i = 0; i < 5; ++i ) {
 
222
    spnts_t2_trk4.push_back(new SciFiSpacePoint());
 
223
    spnts_t2_trk4[i]->set_tracker(1);
 
224
    spnts_t2_trk4[i]->set_station(i+1);
 
225
    spnts_t2_trk4[i]->set_used(false);
 
226
  }
 
227
 
 
228
 
 
229
  // Spill 4, mu plus
 
230
  spnts_t1_trk1[0]->set_position(ThreeVector(0.0, 66.44, 1100.0));
 
231
  spnts_t1_trk1[1]->set_position(ThreeVector(-26.4, 47.46, 750.5));
 
232
  spnts_t1_trk1[2]->set_position(ThreeVector(-2.491, 28.47, 450.5));
 
233
  spnts_t1_trk1[3]->set_position(ThreeVector(14.45, 49.18, 200.6));
 
234
  spnts_t1_trk1[4]->set_position(ThreeVector(1.993, 69.03, 0.6523));
 
235
 
 
236
  spnts_t2_trk1[0]->set_position(ThreeVector(-26.4, 56.09, 0.6523));
 
237
  spnts_t2_trk1[1]->set_position(ThreeVector(-25.9, -1.726, 200.7));
 
238
  spnts_t2_trk1[2]->set_position(ThreeVector(43.84, -17.26, 450.7));
 
239
  spnts_t2_trk1[3]->set_position(ThreeVector(57.79, 63.85, 750.7));
 
240
  spnts_t2_trk1[4]->set_position(ThreeVector(-32.38, 47.46, 1101));
 
241
 
 
242
  // Spill 5, mu plus
 
243
  spnts_t1_trk2[0]->set_position(ThreeVector(-16.44, 15.53, 1100.0));
 
244
  spnts_t1_trk2[1]->set_position(ThreeVector(-19.93, 10.35, 750.5 ));
 
245
  spnts_t1_trk2[2]->set_position(ThreeVector(-15.44, 9.491, 450.5));
 
246
  spnts_t1_trk2[3]->set_position(ThreeVector(-15.44, 12.94, 200.6));
 
247
  spnts_t1_trk2[4]->set_position(ThreeVector(-18.93, 13.81, 0.6523));
 
248
 
 
249
  spnts_t2_trk2[0]->set_position(ThreeVector(-4.982, 15.53, 0.6523));
 
250
  spnts_t2_trk2[1]->set_position(ThreeVector(-12.7, -5.609, 200.7));
 
251
  spnts_t2_trk2[2]->set_position(ThreeVector(10.71, -20.28, 450.7));
 
252
  spnts_t2_trk2[3]->set_position(ThreeVector(23.41, 9.491, 750.7));
 
253
  spnts_t2_trk2[4]->set_position(ThreeVector(-12.95, 5.177, 1101 ));
 
254
 
 
255
  // Spill 6, mu plus
 
256
  spnts_t1_trk3[0]->set_position(ThreeVector(-50.81, -23.3,  1100));
 
257
  spnts_t1_trk3[1]->set_position(ThreeVector(33.88,  8.628,  750.5));
 
258
  spnts_t1_trk3[2]->set_position(ThreeVector(-41.35, 44.01,  450.5));
 
259
  spnts_t1_trk3[3]->set_position(ThreeVector(-43.84, -31.06, 200.6));
 
260
  spnts_t1_trk3[4]->set_position(ThreeVector(18.93,  -27.61, 0.6523 ));
 
261
 
 
262
  spnts_t2_trk3[0]->set_position(ThreeVector(-3.487, 47.46,  0.6523 ));
 
263
  spnts_t2_trk3[1]->set_position(ThreeVector(13.95,  24.16,  200.7));
 
264
  spnts_t2_trk3[2]->set_position(ThreeVector(40.85,  44.87,  450.7));
 
265
  spnts_t2_trk3[3]->set_position(ThreeVector(8.469,  61.26,  750.7 ));
 
266
  spnts_t2_trk3[4]->set_position(ThreeVector(18.43,  26.75,  1101 ));
 
267
 
 
268
  // Spill 2, mu minus
 
269
  spnts_t1_trk4[0]->set_position(ThreeVector(-0.4982, 31.06, 1100));
 
270
  spnts_t1_trk4[1]->set_position(ThreeVector(-9.465, -0.8628, 750.5));
 
271
  spnts_t1_trk4[2]->set_position(ThreeVector(20.42, 4.314, 450.5));
 
272
  spnts_t1_trk4[3]->set_position(ThreeVector(11.46, 30.2, 200.6));
 
273
  spnts_t1_trk4[4]->set_position(ThreeVector(-9.465, 25.02, 0.6523));
 
274
 
 
275
  spnts_t2_trk4[0]->set_position(ThreeVector(-2.491, -19.85, 0.6523));
 
276
  spnts_t2_trk4[1]->set_position(ThreeVector(12.95, -24.16, 200.7));
 
277
  spnts_t2_trk4[2]->set_position(ThreeVector(18.93, -6.903, 450.7));
 
278
  spnts_t2_trk4[3]->set_position(ThreeVector(-2.491, -4.314, 750.7));
 
279
  spnts_t2_trk4[4]->set_position(ThreeVector(7.971, -25.89, 1101.0));
223
280
 
224
281
  std::vector<SciFiSpacePoint*> spnts(spnts_t1_trk1);
225
282
  spnts.insert(spnts.end(), spnts_t1_trk2.begin(), spnts_t1_trk2.end());
 
283
  spnts.insert(spnts.end(), spnts_t1_trk3.begin(), spnts_t1_trk3.end());
 
284
  spnts.insert(spnts.end(), spnts_t1_trk4.begin(), spnts_t1_trk4.end());
226
285
  spnts.insert(spnts.end(), spnts_t2_trk1.begin(), spnts_t2_trk1.end());
227
286
  spnts.insert(spnts.end(), spnts_t2_trk2.begin(), spnts_t2_trk2.end());
 
287
  spnts.insert(spnts.end(), spnts_t2_trk3.begin(), spnts_t2_trk3.end());
 
288
  spnts.insert(spnts.end(), spnts_t2_trk4.begin(), spnts_t2_trk4.end());
228
289
  SciFiEvent evt1;
229
290
  evt1.set_spacepoints(spnts);
230
291
 
 
292
  // Randomise things a bit to make it harder
 
293
  SciFiSpacePoint *sp1, *sp2;
 
294
  sp1 = spnts[3];
 
295
  sp2 = spnts[14];
 
296
  spnts[3] = sp2;
 
297
  spnts[14] = sp1;
 
298
  sp1 = spnts[4];
 
299
  sp2 = spnts[17];
 
300
  spnts[4] = sp2;
 
301
  spnts[17] = sp1;
 
302
 
 
303
  // Perform the recon
231
304
  pr.process(true, false, evt1); // Helical on, Straight off
232
305
 
233
306
  std::vector<SciFiStraightPRTrack*> strks;
235
308
  strks = evt1.straightprtracks();
236
309
  htrks = evt1.helicalprtracks();
237
310
 
238
 
  ASSERT_EQ(4u, htrks.size());
 
311
  ASSERT_EQ(8u, htrks.size());
239
312
  EXPECT_EQ(0u, strks.size());
240
313
  EXPECT_EQ(5, htrks[0]->get_num_points());
241
314
  EXPECT_EQ(5, htrks[1]->get_num_points());
242
315
  EXPECT_EQ(5, htrks[2]->get_num_points());
243
316
  EXPECT_EQ(5, htrks[3]->get_num_points());
244
 
  EXPECT_NEAR(0.03771, htrks[0]->get_dsdz(), 0.001);
245
 
  EXPECT_NEAR(0.1160, htrks[1]->get_dsdz(), 0.01);
246
 
  EXPECT_NEAR(0.1172, htrks[2]->get_dsdz(), 0.01);
247
 
  EXPECT_NEAR(0.07349, htrks[3]->get_dsdz(), 0.001);
 
317
  EXPECT_EQ(5, htrks[4]->get_num_points());
 
318
  EXPECT_EQ(5, htrks[5]->get_num_points());
 
319
  EXPECT_EQ(5, htrks[6]->get_num_points());
 
320
  EXPECT_EQ(5, htrks[7]->get_num_points());
 
321
  EXPECT_NEAR(-0.1156, htrks[0]->get_dsdz(), 0.001);
 
322
  EXPECT_NEAR(-0.01834, htrks[1]->get_dsdz(), 0.01);
 
323
  EXPECT_NEAR(-0.342, htrks[2]->get_dsdz(), 0.01);
 
324
  EXPECT_NEAR(-0.1178, htrks[3]->get_dsdz(), 0.01);
 
325
  EXPECT_NEAR(0.3126, htrks[4]->get_dsdz(), 0.001);
 
326
  EXPECT_NEAR(0.1257, htrks[5]->get_dsdz(), 0.001);
 
327
  EXPECT_NEAR(0.1504, htrks[6]->get_dsdz(), 0.001);
 
328
  EXPECT_NEAR(0.08396, htrks[7]->get_dsdz(), 0.001);
248
329
 
249
330
  // evt descoping will delete the spacepoints
250
331
}
251
 
*/
252
332
 
253
333
TEST_F(PatternRecognitionTest, test_make_tracks) {
254
334
 
264
344
 
265
345
  // Set up the spacepoints by station 2D vector
266
346
  std::vector< std::vector<SciFiSpacePoint*> > spnts_by_station(n_stations);
267
 
  pr.sort_by_station(spnts, spnts_by_station);
 
347
  SciFiTools::sort_by_station(spnts, spnts_by_station);
268
348
 
269
349
  SciFiEvent evt;
270
350
  bool track_type = 0; // Straight tracks
315
395
  spnts_by_station.clear();
316
396
  spnts_by_station.resize(0);
317
397
  spnts_by_station.resize(n_stations);
318
 
  pr.sort_by_station(spnts, spnts_by_station);
 
398
  SciFiTools::sort_by_station(spnts, spnts_by_station);
319
399
  strks.resize(0);
320
400
  evt.set_straightprtrack(strks);
321
401
  pr.make_all_tracks(track_type, tracker_num, spnts_by_station, evt);
350
430
  spnts_by_station.clear();
351
431
  spnts_by_station.resize(0);
352
432
  spnts_by_station.resize(n_stations);
353
 
  pr.sort_by_station(spnts, spnts_by_station);
 
433
  SciFiTools::sort_by_station(spnts, spnts_by_station);
354
434
  strks.resize(0);
355
435
  evt.set_straightprtrack(strks);
356
436
  pr.make_all_tracks(track_type, tracker_num, spnts_by_station, evt);
389
469
 
390
470
  // Set up the spacepoints by station 2D vector
391
471
  std::vector< std::vector<SciFiSpacePoint*> > spnts_by_station(n_stations);
392
 
  pr.sort_by_station(spnts, spnts_by_station);
 
472
  SciFiTools::sort_by_station(spnts, spnts_by_station);
393
473
 
394
474
  bool track_type = 0; // Straight tracks
395
475
 
413
493
  spnts_by_station.clear();
414
494
  spnts_by_station.resize(0);
415
495
  spnts_by_station.resize(n_stations);
416
 
  pr.sort_by_station(spnts, spnts_by_station);
 
496
  SciFiTools::sort_by_station(spnts, spnts_by_station);
417
497
  strks.resize(0);
418
498
 
419
499
  pr.make_4tracks(track_type, tracker_num, spnts_by_station, strks, htrks);
439
519
  spnts_by_station.clear();
440
520
  spnts_by_station.resize(0);
441
521
  spnts_by_station.resize(n_stations);
442
 
  pr.sort_by_station(spnts, spnts_by_station);
 
522
  SciFiTools::sort_by_station(spnts, spnts_by_station);
443
523
 
444
524
  std::vector<SciFiStraightPRTrack*>::iterator strack;
445
525
  for (strack = strks.begin(); strack != strks.end(); ++strack) {
487
567
 
488
568
  // Set up the spacepoints by station 2D vector
489
569
  std::vector< std::vector<SciFiSpacePoint*> > spnts_by_station(n_stations);
490
 
  pr.sort_by_station(spnts, spnts_by_station);
 
570
  SciFiTools::sort_by_station(spnts, spnts_by_station);
491
571
 
492
572
  // The track parameters that should be reconstructed from the spacepoints in 5 pt track case
493
573
  int num_points = 3;
534
614
  spnts_by_station.clear();
535
615
  spnts_by_station.resize(0);
536
616
  spnts_by_station.resize(n_stations);
537
 
  pr.sort_by_station(spnts, spnts_by_station);
 
617
  SciFiTools::sort_by_station(spnts, spnts_by_station);
538
618
  strks.resize(0);
539
619
 
540
620
  pr.make_3tracks(tracker_num, spnts_by_station, strks);
567
647
  spnts_by_station.clear();
568
648
  spnts_by_station.resize(0);
569
649
  spnts_by_station.resize(n_stations);
570
 
  pr.sort_by_station(spnts, spnts_by_station);
 
650
  SciFiTools::sort_by_station(spnts, spnts_by_station);
571
651
  strks.resize(0);
572
652
 
573
653
  pr.make_3tracks(tracker_num, spnts_by_station, strks);
606
686
 
607
687
  // Set up the spacepoints by station 2D vector
608
688
  std::vector< std::vector<SciFiSpacePoint*> > spnts_by_station(n_stations);
609
 
  pr.sort_by_station(spnts, spnts_by_station);
 
689
  SciFiTools::sort_by_station(spnts, spnts_by_station);
610
690
 
611
691
  // Check the spacepoints have setup correctly
612
692
  EXPECT_EQ(spnts[0], spnts_by_station[0][0]);
957
1037
  EXPECT_FALSE(pr.set_end_stations(ignore_stations, outer_st_num, inner_st_num));
958
1038
}
959
1039
 
960
 
TEST_F(PatternRecognitionTest, test_sort_by_station) {
961
 
 
962
 
  PatternRecognition pr;
963
 
 
964
 
  SciFiSpacePoint *sp1 = new SciFiSpacePoint();
965
 
  SciFiSpacePoint *sp2 = new SciFiSpacePoint();
966
 
  SciFiSpacePoint *sp3 = new SciFiSpacePoint();
967
 
  SciFiSpacePoint *sp4 = new SciFiSpacePoint();
968
 
  SciFiSpacePoint *sp5 = new SciFiSpacePoint();
969
 
 
970
 
  sp1->set_station(1);
971
 
  sp2->set_station(2);
972
 
  sp3->set_station(3);
973
 
  sp4->set_station(4);
974
 
  sp5->set_station(5);
975
 
 
976
 
  std::vector<SciFiSpacePoint*> spnts;
977
 
  spnts.push_back(sp5);
978
 
  spnts.push_back(sp2);
979
 
  spnts.push_back(sp3);
980
 
  spnts.push_back(sp1);
981
 
  spnts.push_back(sp4);
982
 
 
983
 
  std::vector< std::vector<SciFiSpacePoint*> > spnts_by_station(5);
984
 
  pr.sort_by_station(spnts, spnts_by_station);
985
 
  EXPECT_EQ(sp1, spnts_by_station[0][0]);
986
 
  EXPECT_EQ(sp2, spnts_by_station[1][0]);
987
 
  EXPECT_EQ(sp3, spnts_by_station[2][0]);
988
 
  EXPECT_EQ(sp4, spnts_by_station[3][0]);
989
 
  EXPECT_EQ(sp5, spnts_by_station[4][0]);
990
 
 
991
 
  delete sp1;
992
 
  delete sp2;
993
 
  delete sp3;
994
 
  delete sp4;
995
 
  delete sp5;
996
 
}
997
 
 
998
 
TEST_F(PatternRecognitionTest, test_stations_with_unused_sp) {
999
 
 
1000
 
  // Set up spacepoints, leaving station 3 empty to check function copes with an empty station
1001
 
  SciFiSpacePoint *sp1 = new SciFiSpacePoint();
1002
 
  SciFiSpacePoint *sp2 = new SciFiSpacePoint();
1003
 
  // SciFiSpacePoint *sp3 = new SciFiSpacePoint();
1004
 
  SciFiSpacePoint *sp4 = new SciFiSpacePoint();
1005
 
  SciFiSpacePoint *sp4_1 = new SciFiSpacePoint();
1006
 
  SciFiSpacePoint *sp5 = new SciFiSpacePoint();
1007
 
 
1008
 
  sp1->set_station(1);
1009
 
  sp2->set_station(2);
1010
 
  // sp3->set_station(3);
1011
 
  sp4->set_station(4);
1012
 
  sp4_1->set_station(4);
1013
 
  sp5->set_station(5);
1014
 
 
1015
 
  sp1->set_used(true);
1016
 
  sp2->set_used(true);
1017
 
  // sp3->set_used(true);
1018
 
  sp4->set_used(false);
1019
 
  sp4_1->set_used(true);
1020
 
  sp5->set_used(false);
1021
 
 
1022
 
  std::vector<SciFiSpacePoint*> spnts;
1023
 
  spnts.push_back(sp5);
1024
 
  spnts.push_back(sp2);
1025
 
  // spnts.push_back(sp3);
1026
 
  spnts.push_back(sp1);
1027
 
  spnts.push_back(sp4);
1028
 
  spnts.push_back(sp4_1);
1029
 
 
1030
 
  SpacePoint2dPArray spnts_by_station(5);
1031
 
 
1032
 
  PatternRecognition pr;
1033
 
  pr.sort_by_station(spnts, spnts_by_station);
1034
 
  ASSERT_EQ(5u, spnts_by_station.size());
1035
 
  ASSERT_EQ(1u, spnts_by_station[0].size());
1036
 
  ASSERT_EQ(1u, spnts_by_station[1].size());
1037
 
  ASSERT_EQ(2u, spnts_by_station[3].size());
1038
 
  ASSERT_EQ(1u, spnts_by_station[4].size());
1039
 
 
1040
 
  std::vector<int> stations_hit, stations_not_hit;
1041
 
  pr.stations_with_unused_spnts(spnts_by_station, stations_hit, stations_not_hit);
1042
 
 
1043
 
  ASSERT_EQ(2u, stations_hit.size());
1044
 
  ASSERT_EQ(3u, stations_not_hit.size());
1045
 
  EXPECT_EQ(3, stations_hit[0]);
1046
 
  EXPECT_EQ(4, stations_hit[1]);
1047
 
  EXPECT_EQ(0, stations_not_hit[0]);
1048
 
  EXPECT_EQ(1, stations_not_hit[1]);
1049
 
  EXPECT_EQ(2, stations_not_hit[2]);
1050
 
 
1051
 
  int stats_with_unused = pr.num_stations_with_unused_spnts(spnts_by_station);
1052
 
  EXPECT_EQ(2, stats_with_unused);
1053
 
 
1054
 
  delete sp1;
1055
 
  delete sp2;
1056
 
  delete sp4;
1057
 
  delete sp4_1;
1058
 
  delete sp5;
1059
 
}
1060
 
 
1061
1040
TEST_F(PatternRecognitionTest, test_find_dsdz) {
1062
1041
 
1063
1042
  PatternRecognition pr;
1099
1078
  spnts.push_back(sp4);
1100
1079
  spnts.push_back(sp5);
1101
1080
 
1102
 
  LSQFit lsq(0.3844, 0.4298, 150.0);
 
1081
  LeastSquaresFitter lsq(0.3844, 0.4298, 150.0);
1103
1082
  SimpleCircle circle;
1104
1083
  bool good_radius = lsq.circle_fit(spnts, circle);
1105
1084
 
1114
1093
  SimpleLine line_sz;
1115
1094
  std::vector<double> dphi;
1116
1095
  int n_points = 5;
1117
 
 
1118
 
  pr.find_dsdz(n_points, spnts, circle, dphi, line_sz);
1119
 
 
 
1096
  int charge = 0;
 
1097
 
 
1098
  pr.find_dsdz(n_points, spnts, circle, dphi, line_sz, charge);
 
1099
 
 
1100
  ASSERT_EQ(charge, 1);
1120
1101
  EXPECT_NEAR(line_sz.get_c(), 15.47, epsilon);
1121
1102
  EXPECT_NEAR(line_sz.get_m(), 0.126, epsilon);
1122
1103
  EXPECT_NEAR(line_sz.get_chisq(), 1.005 , epsilon);
1128
1109
  delete sp5;
1129
1110
}
1130
1111
 
1131
 
TEST_F(PatternRecognitionTest, test_make_3pt_circle) {
 
1112
TEST_F(PatternRecognitionTest, test_find_n_turns) {
1132
1113
 
1133
1114
  PatternRecognition pr;
1134
1115
 
1135
 
  SciFiSpacePoint *sp1 = new SciFiSpacePoint();
1136
 
  SciFiSpacePoint *sp2 = new SciFiSpacePoint();
1137
 
  SciFiSpacePoint *sp3 = new SciFiSpacePoint();
1138
 
 
1139
 
  // Set up spacepoints corresponding to circle of radius 2 mm, centred at (1,2)
1140
 
  ThreeVector pos(1.0, 4.0, 0.0);
1141
 
  sp1->set_position(pos);
1142
 
  pos.set(3.0, 2.0, 0.0);
1143
 
  sp2->set_position(pos);
1144
 
  pos.set(1.0, 0.0, 0.0);
1145
 
  sp3->set_position(pos);
1146
 
 
1147
 
  SimpleCircle c = pr.make_3pt_circle(sp1, sp2, sp3);
1148
 
 
1149
 
  double x0 = 1.0;
1150
 
  double y0 = 2.0;
1151
 
  double R = 2.0;
 
1116
  // T1 positives
 
1117
  double arr_z[] = {1100.41, 750.48, 450.48, 200.617, 0.6523};
 
1118
  std::vector<double> z(arr_z, arr_z + sizeof(arr_z) / sizeof(double));
 
1119
  double arr_phi[] = {1.80696, 3.93027, 5.81611, 1.16642, 2.39529};
 
1120
  std::vector<double> phi(arr_phi, arr_phi + sizeof(arr_phi) / sizeof(double));
 
1121
  std::vector<double> true_phi;
 
1122
  int charge = 0;
 
1123
  pr.find_n_turns(z, phi, true_phi, charge);
1152
1124
  double epsilon = 0.01;
1153
 
 
1154
 
  EXPECT_NEAR(c.get_x0(), x0, epsilon);
1155
 
  EXPECT_NEAR(c.get_y0(), y0, epsilon);
1156
 
  EXPECT_NEAR(c.get_R(), R, epsilon);
1157
 
 
1158
 
  // Now check for a circle of radius 2mm, centred at (0,0) (involves singular matrices)
1159
 
  pos.set(0.0, 2.0, 0.0);
1160
 
  sp1->set_position(pos);
1161
 
  pos.set(2.0, 0.0, 0.0);
1162
 
  sp2->set_position(pos);
1163
 
  pos.set(0.0, -2.0, 0.0);
1164
 
  sp3->set_position(pos);
1165
 
 
1166
 
  c = pr.make_3pt_circle(sp1, sp2, sp3);
1167
 
 
1168
 
  x0 = 0.0;
1169
 
  y0 = 0.0;
1170
 
  R = 2.0;
1171
 
  epsilon = 0.01;
1172
 
 
1173
 
  EXPECT_NEAR(c.get_x0(), x0, epsilon);
1174
 
  EXPECT_NEAR(c.get_y0(), y0, epsilon);
1175
 
  EXPECT_NEAR(c.get_R(), R, epsilon);
1176
 
 
1177
 
  delete sp1;
1178
 
  delete sp2;
1179
 
  delete sp3;
 
1125
  ASSERT_EQ(charge, 1);
 
1126
  ASSERT_EQ(true_phi.size(), 5);
 
1127
  EXPECT_NEAR(true_phi[0], 1.80696, epsilon);
 
1128
  EXPECT_NEAR(true_phi[1], 3.93027, epsilon);
 
1129
  EXPECT_NEAR(true_phi[2], 5.81611, epsilon);
 
1130
  EXPECT_NEAR(true_phi[3], 7.44961, epsilon);
 
1131
  EXPECT_NEAR(true_phi[4], 8.67847, epsilon);
1180
1132
}
1181
1133
 
1182
1134
} // ~namespace MAUS