GFAbsTrackRep.h

Go to the documentation of this file.

/* 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=NULL, const TMatrixT<double>* aux=NULL){
    fState=st;
    fRefPlane=pl;
    if(cov!=NULL) fCov=*cov;
    if(aux!=NULL) {;}
  }
  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 NULL;
  }

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


  ClassDef(GFAbsTrackRep,3)

};

#endif