MeasurementFactory.h

/* Copyright 2008-2010, Technische Universitaet Muenchen,
   Authors: Christian Hoeppner & Sebastian Neubert & Johannes Rauch & Tobias Schlüter
 
   This file is part of GENFIT.
 
   GENFIT is free software: you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published
   by the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
   GENFIT is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Lesser General Public License for more details.
 
   You should have received a copy of the GNU Lesser General Public License
   along with GENFIT.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef genfit_MeasurementFactory_h
#define genfit_MeasurementFactory_h
 
#include "MeasurementProducer.h"
#include "TrackCand.h"
 
#include <vector>
#include <map>
 
 
namespace genfit {
 
class AbsMeasurement;
 
template <class measurement_T>
class MeasurementFactory {
 private:
  std::map<int, AbsMeasurementProducer<measurement_T>*> hitProdMap_;
 
 
 public:
  MeasurementFactory() {};
  virtual ~MeasurementFactory() { clear(); }
 
  void addProducer(int detID, AbsMeasurementProducer<measurement_T>* hitProd);
 
  void clear();
 
  measurement_T* createOne (int detID, int index, const TrackCandHit* hit) const;
 
  std::vector<measurement_T*> createMany(const TrackCand& cand) const;
 
};
 
 
template <class measurement_T>
void MeasurementFactory<measurement_T>::addProducer(int detID, AbsMeasurementProducer<measurement_T>* hitProd) {
  typename std::map<int, AbsMeasurementProducer<measurement_T>*>::iterator it = hitProdMap_.find(detID);
  if(it == hitProdMap_.end()) {
    hitProdMap_[detID] = hitProd;
  } else {
    Exception exc("MeasurementFactory: detID already in use",__LINE__,__FILE__);
    exc.setFatal();
    std::vector<double> numbers;
    numbers.push_back(detID);
    exc.setNumbers("detID",numbers);
    throw exc;
  }
}
 
template <class measurement_T>
void MeasurementFactory<measurement_T>::clear(){
  typename std::map<int, AbsMeasurementProducer<measurement_T>*>::iterator it=hitProdMap_.begin();
  while(it!=hitProdMap_.end()){
    delete it->second;
    ++it;
  }
  hitProdMap_.clear();
}
 
template <class measurement_T>
measurement_T* MeasurementFactory<measurement_T>::createOne(int detID, int index, const TrackCandHit* hit) const {
  typename std::map<int, AbsMeasurementProducer<measurement_T>*>::const_iterator it = hitProdMap_.find(detID);
 
  if(it != hitProdMap_.end()) {
    return it->second->produce(index, hit);
  } else {
    Exception exc("MeasurementFactory: no hitProducer for this detID available",__LINE__,__FILE__);
    exc.setFatal();
    std::vector<double> numbers;
    numbers.push_back(detID);
    exc.setNumbers("detID", numbers);
    throw exc;
  }
}
 
template <class measurement_T>
typename std::vector<measurement_T*> MeasurementFactory<measurement_T>::createMany(const TrackCand& cand) const {
  typename std::vector<measurement_T*> hitVec;
  unsigned int nHits=cand.getNHits();
  for(unsigned int i=0;i<nHits;i++) {
    int detID, index;
    const TrackCandHit* hit = cand.getHit(i);
    cand.getHit(i, detID, index);
    hitVec.push_back( MeasurementFactory<measurement_T>::createOne(hit->getDetId(), hit->getHitId(), hit) );
  }
  return hitVec;
}
 
 
} /* End of namespace genfit */
#endif // genfit_MeasurementFactory_h