#include <ClosestApproachInRPhi.h>

Inheritance diagram for ClosestApproachInRPhi:

Public Member Functions
virtual bool	calculate (const TrajectoryStateOnSurface &sta, const TrajectoryStateOnSurface &stb)

virtual bool	calculate (const FreeTrajectoryState &sta, const FreeTrajectoryState &stb)

virtual ClosestApproachInRPhi *	clone () const

	ClosestApproachInRPhi ()

virtual GlobalPoint	crossingPoint () const

virtual float	distance () const

virtual std::pair< GlobalPoint, GlobalPoint >	points () const

virtual bool	status () const

std::pair< GlobalTrajectoryParameters, GlobalTrajectoryParameters >	trajectoryParameters () const

	~ClosestApproachInRPhi ()

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 25 of file ClosestApproachInRPhi.h.

Constructor & Destructor Documentation

ClosestApproachInRPhi::ClosestApproachInRPhi ( )

inline

Definition at line 30 of file ClosestApproachInRPhi.h.

30 {status_ = false;}

ClosestApproachInRPhi::status_

bool status_

Definition: ClosestApproachInRPhi.h:109

ClosestApproachInRPhi::~ClosestApproachInRPhi ( )

inline

Definition at line 31 of file ClosestApproachInRPhi.h.

31 {}

Member Function Documentation

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

virtual

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 NuclearVertexBuilder::closestApproach(), BPHPlusMinusVertex::computeApp(), V0Fitter::fitAll(), HLTDiMuonGlbTrkFilter::hltFilter(), HLTMuonTrackMassFilter::hltFilter(), HLTMuonDimuonL3Filter::hltFilter(), HLTMuonTrimuonL3Filter::hltFilter(), ConversionProducer::preselectTrackPair(), 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);
 
 }

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

virtual

Implements ClosestApproachOnHelices.

Definition at line 26 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);
 
 }

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 174 of file ClosestApproachInRPhi.cc.

References funct::abs(), 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();
 
 }

virtual ClosestApproachInRPhi* ClosestApproachInRPhi::clone ( void ) const

inlinevirtual

Clone method

Implements ClosestApproachOnHelices.

Definition at line 60 of file ClosestApproachInRPhi.h.

References ALCARECOTkAlJpsiMuMu_cff::charge, bookConverter::compute(), dso_internal, position, and alignCSCRings::r.

                                                 {
     return new ClosestApproachInRPhi(* this);
   }

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 69 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;
 }

GlobalPoint ClosestApproachInRPhi::crossingPoint ( ) const

virtual

arithmetic mean of the two points of closest approach

Implements ClosestApproachOnHelices.

Definition at line 52 of file ClosestApproachInRPhi.cc.

References Exception.

Referenced by NuclearVertexBuilder::FillVertexWithCrossingPoint(), V0Fitter::fitAll(), NuclearVertexBuilder::isGoodSecondaryTrack(), and ConversionProducer::preselectTrackPair().

 {
   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()));
              
 }

float ClosestApproachInRPhi::distance ( ) const

virtual

distance between the two points of closest approach in 3D

Implements ClosestApproachOnHelices.

Definition at line 61 of file ClosestApproachInRPhi.cc.

References Exception.

Referenced by NuclearInteractionEDProducer::findAdditionalSecondaryTracks(), V0Fitter::fitAll(), HLTDiMuonGlbTrkFilter::hltFilter(), HLTMuonTrackMassFilter::hltFilter(), HLTMuonDimuonL3Filter::hltFilter(), HLTMuonTrimuonL3Filter::hltFilter(), NuclearVertexBuilder::isGoodSecondaryTrack(), 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();
 }

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

staticprivate

Definition at line 136 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;
 }

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

virtual

Returns the two PCA on the trajectories.

Implements ClosestApproachOnHelices.

Definition at line 43 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);
 }

virtual bool ClosestApproachInRPhi::status ( void ) const

inlinevirtual

Implements ClosestApproachOnHelices.

Definition at line 39 of file ClosestApproachInRPhi.h.

References SoftLeptonByDistance_cfi::distance.

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

39 {return status_;}

ClosestApproachInRPhi::status_

bool status_

Definition: ClosestApproachInRPhi.h:109

pair< GlobalTrajectoryParameters, GlobalTrajectoryParameters > ClosestApproachInRPhi::trajectoryParameters ( ) const

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

Definition at line 125 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!");
   pair <GlobalTrajectoryParameters, GlobalTrajectoryParameters> 
     ret ( newTrajectory( posA, paramA, bz),
           newTrajectory( posB, paramB, bz) );
   return ret;
 }

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 205 of file ClosestApproachInRPhi.cc.

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

 {
   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;
 }

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

staticprivate

Definition at line 272 of file ClosestApproachInRPhi.cc.

References funct::abs(), allConversions_cfi::dz, alignCSCRings::r, mathSSE::sqrt(), PV3DBase< T, PVType, FrameType >::transverse(), PV3DBase< T, PVType, FrameType >::x(), 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

int test::ClosestApproachInRPhi_t::test ( )

friend

Member Data Documentation

double ClosestApproachInRPhi::bz

private

Definition at line 108 of file ClosestApproachInRPhi.h.

GlobalTrajectoryParameters ClosestApproachInRPhi::paramA

private

Definition at line 107 of file ClosestApproachInRPhi.h.

GlobalTrajectoryParameters ClosestApproachInRPhi::paramB

private

Definition at line 107 of file ClosestApproachInRPhi.h.

GlobalPoint ClosestApproachInRPhi::posA

private

Definition at line 106 of file ClosestApproachInRPhi.h.

GlobalPoint ClosestApproachInRPhi::posB

private

Definition at line 106 of file ClosestApproachInRPhi.h.

bool ClosestApproachInRPhi::status_

private

Definition at line 109 of file ClosestApproachInRPhi.h.

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation