#include <ThirdHitPredictionFromCircle.h>

Classes
class	HelixRZ

Public Types
typedef PixelRecoRange< float >	Range

using	Scalar = double

typedef Basic2DVector< Scalar >	Vector2D

typedef Basic2DVector< float >	VectorF2D

Public Member Functions
float	angle (float curvature, float radius) const

Range	curvature (double transverseIP) const

double	curvature (const Vector2D &thirdPoint) const

Range	operator() (Range curvature, float radius) const

float	phi (float curvature, float radius) const

	ThirdHitPredictionFromCircle (const GlobalPoint &P1, const GlobalPoint &P2, float tolerance)

double	transverseIP (const Vector2D &thirdPoint) const

Private Member Functions
Scalar	invCenterOnAxis (const Vector2D &thirdPoint) const

Private Attributes
Vector2D	axis

Vector2D	center

Scalar	delta

Scalar	delta2

Vector2D	p1

float	theTolerance

Friends
class	HelixRZ

Detailed Description

Definition at line 10 of file ThirdHitPredictionFromCircle.h.

Member Typedef Documentation

◆ Range

typedef PixelRecoRange<float> ThirdHitPredictionFromCircle::Range

Definition at line 13 of file ThirdHitPredictionFromCircle.h.

◆ Scalar

using ThirdHitPredictionFromCircle::Scalar = double

Definition at line 12 of file ThirdHitPredictionFromCircle.h.

◆ Vector2D

typedef Basic2DVector<Scalar> ThirdHitPredictionFromCircle::Vector2D

Definition at line 14 of file ThirdHitPredictionFromCircle.h.

◆ VectorF2D

typedef Basic2DVector<float> ThirdHitPredictionFromCircle::VectorF2D

Definition at line 15 of file ThirdHitPredictionFromCircle.h.

Constructor & Destructor Documentation

◆ ThirdHitPredictionFromCircle()

ThirdHitPredictionFromCircle::ThirdHitPredictionFromCircle	(	const GlobalPoint &	P1,
		const GlobalPoint &	P2,
		float	tolerance
	)

Definition at line 49 of file ThirdHitPredictionFromCircle.cc.

References axis, center, delta, delta2, change_name::diff, p1, SiStripOfflineCRack_cfg::p2, mathSSE::sqrt(), PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

     : p1(P1.x(), P1.y()), theTolerance(tolerance) {
   Vector2D p2(P2.x(), P2.y());
   Vector2D diff = 0.5 * (p2 - p1);
   delta2 = diff.mag2();
   delta = std::sqrt(delta2);
   axis = Vector2D(-diff.y(), diff.x()) / delta;
   center = p1 + diff;
 }

Member Function Documentation

◆ angle()

float ThirdHitPredictionFromCircle::angle	(	float	curvature,
		float	radius
	)		const

Definition at line 79 of file ThirdHitPredictionFromCircle.cc.

References funct::abs(), axis, center, funct::cos(), curvature(), delta2, MillePedeFileConverter_cfg::e, f, Basic2DVector< T >::mag2(), CosmicsPD_Skims::radius, FWPFMaths::sgn(), funct::sin(), funct::sqr(), and UNLIKELY.

Referenced by MatchedHitRZCorrectionFromBending::tibMatchedHitZFixup().

                                                                              {
   if (UNLIKELY(std::abs(curvature) < float(1.0e-5))) {
     float sin = (center * axis) / radius;
     return sin / clamped_sqrt(1 - sqr(sin));
   } else {
     float radius2 = sqr(1.0f / curvature);
     float orthog = clamped_sqrt(radius2 - delta2);
     Basic2DVector<float> lcenter = Basic2DVector<float>(center) - sgn(curvature) * orthog * Basic2DVector<float>(axis);
 
     float cos = (radius2 + sqr(radius) - lcenter.mag2()) * curvature / (2 * radius);
     return -cos / clamped_sqrt(1.f - sqr(cos));
   }
 }

◆ curvature() [1/2]

ThirdHitPredictionFromCircle::Range ThirdHitPredictionFromCircle::curvature ( double transverseIP ) const

Definition at line 102 of file ThirdHitPredictionFromCircle.cc.

References funct::abs(), axis, center, delta, delta2, MillePedeFileConverter_cfg::e, qcdUeDQM_cfi::lip, FWPFMaths::sgn(), funct::sqr(), mathSSE::sqrt(), edm::swap(), qcdUeDQM_cfi::tip, createJobs::tmp, transverseIP(), testProducerWithPsetDescEmpty_cfi::u1, MetAnalyzer::u2, UNLIKELY, Basic2DVector< T >::x(), and Basic2DVector< T >::y().

Referenced by angle(), CAHitTripletGenerator::hitNtuplets(), MultiHitGeneratorFromChi2::hitSets(), operator()(), phi(), ThirdHitPredictionFromCircle::HelixRZ::rAtZ(), and ThirdHitPredictionFromCircle::HelixRZ::zAtR().

                                                                                                    {
   // this is a mess.  Use a CAS and lots of drawings to verify...
 
   transverseIP = std::abs(transverseIP);
   double transverseIP2 = sqr(transverseIP);
   double tip = axis * center;
   double tip2 = sqr(tip);
   double lip = axis.x() * center.y() - axis.y() * center.x();
   double lip2 = sqr(lip);
 
   double origin = std::sqrt(tip2 + lip2);
   double tmp1 = lip2 + tip2 - transverseIP2;
   double tmp2 = 2. * (tip - transverseIP) * (tip + transverseIP);
   double tmp3 = 2. * delta * origin;
   double tmp4 = tmp1 + delta2;
   double tmp5 = 2. * delta * lip;
 
   // I am probably being overly careful here with border cases
   // but you never know what crap you might get fed
   // VI fixed for finiteMath
 
   double u1 = 0, u2 = 0;
   constexpr double SMALL = 1.0e-23;
   constexpr double LARGE = 1.0e23;
 
   if (UNLIKELY(tmp4 - tmp5 < 1.0e-15)) {
     u1 = -SMALL;
     u2 = +SMALL;
   } else {
     if (UNLIKELY(std::abs(tmp2) < 1.0e-15)) {
       // the denominator is zero
       // this means that one of the tracks will be straight
       // and the other can be computed from the limit of the equation
       double tmp = lip2 - delta2;
       u1 = LARGE;
       u2 = (sqr(0.5 * tmp) - delta2 * tip2) / (tmp * tip);
       if (tip < 0)
         std::swap(u1, u2);
     } else {
       double tmp6 = (tmp4 - tmp5) * (tmp4 + tmp5);
       if (UNLIKELY(tmp6 < 1.0e-15)) {
         u1 = -SMALL;
         u2 = +SMALL;
       } else {
         double tmp7 = tmp6 > 0 ? (transverseIP * std::sqrt(tmp6) / tmp2) : 0.;
         double tmp8 = tip * (tmp1 - delta2) / tmp2;
         // the two quadratic solutions
         u1 = tmp8 + tmp7;
         u2 = tmp8 - tmp7;
       }
     }
 
     if (tmp4 <= std::abs(tmp3)) {
       if ((tmp3 < 0) == (tip < 0))
         u2 = +SMALL;
       else
         u1 = -SMALL;
     }
   }
 
   return Range(sgn(u1) / std::sqrt(sqr(u1) + delta2), sgn(u2) / std::sqrt(sqr(u2) + delta2));
 }

◆ curvature() [2/2]

double ThirdHitPredictionFromCircle::curvature ( const Vector2D & thirdPoint ) const

Definition at line 174 of file ThirdHitPredictionFromCircle.cc.

References delta2, invCenterOnAxis(), SiStripOfflineCRack_cfg::p2, FWPFMaths::sgn(), funct::sqr(), and mathSSE::sqrt().

                                                                        {
   double invDist = invCenterOnAxis(p2);
   double invDist2 = sqr(invDist);
   double curv = std::sqrt(invDist2 / (1. + invDist2 * delta2));
   return sgn(invDist) * curv;
 }

◆ invCenterOnAxis()

ThirdHitPredictionFromCircle::Scalar ThirdHitPredictionFromCircle::invCenterOnAxis ( const Vector2D & thirdPoint ) const

private

Definition at line 165 of file ThirdHitPredictionFromCircle.cc.

References a, axis, b, center, change_name::diff, Basic2DVector< T >::mag(), p1, SiStripOfflineCRack_cfg::p2, Basic2DVector< T >::x(), and Basic2DVector< T >::y().

Referenced by curvature(), and transverseIP().

                                                                                                          {
   Vector2D del = p2 - p1;
   Vector2D axis2 = Vector2D(-del.y(), del.x()) / del.mag();
   Vector2D diff = p1 + 0.5f * del - center;
   Scalar a = diff.y() * axis2.x() - diff.x() * axis2.y();
   Scalar b = axis.y() * axis2.x() - axis.x() * axis2.y();
   return b / a;
 }

◆ operator()()

ThirdHitPredictionFromCircle::Range ThirdHitPredictionFromCircle::operator()	(	Range	curvature,
		float	radius
	)		const

Definition at line 93 of file ThirdHitPredictionFromCircle.cc.

References curvature(), normalizedPhi(), phi(), proxim(), CosmicsPD_Skims::radius, edm::swap(), and theTolerance.

                                                                                                               {
   float phi1 = normalizedPhi(phi(curvature.second, radius));
   float phi2 = proxim(phi(curvature.first, radius), phi1);
   if (phi2 < phi1)
     std::swap(phi2, phi1);
 
   return Range(phi1 * radius - theTolerance, phi2 * radius + theTolerance);
 }

◆ phi()

float ThirdHitPredictionFromCircle::phi	(	float	curvature,
		float	radius
	)		const

Definition at line 61 of file ThirdHitPredictionFromCircle.cc.

References funct::abs(), axis, center, funct::cos(), curvature(), delta2, MillePedeFileConverter_cfg::e, f, Basic2DVector< T >::mag2(), Basic2DVector< T >::phi(), diffTwoXMLs::r2, CosmicsPD_Skims::radius, FWPFMaths::sgn(), Validation_hcalonly_cfi::sign, funct::sqr(), mathSSE::sqrt(), and UNLIKELY.

Referenced by Particle.Particle::__str__(), datamodel.Object::DeltaR(), MultiHitGeneratorFromChi2::hitSets(), operator()(), datamodel.Object::p4(), ntupleDataFormat.Track::phiPull(), and ThirdHitPredictionFromCircle::HelixRZ::rAtZ().

                                                                            {
   float phi;
   if (UNLIKELY(std::abs(curvature) < float(1.0e-5))) {
     float cos = (center * axis) / radius;
     phi = axis.phi() - clamped_acos(cos);
   } else {
     float sign = sgn(curvature);
     float radius2 = sqr(1.0f / curvature);
     float orthog = clamped_sqrt(radius2 - delta2);
     Basic2DVector<float> lcenter = Basic2DVector<float>(center) - sign * orthog * Basic2DVector<float>(axis);
     float rc2 = lcenter.mag2();
     float r2 = sqr(radius);
     float cos = (rc2 + r2 - radius2) / std::sqrt(4.f * rc2 * r2);
     phi = f_phi(lcenter) + sign * clamped_acos(cos);
   }
   return phi;  // not normalized
 }

◆ transverseIP()

double ThirdHitPredictionFromCircle::transverseIP ( const Vector2D & thirdPoint ) const

Definition at line 181 of file ThirdHitPredictionFromCircle.cc.

References funct::abs(), axis, center, delta2, MillePedeFileConverter_cfg::e, invCenterOnAxis(), mag(), SiStripOfflineCRack_cfg::p2, CosmicsPD_Skims::radius, funct::sqr(), mathSSE::sqrt(), and UNLIKELY.

Referenced by curvature().

                                                                           {
   double invDist = invCenterOnAxis(p2);
   if (UNLIKELY(std::abs(invDist) < 1.0e-5))
     return std::abs(p2 * axis);
   else {
     double dist = 1.0 / invDist;
     double radius = std::sqrt(sqr(dist) + delta2);
     return std::abs((center + axis * dist).mag() - radius);
   }
 }