#include <TwoTrackMinimumDistanceHelixHelix.h>

Public Member Functions
bool	calculate (const GlobalTrajectoryParameters &, const GlobalTrajectoryParameters &, const float qual=.001)

double	firstAngle () const

std::pair< double, double >	pathLength () const

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

double	secondAngle () const

	TwoTrackMinimumDistanceHelixHelix ()

	~TwoTrackMinimumDistanceHelixHelix ()

Private Member Functions
void	finalPoints ()

bool	oneIteration (double &, double &)

bool	updateCoeffs (const GlobalPoint &, const GlobalPoint &)

Private Attributes
double	pathG

double	pathH

GlobalPoint	pointG

GlobalPoint	pointH

bool	pointsUpdated

double	thea

double	theb

double	thec1

double	thec2

double	thecospG

double	thecospG0

double	thecospH

double	thecospH0

double	thed1

double	thed2

double	thee1

double	thee2

const GlobalTrajectoryParameters *	theG

double	theg

const GlobalTrajectoryParameters *	theH

double	theh

int	themaxiter

double	themaxjump

double	thepG

double	thepG0

double	thepH

double	thepH0

double	thesingjacI

double	thesinpG

double	thesinpG0

double	thesinpH

double	thesinpH0

double	thetanlambdaG

double	thetanlambdaH

Detailed Description

This is a helper class for TwoTrackMinimumDistance. No user should need direct access to this class. It actually implements a Newton-Kantorowitsch method for finding the minimum distance between two tracks.

Definition at line 18 of file TwoTrackMinimumDistanceHelixHelix.h.

Constructor & Destructor Documentation

◆ TwoTrackMinimumDistanceHelixHelix()

TwoTrackMinimumDistanceHelixHelix::TwoTrackMinimumDistanceHelixHelix ( )

Definition at line 10 of file TwoTrackMinimumDistanceHelixHelix.cc.

11 : theH(nullptr), theG(nullptr), pointsUpdated(false), themaxjump(20), thesingjacI(1. / 0.1), themaxiter(4) {}

◆ ~TwoTrackMinimumDistanceHelixHelix()

TwoTrackMinimumDistanceHelixHelix::~TwoTrackMinimumDistanceHelixHelix ( )

Definition at line 13 of file TwoTrackMinimumDistanceHelixHelix.cc.

13 {}

Member Function Documentation

◆ calculate()

bool TwoTrackMinimumDistanceHelixHelix::calculate	(	const GlobalTrajectoryParameters &	G,
		const GlobalTrajectoryParameters &	H,
		const float	qual = `.001`
	)

Definition at line 112 of file TwoTrackMinimumDistanceHelixHelix.cc.

                                                                     {
   pointsUpdated = false;
   theG = &G;
   theH = &H;
   bool retval = false;
  
   if (updateCoeffs(theG->position(), theH->position())) {
     finalPoints();
     return true;
   }
  
   thepG = thepG0;
   thepH = thepH0;
  
   int counter = 0;
   double pH = 0;
   double pG = 0;
   do {
     retval = oneIteration(pG, pH);
     if (edm::isNotFinite(pG) || edm::isNotFinite(pH))
       retval = true;
     if (counter++ > themaxiter)
       retval = true;
   } while ((!retval) && (fabs(pG) > qual || fabs(pH) > qual));
   if (fabs(theg * (thepG - thepG0)) > themaxjump)
     retval = true;
   if (fabs(theh * (thepH - thepH0)) > themaxjump)
     retval = true;
  
   finalPoints();
  
   return retval;
 }

References finalPoints(), callgraph::G, class-composition::H, edm::isNotFinite(), oneIteration(), pointsUpdated, GlobalTrajectoryParameters::position(), theG, theg, theH, theh, themaxiter, themaxjump, thepG, thepG0, thepH, thepH0, and updateCoeffs().

◆ finalPoints()

void TwoTrackMinimumDistanceHelixHelix::finalPoints ( )

private

Definition at line 148 of file TwoTrackMinimumDistanceHelixHelix.cc.

                                                     {
   if (pointsUpdated)
     return;
   GlobalVector tmpG(sin(thepG) - thesinpG0, -cos(thepG) + thecospG0, thetanlambdaG * (thepG - thepG0));
   pointG = theG->position() + theg * tmpG;
   pathG = (thepG - thepG0) * (theg * sqrt(1 + thetanlambdaG * thetanlambdaG));
  
   GlobalVector tmpH(sin(thepH) - thesinpH0, -cos(thepH) + thecospH0, thetanlambdaH * (thepH - thepH0));
   pointH = theH->position() + theh * tmpH;
   pathH = (thepH - thepH0) * (theh * sqrt(1 + thetanlambdaH * thetanlambdaH));
  
   pointsUpdated = true;
 }

References funct::cos(), pathG, pathH, pointG, pointH, pointsUpdated, GlobalTrajectoryParameters::position(), funct::sin(), mathSSE::sqrt(), thecospG0, thecospH0, theG, theg, theH, theh, thepG, thepG0, thepH, thepH0, thesinpG0, thesinpH0, thetanlambdaG, and thetanlambdaH.

Referenced by calculate().

◆ firstAngle()

double TwoTrackMinimumDistanceHelixHelix::firstAngle ( ) const

inline

Definition at line 31 of file TwoTrackMinimumDistanceHelixHelix.h.

31 { return thepG; }

References thepG.

◆ oneIteration()

bool TwoTrackMinimumDistanceHelixHelix::oneIteration	(	double &	dH,
		double &	dG
	)

private

Definition at line 69 of file TwoTrackMinimumDistanceHelixHelix.cc.

                                                                            {
   thesinpH = sin(thepH);
   thecospH = cos(thepH);
   thesinpG = sin(thepG);
   thecospG = cos(thepG);
  
   const double A11 = theh * (-thesinpH * (thea - theg * thesinpG) + thecospH * (theb + theg * thecospG) + thec1);
   if (A11 < 0) {
     return true;
   };
   const double A22 = -theg * (-thesinpG * (thea + theh * thesinpH) + thecospG * (theb - theh * thecospH) + thec2);
   if (A22 < 0) {
     return true;
   };
   const double A12 = theh * (-theg * thecospG * thecospH - theg * thesinpH * thesinpG + thed1);
   const double A21 = -theg * (theh * thecospG * thecospH + theh * thesinpH * thesinpG + thed2);
   const double detaI = 1. / (A11 * A22 - A12 * A21);
   const double z1 = theh * (thecospH * (thea - theg * thesinpG) + thesinpH * (theb + theg * thecospG) + thec1 * thepH +
                             thed1 * thepG + thee1);
   const double z2 = -theg * (thecospG * (thea + theh * thesinpH) + thesinpG * (theb - theh * thecospH) + thec2 * thepG +
                              thed2 * thepH + thee2);
  
   dH = (z1 * A22 - z2 * A12) * detaI;
   dG = (z2 * A11 - z1 * A21) * detaI;
   if (fabs(detaI) > thesingjacI) {
     return true;
   };
  
   thepH -= dH;
   thepG -= dG;
   return false;
 }

References funct::cos(), funct::sin(), thea, theb, thec1, thec2, thecospG, thecospH, thed1, thed2, thee1, thee2, theg, theh, thepG, thepH, thesingjacI, thesinpG, thesinpH, and testProducerWithPsetDescEmpty_cfi::z2.

Referenced by calculate().

◆ pathLength()

std::pair<double, double> TwoTrackMinimumDistanceHelixHelix::pathLength ( ) const

inline

Definition at line 29 of file TwoTrackMinimumDistanceHelixHelix.h.

29 { return std::pair<double, double>(pathG, pathH); }

References pathG, and pathH.

◆ points()

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

inline

Definition at line 27 of file TwoTrackMinimumDistanceHelixHelix.h.

27 { return std::pair<GlobalPoint, GlobalPoint>(pointG, pointH); }

References pointG, and pointH.

◆ secondAngle()

double TwoTrackMinimumDistanceHelixHelix::secondAngle ( ) const

inline

Definition at line 32 of file TwoTrackMinimumDistanceHelixHelix.h.

32 { return thepH; }

References thepH.

◆ updateCoeffs()

bool TwoTrackMinimumDistanceHelixHelix::updateCoeffs	(	const GlobalPoint &	gpH,
		const GlobalPoint &	gpG
	)

private

Definition at line 15 of file TwoTrackMinimumDistanceHelixHelix.cc.

                                                                                                    {
   const double Bc2kH = theH->magneticField().inInverseGeV(gpH).z();
   const double Bc2kG = theG->magneticField().inInverseGeV(gpG).z();
   const double Ht = theH->momentum().perp();
   const double Gt = theG->momentum().perp();
   //  thelambdaH=asin ( theH->momentum().z() / Hn );
  
   if (Ht == 0. || Gt == 0.) {
     edm::LogWarning("TwoTrackMinimumDistanceHelixHelix") << "transverse momentum of input trajectory is zero.";
     return true;
   };
  
   if (theH->charge() == 0. || theG->charge() == 0.) {
     edm::LogWarning("TwoTrackMinimumDistanceHelixHelix") << "charge of input track is zero.";
     return true;
   };
  
   if (Bc2kG == 0.) {
     edm::LogWarning("TwoTrackMinimumDistanceHelixHelix") << "magnetic field at point " << gpG << " is zero.";
     return true;
   };
  
   if (Bc2kH == 0.) {
     edm::LogWarning("TwoTrackMinimumDistanceHelixHelix") << "magnetic field at point " << gpH << " is zero.";
     return true;
   };
  
   theh = Ht / (theH->charge() * Bc2kH);
   thesinpH0 = -theH->momentum().y() / (Ht);
   thecospH0 = -theH->momentum().x() / (Ht);
   thetanlambdaH = -theH->momentum().z() / (Ht);
   thepH0 = atan2(thesinpH0, thecospH0);
  
   // thelambdaG=asin ( theG->momentum().z()/( Gn ) );
  
   theg = Gt / (theG->charge() * Bc2kG);
   thesinpG0 = -theG->momentum().y() / (Gt);
   thecospG0 = -theG->momentum().x() / (Gt);
   thetanlambdaG = -theG->momentum().z() / (Gt);
   thepG0 = atan2(thesinpG0, thecospG0);
  
   thea = theH->position().x() - theG->position().x() + theg * thesinpG0 - theh * thesinpH0;
   theb = theH->position().y() - theG->position().y() - theg * thecospG0 + theh * thecospH0;
   thec1 = theh * thetanlambdaH * thetanlambdaH;
   thec2 = -theg * thetanlambdaG * thetanlambdaG;
   thed1 = -theg * thetanlambdaG * thetanlambdaH;
   thed2 = theh * thetanlambdaG * thetanlambdaH;
   thee1 = thetanlambdaH *
           (theH->position().z() - theG->position().z() - theh * thepH0 * thetanlambdaH + theg * thepG0 * thetanlambdaG);
   thee2 = thetanlambdaG *
           (theH->position().z() - theG->position().z() - theh * thepH0 * thetanlambdaH + theg * thepG0 * thetanlambdaG);
   return false;
 }