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 = wireDir.Unit();
    double retval = this->extrapolateToLine(state, point1, wireDir, stopAtBoundary, calcJacobianNoise);
    poca = this->getPos(state);
    dirInPoca = this->getMom(state);
    dirInPoca = 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