AbsKalmanFitter.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 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