GENFIT  Rev:NoNumberAvailable
Track.cc
Go to the documentation of this file.
1 /* Copyright 2008-2010, Technische Universitaet Muenchen,
2  Authors: Christian Hoeppner & Sebastian Neubert & Johannes Rauch
3 
4  This file is part of GENFIT.
5 
6  GENFIT is free software: you can redistribute it and/or modify
7  it under the terms of the GNU Lesser General Public License as published
8  by the Free Software Foundation, either version 3 of the License, or
9  (at your option) any later version.
10 
11  GENFIT is distributed in the hope that it will be useful,
12  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  GNU Lesser General Public License for more details.
15 
16  You should have received a copy of the GNU Lesser General Public License
17  along with GENFIT. If not, see <http://www.gnu.org/licenses/>.
18 */
19 
20 #include "Track.h"
21 
22 #include "Exception.h"
23 #include "IO.h"
24 #include "KalmanFitterInfo.h"
25 #include "KalmanFitStatus.h"
26 #include "PlanarMeasurement.h"
27 #include "AbsMeasurement.h"
28 
29 #include "WireTrackCandHit.h"
30 
31 #include <algorithm>
32 #include <map>
33 
34 #include <TDatabasePDG.h>
35 #include <TMath.h>
36 #include <TBuffer.h>
37 
38 //#include <glog/logging.h>
39 
40 //#define DEBUG
41 
42 
43 namespace genfit {
44 
46  cardinalRep_(0), fitStatuses_(), mcTrackId_(-1), timeSeed_(0), stateSeed_(6), covSeed_(6)
47 {
48  ;
49 }
50 
51 
52 Track::Track(const TrackCand& trackCand, const MeasurementFactory<AbsMeasurement>& factory, AbsTrackRep* rep) :
53  cardinalRep_(0), fitStatuses_(), stateSeed_(6), covSeed_(6)
54 {
55 
56  if (rep != NULL)
57  addTrackRep(rep);
58 
59  createMeasurements(trackCand, factory);
60 
61  // Copy seed information from candidate
62  timeSeed_ = trackCand.getTimeSeed();
63  stateSeed_ = trackCand.getStateSeed();
64  covSeed_ = trackCand.getCovSeed();
65 
66  mcTrackId_ = trackCand.getMcTrackId();
67 
68  // fill cache
70 
71  // self test
72  assert(checkConsistency());
73 }
74 
75 void
77 {
78  // create the measurements using the factory.
79  std::vector <AbsMeasurement*> factoryHits = factory.createMany(trackCand);
80 
81  if (factoryHits.size() != trackCand.getNHits()) {
82  Exception exc("Track::Track ==> factoryHits.size() != trackCand->getNHits()",__LINE__,__FILE__);
83  exc.setFatal();
84  throw exc;
85  }
86 
87  // create TrackPoints
88  for (unsigned int i=0; i<factoryHits.size(); ++i){
89  TrackPoint* tp = new TrackPoint(factoryHits[i], this);
90  tp->setSortingParameter(trackCand.getHit(i)->getSortingParameter());
91  insertPoint(tp);
92  }
93 }
94 
95 
96 Track::Track(AbsTrackRep* trackRep, const TVectorD& stateSeed) :
97  cardinalRep_(0), fitStatuses_(), mcTrackId_(-1), timeSeed_(0), stateSeed_(stateSeed),
98  covSeed_(TMatrixDSym::kUnit, TMatrixDSym(6))
99 {
100  addTrackRep(trackRep);
101 }
102 
103 
104 Track::Track(AbsTrackRep* trackRep, const TVector3& posSeed, const TVector3& momSeed) :
105  cardinalRep_(0), fitStatuses_(), mcTrackId_(-1), timeSeed_(0), stateSeed_(6),
106  covSeed_(TMatrixDSym::kUnit, TMatrixDSym(6))
107 {
108  addTrackRep(trackRep);
109  setStateSeed(posSeed, momSeed);
110 }
111 
112 
113 Track::Track(AbsTrackRep* trackRep, const TVectorD& stateSeed, const TMatrixDSym& covSeed) :
114  cardinalRep_(0), fitStatuses_(), mcTrackId_(-1), timeSeed_(0), stateSeed_(stateSeed),
115  covSeed_(covSeed)
116 {
117  addTrackRep(trackRep);
118 }
119 
120 
121 Track::Track(const Track& rhs) :
122  TObject(rhs),
123  cardinalRep_(rhs.cardinalRep_), mcTrackId_(rhs.mcTrackId_), timeSeed_(rhs.timeSeed_),
124  stateSeed_(rhs.stateSeed_), covSeed_(rhs.covSeed_)
125 {
126  assert(rhs.checkConsistency());
127 
128  std::map<const AbsTrackRep*, AbsTrackRep*> oldRepNewRep;
129 
130  for (std::vector<AbsTrackRep*>::const_iterator it=rhs.trackReps_.begin(); it!=rhs.trackReps_.end(); ++it) {
131  AbsTrackRep* newRep = (*it)->clone();
132  addTrackRep(newRep);
133  oldRepNewRep[(*it)] = newRep;
134  }
135 
136  trackPoints_.reserve(rhs.trackPoints_.size());
137  for (std::vector<TrackPoint*>::const_iterator it=rhs.trackPoints_.begin(); it!=rhs.trackPoints_.end(); ++it) {
138  trackPoints_.push_back(new TrackPoint(**it, oldRepNewRep));
139  trackPoints_.back()->setTrack(this);
140  }
141 
142  for (std::map< const AbsTrackRep*, FitStatus* >::const_iterator it=rhs.fitStatuses_.begin(); it!=rhs.fitStatuses_.end(); ++it) {
143  setFitStatus(it->second->clone(), oldRepNewRep[it->first]);
144  }
145 
147 
148  // self test
149  assert(checkConsistency());
150 }
151 
153  swap(other);
154 
155  for (std::vector<TrackPoint*>::const_iterator it=trackPoints_.begin(); it!=trackPoints_.end(); ++it) {
156  trackPoints_.back()->setTrack(this);
157  }
158 
160 
161  // self test
162  assert(checkConsistency());
163 
164  return *this;
165 }
166 
167 void Track::swap(Track& other) {
168  std::swap(this->trackReps_, other.trackReps_);
169  std::swap(this->cardinalRep_, other.cardinalRep_);
170  std::swap(this->trackPoints_, other.trackPoints_);
172  std::swap(this->fitStatuses_, other.fitStatuses_);
173  std::swap(this->mcTrackId_, other.mcTrackId_);
174  std::swap(this->timeSeed_, other.timeSeed_);
175  std::swap(this->stateSeed_, other.stateSeed_);
176  std::swap(this->covSeed_, other.covSeed_);
177 
178 }
179 
181  this->Clear();
182 }
183 
184 void Track::Clear(Option_t*)
185 {
186  // This function is needed for TClonesArray embedding.
187  // FIXME: smarter containers or pointers needed ...
188  for (size_t i = 0; i < trackPoints_.size(); ++i)
189  delete trackPoints_[i];
190 
191  trackPoints_.clear();
193 
194  for (std::map< const AbsTrackRep*, FitStatus* >::iterator it = fitStatuses_.begin(); it!= fitStatuses_.end(); ++it)
195  delete it->second;
196  fitStatuses_.clear();
197 
198  for (size_t i = 0; i < trackReps_.size(); ++i)
199  delete trackReps_[i];
200  trackReps_.clear();
201 
202  cardinalRep_ = 0;
203 
204  mcTrackId_ = -1;
205 
206  timeSeed_ = 0;
207  stateSeed_.Zero();
208  covSeed_.Zero();
209 }
210 
211 
212 TrackPoint* Track::getPoint(int id) const {
213  if (id < 0)
214  id += trackPoints_.size();
215 
216  return trackPoints_.at(id);
217 }
218 
219 
221  if (id < 0)
222  id += trackPointsWithMeasurement_.size();
223 
224  return trackPointsWithMeasurement_.at(id);
225 }
226 
227 
229  if (rep == NULL)
230  rep = getCardinalRep();
231 
232  if (id >= 0) {
233  int i = 0;
234  for (std::vector<TrackPoint*>::const_iterator it = trackPointsWithMeasurement_.begin(); it != trackPointsWithMeasurement_.end(); ++it) {
235  if ((*it)->hasFitterInfo(rep)) {
236  if (id == i)
237  return (*it);
238  ++i;
239  }
240  }
241  } else {
242  // Search backwards.
243  int i = -1;
244  for (std::vector<TrackPoint*>::const_reverse_iterator it = trackPointsWithMeasurement_.rbegin(); it != trackPointsWithMeasurement_.rend(); ++it) {
245  if ((*it)->hasFitterInfo(rep)) {
246  if (id == i)
247  return (*it);
248  --i;
249  }
250  }
251  }
252 
253  // Not found, i.e. abs(id) > number of fitted TrackPoints
254  return 0;
255 }
256 
257 
259  if (rep == NULL)
260  rep = getCardinalRep();
261 
262  if (id >= 0) {
263  int i = 0;
264  for (std::vector<TrackPoint*>::const_iterator it = trackPoints_.begin(); it != trackPoints_.end(); ++it) {
265  if ((*it)->hasFitterInfo(rep)) {
266  if (id == i)
267  return (*it);
268  ++i;
269  }
270  }
271  } else {
272  // Search backwards.
273  int i = -1;
274  for (std::vector<TrackPoint*>::const_reverse_iterator it = trackPoints_.rbegin(); it != trackPoints_.rend(); ++it) {
275  if ((*it)->hasFitterInfo(rep)) {
276  if (id == i)
277  return (*it);
278  --i;
279  }
280  }
281  }
282 
283  // Not found, i.e. abs(id) > number of fitted TrackPoints
284  return 0;
285 }
286 
287 
288 const MeasuredStateOnPlane& Track::getFittedState(int id, const AbsTrackRep* rep, bool biased) const {
289  if (rep == NULL)
290  rep = getCardinalRep();
291 
292  TrackPoint* point = getPointWithFitterInfo(id, rep);
293  if (point == NULL) {
294  Exception exc("Track::getFittedState ==> no trackPoint with fitterInfo for rep",__LINE__,__FILE__);
295  exc.setFatal();
296  throw exc;
297  }
298  return point->getFitterInfo(rep)->getFittedState(biased);
299 }
300 
301 
302 int Track::getIdForRep(const AbsTrackRep* rep) const
303 {
304  for (size_t i = 0; i < trackReps_.size(); ++i)
305  if (trackReps_[i] == rep)
306  return i;
307 
308  Exception exc("Track::getIdForRep ==> cannot find TrackRep in Track",__LINE__,__FILE__);
309  exc.setFatal();
310  throw exc;
311 }
312 
313 
314 bool Track::hasFitStatus(const AbsTrackRep* rep) const {
315  if (rep == NULL)
316  rep = getCardinalRep();
317 
318  if (fitStatuses_.find(rep) == fitStatuses_.end())
319  return false;
320 
321  return (fitStatuses_.at(rep) != NULL);
322 }
323 
324 
325 bool Track::hasKalmanFitStatus(const AbsTrackRep* rep) const {
326  if (rep == NULL)
327  rep = getCardinalRep();
328 
329  if (fitStatuses_.find(rep) == fitStatuses_.end())
330  return false;
331 
332  return (dynamic_cast<KalmanFitStatus*>(fitStatuses_.at(rep)) != NULL);
333 }
334 
335 
337  return dynamic_cast<KalmanFitStatus*>(getFitStatus(rep));
338 }
339 
340 
341 void Track::setFitStatus(FitStatus* fitStatus, const AbsTrackRep* rep) {
342  if (fitStatuses_.find(rep) != fitStatuses_.end())
343  delete fitStatuses_.at(rep);
344 
345  fitStatuses_[rep] = fitStatus;
346 }
347 
348 
349 void Track::setStateSeed(const TVector3& pos, const TVector3& mom) {
350  stateSeed_.ResizeTo(6);
351 
352  stateSeed_(0) = pos.X();
353  stateSeed_(1) = pos.Y();
354  stateSeed_(2) = pos.Z();
355 
356  stateSeed_(3) = mom.X();
357  stateSeed_(4) = mom.Y();
358  stateSeed_(5) = mom.Z();
359 }
360 
361 
362 
363 void Track::insertPoint(TrackPoint* point, int id) {
364 
365  point->setTrack(this);
366 
367  #ifdef DEBUG
368  debugOut << "Track::insertPoint at position " << id << "\n";
369  #endif
370  assert(point!=NULL);
371  trackHasChanged();
372 
373  point->setTrack(this);
374 
375  if (trackPoints_.size() == 0) {
376  trackPoints_.push_back(point);
377 
378  if (point->hasRawMeasurements())
379  trackPointsWithMeasurement_.push_back(point);
380 
381  return;
382  }
383 
384  if (id == -1 || id == (int)trackPoints_.size()) {
385  trackPoints_.push_back(point);
386 
387  if (point->hasRawMeasurements())
388  trackPointsWithMeasurement_.push_back(point);
389 
390  deleteReferenceInfo(std::max(0, (int)trackPoints_.size()-2), (int)trackPoints_.size()-1);
391 
392  // delete fitter infos if inserted point has a measurement
393  if (point->hasRawMeasurements()) {
394  deleteForwardInfo(-1, -1);
395  deleteBackwardInfo(0, -2);
396  }
397 
398  return;
399  }
400 
401  // [-size, size-1] is the allowed range
402  assert(id < (ssize_t)trackPoints_.size() || -id-1 <= (ssize_t)trackPoints_.size());
403 
404  if (id < 0)
405  id += trackPoints_.size() + 1;
406 
407  // insert
408  trackPoints_.insert(trackPoints_.begin() + id, point); // insert inserts BEFORE
409 
410  // delete fitter infos if inserted point has a measurement
411  if (point->hasRawMeasurements()) {
412  deleteForwardInfo(id, -1);
413  deleteBackwardInfo(0, id);
414  }
415 
416  // delete reference info of neighbouring points
417  deleteReferenceInfo(std::max(0, id-1), std::min((int)trackPoints_.size()-1, id+1));
418 
420 }
421 
422 
423 void Track::insertPoints(std::vector<TrackPoint*> points, int id) {
424 
425  int nBefore = getNumPoints();
426  int n = points.size();
427 
428  if (n == 0)
429  return;
430  if (n == 1) {
431  insertPoint(points[0], id);
432  return;
433  }
434 
435  for (std::vector<TrackPoint*>::iterator p = points.begin(); p != points.end(); ++p)
436  (*p)->setTrack(this);
437 
438  if (id == -1 || id == (int)trackPoints_.size()) {
439  trackPoints_.insert(trackPoints_.end(), points.begin(), points.end());
440 
441  deleteReferenceInfo(std::max(0, nBefore-1), nBefore);
442 
443  deleteForwardInfo(nBefore, -1);
444  deleteBackwardInfo(0, std::max(0, nBefore-1));
445 
447 
448  return;
449  }
450 
451 
452  assert(id < (ssize_t)trackPoints_.size() || -id-1 <= (ssize_t)trackPoints_.size());
453 
454  if (id < 0)
455  id += trackPoints_.size() + 1;
456 
457 
458  // insert
459  trackPoints_.insert(trackPoints_.begin() + id, points.begin(), points.end()); // insert inserts BEFORE
460 
461  // delete fitter infos if inserted point has a measurement
462  deleteForwardInfo(id, -1);
463  deleteBackwardInfo(0, id+n);
464 
465  // delete reference info of neighbouring points
466  deleteReferenceInfo(std::max(0, id-1), std::min((int)trackPoints_.size()-1, id));
467  deleteReferenceInfo(std::max(0, id+n-1), std::min((int)trackPoints_.size()-1, id+n));
468 
470 }
471 
472 
473 void Track::deletePoint(int id) {
474 
475  #ifdef DEBUG
476  debugOut << "Track::deletePoint at position " << id << "\n";
477  #endif
478 
479  trackHasChanged();
480 
481  if (id < 0)
482  id += trackPoints_.size();
483  assert(id>0);
484 
485 
486  // delete forwardInfo after point (backwardInfo before point) if deleted point has a measurement
487  if (trackPoints_[id]->hasRawMeasurements()) {
488  deleteForwardInfo(id, -1);
489  deleteBackwardInfo(0, id-1);
490  }
491 
492  // delete reference info of neighbouring points
493  deleteReferenceInfo(std::max(0, id-1), std::min((int)trackPoints_.size()-1, id+1));
494 
495  // delete point
496  std::vector<TrackPoint*>::iterator it = std::find(trackPointsWithMeasurement_.begin(), trackPointsWithMeasurement_.end(), trackPoints_[id]);
497  if (it != trackPointsWithMeasurement_.end())
498  trackPointsWithMeasurement_.erase(it);
499 
500  delete trackPoints_[id];
501  trackPoints_.erase(trackPoints_.begin()+id);
502 
504 
505 }
506 
507 
508 void Track::insertMeasurement(AbsMeasurement* measurement, int id) {
509  insertPoint(new TrackPoint(measurement, this), id);
510 }
511 
512 
513 void Track::mergeTrack(const Track* other, int id) {
514 
515  #ifdef DEBUG
516  debugOut << "Track::mergeTrack\n";
517  #endif
518 
519  if (other->getNumPoints() == 0)
520  return;
521 
522  std::map<const AbsTrackRep*, AbsTrackRep*> otherRepThisRep;
523  std::vector<const AbsTrackRep*> otherRepsToRemove;
524 
525  for (std::vector<AbsTrackRep*>::const_iterator otherRep=other->trackReps_.begin(); otherRep!=other->trackReps_.end(); ++otherRep) {
526  bool found(false);
527  for (std::vector<AbsTrackRep*>::const_iterator thisRep=trackReps_.begin(); thisRep!=trackReps_.end(); ++thisRep) {
528  if ((*thisRep)->isSame(*otherRep)) {
529  otherRepThisRep[*otherRep] = *thisRep;
530  #ifdef DEBUG
531  debugOut << " map other rep " << *otherRep << " to " << (*thisRep) << "\n";
532  #endif
533  if (found) {
534  Exception exc("Track::mergeTrack ==> more than one matching rep.",__LINE__,__FILE__);
535  exc.setFatal();
536  throw exc;
537  }
538  found = true;
539  break;
540  }
541  }
542  if (!found) {
543  otherRepsToRemove.push_back(*otherRep);
544  #ifdef DEBUG
545  debugOut << " remove other rep " << *otherRep << "\n";
546  #endif
547  }
548  }
549 
550 
551  std::vector<TrackPoint*> points;
552  points.reserve(other->getNumPoints());
553 
554  for (std::vector<TrackPoint*>::const_iterator otherTp=other->trackPoints_.begin(); otherTp!=other->trackPoints_.end(); ++otherTp) {
555  points.push_back(new TrackPoint(**otherTp, otherRepThisRep, &otherRepsToRemove));
556  }
557 
558  insertPoints(points, id);
559 }
560 
561 
563  trackReps_.push_back(trackRep);
564  fitStatuses_[trackRep] = new FitStatus();
565 }
566 
567 
568 void Track::deleteTrackRep(int id) {
569  if (id < 0)
570  id += trackReps_.size();
571 
572  AbsTrackRep* rep = trackReps_.at(id);
573 
574  // update cardinalRep_
575  if (int(cardinalRep_) == id)
576  cardinalRep_ = 0; // reset
577  else if (int(cardinalRep_) > id)
578  --cardinalRep_; // make cardinalRep_ point to the same TrackRep before and after deletion
579 
580  // delete FitterInfos related to the deleted TrackRep
581  for (std::vector<TrackPoint*>::const_iterator pointIt = trackPoints_.begin(); pointIt != trackPoints_.end(); ++pointIt) {
582  (*pointIt)->deleteFitterInfo(rep);
583  }
584 
585  // delete fitStatus
586  delete fitStatuses_.at(rep);
587  fitStatuses_.erase(rep);
588 
589  // delete rep
590  delete rep;
591  trackReps_.erase(trackReps_.begin()+id);
592 }
593 
594 
595 void Track::setCardinalRep(int id) {
596 
597  if (id < 0)
598  id += trackReps_.size();
599 
600  if (id >= 0 && (unsigned int)id < trackReps_.size())
601  cardinalRep_ = id;
602  else {
603  cardinalRep_ = 0;
604  errorOut << "Track::setCardinalRep: Attempted to set cardinalRep_ to a value out of bounds. Resetting cardinalRep_ to 0." << std::endl;
605  }
606 }
607 
608 
610 
611  // Todo: test
612 
613  if (trackReps_.size() <= 1)
614  return;
615 
616  double minChi2(9.E99);
617  const AbsTrackRep* bestRep(NULL);
618 
619  for (std::map< const AbsTrackRep*, FitStatus* >::const_iterator it = fitStatuses_.begin(); it != fitStatuses_.end(); ++it) {
620  if (it->second->isFitConverged()) {
621  if (it->second->getChi2() < minChi2) {
622  minChi2 = it->second->getChi2();
623  bestRep = it->first;
624  }
625  }
626  }
627 
628  if (bestRep != NULL) {
629  setCardinalRep(getIdForRep(bestRep));
630  }
631 }
632 
633 
634 bool Track::sort() {
635  #ifdef DEBUG
636  debugOut << "Track::sort \n";
637  #endif
638 
639  int nPoints(trackPoints_.size());
640  // original order
641  std::vector<TrackPoint*> pointsBefore(trackPoints_);
642 
643  // sort
644  std::stable_sort(trackPoints_.begin(), trackPoints_.end(), TrackPointComparator());
645 
646  // see where order changed
647  int equalUntil(-1), equalFrom(nPoints);
648  for (int i = 0; i<nPoints; ++i) {
649  if (pointsBefore[i] == trackPoints_[i])
650  equalUntil = i;
651  else
652  break;
653  }
654 
655  if (equalUntil == nPoints-1)
656  return false; // sorting did not change anything
657 
658 
659  trackHasChanged();
660 
661  for (int i = nPoints-1; i>equalUntil; --i) {
662  if (pointsBefore[i] == trackPoints_[i])
663  equalFrom = i;
664  else
665  break;
666  }
667 
668  #ifdef DEBUG
669  debugOut << "Track::sort. Equal up to (including) hit " << equalUntil << " and from (including) hit " << equalFrom << " \n";
670  #endif
671 
672  deleteForwardInfo(equalUntil+1, -1);
673  deleteBackwardInfo(0, equalFrom-1);
674 
675  deleteReferenceInfo(std::max(0, equalUntil+1), std::min((int)trackPoints_.size()-1, equalFrom-1));
676 
678 
679  return true;
680 }
681 
682 
683 bool Track::udpateSeed(int id, AbsTrackRep* rep, bool biased) {
684  try {
685  const MeasuredStateOnPlane& fittedState = getFittedState(id, rep, biased);
686  setTimeSeed(fittedState.getTime());
687  setStateSeed(fittedState.get6DState());
688  setCovSeed(fittedState.get6DCov());
689 
690  double fittedCharge = fittedState.getCharge();
691 
692  for (unsigned int i = 0; i<trackReps_.size(); ++i) {
693  if (trackReps_[i]->getPDGCharge() * fittedCharge < 0) {
694  trackReps_[i]->switchPDGSign();
695  }
696  }
697  }
698  catch (Exception& e) {
699  // in this case the original track seed will be used
700  return false;
701  }
702  return true;
703 }
704 
705 
707 
708  std::reverse(trackPoints_.begin(),trackPoints_.end());
709 
710  deleteForwardInfo(0, -1);
711  deleteBackwardInfo(0, -1);
712  deleteReferenceInfo(0, -1);
713 
715 }
716 
717 
719  if (rep != NULL) {
720  rep->switchPDGSign();
721  return;
722  }
723 
724  for (unsigned int i = 0; i<trackReps_.size(); ++i) {
725  trackReps_[i]->switchPDGSign();
726  }
727 }
728 
729 
731  udpateSeed(-1); // set fitted state of last hit as new seed
732  reverseMomSeed(); // flip momentum direction
733  switchPDGSigns();
734  reverseTrackPoints(); // also deletes all fitterInfos
735 }
736 
737 
738 void Track::deleteForwardInfo(int startId, int endId, const AbsTrackRep* rep) {
739  #ifdef DEBUG
740  debugOut << "Track::deleteForwardInfo from position " << startId << " to " << endId << "\n";
741  #endif
742 
743  trackHasChanged();
744 
745  if (startId < 0)
746  startId += trackPoints_.size();
747  if (endId < 0)
748  endId += trackPoints_.size();
749  endId += 1;
750 
751  assert (endId >= startId);
752 
753  for (std::vector<TrackPoint*>::const_iterator pointIt = trackPoints_.begin() + startId; pointIt != trackPoints_.begin() + endId; ++pointIt) {
754  if (rep != NULL) {
755  if ((*pointIt)->hasFitterInfo(rep))
756  (*pointIt)->getFitterInfo(rep)->deleteForwardInfo();
757  }
758  else {
759  const std::vector<AbsFitterInfo*> fitterInfos = (*pointIt)->getFitterInfos();
760  for (std::vector<AbsFitterInfo*>::const_iterator fitterInfoIt = fitterInfos.begin(); fitterInfoIt != fitterInfos.end(); ++fitterInfoIt) {
761  (*fitterInfoIt)->deleteForwardInfo();
762  }
763  }
764  }
765 }
766 
767 void Track::deleteBackwardInfo(int startId, int endId, const AbsTrackRep* rep) {
768 
769  #ifdef DEBUG
770  debugOut << "Track::deleteBackwardInfo from position " << startId << " to " << endId << "\n";
771  #endif
772 
773  trackHasChanged();
774 
775  if (startId < 0)
776  startId += trackPoints_.size();
777  if (endId < 0)
778  endId += trackPoints_.size();
779  endId += 1;
780 
781  assert (endId >= startId);
782 
783 
784  for (std::vector<TrackPoint*>::const_iterator pointIt = trackPoints_.begin() + startId; pointIt != trackPoints_.begin() + endId; ++pointIt) {
785  if (rep != NULL) {
786  if ((*pointIt)->hasFitterInfo(rep))
787  (*pointIt)->getFitterInfo(rep)->deleteBackwardInfo();
788  }
789  else {
790  const std::vector<AbsFitterInfo*> fitterInfos = (*pointIt)->getFitterInfos();
791  for (std::vector<AbsFitterInfo*>::const_iterator fitterInfoIt = fitterInfos.begin(); fitterInfoIt != fitterInfos.end(); ++fitterInfoIt) {
792  (*fitterInfoIt)->deleteBackwardInfo();
793  }
794  }
795  }
796 }
797 
798 void Track::deleteReferenceInfo(int startId, int endId, const AbsTrackRep* rep) {
799 
800  #ifdef DEBUG
801  debugOut << "Track::deleteReferenceInfo from position " << startId << " to " << endId << "\n";
802  #endif
803 
804  trackHasChanged();
805 
806  if (startId < 0)
807  startId += trackPoints_.size();
808  if (endId < 0)
809  endId += trackPoints_.size();
810  endId += 1;
811 
812  assert (endId >= startId);
813 
814  for (std::vector<TrackPoint*>::const_iterator pointIt = trackPoints_.begin() + startId; pointIt != trackPoints_.begin() + endId; ++pointIt) {
815  if (rep != NULL) {
816  if ((*pointIt)->hasFitterInfo(rep))
817  (*pointIt)->getFitterInfo(rep)->deleteReferenceInfo();
818  }
819  else {
820  std::vector<AbsFitterInfo*> fitterInfos = (*pointIt)->getFitterInfos();
821  for (std::vector<AbsFitterInfo*>::const_iterator fitterInfoIt = fitterInfos.begin(); fitterInfoIt != fitterInfos.end(); ++fitterInfoIt) {
822  (*fitterInfoIt)->deleteReferenceInfo();
823  }
824  }
825  }
826 }
827 
828 void Track::deleteMeasurementInfo(int startId, int endId, const AbsTrackRep* rep) {
829 
830  #ifdef DEBUG
831  debugOut << "Track::deleteMeasurementInfo from position " << startId << " to " << endId << "\n";
832  #endif
833 
834  trackHasChanged();
835 
836  if (startId < 0)
837  startId += trackPoints_.size();
838  if (endId < 0)
839  endId += trackPoints_.size();
840  endId += 1;
841 
842  assert (endId >= startId);
843 
844  for (std::vector<TrackPoint*>::const_iterator pointIt = trackPoints_.begin() + startId; pointIt != trackPoints_.begin() + endId; ++pointIt) {
845  if (rep != NULL) {
846  if ((*pointIt)->hasFitterInfo(rep))
847  (*pointIt)->getFitterInfo(rep)->deleteMeasurementInfo();
848  }
849  else {
850  std::vector<AbsFitterInfo*> fitterInfos = (*pointIt)->getFitterInfos();
851  for (std::vector<AbsFitterInfo*>::const_iterator fitterInfoIt = fitterInfos.begin(); fitterInfoIt != fitterInfos.end(); ++fitterInfoIt) {
852  (*fitterInfoIt)->deleteMeasurementInfo();
853  }
854  }
855  }
856 }
857 
858 void Track::deleteFitterInfo(int startId, int endId, const AbsTrackRep* rep) {
859 
860  #ifdef DEBUG
861  debugOut << "Track::deleteFitterInfo from position " << startId << " to " << endId << "\n";
862  #endif
863 
864  trackHasChanged();
865 
866  if (startId < 0)
867  startId += trackPoints_.size();
868  if (endId < 0)
869  endId += trackPoints_.size();
870  endId += 1;
871 
872  assert (endId >= startId);
873 
874  for (std::vector<TrackPoint*>::const_iterator pointIt = trackPoints_.begin() + startId; pointIt != trackPoints_.begin() + endId; ++pointIt) {
875  if (rep != NULL) {
876  if ((*pointIt)->hasFitterInfo(rep))
877  (*pointIt)->deleteFitterInfo(rep);
878  }
879  else {
880  for (std::vector<AbsTrackRep*>::const_iterator repIt = trackReps_.begin(); repIt != trackReps_.end(); ++repIt) {
881  if ((*pointIt)->hasFitterInfo(*repIt))
882  (*pointIt)->deleteFitterInfo(*repIt);
883  }
884  }
885  }
886 }
887 
888 
889 double Track::getTrackLen(AbsTrackRep* rep, int startId, int endId) const {
890 
891  if (startId < 0)
892  startId += trackPoints_.size();
893  if (endId < 0)
894  endId += trackPoints_.size();
895 
896  bool backwards(false);
897  if (startId > endId) {
898  double temp = startId;
899  startId = endId;
900  endId = temp;
901  backwards = true;
902  }
903 
904  endId += 1;
905 
906  if (rep == NULL)
907  rep = getCardinalRep();
908 
909  double trackLen(0);
910  StateOnPlane state;
911 
912  for (std::vector<TrackPoint*>::const_iterator pointIt = trackPoints_.begin() + startId; pointIt != trackPoints_.begin() + endId; ++pointIt) {
913  if (! (*pointIt)->hasFitterInfo(rep)) {
914  Exception e("Track::getTracklength: trackPoint has no fitterInfo", __LINE__,__FILE__);
915  throw e;
916  }
917 
918  if (pointIt != trackPoints_.begin() + startId) {
919  trackLen += rep->extrapolateToPlane(state, (*pointIt)->getFitterInfo(rep)->getPlane());
920  }
921 
922  state = (*pointIt)->getFitterInfo(rep)->getFittedState();
923  }
924 
925  if (backwards)
926  trackLen *= -1.;
927 
928  return trackLen;
929 }
930 
931 
933  TrackCand* cand = new TrackCand();
934 
936  cand->setCovSeed(covSeed_);
937  cand->setMcTrackId(mcTrackId_);
938 
939  for (unsigned int i = 0; i < trackPointsWithMeasurement_.size(); ++i) {
941  const std::vector< AbsMeasurement* >& measurements = tp->getRawMeasurements();
942 
943  for (unsigned int j = 0; j < measurements.size(); ++j) {
944  const AbsMeasurement* m = measurements[j];
945  TrackCandHit* tch;
946 
947  int planeId = -1;
948  if (dynamic_cast<const PlanarMeasurement*>(m)) {
949  planeId = static_cast<const PlanarMeasurement*>(m)->getPlaneId();
950  }
951 
952  if (m->isLeftRightMeasurement()) {
953  tch = new WireTrackCandHit(m->getDetId(), m->getHitId(), planeId,
955  }
956  else {
957  tch = new TrackCandHit(m->getDetId(), m->getHitId(), planeId,
958  tp->getSortingParameter());
959  }
960  cand->addHit(tch);
961  }
962  }
963 
964  return cand;
965 }
966 
967 
968 double Track::getTOF(AbsTrackRep* rep, int startId, int endId) const {
969 
970  if (startId < 0)
971  startId += trackPoints_.size();
972  if (endId < 0)
973  endId += trackPoints_.size();
974 
975  if (startId > endId) {
976  std::swap(startId, endId);
977  }
978 
979  endId += 1;
980 
981  if (rep == NULL)
982  rep = getCardinalRep();
983 
984  StateOnPlane state;
985 
986  const TrackPoint* startPoint(trackPoints_[startId]);
987  const TrackPoint* endPoint(trackPoints_[endId]);
988 
989  if (!startPoint->hasFitterInfo(rep)
990  || !endPoint->hasFitterInfo(rep)) {
991  Exception e("Track::getTOF: trackPoint has no fitterInfo", __LINE__,__FILE__);
992  throw e;
993  }
994 
995  double tof = (rep->getTime(endPoint->getFitterInfo(rep)->getFittedState())
996  - rep->getTime(startPoint->getFitterInfo(rep)->getFittedState()));
997  return tof;
998 }
999 
1000 
1001 void Track::fixWeights(AbsTrackRep* rep, int startId, int endId) {
1002 
1003  if (startId < 0)
1004  startId += trackPoints_.size();
1005  if (endId < 0)
1006  endId += trackPoints_.size();
1007 
1008  assert(startId >= 0);
1009  assert(startId <= endId);
1010  assert(endId <= (int)trackPoints_.size());
1011 
1012  std::vector< AbsFitterInfo* > fis;
1013 
1014  for (std::vector<TrackPoint*>::iterator tp = trackPoints_.begin() + startId; tp != trackPoints_.begin() + endId; ++tp) {
1015  fis.clear();
1016  if (rep == NULL) {
1017  fis = (*tp)->getFitterInfos();
1018  }
1019  else if ((*tp)->hasFitterInfo(rep)) {
1020  fis.push_back((*tp)->getFitterInfo(rep));
1021  }
1022 
1023  for (std::vector< AbsFitterInfo* >::iterator fi = fis.begin(); fi != fis.end(); ++fi) {
1024  KalmanFitterInfo* kfi = dynamic_cast<KalmanFitterInfo*>(*fi);
1025  if (kfi == NULL)
1026  continue;
1027 
1028  kfi->fixWeights();
1029  }
1030  }
1031 }
1032 
1033 
1034 void Track::prune(const Option_t* option) {
1035 
1036  PruneFlags f;
1037  f.setFlags(option);
1038 
1039  for (std::map< const AbsTrackRep*, FitStatus* >::const_iterator it=fitStatuses_.begin(); it!=fitStatuses_.end(); ++it) {
1040  it->second->getPruneFlags().setFlags(option);
1041  }
1042 
1043  // prune trackPoints
1044  if (f.hasFlags("F") || f.hasFlags("L")) {
1045  TrackPoint* firstPoint = getPointWithFitterInfo(0);
1046  TrackPoint* lastPoint = getPointWithFitterInfo(-1);
1047  for (unsigned int i = 0; i<trackPoints_.size(); ++i) {
1048  if (trackPoints_[i] == firstPoint && f.hasFlags("F"))
1049  continue;
1050 
1051  if (trackPoints_[i] == lastPoint && f.hasFlags("L"))
1052  continue;
1053 
1054  delete trackPoints_[i];
1055  trackPoints_.erase(trackPoints_.begin()+i);
1056  --i;
1057  }
1058  }
1059 
1060  // prune TrackReps
1061  if (f.hasFlags("C")) {
1062  for (unsigned int i = 0; i < trackReps_.size(); ++i) {
1063  if (i != cardinalRep_) {
1064  deleteTrackRep(i);
1065  --i;
1066  }
1067  }
1068  }
1069 
1070 
1071  // from remaining trackPoints: prune measurementsOnPlane, unneeded fitterInfoStuff
1072  for (unsigned int i = 0; i<trackPoints_.size(); ++i) {
1073  if (f.hasFlags("W"))
1074  trackPoints_[i]->deleteRawMeasurements();
1075 
1076  std::vector< AbsFitterInfo* > fis = trackPoints_[i]->getFitterInfos();
1077  for (unsigned int j = 0; j<fis.size(); ++j) {
1078 
1079  if (i == 0 && f.hasFlags("FLI"))
1080  fis[j]->deleteForwardInfo();
1081  else if (i == trackPoints_.size()-1 && f.hasFlags("FLI"))
1082  fis[j]->deleteBackwardInfo();
1083  else if (f.hasFlags("FI"))
1084  fis[j]->deleteForwardInfo();
1085  else if (f.hasFlags("LI"))
1086  fis[j]->deleteBackwardInfo();
1087 
1088  if (f.hasFlags("U") && dynamic_cast<KalmanFitterInfo*>(fis[j]) != NULL) {
1089  static_cast<KalmanFitterInfo*>(fis[j])->deletePredictions();
1090  }
1091 
1092  // also delete reference info if points have been removed since it is invalid then!
1093  if (f.hasFlags("R") or f.hasFlags("F") or f.hasFlags("L"))
1094  fis[j]->deleteReferenceInfo();
1095  if (f.hasFlags("M"))
1096  fis[j]->deleteMeasurementInfo();
1097  }
1098  }
1099 
1101 
1102  #ifdef DEBUG
1103  debugOut << "pruned Track: "; Print();
1104  #endif
1105 
1106 }
1107 
1108 
1109 void Track::Print(const Option_t* option) const {
1110  TString opt = option;
1111  opt.ToUpper();
1112  if (opt.Contains("C")) { // compact
1113 
1114  printOut << "\n ";
1115  for (unsigned int i=0; i<trackPoints_.size(); ++i) {
1116 
1117  int color = 32*(size_t)(trackPoints_[i]) % 15;
1118  switch (color) {
1119  case 0:
1120  printOut<<"\033[1;30m";
1121  break;
1122  case 1:
1123  printOut<<"\033[0;34m";
1124  break;
1125  case 2:
1126  printOut<<"\033[1;34m";
1127  break;
1128  case 3:
1129  printOut<<"\033[0;32m";
1130  break;
1131  case 4:
1132  printOut<<"\033[1;32m";
1133  break;
1134  case 5:
1135  printOut<<"\033[0;36m";
1136  break;
1137  case 6:
1138  printOut<<"\033[1;36m";
1139  break;
1140  case 7:
1141  printOut<<"\033[0;31m";
1142  break;
1143  case 8:
1144  printOut<<"\033[1;31m";
1145  break;
1146  case 9:
1147  printOut<<"\033[0;35m";
1148  break;
1149  case 10:
1150  printOut<<"\033[1;35m";
1151  break;
1152  case 11:
1153  printOut<<"\033[0;33m";
1154  break;
1155  case 12:
1156  printOut<<"\033[1;33m";
1157  break;
1158  case 13:
1159  printOut<<"\033[0;37m";
1160  break;
1161  default:
1162  ;
1163  }
1164  printOut << trackPoints_[i] << "\033[00m ";
1165  }
1166  printOut << "\n";
1167 
1168  printOut << " ";
1169  for (unsigned int i=0; i<trackPoints_.size(); ++i) {
1170  printf("% -9.3g ", trackPoints_[i]->getSortingParameter());
1171  }
1172 
1173  for (std::vector<AbsTrackRep*>::const_iterator rep = trackReps_.begin(); rep != trackReps_.end(); ++rep) {
1174  printOut << "\n" << getIdForRep(*rep) << " ";
1175  for (unsigned int i=0; i<trackPoints_.size(); ++i) {
1176  if (! trackPoints_[i]->hasFitterInfo(*rep)) {
1177  printOut << " ";
1178  continue;
1179  }
1180  AbsFitterInfo* fi = trackPoints_[i]->getFitterInfo(*rep);
1181  if (fi->hasMeasurements())
1182  printOut << "M";
1183  else
1184  printOut << " ";
1185 
1186  if (fi->hasReferenceState())
1187  printOut << "R";
1188  else
1189  printOut << " ";
1190 
1191  printOut << " ";
1192  }
1193  printOut << "\n";
1194 
1195  printOut << " -> ";
1196  for (unsigned int i=0; i<trackPoints_.size(); ++i) {
1197  if (! trackPoints_[i]->hasFitterInfo(*rep)) {
1198  printOut << " ";
1199  continue;
1200  }
1201  AbsFitterInfo* fi = trackPoints_[i]->getFitterInfo(*rep);
1202  if (fi->hasForwardPrediction())
1203  printOut << "P";
1204  else
1205  printOut << " ";
1206 
1207  if (fi->hasForwardUpdate())
1208  printOut << "U";
1209  else
1210  printOut << " ";
1211 
1212  printOut << " ";
1213  }
1214  printOut << "\n";
1215 
1216  printOut << " <- ";
1217  for (unsigned int i=0; i<trackPoints_.size(); ++i) {
1218  if (! trackPoints_[i]->hasFitterInfo(*rep)) {
1219  printOut << " ";
1220  continue;
1221  }
1222  AbsFitterInfo* fi = trackPoints_[i]->getFitterInfo(*rep);
1223  if (fi->hasBackwardPrediction())
1224  printOut << "P";
1225  else
1226  printOut << " ";
1227 
1228  if (fi->hasBackwardUpdate())
1229  printOut << "U";
1230  else
1231  printOut << " ";
1232 
1233  printOut << " ";
1234  }
1235 
1236  printOut << "\n";
1237 
1238  } //end loop over reps
1239 
1240  printOut << "\n";
1241  return;
1242  }
1243 
1244 
1245 
1246  printOut << "=======================================================================================\n";
1247  printOut << "genfit::Track, containing " << trackPoints_.size() << " TrackPoints and " << trackReps_.size() << " TrackReps.\n";
1248  printOut << " Seed state: "; stateSeed_.Print();
1249 
1250  for (unsigned int i=0; i<trackReps_.size(); ++i) {
1251  printOut << " TrackRep Nr. " << i;
1252  if (i == cardinalRep_)
1253  printOut << " (This is the cardinal rep)";
1254  printOut << "\n";
1255  trackReps_[i]->Print();
1256  }
1257 
1258  printOut << "---------------------------------------------------------------------------------------\n";
1259 
1260  for (unsigned int i=0; i<trackPoints_.size(); ++i) {
1261  printOut << "TrackPoint Nr. " << i << "\n";
1262  trackPoints_[i]->Print();
1263  printOut << "..........................................................................\n";
1264  }
1265 
1266  for (std::map< const AbsTrackRep*, FitStatus* >::const_iterator it=fitStatuses_.begin(); it!=fitStatuses_.end(); ++it) {
1267  it->second->Print();
1268  }
1269 
1270  printOut << "=======================================================================================\n";
1271 
1272 }
1273 
1274 
1276 
1277  bool retVal(true);
1278 
1279  std::map<const AbsTrackRep*, const KalmanFitterInfo*> prevFis;
1280 
1281  // check if seed is 6D
1282  if (stateSeed_.GetNrows() != 6) {
1283  errorOut << "Track::checkConsistency(): stateSeed_ dimension != 6" << std::endl;
1284  retVal = false;
1285  }
1286 
1287  if (covSeed_.GetNrows() != 6) {
1288  errorOut << "Track::checkConsistency(): covSeed_ dimension != 6" << std::endl;
1289  retVal = false;
1290  }
1291 
1292  if (covSeed_.Max() == 0.) {
1293  errorOut << "Track::checkConsistency(): Warning: covSeed_ is zero" << std::endl;
1294  //retVal = false;
1295  }
1296 
1297  // check if correct number of fitStatuses
1298  if (fitStatuses_.size() != trackReps_.size()) {
1299  errorOut << "Track::checkConsistency(): Number of fitStatuses is != number of TrackReps " << std::endl;
1300  retVal = false;
1301  }
1302 
1303  // check if cardinalRep_ is in range of trackReps_
1304  if (trackReps_.size() && cardinalRep_ >= trackReps_.size()) {
1305  errorOut << "Track::checkConsistency(): cardinalRep id " << cardinalRep_ << " out of bounds" << std::endl;
1306  retVal = false;
1307  }
1308 
1309  for (std::vector<AbsTrackRep*>::const_iterator rep = trackReps_.begin(); rep != trackReps_.end(); ++rep) {
1310  // check for NULL
1311  if ((*rep) == NULL) {
1312  errorOut << "Track::checkConsistency(): TrackRep is NULL" << std::endl;
1313  retVal = false;
1314  }
1315 
1316  // check for valid pdg code
1317  TParticlePDG* particle = TDatabasePDG::Instance()->GetParticle((*rep)->getPDG());
1318  if (particle == NULL) {
1319  errorOut << "Track::checkConsistency(): TrackRep pdg ID " << (*rep)->getPDG() << " is not valid" << std::endl;
1320  retVal = false;
1321  }
1322 
1323  // check if corresponding FitStatus is there
1324  if (fitStatuses_.find(*rep) == fitStatuses_.end() and fitStatuses_.find(*rep)->second != NULL) {
1325  errorOut << "Track::checkConsistency(): No FitStatus for Rep or FitStatus is NULL" << std::endl;
1326  retVal = false;
1327  }
1328  }
1329 
1330  // check TrackPoints
1331  for (std::vector<TrackPoint*>::const_iterator tp = trackPoints_.begin(); tp != trackPoints_.end(); ++tp) {
1332  // check for NULL
1333  if ((*tp) == NULL) {
1334  errorOut << "Track::checkConsistency(): TrackPoint is NULL" << std::endl;
1335  retVal = false;
1336  }
1337  // check if trackPoint points back to this track
1338  if ((*tp)->getTrack() != this) {
1339  errorOut << "Track::checkConsistency(): TrackPoint does not point back to this track" << std::endl;
1340  retVal = false;
1341  }
1342 
1343  // check rawMeasurements
1344  const std::vector<AbsMeasurement*>& rawMeasurements = (*tp)->getRawMeasurements();
1345  for (std::vector<AbsMeasurement*>::const_iterator m = rawMeasurements.begin(); m != rawMeasurements.end(); ++m) {
1346  // check for NULL
1347  if ((*m) == NULL) {
1348  errorOut << "Track::checkConsistency(): Measurement is NULL" << std::endl;
1349  retVal = false;
1350  }
1351  // check if measurement points back to TrackPoint
1352  if ((*m)->getTrackPoint() != *tp) {
1353  errorOut << "Track::checkConsistency(): Measurement does not point back to correct TrackPoint" << std::endl;
1354  retVal = false;
1355  }
1356  }
1357 
1358  // check fitterInfos
1359  std::vector<AbsFitterInfo*> fitterInfos = (*tp)->getFitterInfos();
1360  for (std::vector<AbsFitterInfo*>::const_iterator fi = fitterInfos.begin(); fi != fitterInfos.end(); ++fi) {
1361  // check for NULL
1362  if ((*fi) == NULL) {
1363  errorOut << "Track::checkConsistency(): FitterInfo is NULL. TrackPoint: " << *tp << std::endl;
1364  retVal = false;
1365  }
1366 
1367  // check if fitterInfos point to valid TrackReps in trackReps_
1368  int mycount (0);
1369  for (std::vector<AbsTrackRep*>::const_iterator rep = trackReps_.begin(); rep != trackReps_.end(); ++rep) {
1370  if ( (*rep) == (*fi)->getRep() ) {
1371  ++mycount;
1372  }
1373  }
1374  if (mycount == 0) {
1375  errorOut << "Track::checkConsistency(): fitterInfo points to TrackRep which is not in Track" << std::endl;
1376  retVal = false;
1377  }
1378 
1379  if (!( (*fi)->checkConsistency(&(this->getFitStatus((*fi)->getRep())->getPruneFlags())) ) ) {
1380  errorOut << "Track::checkConsistency(): FitterInfo not consistent. TrackPoint: " << *tp << std::endl;
1381  retVal = false;
1382  }
1383 
1384  if (dynamic_cast<KalmanFitterInfo*>(*fi) != NULL) {
1385  if (prevFis[(*fi)->getRep()] != NULL &&
1386  static_cast<KalmanFitterInfo*>(*fi)->hasReferenceState() &&
1387  prevFis[(*fi)->getRep()]->hasReferenceState() ) {
1388  double len = static_cast<KalmanFitterInfo*>(*fi)->getReferenceState()->getForwardSegmentLength();
1389  double prevLen = prevFis[(*fi)->getRep()]->getReferenceState()->getBackwardSegmentLength();
1390  if (fabs(prevLen + len) > 1E-10 ) {
1391  errorOut << "Track::checkConsistency(): segment lengths of reference states for rep " << (*fi)->getRep() << " (id " << getIdForRep((*fi)->getRep()) << ") at TrackPoint " << (*tp) << " don't match" << std::endl;
1392  errorOut << prevLen << " + " << len << " = " << prevLen + len << std::endl;
1393  errorOut << "TrackPoint " << *tp << ", FitterInfo " << *fi << ", rep " << getIdForRep((*fi)->getRep()) << std::endl;
1394  retVal = false;
1395  }
1396  }
1397 
1398  prevFis[(*fi)->getRep()] = static_cast<KalmanFitterInfo*>(*fi);
1399  }
1400  else
1401  prevFis[(*fi)->getRep()] = NULL;
1402 
1403  } // end loop over FitterInfos
1404 
1405  } // end loop over TrackPoints
1406 
1407 
1408  // check trackPointsWithMeasurement_
1409  std::vector<TrackPoint*> trackPointsWithMeasurement;
1410 
1411  for (std::vector<TrackPoint*>::const_iterator it = trackPoints_.begin(); it != trackPoints_.end(); ++it) {
1412  if ((*it)->hasRawMeasurements()) {
1413  trackPointsWithMeasurement.push_back(*it);
1414  }
1415  }
1416 
1417  if (trackPointsWithMeasurement.size() != trackPointsWithMeasurement_.size()) {
1418  errorOut << "Track::checkConsistency(): trackPointsWithMeasurement_ has incorrect size" << std::endl;
1419  retVal = false;
1420  }
1421 
1422  for (unsigned int i = 0; i < trackPointsWithMeasurement.size(); ++i) {
1423  if (trackPointsWithMeasurement[i] != trackPointsWithMeasurement_[i]) {
1424  errorOut << "Track::checkConsistency(): trackPointsWithMeasurement_ is not correct" << std::endl;
1425  errorOut << "has id " << i << ", address " << trackPointsWithMeasurement_[i] << std::endl;
1426  errorOut << "should have id " << i << ", address " << trackPointsWithMeasurement[i] << std::endl;
1427  retVal = false;
1428  }
1429  }
1430 
1431  return retVal;
1432 }
1433 
1434 
1436 
1437  #ifdef DEBUG
1438  debugOut << "Track::trackHasChanged \n";
1439  #endif
1440 
1441  if (fitStatuses_.empty())
1442  return;
1443 
1444  for (std::map< const AbsTrackRep*, FitStatus* >::const_iterator it=fitStatuses_.begin(); it!=fitStatuses_.end(); ++it) {
1445  it->second->setHasTrackChanged();
1446  }
1447 }
1448 
1449 
1452  trackPointsWithMeasurement_.reserve(trackPoints_.size());
1453 
1454  for (std::vector<TrackPoint*>::const_iterator it = trackPoints_.begin(); it != trackPoints_.end(); ++it) {
1455  if ((*it)->hasRawMeasurements()) {
1456  trackPointsWithMeasurement_.push_back(*it);
1457  }
1458  }
1459 }
1460 
1461 
1462 void Track::Streamer(TBuffer &R__b)
1463 {
1464  // Stream an object of class genfit::Track.
1465  const bool streamTrackPoints = true; // debugging option
1466  //This works around a msvc bug and should be harmless on other platforms
1467  typedef ::genfit::Track thisClass;
1468  UInt_t R__s, R__c;
1469  if (R__b.IsReading()) {
1470  this->Clear();
1471  Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
1472  TObject::Streamer(R__b);
1473  {
1474  std::vector<AbsTrackRep*> &R__stl = trackReps_;
1475  R__stl.clear();
1476  TClass *R__tcl1 = TBuffer::GetClass(typeid(genfit::AbsTrackRep));
1477  if (R__tcl1==0) {
1478  Error("trackReps_ streamer","Missing the TClass object for genfit::AbsTrackRep!");
1479  return;
1480  }
1481  int R__i, R__n;
1482  R__b >> R__n;
1483  R__stl.reserve(R__n);
1484  for (R__i = 0; R__i < R__n; R__i++) {
1485  genfit::AbsTrackRep* R__t;
1486  R__b >> R__t;
1487  R__stl.push_back(R__t);
1488  }
1489  }
1490  R__b >> cardinalRep_;
1491  if (streamTrackPoints)
1492  {
1493  std::vector<TrackPoint*> &R__stl = trackPoints_;
1494  R__stl.clear();
1495  TClass *R__tcl1 = TBuffer::GetClass(typeid(genfit::TrackPoint));
1496  if (R__tcl1==0) {
1497  Error("trackPoints_ streamer","Missing the TClass object for genfit::TrackPoint!");
1498  return;
1499  }
1500  int R__i, R__n;
1501  R__b >> R__n;
1502  R__stl.reserve(R__n);
1503  for (R__i = 0; R__i < R__n; R__i++) {
1504  genfit::TrackPoint* R__t;
1505  R__t = (genfit::TrackPoint*)R__b.ReadObjectAny(R__tcl1);
1506  R__t->setTrack(this);
1507  R__t->fixupRepsForReading();
1508  R__stl.push_back(R__t);
1509  }
1510  }
1511  {
1512  std::map<const AbsTrackRep*,FitStatus*> &R__stl = fitStatuses_;
1513  R__stl.clear();
1514  TClass *R__tcl1 = TBuffer::GetClass(typeid(genfit::AbsTrackRep));
1515  if (R__tcl1==0) {
1516  Error("fitStatuses_ streamer","Missing the TClass object for genfit::AbsTrackRep!");
1517  return;
1518  }
1519  TClass *R__tcl2 = TBuffer::GetClass(typeid(genfit::FitStatus));
1520  if (R__tcl2==0) {
1521  Error("fitStatuses_ streamer","Missing the TClass object for genfit::FitStatus!");
1522  return;
1523  }
1524  int R__i, R__n;
1525  R__b >> R__n;
1526  for (R__i = 0; R__i < R__n; R__i++) {
1527  int id;
1528  R__b >> id;
1529  genfit::FitStatus* R__t2;
1530  R__t2 = (genfit::FitStatus*)R__b.ReadObjectAny(R__tcl2);
1531 
1532  R__stl[this->getTrackRep(id)] = R__t2;
1533  }
1534  }
1535  // timeSeed_ was introduced in version 3. If reading an earlier
1536  // version, default to zero.
1537  if (R__v >= 3) {
1538  R__b >> timeSeed_;
1539  } else {
1540  timeSeed_ = 0;
1541  }
1542  stateSeed_.Streamer(R__b);
1543  covSeed_.Streamer(R__b);
1544  R__b.CheckByteCount(R__s, R__c, thisClass::IsA());
1545 
1547  } else {
1548  R__c = R__b.WriteVersion(thisClass::IsA(), kTRUE);
1549  TObject::Streamer(R__b);
1550  {
1551  std::vector<AbsTrackRep*> &R__stl = trackReps_;
1552  int R__n=int(R__stl.size());
1553  R__b << R__n;
1554  if(R__n) {
1555  TClass *R__tcl1 = TBuffer::GetClass(typeid(genfit::AbsTrackRep));
1556  if (R__tcl1==0) {
1557  Error("trackReps_ streamer","Missing the TClass object for genfit::AbsTrackRep!");
1558  return;
1559  }
1560  std::vector<AbsTrackRep*>::iterator R__k;
1561  for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
1562  R__b << *R__k;
1563  }
1564  }
1565  }
1566  R__b << cardinalRep_;
1567  if (streamTrackPoints)
1568  {
1569  std::vector<TrackPoint*> &R__stl = trackPoints_;
1570  int R__n=int(R__stl.size());
1571  R__b << R__n;
1572  if(R__n) {
1573  std::vector<TrackPoint*>::iterator R__k;
1574  for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
1575  R__b << (*R__k);
1576  }
1577  }
1578  }
1579  {
1580  std::map<const AbsTrackRep*,FitStatus*> &R__stl = fitStatuses_;
1581  int R__n=int(R__stl.size());
1582  R__b << R__n;
1583  if(R__n) {
1584  TClass *R__tcl1 = TBuffer::GetClass(typeid(genfit::AbsTrackRep));
1585  if (R__tcl1==0) {
1586  Error("fitStatuses_ streamer","Missing the TClass object for genfit::AbsTrackRep!");
1587  return;
1588  }
1589  TClass *R__tcl2 = TBuffer::GetClass(typeid(genfit::FitStatus));
1590  if (R__tcl2==0) {
1591  Error("fitStatuses_ streamer","Missing the TClass object for genfit::FitStatus!");
1592  return;
1593  }
1594  std::map<const AbsTrackRep*,FitStatus*>::iterator R__k;
1595  for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
1596  int id = this->getIdForRep((*R__k).first);
1597  R__b << id;
1598  R__b << ((*R__k).second);
1599  }
1600  }
1601  }
1602  R__b << timeSeed_;
1603  stateSeed_.Streamer(R__b);
1604  covSeed_.Streamer(R__b);
1605  R__b.SetByteCount(R__c, kTRUE);
1606  }
1607 }
1608 
1609 
1610 
1611 } /* End of namespace genfit */
genfit::Track::covSeed_
TMatrixDSym covSeed_
Definition: Track.h:308
genfit::Track::trackHasChanged
void trackHasChanged()
Definition: Track.cc:1435
genfit::Track::insertMeasurement
void insertMeasurement(AbsMeasurement *measurement, int id=-1)
Creates a new TrackPoint containing the measurement, and adds it to the track.
Definition: Track.cc:508
genfit::AbsTrackRep::extrapolateToPlane
virtual double extrapolateToPlane(StateOnPlane &state, const genfit::SharedPlanePtr &plane, bool stopAtBoundary=false, bool calcJacobianNoise=false) const =0
Extrapolates the state to plane, and returns the extrapolation length and, via reference,...
genfit::Track::addTrackRep
void addTrackRep(AbsTrackRep *trackRep)
Definition: Track.cc:562
genfit::Track
Collection of TrackPoint objects, AbsTrackRep objects and FitStatus objects.
Definition: Track.h:71
genfit::Track::getPointWithMeasurementAndFitterInfo
TrackPoint * getPointWithMeasurementAndFitterInfo(int id, const AbsTrackRep *rep=NULL) const
Definition: Track.cc:228
genfit::AbsFitterInfo::getFittedState
virtual const MeasuredStateOnPlane & getFittedState(bool biased=true) const =0
genfit::Track::getKalmanFitStatus
KalmanFitStatus * getKalmanFitStatus(const AbsTrackRep *rep=NULL) const
If FitStatus is a KalmanFitStatus, return it. Otherwise return NULL.
Definition: Track.cc:336
genfit::Track::constructTrackCand
TrackCand * constructTrackCand() const
Construct a new TrackCand containing the hit IDs of the measurements.
Definition: Track.cc:932
genfit::TrackCand::addHit
void addHit(int detId, int hitId, int planeId=-1, double sortingParameter=0)
Definition: TrackCand.cc:125
genfit::TrackCand::setTime6DSeedAndPdgCode
void setTime6DSeedAndPdgCode(double time, const TVectorD &state6D, const int pdgCode)
This function works the same as set6DSeed but instead of a charge hypothesis you can set a pdg code w...
Definition: TrackCand.cc:279
genfit::KalmanFitterInfo
Collects information needed and produced by a AbsKalmanFitter implementations and is specific to one ...
Definition: KalmanFitterInfo.h:46
genfit::AbsFitterInfo::hasBackwardPrediction
virtual bool hasBackwardPrediction() const =0
genfit::Track::Print
void Print(const Option_t *="") const
Definition: Track.cc:1109
genfit::Track::deletePoint
void deletePoint(int id)
Definition: Track.cc:473
genfit::TrackCandHit
Hit object for use in TrackCand. Provides IDs and sorting parameters.
Definition: TrackCandHit.h:34
genfit::Track::udpateSeed
bool udpateSeed(int id=0, AbsTrackRep *rep=NULL, bool biased=true)
Definition: Track.cc:683
genfit::MeasuredStateOnPlane
StateOnPlane with additional covariance matrix.
Definition: MeasuredStateOnPlane.h:38
genfit::Track::reverseTrack
void reverseTrack()
Make track ready to be fitted in reverse direction.
Definition: Track.cc:730
genfit::printOut
std::ostream printOut
genfit::StateOnPlane::getCharge
double getCharge() const
Definition: StateOnPlane.h:119
genfit::AbsFitterInfo::hasForwardPrediction
virtual bool hasForwardPrediction() const =0
genfit::Exception
Exception class for error handling in GENFIT (provides storage for diagnostic information)
Definition: Exception.h:48
genfit::Track::getPointWithFitterInfo
TrackPoint * getPointWithFitterInfo(int id, const AbsTrackRep *rep=NULL) const
Definition: Track.cc:258
genfit::Track::setFitStatus
void setFitStatus(FitStatus *fitStatus, const AbsTrackRep *rep)
Definition: Track.cc:341
genfit
Defines for I/O streams used for error and debug printing.
Definition: AbsFinitePlane.cc:22
genfit::AbsFitterInfo::hasBackwardUpdate
virtual bool hasBackwardUpdate() const =0
genfit::StateOnPlane::getTime
double getTime() const
Definition: StateOnPlane.h:122
genfit::MeasurementFactory
Factory object to create AbsMeasurement objects from digitized and clustered data.
Definition: MeasurementFactory.h:51
genfit::Track::getTOF
double getTOF(AbsTrackRep *rep=NULL, int startId=0, int endId=-1) const
get time of flight in ns between to trackPoints (if NULL, for cardinal rep)
Definition: Track.cc:968
genfit::AbsMeasurement::getHitId
int getHitId() const
Definition: AbsMeasurement.h:63
genfit::Track::getTrackRep
AbsTrackRep * getTrackRep(int id) const
Definition: Track.h:130
genfit::Track::deleteFitterInfo
void deleteFitterInfo(int startId=0, int endId=-1, const AbsTrackRep *rep=NULL)
Definition: Track.cc:858
genfit::TrackCandHit::getPlaneId
int getPlaneId() const
Definition: TrackCandHit.h:50
genfit::Track::getPoint
TrackPoint * getPoint(int id) const
Definition: Track.cc:212
genfit::Track::Clear
virtual void Clear(Option_t *="")
Definition: Track.cc:184
genfit::Track::setStateSeed
void setStateSeed(const TVectorD &s)
Definition: Track.h:165
genfit::AbsMeasurement::getDetId
int getDetId() const
Definition: AbsMeasurement.h:62
genfit::Track::deleteReferenceInfo
void deleteReferenceInfo(int startId=0, int endId=-1, const AbsTrackRep *rep=NULL)
Definition: Track.cc:798
genfit::TrackPoint::setTrack
void setTrack(Track *track)
Definition: TrackPoint.h:91
genfit::Track::getFitStatus
FitStatus * getFitStatus(const AbsTrackRep *rep=NULL) const
Get FitStatus for a AbsTrackRep. Per default, return FitStatus for cardinalRep.
Definition: Track.h:152
genfit::Track::reverseTrackPoints
void reverseTrackPoints()
Flip the ordering of the TrackPoints.
Definition: Track.cc:706
genfit::Track::switchPDGSigns
void switchPDGSigns(AbsTrackRep *rep=NULL)
Switch the pdg signs of specified rep (of all reps if rep == NULL).
Definition: Track.cc:718
genfit::AbsTrackRep
Abstract base class for a track representation.
Definition: AbsTrackRep.h:66
genfit::Track::getTrackLen
double getTrackLen(AbsTrackRep *rep=NULL, int startId=0, int endId=-1) const
get TrackLength between to trackPoints (if NULL, for cardinal rep)
Definition: Track.cc:889
genfit::AbsFitterInfo::hasMeasurements
virtual bool hasMeasurements() const =0
genfit::Track::timeSeed_
double timeSeed_
Definition: Track.h:306
AbsMeasurement.h
genfit::TrackPoint::setSortingParameter
void setSortingParameter(double sortingParameter)
Definition: TrackPoint.h:111
genfit::Track::fitStatuses_
std::map< const AbsTrackRep *, FitStatus * > fitStatuses_
helper
Definition: Track.h:303
genfit::WireTrackCandHit
Hit object for use in TrackCand. Provides additional left/right parameter.
Definition: WireTrackCandHit.h:34
genfit::Track::reverseMomSeed
void reverseMomSeed()
Flip direction of momentum seed.
Definition: Track.h:231
genfit::MeasuredStateOnPlane::get6DCov
TMatrixDSym get6DCov() const
Definition: MeasuredStateOnPlane.h:66
genfit::TrackCand::getStateSeed
const TVectorD & getStateSeed() const
Returns the 6D seed state; should be in global coordinates.
Definition: TrackCand.h:134
genfit::Exception::setFatal
void setFatal(bool b=true)
Set fatal flag.
Definition: Exception.h:61
genfit::Track::prune
void prune(const Option_t *="CFLWRMIU")
Delete unneeded information from the Track.
Definition: Track.cc:1034
genfit::Track::determineCardinalRep
void determineCardinalRep()
See with which AbsTrackRep the track was fitted best (converged fit w/ smallest chi2) and set the car...
Definition: Track.cc:609
genfit::TrackCand
Track candidate – seed values and indices.
Definition: TrackCand.h:69
genfit::Track::hasFitStatus
bool hasFitStatus(const AbsTrackRep *rep=NULL) const
Check if track has a FitStatus for given AbsTrackRep. Per default, check for cardinal rep.
Definition: Track.cc:314
genfit::Track::swap
void swap(Track &other)
Definition: Track.cc:167
genfit::TrackCandHit::getSortingParameter
double getSortingParameter() const
Definition: TrackCandHit.h:51
genfit::AbsMeasurement::getLeftRightResolution
virtual int getLeftRightResolution() const
Definition: AbsMeasurement.h:67
genfit::Track::insertPoints
void insertPoints(std::vector< genfit::TrackPoint * > points, int id=-1)
Insert TrackPoints BEFORE TrackPoint with position id, if id >= 0.
Definition: Track.cc:423
genfit::TrackPoint::hasFitterInfo
bool hasFitterInfo(const AbsTrackRep *rep) const
Definition: TrackPoint.h:103
genfit::TrackCand::setMcTrackId
void setMcTrackId(int i)
Set the MCT track id, for MC simulations.
Definition: TrackCand.h:151
genfit::AbsMeasurement
Contains the measurement and covariance in raw detector coordinates.
Definition: AbsMeasurement.h:42
genfit::Track::insertPoint
void insertPoint(TrackPoint *point, int id=-1)
Insert TrackPoint BEFORE TrackPoint with position id, if id >= 0.
Definition: Track.cc:363
genfit::Track::getPointWithMeasurement
TrackPoint * getPointWithMeasurement(int id) const
Definition: Track.cc:220
genfit::AbsFitterInfo
This class collects all information needed and produced by a specific AbsFitter and is specific to on...
Definition: AbsFitterInfo.h:42
genfit::TrackPoint
Object containing AbsMeasurement and AbsFitterInfo objects.
Definition: TrackPoint.h:50
genfit::TrackPoint::getRawMeasurements
const std::vector< genfit::AbsMeasurement * > & getRawMeasurements() const
Definition: TrackPoint.h:93
genfit::AbsTrackRep::clone
virtual AbsTrackRep * clone() const =0
Clone the trackRep.
genfit::Track::fillPointsWithMeasurement
void fillPointsWithMeasurement()
Definition: Track.cc:1450
genfit::Track::mergeTrack
void mergeTrack(const Track *other, int id=-1)
Merge two tracks.
Definition: Track.cc:513
KalmanFitStatus.h
genfit::StateOnPlane
A state with arbitrary dimension defined in a DetPlane.
Definition: StateOnPlane.h:45
genfit::TrackPointComparator
Helper class for TrackPoint sorting, used in Track::sort().
Definition: Track.h:45
genfit::TrackCand::getHit
TrackCandHit * getHit(int i) const
Definition: TrackCand.cc:88
genfit::TrackPoint::hasRawMeasurements
bool hasRawMeasurements() const
Definition: TrackPoint.h:96
genfit::AbsFitterInfo::hasForwardUpdate
virtual bool hasForwardUpdate() const =0
IO.h
genfit::Track::deleteForwardInfo
void deleteForwardInfo(int startId=0, int endId=-1, const AbsTrackRep *rep=NULL)
Definition: Track.cc:738
genfit::Track::hasKalmanFitStatus
bool hasKalmanFitStatus(const AbsTrackRep *rep=NULL) const
Check if track has a KalmanFitStatus for given AbsTrackRep. Per default, check for cardinal rep.
Definition: Track.cc:325
genfit::Track::mcTrackId_
int mcTrackId_
Definition: Track.h:305
genfit::Track::getIdForRep
int getIdForRep(const AbsTrackRep *rep) const
This is used when streaming TrackPoints.
Definition: Track.cc:302
genfit::FitStatus
Class where important numbers and properties of a fit can be stored.
Definition: FitStatus.h:80
genfit::AbsTrackRep::getTime
virtual double getTime(const StateOnPlane &) const =0
Get the time corresponding to the StateOnPlane. Extrapolation.
genfit::Track::cardinalRep_
unsigned int cardinalRep_
Definition: Track.h:298
KalmanFitterInfo.h
genfit::Track::trackPoints_
std::vector< TrackPoint * > trackPoints_
Definition: Track.h:300
genfit::StateOnPlane::get6DState
TVectorD get6DState() const
Definition: StateOnPlane.h:116
genfit::Track::operator=
Track & operator=(Track)
Definition: Track.cc:152
genfit::Track::deleteBackwardInfo
void deleteBackwardInfo(int startId=0, int endId=-1, const AbsTrackRep *rep=NULL)
Definition: Track.cc:767
genfit::KalmanFitterInfo::fixWeights
void fixWeights(bool arg=true)
Definition: KalmanFitterInfo.h:102
genfit::Track::setCardinalRep
void setCardinalRep(int id)
Definition: Track.cc:595
genfit::errorOut
std::ostream errorOut
genfit::MeasurementFactory::createMany
std::vector< measurement_T * > createMany(const TrackCand &cand) const
Create a collection of Measurements.
Definition: MeasurementFactory.h:138
genfit::Track::deleteMeasurementInfo
void deleteMeasurementInfo(int startId=0, int endId=-1, const AbsTrackRep *rep=NULL)
Definition: Track.cc:828
genfit::StateOnPlane::getPlane
const SharedPlanePtr & getPlane() const
Definition: StateOnPlane.h:65
PlanarMeasurement.h
genfit::AbsFitterInfo::hasReferenceState
virtual bool hasReferenceState() const =0
Track.h
genfit::Track::checkConsistency
bool checkConsistency() const
Definition: Track.cc:1275
genfit::Track::~Track
virtual ~Track()
Definition: Track.cc:180
genfit::TrackCand::getMcTrackId
int getMcTrackId() const
Get the MCT track id, for MC simulations - default value = -1.
Definition: TrackCand.h:119
genfit::TrackCand::setCovSeed
void setCovSeed(const TMatrixDSym &cov6D)
set the covariance matrix seed (6D).
Definition: TrackCand.h:175
genfit::Track::getCardinalRep
AbsTrackRep * getCardinalRep() const
Get cardinal track representation.
Definition: Track.h:143
genfit::Track::trackPointsWithMeasurement_
std::vector< TrackPoint * > trackPointsWithMeasurement_
Definition: Track.h:301
genfit::TrackCand::getTimeSeed
double getTimeSeed() const
Get the time at which the seed state is defined.
Definition: TrackCand.h:122
genfit::Track::getFittedState
const MeasuredStateOnPlane & getFittedState(int id=0, const AbsTrackRep *rep=NULL, bool biased=true) const
Shortcut to get FittedStates.
Definition: Track.cc:288
Exception.h
genfit::Track::setTimeSeed
void setTimeSeed(double time)
Definition: Track.h:162
genfit::PruneFlags::setFlags
void setFlags(Option_t *option="")
does not reset! If a flag is already true and is not in opt, it will stay true.
Definition: FitStatus.cc:38
genfit::Track::createMeasurements
void createMeasurements(const TrackCand &trackCand, const MeasurementFactory< genfit::AbsMeasurement > &factory)
Definition: Track.cc:76
genfit::TrackCand::getCovSeed
const TMatrixDSym & getCovSeed() const
get the covariance matrix seed (6D).
Definition: TrackCand.h:131
genfit::PruneFlags::hasFlags
bool hasFlags(Option_t *option="CFLWRMIU") const
check if all the given flags are set
Definition: FitStatus.cc:53
genfit::Track::trackReps_
std::vector< AbsTrackRep * > trackReps_
Definition: Track.h:297
genfit::Track::stateSeed_
TVectorD stateSeed_
Definition: Track.h:307
genfit::AbsMeasurement::isLeftRightMeasurement
virtual bool isLeftRightMeasurement() const
If the AbsMeasurement is a wire hit, the left/right resolution will be used.
Definition: AbsMeasurement.h:66
genfit::KalmanFitStatus
FitStatus for use with AbsKalmanFitter implementations.
Definition: KalmanFitStatus.h:36
genfit::AbsTrackRep::switchPDGSign
bool switchPDGSign()
try to multiply pdg code with -1. (Switch from particle to anti-particle and vice versa).
Definition: AbsTrackRep.cc:183
genfit::Track::fixWeights
void fixWeights(AbsTrackRep *rep=NULL, int startId=0, int endId=-1)
Definition: Track.cc:1001
genfit::Track::deleteTrackRep
void deleteTrackRep(int id)
Delete a AbsTrackRep and all corresponding AbsFitterInfo objects in every TrackPoint.
Definition: Track.cc:568
genfit::Track::sort
bool sort()
Sort TrackPoint and according to their sorting parameters.
Definition: Track.cc:634
genfit::TrackPoint::getFitterInfo
AbsFitterInfo * getFitterInfo(const AbsTrackRep *rep=NULL) const
Get fitterInfo for rep. Per default, use cardinal rep.
Definition: TrackPoint.cc:169
genfit::Track::Track
Track()
Definition: Track.cc:45
WireTrackCandHit.h
genfit::Track::getNumPoints
unsigned int getNumPoints() const
Definition: Track.h:110
genfit::TrackPoint::getSortingParameter
double getSortingParameter() const
Definition: TrackPoint.h:88
genfit::TrackCand::getNHits
unsigned int getNHits() const
Definition: TrackCand.h:103
genfit::TrackPoint::fixupRepsForReading
void fixupRepsForReading()
Definition: TrackPoint.cc:319
genfit::debugOut
std::ostream debugOut
genfit::PruneFlags
Info which information has been pruned from the Track.
Definition: FitStatus.h:47
genfit::Track::setCovSeed
void setCovSeed(const TMatrixDSym &c)
Definition: Track.h:169