core/src/TrackPoint.cc

0001 /* Copyright 2008-2009, Technische Universitaet Muenchen,
0002    Authors: Christian Hoeppner & Sebastian Neubert & Johannes Rauch
0003
0004    This file is part of GENFIT.
0005
0006    GENFIT is free software: you can redistribute it and/or modify
0007    it under the terms of the GNU Lesser General Public License as published
0008    by the Free Software Foundation, either version 3 of the License, or
0009    (at your option) any later version.
0010
0011    GENFIT is distributed in the hope that it will be useful,
0012    but WITHOUT ANY WARRANTY; without even the implied warranty of
0013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
0014    GNU Lesser General Public License for more details.
0015
0016    You should have received a copy of the GNU Lesser General Public License
0017    along with GENFIT.  If not, see <http://www.gnu.org/licenses/>.
0018 */
0019
0020 #include "Track.h"
0021
0022 #include "TrackPoint.h"
0023 #include "Exception.h"
0024 #include "KalmanFitterInfo.h"
0025 #include "IO.h"
0026
0027 #include <algorithm>
0028 #include <TBuffer.h>
0029
0030 namespace genfit {
0031
0032 TrackPoint::TrackPoint() :
0033   sortingParameter_(0), track_(nullptr), thinScatterer_(nullptr)
0034 {
0035   ;
0036 }
0037
0038 TrackPoint::TrackPoint(Track* track) :
0039   sortingParameter_(0), track_(track), thinScatterer_(nullptr)
0040 {
0041   ;
0042 }
0043
0044 TrackPoint::TrackPoint(const std::vector< genfit::AbsMeasurement* >& rawMeasurements, Track* track) :
0045   sortingParameter_(0), track_(track), thinScatterer_(nullptr)
0046 {
0047   rawMeasurements_.reserve(rawMeasurements.size());
0048
0049   for (std::vector<AbsMeasurement*>::const_iterator m = rawMeasurements.begin(); m != rawMeasurements.end(); ++m) {
0050     addRawMeasurement(*m);
0051   }
0052 }
0053
0054 TrackPoint::TrackPoint(AbsMeasurement* rawMeasurement, Track* track) :
0055   sortingParameter_(0), track_(track), thinScatterer_(nullptr)
0056 {
0057   addRawMeasurement(rawMeasurement);
0058 }
0059
0060
0061 TrackPoint::TrackPoint(const TrackPoint& rhs) :
0062   TObject(rhs),
0063   sortingParameter_(rhs.sortingParameter_), track_(rhs.track_), thinScatterer_(nullptr)
0064 {
0065   // clone rawMeasurements
0066   for (std::vector<AbsMeasurement*>::const_iterator it = rhs.rawMeasurements_.begin(); it != rhs.rawMeasurements_.end(); ++it) {
0067     AbsMeasurement* tp = (*it)->clone();
0068     addRawMeasurement(tp);
0069   }
0070
0071   // copy fitterInfos
0072   for (std::map<const AbsTrackRep*, AbsFitterInfo* >::const_iterator it = rhs.fitterInfos_.begin(); it != rhs.fitterInfos_.end();  ++it ) {
0073     AbsFitterInfo* fi = it->second->clone();
0074     fi->setTrackPoint(this);
0075     setFitterInfo(fi);
0076   }
0077
0078   if (rhs.thinScatterer_ != nullptr)
0079     thinScatterer_.reset(new ThinScatterer(*(rhs.thinScatterer_)));
0080 }
0081
0082 TrackPoint::TrackPoint(const TrackPoint& rhs,
0083     const std::map<const AbsTrackRep*, AbsTrackRep*>& map,
0084     const std::vector<const genfit::AbsTrackRep*> * repsToIgnore) :
0085   sortingParameter_(rhs.sortingParameter_), track_(rhs.track_), thinScatterer_(nullptr)
0086 {
0087   // clone rawMeasurements
0088   for (std::vector<AbsMeasurement*>::const_iterator it = rhs.rawMeasurements_.begin(); it!=rhs.rawMeasurements_.end(); ++it) {
0089     AbsMeasurement* m = (*it)->clone();
0090     addRawMeasurement(m);
0091   }
0092
0093   // copy fitterInfos
0094   for (std::map<const AbsTrackRep*, AbsFitterInfo* >::const_iterator it = rhs.fitterInfos_.begin(); it != rhs.fitterInfos_.end();  ++it ) {
0095     if (repsToIgnore != nullptr) {
0096       if (std::find(repsToIgnore->begin(), repsToIgnore->end(), it->first) != repsToIgnore->end())
0097         continue;
0098     }
0099     AbsFitterInfo* fi = it->second->clone();
0100     fi->setRep(map.at(it->first));
0101     fi->setTrackPoint(this);
0102     setFitterInfo(fi);
0103   }
0104
0105   if (rhs.thinScatterer_ != nullptr)
0106     thinScatterer_.reset(new ThinScatterer(*(rhs.thinScatterer_)));
0107 }
0108
0109
0110 TrackPoint& TrackPoint::operator=(TrackPoint rhs) {
0111   swap(rhs);
0112
0113   for (std::vector<AbsMeasurement*>::const_iterator it = rawMeasurements_.begin(); it!=rawMeasurements_.end(); ++it) {
0114     (*it)->setTrackPoint(this);
0115   }
0116
0117   for (std::map<const AbsTrackRep*, AbsFitterInfo* >::const_iterator it = fitterInfos_.begin(); it != fitterInfos_.end();  ++it ) {
0118     it->second->setTrackPoint(this);
0119   }
0120
0121   return *this;
0122 }
0123
0124
0125 void TrackPoint::swap(TrackPoint& other) {
0126   std::swap(this->sortingParameter_, other.sortingParameter_);
0127   std::swap(this->track_, other.track_);
0128   std::swap(this->rawMeasurements_, other.rawMeasurements_);
0129   std::swap(this->fitterInfos_, other.fitterInfos_);
0130   this->thinScatterer_.swap(other.thinScatterer_);
0131 }
0132
0133
0134 TrackPoint::~TrackPoint() {
0135   // FIXME: We definitely need some smart containers or smart pointers that
0136   // take care of this, but so far we haven't found a convincing
0137   // option (2013-07-05).
0138
0139   for (size_t i = 0; i < rawMeasurements_.size(); ++i)
0140     delete rawMeasurements_[i];
0141
0142   std::map< const AbsTrackRep*, AbsFitterInfo* >::iterator it;
0143   for (it = fitterInfos_.begin(); it != fitterInfos_.end(); ++it)
0144     delete it->second;
0145 }
0146
0147
0148 AbsMeasurement* TrackPoint::getRawMeasurement(int i) const {
0149   if (i < 0)
0150     i += rawMeasurements_.size();
0151
0152   return rawMeasurements_.at(i);
0153 }
0154
0155
0156 std::vector< AbsFitterInfo* > TrackPoint::getFitterInfos() const {
0157   std::vector< AbsFitterInfo* > retVal;
0158
0159   if (fitterInfos_.empty())
0160     return retVal;
0161
0162   for (std::map<const AbsTrackRep*, AbsFitterInfo* >::const_iterator it = fitterInfos_.begin(); it != fitterInfos_.end();  ++it ) {
0163     retVal.push_back(it->second);
0164   }
0165
0166   return retVal;
0167 }
0168
0169
0170 AbsFitterInfo* TrackPoint::getFitterInfo(const AbsTrackRep* rep) const {
0171   if (!rep)
0172     rep = track_->getCardinalRep();
0173   std::map<const AbsTrackRep*, AbsFitterInfo*>::const_iterator it = fitterInfos_.find(rep);
0174   if (it == fitterInfos_.end())
0175     return nullptr;
0176   return fitterInfos_.at(rep);
0177 }
0178
0179
0180 KalmanFitterInfo* TrackPoint::getKalmanFitterInfo(const AbsTrackRep* rep) const {
0181   return dynamic_cast<KalmanFitterInfo*>(getFitterInfo(rep));
0182 }
0183
0184
0185
0186 void TrackPoint::deleteRawMeasurements() {
0187   for (size_t i = 0; i < rawMeasurements_.size(); ++i)
0188     delete rawMeasurements_[i];
0189
0190   rawMeasurements_.clear();
0191 }
0192
0193
0194 void TrackPoint::setFitterInfo(genfit::AbsFitterInfo* fitterInfo) {
0195   assert (fitterInfo != nullptr);
0196   if (hasFitterInfo(fitterInfo->getRep()))
0197     delete fitterInfos_[fitterInfo->getRep()];
0198
0199   fitterInfos_[fitterInfo->getRep()] = fitterInfo;
0200 }
0201
0202
0203 void TrackPoint::Print(const Option_t*) const {
0204   printOut << "genfit::TrackPoint, belonging to Track " << track_ << "; sorting parameter = " << sortingParameter_ << "\n";
0205   printOut << "contains " << rawMeasurements_.size() << " rawMeasurements and " << getFitterInfos().size() << " fitterInfos for " << fitterInfos_.size() << " TrackReps.\n";
0206
0207   for (unsigned int i=0; i<rawMeasurements_.size(); ++i) {
0208     printOut << "RawMeasurement Nr. " << i << "\n";
0209     rawMeasurements_[i]->Print();
0210     printOut << "............\n";
0211   }
0212
0213   for (std::map< const AbsTrackRep*, AbsFitterInfo* >::const_iterator it = fitterInfos_.begin(); it != fitterInfos_.end();  ++it ) {
0214     printOut << "FitterInfo for TrackRep " << it->first << "\n";
0215     it->second->Print();
0216     printOut << "............\n";
0217   }
0218
0219   if (thinScatterer_)
0220     thinScatterer_->Print();
0221
0222 }
0223
0224
0225 //
0226 // This is modified from the auto-generated Streamer.
0227 //
0228 void TrackPoint::Streamer(TBuffer &R__b)
0229 {
0230    // Stream an object of class genfit::TrackPoint.
0231    //This works around a msvc bug and should be harmless on other platforms
0232    typedef ::genfit::TrackPoint thisClass;
0233    UInt_t R__s, R__c;
0234    if (R__b.IsReading()) {
0235       Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
0236       //TObject::Streamer(R__b);
0237       R__b >> sortingParameter_;
0238       {
0239         std::vector<genfit::AbsMeasurement*,std::allocator<genfit::AbsMeasurement*> > &R__stl =  rawMeasurements_;
0240         R__stl.clear();
0241         TClass *R__tcl1 = TBuffer::GetClass(typeid(genfit::AbsMeasurement));
0242         if (R__tcl1==0) {
0243           Error("rawMeasurements_ streamer","Missing the TClass object for genfit::AbsMeasurement!");
0244           return;
0245         }
0246         int R__i, R__n;
0247         R__b >> R__n;
0248         R__stl.reserve(R__n);
0249         for (R__i = 0; R__i < R__n; R__i++) {
0250           genfit::AbsMeasurement* R__t = 0;
0251           R__b >> R__t;
0252           R__stl.push_back(R__t);
0253         }
0254       }
0255       track_ = nullptr;
0256       size_t nTrackReps;
0257       R__b >> nTrackReps;
0258       for (size_t i = 0; i < nTrackReps; ++i)  {
0259         int id;
0260         R__b >> id;
0261         AbsFitterInfo* p = 0;
0262         R__b >> p;
0263         vFitterInfos_[id] = p;
0264       }
0265       thinScatterer_.reset();
0266       char flag;
0267       R__b >> flag;
0268       if (flag) {
0269         genfit::ThinScatterer *scatterer = 0;
0270         R__b >> scatterer;
0271         thinScatterer_.reset(new ThinScatterer(*scatterer));
0272       }
0273       R__b.CheckByteCount(R__s, R__c, thisClass::IsA());
0274
0275
0276       // Fixup ownerships.
0277       for (size_t i = 0; i < rawMeasurements_.size(); ++i) {
0278         rawMeasurements_[i]->setTrackPoint(this);
0279       }
0280       for (auto& trackRepIDWithFitterInfo : vFitterInfos_) {
0281         AbsFitterInfo* fitterInfo = trackRepIDWithFitterInfo.second;
0282         if (fitterInfo)
0283           fitterInfo->setTrackPoint(this);
0284       }
0285    } else {
0286       R__c = R__b.WriteVersion(thisClass::IsA(), kTRUE);
0287       //TObject::Streamer(R__b);
0288       R__b << sortingParameter_;
0289       {
0290         std::vector<genfit::AbsMeasurement*,std::allocator<genfit::AbsMeasurement*> > &R__stl = rawMeasurements_;
0291         int R__n= int(R__stl.size());
0292         R__b << R__n;
0293         if(R__n) {
0294           std::vector<genfit::AbsMeasurement*,std::allocator<genfit::AbsMeasurement*> >::iterator R__k;
0295           for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
0296             R__b << (*R__k);
0297           }
0298         }
0299       }
0300       R__b << fitterInfos_.size();
0301       for (std::map<const AbsTrackRep*, AbsFitterInfo*>::const_iterator it = fitterInfos_.begin();
0302           it != fitterInfos_.end(); ++it)
0303       {
0304         int id = track_->getIdForRep(it->first);
0305         R__b << id;
0306         R__b << it->second;
0307       }
0308       if (thinScatterer_) {
0309         R__b << (char)1;
0310         R__b << thinScatterer_.get();
0311       } else {
0312         R__b << (char)0;
0313       }
0314       R__b.SetByteCount(R__c, kTRUE);
0315    }
0316 }
0317
0318
0319 void TrackPoint::fixupRepsForReading()
0320 {
0321   for (auto& trackRepIDWithFitterInfo : vFitterInfos_) {
0322     // The map is filled such that i corresponds to the id of the TrackRep.
0323     const unsigned int id = trackRepIDWithFitterInfo.first;
0324     AbsFitterInfo* fitterInfo = trackRepIDWithFitterInfo.second;
0325
0326     // May not have FitterInfos for all reps.
0327     if (!fitterInfo)
0328       continue;
0329     AbsTrackRep* trackRep = track_->getTrackRep(id);
0330
0331     fitterInfos_[trackRep] = fitterInfo;
0332     fitterInfos_[trackRep]->setRep(trackRep);
0333   }
0334   vFitterInfos_.clear();
0335 }
0336
0337 } /* End of namespace genfit */