AbsKalmanFitter.h

Go to the documentation of this file.

/* Copyright 2013, Ludwig-Maximilians Universität München,
   Authors: Tobias Schlüter & Johannes Rauch
 
   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_AbsKalmanFitter_h
#define genfit_AbsKalmanFitter_h
 
#include "AbsFitter.h"
#include "MeasurementOnPlane.h"
#include "TrackPoint.h"
 
 
namespace genfit {
 
class KalmanFitterInfo;
 
enum eMultipleMeasurementHandling {
  weightedAverage, 
  unweightedAverage, 
  weightedClosestToReference, 
  unweightedClosestToReference, 
  weightedClosestToPrediction, 
  unweightedClosestToPrediction, 
  weightedClosestToReferenceWire, 
  unweightedClosestToReferenceWire, 
  weightedClosestToPredictionWire, 
  unweightedClosestToPredictionWire 
};

class AbsKalmanFitter : public AbsFitter {
 
 public:
 
  AbsKalmanFitter(unsigned int maxIterations = 4, double deltaPval = 1e-3, double blowUpFactor = 1e3)
    : AbsFitter(), minIterations_(2), maxIterations_(maxIterations), deltaPval_(deltaPval), relChi2Change_(0.2),
      blowUpFactor_(blowUpFactor), resetOffDiagonals_(true), blowUpMaxVal_(1.E6),
      multipleMeasurementHandling_(unweightedClosestToPredictionWire),
      maxFailedHits_(-1) {
    if (minIterations_ > maxIterations_)
      minIterations_ = maxIterations_;
  }
 
  virtual ~AbsKalmanFitter() {;}
 
  //virtual void fitTrack(Track* tr, const AbsTrackRep* rep, double& chi2, double& ndf, int direction) = 0;
 
  void getChiSquNdf(const Track* tr, const AbsTrackRep* rep, double& bChi2, double& fChi2, double& bNdf,  double& fNdf) const;
  double getChiSqu(const Track* tr, const AbsTrackRep* rep, int direction = -1) const;
  double getNdf(const Track* tr, const AbsTrackRep* rep, int direction = -1) const;
  double getRedChiSqu(const Track* tr, const AbsTrackRep* rep, int direction = -1) const;
  double getPVal(const Track* tr, const AbsTrackRep* rep, int direction = -1) const;
 
  unsigned int getMinIterations() const {return minIterations_;}
  unsigned int getMaxIterations() const {return maxIterations_;}
  double getDeltaPval() const {return deltaPval_;}
  double getRelChi2Change() const {return relChi2Change_;}
  double getBlowUpFactor() const {return blowUpFactor_;}
  bool getResetOffDiagonals() const {return resetOffDiagonals_;}
  double getBlowUpMaxVal() const {return blowUpMaxVal_;}
  eMultipleMeasurementHandling getMultipleMeasurementHandling() const {return multipleMeasurementHandling_;}
  int getMaxFailedHits() const {return maxFailedHits_;}

  virtual void setMinIterations(unsigned int n) {minIterations_ = std::max((unsigned int)1,n); if (maxIterations_ < minIterations_) maxIterations_ = minIterations_;}
  virtual void setMaxIterations(unsigned int n) {maxIterations_ = n; if (minIterations_ > maxIterations_) minIterations_ = maxIterations_;}

  void setDeltaPval(double deltaPval) {deltaPval_ = deltaPval;}

  void setRelChi2Change(double relChi2Change) {relChi2Change_ = relChi2Change;}
 
  void setBlowUpFactor(double blowUpFactor) {blowUpFactor_ = blowUpFactor;}
  void setResetOffDiagonals(bool resetOffDiagonals) {resetOffDiagonals_ = resetOffDiagonals;}

  void setBlowUpMaxVal(double blowUpMaxVal) {blowUpMaxVal_= blowUpMaxVal;}

  void setMultipleMeasurementHandling(eMultipleMeasurementHandling mmh) {multipleMeasurementHandling_ = mmh;}
 
  virtual void setMaxFailedHits(int val) {maxFailedHits_ = val;}
 
  bool isTrackPrepared(const Track* tr, const AbsTrackRep* rep) const;
  bool isTrackFitted(const Track* tr, const AbsTrackRep* rep) const;

  bool canIgnoreWeights() const;
 
 protected:

  const std::vector<MeasurementOnPlane *> getMeasurements(const KalmanFitterInfo* fi, const TrackPoint* tp, int direction) const;

  unsigned int minIterations_;

  unsigned int maxIterations_;
  double deltaPval_;
  double relChi2Change_;

  double blowUpFactor_;
  bool resetOffDiagonals_;
  double blowUpMaxVal_;

  eMultipleMeasurementHandling multipleMeasurementHandling_;

  int maxFailedHits_;
 
 public:
 
  ClassDef(AbsKalmanFitter, 2)
 
};
 
} /* End of namespace genfit */
 
#endif //genfit_AbsKalmanFitter_h