AbsTrackRep.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 & 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 "MaterialProperties.h"

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

namespace genfit {

struct MatStep {
  MaterialProperties materialProperties_;
  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
  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