ClosestApproachInRPhi Class Reference

#include <ClosestApproachInRPhi.h>

Inheritance diagram for ClosestApproachInRPhi:

Public Member Functions
bool	calculate (const TrajectoryStateOnSurface &sta, const TrajectoryStateOnSurface &stb) override
bool	calculate (const FreeTrajectoryState &sta, const FreeTrajectoryState &stb) override
ClosestApproachInRPhi *	clone () const override
	ClosestApproachInRPhi ()
GlobalPoint	crossingPoint () const override
float	distance () const override
std::pair< GlobalPoint, GlobalPoint >	points () const override
bool	status () const override
std::pair< GlobalTrajectoryParameters, GlobalTrajectoryParameters >	trajectoryParameters () const
	~ClosestApproachInRPhi () override
Public Member Functions inherited from ClosestApproachOnHelices
	ClosestApproachOnHelices ()
virtual	~ClosestApproachOnHelices ()

Private Member Functions
bool	compute (const TrackCharge &chargeA, const GlobalVector &momentumA, const GlobalPoint &positionA, const TrackCharge &chargeB, const GlobalVector &momentumB, const GlobalPoint &positionB)

Static Private Member Functions
static void	circleParameters (const TrackCharge &charge, const GlobalVector &momemtum, const GlobalPoint &position, double &xc, double &yc, double &r, double bz)
static GlobalTrajectoryParameters	newTrajectory (const GlobalPoint &newpt, const GlobalTrajectoryParameters &oldpar, double bz)
static int	transverseCoord (double cxa, double cya, double ra, double cxb, double cyb, double rb, double &xg1, double &yg1, double &xg2, double &yg2)
static double	zCoord (const GlobalVector &mom, const GlobalPoint &pos, double r, double xc, double yc, double xg, double yg)

Private Attributes
double	bz
GlobalTrajectoryParameters	paramA
GlobalTrajectoryParameters	paramB
GlobalPoint	posA
GlobalPoint	posB
bool	status_

Friends
int	test::ClosestApproachInRPhi_t::test ()

Detailed Description

Definition at line 26 of file ClosestApproachInRPhi.h.

Constructor & Destructor Documentation

ClosestApproachInRPhi()

ClosestApproachInRPhi::ClosestApproachInRPhi ( )

inline

Definition at line 30 of file ClosestApproachInRPhi.h.

References status_.

Referenced by clone().

{ status_ = false; }

~ClosestApproachInRPhi()

ClosestApproachInRPhi::~ClosestApproachInRPhi ( )

inlineoverride

Definition at line 31 of file ClosestApproachInRPhi.h.

{}

Member Function Documentation

calculate() [1/2]

bool ClosestApproachInRPhi::calculate ( const TrajectoryStateOnSurface &  sta, const TrajectoryStateOnSurface &  stb  )

overridevirtual

Implements ClosestApproachOnHelices.

Definition at line 8 of file ClosestApproachInRPhi.cc.

References TrajectoryStateOnSurface::charge(), bookConverter::compute(), TrajectoryStateOnSurface::freeState(), TrajectoryStateOnSurface::globalMomentum(), TrajectoryStateOnSurface::globalParameters(), TrajectoryStateOnSurface::globalPosition(), MagneticField::inTesla(), GlobalTrajectoryParameters::magneticField(), FreeTrajectoryState::parameters(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by BPHMonitor::analyze(), HLTMuonDimuonL3Filter::applyDiMuonSelection(), BPHPlusMinusVertex::computeApp(), V0Fitter::fitAll(), HLTDiMuonGlbTrkFilter::hltFilter(), HLTMuonTrackMassFilter::hltFilter(), HLTMuonTrimuonL3Filter::hltFilter(), and Onia2MuMuPAT::produce().

                                                                                                              {
  TrackCharge chargeA = sta.charge();
  TrackCharge chargeB = stb.charge();
  GlobalVector momentumA = sta.globalMomentum();
  GlobalVector momentumB = stb.globalMomentum();
  GlobalPoint positionA = sta.globalPosition();
  GlobalPoint positionB = stb.globalPosition();
  paramA = sta.globalParameters();
  paramB = stb.globalParameters();
  // compute magnetic field ONCE
  bz = sta.freeState()->parameters().magneticField().inTesla(positionA).z() * 2.99792458e-3;

  return compute(chargeA, momentumA, positionA, chargeB, momentumB, positionB);
}

calculate() [2/2]

bool ClosestApproachInRPhi::calculate ( const FreeTrajectoryState &  sta, const FreeTrajectoryState &  stb  )

overridevirtual

Implements ClosestApproachOnHelices.

Definition at line 23 of file ClosestApproachInRPhi.cc.

References FreeTrajectoryState::charge(), bookConverter::compute(), MagneticField::inTesla(), GlobalTrajectoryParameters::magneticField(), FreeTrajectoryState::momentum(), FreeTrajectoryState::parameters(), FreeTrajectoryState::position(), and PV3DBase< T, PVType, FrameType >::z().

                                                                                                    {
  TrackCharge chargeA = sta.charge();
  TrackCharge chargeB = stb.charge();
  GlobalVector momentumA = sta.momentum();
  GlobalVector momentumB = stb.momentum();
  GlobalPoint positionA = sta.position();
  GlobalPoint positionB = stb.position();
  paramA = sta.parameters();
  paramB = stb.parameters();
  // compute magnetic field ONCE
  bz = sta.parameters().magneticField().inTesla(positionA).z() * 2.99792458e-3;

  return compute(chargeA, momentumA, positionA, chargeB, momentumB, positionB);
}

circleParameters()

void ClosestApproachInRPhi::circleParameters ( const TrackCharge &  charge, const GlobalVector &  momemtum, const GlobalPoint &  position, double &  xc, double &  yc, double &  r, double  bz  )

staticprivate

temporary code, to be replaced by call to curvature() when bug is fixed.

end of temporary code

Definition at line 169 of file ClosestApproachInRPhi.cc.

References funct::abs(), ALCARECOTkAlJpsiMuMu_cff::charge, position, PV3DBase< T, PVType, FrameType >::transverse(), PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

                                                        {
  // compute radius of circle
  //   double bz = MagneticField::inInverseGeV(position).z();

  // signed_r directed towards circle center, along F_Lorentz = q*v X B
  double qob = charge / bz;
  double signed_r = qob * momentum.transverse();
  r = abs(signed_r);
  // compute centre of circle
  // double phi = momentum.phi();
  // xc = signed_r*sin(phi) + position.x();
  // yc = -signed_r*cos(phi) + position.y();
  xc = position.x() + qob * momentum.y();
  yc = position.y() - qob * momentum.x();
}

clone()

ClosestApproachInRPhi* ClosestApproachInRPhi::clone ( void  ) const

inlineoverridevirtual

Clone method

Implements ClosestApproachOnHelices.

Definition at line 57 of file ClosestApproachInRPhi.h.

References ClosestApproachInRPhi().

{ return new ClosestApproachInRPhi(*this); }

compute()

bool ClosestApproachInRPhi::compute ( const TrackCharge &  chargeA, const GlobalVector &  momentumA, const GlobalPoint &  positionA, const TrackCharge &  chargeB, const GlobalVector &  momentumB, const GlobalPoint &  positionB  )

private

Definition at line 62 of file ClosestApproachInRPhi.cc.

References funct::abs(), and RemoveAddSevLevel::flag.

                                                                  {
  // centres and radii of track circles
  double xca, yca, ra;
  circleParameters(chargeA, momentumA, positionA, xca, yca, ra, bz);
  double xcb, ycb, rb;
  circleParameters(chargeB, momentumB, positionB, xcb, ycb, rb, bz);

  // points of closest approach in transverse plane
  double xg1, yg1, xg2, yg2;
  int flag = transverseCoord(xca, yca, ra, xcb, ycb, rb, xg1, yg1, xg2, yg2);
  if (flag == 0) {
    status_ = false;
    return false;
  }

  double xga, yga, zga, xgb, ygb, zgb;

  if (flag == 1) {
    // two crossing points on each track in transverse plane
    // select point for which z-coordinates on the 2 tracks are the closest
    double za1 = zCoord(momentumA, positionA, ra, xca, yca, xg1, yg1);
    double zb1 = zCoord(momentumB, positionB, rb, xcb, ycb, xg1, yg1);
    double za2 = zCoord(momentumA, positionA, ra, xca, yca, xg2, yg2);
    double zb2 = zCoord(momentumB, positionB, rb, xcb, ycb, xg2, yg2);

    if (abs(zb1 - za1) < abs(zb2 - za2)) {
      xga = xg1;
      yga = yg1;
      zga = za1;
      zgb = zb1;
    } else {
      xga = xg2;
      yga = yg2;
      zga = za2;
      zgb = zb2;
    }
    xgb = xga;
    ygb = yga;
  } else {
    // one point of closest approach on each track in transverse plane
    xga = xg1;
    yga = yg1;
    zga = zCoord(momentumA, positionA, ra, xca, yca, xga, yga);
    xgb = xg2;
    ygb = yg2;
    zgb = zCoord(momentumB, positionB, rb, xcb, ycb, xgb, ygb);
  }

  posA = GlobalPoint(xga, yga, zga);
  posB = GlobalPoint(xgb, ygb, zgb);
  status_ = true;
  return true;
}

crossingPoint()

GlobalPoint ClosestApproachInRPhi::crossingPoint ( ) const

overridevirtual

arithmetic mean of the two points of closest approach

Implements ClosestApproachOnHelices.

Definition at line 46 of file ClosestApproachInRPhi.cc.

References Exception.

Referenced by V0Fitter::fitAll().

                                                       {
  if (!status_)
    throw cms::Exception(
        "TrackingTools/PatternTools",
        "ClosestApproachInRPhi::could not compute track crossing. Check status before calling this method!");
  return GlobalPoint(0.5 * (posA.basicVector() + posB.basicVector()));
}

distance()

float ClosestApproachInRPhi::distance ( ) const

overridevirtual

distance between the two points of closest approach in 3D

Implements ClosestApproachOnHelices.

Definition at line 54 of file ClosestApproachInRPhi.cc.

References Exception.

Referenced by BPHMonitor::analyze(), HLTMuonDimuonL3Filter::applyDiMuonSelection(), V0Fitter::fitAll(), HLTDiMuonGlbTrkFilter::hltFilter(), HLTMuonTrackMassFilter::hltFilter(), HLTMuonTrimuonL3Filter::hltFilter(), and Onia2MuMuPAT::produce().

                                            {
  if (!status_)
    throw cms::Exception(
        "TrackingTools/PatternTools",
        "ClosestApproachInRPhi::could not compute track crossing. Check status before calling this method!");
  return (posB - posA).mag();
}

newTrajectory()

GlobalTrajectoryParameters ClosestApproachInRPhi::newTrajectory ( const GlobalPoint &  newpt, const GlobalTrajectoryParameters &  oldpar, double  bz  )

staticprivate

Definition at line 131 of file ClosestApproachInRPhi.cc.

References GlobalTrajectoryParameters::charge(), GlobalTrajectoryParameters::magneticField(), GlobalTrajectoryParameters::momentum(), GlobalTrajectoryParameters::position(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                           {
  // First we need the centers of the circles.
  double qob = oldgtp.charge() / bz;
  double xc = oldgtp.position().x() + qob * oldgtp.momentum().y();
  double yc = oldgtp.position().y() - qob * oldgtp.momentum().x();

  // and of course....
  double npx = (newpt.y() - yc) * (bz / oldgtp.charge());
  double npy = (xc - newpt.x()) * (bz / oldgtp.charge());

  /*
   * old code: slow and wrong
   *
  // now we do a translation, move the center of circle to (0,0,0).
  double dx1 = oldgtp.position().x() - xc;
  double dy1 = oldgtp.position().y() - yc;
  double dx2 = newpt.x() - xc;
  double dy2 = newpt.y() - yc;
 
  // now for the angles:
  double cosphi = ( dx1 * dx2 + dy1 * dy2 ) / 
    ( sqrt ( dx1 * dx1 + dy1 * dy1 ) * sqrt ( dx2 * dx2 + dy2 * dy2 ));
  double sinphi = - oldgtp.charge() * sqrt ( 1 - cosphi * cosphi );
  
  // Finally, the new momenta:
  double px = cosphi * oldgtp.momentum().x() - sinphi * oldgtp.momentum().y();
  double py = sinphi * oldgtp.momentum().x() + cosphi * oldgtp.momentum().y();
  
  std::cout << px-npx << " " << py-npy << ", " << oldgtp.charge() << std::endl;
  */

  GlobalVector vta(npx, npy, oldgtp.momentum().z());
  GlobalTrajectoryParameters gta(newpt, vta, oldgtp.charge(), &(oldgtp.magneticField()));
  return gta;
}

points()

pair< GlobalPoint, GlobalPoint > ClosestApproachInRPhi::points ( ) const

overridevirtual

Returns the two PCA on the trajectories.

Implements ClosestApproachOnHelices.

Definition at line 38 of file ClosestApproachInRPhi.cc.

References Exception.

                                                                   {
  if (!status_)
    throw cms::Exception(
        "TrackingTools/PatternTools",
        "ClosestApproachInRPhi::could not compute track crossing. Check status before calling this method!");
  return pair<GlobalPoint, GlobalPoint>(posA, posB);
}

status()

bool ClosestApproachInRPhi::status ( void  ) const

inlineoverridevirtual

Implements ClosestApproachOnHelices.

Definition at line 37 of file ClosestApproachInRPhi.h.

References status_.

Referenced by HLTMuonDimuonL3Filter::applyDiMuonSelection(), V0Fitter::fitAll(), HLTDiMuonGlbTrkFilter::hltFilter(), HLTMuonTrackMassFilter::hltFilter(), HLTMuonTrimuonL3Filter::hltFilter(), and Onia2MuMuPAT::produce().

{ return status_; }

trajectoryParameters()

pair< GlobalTrajectoryParameters, GlobalTrajectoryParameters > ClosestApproachInRPhi::trajectoryParameters

(

)

const

Returns not only the points, but the full GlobalTrajectoryParemeters at the points of closest approach

Definition at line 121 of file ClosestApproachInRPhi.cc.

References Exception, and runTheMatrix::ret.

                                                                                                               {
  if (!status_)
    throw cms::Exception(
        "TrackingTools/PatternTools",
        "ClosestApproachInRPhi::could not compute track crossing. Check status before calling this method!");
  pair<GlobalTrajectoryParameters, GlobalTrajectoryParameters> ret(newTrajectory(posA, paramA, bz),
                                                                   newTrajectory(posB, paramB, bz));
  return ret;
}

transverseCoord()

int ClosestApproachInRPhi::transverseCoord ( double  cxa, double  cya, double  ra, double  cxb, double  cyb, double  rb, double &  xg1, double &  yg1, double &  xg2, double &  yg2  )

staticprivate

Definition at line 197 of file ClosestApproachInRPhi.cc.

References funct::abs(), RemoveAddSevLevel::flag, Validation_hcalonly_cfi::sign, mathSSE::sqrt(), findQualityFiles::v, testProducerWithPsetDescEmpty_cfi::y1, and testProducerWithPsetDescEmpty_cfi::y2.

                                                        {
  int flag = 0;
  double x1, y1, x2, y2;

  // new reference frame with origin in (cxa, cya) and x-axis
  // directed from (cxa, cya) to (cxb, cyb)

  double d_ab = sqrt((cxb - cxa) * (cxb - cxa) + (cyb - cya) * (cyb - cya));
  if (d_ab == 0) {  // concentric circles
    return 0;
  }
  // elements of rotation matrix
  double u = (cxb - cxa) / d_ab;
  double v = (cyb - cya) / d_ab;

  // conditions for circle intersection
  if (d_ab <= ra + rb && d_ab >= abs(rb - ra)) {
    // circles cross each other
    flag = 1;

    // triangle (ra, rb, d_ab)
    double cosphi = (ra * ra - rb * rb + d_ab * d_ab) / (2 * ra * d_ab);
    double sinphi2 = 1. - cosphi * cosphi;
    if (sinphi2 < 0.) {
      sinphi2 = 0.;
      cosphi = 1.;
    }

    // intersection points in new frame
    double sinphi = sqrt(sinphi2);
    x1 = ra * cosphi;
    y1 = ra * sinphi;
    x2 = x1;
    y2 = -y1;
  } else if (d_ab > ra + rb) {
    // circles are external to each other
    flag = 2;

    // points of closest approach in new frame
    // are on line between 2 centers
    x1 = ra;
    y1 = 0;
    x2 = d_ab - rb;
    y2 = 0;
  } else if (d_ab < abs(rb - ra)) {
    // circles are inside each other
    flag = 2;

    // points of closest approach in new frame are on line between 2 centers
    // choose 2 closest points
    double sign = 1.;
    if (ra <= rb)
      sign = -1.;
    x1 = sign * ra;
    y1 = 0;
    x2 = d_ab + sign * rb;
    y2 = 0;
  } else {
    return 0;
  }

  // intersection points in global frame, transverse plane
  xg1 = u * x1 - v * y1 + cxa;
  yg1 = v * x1 + u * y1 + cya;
  xg2 = u * x2 - v * y2 + cxa;
  yg2 = v * x2 + u * y2 + cya;

  return flag;
}

zCoord()

double ClosestApproachInRPhi::zCoord ( const GlobalVector &  mom, const GlobalPoint &  pos, double  r, double  xc, double  yc, double  xg, double  yg  )

staticprivate

Definition at line 276 of file ClosestApproachInRPhi.cc.

References funct::abs(), l1tSlwPFPuppiJets_cfi::cosPhi, PVValHelper::dz, multPhiCorr_741_25nsDY_cfi::px, multPhiCorr_741_25nsDY_cfi::py, mathSSE::sqrt(), PV3DBase< T, PVType, FrameType >::transverse(), x, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                                                           {
  // starting point
  double x = pos.x();
  double y = pos.y();
  double z = pos.z();

  double px = mom.x();
  double py = mom.y();
  double pz = mom.z();

  // rotation angle phi from starting point to crossing point (absolute value)
  // -- compute sin(phi/2) if phi smaller than pi/4,
  // -- cos(phi) if phi larger than pi/4
  double phi = 0.;
  double sinHalfPhi = sqrt((x - xg) * (x - xg) + (y - yg) * (y - yg)) / (2 * r);
  if (sinHalfPhi < 0.383) {  // sin(pi/8)
    phi = 2 * asin(sinHalfPhi);
  } else {
    double cosPhi = ((x - xc) * (xg - xc) + (y - yc) * (yg - yc)) / (r * r);
    if (std::abs(cosPhi) > 1)
      cosPhi = (cosPhi > 0 ? 1 : -1);
    phi = abs(acos(cosPhi));
  }
  // -- sign of phi
  double signPhi = ((x - xc) * (yg - yc) - (xg - xc) * (y - yc) > 0) ? 1. : -1.;

  // sign of track angular momentum
  // if rotation is along angular momentum, delta z is along pz
  double signOmega = ((x - xc) * py - (y - yc) * px > 0) ? 1. : -1.;

  // delta z
  // -- |dz| = |cos(theta) * path along helix|
  //         = |cos(theta) * arc length along circle / sin(theta)|
  double dz = signPhi * signOmega * (pz / mom.transverse()) * phi * r;

  return z + dz;
}

Friends And Related Function Documentation

test::ClosestApproachInRPhi_t::test

int test::ClosestApproachInRPhi_t::test ( )

friend

Member Data Documentation

bz

double ClosestApproachInRPhi::bz

private

Definition at line 114 of file ClosestApproachInRPhi.h.

paramA

GlobalTrajectoryParameters ClosestApproachInRPhi::paramA

private

Definition at line 113 of file ClosestApproachInRPhi.h.

paramB

GlobalTrajectoryParameters ClosestApproachInRPhi::paramB

private

Definition at line 113 of file ClosestApproachInRPhi.h.

posA

GlobalPoint ClosestApproachInRPhi::posA

private

Definition at line 112 of file ClosestApproachInRPhi.h.

posB

GlobalPoint ClosestApproachInRPhi::posB

private

Definition at line 112 of file ClosestApproachInRPhi.h.

status_

bool ClosestApproachInRPhi::status_

private

Definition at line 115 of file ClosestApproachInRPhi.h.

Referenced by ClosestApproachInRPhi(), and status().