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

   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 GFABSTRACKREP_H
#define GFABSTRACKREP_H

#include <vector>
#include <list>
#include <iostream>

#include "TMatrixT.h"
#include "TVector3.h"

#include "GFDetPlane.h"

class GFAbsRecoHit;

class GFAbsTrackRep : public TObject {

  /*----- Data members -----*/
 protected:
  unsigned int fDimension;

  TMatrixT<double> fState;

  TMatrixT<double> fCov;

  double fChiSqu;
  unsigned int fNdf;

  int fStatusFlag;
  bool fInverted;

  TMatrixT<double> fFirstState;
  TMatrixT<double> fFirstCov;

  TMatrixT<double> fLastState;
  TMatrixT<double> fLastCov;
  GFDetPlane fFirstPlane;
  GFDetPlane fLastPlane;

  // detector plane where the track parameters are given
  GFDetPlane fRefPlane;

 public:
  virtual GFAbsTrackRep *clone() const = 0;

  virtual GFAbsTrackRep *prototype() const = 0;


  virtual double extrapolate(const GFDetPlane &plane, TMatrixT<double> &statePred);

 public:
  GFAbsTrackRep();
  GFAbsTrackRep(int);
  virtual ~GFAbsTrackRep();


  virtual void extrapolateToPoint(const TVector3 &point, TVector3 &poca, TVector3 &normVec);


  virtual void extrapolateToLine(const TVector3 &point1, const TVector3 &point2, TVector3 &poca, TVector3 &normVec, TVector3 &poca_onwire);


  virtual double stepalong(double h, TVector3 &point, TVector3 &dir);


  virtual double extrapolate(const GFDetPlane &plane, TMatrixT<double> &statePred, TMatrixT<double> &covPred) = 0;


  double extrapolate(const GFDetPlane &plane);

  unsigned int getDim() const { return fDimension; }

  virtual void Print() const;

  inline TMatrixT<double> getState() const { return fState; }
  inline TMatrixT<double> getCov() const { return fCov; }

  double getStateElem(int i) const { return fState(i, 0); }
  double getCovElem(int i, int j) const { return fCov(i, j); }

  virtual TVector3 getPos(const GFDetPlane &pl) = 0;
  virtual TVector3 getMom(const GFDetPlane &pl) = 0;
  virtual void getPosMom(const GFDetPlane &pl, TVector3 &pos, TVector3 &mom) = 0;


  virtual void getPosMomCov(const GFDetPlane &pl, TVector3 &pos, TVector3 &mom, TMatrixT<double> &cov);

  virtual double getCharge() const = 0;

  TVector3 getPos() { return getPos(fRefPlane); }
  TVector3 getMom() { return getMom(fRefPlane); }
  void getPosMomCov(TVector3 &pos, TVector3 &mom, TMatrixT<double> &c) { getPosMomCov(fRefPlane, pos, mom, c); }

  inline TMatrixT<double> getFirstState() const { return fFirstState; }
  inline TMatrixT<double> getFirstCov() const { return fFirstCov; }
  inline GFDetPlane getFirstPlane() const { return fFirstPlane; }
  inline TMatrixT<double> getLastState() const { return fLastState; }
  inline TMatrixT<double> getLastCov() const { return fLastCov; }
  inline GFDetPlane getLastPlane() const { return fLastPlane; }
  inline double getChiSqu() const { return fChiSqu; }
  inline double getRedChiSqu() const
  {
    if (getNDF() > 0)
      return getChiSqu() / getNDF();
    return 0;
  }
  inline unsigned int getNDF() const
  {
    if (fNdf > getDim())
      return fNdf - getDim();
    return 0;
  }
  virtual void setData(const TMatrixT<double> &st, const GFDetPlane &pl, const TMatrixT<double> *cov = nullptr, const TMatrixT<double> *aux = nullptr)
  {
    fState = st;
    fRefPlane = pl;
    if (cov != nullptr)
      fCov = *cov;
    if (aux != nullptr) {
      ;
    }
  }
  inline void setCov(const TMatrixT<double> &aCov) { fCov = aCov; }
  inline void setFirstState(const TMatrixT<double> &aState) { fFirstState = aState; }
  inline void setFirstCov(const TMatrixT<double> &aCov) { fFirstCov = aCov; }
  inline void setFirstPlane(const GFDetPlane &aPlane)
  {
    fFirstPlane = aPlane;
    ;
  }
  inline void setLastState(const TMatrixT<double> &aState) { fLastState = aState; }
  inline void setLastCov(const TMatrixT<double> &aCov) { fLastCov = aCov; }
  inline void setLastPlane(const GFDetPlane &aPlane)
  {
    fLastPlane = aPlane;
    ;
  }

  const GFDetPlane &getReferencePlane() const { return fRefPlane; }

  inline void setChiSqu(double aChiSqu) { fChiSqu = aChiSqu; }
  inline void setNDF(unsigned int n) { fNdf = n; }
  inline void addChiSqu(double aChiSqu) { fChiSqu += aChiSqu; }
  inline void addNDF(unsigned int n) { fNdf += n; }
  inline void setStatusFlag(int _val) { fStatusFlag = _val; }

  virtual void switchDirection() = 0;

  bool setInverted(bool f = true)
  {
    fInverted = f;
    return true;
  }

  inline bool getStatusFlag() { return fStatusFlag; }

  virtual void reset();

  virtual bool hasAuxInfo() { return false; }

  virtual const TMatrixT<double> *getAuxInfo(const GFDetPlane &)
  { //(const GFDetPlane& pl)
    return nullptr;
  }

 private:
  void Abort(std::string method);

  ClassDef(GFAbsTrackRep, 3)
};

#endif