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 <iostream>
#include <stdexcept> // std::logic_error

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

#include "larreco/Genfit/GFDetPlane.h"

//class genf::GFAbsRecoHit;

namespace genf {

  class GFAbsTrackRep : public TObject {

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

    TMatrixT<Double_t> fState;

    TMatrixT<Double_t> fCov;

    double fChiSqu;
    unsigned int fNdf;

    int fStatusFlag;
    bool fInverted;

    TMatrixT<Double_t> fFirstState;
    TMatrixT<Double_t> fFirstCov;

    TMatrixT<Double_t> fLastState;
    TMatrixT<Double_t> 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;

    /* ! There is a default implementation in GFAbsTrackRep.cxx which just drops
     the predicted covaraiance. If your trackrep has a way to extrapolate
     without giving a correct cov (that would be faster probably), please
     overwrite it.
  */
    virtual double extrapolate(const GFDetPlane& plane, TMatrixT<Double_t>& statePred);

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

    /* ! There is an empty implementation of this method in GFAbsTrackRep.cxx,
      which will just abort with an error message. One can overwrite this
      method if one wishes to implement a track representation, which should
      have this feature. An example of an experiment in which you would not
      need this feature would be track fitting (not so much vertexing) in
      an experiment with only planar trackers like silicons or planar wire
      chambers and such. An example where you would need it, would be a TPC
      where you have to fit the track to space points, or other drift chambers
      with complicated hit topology.
   */
    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 void stepalong(double h);


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


    double extrapolate(const GFDetPlane& plane);

    unsigned int getDim() const { return fDimension; }

    virtual void Print(std::ostream& out = std::cout) const;

    const TMatrixT<Double_t>& getState() const { return fState; }
    const TMatrixT<Double_t>& 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_t>& cov);

    virtual double getCharge() const = 0;

    TVector3 getPos() { return getPos(fRefPlane); }
    TVector3 getMom() { return getMom(fRefPlane); }

    void getPosMomCov(TVector3& pos, TVector3& mom, TMatrixT<Double_t>& c)
    {
      getPosMomCov(fRefPlane, pos, mom, c);
    }

    inline TMatrixT<Double_t> getFirstState() const { return fFirstState; }
    inline TMatrixT<Double_t> getFirstCov() const { return fFirstCov; }
    inline GFDetPlane getFirstPlane() const { return fFirstPlane; }
    inline TMatrixT<Double_t> getLastState() const { return fLastState; }
    inline TMatrixT<Double_t> 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_t>& st,
                         const GFDetPlane& pl,
                         const TMatrixT<Double_t>* cov = NULL)
    {
      fState = st;
      fRefPlane = pl;
      if (cov != NULL) fCov = *cov;
    }
    inline void setCov(const TMatrixT<Double_t>& aCov) { fCov = aCov; }
    inline void setFirstState(const TMatrixT<Double_t>& aState) { fFirstState = aState; }
    inline void setFirstCov(const TMatrixT<Double_t>& aCov) { fFirstCov = aCov; }
    inline void setFirstPlane(const GFDetPlane& aPlane)
    {
      fFirstPlane = aPlane;
      ;
    }
    inline void setLastState(const TMatrixT<Double_t>& aState) { fLastState = aState; }
    inline void setLastCov(const TMatrixT<Double_t>& 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();

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

    virtual void Print(Option_t*) const
    {
      throw std::logic_error(std::string(__func__) + "::Print(Option_t*) not available");
    }

    //ClassDef(GFAbsTrackRep,3)
  };

} // namespace genf

#endif