LocalTrajectoryParameters.h

Go to the documentation of this file.

#ifndef _TRACKER_LOCALTRAJECTORYPARAMETERS_H_
#define _TRACKER_LOCALTRAJECTORYPARAMETERS_H_

#include "DataFormats/GeometryVector/interface/LocalPoint.h"
#include "DataFormats/GeometryVector/interface/LocalVector.h"
#include "DataFormats/TrajectoryState/interface/TrackCharge.h"
#include "DataFormats/Math/interface/AlgebraicROOTObjects.h"

#include <cmath>

class LocalTrajectoryParameters {
public:
// construct

  LocalTrajectoryParameters() {}

  LocalTrajectoryParameters(const AlgebraicVector5& v, float aPzSign, bool charged = true) {
    theQbp  = v[0];
    theDxdz = v[1];
    theDydz = v[2];
    theX    = v[3];
    theY    = v[4];
    thePzSign = aPzSign;
    if ( charged )
      theCharge = theQbp>0 ? 1 : -1;
    else
      theCharge = 0;
  }


  LocalTrajectoryParameters(float aQbp, float aDxdz, float aDydz,
                            float aX, float aY, float aPzSign, bool charged = true) :
    theDxdz(aDxdz), theDydz(aDydz),
    theX(aX), theY(aY), thePzSign(aPzSign>0 ? 1 : -1) {
    if ( charged ) {
      theQbp = aQbp;
      theCharge = theQbp>0 ? 1 : -1;
    }
    else {
      theQbp = aQbp;
      theCharge = 0;
    }
  }

  LocalTrajectoryParameters( const LocalPoint& pos, const LocalVector& p,
                 TrackCharge charge) :
    theQbp( charge/p.mag()), theDxdz( p.x()/p.z()), theDydz( p.y()/p.z()), 
    theX( pos.x()), theY(pos.y()), thePzSign( p.z()>0. ? 1:-1), theCharge(charge) {
    if ( charge==0 )  theQbp = 1.f/p.mag();
  }

// access

  LocalPoint position() const {
    return LocalPoint(theX, theY);
  }

  LocalVector momentum() const {
    float op = std::abs(theQbp);
    if ( op<1.e-9f )  op = 1.e-9f;
    float pz = float(thePzSign)/(op*std::sqrt(1.f + theDxdz*theDxdz + theDydz*theDydz));
    float px = pz*theDxdz;
    float py = pz*theDydz;
    return LocalVector(px, py, pz);
  }

  LocalVector direction() const {
    float dz = float(thePzSign)/std::sqrt(1.f + theDxdz*theDxdz + theDydz*theDydz);
    float dx = dz*theDxdz;
    float dy = dz*theDydz;
    return LocalVector(dx, dy, dz);
  }

  LocalVector directionNotNormalized() const {
    return LocalVector(theDxdz, theDydz, 1.f);
  }


  TrackCharge charge() const {return theCharge;}

  float signedInverseMomentum() const {
    return charge()==0 ? 0.f : theQbp;
  }

  AlgebraicVector5 vector() const {
    AlgebraicVector5 v;
    v[0] = signedInverseMomentum();
    v[1] = theDxdz;
    v[2] = theDydz;
    v[3] = theX;
    v[4] = theY;
    return v;
  }

  AlgebraicVector5 mixedFormatVector() const {
    AlgebraicVector5 v;
    v[0] = theQbp;    // signed in case of charged particles, 1/p for neutrals
    v[1] = theDxdz;
    v[2] = theDydz;
    v[3] = theX;
    v[4] = theY;
    return v;
  }

  float pzSign() const {
    return thePzSign;
  }

  bool updateP(float dP) {
    float p = 1.f/std::abs(theQbp);
    if ((p += dP) <= 0.f) return false;
    float newQbp = theQbp > 0. ? 1.f/p : -1.f/p;
    theQbp = newQbp;
    return true;
  }


  float qbp() const { return theQbp;}
  float dxdz() const { return theDxdz;}
  float dydz() const { return theDydz;}
  float absdz() const { return 1.f/std::sqrt(1.f + theDxdz*theDxdz + theDydz*theDydz); }


private:
  float theQbp;    
  float theDxdz;   
  float theDydz;   
  float theX;      
  float theY;      

  short thePzSign; 

  short theCharge; 

};

#endif