DAF.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_DAF_h
#define genfit_DAF_h

#include "AbsKalmanFitter.h"

#include <vector>
#include <map>

namespace genfit {

class DAF : public AbsKalmanFitter {

 private:
  DAF(const DAF &);
  DAF &operator=(genfit::DAF const &);

 public:
  DAF(bool useRefKalman = true, double deltaWeight = 1e-3, double deltaPval = 1e-3);
  DAF(AbsKalmanFitter *kalman, double deltaWeight = 1e-3, double deltaPval = 1e-3);
  ~DAF(){};

  void processTrackWithRep(Track *tr, const AbsTrackRep *rep, bool resortHits = false);

  void setProbCut(const double prob_cut);

  void addProbCut(const double prob_cut, const int measDim);

  void setBetas(double b1, double b2 = -1, double b3 = -1., double b4 = -1., double b5 = -1., double b6 = -1., double b7 = -1., double b8 = -1., double b9 = -1., double b10 = -1.);

  const std::vector<double> &getBetas() { return betas_; }

  void setAnnealingScheme(double bStart, double bFinal, unsigned int nSteps);

  void setMaxIterations(unsigned int n)
  {
    maxIterations_ = n;
    betas_.resize(maxIterations_, betas_.back());
  }

  void setConvergenceDeltaWeight(double delta) { deltaWeight_ = delta; }

  AbsKalmanFitter *getKalman() const { return kalman_.get(); }

  virtual void setMaxFailedHits(int val) { getKalman()->setMaxFailedHits(val); }

  virtual void setDebugLvl(unsigned int lvl = 1)
  {
    AbsFitter::setDebugLvl(lvl);
    if (lvl > 1)
      getKalman()->setDebugLvl(lvl - 1);
  }

 private:
  bool calcWeights(Track *trk, const AbsTrackRep *rep, double beta);

  double deltaWeight_;        // convergence criterium
  std::vector<double> betas_; // Temperatures, NOT inverse temperatures.
  double chi2Cuts_[7];        // '7' assumes tracks are helices with one
                              // parameter, i.e. we're living in 3D space,
                              // where time may be used in the fit.  Zeroth
                              // entry is not used.
#ifndef __CINT__
  boost::scoped_ptr<AbsKalmanFitter> kalman_;
#else
  AbsKalmanFitter *kalman_;
#endif

 public:
  ClassDef(DAF, 2)
};

} /* End of namespace genfit */
#endif // genfit_DAF_h