TMBTrack.hpp

Go to the documentation of this file.

#ifndef TMB_TREE_TMBTRACK_HPP__
#define TMB_TREE_TMBTRACK_HPP__

#include "tmb_tree/TMBLorentzVector.hpp"

#ifndef ROOT_TRef
#include "TRef.h"
#endif

#ifndef ROOT_TRefArray
#include "TRefArray.h"
#endif

class TMBIsoTrack;
class TMBVertex;

class TMBTrack : public TMBLorentzVector {

private:

  // Persistent attributes.

  Int_t _q;                  // Charge
  Double32_t _chi2_ndof;     // Chisquare/dof.
  Double32_t _smtdedx;       // dE/dx in smt.
  Double32_t _smtededx;      // dE/dx in smt error.
  UInt_t _hitmask[3];        // hit mask.
  TRef _isotref;             // Ref. to TMBIsoTrack.

  // Magnetic field Bz.  Used for propagation.
  // Tmb_analyze fills this attribute with Bz(0,0,0).  
  // Since Bz doesn't change from event to event, this attribute will
  // compress to insignificant size.

  Double32_t _bz;

  // TRF dca track parameters.
  // Par0 and par1 are regular persistent attributes.
  // Par2-par4 redundant with the base class and are cached transiently.
  // All trf track parameters are available as methods.
  //
  // par0 = r at dca (signed).
  // par1 = z at dca.
  // par2 = phidir (phi of momentum vector).
  // par3 = tan(lambda).
  // par4 = q/pT.

  Double32_t _rdca;     // Signed radial impact parameter (TRF par0).
  Double32_t _z;        // Z at dca (TRF par1).

  //
  // TRF track parameter covariance matrix:
  // (0,0) 
  // (1,0) (1,1) 
  // (2,0) (2,1) (2,2)
  // (3,0) (3,1) (3,2) (3,3)
  // (4,0) (4,1) (4,2) (4,3) (4,4)
  //

  Double32_t _trerrs[15];

  // TRF DCA Surface parameters: (xdca, ydca).
  // Surface parameters are (0,0) by default, and are also (0,0) for
  // TMBTracks created by tmb_analyze (therefore these attributes should
  // compress to insignificant size).  Otherwise, they are regular 
  // persistent attributes which can be accessed and modified by 
  // propagation.  

  Double32_t _xdca;          // x of dca surface.
  Double32_t _ydca;          // y of dca surface.

  // Track parameters at PS.
  // Here we use straight Cartesian position and momentum rather than trf
  // track and surface parameters.

  Double32_t _x_ps;          // x at PS.
  Double32_t _y_ps;          // y at PS.
  Double32_t _z_ps;          // z at PS.
  Double32_t _px_ps;         // px at PS.
  Double32_t _py_ps;         // py at PS.
  Double32_t _pz_ps;         // pz at PS.

  // Transient attributes.

  mutable TMBVector3 _last_p;      

  mutable bool _trpars_valid;      
  mutable Double_t _trpars[5];     
  mutable bool _trpos_valid;       
  mutable Double_t _trpos[3];      

 public:

  // Constructors, destructor.

  TMBTrack();
  TMBTrack(const Double_t* trpars, const Double_t* trerrs, 
           Double_t bz,
           const UInt_t* hitmask, Double_t chi2_ndof, 
           Double_t smtdedx, Double_t smt_ededx,
           const Double_t* ps_position, const Double_t* ps_momentum,
           const Double_t* surfpars,
           const TRef& isotref=TRef());

  virtual ~TMBTrack();
  virtual void Clear(Option_t* opt);

  // Accessors.

  Int_t charge() const {return _q;}
  Double_t getChi2Ndf() const {return _chi2_ndof;}
  Double_t get_smtdedx() const {return _smtdedx;}
  Double_t getrms_smtdedx() const {return _smtededx;}
  Double_t bz() const {return _bz;}
  Double_t det_etaCFT() const; // detector eta of track for external CFT layer

  // TRF track parameters.

  const Double_t* trpars() const {fill_trpars(); return _trpars;}
  Double_t trpars(Int_t i) const {fill_trpars(); return _trpars[i];}
  Double_t rdca() const {return _rdca;}        // R at dca.
  Double_t z() const {return _z;}              // Z at dca.
  Double_t phid() const {return trpars(2);}    // Phidir
  Double_t tlm() const {return trpars(3);}     // Tan(lambda).
  Double_t qpt() const {return trpars(4);}     // q/pT.

  // TRF error matrix.

  const Double_t* trerrs() const  {return _trerrs;}
  Double_t trerrs(Int_t i) const {return _trerrs[i];}
  Double_t trerrs(Int_t i, Int_t j) const  {
    return _trerrs[i>j ? i*(i+1)/2 + j : j*(j+1)/2 + i];}

  // Surface parameters.

  Double_t xdca() const {return _xdca;}
  Double_t ydca() const {return _ydca;}

  // Track position 3-vector (x,y,z).

  const Double_t* position() const {fill_trpos(); return _trpos;}
  Double_t x() const {return position()[0];}
  Double_t y() const {return position()[1];}

  // Track Cartesian position and momentum at PS.

  const Double_t* ps_position() const {return &_x_ps;}
  const Double_t* ps_momentum() const {return &_px_ps;}

  // Hit mask.

  const UInt_t* hitmask() const {return _hitmask;}
  UInt_t hitmask(Int_t i) const {return _hitmask[i];}
  Int_t nhit() const;
  Int_t ncft() const;
  Int_t nsmt() const {return nhit() - ncft();}

  // Associated IsoTrack.

  const TMBIsoTrack* getIsoTrk() const;
  void setIsoTRef(const TRef& isotref) {_isotref=isotref;}

  // Analysis methods.

  // Propagate to new dca surface.  This method makes use of short-distance
  // approximations, including the approximation that the magnetic field is
  // constant/uniform in the z-direction.  It is intended for propagating 
  // the default dca surface to nearby vertices or the true beam position.

  void propagate(const Double_t* surfpars) {
    propagate(surfpars[0], surfpars[1]);}
  void propagate(const TMBVertex* vert);
  void propagate(Double_t dcax, Double_t dcay);

  // 2D impact parameter wrt arbitrary vertex.  
  //
  // Result is stored in length 2 array ip.
  // Error matrix is optionally in length 3 array iperr.

  void impact(const TMBVertex* vert, Double_t* ip, Double_t* iperr=0) const;
  void impact(Double_t x, Double_t y, Double_t z, Double_t* ip, 
              Double_t* iperr=0) const;

  // Non-const versions propagate track to vertex dca surface as a side 
  // effect.

  void impact(const TMBVertex* vert, Double_t* ip, Double_t* iperr=0);
  void impact(Double_t x, Double_t y, Double_t z, Double_t* ip, 
              Double_t* iperr=0);

  // Vertex constraint.
  //
  // Modify track parameters so that this track has zero impact parameter 
  // with respect to the specified vertex.  As a side effect, the track
  // is propagated to the dca surface going though the vertex.
  //
  // After calling this method, the surface parameters will be the x and y 
  // of the vertex, the z track parameter will be the z of the vertex, and
  // the radial impact parameter will be zero.
  //
  // The error of the vertex is taken into account.  The vertex error does 
  // not affect the contrained track parameters, but only the error matrix.
  // It is assumed that this track has contributed with unit weight to
  // the vertex.  This implies that the vertex errors are no larger than
  // the track errors of the first two track parameters (they could be much 
  // smaller).

  void constrain(const TMBVertex* vert);

  // This version of the constrain method assusmes zero vertex error.
  // The resultant track error matrix has zero error for the first two
  // track parameters.

  void constrain(Double_t x, Double_t y);

 private:

  // These methods are used to fill transient attributes.

  void fill_trpars() const;
  void fill_trpos() const;

  ClassDef(TMBTrack, 2);
};

#endif // TMB_TREE_TMBTRACK_HPP__

---