All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
TrackTrajectory_test.cc
Go to the documentation of this file.
1 /**
2  * @file TrackTrajectory_test.cc
3  * @brief Simple test on a recob::TrackTrajectory object
4  * @author Gianluca Petrillo (petrillo@fnal.gov)
5  * @date January 3, 2016
6  * @version 1.0
7  *
8  * This test simply creates recob::TrackTrajectory objects and verifies that the
9  * values it can access are the right ones.
10  *
11  * See http://www.boost.org/libs/test for the Boost test library home page.
12  *
13  */
14 
15 
16 // Boost libraries
17 /*
18  * Boost: define the name of the module;
19  * and do that before the inclusion of Boost unit test headers
20  * because it will change what they provide.
21  * Among the those, there is a main() function and some wrapping catching
22  * unhandled exceptions and considering them test failures, and probably more.
23  * This also makes fairly complicate to receive parameters from the command line
24  * (for example, a random seed).
25  */
26 #define BOOST_TEST_MODULE ( tracktrajectory_test )
27 #include "boost/test/unit_test.hpp"
28 
29 
30 // LArSoft libraries
31 #include "lardataobj/RecoBase/TrackTrajectory.h"
32 #include "lardataobj/RecoBase/TrajectoryPointFlags.h"
33 #include "larcoreobj/SimpleTypesAndConstants/PhysicalConstants.h" // util::pi()
34 
35 // ROOT libraries (for the legacy interface)
36 #include "TVector3.h"
37 #include "TMatrixD.h"
38 
39 // C/C++ standard libraries
40 #include <set>
41 #include <iterator> // std::prev(), std::next()
42 #include <algorithm> // std::equal(), std::accumulate()
43 #include <tuple> // std::tie()
44 #include <iostream>
45 
46 
47 //------------------------------------------------------------------------------
48 //--- Test code
49 //
50 struct Expected_t {
51 
52  recob::TrackTrajectory::Positions_t positions;
53  recob::TrackTrajectory::Momenta_t momenta;
54  recob::TrackTrajectory::Flags_t flags;
55  bool hasMomenta;
56  double length;
57  double theta;
58  double phi;
59  double zenith;
60  double azimuth;
61 
62 }; // struct Expected_t
63 
64 template <typename T>
65 void CheckValue(T v, T exp, T tol, std::string tag = "") {
66  if (!tag.empty()) BOOST_TEST_MESSAGE(tag);
67  if (std::abs(exp) < (tol / 100.)) BOOST_CHECK_SMALL(v, tol);
68  else BOOST_CHECK_CLOSE(v, exp, tol);
69 } // CheckValue()
70 
71 template <typename VectA, typename VectB>
72 void CheckVectorsEqual(VectA const& v, VectB const& exp) {
73  BOOST_TEST(v.X() == exp.X());
74  BOOST_TEST(v.Y() == exp.Y());
75  BOOST_TEST(v.Z() == exp.Z());
76 } // CheckVectorsEqual()
77 
78 template <typename VectA, typename VectB>
79 void CheckVectorsClose(VectA const& v, VectB const& exp, double tol = 0.01) {
80  CheckValue(v.X(), exp.X(), tol, " X()");
81  CheckValue(v.Y(), exp.Y(), tol, " Y()");
82  CheckValue(v.Z(), exp.Z(), tol, " Z()");
83 } // CheckVectorsClose()
84 
85 
86 recob::TrackTrajectory::Rotation_t makeRotationMatrix(TMatrixD const& Tm) {
87  recob::TrackTrajectory::Rotation_t m;
88  m.SetRotationMatrix(Tm);
89  return m;
90 } // makeRotationMatrix()
91 
92 
93 void TestTrackTrajectory(
94  recob::TrackTrajectory const& traj,
95  Expected_t const& expected
96  )
97 {
98 
99  //----------------------------------------------------------------------------
100  const size_t NPoints = expected.positions.size();
101  BOOST_TEST(traj.NPoints() == NPoints);
102  BOOST_TEST(traj.NumberTrajectoryPoints() == NPoints);
103 
104  for (size_t i = 0; i <= NPoints + 1; ++i) {
105  BOOST_TEST_MESSAGE("HasPoint() position #" << i);
106  BOOST_TEST(traj.HasPoint(i) == (i < NPoints));
107  } // for
108 
109  if (NPoints == 0) return; // nothing else is defined
110 
111  BOOST_TEST(traj.HasMomentum() == expected.hasMomenta);
112 
113  //----------------------------------------------------------------------------
114  // some preparation:
115  std::set<size_t> validPoints;
116  for (size_t i = 0; i < NPoints; ++i) {
117  if (expected.flags[i].isSet(recob::TrackTrajectory::flag::NoPoint))
118  continue;
119  validPoints.insert(i);
120  } // for
121  std::size_t const firstValidPoint = validPoints.empty()
122  ? recob::TrackTrajectory::InvalidIndex: *(validPoints.begin());
123  std::size_t const lastValidPoint = validPoints.empty()
124  ? recob::TrackTrajectory::InvalidIndex: *(validPoints.rbegin());
125 
126  //----------------------------------------------------------------------------
127  BOOST_TEST(traj.LastPoint() == NPoints - 1);
128 
129  //----------------------------------------------------------------------------
130  for (size_t i = 0; i < NPoints; ++i) {
131 
132  bool const isValid = (validPoints.count(i) > 0);
133  BOOST_TEST_MESSAGE("HasValidPoint() position #" << i);
134  BOOST_TEST(traj.HasValidPoint(i) == isValid);
135 
136  if (isValid) {
137  BOOST_TEST(traj.NextValidPoint(i) == i);
138  BOOST_TEST(traj.PreviousValidPoint(i) == i);
139  }
140  else { // if not a valid point
141  constexpr auto InvalidIndex = recob::TrackTrajectory::InvalidIndex;
142  auto iNext = validPoints.upper_bound(i);
143  if (iNext == validPoints.end()) { // after last valid point
144  BOOST_TEST(traj.PreviousValidPoint(i) == lastValidPoint);
145  BOOST_TEST(traj.NextValidPoint(i) == InvalidIndex);
146  }
147  else if (iNext == validPoints.begin()) { // before first valid point
148  BOOST_TEST(traj.PreviousValidPoint(i) == InvalidIndex);
149  BOOST_TEST(traj.NextValidPoint(i) == firstValidPoint);
150  }
151  else { // in the middle of the trajectory
152  BOOST_TEST(traj.PreviousValidPoint(i) == *(std::prev(iNext)));
153  BOOST_TEST(traj.NextValidPoint(i) == *iNext);
154  }
155  }
156 
157  } // for
158 
159  if (!validPoints.empty()) {
160  BOOST_TEST(traj.FirstValidPoint() == firstValidPoint);
161  BOOST_TEST(traj.LastValidPoint() == lastValidPoint);
162  }
163 
164  BOOST_TEST(traj.CountValidPoints() == validPoints.size());
165 
166  //----------------------------------------------------------------------------
167  BOOST_TEST_MESSAGE("Vertex()");
168  CheckVectorsEqual(traj.Vertex(), expected.positions[firstValidPoint]);
169 
170  BOOST_TEST_MESSAGE("Start()");
171  CheckVectorsEqual(traj.Start(), expected.positions[firstValidPoint]);
172 
173  BOOST_TEST_MESSAGE("End()");
174  CheckVectorsEqual(traj.End(), expected.positions[lastValidPoint]);
175 
176  //----------------------------------------------------------------------------
177  for (size_t i = 0; i < NPoints; ++i) {
178 
179  BOOST_TEST_MESSAGE("LocationAtPoint() position #" << i);
180  CheckVectorsEqual(traj.LocationAtPoint(i), expected.positions[i]);
181 
182  } // for
183 
184 
185  //----------------------------------------------------------------------------
186  TVector3 Vstart, Vend;
187  std::tie(Vstart, Vend) = traj.Extent<TVector3>();
188  BOOST_TEST(Vstart[0] == expected.positions[firstValidPoint].X());
189  BOOST_TEST(Vstart[1] == expected.positions[firstValidPoint].Y());
190  BOOST_TEST(Vstart[2] == expected.positions[firstValidPoint].Z());
191  BOOST_TEST(Vend[0] == expected.positions[lastValidPoint].X());
192  BOOST_TEST(Vend[1] == expected.positions[lastValidPoint].Y());
193  BOOST_TEST(Vend[2] == expected.positions[lastValidPoint].Z());
194 
195 
196  recob::Trajectory::Point_t start, end;
197  std::tie(start, end) = traj.Extent(); // assign both start and end
198  BOOST_TEST_MESSAGE("Extent() start");
199  CheckVectorsEqual(start, expected.positions[firstValidPoint]);
200  BOOST_TEST_MESSAGE("Extent() end");
201  CheckVectorsEqual(end, expected.positions[lastValidPoint]);
202 
203 
204  //----------------------------------------------------------------------------
205  BOOST_CHECK_CLOSE(traj.Length(), expected.length, 0.01); // 0.01%
206  if (validPoints.size() >= 2) {
207  std::size_t const secondValidPoint = *(std::next(validPoints.begin()));
208  BOOST_CHECK_CLOSE(traj.Length(firstValidPoint + 1),
209  expected.length - (
210  expected.positions[secondValidPoint]
211  - expected.positions[firstValidPoint]
212  ).R(),
213  0.01
214  );
215  } // if
216 
217 
218  //----------------------------------------------------------------------------
219  BOOST_TEST_MESSAGE("VertexDirection()");
220  CheckVectorsClose
221  (traj.VertexDirection(), expected.momenta[firstValidPoint].Unit());
222  BOOST_CHECK_CLOSE(traj.VertexDirection().Mag2(), 1.0, 0.01);
223 
224  BOOST_TEST_MESSAGE("StartDirection()");
225  CheckVectorsClose
226  (traj.StartDirection(), expected.momenta[firstValidPoint].Unit());
227  BOOST_CHECK_CLOSE(traj.StartDirection().Mag2(), 1.0, 0.01);
228 
229  BOOST_TEST_MESSAGE("EndDirection()");
230  CheckVectorsClose
231  (traj.EndDirection(), expected.momenta[lastValidPoint].Unit());
232  BOOST_CHECK_CLOSE(traj.EndDirection().Mag2(), 1.0, 0.01);
233 
234 
235  //----------------------------------------------------------------------------
236  BOOST_CHECK_CLOSE(traj.Theta(), expected.theta, 0.01);
237  BOOST_CHECK_CLOSE(traj.Phi(), expected.phi, 0.01);
238  BOOST_CHECK_CLOSE(traj.ZenithAngle(), expected.zenith, 0.01);
239  BOOST_CHECK_CLOSE(traj.AzimuthAngle(), expected.azimuth, 0.01);
240 
241 
242  //----------------------------------------------------------------------------
243 
244  BOOST_TEST_MESSAGE("VertexMomentumVector()");
245  CheckVectorsClose
246  (traj.VertexMomentumVector(), expected.momenta[firstValidPoint]);
247 
248  BOOST_TEST_MESSAGE("StartMomentumVector()");
249  CheckVectorsClose
250  (traj.StartMomentumVector(), expected.momenta[firstValidPoint]);
251 
252  BOOST_TEST_MESSAGE("EndMomentumVector()");
253  CheckVectorsClose(traj.EndMomentumVector(), expected.momenta[lastValidPoint]);
254 
255 
256  //----------------------------------------------------------------------------
257  BOOST_TEST_MESSAGE("VertexMomentum()");
258  BOOST_CHECK_CLOSE
259  (traj.VertexMomentum(), expected.momenta[firstValidPoint].R(), 0.01);
260 
261  BOOST_TEST_MESSAGE("StartMomentum()");
262  BOOST_CHECK_CLOSE
263  (traj.StartMomentum(), expected.momenta[firstValidPoint].R(), 0.01);
264 
265  BOOST_TEST_MESSAGE("EndMomentum()");
266  BOOST_CHECK_CLOSE
267  (traj.EndMomentum(), expected.momenta[lastValidPoint].R(), 0.01);
268 
269 
270  //----------------------------------------------------------------------------
271  for (size_t i = 0; i < NPoints; ++i) {
272 
273  BOOST_TEST_MESSAGE("DirectionAtPoint() position #" << i);
274  CheckVectorsClose(traj.DirectionAtPoint(i), expected.momenta[i].Unit());
275 
276  } // for
277 
278 
279  //----------------------------------------------------------------------------
280  for (size_t i = 0; i < NPoints; ++i) {
281 
282  if (validPoints.count(i) == 0) continue; // invalid points can be whatever
283 
284  BOOST_TEST_MESSAGE("MomentumVectorAtPoint() position #" << i);
285  if (traj.HasMomentum())
286  CheckVectorsClose(traj.MomentumVectorAtPoint(i), expected.momenta[i]);
287  else {
288  CheckVectorsClose
289  (traj.MomentumVectorAtPoint(i), expected.momenta[i].Unit());
290  }
291 
292  BOOST_TEST_MESSAGE("MomentumAtPoint() position #" << i);
293  if (traj.HasMomentum()) {
294  BOOST_CHECK_CLOSE
295  (traj.MomentumAtPoint(i), expected.momenta[i].R(), 0.01);
296  }
297  else
298  BOOST_CHECK_CLOSE(traj.MomentumAtPoint(i), 1.0, 0.01);
299 
300  } // for
301 
302 
303  //----------------------------------------------------------------------------
304  TVector3 AstartDir, AendDir;
305  std::tie(AstartDir, AendDir) = traj.Direction<TVector3>();
306  BOOST_CHECK_CLOSE
307  (AstartDir[0], expected.momenta[firstValidPoint].Unit().X(), 0.01);
308  BOOST_CHECK_CLOSE
309  (AstartDir[1], expected.momenta[firstValidPoint].Unit().Y(), 0.01);
310  BOOST_CHECK_CLOSE
311  (AstartDir[2], expected.momenta[firstValidPoint].Unit().Z(), 0.01);
312  BOOST_CHECK_CLOSE
313  (AendDir[0], expected.momenta[lastValidPoint].Unit().X(), 0.01);
314  BOOST_CHECK_CLOSE
315  (AendDir[1], expected.momenta[lastValidPoint].Unit().Y(), 0.01);
316  BOOST_CHECK_CLOSE
317  (AendDir[2], expected.momenta[lastValidPoint].Unit().Z(), 0.01);
318 
319  recob::Trajectory::Vector_t startDir, endDir;
320  std::tie(startDir, endDir) = traj.Direction();
321  BOOST_TEST_MESSAGE("Direction() start");
322  CheckVectorsClose(startDir, expected.momenta[firstValidPoint].Unit());
323  BOOST_TEST_MESSAGE("Direction() end");
324  CheckVectorsClose(endDir, expected.momenta[lastValidPoint].Unit());
325 
326 
327  //----------------------------------------------------------------------------
328 
329  for (size_t i = 0; i < NPoints; ++i) {
330 
331  if (validPoints.count(i) == 0) continue; // invalid points can be whatever
332 
333  auto const& dir = expected.momenta[i];
334  recob::Trajectory::Vector_t localDir(0., 0., dir.R());
335 
336  BOOST_TEST_MESSAGE("Test transformation to local at point #" << i);
337  auto toLocal = traj.GlobalToLocalRotationAtPoint(i);
338  CheckVectorsClose(toLocal * dir, localDir);
339 
340  BOOST_TEST_MESSAGE("Test transformation to global at point #" << i);
341  auto toGlobal = traj.LocalToGlobalRotationAtPoint(i);
342  CheckVectorsClose(toGlobal * localDir, dir);
343 
344  } // for
345 
346  //----------------------------------------------------------------------------
347  for (size_t i = 0; i < NPoints; ++i) {
348 
349  if (validPoints.count(i) == 0) continue; // invalid points can be whatever
350 
351  auto const& dir = expected.momenta[i];
352  recob::Trajectory::Vector_t localDir(0., 0., dir.R());
353 
354  BOOST_TEST_MESSAGE("Test legacy transformation to local at point #" << i);
355  TMatrixD TtoLocal = traj.GlobalToLocalRotationAtPoint<TMatrixD>(i);
356  auto toLocal = makeRotationMatrix(TtoLocal);
357  CheckVectorsClose(toLocal * dir, localDir);
358 
359  BOOST_TEST_MESSAGE("Test legacy transformation to global at point #" << i);
360  TMatrixD TtoGlobal = traj.LocalToGlobalRotationAtPoint<TMatrixD>(i);
361  auto toGlobal = makeRotationMatrix(TtoGlobal);
362  CheckVectorsClose(toGlobal * localDir, dir);
363 
364  } // for
365 
366  //----------------------------------------------------------------------------
367 
368 } // TestTrackTrajectory()
369 
370 
371 //------------------------------------------------------------------------------
372 void TrackTrajectoryTestDefaultConstructor() {
373 
374  BOOST_TEST_MESSAGE("Testing the default recob::TrackTrajectory constructor");
375 
376  //
377  // Part I: initialization of trajectory inputs
378  //
379  // these are the values expected for a default-constructed trajectory
380  Expected_t expected;
381  expected.positions.clear();
382  expected.momenta.clear();
383  expected.flags.clear();
384  expected.hasMomenta = false;
385  expected.length = 0.0;
386 
387  //
388  // Part II: default constructor
389  //
390  // step II.1: create a trajectory with the default constructor
391  recob::TrackTrajectory traj;
392 
393  for (unsigned int v = 0; v <= recob::TrackTrajectory::MaxDumpVerbosity; ++v) {
394  std::cout
395  << "Default-constructed track trajectory dump with verbosity level "
396  << v << ":" << std::endl;
397  traj.Dump(std::cout, v, " ", " ");
398  std::cout << std::endl;
399  } // for
400 
401  // step II.2: verify that the values are as expected
402  TestTrackTrajectory(traj, expected);
403 
404 } // TrackTrajectoryTestDefaultConstructor()
405 
406 
407 //------------------------------------------------------------------------------
408 void TrackTrajectoryTestMainConstructor() {
409 
410  BOOST_TEST_MESSAGE("Testing the main recob::TrackTrajectory constructor");
411 
412  //
413  // Part I: initialization of trajectory inputs
414  //
415  const recob::TrackTrajectory::Coord_t V2_2 = std::sqrt(0.5);
416  Expected_t expected;
417  // we describe a trajectory with uniform electric and magnetic fields aligned
418  // on z; curvature is 1 on the x/y plane.
419  expected.positions = {
420  recob::TrackTrajectory::Point_t( -1.0, 0.0, 0.0 ),
421  recob::TrackTrajectory::Point_t( -V2_2, +V2_2, 1.0 ),
422  recob::TrackTrajectory::Point_t( 0.0, +1.0, 2.0 ),
423  recob::TrackTrajectory::Point_t( +V2_2, +V2_2, 3.0 ),
424  recob::TrackTrajectory::Point_t( +1.0, 0.0, 4.0 ),
425  recob::TrackTrajectory::Point_t( +V2_2, -V2_2, 5.0 ),
426  recob::TrackTrajectory::Point_t( 0.0, -1.0, 6.0 ),
427  recob::TrackTrajectory::Point_t( -V2_2, -V2_2, 7.0 ),
428  recob::TrackTrajectory::Point_t( -1.0, 0.0, 8.0 ),
429  recob::TrackTrajectory::Point_t( -V2_2, +V2_2, 9.0 ),
430  recob::TrackTrajectory::Point_t( 0.0, +1.0, 10.0 ),
431  recob::TrackTrajectory::Point_t( +V2_2, +V2_2, 11.0 ),
432  recob::TrackTrajectory::Point_t( +1.0, 0.0, 12.0 ),
433  recob::TrackTrajectory::Point_t( +V2_2, -V2_2, 13.0 ),
434  recob::TrackTrajectory::Point_t( 0.0, -1.0, 14.0 ),
435  recob::TrackTrajectory::Point_t( -V2_2, -V2_2, 15.0 ),
436  recob::TrackTrajectory::Point_t( -1.0, 0.0, 16.0 ),
437  recob::TrackTrajectory::Point_t( -V2_2, +V2_2, 17.0 ),
438  recob::TrackTrajectory::Point_t( 0.0, +1.0, 18.0 ),
439  recob::TrackTrajectory::Point_t( +V2_2, +V2_2, 19.0 ),
440  recob::TrackTrajectory::Point_t( +1.0, 0.0, 20.0 ),
441  recob::TrackTrajectory::Point_t( +V2_2, -V2_2, 21.0 ),
442  recob::TrackTrajectory::Point_t( 0.0, -1.0, 22.0 ),
443  recob::TrackTrajectory::Point_t( -V2_2, -V2_2, 23.0 ),
444  recob::TrackTrajectory::Point_t( -1.0, 0.0, 24.0 )
445  };
446  expected.momenta = {
447  recob::TrackTrajectory::Vector_t( 0.0, +1.0, 1.0 ),
448  recob::TrackTrajectory::Vector_t( +V2_2, +V2_2, 1.0 ),
449  recob::TrackTrajectory::Vector_t( +1.0, 0.0, 1.0 ),
450  recob::TrackTrajectory::Vector_t( +V2_2, -V2_2, 1.0 ),
451  recob::TrackTrajectory::Vector_t( 0.0, -1.0, 1.0 ),
452  recob::TrackTrajectory::Vector_t( -V2_2, -V2_2, 1.0 ),
453  recob::TrackTrajectory::Vector_t( -1.0, 0.0, 1.0 ),
454  recob::TrackTrajectory::Vector_t( -V2_2, +V2_2, 1.0 ),
455  recob::TrackTrajectory::Vector_t( 0.0, +1.0, 1.0 ),
456  recob::TrackTrajectory::Vector_t( +V2_2, +V2_2, 1.0 ),
457  recob::TrackTrajectory::Vector_t( +1.0, 0.0, 1.0 ),
458  recob::TrackTrajectory::Vector_t( +V2_2, -V2_2, 1.0 ),
459  recob::TrackTrajectory::Vector_t( 0.0, -1.0, 1.0 ),
460  recob::TrackTrajectory::Vector_t( -V2_2, -V2_2, 1.0 ),
461  recob::TrackTrajectory::Vector_t( -1.0, 0.0, 1.0 ),
462  recob::TrackTrajectory::Vector_t( -V2_2, +V2_2, 1.0 ),
463  recob::TrackTrajectory::Vector_t( 0.0, +1.0, 1.0 ),
464  recob::TrackTrajectory::Vector_t( +V2_2, +V2_2, 1.0 ),
465  recob::TrackTrajectory::Vector_t( +1.0, 0.0, 1.0 ),
466  recob::TrackTrajectory::Vector_t( +V2_2, -V2_2, 1.0 ),
467  recob::TrackTrajectory::Vector_t( 0.0, -1.0, 1.0 ),
468  recob::TrackTrajectory::Vector_t( -V2_2, -V2_2, 1.0 ),
469  recob::TrackTrajectory::Vector_t( -1.0, 0.0, 1.0 ),
470  recob::TrackTrajectory::Vector_t( -V2_2, +V2_2, 1.0 ),
471  recob::TrackTrajectory::Vector_t( 0.0, +1.0, 1.0 )
472  };
473  using trkflag = recob::TrackTrajectory::flag;
474  expected.flags = {
475  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex },
476  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
477  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex },
478  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
479  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex },
480  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
481  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex },
482  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
483  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex },
484  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
485  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex },
486  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
487  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex },
488  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
489  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex },
490  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
491  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex },
492  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
493  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex },
494  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
495  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex },
496  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
497  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex },
498  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
499  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex }
500  };
501  expected.hasMomenta = true;
502  expected.length = 12. * std::sqrt(6);
503  expected.theta = util::pi() / 4.0;
504  expected.phi = util::pi() / 2.0;
505  expected.zenith = 0.75 * util::pi();
506  expected.azimuth = 0.0;
507 
508  //
509  // Part II: complete constructor
510  //
511  // step II.1: create a track with momentum information
512  auto positions = expected.positions;
513  auto momenta = expected.momenta;
514  auto flags = expected.flags;
515  recob::TrackTrajectory traj
516  (std::move(positions), std::move(momenta), std::move(flags), true);
517 
518  for (unsigned int v = 0; v <= recob::TrackTrajectory::MaxDumpVerbosity; ++v) {
519  std::cout << "Track trajectory dump with verbosity level "
520  << v << ":" << std::endl;
521  traj.Dump(std::cout, v, " ", " ");
522  std::cout << std::endl;
523  } // for
524 
525  // step II.2: verify that the values are as expected
526  TestTrackTrajectory(traj, expected);
527 
528  //
529  // Part III: complete constructor, no momentum
530  //
531 
532  // step III.1: amend the expectation for a momentumless track
533  std::transform(expected.momenta.begin(), expected.momenta.end(),
534  expected.momenta.begin(), [](auto const& v){ return v.unit(); });
535  expected.hasMomenta = false;
536 
537  // step III.2: create a track with no momentum information
538  positions = expected.positions; // copy again
539  recob::TrackTrajectory::Momenta_t directions = expected.momenta;
540  flags = expected.flags;
541  recob::TrackTrajectory mltraj
542  (std::move(positions), std::move(directions), std::move(flags), false);
543 
544  for (unsigned int v = 0; v <= recob::TrackTrajectory::MaxDumpVerbosity; ++v) {
545  std::cout << "Momentumless trajectory dump with verbosity level "
546  << v << ":" << std::endl;
547  mltraj.Dump(std::cout, v, " ", " ");
548  std::cout << std::endl;
549  } // for
550 
551  // step III.3: verify that the values are as expected
552  TestTrackTrajectory(mltraj, expected);
553 
554  //
555  // Part IV: complete constructor, less valid points
556  //
557 
558  // step IV.2: suppress the points
559  expected.flags = {
560  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
561  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
562  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
563  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
564  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
565  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
566  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
567  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
568  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex },
569  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
570  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
571  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
572  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex },
573  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
574  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
575  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
576  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex },
577  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
578  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
579  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
580  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
581  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
582  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
583  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint },
584  { recob::TrackTrajectory::PointFlags_t::InvalidHitIndex, trkflag::NoPoint }
585  };
586  expected.hasMomenta = true;
587  expected.length = 2. * std::sqrt(20.0);
588 
589  // step IV.2: create the track
590  positions = expected.positions; // copy again
591  momenta = expected.momenta;
592  flags = expected.flags;
593  recob::TrackTrajectory shorttraj
594  (std::move(positions), std::move(momenta), std::move(flags), true);
595 
596  for (unsigned int v = 0; v <= recob::TrackTrajectory::MaxDumpVerbosity; ++v) {
597  std::cout << "Short trajectory dump with verbosity level "
598  << v << ":" << std::endl;
599  shorttraj.Dump(std::cout, v, " ", " ");
600  std::cout << std::endl;
601  } // for
602 
603  // step IV.3: verify that the values are as expected
604  TestTrackTrajectory(shorttraj, expected);
605 
606 } // TrackTrajectoryTestMainConstructor()
607 
608 
609 //------------------------------------------------------------------------------
610 //--- registration of tests
611 //
612 // Boost needs now to know which tests we want to run.
613 // Tests are "automatically" registered, hence the BOOST_AUTO_TEST_CASE()
614 // macro name. The argument is the name of the test; each step may have a
615 // number of checks and it will fail if any of them does.
616 //
617 
618 BOOST_AUTO_TEST_CASE(TrackTrajectoryTestDefaultConstructorTestCase) {
619  TrackTrajectoryTestDefaultConstructor();
620 }
621 
622 BOOST_AUTO_TEST_CASE(TrackTrajectoryTestMainConstructorTestCase) {
623  TrackTrajectoryTestMainConstructor();
624 }
625 
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(AllTests)
Definition: WaveformOperations_test.cc:128
recob::TrackTrajectory::Dump
void Dump(Stream &&out, unsigned int verbosity, std::string indent, std::string indentFirst) const
Prints trajectory content into a stream.
Expected_t::theta
double theta
Definition: TrackTrajectory_test.cc:57
Expected_t::phi
double phi
Definition: TrackTrajectory_test.cc:58
recob::Trajectory::HasPoint
bool HasPoint(size_t i) const
Returns whether the specified trajectory point is available.
Definition: Trajectory.h:183
Expected_t::positions
recob::TrackTrajectory::Positions_t positions
Definition: TrackTrajectory_test.cc:52
Expected_t
Definition: TrackTrajectory_test.cc:50
icarus::waveform_operations::details::transform
static constexpr Sample_t transform(Sample_t sample)
Definition: WaveformOperations.h:145
recob::TrajectoryPointFlagTraits::NoPoint
static constexpr Flag_t NoPoint
The trajectory point is not defined.
Definition: TrajectoryPointFlags.h:119
recob::TrackTrajectory::DirectionAtPoint
T DirectionAtPoint(unsigned int p) const
Direction at point p. Use e.g. as:
Definition: TrackTrajectory.h:559
Expected_t::zenith
double zenith
Definition: TrackTrajectory_test.cc:59
tol
auto const tol
Definition: SurfXYZTest.cc:16
recob::TrackTrajectory::LastValidPoint
size_t LastValidPoint() const
Returns the index of the last valid point in the trajectory.
Definition: TrackTrajectory.h:235
recob::TrackTrajectory::GlobalToLocalRotationAtPoint
T GlobalToLocalRotationAtPoint(unsigned int p) const
Returns a rotation matrix that brings trajectory direction along z. Use e.g. as:
Definition: TrackTrajectory.h:574
recob::TrackTrajectory::Positions_t
tracking::Positions_t Positions_t
Type of trajectory point list.
Definition: TrackTrajectory.h:82
recob::TrackTrajectory::ZenithAngle
double ZenithAngle(size_t p) const
&quot;Zenith&quot; angle of trajectory, with respect to the vertical axis.
Definition: TrackTrajectory.h:404
TrackTrajectoryTestMainConstructor
void TrackTrajectoryTestMainConstructor()
Definition: TrackTrajectory_test.cc:408
recob::TrackTrajectory::StartMomentumVector
Vector_t const & StartMomentumVector() const
Returns the momentum of the trajectory at the first valid point [GeV/c].
Definition: TrackTrajectory.h:462
recob::TrackTrajectory::VertexMomentumVector
Vector_t const & VertexMomentumVector() const
Returns the momentum of the trajectory at the first valid point [GeV/c].
Definition: TrackTrajectory.h:458
recob::TrackTrajectory::LocalToGlobalRotationAtPoint
T LocalToGlobalRotationAtPoint(unsigned int p) const
Returns a rotation matrix bringing relative directions to global. Use e.g. as:
Definition: TrackTrajectory.h:581
recob::TrackTrajectory::EndMomentum
double EndMomentum() const
Definition: TrackTrajectory.h:482
recob::TrackTrajectory::flag
PointFlags_t::flag flag
Flag traits (including the definition of flag mnemonics).
Definition: TrackTrajectory.h:79
makeRotationMatrix
recob::TrackTrajectory::Rotation_t makeRotationMatrix(TMatrixD const &Tm)
Definition: TrackTrajectory_test.cc:86
CheckValue
void CheckValue(T v, T exp, T tol, std::string tag="")
Definition: TrackTrajectory_test.cc:65
recob::TrackTrajectory::CountValidPoints
unsigned int CountValidPoints() const
Computes and returns the number of points with valid location.
Definition: TrackTrajectory.cxx:42
recob::TrackTrajectory::Momenta_t
tracking::Momenta_t Momenta_t
Type of momentum list.
Definition: TrackTrajectory.h:85
gen_crt_frags.m
tuple m
now if test mode generate materials, CRT shell, world, gdml header else just generate CRT shell for u...
Definition: gen_crt_frags.py:1347
recob::TrackTrajectory::Extent
std::pair< T, T > Extent() const
Fills the first and last valid point in the trajectory.
Definition: TrackTrajectory.h:270
CheckVectorsEqual
void CheckVectorsEqual(VectA const &v, VectB const &exp)
Definition: TrackTrajectory_test.cc:72
recob::Trajectory::Vector_t
tracking::Vector_t Vector_t
Type for representation of momenta in 3D space.
Definition: Trajectory.h:76
recob::TrackTrajectory::VertexDirection
Vector_t VertexDirection() const
Returns the direction of the trajectory at the first point.
Definition: TrackTrajectory.h:313
abs
T abs(T value)
Definition: sparse_vector_test.cc:30
recob::TrackTrajectory::Direction
std::pair< T, T > Direction() const
Fills the starting and ending direction of the trajectory.
Definition: TrackTrajectory.h:506
TrackTrajectoryTestDefaultConstructor
void TrackTrajectoryTestDefaultConstructor()
Definition: TrackTrajectory_test.cc:372
recob::TrackTrajectory::Length
double Length(size_t startAt=0) const
Returns the approximate length of the trajectory.
Definition: TrackTrajectory.cxx:70
recob::Trajectory::LastPoint
size_t LastPoint() const
Returns the index of the last point in the trajectory.
Definition: Trajectory.h:175
recob::TrackTrajectory::PreviousValidPoint
size_t PreviousValidPoint(size_t index) const
Returns the index of the previous valid point in the trajectory.
Definition: TrackTrajectory.h:225
recob::Trajectory::NPoints
size_t NPoints() const
Returns the number of stored trajectory points.
Definition: Trajectory.h:167
recob::TrackTrajectory
A trajectory in space reconstructed from hits.
Definition: TrackTrajectory.h:62
recob::TrackTrajectory::LocationAtPoint
T LocationAtPoint(unsigned int p) const
Position at point p. Use e.g. as:
Definition: TrackTrajectory.h:547
recob::Trajectory::MomentumAtPoint
double MomentumAtPoint(size_t i) const
Computes and returns the modulus of the momentum at a point.
Definition: Trajectory.h:442
recob::TrackTrajectory::HasValidPoint
bool HasValidPoint(size_t i) const
Returns whether the specified point has NoPoint flag unset.
Definition: TrackTrajectory.h:184
icarus::ns::util::end
auto end(FixedBins< T, C > const &) noexcept
Definition: FixedBins.h:585
recob::TrackTrajectory::StartMomentum
double StartMomentum() const
Definition: TrackTrajectory.h:477
recob::TrackTrajectory::Rotation_t
tracking::Rotation_t Rotation_t
Type for representation of space rotations.
Definition: TrackTrajectory.h:97
TrackTrajectory.h
Data product for reconstructed trajectory in space.
Expected_t::flags
recob::TrackTrajectory::Flags_t flags
Definition: TrackTrajectory_test.cc:54
recob::TrackTrajectory::Vector_t
tracking::Vector_t Vector_t
Type for representation of momenta in 3D space.
Definition: TrackTrajectory.h:73
TestTrackTrajectory
void TestTrackTrajectory(recob::TrackTrajectory const &traj, Expected_t const &expected)
Definition: TrackTrajectory_test.cc:93
recob::TrackTrajectory::Flags_t
std::vector< PointFlags_t > Flags_t
Type of point flag list.
Definition: TrackTrajectory.h:88
recob::Trajectory::NumberTrajectoryPoints
size_t NumberTrajectoryPoints() const
Returns the number of stored trajectory points.
Definition: Trajectory.h:156
recob::TrajectoryPointFlags::InvalidHitIndex
static constexpr HitIndex_t InvalidHitIndex
Value marking an invalid hit index.
Definition: TrajectoryPointFlags.h:336
TrajectoryPointFlags.h
Set of flags pertaining a point of the track.
Expected_t::momenta
recob::TrackTrajectory::Momenta_t momenta
Definition: TrackTrajectory_test.cc:53
recob::TrackTrajectory::Phi
double Phi(size_t p) const
Azimuthal angle at a point on the trajectory, with respect to z.
Definition: TrackTrajectory.h:371
recob::TrackTrajectory::Vertex
Point_t const & Vertex() const
Returns the position of the first valid point of the trajectory [cm].
Definition: TrackTrajectory.h:249
make_calib_df.exp
def exp
Definition: make_calib_df.py:43
dropbox.dir
tuple dir
Definition: dropbox.py:28
recob::TrackTrajectory::EndDirection
Vector_t EndDirection() const
Returns the direction of the trajectory at the last point.
Definition: TrackTrajectory.h:321
recob::TrackTrajectory::Coord_t
tracking::Coord_t Coord_t
Type used for coordinates and values in general.
Definition: TrackTrajectory.h:67
Expected_t::azimuth
double azimuth
Definition: TrackTrajectory_test.cc:60
recob::TrackTrajectory::Theta
double Theta(size_t p) const
Trajectory angle at point, with respect to positive z direction.
Definition: TrackTrajectory.h:339
recob::TrackTrajectory::FirstValidPoint
size_t FirstValidPoint() const
Returns the index of the first valid point in the trajectory.
Definition: TrackTrajectory.h:197
recob::TrackTrajectory::InvalidIndex
static constexpr size_t InvalidIndex
Value returned on failed index queries.
Definition: TrackTrajectory.h:661
recob::Trajectory::HasMomentum
bool HasMomentum() const
Returns whether information about the momentum is available.
Definition: Trajectory.h:425
recob::TrackTrajectory::EndMomentumVector
Vector_t const & EndMomentumVector() const
Returns the momentum of the trajectory at the last valid point [GeV/c].
Definition: TrackTrajectory.h:466
Expected_t::hasMomenta
bool hasMomenta
Definition: TrackTrajectory_test.cc:55
recob::TrackTrajectory::MaxDumpVerbosity
static constexpr unsigned int MaxDumpVerbosity
Largest verbosity level supported by Dump().
Definition: TrackTrajectory.h:658
recob::TrackTrajectory::End
Point_t const & End() const
Returns the position of the last valid point of the trajectory [cm].
Definition: TrackTrajectory.h:257
recob::Trajectory::Point_t
tracking::Point_t Point_t
Type for representation of position in physical 3D space.
Definition: Trajectory.h:73
util::pi
constexpr T pi()
Returns the constant pi (up to 35 decimal digits of precision)
Definition: PhysicalConstants.h:80
recob::TrackTrajectory::NextValidPoint
size_t NextValidPoint(size_t index) const
Returns the index of the next valid point in the trajectory.
Definition: TrackTrajectory.h:211
recob::TrackTrajectory::AzimuthAngle
double AzimuthAngle(size_t p) const
&quot;Azimuth&quot; angle of trajectory, with respect to the sky.
Definition: TrackTrajectory.h:437
Expected_t::length
double length
Definition: TrackTrajectory_test.cc:56
recob::TrackTrajectory::Point_t
tracking::Point_t Point_t
Type for representation of position in physical 3D space.
Definition: TrackTrajectory.h:70
recob::TrackTrajectory::VertexMomentum
double VertexMomentum() const
Definition: TrackTrajectory.h:472
recob::TrackTrajectory::MomentumVectorAtPoint
T MomentumVectorAtPoint(unsigned int p) const
Momentum vector at point p. Use e.g. as:
Definition: TrackTrajectory.h:571
PhysicalConstants.h
Collection of Physical constants used in LArSoft.
recob::TrackTrajectory::StartDirection
Vector_t StartDirection() const
Returns the direction of the trajectory at the first point.
Definition: TrackTrajectory.h:317
recob::TrackTrajectory::Start
Point_t const & Start() const
Returns the position of the first valid point of the trajectory [cm].
Definition: TrackTrajectory.h:253
cout
BEGIN_PROLOG could also be cout
Definition: messageservice.fcl:10
CheckVectorsClose
void CheckVectorsClose(VectA const &v, VectB const &exp, double tol=0.01)
Definition: TrackTrajectory_test.cc:79
Generated by   doxygen 1.8.5