#include <ThirdHitPredictionFromCircle.h>

Public Types
using	Scalar = ThirdHitPredictionFromCircle::Scalar

using	Vector2D = ThirdHitPredictionFromCircle::Vector2D

Public Member Functions
	HelixRZ ()

	HelixRZ (const ThirdHitPredictionFromCircle *icircle, double iz1, double z2, double curv)

Scalar	rAtZ (Scalar z) const

Scalar	zAtR (Scalar r) const

Static Public Member Functions
static double	maxCurvature (const ThirdHitPredictionFromCircle *circle, double z1, double z2, double z3)

Private Attributes
Vector2D	center

const ThirdHitPredictionFromCircle *	circle

Scalar	curvature

Scalar	dzdu

Scalar	radius

Scalar	seg

Scalar	z1

Detailed Description

Definition at line 30 of file ThirdHitPredictionFromCircle.h.

Member Typedef Documentation

◆ Scalar

using ThirdHitPredictionFromCircle::HelixRZ::Scalar = ThirdHitPredictionFromCircle::Scalar

Definition at line 33 of file ThirdHitPredictionFromCircle.h.

◆ Vector2D

using ThirdHitPredictionFromCircle::HelixRZ::Vector2D = ThirdHitPredictionFromCircle::Vector2D

Definition at line 32 of file ThirdHitPredictionFromCircle.h.

Constructor & Destructor Documentation

◆ HelixRZ() [1/2]

ThirdHitPredictionFromCircle::HelixRZ::HelixRZ ( )

inline

Definition at line 37 of file ThirdHitPredictionFromCircle.h.

37 : circle(nullptr) {}

ThirdHitPredictionFromCircle::HelixRZ::circle

const ThirdHitPredictionFromCircle * circle

Definition: ThirdHitPredictionFromCircle.h:46

◆ HelixRZ() [2/2]

ThirdHitPredictionFromCircle::HelixRZ::HelixRZ	(	const ThirdHitPredictionFromCircle *	icircle,
		double	iz1,
		double	z2,
		double	curv
	)

Definition at line 208 of file ThirdHitPredictionFromCircle.cc.

References funct::abs(), ThirdHitPredictionFromCircle::axis, center, ThirdHitPredictionFromCircle::center, circle, ThirdHitPredictionFromCircle::delta, ThirdHitPredictionFromCircle::delta2, dzdu, radius, seg, FWPFMaths::sgn(), z1, and testProducerWithPsetDescEmpty_cfi::z2.

     : circle(icircle), curvature(curv), radius(1. / curv), z1(iz1) {
   Scalar orthog = sgn(curv) * clamped_sqrt(radius * radius - circle->delta2);
   center = circle->center + orthog * circle->axis;
 
   Scalar absCurv = std::abs(curv);
   seg = circle->delta;
   seg = arc(absCurv, seg);
   dzdu = (z2 - z1) / seg;
 }

Member Function Documentation

◆ maxCurvature()

double ThirdHitPredictionFromCircle::HelixRZ::maxCurvature	(	const ThirdHitPredictionFromCircle *	circle,
		double	z1,
		double	z2,
		double	z3
	)

static

Definition at line 222 of file ThirdHitPredictionFromCircle.cc.

References ThirdHitPredictionFromCircle::delta, M_PI, funct::sin(), UNLIKELY, and testProducerWithPsetDescEmpty_cfi::z2.

Referenced by PixelTripletLargeTipGenerator::hitTriplets().

                                                                       {
   constexpr double maxAngle = M_PI;
   double halfAngle = (0.5 * maxAngle) * (z2 - z1) / (z3 - z1);
   if (UNLIKELY(halfAngle <= 0.0))
     return 0.0;
 
   return std::sin(halfAngle) / circle->delta;
 }

◆ rAtZ()

ThirdHitPredictionFromCircle::HelixRZ::Scalar ThirdHitPredictionFromCircle::HelixRZ::rAtZ ( Scalar z ) const

Definition at line 262 of file ThirdHitPredictionFromCircle.cc.

References funct::abs(), HltBtagPostValidation_cff::c, ThirdHitPredictionFromCircle::center, ThirdHitPredictionFromCircle::curvature(), MillePedeFileConverter_cfg::e, qcdUeDQM_cfi::lip, M_PI, mag2(), SiStripPI::max, AlCaHLTBitMon_ParallelJobs::p, ThirdHitPredictionFromCircle::phi(), RefreshWebPage::rel, alignCSCRings::s, funct::sqr(), mathSSE::sqrt(), qcdUeDQM_cfi::tip, UNLIKELY, Basic2DVector< T >::x(), Basic2DVector< T >::y(), and z.

                                                                                                   {
   if (UNLIKELY(std::abs(dzdu) < 1.0e-5))
     return 99999.0;
 
   if (UNLIKELY(std::abs(curvature) < 1.0e-5)) {
     Scalar tip = circle->axis * circle->p1;
     Scalar lip = circle->axis.y() * circle->p1.x() - circle->axis.x() * circle->p1.y();
     return std::sqrt(sqr(tip) + sqr(lip + (z - z1) / dzdu));
   }
 
   // we won't go below that (see comment below)
   Scalar minR2 = (2. * circle->center - circle->p1).mag2();
 
   float phi = curvature * (z - z1) / dzdu;
 
   if (UNLIKELY(std::abs(phi) > 2. * M_PI)) {
     // with a helix we can get problems here - this is used to get the limits
     // however, if phi gets large, we get into the regions where we loop back
     // to smaller r's.  The question is - do we care about these tracks?
     // The answer is probably no:  Too much pain, and the rest of the
     // tracking won't handle looping tracks anyway.
     // So, what we do here is to return nothing smaller than the radius
     // than any of the two hits, i.e. the second hit, which is presumably
     // outside of the 1st hit.
 
     return std::sqrt(minR2);
   }
 
   Vector2D rel = circle->p1 - center;
 
   float c;
   float s;
   vdt::fast_sincosf(phi, s, c);
 
   Vector2D p(center.x() + c * rel.x() - s * rel.y(), center.y() + s * rel.x() + c * rel.y());
 
   return std::sqrt(std::max(minR2, p.mag2()));
 }

◆ zAtR()

ThirdHitPredictionFromCircle::HelixRZ::Scalar ThirdHitPredictionFromCircle::HelixRZ::zAtR ( Scalar r ) const

Definition at line 234 of file ThirdHitPredictionFromCircle.cc.

References funct::abs(), b, b2, ThirdHitPredictionFromCircle::center, ThirdHitPredictionFromCircle::curvature(), MillePedeFileConverter_cfg::e, qcdUeDQM_cfi::lip, Basic2DVector< T >::mag2(), alignCSCRings::r, CosmicsPD_Skims::radius, funct::sqr(), mathSSE::sqrt(), qcdUeDQM_cfi::tip, testProducerWithPsetDescEmpty_cfi::u1, MetAnalyzer::u2, and UNLIKELY.

                                                                                                   {
   if (UNLIKELY(std::abs(curvature) < 1.0e-5)) {
     Scalar tip = circle->axis * circle->p1;
     Scalar lip = circle->axis.y() * circle->p1.x() - circle->axis.x() * circle->p1.y();
     return z1 + (std::sqrt(sqr(r) - sqr(tip)) - lip) * dzdu;
   }
 
   Scalar radius2 = sqr(radius);
 
   Scalar b2 = center.mag2();
   Scalar b = std::sqrt(b2);
 
   Scalar cos1 = 0.5 * curvature * (radius2 + b2 - sqr(r)) / b;
   Scalar cos2 = 0.5 * curvature * (radius2 + b2 - circle->p1.mag2()) / b;
 
   Scalar phi1 = clamped_acos(cos1);
   Scalar phi2 = clamped_acos(cos2);
 
   // more plausbility checks needed...
   // the two circles can have two possible intersections
   Scalar u1 = std::abs((phi1 - phi2) * radius);
   Scalar u2 = std::abs((phi1 + phi2) * radius);
 
   return z1 + ((u1 >= seg && u1 < u2) ? u1 : u2) * dzdu;
 }