MeasurementFactory.h

Go to the documentation of this file.

//****************************************************************************
//*                   This file is part of PandaRoot.                        *
//*                                                                          *
//*            PandaRoot is distributed under the terms of the               *
//*              GNU General Public License (GPL) version 3,                 *
//*                 copied verbatim in the file "LICENSE".                   *
//*                                                                          *
//*  Copyright (C) 2006 - 2024 FAIR GmbH and copyright holders of PandaRoot  *
//*     The copyright holders are listed in the file "COPYRIGHTHOLDERS".     *
//*               The authors are listed in the file "AUTHORS".              *
//****************************************************************************

/* 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