GENFIT  Rev:NoNumberAvailable
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules
TrackPoint.cc
Go to the documentation of this file.
1 /* Copyright 2008-2009, 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 "TrackPoint.h"
23 #include "Exception.h"
24 #include "KalmanFitterInfo.h"
25 #include "IO.h"
26 
27 #include <TBuffer.h>
28 
29 namespace genfit {
30 
32  sortingParameter_(0), track_(NULL), thinScatterer_(NULL)
33 {
34  ;
35 }
36 
38  sortingParameter_(0), track_(track), thinScatterer_(NULL)
39 {
40  ;
41 }
42 
43 TrackPoint::TrackPoint(const std::vector< genfit::AbsMeasurement* >& rawMeasurements, Track* track) :
44  sortingParameter_(0), track_(track), thinScatterer_(NULL)
45 {
46  rawMeasurements_.reserve(rawMeasurements.size());
47 
48  for (std::vector<AbsMeasurement*>::const_iterator m = rawMeasurements.begin(); m != rawMeasurements.end(); ++m) {
50  }
51 }
52 
53 TrackPoint::TrackPoint(AbsMeasurement* rawMeasurement, Track* track) :
54  sortingParameter_(0), track_(track), thinScatterer_(NULL)
55 {
56  addRawMeasurement(rawMeasurement);
57 }
58 
59 
61  TObject(rhs),
62  sortingParameter_(rhs.sortingParameter_), track_(rhs.track_), thinScatterer_(NULL)
63 {
64  // clone rawMeasurements
65  for (std::vector<AbsMeasurement*>::const_iterator it = rhs.rawMeasurements_.begin(); it != rhs.rawMeasurements_.end(); ++it) {
66  AbsMeasurement* tp = (*it)->clone();
68  }
69 
70  // copy fitterInfos
71  for (std::map<const AbsTrackRep*, AbsFitterInfo* >::const_iterator it = rhs.fitterInfos_.begin(); it != rhs.fitterInfos_.end(); ++it ) {
72  AbsFitterInfo* fi = it->second->clone();
73  fi->setTrackPoint(this);
74  setFitterInfo(fi);
75  }
76 
77  if (rhs.thinScatterer_ != NULL)
78  thinScatterer_.reset(new ThinScatterer(*(rhs.thinScatterer_)));
79 }
80 
82  const std::map<const AbsTrackRep*, AbsTrackRep*>& map,
83  const std::vector<const genfit::AbsTrackRep*> * repsToIgnore) :
84  sortingParameter_(rhs.sortingParameter_), track_(rhs.track_), thinScatterer_(NULL)
85 {
86  // clone rawMeasurements
87  for (std::vector<AbsMeasurement*>::const_iterator it = rhs.rawMeasurements_.begin(); it!=rhs.rawMeasurements_.end(); ++it) {
88  AbsMeasurement* m = (*it)->clone();
90  }
91 
92  // copy fitterInfos
93  for (std::map<const AbsTrackRep*, AbsFitterInfo* >::const_iterator it = rhs.fitterInfos_.begin(); it != rhs.fitterInfos_.end(); ++it ) {
94  if (repsToIgnore != NULL) {
95  if (std::find(repsToIgnore->begin(), repsToIgnore->end(), it->first) != repsToIgnore->end())
96  continue;
97  }
98  AbsFitterInfo* fi = it->second->clone();
99  fi->setRep(map.at(it->first));
100  fi->setTrackPoint(this);
101  setFitterInfo(fi);
102  }
103 
104  if (rhs.thinScatterer_ != NULL)
105  thinScatterer_.reset(new ThinScatterer(*(rhs.thinScatterer_)));
106 }
107 
108 
110  swap(rhs);
111 
112  for (std::vector<AbsMeasurement*>::const_iterator it = rawMeasurements_.begin(); it!=rawMeasurements_.end(); ++it) {
113  (*it)->setTrackPoint(this);
114  }
115 
116  for (std::map<const AbsTrackRep*, AbsFitterInfo* >::const_iterator it = fitterInfos_.begin(); it != fitterInfos_.end(); ++it ) {
117  it->second->setTrackPoint(this);
118  }
119 
120  return *this;
121 }
122 
123 
125  std::swap(this->sortingParameter_, other.sortingParameter_);
126  std::swap(this->track_, other.track_);
127  std::swap(this->rawMeasurements_, other.rawMeasurements_);
128  std::swap(this->fitterInfos_, other.fitterInfos_);
129  this->thinScatterer_.swap(other.thinScatterer_);
130 }
131 
132 
134  // FIXME: We definitely need some smart containers or smart pointers that
135  // take care of this, but so far we haven't found a convincing
136  // option (2013-07-05).
137 
138  for (size_t i = 0; i < rawMeasurements_.size(); ++i)
139  delete rawMeasurements_[i];
140 
141  std::map< const AbsTrackRep*, AbsFitterInfo* >::iterator it;
142  for (it = fitterInfos_.begin(); it != fitterInfos_.end(); ++it)
143  delete it->second;
144 }
145 
146 
148  if (i < 0)
149  i += rawMeasurements_.size();
150 
151  return rawMeasurements_.at(i);
152 }
153 
154 
155 std::vector< AbsFitterInfo* > TrackPoint::getFitterInfos() const {
156  std::vector< AbsFitterInfo* > retVal;
157 
158  if (fitterInfos_.empty())
159  return retVal;
160 
161  for (std::map<const AbsTrackRep*, AbsFitterInfo* >::const_iterator it = fitterInfos_.begin(); it != fitterInfos_.end(); ++it ) {
162  retVal.push_back(it->second);
163  }
164 
165  return retVal;
166 }
167 
168 
170  if (!rep)
171  rep = track_->getCardinalRep();
172  std::map<const AbsTrackRep*, AbsFitterInfo*>::const_iterator it = fitterInfos_.find(rep);
173  if (it == fitterInfos_.end())
174  return NULL;
175  return fitterInfos_.at(rep);
176 }
177 
178 
180  return dynamic_cast<KalmanFitterInfo*>(getFitterInfo(rep));
181 }
182 
183 
184 
186  for (size_t i = 0; i < rawMeasurements_.size(); ++i)
187  delete rawMeasurements_[i];
188 
189  rawMeasurements_.clear();
190 }
191 
192 
194  assert (fitterInfo != NULL);
195  if (hasFitterInfo(fitterInfo->getRep()))
196  delete fitterInfos_[fitterInfo->getRep()];
197 
198  fitterInfos_[fitterInfo->getRep()] = fitterInfo;
199 }
200 
201 
202 void TrackPoint::Print(const Option_t*) const {
203  printOut << "genfit::TrackPoint, belonging to Track " << track_ << "; sorting parameter = " << sortingParameter_ << "\n";
204  printOut << "contains " << rawMeasurements_.size() << " rawMeasurements and " << getFitterInfos().size() << " fitterInfos for " << fitterInfos_.size() << " TrackReps.\n";
205 
206  for (unsigned int i=0; i<rawMeasurements_.size(); ++i) {
207  printOut << "RawMeasurement Nr. " << i << "\n";
208  rawMeasurements_[i]->Print();
209  printOut << "............\n";
210  }
211 
212  for (std::map< const AbsTrackRep*, AbsFitterInfo* >::const_iterator it = fitterInfos_.begin(); it != fitterInfos_.end(); ++it ) {
213  printOut << "FitterInfo for TrackRep " << it->first << "\n";
214  it->second->Print();
215  printOut << "............\n";
216  }
217 
218  if (thinScatterer_)
219  thinScatterer_->Print();
220 
221 }
222 
223 
224 //
225 // This is modified from the auto-generated Streamer.
226 //
227 void TrackPoint::Streamer(TBuffer &R__b)
228 {
229  // Stream an object of class genfit::TrackPoint.
230  //This works around a msvc bug and should be harmless on other platforms
231  typedef ::genfit::TrackPoint thisClass;
232  UInt_t R__s, R__c;
233  if (R__b.IsReading()) {
234  Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
235  //TObject::Streamer(R__b);
236  R__b >> sortingParameter_;
237  {
238  std::vector<genfit::AbsMeasurement*,std::allocator<genfit::AbsMeasurement*> > &R__stl = rawMeasurements_;
239  R__stl.clear();
240  TClass *R__tcl1 = TBuffer::GetClass(typeid(genfit::AbsMeasurement));
241  if (R__tcl1==0) {
242  Error("rawMeasurements_ streamer","Missing the TClass object for genfit::AbsMeasurement!");
243  return;
244  }
245  int R__i, R__n;
246  R__b >> R__n;
247  R__stl.reserve(R__n);
248  for (R__i = 0; R__i < R__n; R__i++) {
249  genfit::AbsMeasurement* R__t = 0;
250  R__b >> R__t;
251  R__stl.push_back(R__t);
252  }
253  }
254  track_ = NULL;
255  size_t nTrackReps;
256  R__b >> nTrackReps;
257  vFitterInfos_.resize(nTrackReps);
258  for (size_t i = 0; i < nTrackReps; ++i) {
259  int id;
260  R__b >> id;
261  AbsFitterInfo* p = 0;
262  R__b >> p;
263  vFitterInfos_[id] = p;
264  }
265  thinScatterer_.reset();
266  char flag;
267  R__b >> flag;
268  if (flag) {
269  genfit::ThinScatterer *scatterer = 0;
270  R__b >> scatterer;
271  thinScatterer_.reset(new ThinScatterer(*scatterer));
272  }
273  R__b.CheckByteCount(R__s, R__c, thisClass::IsA());
274 
275 
276  // Fixup ownerships.
277  for (size_t i = 0; i < rawMeasurements_.size(); ++i) {
278  rawMeasurements_[i]->setTrackPoint(this);
279  }
280  for (size_t i = 0; i < vFitterInfos_.size(); ++i) {
281  // May not have FitterInfos for all reps.
282  if (vFitterInfos_[i])
283  vFitterInfos_[i]->setTrackPoint(this);
284  }
285  } else {
286  R__c = R__b.WriteVersion(thisClass::IsA(), kTRUE);
287  //TObject::Streamer(R__b);
288  R__b << sortingParameter_;
289  {
290  std::vector<genfit::AbsMeasurement*,std::allocator<genfit::AbsMeasurement*> > &R__stl = rawMeasurements_;
291  int R__n= int(R__stl.size());
292  R__b << R__n;
293  if(R__n) {
294  std::vector<genfit::AbsMeasurement*,std::allocator<genfit::AbsMeasurement*> >::iterator R__k;
295  for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
296  R__b << (*R__k);
297  }
298  }
299  }
300  R__b << fitterInfos_.size();
301  for (std::map<const AbsTrackRep*, AbsFitterInfo*>::const_iterator it = fitterInfos_.begin();
302  it != fitterInfos_.end(); ++it)
303  {
304  int id = track_->getIdForRep(it->first);
305  R__b << id;
306  R__b << it->second;
307  }
308  if (thinScatterer_) {
309  R__b << (char)1;
310  R__b << thinScatterer_.get();
311  } else {
312  R__b << (char)0;
313  }
314  R__b.SetByteCount(R__c, kTRUE);
315  }
316 }
317 
318 
320 {
321  for (size_t i = 0; i < vFitterInfos_.size(); ++i) {
322  // The vector is filled such that i corresponds to the id of the TrackRep.
323 
324  // May not have FitterInfos for all reps.
325  if (!vFitterInfos_[i])
326  continue;
329  }
330  vFitterInfos_.clear();
331 }
332 
333 } /* End of namespace genfit */
Contains the measurement and covariance in raw detector coordinates.
AbsTrackRep * getCardinalRep() const
Get cardinal track representation.
Definition: Track.h:143
bool hasFitterInfo(const AbsTrackRep *rep) const
Definition: TrackPoint.h:103
virtual AbsFitterInfo * clone() const =0
Deep copy ctor for polymorphic class.
void Print(const Option_t *="") const
Definition: TrackPoint.cc:202
std::vector< AbsFitterInfo * > vFitterInfos_
Ownership over FitterInfos.
Definition: TrackPoint.h:149
int getIdForRep(const AbsTrackRep *rep) const
This is used when streaming TrackPoints.
Definition: Track.cc:302
void swap(TrackPoint &other)
Definition: TrackPoint.cc:124
Track * track_
Pointer to Track where TrackPoint belongs to.
Definition: TrackPoint.h:136
std::ostream printOut
AbsMeasurement * getRawMeasurement(int i=0) const
Definition: TrackPoint.cc:147
KalmanFitterInfo * getKalmanFitterInfo(const AbsTrackRep *rep=NULL) const
Helper to avoid casting.
Definition: TrackPoint.cc:179
void deleteRawMeasurements()
Definition: TrackPoint.cc:185
std::vector< AbsMeasurement * > rawMeasurements_
No ownership.
Definition: TrackPoint.h:139
AbsTrackRep * getTrackRep(int id) const
Definition: Track.h:130
Abstract base class for a track representation.
Definition: AbsTrackRep.h:66
double sortingParameter_
Definition: TrackPoint.h:133
void setTrackPoint(const TrackPoint *tp)
Definition: AbsFitterInfo.h:57
Collects information needed and produced by a AbsKalmanFitter implementations and is specific to one ...
virtual ~TrackPoint()
Definition: TrackPoint.cc:133
std::map< const AbsTrackRep *, AbsFitterInfo * > fitterInfos_
Definition: TrackPoint.h:141
virtual AbsMeasurement * clone() const =0
Deep copy ctor for polymorphic class.
Object containing AbsMeasurement and AbsFitterInfo objects.
Definition: TrackPoint.h:50
TrackPoint & operator=(TrackPoint)
Definition: TrackPoint.cc:109
void fixupRepsForReading()
Definition: TrackPoint.cc:319
std::vector< genfit::AbsFitterInfo * > getFitterInfos() const
Get list of all fitterInfos.
Definition: TrackPoint.cc:155
const AbsTrackRep * getRep() const
Definition: AbsFitterInfo.h:55
boost::scoped_ptr< ThinScatterer > thinScatterer_
Definition: TrackPoint.h:152
Collection of TrackPoint objects, AbsTrackRep objects and FitStatus objects.
Definition: Track.h:71
void addRawMeasurement(genfit::AbsMeasurement *rawMeasurement)
Takes ownership and sets this as measurement's trackPoint.
Definition: TrackPoint.h:113
Thin or thick scatterer.
Definition: ThinScatterer.h:38
AbsFitterInfo * getFitterInfo(const AbsTrackRep *rep=NULL) const
Get fitterInfo for rep. Per default, use cardinal rep.
Definition: TrackPoint.cc:169
Defines for I/O streams used for error and debug printing.
This class collects all information needed and produced by a specific AbsFitter and is specific to on...
Definition: AbsFitterInfo.h:42
void setFitterInfo(genfit::AbsFitterInfo *fitterInfo)
Takes Ownership.
Definition: TrackPoint.cc:193