22 #include "Exception.h"
24 #include "KalmanFitterInfo.h"
25 #include "KalmanFitStatus.h"
26 #include "PlanarMeasurement.h"
27 #include "AbsMeasurement.h"
29 #include "WireTrackCandHit.h"
34 #include <TDatabasePDG.h>
46 cardinalRep_(0), fitStatuses_(), mcTrackId_(-1), timeSeed_(0), stateSeed_(6), covSeed_(6)
53 cardinalRep_(0), fitStatuses_(), stateSeed_(6), covSeed_(6)
59 createMeasurements(trackCand, factory);
69 fillPointsWithMeasurement();
78 std::vector <AbsMeasurement*> factoryHits = factory.
createMany(trackCand);
80 if (factoryHits.size() != trackCand.getNHits()) {
81 Exception exc(
"Track::Track ==> factoryHits.size() != trackCand->getNHits()",__LINE__,__FILE__);
87 for (
unsigned int i=0; i<factoryHits.size(); ++i){
88 TrackPoint* tp =
new TrackPoint(factoryHits[i],
this);
89 tp->setSortingParameter(trackCand.getHit(i)->getSortingParameter());
95 Track::Track(AbsTrackRep* trackRep,
const TVectorD& stateSeed) :
96 cardinalRep_(0), fitStatuses_(), mcTrackId_(-1), timeSeed_(0), stateSeed_(stateSeed),
97 covSeed_(TMatrixDSym::kUnit, TMatrixDSym(6))
99 addTrackRep(trackRep);
103 Track::Track(AbsTrackRep* trackRep,
const TVector3& posSeed,
const TVector3& momSeed) :
104 cardinalRep_(0), fitStatuses_(), mcTrackId_(-1), timeSeed_(0), stateSeed_(6),
105 covSeed_(TMatrixDSym::kUnit, TMatrixDSym(6))
107 addTrackRep(trackRep);
108 setStateSeed(posSeed, momSeed);
112 Track::Track(AbsTrackRep* trackRep,
const TVectorD& stateSeed,
const TMatrixDSym& covSeed) :
113 cardinalRep_(0), fitStatuses_(), mcTrackId_(-1), timeSeed_(0), stateSeed_(stateSeed),
116 addTrackRep(trackRep);
120 Track::Track(
const Track& rhs) :
122 cardinalRep_(rhs.cardinalRep_), mcTrackId_(rhs.mcTrackId_), timeSeed_(rhs.timeSeed_),
123 stateSeed_(rhs.stateSeed_), covSeed_(rhs.covSeed_)
125 rhs.checkConsistency();
127 std::map<const AbsTrackRep*, AbsTrackRep*> oldRepNewRep;
129 for (std::vector<AbsTrackRep*>::const_iterator it=rhs.trackReps_.begin(); it!=rhs.trackReps_.end(); ++it) {
130 AbsTrackRep* newRep = (*it)->clone();
132 oldRepNewRep[(*it)] = newRep;
135 trackPoints_.reserve(rhs.trackPoints_.size());
136 for (std::vector<TrackPoint*>::const_iterator it=rhs.trackPoints_.begin(); it!=rhs.trackPoints_.end(); ++it) {
137 trackPoints_.push_back(
new TrackPoint(**it, oldRepNewRep));
138 trackPoints_.back()->setTrack(
this);
141 for (std::map< const AbsTrackRep*, FitStatus* >::const_iterator it=rhs.fitStatuses_.begin(); it!=rhs.fitStatuses_.end(); ++it) {
142 setFitStatus(it->second->clone(), oldRepNewRep[it->first]);
145 fillPointsWithMeasurement();
150 Track& Track::operator=(Track other) {
153 for (std::vector<TrackPoint*>::const_iterator it=trackPoints_.begin(); it!=trackPoints_.end(); ++it) {
154 trackPoints_.back()->setTrack(
this);
157 fillPointsWithMeasurement();
164 void Track::swap(Track& other) {
165 std::swap(this->trackReps_, other.trackReps_);
166 std::swap(this->cardinalRep_, other.cardinalRep_);
167 std::swap(this->trackPoints_, other.trackPoints_);
168 std::swap(this->trackPointsWithMeasurement_, other.trackPointsWithMeasurement_);
170 std::swap(this->
mcTrackId_, other.mcTrackId_);
171 std::swap(this->timeSeed_, other.timeSeed_);
172 std::swap(this->stateSeed_, other.stateSeed_);
173 std::swap(this->covSeed_, other.covSeed_);
181 void Track::Clear(Option_t*)
185 for (
size_t i = 0; i < trackPoints_.size(); ++i)
186 delete trackPoints_[i];
188 trackPoints_.clear();
189 trackPointsWithMeasurement_.clear();
195 for (
size_t i = 0; i < trackReps_.size(); ++i)
196 delete trackReps_[i];
209 TrackPoint* Track::getPoint(
int id)
const {
211 id += trackPoints_.size();
213 return trackPoints_.at(
id);
217 TrackPoint* Track::getPointWithMeasurement(
int id)
const {
219 id += trackPointsWithMeasurement_.size();
221 return trackPointsWithMeasurement_.at(
id);
225 TrackPoint* Track::getPointWithMeasurementAndFitterInfo(
int id,
const AbsTrackRep* rep)
const {
231 for (std::vector<TrackPoint*>::const_iterator it = trackPointsWithMeasurement_.begin(); it != trackPointsWithMeasurement_.end(); ++it) {
232 if ((*it)->hasFitterInfo(rep)) {
241 for (std::vector<TrackPoint*>::const_reverse_iterator it = trackPointsWithMeasurement_.rbegin(); it != trackPointsWithMeasurement_.rend(); ++it) {
242 if ((*it)->hasFitterInfo(rep)) {
255 TrackPoint* Track::getPointWithFitterInfo(
int id,
const AbsTrackRep* rep)
const {
261 for (std::vector<TrackPoint*>::const_iterator it = trackPoints_.begin(); it != trackPoints_.end(); ++it) {
262 if ((*it)->hasFitterInfo(rep)) {
271 for (std::vector<TrackPoint*>::const_reverse_iterator it = trackPoints_.rbegin(); it != trackPoints_.rend(); ++it) {
272 if ((*it)->hasFitterInfo(rep)) {
289 TrackPoint* point = getPointWithFitterInfo(
id, rep);
290 if (point ==
nullptr) {
291 Exception exc(
"Track::getFittedState ==> no trackPoint with fitterInfo for rep",__LINE__,__FILE__);
301 for (
size_t i = 0; i < trackReps_.size(); ++i)
302 if (trackReps_[i] == rep)
305 Exception exc(
"Track::getIdForRep ==> cannot find TrackRep in Track",__LINE__,__FILE__);
346 void Track::setStateSeed(
const TVector3& pos,
const TVector3& mom) {
347 stateSeed_.ResizeTo(6);
349 stateSeed_(0) = pos.X();
350 stateSeed_(1) = pos.Y();
351 stateSeed_(2) = pos.Z();
353 stateSeed_(3) = mom.X();
354 stateSeed_(4) = mom.Y();
355 stateSeed_(5) = mom.Z();
362 point->setTrack(
this);
365 debugOut <<
"Track::insertPoint at position " <<
id <<
"\n";
367 assert(point!=
nullptr);
370 point->setTrack(
this);
372 if (trackPoints_.size() == 0) {
373 trackPoints_.push_back(point);
375 if (point->hasRawMeasurements())
376 trackPointsWithMeasurement_.push_back(point);
381 if (
id == -1 ||
id == (
int)trackPoints_.size()) {
382 trackPoints_.push_back(point);
384 if (point->hasRawMeasurements())
385 trackPointsWithMeasurement_.push_back(point);
387 deleteReferenceInfo(std::max(0, (
int)trackPoints_.size()-2), (
int)trackPoints_.size()-1);
390 if (point->hasRawMeasurements()) {
391 deleteForwardInfo(-1, -1);
392 deleteBackwardInfo(0, -2);
399 assert(
id < (ssize_t)trackPoints_.size() || -
id-1 <= (ssize_t)trackPoints_.size());
402 id += trackPoints_.size() + 1;
405 trackPoints_.insert(trackPoints_.begin() +
id, point);
408 if (point->hasRawMeasurements()) {
409 deleteForwardInfo(
id, -1);
410 deleteBackwardInfo(0,
id);
414 deleteReferenceInfo(std::max(0,
id-1), std::min((
int)trackPoints_.size()-1,
id+1));
416 fillPointsWithMeasurement();
422 int nBefore = getNumPoints();
423 int n = points.size();
432 for (std::vector<TrackPoint*>::iterator p = points.begin(); p != points.end(); ++p)
433 (*p)->setTrack(
this);
435 if (
id == -1 ||
id == (
int)trackPoints_.size()) {
436 trackPoints_.insert(trackPoints_.end(), points.begin(), points.end());
438 deleteReferenceInfo(std::max(0, nBefore-1), nBefore);
440 deleteForwardInfo(nBefore, -1);
441 deleteBackwardInfo(0, std::max(0, nBefore-1));
443 fillPointsWithMeasurement();
449 assert(
id < (ssize_t)trackPoints_.size() || -
id-1 <= (ssize_t)trackPoints_.size());
452 id += trackPoints_.size() + 1;
456 trackPoints_.insert(trackPoints_.begin() +
id, points.begin(), points.end());
459 deleteForwardInfo(
id, -1);
460 deleteBackwardInfo(0,
id+n);
463 deleteReferenceInfo(std::max(0,
id-1), std::min((
int)trackPoints_.size()-1,
id));
464 deleteReferenceInfo(std::max(0,
id+n-1), std::min((
int)trackPoints_.size()-1,
id+n));
466 fillPointsWithMeasurement();
470 void Track::deletePoint(
int id) {
473 debugOut <<
"Track::deletePoint at position " <<
id <<
"\n";
479 id += trackPoints_.size();
484 if (trackPoints_[
id]->hasRawMeasurements()) {
485 deleteForwardInfo(
id, -1);
486 deleteBackwardInfo(0,
id-1);
490 deleteReferenceInfo(std::max(0,
id-1), std::min((
int)trackPoints_.size()-1,
id+1));
493 std::vector<TrackPoint*>::iterator it = std::find(trackPointsWithMeasurement_.begin(), trackPointsWithMeasurement_.end(), trackPoints_[
id]);
494 if (it != trackPointsWithMeasurement_.end())
495 trackPointsWithMeasurement_.erase(it);
497 delete trackPoints_[id];
498 trackPoints_.erase(trackPoints_.begin()+
id);
500 fillPointsWithMeasurement();
516 for (
const auto& trackPoint : trackPoints_) {
517 if(trackPoint->hasFitterInfo(rep)) {
518 trackPoint->deleteFitterInfo(rep);
530 if (other->getNumPoints() == 0)
533 std::map<const AbsTrackRep*, AbsTrackRep*> otherRepThisRep;
534 std::vector<const AbsTrackRep*> otherRepsToRemove;
536 for (std::vector<AbsTrackRep*>::const_iterator otherRep=other->trackReps_.begin(); otherRep!=other->trackReps_.end(); ++otherRep) {
538 for (std::vector<AbsTrackRep*>::const_iterator thisRep=trackReps_.begin(); thisRep!=trackReps_.end(); ++thisRep) {
539 if ((*thisRep)->isSame(*otherRep)) {
540 otherRepThisRep[*otherRep] = *thisRep;
542 debugOut <<
" map other rep " << *otherRep <<
" to " << (*thisRep) <<
"\n";
545 Exception exc(
"Track::mergeTrack ==> more than one matching rep.",__LINE__,__FILE__);
554 otherRepsToRemove.push_back(*otherRep);
556 debugOut <<
" remove other rep " << *otherRep <<
"\n";
562 std::vector<TrackPoint*> points;
563 points.reserve(other->getNumPoints());
565 for (std::vector<TrackPoint*>::const_iterator otherTp=other->trackPoints_.begin(); otherTp!=other->trackPoints_.end(); ++otherTp) {
566 points.push_back(
new TrackPoint(**otherTp, otherRepThisRep, &otherRepsToRemove));
574 trackReps_.push_back(trackRep);
581 id += trackReps_.size();
586 if (
int(cardinalRep_) ==
id)
588 else if (
int(cardinalRep_) >
id)
592 for (std::vector<TrackPoint*>::const_iterator pointIt = trackPoints_.begin(); pointIt != trackPoints_.end(); ++pointIt) {
593 (*pointIt)->deleteFitterInfo(rep);
602 trackReps_.erase(trackReps_.begin()+
id);
606 void Track::setCardinalRep(
int id) {
609 id += trackReps_.size();
611 if (
id >= 0 && (
unsigned int)
id < trackReps_.size())
615 errorOut <<
"Track::setCardinalRep: Attempted to set cardinalRep_ to a value out of bounds. Resetting cardinalRep_ to 0." << std::endl;
624 if (trackReps_.size() <= 1)
627 double minChi2(9.E99);
630 for (std::map< const AbsTrackRep*, FitStatus* >::const_iterator it =
fitStatuses_.begin(); it !=
fitStatuses_.end(); ++it) {
631 if (it->second->isFitConverged()) {
632 if (it->second->getChi2() < minChi2) {
633 minChi2 = it->second->getChi2();
639 if (bestRep !=
nullptr) {
650 int nPoints(trackPoints_.size());
652 std::vector<TrackPoint*> pointsBefore(trackPoints_);
658 int equalUntil(-1), equalFrom(nPoints);
659 for (
int i = 0; i<nPoints; ++i) {
660 if (pointsBefore[i] == trackPoints_[i])
666 if (equalUntil == nPoints-1)
672 for (
int i = nPoints-1; i>equalUntil; --i) {
673 if (pointsBefore[i] == trackPoints_[i])
680 debugOut <<
"Track::sort. Equal up to (including) hit " << equalUntil <<
" and from (including) hit " << equalFrom <<
" \n";
683 deleteForwardInfo(equalUntil+1, -1);
684 deleteBackwardInfo(0, equalFrom-1);
686 deleteReferenceInfo(std::max(0, equalUntil+1), std::min((
int)trackPoints_.size()-1, equalFrom-1));
688 fillPointsWithMeasurement();
697 setTimeSeed(fittedState.getTime());
698 setStateSeed(fittedState.get6DState());
699 setCovSeed(fittedState.get6DCov());
701 double fittedCharge = fittedState.getCharge();
703 for (
unsigned int i = 0; i<trackReps_.size(); ++i) {
704 if (trackReps_[i]->getPDGCharge() * fittedCharge < 0) {
705 trackReps_[i]->switchPDGSign();
719 std::reverse(trackPoints_.begin(),trackPoints_.end());
721 deleteForwardInfo(0, -1);
722 deleteBackwardInfo(0, -1);
723 deleteReferenceInfo(0, -1);
725 fillPointsWithMeasurement();
730 if (rep !=
nullptr) {
735 for (
unsigned int i = 0; i<trackReps_.size(); ++i) {
736 trackReps_[i]->switchPDGSign();
749 void Track::deleteForwardInfo(
int startId,
int endId,
const AbsTrackRep* rep) {
751 debugOut <<
"Track::deleteForwardInfo from position " << startId <<
" to " << endId <<
"\n";
757 startId += trackPoints_.size();
759 endId += trackPoints_.size();
762 assert (endId >= startId);
764 for (std::vector<TrackPoint*>::const_iterator pointIt = trackPoints_.begin() + startId; pointIt != trackPoints_.begin() + endId; ++pointIt) {
765 if (rep !=
nullptr) {
766 if ((*pointIt)->hasFitterInfo(rep))
767 (*pointIt)->getFitterInfo(rep)->deleteForwardInfo();
770 const std::vector<AbsFitterInfo*> fitterInfos = (*pointIt)->getFitterInfos();
771 for (std::vector<AbsFitterInfo*>::const_iterator fitterInfoIt = fitterInfos.begin(); fitterInfoIt != fitterInfos.end(); ++fitterInfoIt) {
772 (*fitterInfoIt)->deleteForwardInfo();
778 void Track::deleteBackwardInfo(
int startId,
int endId,
const AbsTrackRep* rep) {
781 debugOut <<
"Track::deleteBackwardInfo from position " << startId <<
" to " << endId <<
"\n";
787 startId += trackPoints_.size();
789 endId += trackPoints_.size();
792 assert (endId >= startId);
795 for (std::vector<TrackPoint*>::const_iterator pointIt = trackPoints_.begin() + startId; pointIt != trackPoints_.begin() + endId; ++pointIt) {
796 if (rep !=
nullptr) {
797 if ((*pointIt)->hasFitterInfo(rep))
798 (*pointIt)->getFitterInfo(rep)->deleteBackwardInfo();
801 const std::vector<AbsFitterInfo*> fitterInfos = (*pointIt)->getFitterInfos();
802 for (std::vector<AbsFitterInfo*>::const_iterator fitterInfoIt = fitterInfos.begin(); fitterInfoIt != fitterInfos.end(); ++fitterInfoIt) {
803 (*fitterInfoIt)->deleteBackwardInfo();
809 void Track::deleteReferenceInfo(
int startId,
int endId,
const AbsTrackRep* rep) {
812 debugOut <<
"Track::deleteReferenceInfo from position " << startId <<
" to " << endId <<
"\n";
818 startId += trackPoints_.size();
820 endId += trackPoints_.size();
823 assert (endId >= startId);
825 for (std::vector<TrackPoint*>::const_iterator pointIt = trackPoints_.begin() + startId; pointIt != trackPoints_.begin() + endId; ++pointIt) {
826 if (rep !=
nullptr) {
827 if ((*pointIt)->hasFitterInfo(rep))
828 (*pointIt)->getFitterInfo(rep)->deleteReferenceInfo();
831 std::vector<AbsFitterInfo*> fitterInfos = (*pointIt)->getFitterInfos();
832 for (std::vector<AbsFitterInfo*>::const_iterator fitterInfoIt = fitterInfos.begin(); fitterInfoIt != fitterInfos.end(); ++fitterInfoIt) {
833 (*fitterInfoIt)->deleteReferenceInfo();
839 void Track::deleteMeasurementInfo(
int startId,
int endId,
const AbsTrackRep* rep) {
842 debugOut <<
"Track::deleteMeasurementInfo from position " << startId <<
" to " << endId <<
"\n";
848 startId += trackPoints_.size();
850 endId += trackPoints_.size();
853 assert (endId >= startId);
855 for (std::vector<TrackPoint*>::const_iterator pointIt = trackPoints_.begin() + startId; pointIt != trackPoints_.begin() + endId; ++pointIt) {
856 if (rep !=
nullptr) {
857 if ((*pointIt)->hasFitterInfo(rep))
858 (*pointIt)->getFitterInfo(rep)->deleteMeasurementInfo();
861 std::vector<AbsFitterInfo*> fitterInfos = (*pointIt)->getFitterInfos();
862 for (std::vector<AbsFitterInfo*>::const_iterator fitterInfoIt = fitterInfos.begin(); fitterInfoIt != fitterInfos.end(); ++fitterInfoIt) {
863 (*fitterInfoIt)->deleteMeasurementInfo();
869 void Track::deleteFitterInfo(
int startId,
int endId,
const AbsTrackRep* rep) {
872 debugOut <<
"Track::deleteFitterInfo from position " << startId <<
" to " << endId <<
"\n";
878 startId += trackPoints_.size();
880 endId += trackPoints_.size();
883 assert (endId >= startId);
885 for (std::vector<TrackPoint*>::const_iterator pointIt = trackPoints_.begin() + startId; pointIt != trackPoints_.begin() + endId; ++pointIt) {
886 if (rep !=
nullptr) {
887 if ((*pointIt)->hasFitterInfo(rep))
888 (*pointIt)->deleteFitterInfo(rep);
891 for (std::vector<AbsTrackRep*>::const_iterator repIt = trackReps_.begin(); repIt != trackReps_.end(); ++repIt) {
892 if ((*pointIt)->hasFitterInfo(*repIt))
893 (*pointIt)->deleteFitterInfo(*repIt);
903 startId += trackPoints_.size();
905 endId += trackPoints_.size();
907 bool backwards(
false);
908 if (startId > endId) {
909 double temp = startId;
923 for (std::vector<TrackPoint*>::const_iterator pointIt = trackPoints_.begin() + startId; pointIt != trackPoints_.begin() + endId; ++pointIt) {
924 if (! (*pointIt)->hasFitterInfo(rep)) {
925 Exception e(
"Track::getTracklength: trackPoint has no fitterInfo", __LINE__,__FILE__);
929 if (pointIt != trackPoints_.begin() + startId) {
930 trackLen += rep->
extrapolateToPlane(state, (*pointIt)->getFitterInfo(rep)->getPlane());
933 state = (*pointIt)->getFitterInfo(rep)->getFittedState();
950 for (
unsigned int i = 0; i < trackPointsWithMeasurement_.size(); ++i) {
951 const TrackPoint* tp = trackPointsWithMeasurement_[i];
952 const std::vector< AbsMeasurement* >& measurements = tp->getRawMeasurements();
954 for (
unsigned int j = 0; j < measurements.size(); ++j) {
963 if (m->isLeftRightMeasurement()) {
965 tp->getSortingParameter(), m->getLeftRightResolution());
968 tch =
new TrackCandHit(m->getDetId(), m->getHitId(), planeId,
969 tp->getSortingParameter());
982 startId += trackPoints_.size();
984 endId += trackPoints_.size();
986 if (startId > endId) {
987 std::swap(startId, endId);
997 const TrackPoint* startPoint(trackPoints_[startId]);
998 const TrackPoint* endPoint(trackPoints_[endId]);
1000 if (!startPoint->hasFitterInfo(rep)
1001 || !endPoint->hasFitterInfo(rep)) {
1002 Exception e(
"Track::getTOF: trackPoint has no fitterInfo", __LINE__,__FILE__);
1015 startId += trackPoints_.size();
1017 endId += trackPoints_.size();
1019 assert(startId >= 0);
1020 assert(startId <= endId);
1021 assert(endId <= (
int)trackPoints_.size());
1023 std::vector< AbsFitterInfo* > fis;
1025 for (std::vector<TrackPoint*>::iterator tp = trackPoints_.begin() + startId; tp != trackPoints_.begin() + endId; ++tp) {
1027 if (rep ==
nullptr) {
1028 fis = (*tp)->getFitterInfos();
1030 else if ((*tp)->hasFitterInfo(rep)) {
1031 fis.push_back((*tp)->getFitterInfo(rep));
1034 for (std::vector< AbsFitterInfo* >::iterator fi = fis.begin(); fi != fis.end(); ++fi) {
1050 for (std::map< const AbsTrackRep*, FitStatus* >::const_iterator it=
fitStatuses_.begin(); it!=
fitStatuses_.end(); ++it) {
1051 it->second->getPruneFlags().setFlags(option);
1055 if (f.hasFlags(
"F") || f.hasFlags(
"L")) {
1056 TrackPoint* firstPoint = getPointWithFitterInfo(0);
1057 TrackPoint* lastPoint = getPointWithFitterInfo(-1);
1058 for (
unsigned int i = 0; i<trackPoints_.size(); ++i) {
1059 if (trackPoints_[i] == firstPoint && f.hasFlags(
"F"))
1062 if (trackPoints_[i] == lastPoint && f.hasFlags(
"L"))
1065 delete trackPoints_[i];
1066 trackPoints_.erase(trackPoints_.begin()+i);
1072 if (f.hasFlags(
"C")) {
1073 for (
unsigned int i = 0; i < trackReps_.size(); ++i) {
1074 if (i != cardinalRep_) {
1083 for (
unsigned int i = 0; i<trackPoints_.size(); ++i) {
1084 if (f.hasFlags(
"W"))
1085 trackPoints_[i]->deleteRawMeasurements();
1087 std::vector< AbsFitterInfo* > fis = trackPoints_[i]->getFitterInfos();
1088 for (
unsigned int j = 0; j<fis.size(); ++j) {
1090 if (i == 0 && f.hasFlags(
"FLI"))
1091 fis[j]->deleteForwardInfo();
1092 else if (i == trackPoints_.size()-1 && f.hasFlags(
"FLI"))
1093 fis[j]->deleteBackwardInfo();
1094 else if (f.hasFlags(
"FI"))
1095 fis[j]->deleteForwardInfo();
1096 else if (f.hasFlags(
"LI"))
1097 fis[j]->deleteBackwardInfo();
1099 if (f.hasFlags(
"U") &&
dynamic_cast<KalmanFitterInfo*
>(fis[j]) !=
nullptr) {
1104 if (f.hasFlags(
"R") or f.hasFlags(
"F") or f.hasFlags(
"L"))
1105 fis[j]->deleteReferenceInfo();
1106 if (f.hasFlags(
"M"))
1107 fis[j]->deleteMeasurementInfo();
1111 fillPointsWithMeasurement();
1114 debugOut <<
"pruned Track: "; Print();
1120 void Track::Print(
const Option_t* option)
const {
1121 TString opt = option;
1123 if (opt.Contains(
"C")) {
1126 for (
unsigned int i=0; i<trackPoints_.size(); ++i) {
1128 int color = 32*(size_t)(trackPoints_[i]) % 15;
1175 printOut << trackPoints_[i] <<
"\033[00m ";
1180 for (
unsigned int i=0; i<trackPoints_.size(); ++i) {
1181 printf(
"% -9.3g ", trackPoints_[i]->getSortingParameter());
1184 for (std::vector<AbsTrackRep*>::const_iterator rep = trackReps_.begin(); rep != trackReps_.end(); ++rep) {
1186 for (
unsigned int i=0; i<trackPoints_.size(); ++i) {
1187 if (! trackPoints_[i]->hasFitterInfo(*rep)) {
1191 AbsFitterInfo*
fi = trackPoints_[i]->getFitterInfo(*rep);
1192 if (
fi->hasMeasurements())
1197 if (
fi->hasReferenceState())
1207 for (
unsigned int i=0; i<trackPoints_.size(); ++i) {
1208 if (! trackPoints_[i]->hasFitterInfo(*rep)) {
1212 AbsFitterInfo*
fi = trackPoints_[i]->getFitterInfo(*rep);
1213 if (
fi->hasForwardPrediction())
1218 if (
fi->hasForwardUpdate())
1228 for (
unsigned int i=0; i<trackPoints_.size(); ++i) {
1229 if (! trackPoints_[i]->hasFitterInfo(*rep)) {
1233 AbsFitterInfo*
fi = trackPoints_[i]->getFitterInfo(*rep);
1234 if (
fi->hasBackwardPrediction())
1239 if (
fi->hasBackwardUpdate())
1257 printOut <<
"=======================================================================================\n";
1258 printOut <<
"genfit::Track, containing " << trackPoints_.size() <<
" TrackPoints and " << trackReps_.size() <<
" TrackReps.\n";
1259 printOut <<
" Seed state: "; stateSeed_.Print();
1261 for (
unsigned int i=0; i<trackReps_.size(); ++i) {
1263 if (i == cardinalRep_)
1264 printOut <<
" (This is the cardinal rep)";
1266 trackReps_[i]->Print();
1269 printOut <<
"---------------------------------------------------------------------------------------\n";
1271 for (
unsigned int i=0; i<trackPoints_.size(); ++i) {
1272 printOut <<
"TrackPoint Nr. " << i <<
"\n";
1273 trackPoints_[i]->Print();
1274 printOut <<
"..........................................................................\n";
1277 for (std::map< const AbsTrackRep*, FitStatus* >::const_iterator it=
fitStatuses_.begin(); it!=
fitStatuses_.end(); ++it) {
1278 it->second->Print();
1281 printOut <<
"=======================================================================================\n";
1286 void Track::checkConsistency()
const {
1288 bool consistent =
true;
1289 std::stringstream failures;
1291 std::map<const AbsTrackRep*, const KalmanFitterInfo*> prevFis;
1294 if (stateSeed_.GetNrows() != 6) {
1295 failures <<
"Track::checkConsistency(): stateSeed_ dimension != 6" << std::endl;
1299 if (covSeed_.GetNrows() != 6) {
1300 failures <<
"Track::checkConsistency(): covSeed_ dimension != 6" << std::endl;
1304 if (covSeed_.Max() == 0.) {
1307 failures <<
"Track::checkConsistency(): Warning: covSeed_ is zero" << std::endl;
1312 failures <<
"Track::checkConsistency(): Number of fitStatuses is != number of TrackReps " << std::endl;
1317 if (trackReps_.size() && cardinalRep_ >= trackReps_.size()) {
1318 failures <<
"Track::checkConsistency(): cardinalRep id " << cardinalRep_ <<
" out of bounds" << std::endl;
1322 for (std::vector<AbsTrackRep*>::const_iterator rep = trackReps_.begin(); rep != trackReps_.end(); ++rep) {
1324 if ((*rep) ==
nullptr) {
1325 failures <<
"Track::checkConsistency(): TrackRep is nullptr" << std::endl;
1330 TParticlePDG* particle = TDatabasePDG::Instance()->GetParticle((*rep)->getPDG());
1331 if (particle ==
nullptr) {
1332 failures <<
"Track::checkConsistency(): TrackRep pdg ID " << (*rep)->getPDG() <<
" is not valid" << std::endl;
1338 failures <<
"Track::checkConsistency(): No FitStatus for Rep or FitStatus is nullptr" << std::endl;
1344 for (std::vector<TrackPoint*>::const_iterator tp = trackPoints_.begin(); tp != trackPoints_.end(); ++tp) {
1346 if ((*tp) ==
nullptr) {
1347 failures <<
"Track::checkConsistency(): TrackPoint is nullptr" << std::endl;
1351 if ((*tp)->getTrack() !=
this) {
1352 failures <<
"Track::checkConsistency(): TrackPoint does not point back to this track" << std::endl;
1357 const std::vector<AbsMeasurement*>& rawMeasurements = (*tp)->getRawMeasurements();
1358 for (std::vector<AbsMeasurement*>::const_iterator m = rawMeasurements.begin(); m != rawMeasurements.end(); ++m) {
1360 if ((*m) ==
nullptr) {
1361 failures <<
"Track::checkConsistency(): Measurement is nullptr" << std::endl;
1365 if ((*m)->getTrackPoint() != *tp) {
1366 failures <<
"Track::checkConsistency(): Measurement does not point back to correct TrackPoint" << std::endl;
1372 std::vector<AbsFitterInfo*> fitterInfos = (*tp)->getFitterInfos();
1373 for (std::vector<AbsFitterInfo*>::const_iterator fi = fitterInfos.begin(); fi != fitterInfos.end(); ++fi) {
1375 if ((*fi) ==
nullptr) {
1376 failures <<
"Track::checkConsistency(): FitterInfo is nullptr. TrackPoint: " << *tp << std::endl;
1382 for (std::vector<AbsTrackRep*>::const_iterator rep = trackReps_.begin(); rep != trackReps_.end(); ++rep) {
1383 if ( (*rep) == (*fi)->getRep() ) {
1388 failures <<
"Track::checkConsistency(): fitterInfo points to TrackRep which is not in Track" << std::endl;
1392 if (!( (*fi)->checkConsistency(&(this->getFitStatus((*fi)->getRep())->getPruneFlags())) ) ) {
1393 failures <<
"Track::checkConsistency(): FitterInfo not consistent. TrackPoint: " << *tp << std::endl;
1397 if (
dynamic_cast<KalmanFitterInfo*
>(*fi) !=
nullptr) {
1398 if (prevFis[(*fi)->getRep()] !=
nullptr &&
1399 static_cast<KalmanFitterInfo*
>(*fi)->hasReferenceState() &&
1400 prevFis[(*fi)->getRep()]->hasReferenceState() ) {
1401 double len =
static_cast<KalmanFitterInfo*
>(*fi)->getReferenceState()->getForwardSegmentLength();
1402 double prevLen = prevFis[(*fi)->getRep()]->getReferenceState()->getBackwardSegmentLength();
1403 if (fabs(prevLen + len) > 1E-10 ) {
1404 failures <<
"Track::checkConsistency(): segment lengths of reference states for rep " << (*fi)->getRep() <<
" (id " <<
getIdForRep((*fi)->getRep()) <<
") at TrackPoint " << (*tp) <<
" don't match" << std::endl;
1405 failures << prevLen <<
" + " << len <<
" = " << prevLen + len << std::endl;
1406 failures <<
"TrackPoint " << *tp <<
", FitterInfo " << *
fi <<
", rep " <<
getIdForRep((*fi)->getRep()) << std::endl;
1411 prevFis[(*fi)->getRep()] =
static_cast<KalmanFitterInfo*
>(*fi);
1414 prevFis[(*fi)->getRep()] =
nullptr;
1422 std::vector<TrackPoint*> trackPointsWithMeasurement;
1424 for (std::vector<TrackPoint*>::const_iterator it = trackPoints_.begin(); it != trackPoints_.end(); ++it) {
1425 if ((*it)->hasRawMeasurements()) {
1426 trackPointsWithMeasurement.push_back(*it);
1430 if (trackPointsWithMeasurement.size() != trackPointsWithMeasurement_.size()) {
1431 failures <<
"Track::checkConsistency(): trackPointsWithMeasurement_ has incorrect size" << std::endl;
1435 for (
unsigned int i = 0; i < trackPointsWithMeasurement.size(); ++i) {
1436 if (trackPointsWithMeasurement[i] != trackPointsWithMeasurement_[i]) {
1437 failures <<
"Track::checkConsistency(): trackPointsWithMeasurement_ is not correct" << std::endl;
1438 failures <<
"has id " << i <<
", address " << trackPointsWithMeasurement_[i] << std::endl;
1439 failures <<
"should have id " << i <<
", address " << trackPointsWithMeasurement[i] << std::endl;
1444 if (not consistent) {
1450 void Track::trackHasChanged() {
1453 debugOut <<
"Track::trackHasChanged \n";
1459 for (std::map< const AbsTrackRep*, FitStatus* >::const_iterator it=
fitStatuses_.begin(); it!=
fitStatuses_.end(); ++it) {
1460 it->second->setHasTrackChanged();
1465 void Track::fillPointsWithMeasurement() {
1466 trackPointsWithMeasurement_.clear();
1467 trackPointsWithMeasurement_.reserve(trackPoints_.size());
1469 for (std::vector<TrackPoint*>::const_iterator it = trackPoints_.begin(); it != trackPoints_.end(); ++it) {
1470 if ((*it)->hasRawMeasurements()) {
1471 trackPointsWithMeasurement_.push_back(*it);
1477 void Track::Streamer(TBuffer &R__b)
1480 const bool streamTrackPoints =
true;
1482 typedef ::genfit::Track thisClass;
1484 if (R__b.IsReading()) {
1486 Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
if (R__v) { }
1487 TObject::Streamer(R__b);
1489 std::vector<AbsTrackRep*> &R__stl = trackReps_;
1493 Error(
"trackReps_ streamer",
"Missing the TClass object for genfit::AbsTrackRep!");
1498 R__stl.reserve(R__n);
1499 for (R__i = 0; R__i < R__n; R__i++) {
1502 R__stl.push_back(R__t);
1505 R__b >> cardinalRep_;
1506 if (streamTrackPoints)
1508 std::vector<TrackPoint*> &R__stl = trackPoints_;
1512 Error(
"trackPoints_ streamer",
"Missing the TClass object for genfit::TrackPoint!");
1517 R__stl.reserve(R__n);
1518 for (R__i = 0; R__i < R__n; R__i++) {
1521 R__t->setTrack(
this);
1523 R__stl.push_back(R__t);
1527 std::map<const AbsTrackRep*,FitStatus*> &R__stl =
fitStatuses_;
1531 Error(
"fitStatuses_ streamer",
"Missing the TClass object for genfit::AbsTrackRep!");
1536 Error(
"fitStatuses_ streamer",
"Missing the TClass object for genfit::FitStatus!");
1541 for (R__i = 0; R__i < R__n; R__i++) {
1547 R__stl[this->getTrackRep(
id)] = R__t2;
1557 stateSeed_.Streamer(R__b);
1558 covSeed_.Streamer(R__b);
1559 R__b.CheckByteCount(R__s, R__c, thisClass::IsA());
1561 fillPointsWithMeasurement();
1563 R__c = R__b.WriteVersion(thisClass::IsA(), kTRUE);
1564 TObject::Streamer(R__b);
1566 std::vector<AbsTrackRep*> &R__stl = trackReps_;
1567 int R__n=int(R__stl.size());
1572 Error(
"trackReps_ streamer",
"Missing the TClass object for genfit::AbsTrackRep!");
1575 std::vector<AbsTrackRep*>::iterator R__k;
1576 for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
1581 R__b << cardinalRep_;
1582 if (streamTrackPoints)
1584 std::vector<TrackPoint*> &R__stl = trackPoints_;
1585 int R__n=int(R__stl.size());
1588 std::vector<TrackPoint*>::iterator R__k;
1589 for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
1595 std::map<const AbsTrackRep*,FitStatus*> &R__stl =
fitStatuses_;
1596 int R__n=int(R__stl.size());
1601 Error(
"fitStatuses_ streamer",
"Missing the TClass object for genfit::AbsTrackRep!");
1606 Error(
"fitStatuses_ streamer",
"Missing the TClass object for genfit::FitStatus!");
1609 std::map<const AbsTrackRep*,FitStatus*>::iterator R__k;
1610 for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
1613 R__b << ((*R__k).second);
1618 stateSeed_.Streamer(R__b);
1619 covSeed_.Streamer(R__b);
1620 R__b.SetByteCount(R__c, kTRUE);
1625 for (
size_t i = 0; i < trackPoints_.size(); ++i)
1626 delete trackPoints_[i];
1628 trackPoints_.clear();
1629 trackPointsWithMeasurement_.clear();
1631 for (std::map< const AbsTrackRep*, FitStatus* >::iterator it =
fitStatuses_.begin(); it!=
fitStatuses_.end(); ++it)