AbsTrackRep.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file AbsTrackRep.h

/* Copyright 2008-2010, Technische Universitaet Muenchen,
   Authors: Christian Hoeppner & Sebastian Neubert & 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_AbsTrackRep_h
#define genfit_AbsTrackRep_h

#include "SharedPlanePtr.h"
//#include "MaterialInfo.h"
#include "Material.h"

#include <TVector3.h>
#include <TObject.h>
#include <TVectorD.h>
#include <TMatrixD.h>
#include <TMatrixDSym.h>


namespace genfit {

struct MatStep {
  Material material_;
  double stepSize_;

  MatStep() {
    stepSize_ = 0;
  }

};

class StateOnPlane;
class MeasuredStateOnPlane;
class AbsMeasurement;

class AbsTrackRep : public TObject {

 public:

  AbsTrackRep();
  AbsTrackRep(int pdgCode, char propDir = 0);

  virtual ~AbsTrackRep() {;}

  virtual AbsTrackRep* clone() const = 0;

  virtual double extrapolateToPlane(
      StateOnPlane& state,
      const genfit::SharedPlanePtr& plane,
      bool stopAtBoundary = false,
      bool calcJacobianNoise = false) const = 0;

  virtual double extrapolateToLine(StateOnPlane& state,
      const TVector3& linePoint,
      const TVector3& lineDirection,
      bool stopAtBoundary = false,
      bool calcJacobianNoise = false) const = 0;

  virtual double extrapolateToLine(StateOnPlane& state,
      const TVector3& point1,
      const TVector3& point2,
      TVector3& poca,
      TVector3& dirInPoca,
      TVector3& poca_onwire,
      bool stopAtBoundary = false,
      bool calcJacobianNoise = false) const {
    TVector3 wireDir(point2 - point1);
    wireDir.Unit();
    double retval = this->extrapolateToLine(state, point1, wireDir, stopAtBoundary, calcJacobianNoise);
    poca = this->getPos(state);
    dirInPoca = this->getMom(state);
    dirInPoca.Unit();

    poca_onwire = point1 + wireDir*((poca - point1)*wireDir);
    
    return retval;
  }

  virtual double extrapolateToPoint(StateOnPlane& state,
      const TVector3& point,
      bool stopAtBoundary = false,
      bool calcJacobianNoise = false) const = 0;

  virtual double extrapolateToPoint(StateOnPlane& state,
      const TVector3& point,
      const TMatrixDSym& G, // weight matrix (metric)
      bool stopAtBoundary = false,
      bool calcJacobianNoise = false) const = 0;

  virtual double extrapolateToCylinder(StateOnPlane& state,
      double radius,
      const TVector3& linePoint = TVector3(0.,0.,0.),
      const TVector3& lineDirection = TVector3(0.,0.,1.),
      bool stopAtBoundary = false,
      bool calcJacobianNoise = false) const = 0;

  virtual double extrapolateToCone(StateOnPlane& state,
      double radius,
      const TVector3& linePoint = TVector3(0.,0.,0.),
      const TVector3& lineDirection = TVector3(0.,0.,1.),
      bool stopAtBoundary = false,
      bool calcJacobianNoise = false) const = 0;

  virtual double extrapolateToSphere(StateOnPlane& state,
      double radius,
      const TVector3& point = TVector3(0.,0.,0.),
      bool stopAtBoundary = false,
      bool calcJacobianNoise = false) const = 0;

  virtual double extrapolateBy(StateOnPlane& state,
      double step,
      bool stopAtBoundary = false,
      bool calcJacobianNoise = false) const = 0;

  double extrapolateToMeasurement(StateOnPlane& state,
      const AbsMeasurement* measurement,
      bool stopAtBoundary = false,
      bool calcJacobianNoise = false) const;

  virtual unsigned int getDim() const = 0;

  virtual TVector3 getPos(const StateOnPlane& state) const = 0;

  virtual TVector3 getMom(const StateOnPlane& state) const = 0;

  TVector3 getDir(const StateOnPlane& state) const {return getMom(state).Unit();}

  virtual void getPosMom(const StateOnPlane& state, TVector3& pos, TVector3& mom) const = 0;

  void getPosDir(const StateOnPlane& state, TVector3& pos, TVector3& dir) const {getPosMom(state, pos, dir); dir.SetMag(1.);}

  virtual TVectorD get6DState(const StateOnPlane& state) const;

  virtual TMatrixDSym get6DCov(const MeasuredStateOnPlane& state) const = 0;

  virtual void getPosMomCov(const MeasuredStateOnPlane& state, TVector3& pos, TVector3& mom, TMatrixDSym& cov) const = 0;

  virtual void get6DStateCov(const MeasuredStateOnPlane& state, TVectorD& stateVec, TMatrixDSym& cov) const;

  virtual double getMomMag(const StateOnPlane& state) const = 0;
  virtual double getMomVar(const MeasuredStateOnPlane& state) const = 0;

  int getPDG() const {return pdgCode_;}

  double getPDGCharge() const;

  virtual double getCharge(const StateOnPlane& state) const = 0;
  virtual double getQop(const StateOnPlane& state) const = 0;
  double getMass(const StateOnPlane& state) const;

  char getPropDir() const {return propDir_;}

  virtual void getForwardJacobianAndNoise(TMatrixD& jacobian, TMatrixDSym& noise, TVectorD& deltaState) const = 0;

  virtual void getBackwardJacobianAndNoise(TMatrixD& jacobian, TMatrixDSym& noise, TVectorD& deltaState) const = 0;

  virtual std::vector<genfit::MatStep> getSteps() const = 0;

  virtual double getRadiationLenght() const = 0;

  // should keep this up to date with the time of flight.
  virtual double getTime(const StateOnPlane&) const = 0;

  void calcJacobianNumerically(const genfit::StateOnPlane& origState,
                                   const genfit::SharedPlanePtr destPlane,
                                   TMatrixD& jacobian) const;

  bool switchPDGSign();

  virtual void setPosMom(StateOnPlane& state, const TVector3& pos, const TVector3& mom) const = 0;
  virtual void setPosMom(StateOnPlane& state, const TVectorD& state6) const = 0;
  virtual void setPosMomErr(MeasuredStateOnPlane& state, const TVector3& pos, const TVector3& mom, const TVector3& posErr, const TVector3& momErr) const = 0;
  virtual void setPosMomCov(MeasuredStateOnPlane& state, const TVector3& pos, const TVector3& mom, const TMatrixDSym& cov6x6) const = 0;
  virtual void setPosMomCov(MeasuredStateOnPlane& state, const TVectorD& state6, const TMatrixDSym& cov6x6) const = 0;

  virtual void setChargeSign(StateOnPlane& state, double charge) const = 0;
  virtual void setQop(StateOnPlane& state, double qop) const = 0;
  virtual void setTime(StateOnPlane& state, double time) const = 0;

  void setPropDir(int dir) {
    if (dir>0) propDir_ = 1;
    else if (dir<0) propDir_ = -1;
    else propDir_ = 0;
  };

  void switchPropDir(){propDir_ = -1*propDir_;}

  virtual bool isSameType(const AbsTrackRep* other) = 0;

  virtual bool isSame(const AbsTrackRep* other) = 0;

  virtual void setDebugLvl(unsigned int lvl = 1) {debugLvl_ = lvl;}

  virtual void Print(const Option_t* = "") const;

 protected:

  AbsTrackRep(const AbsTrackRep&);
  AbsTrackRep& operator=(const AbsTrackRep&);


  int pdgCode_;
  char propDir_;

  unsigned int debugLvl_;

 public:
  ClassDef(AbsTrackRep,1)

};

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